Tm90aXppZSBxdW90aWRpYW5lIHwgRXRoZXJldW0gU3BvdCBFVEYgaGEgcmVnaXN0cmF0byBkZWZsdXNzaSBuZXR0aSBwZXIgMTIgZ2lvcm5pIGNvbnNlY3V0aXZpLCBpbCBUVkwgZGkgU29uaWMgTmV0d29yayBoYSBzdXBlcmF0byBnbGkgJDg1MCBtaWxpb25p

2025-03-21, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/174253123415.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20lETF20spot20Ethereum20ha20subito20un20deflusso20netto20per201220giorni20consecutivi20il20TVL20di20Sonic20Network20ha20superato20gli2085020milioni20di20dollari153866"><a name="Crypto Daily Digest: l’ETF spot Ethereum ha subito un deflusso netto per 12 giorni consecutivi, il TVL di Sonic Network ha superato gli 850 milioni di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: l’ETF spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha subito un deflusso netto per 12 giorni consecutivi, il TVL di Sonic Network ha superato gli 850 milioni di dollari</h2><p>Il 21 marzo, secondo i dati di monitoraggio degli investitori di Farside, gli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF spot ha registrato un afflusso netto di $165,7 milioni ieri, segnando il quinto giorno consecutivo di afflusso netto. Tra questi, BlackRock IBIT ha registrato un afflusso netto di $172,1 milioni, e FETH ha registrato un deflusso netto di $3,5 milioni.</p>
<p>Ieri, gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF ha avuto un deflusso netto di $12.5 milioni, e ha ora registrato deflussi netti per 12 giorni consecutivi, di cui BlackRock ETHA ha avuto un deflusso netto di $9 milioni.</p>
<p><strong>Il TVL di Sonic Networks ha superato gli $850 milioni</strong></p>
<p>Il 21 marzo, secondo i dati di Defillama, il TVL di Sonic Network è stato segnalato essere $854 milioni, un aumento dell’83% nell’ultimo mese.</p>
<p>I tre principali protocolli DeFi TVL della rete attualmente sono: il protocollo di prestito Silo Finance, il protocollo di staking di liquidità Beets e <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> V3.</p>
<p><strong>Le scorte di ETH su CEX sono scese ai minimi storici di 10 anni</strong></p>
<p>Il 21 marzo, secondo i dati da <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato cripto</a> L’agenzia di analisi Santiment, a causa delle numerose opzioni DeFi e di staking presenti sul mercato, ha ridotto l’offerta disponibile sulle piattaforme di trading a 8,97 milioni di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a>, il livello più basso da quasi 10 anni (il precedente minimo risale a novembre 2015).</p>
<p><strong>Pump.fun ha annunciato il lancio di PumpSwap</strong></p>
<p>Il 21 marzo, CoinDesk ha riportato che Pump.fun ha lanciato un servizio di scambio di token basato sul protocollo liquidity pool. Il servizio, chiamato PumpSwap, mette il progetto in diretta concorrenza con i market maker automatizzati (AMM) <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosistema che si specializza nelle transazioni di token on-chain.</p>
<p><strong>Il discorso del summit di Trump non ha annunciato <a href="/price/view/new-cryptocurrencies" rel="nofollow noopener noreferrer" target="_blank">nuova criptovaluta</a>-related politiche</strong></p>
<p>Il 20 marzo, il discorso del presidente degli Stati Uniti Trump al Vertice degli Asset Digitali 2025 è durato solo circa 2 minuti. Erano solo osservazioni formali senza alcun contenuto nuovo. Non è stato come precedentemente riportato dalla giornalista Eleanor Terrett che Trump avrebbe annunciato la sua successiva politica cripto al Vertice degli Asset Digitali degli Stati Uniti. A giudicare dalla trasmissione in diretta del vertice, la stanza della trasmissione in diretta era invasa da commenti delusi dai seguaci.</p>
<h2 id="h2-Tendenze20di20mercato20in20generale20le20altcoin20hanno20registrato20un20calo20ETH2020sceso20sotto20i20200020dollari155917"><a name="Tendenze di mercato: in generale, le altcoin hanno registrato un calo, ETH è sceso sotto i 2.000 dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: in generale, le altcoin hanno registrato un calo, ETH è sceso sotto i 2.000 dollari</h2><h3 id="h3-Punti20Caldi20del20Mercato794851"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>BANANA ha superato i $23, con un aumento del 23,4% nelle ultime 24 ore. Dopo aver toccato un minimo a breve termine di $10,2 l’11 marzo, la moneta si è più che raddoppiata. I piani futuri del team di Banana Gun includono la distruzione del token, la condivisione dei ricavi e ulteriori implementazioni del programma bonus, che potrebbero avere un impatto positivo sul prezzo del token.</p>
<p>Influenzato dalla notizia che L3 potrebbe essere aggiunto alla tabella di marcia della quotazione degli asset da parte degli scambi principali, L3 è salito di oltre il 20% in breve tempo, segnalando temporaneamente $0.06831.</p>
<h3 id="h3-Monete20principali609717"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC è sceso sotto gli $84.000 durante la sessione. Dopo un breve rimbalzo, il mercato <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">ottimismo</a> non è durato a lungo ed è tornato ieri a uno stato di “panico”. Dal punto di vista del mercato, BTC non è ancora riuscito a mantenere un trend al rialzo e la possibilità di un ulteriore declino nel breve termine è ancora abbastanza alta.</p>
<p>ETH è sceso sotto la soglia dei $2.000. Giudicando dai dati dell’ETF, le prospettive non sono ottimistiche.</p>
<p>Le altcoin non hanno ancora un mercato indipendente e il mercato è sceso su tutta la linea. I settori SocialFi e CeFi sono relativamente forti. Tra questi, il settore SocialFi è aumentato del 1,44% nelle ultime 24 ore. All’interno del settore, <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> (TON) è aumentato del 2,14% a causa di fattori come il finanziamento a grande scala, e Galxe (GAL) è aumentato del 3,10%. Il settore CeFi è aumentato dello 0,67%, e all’interno del settore, Binance Coin ( <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>) è salito dell’1,14%.</p>
<h2 id="h2-Macro20news20Le20azioni20statunitensi20hanno20continuato20a20cadere20dopo20il20rimbalzo20linflazione20core20del20Giappone20ha20registrato20la20crescita20pi20rapida820272"><a name="Macro news: Le azioni statunitensi hanno continuato a cadere dopo il rimbalzo, l’inflazione core del Giappone ha registrato la crescita più rapida" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro news: Le azioni statunitensi hanno continuato a cadere dopo il rimbalzo, l’inflazione core del Giappone ha registrato la crescita più rapida</h2><p>Il mercato ha digerito la decisione della Fed, dubitando che la Fed potesse tagliare drasticamente i tassi di interesse di fronte a potenziali tariffe commerciali inflazionistiche, mentre i commenti della Presidente della Banca Centrale Europea Christine Lagarde hanno pesato sul sentiment del mercato. Lagarde ha detto che le tariffe statunitensi potrebbero colpire la crescita economica nella regione, ma non poteva fare un impegno vincolante sui tassi di interesse. Il rimbalzo del mercato azionario statunitense è durato solo un giorno il giorno della decisione della Fed, e tutti e tre i principali indici azionari statunitensi sono scesi ieri.</p>
<p>L’inflazione core del Giappone, escludendo i prodotti alimentari freschi, è aumentata del 3% su base annua a febbraio, in calo rispetto al 3,2% di gennaio, ma l’inflazione core è aumentata del 2,6%, la crescita più rapida da quasi un anno. Questo risultato supporta il caso affinché la Banca del Giappone continui a aumentare gradualmente i tassi di interesse. Il mercato si aspetta ancora che la Banca del Giappone aumenti di nuovo i tassi di interesse a giugno o luglio e mantenga il ritmo di aumento dei tassi di interesse circa ogni sei mesi.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Rooick Z. &amp;<a href="/price/amp-amp" target="_blank" class="blog_inner_link">amp</a>; Orisi T.</strong>, Ricercatore Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>