Tm90aXppZSBxdW90aWRpYW5lIHwgUEkgQ29pbiBoYSByYWdnaXVudG8gdW4gbWFzc2ltbyBkaSAkMyBlIHBvaSBzaSDDqCByaXRpcmF0bywgbGEgcXVvdGEgZGkgbWVyY2F0byBkaSBFVEggw6ggc2Nlc2Egc290dG8gaWwgMTAlIHBlciBsYSBwcmltYSB2b2x0YSBpbiA0IGFubmk=

2025-02-28, 04:23

<p><img src="https://gimg2.gateimg.com/image/article/174071649920.png" alt=""></p>
<h2 id="h2-Criptovalute20Digest20quotidiano20lETF20BTC20ha20registrato20deflussi20netti20per20820giorni20consecutivi20mentre20ETH20e20SOL20sono20scesi20di20oltre20il205020dai20loro20massimi20storici862727"><a name="Criptovalute Digest quotidiano: l’ETF BTC ha registrato deflussi netti per 8 giorni consecutivi, mentre ETH e SOL sono scesi di oltre il 50% dai loro massimi storici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovalute Digest quotidiano: l’ETF BTC ha registrato deflussi netti per 8 giorni consecutivi, mentre ETH e SOL sono scesi di oltre il 50% dai loro massimi storici</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> L’ETF spot ha avuto un deflusso netto di 266 milioni di dollari ieri, di cui BlackRock ha avuto un deflusso di 192 milioni di dollari e Fidelity FBTC ha avuto un deflusso di 7,25 milioni di dollari. L’ETF BTC ha avuto un deflusso netto per otto giorni consecutivi, con un deflusso totale di oltre 3,2 miliardi di dollari in questi otto giorni.</p>
<p>Ieri, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot hanno registrato deflussi per $46,4 milioni, di cui BlackRock ETHA ha visto deflussi per $26,74 milioni e Grayscale ETHE ha visto deflussi per $19,6 milioni.</p>
<p><strong>Dati: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è sceso del 25% dal suo massimo storico, mentre <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è sceso di più del 50% dal suo massimo storico</strong></p>
<p>Secondo Gate.io dati di mercato, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è sceso di oltre il 25% dal suo massimo storico di $ 109.588 in 39 giorni e ora viene scambiato a $ 80.610. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è sceso del 55% dal suo massimo del mercato rialzista di $ 4.107 in 74 giorni e ora viene scambiato a $ 2.116; SOL è sceso del 55% dal suo massimo storico di $ 295,8 in 40 giorni e ora viene scambiato a $ 129,6.</p>
<p><strong>Glassnode: l’area di concentrazione del costo di Bitcoin compresa tra 96.000$ e 98.000$ potrebbe essere un forte livello di resistenza</strong></p>
<p>Glassnode ha pubblicato sui social media che “Tra la fine di dicembre 2024 e febbraio 2025, c’è stata un’accumulazione significativa nell’area da $96.000 a $98.000.”</p>
<p>Mentre alcuni indirizzi all’interno di questi intervalli di prezzo stanno riallocando i loro BTC, questo cluster di offerta rimane estremamente denso - e potrebbe fungere da forte resistenza se dovessimo tornare a questo livello.</p>
<p><strong>Analisi: mantenere la posizione rialzista, aspettarsi un rimbalzo del mercato prima della fine della settimana</strong></p>
<p>“L’annuncio del presidente degli Stati Uniti Donald Trump di un possibile dazio del 25% sui beni europei ha riacceso le paure degli investitori, facendo scendere l’indice della Paura e Dell’Avidità Crypto a 10, in territorio di paura estrema,” ha detto Valentin Fournier, analista presso BRN.</p>
<p>Mentre alcuni temono l’inizio di un mercato ribassista, la storia dimostra che i pullback del 25% sono comuni nei cicli rialzisti e lo sforzo degli Stati Uniti per costruire una riserva nazionale di criptovalute rimane un importante catalizzatore a lungo termine. Manteniamo la nostra posizione rialzista e ci aspettiamo che il mercato rimbalzi entro la fine della settimana. Continuiamo a sovrappesare <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e rimanere neutrale su BTC e ETH.</p>
<h2 id="h2-Tendenze20di20mercato20la20criptovaluta20PI20ha20raggiunto20i20320dollari20e20ha20subito20un20ritiro20la20quota20di20mercato20di20ETH2020scesa20al20di20sotto20del2010782418"><a name="Tendenze di mercato: la criptovaluta PI ha raggiunto i 3 dollari e ha subito un ritiro, la quota di mercato di ETH è scesa al di sotto del 10%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: la criptovaluta PI ha raggiunto i 3 dollari e ha subito un ritiro, la quota di mercato di ETH è scesa al di sotto del 10%</h2><h3 id="h3-Punti20caldi20di20mercato499154"><a name="Punti caldi di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi di mercato</h3><p>Il nuovo concetto di criptovaluta AI SHELL è aumentato notevolmente, con il picco giornaliero che ha superato il 40% in un momento; SHELL è il principale progetto di Agente AI promosso da il <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> catena. Con CZ spingendo la catena <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a>, SHELL ha ricevuto molto supporto; la capitalizzazione di mercato circolante attuale di SHELL è di $160 milioni, che si classifica al 260° posto nell’intero mercato, con una capitalizzazione di mercato circolante totale di $600 milioni;</p>
<p>Il coin PI ha subito una correzione, incontrando un forte sell-off al livello intero di $3, e attualmente si sta consolidando intorno a $2.5; la capitalizzazione di mercato circolante attuale di PI è di $17.7 miliardi, e il tasso di circolazione effettivo è solo del 6.7%; la capitalizzazione di mercato circolante completa del coin PI è altrettanto alta quanto $250 miliardi, che è infinitamente vicina alla capitalizzazione di mercato circolante completa di ETH; dal punto di vista dello spazio della capitalizzazione di mercato, questa performance di prezzo del coin PI è quasi insostenibile.</p>
<h3 id="h3-Monete20principali367817"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC è crollato di nuovo oggi, e l’ETF BTC ha avuto un deflusso netto per 8 giorni consecutivi. Questa settimana è stato registrato un record di deflusso giornaliero di oltre $1.1 miliardi. La tendenza al ribasso volatile a breve termine continuerà; l’indice AHR999 è anche recentemente diminuito bruscamente, indicando che l’attuale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo di BTC</a> è adatto a chi investe regolarmente a lungo termine;</p>
<p>ETH è sceso per 5 giorni consecutivi, toccando la soglia dei 2.200$. Dal punto di vista dei finanziamenti, l’ETF ETH non ha subito un grande sell-off questa settimana e sta ancora seguendo principalmente l’andamento del mercato. Allo stesso tempo, l’ETHD è ufficialmente sceso sotto il 10% oggi ed è ora al 9,8%, che è anche un nuovo minimo negli ultimi 4 anni;</p>
<p>Le altcoin sono generalmente diminuite e il mercato ha mancato di un punto caldo narrativo collettivo.</p>
<h2 id="h2-Notizia20macro20le20azioni20statunitensi20sono20crollate20bruscamente20gli20occhi20del20mercato20sono20puntati20sui20dati20PCE20di20stasera154074"><a name="Notizia macro: le azioni statunitensi sono crollate bruscamente, gli occhi del mercato sono puntati sui dati PCE di stasera" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizia macro: le azioni statunitensi sono crollate bruscamente, gli occhi del mercato sono puntati sui dati PCE di stasera</h2><p>I tre principali indici azionari statunitensi sono tutti diminuiti nettamente, con lo S&amp;P 500 in calo dell’1,59% a 5.861,57 punti, il Nasdaq Composite in calo del 2,78% a 18.544,42 punti e il Dow Jones Industrial Average in calo dello 0,45% a 43.239,5 punti. Il rendimento del titolo di Stato decennale di riferimento era del 4,22% e il rendimento del titolo di Stato a 2 anni, che è il più sensibile al tasso di politica della Fed, era del 4,02%.</p>
<p>In termini di dati macroeconomici, anche una serie di dati pubblicati il 27 ha disturbato il mercato azionario statunitense. Tra questi, il rapporto pubblicato dal Bureau of Economic Analysis degli Stati Uniti ha mostrato che il tasso di crescita annualizzato trimestre su trimestre del PIL reale nel quarto trimestre degli Stati Uniti è stato rivisto al 2,3%, in linea con le aspettative del mercato e uguale al valore iniziale. Sebbene il tasso di crescita sia rallentato rispetto ai trimestri precedenti, mostra ancora la resilienza dell’economia statunitense. Tuttavia, i dati sull’inflazione non sono ottimistici.</p>
<p>Attualmente il mercato sta prestando particolare attenzione al rapporto PCE degli Stati Uniti per gennaio 2025, che sarà rilasciato alle 21:30 di stasera ora di Pechino. Questi dati forniranno al mercato gli ultimi indizi sul trend dell’inflazione negli Stati Uniti e potrebbero avere un impatto importante sulle decisioni di politica della Federal Reserve.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Icing T.</strong>, Ricercatore Gate.io<br><div>Traduttore:Gioia 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 prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>