Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgZG9taW5hbnphIGRpIEJUQyDDqCBzY2VzYSBkZWxsJzEsNSUgbmVsbCdhcmNvIGRlbGxhIGdpb3JuYXRhLCBsJ3VzY2l0YSBkaSBjYXBpdGFsZSBoYSBzdGltb2xhdG8gaWwgbWVyY2F0byBkZWxsZSBhbHRjb2lu

2024-12-24, 03:44

<p><img src="https://gimg2.gateimg.com/image/article/173501179612.24.png" alt=""></p>
<h2 id="h2-Digest20giornaliero20delle20criptovalute20gli20ETF20su20BTC20hanno20registrato20significativi20deflussi20per20tre20giorni20consecutivi20con20una20probabilit20inferiore20al201020che20la20Fed20tagli20i20tassi20di20interesse20a20gennaio465297"><a name="Digest giornaliero delle criptovalute: gli ETF su BTC hanno registrato significativi deflussi per tre giorni consecutivi, con una probabilità inferiore al 10% che la Fed tagli i tassi di interesse a gennaio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digest giornaliero delle criptovalute: gli ETF su BTC hanno registrato significativi deflussi per tre giorni consecutivi, con una probabilità inferiore al 10% che la Fed tagli i tassi di interesse a gennaio</h2><p>Secondo i dati degli investitori di Farside, ieri è stato registrato un deflusso netto dagli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Lo spot ETF è stato di $258 milioni. Fidelity FBTC ha registrato una fuoriuscita netta di $146 milioni, Ark ARKB di $15,7 milioni e i dati di BlackRock IBIT non sono ancora stati aggiornati.</p>
<p>Ieri, l’afflusso netto di US <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’ETF spot era di $41,3 milioni. L’afflusso di Fidelity FETH è stato di $46,4 milioni, l’uscita di Grayscale ETHE è stata di $6,1 milioni e i dati di BlackRock ETHA non sono ancora stati aggiornati.</p>
<p><strong>Santiment: Quando gli investitori al dettaglio vendono per panico, le balene e gli investitori di grandi dimensioni che raccolgono a prezzi bassi provocheranno un rimbalzo dei prezzi</strong></p>
<p><a href="/price" rel="nofollow noopener noreferrer" target="_blank">Mercato delle criptovalute</a> La società di ricerca Santiment ha pubblicato sui social media che il mercato delle criptovalute si è ulteriormente ripreso questa settimana, causando panico tra gli investitori al dettaglio. In particolare, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> sono stati oggetto di una grande quantità di vendite di panico da parte di nuovi trader che sono appena entrati nel mercato negli ultimi 2-3 mesi.</p>
<p>Questi nuovi trader non hanno mai sperimentato un adeguamento moderato prima e si sentono in panico di fronte all’ambiente di mercato straniero sconosciuto. Da un punto di vista storico, quando gli investitori al dettaglio iniziano a vendere a causa del panico e delle emozioni, balene e grandi investitori di solito colgono l’occasione per comprare più monete con meno resistenza, scatenando così un rimbalzo dei prezzi. Questo rimbalzo potrebbe non verificarsi immediatamente, ma le condizioni di mercato si stanno muovendo nella giusta direzione.</p>
<p><strong>Skely ha lanciato l’esperimento di pre-vendita dell’agente AI aiPool, raccogliendo oltre $6 milioni di finanziamenti</strong></p>
<p>Skely ha lanciato un nuovo e radicale esperimento chiamato aiPool sull’autonomia degli agenti AI e sul meccanismo di pre-vendita, con l’obiettivo di rendere le pre-vendite gestite dall’IA più sicure, prevenendo che gli utenti vengano “raccolti come porri”, e rendendo l’intero processo più trasparente. Oltre 30.000 SOL, del valore superiore a 6 milioni di dollari, sono stati depositati nel suo indirizzo di pre-vendita.</p>
<p><strong>Osservazione della CME sulla Fed: la probabilità che la Fed riduca i tassi di interesse di 25 punti base a gennaio prossimo è dell’8,6%</strong></p>
<p>Secondo i dati di “FedWatch” della CME, la probabilità che la Federal Reserve riduca i tassi di interesse di 25 punti base a gennaio prossimo è dell’8,6%, mentre la probabilità che rimanga invariata è del 91,4%.</p>
<h2 id="h2-Tendenze20di20mercato20ZEN20ha20raddoppiato20il20suo20prezzo20in20tre20giorni20mentre20VIRTUAL2020aumentato20di20oltre20il2030655428"><a name="Tendenze di mercato: ZEN ha raddoppiato il suo prezzo in tre giorni, mentre VIRTUAL è aumentato di oltre il 30%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: ZEN ha raddoppiato il suo prezzo in tre giorni, mentre VIRTUAL è aumentato di oltre il 30%</h2><h3 id="h3-Punti20Caldi20del20Mercato812539"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>ZEN è aumentato del 30%, con una capitalizzazione di mercato di 600 milioni di dollari e un aumento mensile superiore al 150% da dicembre; Nel mezzo di questo mese, Grayscale ha annunciato il lancio del Fondo fiduciario ZEN, che consente agli investitori qualificati di investire in token ZEN senza acquistarli o gestirli direttamente. Attualmente, la dimensione del fondo fiduciario ha superato i 30 milioni di dollari;</p>
<p>I token del settore dell’IA come VIRTUAL, GOAT e AIXBT sono aumentati significativamente, con VIRTUAL in testa con un aumento intraday del 35%; VIRTUAL è un progetto di IA sulla catena Base, con una capitalizzazione di mercato circolante attuale di $3 miliardi, posizionandosi al 45° posto nell’intero mercato;</p>
<p>Il KOMA del settore dei meme continua a salire, con prezzi più di 50 volte più alti rispetto al lancio avvenuto a ottobre; KOMA è una moneta meme a tema cane su <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, con una capitalizzazione di mercato circolante attuale di $120 milioni.</p>
<h3 id="h3-Monete20principali212960"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC sta ancora negoziando lateralmente intorno ai $94.000, BTCD è sceso del 1,5% in un giorno e i fondi sono affluiti in Altcoins. Inoltre, gli ETF BTC continuano a … <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> I fondi stanno fluendo indietro all’avvicinarsi delle festività natalizie degli Stati Uniti.</p>
<p>ETH ha mostrato una performance relativamente forte, guadagnando supporto intorno a $3,400 e fungendo da barometro per il mercato delle Altcoin;</p>
<p>Le altcoin sono generalmente aumentate, con il settore dell’IA che ha beneficiato di più.</p>
<h2 id="h2-Notizie20macroeconomiche20i20tre20principali20indici20azionari20statunitensi20hanno20chiuso20in20rialzo20e20il20mercato20azionario20statunitense20sar20chiuso20per20le20festivit20natalizie446665"><a name="Notizie macroeconomiche: i tre principali indici azionari statunitensi hanno chiuso in rialzo e il mercato azionario statunitense sarà chiuso per le festività natalizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie macroeconomiche: i tre principali indici azionari statunitensi hanno chiuso in rialzo e il mercato azionario statunitense sarà chiuso per le festività natalizie</h2><p>I tre principali indici azionari statunitensi hanno chiuso in rialzo, con l’indice S&amp;P 500 che è salito dello 0,73% a 5.974,07 punti; Il Dow Jones Industrial Average è salito dello 0,16% a 42.906,95 punti; L’indice Nasdaq è salito dello 0,98% a 19.764,88 punti. Il rendimento del Tesoro a 2 anni, che è il più sensibile al tasso di politica della Federal Reserve, è del 4,33%.</p>
<p>Mercoledì (25 dicembre) è festa di Natale negli Stati Uniti e i mercati finanziari statunitensi sono chiusi in quel giorno. La Borsa di New York chiuderà anticipatamente alle 13:00 ora della costa orientale martedì e ci si aspetta che le negoziazioni siano relativamente lente questa settimana.</p>
<p>La Fed ha annunciato lunedì che le banche di Wall Street avranno l’opportunità di esprimere le loro opinioni su una serie di modifiche al test di stress bancario annuale della Fed. La Fed ha dichiarato che raccoglierà pareri pubblici sul modello utilizzato per determinare le perdite e i ricavi ipotetici delle banche in condizioni di stress. La proposta di riforma prevede anche la media dei risultati di due anni di test per ridurre le variazioni annuali dei requisiti di capitale causate dal test di stress.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Ghiaccio</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; una decisione prudente è essenziale.<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, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>