Tm90aXppZSBxdW90aWRpYW5lIHwgRkFSVENPSU4gaGEgcmVnaXN0cmF0byB1bmEgZm9ydGUgcGVyZm9ybWFuY2UsIGlsIG1lcmNhdG8gZGVsbGUgY3JpcHRvdmFsdXRlIHBvdHJlYmJlIHJpcHJlbmRlcnNpIGEgbWV0w6Agc2V0dGltYW5h

2025-04-08, 04:00

<p><img src="https://gimg2.gateimg.com/image/article/17440845074.8.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest207000020potrebbe20diventare20il20supporto20di20fondo20e20il20mercato20delle20criptovalute20potrebbe20riprendersi20a20met20settimana440703"><a name="Crypto Daily Digest: $70,000 potrebbe diventare il supporto di fondo e il mercato delle criptovalute potrebbe riprendersi a metà settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: $70,000 potrebbe diventare il supporto di fondo e il mercato delle criptovalute potrebbe riprendersi a metà settimana</h2><p>Secondo i dati degli investitori di Farside, l’uscita netta totale degli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF spot ieri è stato di $97.7 milioni, di cui Grayscale GBTC ha avuto un deflusso di $74 milioni, e i dati di BlackRock IBIT non sono ancora stati aggiornati. Non c’è stato ingresso o deflusso di fondi nel <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF spot ieri.</p>
<p>Secondo i dati alternativi, l’indice crypto Fear &amp; Greed di oggi è 24 (quello di ieri era 23), e il sentiment di mercato è ancora in “panico estremo”. Secondo i dati di Coinglass, i tassi di finanziamento attuali di CEX e DEX mainstream mostrano che il mercato è ribassista su tutta la linea.</p>
<p><strong>Analyst: <a href="/price" rel="nofollow noopener noreferrer" target="_blank">Mercato delle criptovalute</a> vendita guidata da fattori macro, potrebbe riprendersi a metà settimana</strong></p>
<p>Secondo The Block, gli analisti hanno affermato che il sell-off nel mercato delle criptovalute lunedì è stato principalmente guidato da fattori macro globali piuttosto che da problemi nel mercato delle criptovalute stesse. Il dott. Kirill Kretov, esperto senior di automazione presso CoinPanel, ha dichiarato in un’intervista a The Block: ‘Ci troviamo in un periodo di elevata incertezza globale, con conflitti tariffari in aumento, frequenti focolai geopolitici e segnali macro contrastanti che convergono. In questo contesto, gli investitori si stanno spostando da asset ad alto rischio a asset considerati più sicuri come i titoli del Tesoro statunitense e l’oro. Le criptovalute, in particolare gli Altcoin, stanno sopportando la pressione.’</p>
<p>Nonostante il sell-off di mercato, alcuni analisti vedono ancora un potenziale per un rimbalzo nel breve termine. Chu, un analista presso BRN, ha detto che le condizioni ipervendute potrebbero innescare un rimbalzo a metà settimana, a seconda dei prossimi dati economici.</p>
<p>Chu ha detto: “Poiché gli asset a rischio sono ipervenduti nel breve termine, potrebbe essere visibile un certo sollievo a breve termine nei prossimi uno o due giorni. Con la pubblicazione del verbale della riunione del FOMC della Federal Reserve mercoledì, la pubblicazione del CPI degli Stati Uniti e delle richieste di sussidio di disoccupazione iniziali giovedì, e la pubblicazione del PPI e dei dati sull’indice di fiducia dei consumatori dell’Università del Michigan sulle aspettative di inflazione venerdì, il mercato potrebbe vedere un “rimbalzo del gatto morto” che durerà almeno diverse settimane, il quale potrebbe iniziare già mercoledì.</p>
<p><strong>Dati: Le attuali tariffe di finanziamento CEX e DEX mostrano che il mercato è ribassista su tutta la linea</strong></p>
<p>Secondo i dati di Coinglass, i tassi di finanziamento attuali di CEX e DEX principali mostrano che il mercato è ribassista in generale.</p>
<p>I tassi di finanziamento sono i tassi stabiliti dalle piattaforme di trading di criptovalute per mantenere un equilibrio tra il prezzo del contratto e il prezzo dell’attività sottostante, e sono di solito applicabili ai futures perpetui. È un meccanismo per scambiare fondi tra trader long e short. La piattaforma di trading non addebita questa commissione, ma viene utilizzata per regolare il costo o il beneficio dei trader che detengono futures per mantenere il prezzo del contratto vicino al prezzo dell’attività sottostante. Quando il tasso di finanziamento è dello 0,01%, indica il tasso base. Quando il tasso di finanziamento è superiore allo 0,01%, indica che il mercato è generalmente rialzista. Quando il tasso di finanziamento è inferiore allo 0,005%, indica che il mercato è generalmente ribassista.</p>
<p><strong>Punto di vista: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è strettamente legato al Nasdaq e il range minimo potrebbe essere intorno a $70,000</strong></p>
<p>Julio Moreno, capo della ricerca presso CryptoQuant, ha affermato che il calo del 26,62% del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> dal suo massimo storico di 109.500 dollari ha reso questo ribasso il peggiore ritracciamento nel ciclo rialzista attuale.</p>
<p>Guardando il ciclo storico, questa fase di correzione non è così grave come quella del 2018 (in calo dell’83%) e del 2022 (in calo del 73%), ma ha comunque un impatto significativo. Gli analisti affermano che se il Nasdaq è debole, il rimbalzo del Bitcoin potrebbe essere limitato. Inoltre, la società di Michael Saylor ha recentemente sospeso l’acquisto di monete, e il rendimento sui titoli è solo del 17%. Tecnicamente, se il BTC scende al di sotto della EMA a 50 settimane, potrebbe entrare in un mercato ribassista. L’RSI mostra che il fondo potrebbe essere intorno ai $70.000.</p>
<h2 id="h2-Tendenze20di20mercato20FARTCOIN20ha20registrato20una20forte20performance20ETHD2020sceso20al207520un20nuovo20minimo20quasi20quattro20anni20520"><a name="Tendenze di mercato: FARTCOIN ha registrato una forte performance, ETHD è sceso al 7.5%, un nuovo minimo quasi quattro anni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: FARTCOIN ha registrato una forte performance, ETHD è sceso al 7.5%, un nuovo minimo quasi quattro anni</h2><h3 id="h3-Punti20Caldi20del20Mercato161498"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>FARTCOIN nel settore degli agenti AI è aumentato di oltre il 20% nella giornata, e le sue prestazioni di prezzo sono state significativamente più forti rispetto ad altri Altcoin nello stesso periodo; FARTCOIN è cresciuto quasi 3 volte nel mese scorso, diventando il token di agente AI dal rendimento migliore sul mercato; La capitalizzazione di mercato attuale di FARTCOIN in circolazione è di $580 milioni, posizionandosi al 87º posto nell’intero mercato. FARTCOIN è ancora in calo di quasi l’80% rispetto al suo massimo storico;</p>
<p>Il token educativo EDU, che CZ ha una volta fortemente promosso, è aumentato del 35%, diventando la principale Altcoin sul mercato; tuttavia, il progetto Open Campus stesso non ha lanciato alcuna attività operativa per aumentare il prezzo della moneta e il suo futuro trend rimane da vedere; La capitalizzazione di mercato circolante attuale di EDU è di $66 milioni, in calo di più del 90% rispetto al suo massimo storico.</p>
<h3 id="h3-Monete20principali653661"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>L’instabilità intraday del BTC è aumentata, toccando brevemente i $75.000 prima di riprendersi sopra gli $80.000. I fondi di mercato hanno ripetutamente competuto per il livello intero di $80.000. L’indice AHR999 di oggi è 0,67, indicando che è adatto per gli investitori a lungo termine investire regolarmente;</p>
<p>ETH è sceso a circa $1,400 dopo la liquidazione della balena on-chain, per poi tornare a $1,600 in seguito alla ripresa del mercato. ETHD è al 7.5% oggi, un nuovo minimo di quasi quattro anni;</p>
<p>Le altcoin hanno generalmente ripreso, ma il rimbalzo è stato debole, il che potrebbe essere causato da un gran numero di venditori allo scoperto sul mercato che stanno chiudendo le loro posizioni. Le prospettive sono cautamente ottimistiche.</p>
<h2 id="h2-Macro20News20Le20azioni20statunitensi20hanno20oscillato20bruscamente20e20le20aspettative20di20mercato20per20il20taglio20dei20tassi20della20Fed20sono20aumentate295293"><a name="Macro News: Le azioni statunitensi hanno oscillato bruscamente, e le aspettative di mercato per il taglio dei tassi della Fed sono aumentate" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: Le azioni statunitensi hanno oscillato bruscamente, e le aspettative di mercato per il taglio dei tassi della Fed sono aumentate</h2><p>La scorsa notte, i tre principali indici azionari statunitensi hanno subito forti fluttuazioni, con il Nasdaq che ha oscillato del 9,68% e l’indice Golden Dragon che è sceso del 5%. Alla chiusura, il Dow è sceso dello 0,91%, il Nasdaq è salito dello 0,1% e lo S&amp;P è sceso dello 0,23%. Il rendimento del titolo di Stato statunitense decennale è aumentato del 4,777% per chiudere al 4,189%, inferiore di 40,9 punti base rispetto al rendimento del titolo di Stato biennale. L’indice VIX è salito del 3,69% a 46,98 e l’indice del dollaro statunitense è aumentato dello 0,61% ieri a 103,51.</p>
<p>Durante la sessione di trading, diversi media statunitensi hanno riportato che Kevin Hassett, direttore del Consiglio Economico Nazionale della Casa Bianca, ha dichiarato che il presidente degli Stati Uniti Trump sta considerando di sospendere i dazi su alcuni paesi per 90 giorni. In seguito a ciò, le azioni statunitensi, che avevano subito un crollo all’apertura, sono passate da un calo a un aumento, e il Nasdaq è passato da un calo del 5% a un aumento del 4,3%. Tuttavia, è stato verificato che le parole originali di Hassett in un’intervista con Fox News quel giorno erano “il presidente prenderà la decisione che vuole prendere”, e non ha specificato che “Trump sta considerando di sospendere i dazi su alcuni paesi per 90 giorni”. La portavoce della Casa Bianca, Carolyn Levitt, ha definito ciò “fake news”. Di conseguenza, i tre principali indici azionari statunitensi sono nuovamente scesi.</p>
<p>Senza segni che Trump cederà sulle tariffe, le aspettative stanno aumentando per un taglio dei tassi di emergenza dalla Federal Reserve. Gli swap stanno prezzando circa il 40% di probabilità di un taglio dei tassi di un quarto di punto la prossima settimana, ben prima della decisione sui tassi programmata per il 7 maggio della banca centrale.</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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>