U2hpYmEgSW51IE5pZXV3czogV2FsdmlzYWN0aXZpdGVpdCBzdGlqZ3QgdGVyd2lqbCA2LDUgVHJpbGxpb24gU0hJQiBuYWFyIGRlIGJldXJzIHdvcmR0IHZlcnBsYWF0c3Q=

2025-06-09, 07:23

<p><img src="https://gimg2.gateimg.com/image/shib202506091521048721379427.png" alt="">
</p><p>De <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a> is tumultueus, en achter een reeks astronomische SHIB-transfers, is het een verkoop signaal van walvissen of routine operaties door markt makers?</p>
<p>In de afgelopen 24 uur is er meer dan 80 miljoen dollar aan 6,59 biljoen SHIB overgemaakt van een mysterieuze portemonnee naar een gecentraliseerde beurs, wat voor opschudding heeft gezorgd in de crypto-gemeenschap.</p>
<p>Het blockchain-trackingplatform Whale Alert heeft continu drie grote overboekingen van meer dan 20 biljoen SHIB gevolgd, allemaal bestemd voor Coinbase Institutional. Gegevens tonen aan dat het verzendadres “0x2E2A” deze batch grote overboekingen naar het Coinbase-bewaarportemonnee adres “0x46E5” heeft voltooid.</p>
<p>Dit is geen geïsoleerd voorval. Ongeveer 7,5 biljoen hebben deze week plaatsgevonden. <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> Deze activa die naar Coinbase Institutional stromen, zijn allemaal afkomstig van BitGo bewakingsrekeningen.</p>
<h2 id="h2-Walvis20ontwaakt20enorme20SHIB20fluctuatie163563"><a name="Walvis ontwaakt, enorme SHIB fluctuatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Walvis ontwaakt, enorme SHIB fluctuatie</h2><p>De blockchainwereld kent nooit een tekort aan dramatische momenten. Begin juni zorgden een reeks astronomische SHIB-transfers ervoor dat de hele cryptocommunity ademloos was. Binnen 24 uur werd 3,2 biljoen SHIB ter waarde van 43,6 miljoen USD overgemaakt naar een Coinbase-institutionele portemonnee.</p>
<p>Diepgaand onderzoek onthult een deel van het mysterie: deze verzendadressen zijn niet helemaal “onbekend”, maar zijn geassocieerd met de bekende market maker Wintermute. Belangrijker nog, dit is slechts de top van de ijsberg.</p>
<p>Wintermute heeft in totaal 650 biljoen SHIB (ter waarde van 80,2 miljoen USD) en 32.650 ETH (ter waarde van 82,38 miljoen USD) binnen 24 uur overgedragen. Alle activa kwamen van BitGo-bewaardersaccounts, en industrie-insiders analyseren dat het mogelijk een routineoperatie is voor market makers om hun posities aan te passen.</p>
<p>Een andere inactieve wallet “0x6E45” die drie jaar lang niet actief is geweest, is plotseling wakker geworden, heeft 10 miljard SHIB naar Binance overgemaakt en $311.000 opgenomen. Als dit adres verkoopt op de historische piek van SHIB ($0.00008845), zou de theoretische winst $2,7 miljoen kunnen bereiken.</p>
<h2 id="h2-De20markprestaties20zijn20zwak20en20belangrijke20steunniveaus20staan20onder20druk864875"><a name="De markprestaties zijn zwak en belangrijke steunniveaus staan onder druk." class="reference-link"></a><span class="header-link octicon octicon-link"></span>De markprestaties zijn zwak en belangrijke steunniveaus staan onder druk.</h2><p>Ondanks frequente on-chain bewegingen lijkt de marktprestaties van SHIB nog steeds traag. Op het moment van schrijven, <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">SHIB prijs</a> Prijs: 0,00001223 USD, daling in 24 uur: 4,33%, de daling sinds begin van het jaar is uitgebreid tot 42,14%.</p>
<p>Het technische aspect toont een touwtrekwedstrijd tussen stieren en beren:</p>
<ul>
<li>Het 50-daags voortschrijdend gemiddelde staat op 0,0000139 USD, en de huidige prijs ligt eronder.</li><li>Het 200-daags voortschrijdend gemiddelde vormt een medium tot lange termijn weerstandsniveau, gelegen op 0.0000160 USD.</li><li>Het handelsvolume blijft afnemen sinds de piek begin mei.</li></ul>
<p>Belangrijke posities zijn het onderwerp geworden van lange en korte strijd. Als de prijs kan stabiliseren op 0.0000125 en door de weerstand van 0.0000140 breekt, kan dit een nieuwe golf van kopen triggeren; omgekeerd, als het niet lukt om de ondersteuning van 0.0000125 vast te houden, kan dit ruimte openen om te vallen naar 0.0000100.</p>
<h2 id="h2-Positieve20signalen20komen20naar20voren855638"><a name="Positieve signalen komen naar voren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Positieve signalen komen naar voren</h2><p>Onder de schijnbaar traag bewegende oppervlakte komen er verschillende positieve signalen stilletjes naar voren.</p>
<p>Het aantal on-chain houders heeft een historisch hoogtepunt bereikt van 1.510.290 portefeuilles, een stijging van bijna 3 miljoen sinds eind mei. De uitbreiding van de houdersbasis biedt een solidere gemeenschapsbasis voor SHIB.</p>
<p>De tokenverbrandingssnelheid is recentelijk enorm gestegen. Gegevens tonen aan dat in de afgelopen 24 uur de SHIB-verbrandingssnelheid met 863,58% is toegenomen, met een totaal van 107.081.056 verbrande tokens, en een cumulatieve verbranding van 368.456.226 tokens afgelopen week. Dit deflatoire mechanisme verhoogt de schaarste door de circulerende voorraad te verminderen, wat de aanbod-vraagrelatie op de lange termijn kan verbeteren.</p>
<p>Het rapport van het on-chain analyticsbedrijf Santiment brengt meer optimistische verwachtingen. De MVRV-ratio van SHIB is gedaald naar -19,1%, het laagste onder de mainstream cryptocurrencies, wat aangeeft dat het ernstig ondergewaardeerd is en een hogere waarschijnlijkheid heeft op een kortetermijnherstel.</p>
<h2 id="h2-De20marktdivergenties20nemen20toe20waar20zal20het20vanaf20hier20naartoe20gaan418731"><a name="De marktdivergenties nemen toe; waar zal het vanaf hier naartoe gaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De marktdivergenties nemen toe; waar zal het vanaf hier naartoe gaan?</h2><p>De huidige marktomgeving voor SHIB toont een duidelijke divergentie. Sommige analisten waarschuwen dat de meme coin-sector als geheel tekenen van vermoeidheid vertoont, met zowel SHIB als DOGE die “vermoeidheidssignalen” vertonen en de belangstelling van detailhandelaren afneemt.</p>
<p>De gegevens van IntoTheBlock tonen aan dat 50.590 adressen 45,78 biljoen SHIB hebben gekocht in de prijsklasse van $0,000023 tot $0,000025, met een gemiddelde kostprijs van $0,000024. De concurrentie tussen stieren en beren op dit belangrijke prijsniveau zal de kortetermijndirection bepalen.</p>
<p>Desondanks blijft de SHIB-gemeenschap “ShibArmy” een hoog niveau van activiteit behouden. Het onderwerp #SHIBMemes op Twitter leidt in klikken vergeleken met andere meme coins, en hoewel de discussies op Reddit en Discord zijn afgenomen, behouden ze nog steeds een basisniveau van enthousiasme.</p>
<h2 id="h2-Uitzicht20en20Strategie222235"><a name="Uitzicht en Strategie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uitzicht en Strategie</h2><p><a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> bevindt zich op een kritiek keerpunt. Op de korte termijn is het essentieel om te focussen op de doorbraaksituatie op het ondersteuningsniveau van $0.0000125 en het weerstandsniveau van $0.0000140. Als de weerstand succesvol wordt doorbroken met een toegenomen handelsvolume, kan dit een nieuwe ronde van marktbeweging inluiden.</p>
<p>Voor houders van verschillende investeringsstijlen:</p>
<ul>
<li>Nieuwe investeerders: Het wordt aanbevolen om een kleinschalige trial-and-error strategie te hanteren, niet meer dan 1%-2% van idle fondsen aan SHIB toe te wijzen, geleidelijk posities op te bouwen op belangrijke ondersteuningsniveaus en strikte stop-loss orders in te stellen.</li><li>Langdurige houders: er kan gematigde accumulatie plaatsvinden in het bereik van 0,0000120-0,0000125 USD, terwijl er aandacht wordt besteed aan de voortgang van het Shibarium Layer 2-netwerk en signalen van fundamentele verbetering in het NFT-ecosysteem.</li></ul>
<p>De MVRV-metric van Santiment toont aan dat SHIB ernstig ondergewaardeerd is. Hoewel het technische aspect bearish is, heeft het aantal on-chain houders een nieuw hoogtepunt bereikt, en de marktdivergentie suggereert dat de volatiliteit kan toenemen. Het krimpende handelsvolume en de verminderde activiteit van Walvissen geven aan dat de markt in een afwachtende modus verkeert, wachtend op nieuwe katalysatoren die naar voren kunnen komen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbieding, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <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>