Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWFya2V0IGNhcCBkaSBCTkIgQ2hhaW4gTVVCQVJBSyBzdXBlcmEgaSAkMjAwIG1pbGlvbmksIFBMVU1FIMOoIHNhbGl0byBkaSBvbHRyZSBpbCAyMCUgaW4gdW4gZ2lvcm5v

2025-03-18, 03:38

<p><img src="https://gimg2.gateimg.com/image/article/174226886712.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20WLFI20ha20incluso20SUI20e20ONDO20nelle20sue20riserve20strategiche20e20YZi20Labs20ha20annunciato20un20investimento20in20Plume20Network512465"><a name="Riepilogo giornaliero delle criptovalute: WLFI ha incluso SUI e ONDO nelle sue riserve strategiche e YZi Labs ha annunciato un investimento in Plume Network" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: WLFI ha incluso SUI e ONDO nelle sue riserve strategiche e YZi Labs ha annunciato un investimento in Plume Network</h2><p>Secondo i dati degli investitori di Farside, l’ afflusso netto totale degli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF ieri è stato di $274 milioni, di cui BlackRock IBIT ha ricevuto $42 milioni e Fidelity FBTC ha ricevuto $127 milioni. Si tratta del maggiore afflusso giornaliero di ETF dal 7 febbraio 2025.</p>
<p>Ieri, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF spot ha avuto un deflusso totale di $7,3 milioni, di cui Grayscale ETHE ha avuto un deflusso di $7,3 milioni, e i dati di BlackRock ETHA non sono ancora stati aggiornati. Il tasso di cambio ETH/BTC è attualmente a 0,023, che continua a essere vicino al minimo di quasi 4 anni.</p>
<p><strong>YZi Labs ha annunciato un investimento in Plume Network</strong></p>
<p>La scorsa notte, YZi Labs ha annunciato un investimento in Plume Network, con l’obiettivo di portare gli asset del mondo reale on-chain e avanzare in RWAfi. Plume sta costruendo un ambiente compatibile con l’EVM che non solo può introdurre diverse RWAs, ma anche connetterle a un ecosistema componibile RWAfi per conferire loro praticità.</p>
<p>Plume Network è il primo blockchain modulare RWAFi su misura per le RWAs. Semplifica il modo in cui gli asset del mondo reale sono on-chain incorporando la conformità e la tokenizzazione degli asset direttamente nello strato del protocollo. Mentre altri protocolli si concentrano principalmente sugli strumenti finanziari, l’architettura di Plume è progettata per ospitare una gamma più ampia di asset, tra cui oggetti da collezione, materie prime e persino feed di dati del mondo reale, aprendo nuove possibilità per la finanza decentralizzata (DeFi) e la partecipazione istituzionale.</p>
<p><strong>WLFI ha annunciato di aver incluso BTC, ETH, TRX, <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, SUI e ONDO nelle sue riserve strategiche di token</strong></p>
<p>Secondo le notizie ufficiali, il progetto criptato di Trump WLFI ha annunciato il completamento di una vendita di token per un totale di $550 milioni, con più di 85.000 partecipanti che hanno completato la certificazione KYC.</p>
<p>WLFI “Strategia Macro” alloca anche una varietà di asset digitali nel suo piano di riserva strategica, tra cui BTC, ETH, TRX, <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a>, SUI e token ONDO. “Macro Strategy” potrebbe essere utilizzata in parte per sostenere WLFI nel finanziare progetti innovativi, promuovere la crescita dell’ecosistema e creare nuove opportunità nel campo DeFi in rapida evoluzione.</p>
<p><strong>Lazard view: La Fed non è previsto abbassi i tassi di interesse fino al 2025</strong></p>
<p>Il capo stratega di mercato di Lazard Temple ha analizzato che a causa dei rischi legati all’inflazione, Lazard si aspetta ancora che la Federal Reserve non tagli i tassi di interesse nel 2025. Ha affermato che le opinioni di Lazard differiscono significativamente dal consenso di mercato e che in generale il mercato ritiene che potrebbero esserci tre tagli ai tassi di interesse quest’anno.</p>
<p>“La mia visione si discosta dalla visione consensuale perché mi aspetto che i dazi statunitensi si espandano in termini di portata e dimensioni, spingendo l’inflazione al rialzo entro il 2025”, ha detto Temple. Una riaccelerazione dell’inflazione non necessariamente porterebbe a un aumento dei tassi, ma le pressioni sui prezzi in aumento potrebbero impedire alla Fed di allentare la politica se la disoccupazione aumenta, ha detto.”</p>
<h2 id="h2-Tendenze20di20mercato20MUBARAK2020andato20online20e2020aumentato20di20pi20di205020volte20PLUME2020aumentato20del202020in20un20giorno842733"><a name="Tendenze di mercato: MUBARAK è andato online e è aumentato di più di 50 volte, PLUME è aumentato del 20% in un giorno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: MUBARAK è andato online e è aumentato di più di 50 volte, PLUME è aumentato del 20% in un giorno</h2><h3 id="h3-Punti20Caldi20del20Mercato138329"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> catena MUBARAK, CAKE, BNX, CHEEMS e altri token sono tutti aumentati, e la catena <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> è diventata la migliore catena pubblica in termini di rendimento nel progetto dell’ecosistema negli ultimi tempi; Mubarak significa benedizione in arabo, e il token MUBARAK dello stesso nome è un progetto meme della catena BNB. Dall lancio il 13 marzo, l’aumento massimo ha superato 50 volte. Durante questo periodo, MUBARAK ha anche ricevuto il supporto di ritweet da CZ; La capitalizzazione di mercato di MUBARAK ha raggiunto un massimo di $217 milioni, ed attualmente è di $190 milioni, classificandosi al 224º posto nell’intero mercato;</p>
<p>Il progetto concettuale RWA della rete Plume Network token PLUME è salito del 20% in giornata, con una capitalizzazione di mercato superiore a $350 milioni; PLUME ha annunciato ieri di aver ricevuto finanziamenti da un’importante istituzione finanziaria, e la notizia ha stimolato un aumento di PLUME; da quando PLUME è stata quotata in borsa alla fine di gennaio, il prezzo è stato oscillante nell’intervallo di $0.1-$0.15, e attualmente ha superato $0.18, il che potrebbe valere la pena di tenere d’occhio nel futuro mercato.</p>
<h3 id="h3-Criptovalute20mainstream285388"><a name="Criptovalute mainstream" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovalute mainstream</h3><p>BTC si trova in un piccolo intervallo di $82,500-$84,000. Il mercato potrebbe fluttuare di più in occasione della riunione sui tassi d’interesse della Federal Reserve di giovedì. L’indice AHR999 di oggi è 0.81, indicando che è adatto per gli investitori a lungo termine.</p>
<p>ETH ha visto meno volatilità nella scorsa settimana ed è rimasto intorno ai $1.900. Il tasso di cambio ETH/BTC è rimasto a un minimo quasi quadriennale.</p>
<p>Le altcoin hanno registrato guadagni e perdite misti, con solo i progetti sulla catena <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> che vedono un aumento generale.</p>
<h2 id="h2-Macro20News20I20tre20principali20indici20azionari20statunitensi20hanno20chiuso20in20rialzo20e20la20Federal20Reserve20non2020probabile20che20taglier20i20tassi20di20interesse20nella20prima20met20dellanno906224"><a name="Macro News: I tre principali indici azionari statunitensi hanno chiuso in rialzo, e la Federal Reserve non è probabile che taglierà i tassi di interesse nella prima metà dell’anno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: I tre principali indici azionari statunitensi hanno chiuso in rialzo, e la Federal Reserve non è probabile che taglierà i tassi di interesse nella prima metà dell’anno</h2><p>I tre principali indici azionari degli Stati Uniti hanno chiuso in rialzo, con lo S&amp;P 500 in aumento dello 0,64% a 5.675,12 punti, il Dow Jones in aumento dello 0,85% a 41.841,63 punti e il Nasdaq in aumento dello 0,31% a 17.808,66 punti. Il rendimento del benchmark del Tesoro decennale era del 4,31%, mentre il rendimento del Tesoro a 2 anni, il più sensibile al tasso di politica della Fed, era del 4,06%.</p>
<p>L’analisi di mercato mostra che i tre principali indici azionari statunitensi sono attualmente ipervenduti al livello più alto dal 2022, il sentiment di mercato e gli indicatori di posizione si sono notevolmente attenuati, e i fattori stagionali di fine marzo dovrebbero migliorare le revisioni degli utili e le performance dei prezzi delle azioni. Inoltre, il recente indebolimento del dollaro statunitense dovrebbe aiutare la stagione degli utili del primo trimestre e le previsioni di performance del secondo trimestre, che sono più vantaggiose rispetto al quarto trimestre del 2024. Se si applicano ancora i modelli storici, il calo dei tassi di interesse potrebbe aumentare la probabilità che i dati economici superino le aspettative.</p>
<p>Alcune persone credono che l’attuale inflazione negli Stati Uniti rimanga al di sopra del 3%, il che significa che la Fed non può tagliare i tassi di interesse in anticipo nella prima metà dell’anno, quindi i rendimenti dei titoli di Stato più bassi diventeranno un “stabilizzatore automatico” per la crescita economica. La curva dei rendimenti del Tesoro degli Stati Uniti continuerà ad appiattirsi fino a quando gli Stati Uniti aumenteranno significativamente il loro tetto del debito o la Fed sarà costretta a effettuare tagli massicci dei tassi di interesse.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Icing T.</strong>, Ricercatore Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>