Tm90aXppZSBzdSBTaGliYSBJbnU6IExcJ2F0dGl2aXTDoCBkZWxsZSBiYWxlbmUgYXVtZW50YSBjb24gNiw1IHRyaWxpb25pIGRpIFNISUIgdHJhc2Zlcml0aSBhbGxcJ2V4Y2hhbmdl

2025-06-09, 07:23

<p><img src="https://gimg2.gateimg.com/image/shib202506091521048721379427.png" alt="">
</p><p>Il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> è tumultuosa, e dietro una serie di trasferimenti astronomici di SHIB, è un segnale di vendita da parte delle balene o operazioni di routine da parte dei market maker?</p>
<p>Nelle ultime 24 ore, oltre 80 milioni di dollari di 6,59 trilioni di SHIB sono stati trasferiti da un portafoglio misterioso a un exchange centralizzato, suscitando scalpore nella comunità cripto.</p>
<p>La piattaforma di tracciamento blockchain Whale Alert ha monitorato continuamente tre grandi trasferimenti che superano i 20 trilioni di SHIB, tutti destinati a Coinbase Institutional. I dati mostrano che l’indirizzo di invio “0x2E2A” ha completato questo lotto di grandi trasferimenti all’indirizzo del wallet di custodia di Coinbase “0x46E5”.</p>
<p>Non si tratta di un incidente isolato. Circa 7,5 trilioni sono avvenuti questa settimana. <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> In arrivo su Coinbase Institutional, questi asset provengono tutti da conti di custodia BitGo.</p>
<h2 id="h2-La20balena20si20risveglia20massiva20fluttuazione20di20SHIB114655"><a name="La balena si risveglia, massiva fluttuazione di SHIB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La balena si risveglia, massiva fluttuazione di SHIB</h2><p>Il mondo della blockchain non manca mai di momenti drammatici. All’inizio di giugno, una serie di trasferimenti astronomici di SHIB ha lasciato l’intera comunità cripto senza fiato. In 24 ore, 3,2 trilioni di SHIB del valore di 43,6 milioni di USD sono stati trasferiti in un wallet istituzionale di Coinbase.</p>
<p>Un’indagine approfondita rivela parte del mistero: questi indirizzi di invio non sono del tutto “sconosciuti”, ma sono portafogli associati al noto market maker Wintermute. Ancora più importante, questo è solo la punta dell’iceberg.</p>
<p>Wintermute ha trasferito un totale di 650 trilioni di SHIB (del valore di 80,2 milioni di USD) e 32.650 ETH (del valore di 82,38 milioni di USD) nell’arco di 24 ore. Tutti gli asset provengono da conti di custodia BitGo, e gli esperti del settore analizzano che potrebbe essere un’operazione di routine per i market maker per regolare le loro posizioni.</p>
<p>Un altro wallet dormiente “0x6E45” che è stato inattivo per tre anni si è improvvisamente risvegliato, trasferendo 10 miliardi di SHIB a Binance e incassando $311.000. Se questo indirizzo vendesse al picco storico di SHIB ($0.00008845), il profitto teorico potrebbe raggiungere $2,7 milioni.</p>
<h2 id="h2-La20performance20del20mercato2020debole20e20i20livelli20di20supporto20chiave20sono20sotto20pressione144929"><a name="La performance del mercato è debole e i livelli di supporto chiave sono sotto pressione." class="reference-link"></a><span class="header-link octicon octicon-link"></span>La performance del mercato è debole e i livelli di supporto chiave sono sotto pressione.</h2><p>Nonostante i frequenti movimenti on-chain, le prestazioni di mercato di SHIB sembrano ancora lente. Al momento della scrittura, <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Prezzo SHIB</a> Prezzo: 0.00001223 USD, declino nelle ultime 24 ore: 4,33%, il declino dall’inizio dell’anno si è ampliato al 42,14%.</p>
<p>L’aspetto tecnico mostra un modello di tiro alla fune tra tori e orsi:</p>
<ul>
<li>La media mobile a 50 giorni è a 0,0000139 USD e il prezzo attuale è al di sotto di essa.</li><li>La media mobile a 200 giorni costituisce un livello di resistenza a medio-lungo termine, situato a 0.0000160 USD.</li><li>Il volume degli scambi ha continuato a ridursi dal picco all’inizio di maggio.</li></ul>
<p>Le posizioni chiave sono diventate il fulcro della contesa tra long e short. Se il prezzo riesce a stabilizzarsi a 0.0000125 e a superare la resistenza di 0.0000140, potrebbe innescare una nuova ondata di acquisti; al contrario, se non riesce a mantenere il supporto di 0.0000125, potrebbe aprire spazio per un calo verso 0.0000100.</p>
<h2 id="h2-Emergono20segnali20positivi361392"><a name="Emergono segnali positivi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Emergono segnali positivi</h2><p>Sotto la superficie apparentemente lenta, stanno emergendo silenziosamente diversi segnali positivi.</p>
<p>Il numero di detentori on-chain ha raggiunto un massimo storico di 1.510.290 portafogli, un aumento di quasi 3 milioni dalla fine di maggio. L’espansione della base di detentori fornisce una base comunitaria più solida per SHIB.</p>
<p>Il tasso di burn dei token è recentemente schizzato alle stelle. I dati mostrano che nelle ultime 24 ore, il tasso di burn di SHIB è aumentato dell’863,58%, con un totale di 107.081.056 token bruciati, e un burn cumulativo di 368.456.226 token la scorsa settimana. Questo meccanismo deflazionistico aumenta la scarsità riducendo l’offerta circolante, il che potrebbe migliorare la relazione tra offerta e domanda a lungo termine.</p>
<p>Il rapporto dell’azienda di analisi on-chain Santiment porta aspettative più ottimistiche. Il rapporto MVRV di SHIB è sceso a -19,1%, il più basso tra le criptovalute principali, indicando che è gravemente sottovalutato e ha una maggiore probabilità di un rimbalzo a breve termine.</p>
<h2 id="h2-Le20divergenze20di20mercato20si20stanno20intensificando20dove20andr20da20qui397864"><a name="Le divergenze di mercato si stanno intensificando; dove andrà da qui?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le divergenze di mercato si stanno intensificando; dove andrà da qui?</h2><p>L’attuale outlook di mercato per SHIB mostra una chiara divergenza. Alcuni analisti avvertono che il settore delle monete meme nel suo complesso sta mostrando segni di affaticamento, con sia SHIB che DOGE che mostrano “segni di affaticamento” e un indebolimento dell’interesse da parte dei rivenditori.</p>
<p>I dati di IntoTheBlock mostrano che 50.590 indirizzi hanno acquistato 45,78 trilioni di SHIB nella fascia di prezzo da $0,000023 a $0,000025, con un costo medio di $0,000024. La competizione tra tori e orsi a questo punto di prezzo chiave determinerà la direzione a breve termine.</p>
<p>Tuttavia, la comunità SHIB “ShibArmy” mantiene ancora un alto livello di attività. L’argomento #SHIBMemes su Twitter guida i clic rispetto ad altre monete meme, e sebbene le discussioni su Reddit e Discord siano diminuite, mantengono comunque un livello base di entusiasmo.</p>
<h2 id="h2-Prospettive20e20Strategia697113"><a name="Prospettive e Strategia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive e Strategia</h2><p><a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> è in un momento critico. A breve termine, è essenziale concentrarsi sulla situazione di breakout al livello di supporto di $0.0000125 e al livello di resistenza di $0.0000140. Se la resistenza viene superata con un volume di scambi aumentato, potrebbe avviare un nuovo ciclo di movimento del mercato.</p>
<p>Per i detentori di diversi stili di investimento:</p>
<ul>
<li>Nuovi investitori: Si consiglia di adottare una strategia di prova e errore su piccola scala, assegnando non più dell’1%-2% dei fondi inattivi a SHIB, accumulando gradualmente posizioni nei livelli di supporto chiave e impostando ordini di stop-loss rigorosi.</li><li>Detentori a lungo termine: è possibile effettuare un’accumulazione moderata nella fascia di 0,0000120-0,0000125 USD, prestando attenzione ai progressi della rete Shibarium Layer 2 e ai segnali di miglioramento fondamentale nell’ecosistema NFT.</li></ul>
<p>Il metrica MVRV di Santiment mostra che SHIB è gravemente sottovalutato. Sebbene l’aspetto tecnico sia ribassista, il numero di detentori on-chain ha raggiunto un nuovo massimo e la divergenza di mercato suggerisce che la volatilità potrebbe intensificarsi. Il volume di scambi in diminuzione e la ridotta attività delle balene indicano che il mercato è in modalità di attesa, in attesa che emergano nuovi catalizzatori.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui presente non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o di una parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="5">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>