TUFOVFJBIChPTSkgc3RvcnR0ZSA5MCUgaW46IFZlcnRyb3V3ZW5zY3Jpc2lzIG9mIE1hcmt0dmFsbGVuPw==

2025-04-14, 05:22

<p><img src="https://gimg2.gateimg.com/image/article/1744607951hot.png" alt=""></p>
<p>Op 13 april 2025 raasde er een grote storm door de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>: Het sterproject MANTRA (OM) token voor Real World Assets (RWA) is in slechts een paar uur gedaald van $6,3 naar $0,37, een daling van meer dan 90%, waarbij een marktwaarde van maar liefst $10 miljard verdampt. Deze plotselinge ineenstorting heeft een intens debat binnen de gemeenschap aangewakkerd, waarbij sommigen het team beschuldigen van ‘weglopen’ en anderen geloven dat het een ‘kwaadaardige liquidatie’ is door gecentraliseerde beurzen.</p>
<p>Achter de grote dump van MANTRA, is het interne projectletsel, marktvalstrik, of een andere waarschuwing in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> Dit artikel zal het incident reconstrueren, de redenen analyseren en de implicaties voor investeerders onderzoeken.</p>
<h2 id="h2-De20Opkomst20en20Hoogtepunten20van20MANTRA157522"><a name="De Opkomst en Hoogtepunten van MANTRA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Opkomst en Hoogtepunten van MANTRA</h2><p>MANTRA is een Layer 1 blockchain gebaseerd op Cosmos SDK, gewijd aan het tokeniseren van echte wereld activa en het verbinden ervan met DeFi. Sinds 2024 heeft het concept van RWA de cryptomarkt overspoeld, en MANTRA is het middelpunt geworden met partnerschappen met zwaargewichten zoals Google Cloud en Dubai DAMAC.</p>
<p>Its token OM steeg van 0,0158 USD aan het begin van het jaar tot een hoogtepunt van 9 USD gedurende het jaar, met een marktwaarde die ooit meer dan 8 miljard USD overschreed. Echter, achter de glorie, zijn er verborgen zorgen in de tokenomics van MANTRA: het team en vroege investeerders controleren bijna 90% van de 888 miljoen tokenvoorraad, en de gemeenschap heeft veel twijfels over de transparantie en de uitvoering van het lock-up plan.</p>
<h2 id="h2-Twee20het20hele20verhaal20van20de20grote20dump20miljarden20verdwenen20s20nachts826537"><a name="Twee, het hele verhaal van de grote dump: miljarden verdwenen ‘s nachts" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Twee, het hele verhaal van de grote dump: miljarden verdwenen ‘s nachts</h2><p>Op de avond van zondag 13 april (UTC) daalde de prijs van OM plotseling, tot een dieptepunt van $0,37, een daling van meer dan 90%. On-chain data toont aan dat het handelsvolume op gecentraliseerde beurzen die avond steeg, wat leidde tot marktpaniek door vermoedelijke grootschalige verkopen. De grote dump vond plaats tijdens een weekendperiode met lage liquiditeit, wat leidde tot een snelle versterking van marktreacties.</p>
<p>Vervolgens herstelde de prijs zich lichtjes tot ongeveer $1, maar het vertrouwen van beleggers is ernstig beschadigd. De omvang en snelheid van deze crash roepen onvermijdelijk herinneringen op aan de ineenstorting van <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> LUNA in 2022.</p>
<h2 id="h2-Drie20redenen20voor20de20grote20dump20Officile20vs20Community20Clash551595"><a name="Drie redenen voor de grote dump: Officiële vs. Community Clash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Drie redenen voor de grote dump: Officiële vs. Community Clash</h2><p>Het MANTRA-team reageerde snel, ontkende interne verkopen en gaf de ‘roekeloze gedwongen liquidatie’ van gecentraliseerde beurzen de schuld als de schuldige. Medeoprichter John Patrick Mullin verklaarde op X dat de tokens van het team nog steeds volgens het lock-up plan worden vastgehouden, de tokenomics onveranderd blijven en de grote dump beschreef als een ‘externe aanval’.</p>
<p>Echter is de gemeenschap niet volledig overtuigd. Uit on-chain analyse blijkt dat een portemonnee waarvan wordt vermoed dat deze aan het team gerelateerd is, 3,9 miljoen OM heeft gestort in OKX, wat speculatie over verkoop heeft veroorzaakt. Er zijn ook onbevestigde geruchten dat het team unilateraal de tokenvoorraad heeft verhoogd van 888 miljoen naar 1,78 miljard, zonder instemming van de gemeenschap, wat een vertrouwenscrisis heeft veroorzaakt.</p>
<p>Ook de woede van de gemeenschap is gericht op MANTRA’s langdurige problemen: oneerlijk stemsysteem, vertraagde plannen voor airdrops, zeer gecentraliseerde tokens, enzovoort. Sommige investeerders noemen het direct een ‘rug pull’ (wegrennen), terwijl supporters geloven dat de kerntechnologie van het team nog steeds aanwezig is, en de grote dump misschien het gevolg is van marktmanipulatie of het terugtrekken van de RWA-hype. Objectief gezien heeft de overwaardering en lage liquiditeit van OM ongetwijfeld het risico vergroot, en soortgelijke gebeurtenissen zijn niet ongewoon op de cryptomarkt.</p>
<h2 id="h2-Vier20Community20Split20en20Marktnasleep114795"><a name="Vier, Community Split en Marktnasleep" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vier, Community Split en Marktnasleep</h2><p>Na een grote dump is de MANTRA-gemeenschap verdeeld. Sommigen roepen het team op om de transparantie te vergroten en gedetailleerde fondsenstromen bekend te maken; anderen kiezen ervoor om de steun voort te zetten en hopen op een comeback van het project. Het team belooft een gemeenschapsdiscussie te houden op X en meer details te verstrekken om het vertrouwen te herstellen.</p>
<p>Echter heeft de impact van het incident zich uitgebreid buiten het project zelf. OM’s grote dump is veelvuldig vergeleken met <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> LUNA, herinnerend beleggers aan de kwetsbaarheid van high-risk tokens. Bovendien kan het sterk gecentraliseerde patroon van tokens regelgevende aandacht trekken, waardoor het alarm afgaat voor het bestuur van DeFi-projecten.</p>
<h2 id="h2-Vijf20inzichten20uit20de20Cryptocurrency20Markt386068"><a name="Vijf, inzichten uit de Cryptocurrency Markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vijf, inzichten uit de Cryptocurrency Markt</h2><p>De grote dump van MANTRA onthult verschillende waarheden over de cryptomarkt. Ten eerste is tokenomics de levensader van een project, hoge centralisatie en lage transparantie verbergen vaak risico’s. Ten tweede zijn markten met lage liquiditeit gemakkelijk te manipuleren, investeerders moeten op hun hoede zijn voor ‘zwarte zwaan’ gebeurtenissen.</p>
<p>Nogmaals, vertrouwen van de gemeenschap is cruciaal voor het voortbestaan van het project, en elke communicatiefout kan een sneeuwbaleffect veroorzaken. Voor gewone investeerders is de les van MANTRA: laat speculatie niet uw oordeel vertroebelen, onafhankelijk onderzoek, gediversifieerde investeringen en risicobeheersing zijn de manier om te overleven.</p>
<p>MANTRA (OM) grote dump is een complexe Crisis van Vertrouwen, verweven met marktvolatiliteit, bestuursconflicten en tests van gemeenschapsvertrouwen. Hoewel de prijs lichtjes is hersteld, heeft het project nog steeds tijd nodig om te verifiëren of het de gunst van investeerders kan terugwinnen.</p>
<p>De cryptomarkt heeft nooit aan drama ontbroken, en het verhaal van MANTRA is er slechts een van. Beleggers zouden ervan moeten leren en altijd rationeel en waakzaam moeten blijven terwijl ze kansen najagen.</p>
<div class="blog-details-info"><br> <div>Auteur: Rooick Z., Gate.io Onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen het standpunt van de auteur en vormt geen handelsadvies. Beleggen is riskant en beslissingen moeten zorgvuldig worden genomen.<br></em><div><em></em>Dit artikel is origineel en het auteursrecht behoort toe aan Gate.io. Geef de auteur en bron aan als u wilt herdrukken, anders zullen juridische verantwoordelijkheden worden nagestreefd.<br></div><p></p><br></div></div></div>