T00tdG9rZW4gZmxpdHNjcmFzaCA5MCUsIE1BTlRSQSdzIG9ubWlkZGVsbGlqa2Ugb25kZXJnYW5n

2025-04-14, 06:09

<p><img src="https://gimg2.gateimg.com/image/article/1744610714news.png" alt=""></p>
<h2 id="h2-Introductie671863"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Op 13 april 2025 werd de cryptowereld hard getroffen: MANTRA (OM) token stortte in van $6,3 naar $0,37 in slechts een paar uur, een daling van meer dan 90%, met een marktwaarde van miljarden die in het niets verdween.</p>
<p>Beleggers zijn geschokt, de gemeenschap is in rep en roer, en X platform is gevuld met woede, argwaan en wanhoop. Deze flash crash is als een plotselinge storm, die MANTRA genadeloos van de troon van RWA schitterende ster stoot. Is het het complot van de Gate? Verraad van het team? Of het meedogenloze oordeel van de markt? Laten we het centrum van deze cryptoramp betreden en op zoek gaan naar fragmenten van waarheid.</p>
<h2 id="h2-De20schittering20en20verborgen20zorgen20van20RWA20Star939670"><a name="De schittering en verborgen zorgen van RWA Star" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De schittering en verborgen zorgen van RWA Star</h2><p>MANTRA was ooit de lieveling van de 2024 <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> Als een Layer 1 blockchain gebaseerd op Cosmos SDK, markeert het de tokenisatie van echte wereldactiva (RWA), met de belofte om traditionele activa zoals onroerend goed en obligaties naar de DeFi-wereld te brengen. Samenwerkingen met Google Cloud, goedkeuringen van Dubai’s DAMAC Group, en zelfs vage geruchten met BlackRock hebben de OM-token een vurige achtervolging voor investeerders gemaakt.</p>
<p>Van een laagste punt van $0.0158 aan het begin van het jaar tot een piek van $9, steeg de marktwaarde van OM ooit tot meer dan 8 miljard USD. Echter, achter de welvaart, zijn er verborgen onderstromen: van de 8,88 miljard tokens wordt 90% gehouden door het team en vroege investeerders. Hoewel er een bekendgemaakt lock-up plan is, is het herhaaldelijk bekritiseerd vanwege onvoldoende transparantie. De ontevredenheid van de gemeenschap is als een tijdbom, stil wachtend om te exploderen.</p>
<h2 id="h2-Aftellen20naar20Doomsday20De20fatale20klap20van20een20Flash20Crash632331"><a name="Aftellen naar Doomsday: De fatale klap van een Flash Crash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aftellen naar Doomsday: De fatale klap van een Flash Crash</h2><p>Op de avond van zondag 13 april, de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptomarkt</a> zat in de luiheid van het weekend, maar OM stortte zonder enige waarschuwing in de afgrond. On-chain data toont aan dat op die avond OKX en Binance beurzen abnormale handelsvolumes ervaarden, met een onbekende portemonnee die 3,9 miljoen OM naar OKX overmaakte, gevolgd door een prijsdaling van $6,3 naar $0,37 als een sneeuw <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">lawine</a>, waardoor een marktwaardeverdamping van bijna $10 miljard ontstaat.</p>
<p>Paniek greep de markt, kleine beleggers keken hulpeloos toe terwijl hun rekeningsaldi werden weggevaagd, en Gate.io werd onmiddellijk overspoeld met berichten over de ‘OM-crash’. De periode van lage liquiditeit versterkte het verkoop-effect, het orderboek werd doorboord en de markt was in chaos. Enkele uren later worstelde de prijs om te herstellen tot ongeveer $1,3, maar de littekens konden niet worden uitgewist.</p>
<h2 id="h2-Wie20is20de20meesterbrein20achter20de20schermen20De20waarheid20is20ontwijkend863630"><a name="Wie is de meesterbrein achter de schermen? De waarheid is ontwijkend." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie is de meesterbrein achter de schermen? De waarheid is ontwijkend.</h2><p>Na de flash-crash stapte het MANTRA-team snel naar voren om verduidelijking te geven. Medeoprichter John Patrick Mullin beschuldigde woedend gecentraliseerde beurzen op X van ‘kwaadwillige gedwongen liquidatie’ die de markt vernietigde, waarbij werd benadrukt dat het team niet heeft verkocht en de tokens nog steeds worden aangehouden volgens het lock-up plan. Deze uitleg slaagde er echter niet in om de woede van de gemeenschap te temperen.</p>
<p>Keten-detectives hebben snel vermoedens blootgelegd: de 3,9 miljoen OM-portemonnee die naar OKX is overgeboekt, is nauw verbonden met het team, met een precieze timing die twijfels oproept. Wat nog verontrustender is, is het onbevestigde gerucht dat circuleert op X dat het team in het geheim de tokensupply heeft verhoogd van 888 miljoen naar 1,78 miljard, volledig omzeilend de gemeenschapsgovernance.</p>
<p>De kritiek van de gemeenschap is ook gericht op MANTRA’s ‘vorige record’: het airdrop-plan wordt herhaaldelijk vertraagd, het stemmechanisme wordt beschuldigd van manipulatie, en de tokenverdeling is zeer gecentraliseerd. Deze kwesties hebben investeerders al lang wantrouwend gemaakt, en de flash crash is slechts de lont.</p>
<p>Sommige mensen verdenken dat dit een zorgvuldig geplande ‘tapijt pull’ is, en roepen zelfs op tot regelgevend ingrijpen; maar er zijn ook stemmen die geloven dat de terugtrekking van de RWA-rage en de druk van overwaardering de echte boosdoeners zijn. De waarheid is nog steeds in nevelen gehuld, maar één ding is zeker: de hoge concentratie en fragiele liquiditeit van OM hebben de weg geplaveid voor deze ramp.</p>
<h2 id="h2-Het20gebrul20van20de20gemeenschap20en20het20gekraak20van20hoop874400"><a name="Het gebrul van de gemeenschap en het gekraak van hoop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het gebrul van de gemeenschap en het gekraak van hoop</h2><p>De flitscrash heeft het kruitvat van de gemeenschap doen ontbranden. Op het X-platform zijn de emoties van investeerders verschoven van schok naar woede. Een gebruiker schreef: “$20.000 geïnvesteerd, ‘s nachts achtergelaten met $2.000, MANTRA je bent me een uitleg verschuldigd!”</p>
<p>Aan de andere kant proberen voorstanders de situatie te stabiliseren: “Paniek niet, de technologie is er nog steeds, RWA is de toekomst, het team zal zich inzetten.” De gemeenschap is verdeeld in twee kampen: de ene kant eist dat het team alle portefeuilletransacties openbaar maakt, terwijl de andere kant vraagt om MANTRA tijd te geven. Historische kwesties zijn naar voren gebracht - zoals vertraagde luchtdrops en oneerlijk bestuur - waardoor elke reactie van het team aanvoelt als dansen op een koorddans.</p>
<p>MANTRA belooft een AMA te houden in X, meer on-chain gegevens bekend te maken en probeert het vertrouwen te herstellen. Echter, investeerders geloven niet langer gemakkelijk in mooie woorden. Een anoniem gemeenschapslid betreurde: ‘We jagen dromen na, maar eindigen in een val.’ Deze crisis test niet alleen MANTRA, maar werpt ook een schaduw op de geloofwaardigheid van de hele RWA-track.</p>
<h2 id="h2-De20volgende20LUNA20crisis20Het20kruispunt20van20de20industrie375456"><a name="De volgende LUNA crisis? Het kruispunt van de industrie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De volgende LUNA crisis? Het kruispunt van de industrie</h2><p>Het rimpel effect van OM flash crash verspreidt zich snel, waarbij de markt het koppelt aan 2022 <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> De flashcrash van LUNA wordt ermee vergeleken. Beide vertonen overeenkomsten: hoogwaardige concepten, sterk geconcentreerde tokens en fragiel marktvertrouwen. Een rapport van het crypto-dataplatform Messari toont aan dat de handelsvolume van RWA-tokens met 18% daalde na de flashcrash, waardoor het vertrouwen van investeerders aanzienlijk werd geschokt.</p>
<p>Analisten waarschuwen dat tokencentralisatie de fatale zwakte is van DeFi, een crisis vergelijkbaar met het OM-incident kan zich herhalen in andere projecten. Het diepgaandere effect ligt in de regelgeving: het OM-incident kan wereldwijde toezichthouders aansporen om de tokenverspreiding en bestuurlijke transparantie van DeFi-projecten opnieuw te onderzoeken.</p>
<p>Voor MANTRA is een flash crash een test van leven en dood. Als het team er niet in slaagt transparante verbintenissen na te komen, kan het project de volledige steun van de gemeenschap verliezen. Echter, als deze crisis kan worden gebruikt om governance te optimaliseren, kan het langetermijnpotentieel van RWA nog hoop hebben. Ongeacht de uitkomst, luidt deze crisis het alarm voor de cryptocurrency-industrie: vertrouwen is kostbaarder dan technologie.</p>
<h2 id="h2-Leren20van20het20puin20overlevingsgids20voor20investeerders961018"><a name="Leren van het puin: overlevingsgids voor investeerders" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Leren van het puin: overlevingsgids voor investeerders</h2><p>OM flash crash is een bloedige les, die elke crypto-speler eraan herinnert: er zijn geen eeuwige winnaars op de markt. Ten eerste is tokenomics het levensbloed van een project, concentratie en transparantie zijn rode lijnen. Ten tweede is lage liquiditeit een tijdbom, retailinvesteerders moeten oppassen voor de val van overgewaardeerde tokens. Ten derde is de stem van de gemeenschap een kompas, het negeren van de publieke opinie is je eigen graf graven.</p>
<p>Beleggers moeten leren om onafhankelijk onderzoek te doen, whitepapers te raadplegen, on-chain data en community discussies, in plaats van blindelings speculatie te volgen. Het diversifiëren van investeringen, het instellen van stop-loss orders en kalm blijven zijn de gouden regels om te overleven in de cryptocurrency jungle.</p>
<p>De flitscrash van MANTRA (OM) is een onafgemaakte drama. De plotselinge ineenstorting van een marktwaarde van honderd miljard blootstelt de kwetsbaarheid en waanzin van de cryptomarkt. Of het team vertrouwen kan herwinnen door acties, of de gemeenschap consensus kan vinden in verdeeldheid, of de markt kan groeien uit de geleerde lessen, het is nog steeds niet concluderend.</p>
<p>Maar voor investeerders is deze storm een wake-up call: voordat je de sterren en de zee achterna jaagt, zorg ervoor dat de boot onder je voeten stevig genoeg is.</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 enkel handelsadvies. Beleggen brengt risico's met zich mee, dus beslissingen moeten zorgvuldig worden genomen.<br></em><div><em></em>Deze inhoud is origineel en het auteursrecht behoort toe aan Gate.io. Gelieve de auteur en de bron te vermelden bij herdruk, anders zal er juridische verantwoordelijkheid worden nagestreefd.<br></div><p></p><br></div></div></div>