Tm90aXppZSBxdW90aWRpYW5lIHwgbCdBcml6b25hIGlzdGl0dWlyw6AgcmlzZXJ2ZSBkaSBCVEMsIFN0cmF0ZWd5IGF1bWVudGEgYW5jb3JhIHVuYSB2b2x0YSBpbCBzdW8gcGF0cmltb25pbyBkaSAxLDQyIG1pbGlhcmRpIGRpIGRvbGxhcmkgaW4gQlRD

2025-04-29, 03:55

<p><img src="https://gimg2.gateimg.com/image/article/17458986624.27.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20lETF20BTC20ha20registrato20un20forte20afflusso20di2058020milioni20di20dollari20e20lArizona20stabilir20una20riserva20di20Bitcoin16725"><a name="Riepilogo giornaliero delle criptovalute: l’ETF BTC ha registrato un forte afflusso di 580 milioni di dollari e l’Arizona stabilirà una riserva di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: l’ETF BTC ha registrato un forte afflusso di 580 milioni di dollari e l’Arizona stabilirà una riserva di Bitcoin</h2><p>Secondo i dati di Farside Investors, un totale di $580 milioni è affluito negli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF spot ieri. Tra questi, BlackRock IBIT ha ricevuto $960 milioni, che è stato il secondo importo di acquisto più grande in un solo giorno da quando BlackRock IBIT è andato online. Inoltre, ARKB ha avuto un deflusso di $226 milioni. Da febbraio di quest’anno, l’ETF BTC ha mostrato un trend unilaterale di deflusso netto, che si è invertito dalla scorsa settimana, e il sentiment del mercato finanziario è ottimista.</p>
<p>Ieri, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> l’ingresso spot ETF è stato di $56.6 milioni, di cui l’ingresso di BlackRock ETHA è stato di $60 milioni e l’uscita di Bitwise ETHW è stata di $3.4 milioni. Anche la tendenza unilaterale al deflusso netto degli ETF ETH da febbraio di quest’anno si è invertita dalla scorsa settimana, ma l’importo dei fondi entrati negli ETF ETH è ancora relativamente piccolo rispetto a BTC.</p>
<p><strong>L’Arizona <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Reserve Act approvato dal Congresso, diventando il primo stato degli Stati Uniti a istituire riserve di Bitcoin</strong></p>
<p>Secondo TheBlock, due atti finali della Riserva Strategica <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> dell’Arizona hanno superato il voto finale alla Camera dei Rappresentanti e attenderanno la firma della governatrice democratica Katie Hobbs. L’Arizona diventerà il primo stato degli Stati Uniti a richiedere che i fondi pubblici siano investiti in Bitcoin.</p>
<p>Tra questi, il SB 1373 propone di istituire un fondo di riserva strategica per asset digitali gestito dal tesoriere dello stato, con fonti di finanziamento che includono asset sequestrati e stanziamenti legislativi. Fino al 10% di ciascun anno fiscale può essere investito in asset digitali come Bitcoin, e possono essere concessi prestiti senza aumentare il rischio. Il SB 1025 consente alle finanze statali e ai sistemi pensionistici di investire fino al 10% dei fondi disponibili in valute virtuali, con un focus su Bitcoin. Il riassunto del disegno di legge recita: “Questo disegno di legge rappresenta una pratica emergente dei governi statali che incorporano le criptovalute nella gestione finanziaria pubblica, riflettendo l’accettazione crescente nel mainstream degli asset digitali.”</p>
<p>I co-sponsor del disegno di legge sono entrambi Repubblicani: il senatore Wendy Rogers e il rappresentante Jeff Weninger. Attualmente, diversi stati, tra cui Iowa, Missouri e Texas, stanno considerando se istituire riserve strategiche di Bitcoin e a livello federale, Trump ha firmato un ordine esecutivo a marzo che richiede l’istituzione di una riserva strategica di Bitcoin e un inventario di asset digitali.</p>
<p><strong>100 giorni dopo che Trump è stato giurato, il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ha perso $537 miliardi di capitalizzazione di mercato</strong></p>
<p>Secondo i dati di CoinGecko, oggi è il centesimo giorno da quando Trump è stato giurato, e la capitalizzazione di mercato totale delle criptovalute è rimbalzata a $3.084 trilioni. Il 20 gennaio, quando ha ufficialmente assunto l’incarico per il suo secondo mandato, la capitalizzazione di mercato totale delle criptovalute era di $3.621 trilioni e il mercato ha fatto evaporare $537 miliardi di capitalizzazione di mercato.</p>
<p>Secondo le informazioni di mercato di Gate.io, Bitcoin ha raggiunto un massimo storico di $109,588 il giorno della sua inaugurazione e attualmente è scambiato a $95,230, un ritracciamento di più del 13%; <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha raggiunto $3,453 il giorno della sua inaugurazione e attualmente è scambiato a $1,801, un ritracciamento di più del 47.8%.</p>
<p><strong>Fornitura di Bitcoin CEX scesa al minimo di sette anni, ora a 2.492 milioni</strong></p>
<p>Secondo i dati di CryptoQuant, l’offerta di Bitcoin sulle piattaforme di trading è scesa al minimo di sette anni, arrivando a 2,488 milioni di BTC lo scorso venerdì. Le riserve della piattaforma di trading sono attualmente 2,492 milioni di BTC, con un aumento di circa 40,000 BTC durante il fine settimana, ma il livello è comunque il più basso dal ottobre 2018.</p>
<p>CoinShares ha riportato un afflusso di $3.2 miliardi nei fondi Bitcoin nella settimana che è terminata il 28 aprile. La combinazione di bilanci di scambio in diminuzione e flussi in aumento suggerisce che sta arrivando una nuova fase di accumulo. Gli investitori al dettaglio sembrano aver giocato un ruolo più grande nel rally della scorsa settimana rispetto alle settimane precedenti. Questo è ancora più evidente nel ‘rapporto tra balene sulle piattaforme di trading’, che è sceso da 0.512 il 17 aprile a 0.36 il 27 aprile.</p>
<h2 id="h2-Tendenze20di20mercato20VIRTUAL20ha20guidato20la20traccia20dellagente20AI20in20aumento20Strategy20ha20aumentato20le20sue20partecipazioni20di2014220miliardi862423"><a name="Tendenze di mercato: VIRTUAL ha guidato la traccia dell’agente AI in aumento, Strategy ha aumentato le sue partecipazioni di $1.42 miliardi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: VIRTUAL ha guidato la traccia dell’agente AI in aumento, Strategy ha aumentato le sue partecipazioni di $1.42 miliardi</h2><h3 id="h3-Punti20Caldi20del20Mercato705713"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>VIRTUAL è aumentato del 40% in giornata, portando i token concettuali dell’agente AI come PIPPIN, , AI16Z e GOAT a salire. I token stellari nella traccia dell’agente AI sono diminuiti di oltre l’80% rispetto all’inizio di quest’anno. Sono aumentati rapidamente dal minimo del prezzo, ma sono ancora lontani dal massimo storico. Da un lato, mostra che l’agente AI è ancora una delle tracce a cui i fondi di mercato prestano maggiore attenzione. D’altra parte, mostra anche che il sentiment complessivo di mercato non è buono e potrebbero esserci nuovi progetti di agente AI.</p>
<p>LAYER è continuato a salire durante il giorno e il suo prezzo ha superato una volta la soglia dei $3. Dall lancio a febbraio di quest’anno, LAYER ha mostrato essenzialmente un trend unilaterale al rialzo, con un aumento cumulativo di oltre il 400%, diventando uno dei migliori altcoin degli ultimi mesi. LAYER è il token di <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Protocollo di restaking della catena Solayer e il design funzionale di Solayer è molto simile al protocollo di restaking di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> EigenLayer.</p>
<h3 id="h3-Criptovalute20mainstream752606"><a name="Criptovalute mainstream" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovalute mainstream</h3><p>BTC è fluttuato in un range ristretto durante la giornata. Sul fronte delle notizie, Gate ha speso $1.42 miliardi la settimana scorsa per aumentare le sue disponibilità di 15.355 BTC. Sul lato del finanziamento, BlackRock IBIT ha ricevuto nuovamente un grande afflusso di $960 milioni, e il sentiment del capitale era ottimistico. L’indice AHR999 di oggi è stato 0.93, indicando che il prezzo attuale è ancora adatto per gli investitori a lungo termine per investire regolarmente;</p>
<p>ETH segue i rialzi e le ribassi del mercato, e le fluttuazioni si sono notevolmente ridotte nella scorsa settimana. Il tasso di cambio ETH/BTC non ha ancora mostrato un trend di inversione, e le prospettive di mercato sono cautamente ottimistiche;</p>
<p>Le altcoin sono generalmente aumentate, l’agente AI ha guidato nuovamente il mercato e il sentiment del mercato si è riscaldato.</p>
<h2 id="h2-Macro20news20Azioni20statunitensi20miste20gli20analisti20avvertono20che20il20mercato20rimane20fragile117712"><a name="Macro news: Azioni statunitensi miste, gli analisti avvertono che il mercato rimane fragile" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro news: Azioni statunitensi miste, gli analisti avvertono che il mercato rimane fragile</h2><p>I tre principali indici azionari statunitensi sono saliti e scesi, con l’S&amp;P 500 in rialzo dello 0,06% a 5.528,75 punti, il Dow Jones in rialzo dello 0,28% a 40.227,59 punti e il Nasdaq in calo dello 0,10% a 17.366,13 punti. Per quanto riguarda i bond statunitensi, il rendimento del Treasury decennale di riferimento era del 4,23% e il rendimento del Treasury a 2 anni, che è il più sensibile al tasso di politica della Fed, era del 3,67%.</p>
<p>L’S&amp;P 500 ha brevemente superato il livello di resistenza di 5.500 impostato da Morgan Stanley, guidato da <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">ottimismo</a> riguardo alla potenziale riduzione dei dazi tra Cina e Stati Uniti e a un cambiamento di politica della Federal Reserve. Tuttavia, gli analisti hanno avvertito che la rottura era ancora fragile. Morgan Stanley ha sottolineato: ‘Una rottura sostenuta della gamma 5.600-5.650 richiede progressi sostanziali su quattro catalizzatori: riduzioni sostanziali dei dazi, una Fed accomodante, tassi di interesse a lungo termine al di sotto del 4% senza segnali di recessione e una revisione al rialzo delle aspettative sugli utili.’</p>
<p>Questa settimana vedrà anche il rilascio dei dati sul prodotto interno lordo del primo trimestre degli Stati Uniti e del rapporto sugli stipendi non agricoli di venerdì per aprile. In generale, Wall Street dovrebbe avere una visione più chiara dell’impatto dei dazi sulle imprese e sui consumatori entro la fine della settimana.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Icing T.</strong>, Ricercatore di Gate.io<br><div>Translator: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. Sarà consentito il ripostaggio dell'articolo a condizione che venga fatto riferimento a 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>