Tm90aXppZSBxdW90aWRpYW5lIHwgS0FJVE8gUm9zZSBjb250cm8gbGEgdGVuZGVuemEgZSBoYSByYWdnaXVudG8gdW4gbnVvdm8gcmVjb3JkIHN0b3JpY28sIEFMQ0ggaGEgZ3VpZGF0byBpbCBwZXJjb3JzbyBkZWxsJ2FnZW50ZSBBSSB2ZXJzbyB1bmEgcmlwcmVzYSBnZW5lcmFsZQ==

2025-02-27, 04:17

<p><img src="https://gimg2.gateimg.com/image/article/174062981319.png" alt=""></p>
<h2 id="h2-Digest20giornaliero20delle20criptovalute20lETF20BTC20ha20registrato20deflussi20netti20per20720giorni20consecutivi20e20il20trend20al20ribasso20del20mercato20non20si2020invertito345531"><a name="Digest giornaliero delle criptovalute: l’ETF BTC ha registrato deflussi netti per 7 giorni consecutivi e il trend al ribasso del mercato non si è invertito" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digest giornaliero delle criptovalute: l’ETF BTC ha registrato deflussi netti per 7 giorni consecutivi e il trend al ribasso del mercato non si è invertito</h2><p>Secondo i dati degli investitori di Farside, gli Stati Uniti. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot hanno avuto un deflusso netto di 756 milioni di dollari ieri, segnando sette giorni consecutivi di deflussi netti; tra questi, BlackRock ha avuto un deflusso di 420 milioni di dollari, che è stato anche il più grande deflusso in un singolo giorno dal lancio del BlackRock IBIT. Inoltre, Fidelity FBTC ha avuto un deflusso di 145 milioni di dollari e Ark ARKB ha avuto un deflusso di 60,5 milioni di dollari.</p>
<p>Ieri, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF spot ha registrato un deflusso di $24.5 milioni, di cui Fidelity FETH ha registrato un deflusso di $18.4 milioni. I dati di BlackRock ETHA non sono ancora stati aggiornati.</p>
<p><strong>Analisi: I dati delle opzioni mostrano che il trend del BTC potrebbe non essersi invertito e ci si aspetta che la volatilità dell’ETH sia bassa nel prossimo futuro</strong></p>
<p>Adam, un analista della nota piattaforma di trading di opzioni Greeks.live, ha pubblicato sui social media che c’è un generale sentimento ribassista sul mercato, ritenendo che il rimbalzo sia debole e che il BTC possa cadere ulteriormente al di sotto degli $80.000. Alcuni credono addirittura che riproduca il trend volatile dell’anno scorso. Molti trader hanno sottolineato che il prezzo attuale è sceso sotto il livello di resistenza ‘M top’ e che ci sono rischi nella direzione a medio termine. Allo stesso tempo, l’ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ha visto anche un record di uscite nette, che ha acuito il sentimento ribassista sul mercato.</p>
<p>In termini di dati sulle opzioni, i trader di opzioni hanno discusso della performance anomala della volatilità di mercato attuale. Nonostante il brusco calo, la volatilità delle opzioni a medio e lungo termine non è aumentata in modo efficace. Ciò potrebbe indicare che il mercato si aspetta che si tratti di un calo isolato piuttosto che di un cambiamento di tendenza. I trader hanno osservato che la distribuzione gamma di ETH è molto forte a $2.500, e la dispersione gamma negativa indica che il mercato si aspetta una minore volatilità nel breve termine.</p>
<p><strong>Ondo entra in partnership con MasterCard per lanciare il servizio RWA su MTN</strong></p>
<p>Il progetto RWA Ondo Finance si è unito alla rete Mastercard per migliorare i pagamenti transfrontalieri. Il prodotto di investimento OUSG (Ondo’s Short-Term US Government Bond Fund) di Ondo sarà aperto alle imprese sulla Mastercard Multi-Token Network (MTN), consentendo loro di ottenere rendimenti su asset tokenizzati, secondo le notizie ufficiali.</p>
<p>Si riferisce che la maggior parte degli asset di OUSG è investita nel BlackRock US Dollar Institutional Digital Liquidity Fund (BUIDL), il più grande fondo di mercato monetario basato su blockchain supportato da obbligazioni governative statunitensi a breve termine. Il MTN di Mastercard combina strumenti blockchain abilitati da API per aiutare le banche a semplificare le transazioni nazionali e transfrontaliere.</p>
<p><strong>Bostic della Fed: la Fed potrebbe abbassare i tassi di interesse due volte quest’anno, l’incertezza è alta</strong></p>
<p>Bostic della Fed ha detto di aspettarsi due tagli dei tassi quest’anno, ma potrebbero verificarsi più o meno tagli a causa dell’incertezza “diffusa”. Non si aspetta che l’inflazione esploda improvvisamente e la sua previsione complessiva sull’inflazione prevede un percorso discendente irregolare. Crede che l’inflazione si avvicinerà all’obiettivo del 2%, ma non è ancora arrivata. L’obiettivo della Fed è raggiungere il target del 2,0% senza danneggiare il mercato del lavoro.</p>
<p>Bostic ha detto che le imprese sono ottimiste riguardo alla deregolamentazione ma sono preoccupate per l’impatto dei dazi e dei cambiamenti nella politica sull’immigrazione. Inoltre, vede segni di alleviamento nel mercato del lavoro. Bostic ha detto che il tasso di interesse di riferimento attuale è moderatamente restrittivo e deve rimanere tale. Ha detto che la frenata economica è una preoccupazione principale a causa del prossimo cambiamento di politica, ma le imprese si aspettano una solida crescita economica nel 2025.</p>
<h2 id="h2-Tendenze20di20mercato20KAITO20ha20raggiunto20un20nuovo20record20contro20il20trend20e20il20track20generale20di20AI20Agent2020aumentato557864"><a name="Tendenze di mercato: KAITO ha raggiunto un nuovo record contro il trend, e il track generale di AI Agent è aumentato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: KAITO ha raggiunto un nuovo record contro il trend, e il track generale di AI Agent è aumentato</h2><h3 id="h3-Punti20Caldi20del20Mercato473500"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>KAITO si è ribellato al trend, raggiungendo $2.6 nel corso della giornata, stabilendo un nuovo record. KAITO è diventato la migliore nuova criptovaluta delle scorse settimane. Kaito AI ha un solido background di investitori ed è stata quotata sui principali mercati mainstream, inclusa Gate.io, il primo giorno del suo lancio. Inoltre, il team di Kaito AI ha un buon controllo del ritmo operativo e ha lanciato carte sociali di diversi livelli all’inizio di questa settimana, che hanno stimolato gli acquisti di capitale durante il calo di mercato. Kaito AI è un progetto basato su intelligenza artificiale. <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">web3</a> strumento di integrazione delle informazioni che mira a risolvere i problemi attuali della frammentazione delle informazioni nell’industria crittografica;</p>
<p>Token AI Agenti in tendenza come ALCH, PIPPIN, AIXBT e  sono tutti aumentati, con ALCH che ha registrato un aumento del più del 200% in tre giorni; Nvidia ha rilasciato il suo rapporto finanziario presto stamattina, con ricavi significativamente superiori alle aspettative, il che ha in certo modo rafforzato la fiducia del mercato nel settore dell’IA. L’IA deve essere la narrazione più diffusa nell’industria criptata del futuro.</p>
<h3 id="h3-Coin20principali262022"><a name="Coin principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Coin principali</h3><p>BTC è sceso sotto gli $82.500 durante la giornata. L’ETF su BTC ha registrato un grande afflusso netto per una settimana di fila, con un deflusso giornaliero di oltre $1,1 miliardi l’altro ieri. Dal punto di vista dei fondi ETF, le prospettive di mercato sono deboli; l’indice AHR999 di oggi è 0,86, indicando che è adatto per gli investitori a lungo termine investire regolarmente;</p>
<p>ETH è sceso per tre giorni consecutivi ed attualmente si sta consolidando intorno ai $2.350. Potrebbe richiedere molto tempo per riprendersi dal mercato negativo. ETHD (quota di mercato di ETH) sta per scendere al di sotto del 10%. ETHD è in discesa dal 2021. Rispetto al massimo storico del 23% nel 2021, ETHD è sceso di più del 55%;</p>
<p>Le altcoin non seguono più il mercato al ribasso, e il track dell’agente AI è salito contro il trend sotto lo stimolo del rapporto finanziario di Nvidia. Le altcoin in tendenza potrebbero aver toccato il fondo.</p>
<h2 id="h2-Macro20News20curva20dei20rendimenti20del20Tesoro20degli20Stati20Uniti20invertita20aumentate20le20aspettative20di20taglio20dei20tassi20della20Fed400606"><a name="Macro News: curva dei rendimenti del Tesoro degli Stati Uniti invertita, aumentate le aspettative di taglio dei tassi della Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: curva dei rendimenti del Tesoro degli Stati Uniti invertita, aumentate le aspettative di taglio dei tassi della Fed</h2><p>I tre principali indici azionari statunitensi sono saliti e scesi, con l’S&amp;P 500 in rialzo dello 0,01% a 5956,06 punti, il Dow Jones in calo dello 0,43% a 43433,12 punti e il Nasdaq in rialzo dello 0,26% a 19075,26 punti. Il rendimento del Treasury decennale di riferimento era del 4,25% e il rendimento del Treasury a 2 anni, il più sensibile al tasso d’interesse della Fed, era del 4,05%.</p>
<p>Inoltre, il rendimento del Tesoro degli Stati Uniti a 10 anni è sceso per il sesto giorno consecutivo, raggiungendo il punto più basso di quest’anno e scendendo al di sotto del rendimento del Tesoro a 3 mesi, formando una “inversione della curva dei rendimenti”. L’inversione della curva dei rendimenti è sempre stato uno dei comuni indicatori per prevedere una recessione economica, il che ha nuovamente alimentato le aspettative di mercato per tagli dei tassi di interesse. Attualmente il mercato si aspetta che la Federal Reserve riduca i tassi di interesse di almeno 0,5 punti percentuali quest’anno.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Icing 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. È consentito ripubblicare l'articolo a condizione che si faccia 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>