Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGhhIGNvbnRpbnVhdG8gYSBmbHV0dHVhcmUsIEVURiBFVEggaGEgcmVnaXN0cmF0byBkZWZsdXNzaSBuZXR0aSBwZXIgMTMgZ2lvcm5pIGNvbnNlY3V0aXZp

2025-03-24, 03:39

<p><img src="https://gimg2.gateimg.com/image/article/174278747316.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20FMI20incluso20Bitcoin20negli20standard20statistici20economici20globali20e20SUI20OP20e20altri20token20verranno20sbloccati20in20grandi20quantit20questa20settimana969183"><a name="Crypto Daily Digest: FMI incluso Bitcoin negli standard statistici economici globali, e SUI, OP e altri token verranno sbloccati in grandi quantità questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: FMI incluso <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> negli standard statistici economici globali, e SUI, OP e altri token verranno sbloccati in grandi quantità questa settimana</h2><p>Secondo i dati degli investitori di Farside, U.S. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot hanno registrato un totale ingresso netto di 83,1 milioni di dollari lo scorso venerdì, di cui BlackRock IBIT ha registrato un ingresso di 105 milioni di dollari e WTree BTCW ha registrato un deflusso di 21,9 milioni di dollari.</p>
<p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli spot ETF hanno registrato un deflusso totale di $18,6 milioni lo scorso venerdì, di cui $11,9 milioni da BlackRock ETHA e $6,7 milioni da Grayscale ETH.</p>
<p><strong>SUI, OP, VENOM e altri token verranno sbloccati in grandi quantità questa settimana</strong></p>
<p>Secondo i dati sugli sblocchi dei token, questa settimana SUI, OP e VENOM avranno uno sblocco di token su larga scala, con un valore totale di oltre $100 milioni. Tra questi: Sui (SUI) sbloccherà 64,19 milioni di token alle 8:00 del 1 aprile, del valore di circa $148 milioni, pari al 2,03% della circolazione; <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> (OP) sbloccherà 31,34 milioni di token alle 8:00 del 31 marzo, del valore approssimativo di $27,09 milioni, corrispondente al 1,93% della circolazione; Venom (VENOM) sbloccherà 59,26 milioni di token alle 16:00 del 25 marzo, del valore approssimativo di $7,04 milioni, corrispondente al 2,9% della circolazione.</p>
<p><strong>Il Fondo Monetario Internazionale ha incluso <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e altri asset digitali negli standard globali delle statistiche economiche</strong></p>
<p>Nella nuova settima edizione del Manuale sulle partite correnti e sulla posizione internazionale degli investimenti (BPM7) appena pubblicato, il Fondo Monetario Internazionale (FMI) ha proposto linee guida dettagliate su come classificare e registrare asset crittografici come Bitcoin, stablecoin e piattaforme basate su token come <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Secondo il nuovo quadro normativo, gli asset digitali sono divisi in token fungibili e token non fungibili, e ulteriormente classificati in base alla presenza di passività associate. Bitcoin e altri token non supportati da passività sono considerati asset non produttivi non finanziari e sono classificati nel conto capitale.</p>
<p><strong>CEO di BlackRock: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> è previsto un aumento a $500,000 a $700,000</strong></p>
<p>Secondo Cointelegraph, il CEO di BlackRock Larry Fink ha dichiarato che ci si aspetta che il prezzo di Bitcoin raggiunga i $500,000 - $700,000.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20ha20continuato20a20oscillare20MUBARAK20ha20registrato20unattivit20attiva913195"><a name="Tendenze di mercato: BTC ha continuato a oscillare, MUBARAK ha registrato un’attività attiva" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC ha continuato a oscillare, MUBARAK ha registrato un’attività attiva</h2><h3 id="h3-Punti20Caldi20del20Mercato996299"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Alcuni giorni fa, Trump ha pubblicato su Truth Social, dicendo: “Amo $TRUMP, molto cool, grande squadra.” Influenzato da questa notizia, $TRUMP ha superato i $12 durante la sessione, con un aumento del 10% in 24 ore;</p>
<p>MUBARAK è rimbalzato del 50% durante il fine settimana, aiutando il <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Il sentimento della catena per riprendersi. Tuttavia, alcuni analisti hanno fatto notare che, sebbene l’entusiasmo per Mubarak abbia acceso il sentimento sulla catena <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a>, nelle attuali condizioni di mercato, la sostenibilità della frenesia potrebbe rimanere da testare se è guidata unicamente dalle emozioni di raccogliere e creare meme.</p>
<h3 id="h3-Monete20principali678175"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC ha continuato a fluttuare, raggiungendo una volta i $86,000, per poi scendere nella fascia dei $85,000. Dato che il pattern precedente di BTC è stato infranto, nonostante ci sia stato un rimbalzo a breve termine, dal punto di vista del pattern, non ha completamente invertito il trend al ribasso;</p>
<p>ETH è sceso sotto i $2.000 lo scorso venerdì e ancora non ha visto alcun segno di un movimento al rialzo. Gli ETF hanno registrato deflussi netti per 13 giorni consecutivi, il che suggerisce che potrebbe continuare a cadere in futuro;</p>
<p>Il mercato delle Altcoin ha un momento debole, con guadagni e perdite misti. I settori dell’IA e di PayFi hanno guidato i guadagni, ma nel complesso il mercato manca di una narrazione attraente.</p>
<h2 id="h2-Macro20News20Le20azioni20statunitensi20terminano20la20serie20di20perdite20di20420settimane20i20rischi20di20incertezza20di20mercato20sono20stati20rilasciati607424"><a name="Macro News: Le azioni statunitensi terminano la serie di perdite di 4 settimane, i rischi di incertezza di mercato sono stati rilasciati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: Le azioni statunitensi terminano la serie di perdite di 4 settimane, i rischi di incertezza di mercato sono stati rilasciati</h2><p>Venerdì scorso, i tre principali indici azionari statunitensi hanno generalmente chiuso in rialzo, con lo S&amp;P 500 e il Nasdaq che hanno messo fine a quattro settimane di calo consecutivo.</p>
<p>L’incertezza di mercato è attesa anche di dissiparsi ulteriormente poiché ci si aspetta che gli Stati Uniti annuncino dazi reciprocamente il 2 aprile e il mercato si aspetta generalmente che ciò possa includere nuove misure contro la Cina. Da quando è entrato in carica a gennaio, Trump ha imposto un dazio del 20% sui beni provenienti dalla Cina. Tuttavia, dato che gli Stati Uniti non vogliono vedere di nuovo l’inflazione aumentare, le prospettive per il commercio sino-americano sembrano ottimistiche.</p>
<p>Il capo stratega dei titoli a reddito fisso di Morgan Stanley, Vishwanath Tirupattur, ha dichiarato venerdì che la previsione di fine anno della banca per il rendimento del Tesoro decennale è del 4%, ma la pressione derivante dai dazi potrebbe spingerlo al ribasso. Dato che i rendimenti dei titoli del Tesoro degli Stati Uniti sono correlati positivamente con il punto basso del tasso di politica della Federal Reserve implicito dal mercato, attualmente il mercato tende a credere che con l’implementazione ufficiale dei dazi statunitensi il 2 aprile, il rendimento del Tesoro decennale statunitense tenderà a diminuire in futuro, guidato da fattori come i problemi di debito e deficit degli Stati Uniti, dati economici deboli, un aumento una tantum dell’inflazione dovuto ai dazi e il ritardo della Federal Reserve nella riduzione del bilancio.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Orisi T.</strong>, Ricercatore di 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 oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il repostaggio dell'articolo sarà permesso a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>