Tm90aXppZSBxdW90aWRpYW5lIHwgR2xpIEVURiBCVEMgaGFubm8gcmVnaXN0cmF0byB1biBncmFuZGUgZGVmbHVzc28sIG1hIGlsIEJUQyDDqCBzYWxpdG8gaW52ZWNlIGRpIHNjZW5kZXJlLCBHVCBoYSBzdXBlcmF0byBpICQxNyw3IGUgaGEgc3RhYmlsaXRvIHVuIG51b3ZvIHJlY29yZCBzdG9yaWNv

2025-01-03, 03:53

<p><img src="https://gimg2.gateimg.com/image/article/173587613512.06.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20luscita20in20un20solo20giorno20di20BlackRock20IBIT20ha20raggiunto20un20nuovo20record20dal20suo20lancio20Xterio20ha20annunciato20la20sua20economia20dei20token235460"><a name="Riepilogo giornaliero delle criptovalute: l’uscita in un solo giorno di BlackRock IBIT ha raggiunto un nuovo record dal suo lancio, Xterio ha annunciato la sua economia dei token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: l’uscita in un solo giorno di BlackRock IBIT ha raggiunto un nuovo record dal suo lancio, Xterio ha annunciato la sua economia dei token</h2><p>Secondo i dati degli investitori di Farside, ieri gli Stati Uniti. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’ETF spot ha avuto un grande deflusso netto di $240 milioni, di cui BlackRock IBIT ha avuto un deflusso di $330 milioni, il più grande deflusso in un solo giorno da quando BlackRock IBIT è stato lanciato online; Fidelity FBTC ha avuto un deflusso netto di $36,2 milioni e Bitwise BITB ha avuto un deflusso di $48,3 milioni.</p>
<p>Ieri, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’ETF sullo spot ha avuto un deflusso netto di $77,5 milioni, di cui Bitwise ETHW ha avuto un deflusso di $56,1 milioni e Grayscale ETHE ha avuto un deflusso di $21,4 milioni. I dati di BlackRock IBIT non sono ancora stati aggiornati.</p>
<p><strong>Xterio ha annunciato l’economia del token XTER, con il 28% assegnato alla comunità</strong></p>
<p><a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> La piattaforma di gioco Xterio ha pubblicato un post sulla piattaforma X affermando che l’economia del token è stata annunciata e l’offerta totale di XTER è di 1 miliardo. La circolazione iniziale di XTER è di 112,5 milioni e il TGE si terrà l’8 gennaio. Tra di essi:</p>
<p>-28% per la comunità e 20 milioni di token saranno completamente sbloccati al TGE;</p>
<p>-26% per l’ecosistema e 20 milioni di token saranno completamente sbloccati al TGE;</p>
<p>-15% per gli investitori;</p>
<p>-12% per il team;</p>
<p>-9% per il marketing e 15 milioni di token saranno completamente sbloccati al TGE;</p>
<p>-4,25% per la cassaforte e il 5,75% dei token vengono utilizzati per fornire liquidità e scommettere quando TEG.</p>
<p><strong>Direttore delle ricerche di VanEck: la probabilità che gli ETF SOL vengano approvati negli Stati Uniti nel 2025 è “estremamente alta”</strong></p>
<p><a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Previsione criptata</a> La piattaforma Polymarket ha precedentemente affermato che la probabilità di un <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L’ETF quotato negli Stati Uniti nel 2025 è circa 77%.</p>
<p>Matthew Sigel, capo della ricerca presso VanEck, ha dichiarato che la previsione è stata “sottovalutata”. A giugno 2024, VanEck e la società rivale di gestione del patrimonio 21Shares hanno cercato il permesso dai regolatori statunitensi per quotare lo spot <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ETF. A novembre dello scorso anno, poco dopo che Trump ha vinto le elezioni presidenziali statunitensi, Matthew Sigel ha detto che la probabilità che gli Stati Uniti approvassero il SOL ETF nel 2025 era “estremamente alta”.</p>
<p><strong>Alcuni token di concetto di intelligenza artificiale sono tornati indietro e ELIZA è sceso del 31,3% in 24 ore</strong></p>
<p>Secondo le informazioni di mercato di Gate.io, oggi alcuni token legati al concetto di AI sono scesi sul mercato, tra cui:</p>
<ul>
<li>ELIZA è sceso del 31,3% nelle ultime 24 ore e ora ha una capitalizzazione di mercato di 112 milioni di dollari;</li></ul>
<p>-SPORE è sceso del 25,1% in 24 ore e la sua capitalizzazione di mercato è ora di $52,85 milioni;</p>
<p>-GAME (GAME by Virtuals) è diminuito del 21,8% in 24 ore, con una capitalizzazione di mercato di $299 milioni;</p>
<p>-LUNA (Luna di Virtuals) è sceso del 21% nelle ultime 24 ore e ora ha una capitalizzazione di mercato di $138 milioni.</p>
<h2 id="h2-Tendenze20di20mercato20GT20ha20raggiunto20un20nuovo20massimo20storico20i20token20concetto20dellagente20AI20in20tendenza20si20sono20ritirati444079"><a name="Tendenze di mercato: GT ha raggiunto un nuovo massimo storico, i token concetto dell’agente AI in tendenza si sono ritirati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: GT ha raggiunto un nuovo massimo storico, i token concetto dell’agente AI in tendenza si sono ritirati</h2><h3 id="h3-Punti20Caldi20del20Mercato820693"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>GT ha superato i $17,7, stabilendo un nuovo record; secondo il Dott. Han, il 2024 è l’anno di crescita più rapida per Gate.io in 11 anni. Gli utenti di Gate.io hanno superato i 20 milioni, raggiungendo una crescita del 50% degli utenti, una crescita del 100% del volume delle transazioni (raddoppiato), una crescita del 200% delle riserve (triplicate) e una crescita del 300% della capitalizzazione di mercato di GT (quadruplicata). Inoltre, le riserve della piattaforma Gate.io hanno superato i $10 miliardi, e GT ha raggiunto anche un nuovo record nel quarto trimestre con la crescita di tutta la piattaforma. La startup ha distribuito un totale di $33,49 milioni in ricompense di airdrop durante l’anno, e Yubibao ha portato $100 milioni di interessi agli utenti del servizio di gestione finanziaria.</p>
<p>Il token GameFi MAGIC è aumentato del 20% nella giornata. Le prestazioni di MAGIC in questa fase di mercato sono state significativamente inferiori rispetto a quelle dei token di traccia popolari e anche inferiori a quelle di BTC. MAGIC è aumentato perché Shaw, il fondatore di ai16z, era precedentemente un membro importante del progetto Magic, e i fondi surriscaldati di AI Agent hanno rivolto la loro attenzione ad altri obiettivi correlati nella traccia.</p>
<p>I token AI Agent più popolari come VIRTUAL e AIXBT sono tornati indietro e VIRTUAL non ha ancora stabilizzato la sua capitalizzazione di mercato di $5 miliardi. La traccia AI Agent è surriscaldata e il sentiment di mercato è estremamente fomo, indicando che il mercato potrebbe temporaneamente entrare in una fase di regolazione;</p>
<h3 id="h3-Monete20principali49952"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC è tornato sopra i $97.000. Gli ETF di BTC hanno registrato un piccolo flusso in entrata ieri. BTC è ancora rialzista nel medio e lungo termine.</p>
<p>ETH si sta avvicinando di nuovo alla soglia dei 3.500$, mostrando una performance relativamente forte.</p>
<p>Performance miste delle altcoins, con evidente rotazione del capitale di mercato. Le altcoins a grande capitalizzazione hanno poco spazio per la crescita, mentre i token a bassa capitalizzazione sulla catena hanno maggiori opportunità.</p>
<h2 id="h2-Notizie20macro20le20azioni20statunitensi20sono20in20generale20diminuite20i20bond20statunitensi20sono20aumentati20e20il20dollaro20statunitense2020notevolmente20apprezzato414374"><a name="Notizie macro: le azioni statunitensi sono in generale diminuite, i bond statunitensi sono aumentati e il dollaro statunitense è notevolmente apprezzato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie macro: le azioni statunitensi sono in generale diminuite, i bond statunitensi sono aumentati e il dollaro statunitense è notevolmente apprezzato</h2><p>I tre principali indici azionari statunitensi hanno chiuso collettivamente al ribasso, con l’S&amp;P 500 in calo dello 0,22% a 5.868,55 punti, il Dow Jones in calo dello 0,36% a 42.392,27 punti e il Nasdaq in calo dello 0,16% a 19.280,79 punti. Il rendimento del titolo di Stato a 10 anni di riferimento degli Stati Uniti era del 4,57%, mentre il rendimento del titolo di Stato a 2 anni, che è il più sensibile al tasso di politica della Fed, era del 4,25%.</p>
<p>Gli analisti di HSBC Global Research hanno affermato che il forte aumento dei rendimenti dei Treasury statunitensi e il successivo apprezzamento del dollaro USA sono stati gli sviluppi di mercato più importanti delle ultime settimane. Questi guadagni sono stati trainati da “un’altra serie di segnali inaspettatamente positivi dell’attività economica statunitense e segnali di un nuovo aumento dell’inflazione statunitense” che, insieme al taglio dei tassi della Federal Reserve di dicembre, hanno portato a un brusco aggiustamento delle aspettative sui tassi d’interesse statunitensi.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Ghiaccia</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. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>