V2F0IGlzIGVyIGdlYmV1cmQgbWV0IE1BTlRSQSAoJE9NKT8=

<p>MANTRA ($OM) is een Layer-1 blockchainproject voor het tokeniseren van real-world assets (RWA), dat van een sterproject naar het absolute nulpunt is gezakt. Sinds het einde van 2023 is de prijs van $OM met 200 keer gestegen, maar in slechts één dag in april 2025 kelderde de prijs met meer dan 90%, waardoor miljarden dollars aan marktwaarde verloren gingen. Dit retrospectieve artikel zal analyseren hoe het vermoedelijke ‘Rug Pull’-incident van $OM stap voor stap plaatsvond - van manipulatief tokenomics-ontwerp, airdrop-routines, tot de kettingreactie veroorzaakt door marktverpletterende verkopen. We zullen ook bekende cryptocurrency-rampen bespreken zoals de ‘Squid Game’-zwendel en <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> LUNA-crash) ter vergelijking en vat de belangrijke ervaring samen die investeerders zouden moeten leren: hoe ze hoog geconcentreerd aanbod, verdachte prijsstijgingen en andere rode vlag-signalen kunnen identificeren.</p>
<h2 id="h2-OMs20200x20stijging20Q42020232020Q1202025775345"><a name="OM’s 200x stijging (Q4 2023 - Q1 2025)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>OM’s 200x stijging (Q4 2023 - Q1 2025)</h2><p>Tegen het einde van 2023 was de handelsprijs van $OM slechts een paar cent, met een dieptepunt van $0.017 in oktober 2023. Echter, in de daaropvolgende 18 maanden maakte $OM een parabolische stijging door. Begin 2025 was de token gestegen naar bijna $9.00, meer dan 400 keer hoger dan het historische dieptepunt (ongeveer 200 keer hoger dan de prijs in Q4 2023), wat sterke aandacht trok in de cryptogemeenschap.</p>
<p>Verschillende belangrijke factoren hebben deze stijging aangedreven:<br>-<br><strong>RWA frenzy and grote partnerschappen:</strong> MANTRA positioneert zichzelf als een belangrijke speler in de tokenisatie van echte activa, door zelfs een $1 miljard tokenisatiepartnerschap met de DAMAC Groep in Dubai in het begin van 2024 te bereiken en de Dubai VARA-licentie te verkrijgen. Deze ontwikkelingen hebben het bekrachtigd en een grote hoeveelheid speculatief kapitaal aangetrokken.</p>
<p><strong>Airdrop incentives en lock-up beloningen:</strong> In het midden van 2024 kondigde MANTRA een ‘Genesis Airdrop’ aan van 50 miljoen $OM-tokens aan vroege gebruikers en NFT-houders. Deze belofte van ‘gratis munten’ trok gebruikers aan om in te stappen en $OM over te brengen naar het nieuwe mainnet van MANTRA (gelanceerd in 2024), terwijl ze een groot aantal circulerende tokens vastzetten.<br>-<br><strong>Aanbodtekort en FOMO:</strong> Tegen het einde van 2024 werd de airdrop herhaaldelijk uitgesteld en de 50 miljoen airdropped tokens zijn nooit op de markt gekomen. Ondertussen verhoogde MANTRA in oktober 2024 de totale voorraad $OM van 8,88 miljard naar 17,8 miljard, en stapte over naar een jaarlijks inflatiemodel van 8%. Ondanks de nominale voorraadverhoging bleven de daadwerkelijk beschikbare tokens schaars, waardoor het onevenwicht tussen vraag en aanbod verder werd verergerd. $OM steeg van $1 naar meer dan $3 en brak in februari 2025 kort door de $8,99, met een marktkapitalisatie van tientallen miljarden dollars.</p>
<p><strong>Marktmakerhandel Twijfels:</strong> De gemeenschap is begonnen te twijfelen of deze stijgende trend echt is. Sommige handelaren hebben abnormale orderdiepte en transactiegedrag opgemerkt, waarbij ze vermoeden dat market makers de markt achter de schermen controleren. Met de kennis van nu, <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Prijs trend</a> Bijna ‘te perfect’, lineair omhoog, waardoor mensen vermoeden dat insiders de markt aansturen.<br><img src="https://gimg2.gateimg.com/image/article/17446397951.png" alt=""><br>Illustratie: $OM tussen oktober 2023 en april 2025 <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Prijs trend</a> Van het stijgen naar $9 van minder dan $0.02, om vervolgens te dalen naar $0.5. Deze 200-voudige stijging gevolgd door een onmiddellijke ineenstorting is zeldzaam voor een ogenschijnlijk ‘legitiem’ project, waaruit blijkt hoe de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> snel schakelt tussen razernij en paniek.</p>
<p>Tegen het voorjaar van 2025 was de papieren waarde van $OM omhooggeschoten en hadden veel vroege houders “financiële vrijheid” bereikt (althans op papier). Echter, onder de oppervlakte was er een stille crisis aan de gang: walvisportefeuilles controleerden het overgrote deel van het aanbod en de langverwachte luchtdrop was nog steeds nergens te bekennen. Deze factoren kwamen uiteindelijk tot uiting in de ramp die bekend staat als de “MANTRA Collapse” op 13 april 2025.</p>
<h2 id="h2-9020Crash20Volledige20Review20Hoofdoorzaken20en20Tijdlijn358222"><a name="90% Crash Volledige Review: Hoofdoorzaken en Tijdlijn" class="reference-link"></a><span class="header-link octicon octicon-link"></span>90% Crash Volledige Review: Hoofdoorzaken en Tijdlijn</h2><h2 id="h2-Op201320april20202520is20OM20in20slechts20een20paar20uur20met20meer20dan209020gedaald20van2063020naar20ongeveer2004020waardoor20een20marktwaarde20van20meer20dan20520miljard20USD20verdampt20De20snelle20ineenstorting20en20diepe20daling20hebben20verdenkingen20van20rug20pull20of20insider20verkoop20doen20rijzen20ondanks20de20bewering20van20het20team20van20een20andere20reden20De20volgende20zijn20de20kernfactoren20die20hebben20geleid20tot20deze20catastrofale20OM20verkoop201321"><a name="Op 13 april 2025 is $OM in slechts een paar uur met meer dan 90% gedaald, van $6,30 naar ongeveer $0,40, waardoor een marktwaarde van meer dan 5 miljard USD verdampt. De snelle ineenstorting en diepe daling hebben verdenkingen van ‘rug pull’ of insider verkoop doen rijzen, ondanks de bewering van het team van een andere reden. De volgende zijn de kernfactoren die hebben geleid tot deze ‘catastrofale $OM verkoop’:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Op 13 april 2025 is $OM in slechts een paar uur met meer dan 90% gedaald, van $6,30 naar ongeveer $0,40, waardoor een marktwaarde van meer dan 5 miljard USD verdampt. De snelle ineenstorting en diepe daling hebben verdenkingen van ‘rug pull’ of insider verkoop doen rijzen, ondanks de bewering van het team van een andere reden. De volgende zijn de kernfactoren die hebben geleid tot deze ‘catastrofale $OM verkoop’:</h2><p><strong>Team/insider controleert 90% van de circulatie:</strong> Een van de grootste problemen met $OM is de extreme centralisatie van de token. On-chain data laat zien dat het MANTRA-kernsteam ongeveer 90% van de circulerende tokens controleert, waarbij de top 100 adressen meer dan 99% vasthouden. Deze structuur stelt een paar mensen in staat om op elk moment te dumpen, terwijl het ook de publieke circulatie beperkt, wat bevorderlijk is voor speculatieve prijsstijgingen. Hoewel de gemeenschap al lange tijd sceptisch is (sommigen noemen het ‘een van de grootste scams’), heeft het team niet positief gereageerd.</p>
<h2 id="h2-20strongTokenomics20Changes20and20Airdrop20Delays20strong20In20oktober20202420verdubbelde20het20project20stilletjes20de20totale20voorraad20en20introduceerde20het20een20inflatiemechanisme20Deze20stap20bijna20onopgemerkt20tijdens20de20bullish20markt20destijds20reserveerde20een20groot20aantal20tokens20voor20het20team20Tegelijkertijd20is20de20oorspronkelijk20geplande205020miljoen20airdrop20voor20Q120202520meerdere20keren20uitgesteld20en20gewijzigd20naar201020beschikbaar20in20maart20202520waarbij20de20rest20is20uitgesteld20tot20202720Dit20de20maan20beloven20gedrag20verlengt20de20vrijgave20van20voorraad20met20behoud20van20de20prijs20op20een20hoog20niveau789972"><a name="- <strong>Tokenomics Changes and Airdrop Delays: </strong> In oktober 2024 verdubbelde het project stilletjes de totale voorraad en introduceerde het een inflatiemechanisme. Deze stap, bijna onopgemerkt tijdens de bullish markt destijds, reserveerde een groot aantal tokens voor het team. Tegelijkertijd is de oorspronkelijk geplande 50 miljoen airdrop voor Q1 2025 meerdere keren uitgesteld en gewijzigd naar 10% beschikbaar in maart 2025, waarbij de rest is uitgesteld tot 2027. Dit ‘de maan beloven’ gedrag verlengt de vrijgave van voorraad, met behoud van de prijs op een hoog niveau." class="reference-link"></a><span class="header-link octicon octicon-link"></span>- <strong>Tokenomics Changes and Airdrop Delays: </strong> In oktober 2024 verdubbelde het project stilletjes de totale voorraad en introduceerde het een inflatiemechanisme. Deze stap, bijna onopgemerkt tijdens de bullish markt destijds, reserveerde een groot aantal tokens voor het team. Tegelijkertijd is de oorspronkelijk geplande 50 miljoen airdrop voor Q1 2025 meerdere keren uitgesteld en gewijzigd naar 10% beschikbaar in maart 2025, waarbij de rest is uitgesteld tot 2027. Dit ‘de maan beloven’ gedrag verlengt de vrijgave van voorraad, met behoud van de prijs op een hoog niveau.</h2><p><strong>Marktmakers opereren en voeren transacties buiten de beurs uit:</strong> Meerdere analisten noemden $OM <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Prijs trend</a> Wordt gemanipuleerd door market makers. Het afgelopen jaar is de grafiektrend soepel geweest met kleine schommelingen, waarvan wordt vermoed dat er menselijke tussenkomst is. Tegelijkertijd zijn er meldingen dat het team tokens verkoopt aan grote houders via OTC met 50% korting, waardoor ze kunnen arbitreren tegen een hoge prijs op de openbare markt.</p>
<h2 id="h2-strongWeekend20liquiditeitsdroogtestrong20De20crash20vond20plaats20tijdens20het20weekend20wat20betekent20dat20er20een20extreem20lage20handelsliquiditeit20is20en20er20weinig20marktkooporders20zijn20Wanneer20er20een20grote20hoeveelheid20verkooporders20verschijnt20daalt20de20prijs20zonder20enige20ondersteuning20wat20leidt20tot20een20directe20daling20Stoploss20orders20worden20voortdurend20geactiveerd20wat20weer20leidt20tot20paniekverkoop609802"><a name="<strong>Weekend liquiditeitsdroogte:</strong> De crash vond plaats tijdens het weekend, wat betekent dat er een extreem lage handelsliquiditeit is en er weinig marktkooporders zijn. Wanneer er een grote hoeveelheid verkooporders verschijnt, daalt de prijs zonder enige ondersteuning, wat leidt tot een directe daling. Stop-loss orders worden voortdurend geactiveerd, wat weer leidt tot paniekverkoop." class="reference-link"></a><span class="header-link octicon octicon-link"></span><strong>Weekend liquiditeitsdroogte:</strong> De crash vond plaats tijdens het weekend, wat betekent dat er een extreem lage handelsliquiditeit is en er weinig marktkooporders zijn. Wanneer er een grote hoeveelheid verkooporders verschijnt, daalt de prijs zonder enige ondersteuning, wat leidt tot een directe daling. Stop-loss orders worden voortdurend geactiveerd, wat weer leidt tot paniekverkoop.</h2><p><strong>OKX verkoopincident (trigger):</strong> Op de dag voor de marktcrash toonde on-chain analyse aan dat een interne portemonnee ongeveer 3,9 miljoen $OM (ter waarde van ongeveer $25 miljoen) naar OKX overmaakte, gevolgd door bijna continu de verkoop van bijna 4 miljoen munten, wat paniek veroorzaakte. Dit evenement is waarschijnlijk de druppel die de emmer deed overlopen op de markt. Een paar dagen eerder waren ook 5 miljoen $OM ontgrendeld en op de markt gekomen.</p>
<p><strong>Paniek en liquidatie kettingreactie:</strong> Naarmate de prijs kelderde, begonnen ook vroege grote houders die tegen een lage prijs via OTC kochten geld te verliezen en gedwongen te stoppen met verlies en te vluchten. Sommige investeerders gebruikten leverage om $OM te kopen. Toen de prijs onder de liquidatielijn daalde, werd het systeem automatisch geliquideerd, waardoor er verdere verkoopdruk ontstond. In totaal werd er in één dag $75,9 miljoen aan $OM-derivaten geliquideerd.</p>
<p><strong>Inflow van beursfonds en beschuldigingen van Rug Pull:</strong> Meerdere walvissen hebben $OM overgedragen aan gecentraliseerde beurzen vóór de crash, wat meestal wijst op een dreigende dump. De gemeenschap bekritiseerde het team ervoor dat ze opzettelijk geld opnamen en wegrenden, en noemde het de ‘grootste oplichting sinds LUNA/FTX.’ Hoewel het projectteam het ontkende en het toeschreef aan ‘walvissen die geliquideerd werden op CEX,’ is het publiek niet overtuigd.<br><img src="https://gimg2.gateimg.com/image/article/17446401252.png" alt=""><br>Illustratie: Op 13 april 2025 daalde $OM van $6,12 naar $0,37 op Binance, waarbij in slechts vier uur meer dan 90% verdampte. De enorme rode handelsvolumebalk in de grafiek geeft de intensiteit van de verkoopdruk aan en de kwetsbaarheid van het orderboek, benaderend van de standaardzaak van een ‘Rug Pull’ op topniveau.</p>
<p>Het projectteam ontkende vervolgens dat ze verkochten, en beweerde dat de holdings van het team onveranderd bleven, en gaf een verklaring op Telegram waarin stond dat externe ‘overmacht’ dit veroorzaakte. Echter, gezien de eerdere tekenen van zeer gecentraliseerde tokens, vertraagde airdrops en geldinstromen op de keten, zien de meeste mensen het nog steeds als een gepland ontsnappingsgebeurtenis.</p>
<h2 id="h2-Vergelijking20met20historische20cryptorampen20SQUID20LUNA20enz335310"><a name="Vergelijking met historische crypto-rampen (SQUID, LUNA, enz.)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vergelijking met historische crypto-rampen (SQUID, LUNA, enz.)</h2><h2 id="h2-De20snelheid20en20omvang20van20de20ineenstorting20van20de20MANTRAtoken20riepen20snel20associaties20op20met20verschillende20beroemde20cryptorampen20Sommige20ervaren20handelaren20wezen20erop20dat20de20opkomst20en20ineenstorting20van20OM20zeer20vergelijkbaar20zijn20met20de20volgende20gebeurtenissen519195"><a name="De snelheid en omvang van de ineenstorting van de MANTRA-token riepen snel associaties op met verschillende beroemde crypto-rampen. Sommige ervaren handelaren wezen erop dat de opkomst en ineenstorting van OM zeer vergelijkbaar zijn met de volgende gebeurtenissen:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De snelheid en omvang van de ineenstorting van de MANTRA-token riepen snel associaties op met verschillende beroemde crypto-rampen. Sommige ervaren handelaren wezen erop dat de opkomst en ineenstorting van OM zeer vergelijkbaar zijn met de volgende gebeurtenissen:</h2><p><strong>Squid Coin (SQUID) Rug Pull (2021):</strong> De situatie die het meest lijkt op OM is de ‘Squid Coin’-zwendel van 2021. SQUID is een imitatiecoin die op de markt is gebracht met een populaire serie, waarvan de prijs in enkele dagen met meer dan 40.000% steeg en piekte op bijna $2.860. Echter, het ontwikkelingsteam heeft snel de liquiditeit weggenomen, waardoor de prijs bijna naar nul daalde in enkele minuten, waarbij investeerders toekeken hoe de token van meer dan $2.800 naar $0.005 kelderde. Hoewel OM niet naar nul is gedaald (zakte tot ongeveer $0.37), is de structuur van verticale stijging gevolgd door een plotselinge ineenstorting zeer vergelijkbaar. Beide hebben sterk geconcentreerde tokenposities en situaties waarin tokens worden gedumpt wanneer de liquiditeit laag is. Het grootste verschil tussen OM en SQUID is dat MANTRA lijkt te zijn een ‘legitiem project’ met een echt team en echte partnerschapsrecords, waardoor de ineenstorting nog schokkender is.</p>
<p><strong><a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> LUNA Crash (mei 2022):</strong> Een andere veelgenoemde vergelijking is <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Na de ineenstorting van het stablecoin-mechanisme kelderde de prijs van LUNA in enkele dagen met meer dan 99%. Na de initiële crash was er een korte opleving (bekend als een ‘dead cat bounce’), maar het bleef dalen, waarbij veel bodemvissers werden ingesloten. Op vergelijkbare wijze veerde ook OM op van $0.37 naar $1.10 de dag na de crash (een stijging van 200%), maar daalde vervolgens met meer dan 92% vanaf het hoogtepunt. Grafiekanalisten wijzen erop dat dergelijke oplevingen vaak voorkomen in de late stadia van een crash, maar meestal valstrikken zijn. De huidige opwaartse trend van OM zwakt geleidelijk af, waarschijnlijk om het tragische lot van LUNA te herhalen. Bovendien heeft de ‘schandaalachtige sfeer’ rond MANTRA woede opgewekt, waarbij de publieke eis voor regulering en liquidatie na de LUNA-crash van jaren geleden weerklinkt. Hoewel OM niet instortte door een algoritme-falen, is de resulterende verdamping van miljarden dollars vergelijkbaar met de catastrofale gevolgen van LUNA.</p>
<p>Bovendien zijn er ook glen zoals de ineenstorting van BitConnect in 2018 (een typische Ponzi-schema-munt) en de ineenstorting van FTX/FTT in 2022, die beide één ding illustreren: als de prijs van een token ernstig opgeblazen is en gecontroleerd wordt door enkelen, dan is een ineenstorting vaak slechts een kwestie van tijd. Hoewel OM al meer dan twee jaar actief is en partners en middelen heeft, kan het toch niet aan een tragedie ontsnappen en wordt het een ander voorbeeldverhaal.</p>
<h2 id="h2-Investeerder20Ervaring20Samenvatting20Hoe20Potentile20Rode20Vlaggen20te20Identificeren974"><a name="Investeerder Ervaring Samenvatting: Hoe Potentiële Rode Vlaggen te Identificeren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Investeerder Ervaring Samenvatting: Hoe Potentiële Rode Vlaggen te Identificeren</h2><p>Voor investeerders die nog aan de zijlijn staan of al in de ‘landmijn’ zijn gestapt, heeft het OM-incident een diepgaande waarschuwing gebracht. Hoewel het achteraf gemakkelijk is om te beoordelen, zijn er eigenlijk veel vroege signalen die kunnen worden geïdentificeerd. Hier zijn typische ‘rode vlaggen’ en suggesties die de moeite waard zijn om op te letten:</p>
<h2 id="h2-strongToken20holding20structure20met20overmatige20concentratiestrong20Het20is20cruciaal20om20de20tokenverdeling20onchain20te20bekijken20De20top2010020adressen20van20OM20hebben20tot20wel209920van20het20aanbod20in20handen20wat20buitengewoon20ongezond20is20Wanneer20het20merendeel20van20de20tokens20in20handen20is20van20een20zeer20klein20aantal20mensen20174464082142545920In20feite20worden20ze20over20het20algemeen20gecontroleerd20Over20het20algemeen20zouden20gezonde20projecten20dergelijke20structurele20risicos20moeten20vermijden532739"><a name="<strong>Token holding structure met overmatige concentratie:</strong> Het is cruciaal om de tokenverdeling on-chain te bekijken. De top 100 adressen van OM hebben tot wel 99% van het aanbod in handen, wat buitengewoon ongezond is. Wanneer het merendeel van de tokens in handen is van een zeer klein aantal mensen, {1744640821425459} In feite worden ze over het algemeen gecontroleerd. Over het algemeen zouden gezonde projecten dergelijke structurele risico’s moeten vermijden." class="reference-link"></a><span class="header-link octicon octicon-link"></span><strong>Token holding structure met overmatige concentratie:</strong> Het is cruciaal om de tokenverdeling on-chain te bekijken. De top 100 adressen van OM hebben tot wel 99% van het aanbod in handen, wat buitengewoon ongezond is. Wanneer het merendeel van de tokens in handen is van een zeer klein aantal mensen, {1744640821425459} In feite worden ze over het algemeen gecontroleerd. Over het algemeen zouden gezonde projecten dergelijke structurele risico’s moeten vermijden.</h2><p><strong>Plotse of ondoorzichtige tokenomische aanpassing:</strong> Als een project stilzwijgend zijn circulatie wijzigt en inflatiemechanismen introduceert, vooral wanneer niemand oplet tijdens een bullmarkt, is voorzichtigheid geboden. De eenmalige verdubbeling van de voorraad van MANTRA en de introductie van 8% jaarlijkse inflatie is een klassieke verdunningstactiek. Door te vragen ‘waarom nu de verandering?’ kan worden aangenomen dat de risico’s toenemen als het antwoord vaag is.</p>
<p><strong>Airdrops of het ontgrendelen van beloften worden herhaaldelijk vertraagd:</strong> Het herhaaldelijk uitstellen of veranderen van de regels na het beloven van een grote airdrop is een typisch ‘pompinstrument’. De 50 miljoen airdrop van MANTRA is meerdere malen uitgesteld, waardoor sommige gebruikers onterecht worden uitgesloten van deelname. Op korte termijn onderdrukt dit inderdaad de verkoopdruk, maar op de lange termijn ondermijnt het het vertrouwen ernstig.</p>
<p><strong>Prijs en handelsvolume abnormaal:</strong> De prijs van een gezond project zou moeten worden gekoppeld aan marktpopulariteit, samenwerking en technologische vooruitgang. Als er geen duidelijk goed nieuws is maar de prijs blijft stijgen en het handelsvolume ongewoon stabiel blijft, is er waarschijnlijk sprake van marktmanipulatie. De trend van OM is ‘te perfect’, bijna als een manipulatiesjabloon.<br><strong>Sleutelportemonnee overdrachten naar beurzen:</strong> Veel rug-pull-incidenten hebben gezien dat er grote hoeveelheden tokens naar beurzen stromen voordat ze plaatsvinden. Als je merkt dat de kernwallet of walvissenadres munten overmaakt naar Binance, OKX, etc., moet je onmiddellijk extra  zijn. Tools zoals Whale  kunnen worden gebruikt om dergelijke overdrachten te controleren.</p>
<p><strong>Lage liquiditeit of afhankelijkheid van een paar marktmakers:</strong> Als een valuta slechts een paar handelsparen heeft en een zwakke liquiditeit, kan een iets grotere verkoopdruk een <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">lawine</a>. OM is slechts zo’n g, waarbij zelfs wordt vermoed dat een deel van de liquiditeit door het team zelf wordt aangehouden. Zodra de marktmakers zich terugtrekken, daalt de prijs scherp.</p>
<p><strong>Lage transparantie in projectcommunicatie:</strong> Het is cruciaal voor het projectteam om open communicatie te hebben. MANTRA sloot de Telegram-groep in de vroege stadia van het incident en reageerde niet positief, wat zeer onprofessioneel was. Bovendien is de oprichter betrokken geweest bij juridische procedures in de rechtbank van Hong Kong, waar de meeste investeerders niet van op de hoogte zijn. Als de externe communicatie van het team negatief is of er een besmet verleden is, moet er voorzichtigheid worden betracht.</p>
<p><strong>Laat je niet misleiden door de ‘hitte’:</strong> Het ogenschijnlijk eindeloze verhaal (zoals RWA) betekent niet per se dat het project daadwerkelijk geland is. De verhaalverpakking van OM is goed, maar de daadwerkelijke on-chain activiteit is zeer laag. Telkens wanneer een bepaalde munt plotseling populair wordt en de community gek ‘alleen omhoog kan gaan’ verspreidt, is het zeer waarschijnlijk in de pompfase. Vermijd FOMO koste wat het kost, investeer nooit zwaar in een project dat uitsluitend wordt ondersteund door verhalen.</p>
<h2 id="h2-Conclusie604633"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Het verhaal van MANTRA $OM herinnert ons eraan: de cryptomarkt zit vol met wonderen en valkuilen. Een token dat uiteindelijk 200 keer steeg, daalde uiteindelijk meer dan 90% in slechts één dag, waardoor velen de hoogtepunten najagen met niets. Of deze crash te wijten was aan kwaadwillende manipulatie of een reeks slechte beslissingen, investeerders zijn uiteindelijk de slachtoffers.</p>
<p>Dit incident benadrukt nogmaals: zorg ervoor dat u voldoende due diligence uitvoert, neem nooit een project licht op. In de cryptowereld is ‘pump and dump’ vaak de voorbode van een ‘scherpe daling’.</p>
<p>De vraag ‘Wat is er gebeurd met MANTRA ($OM)’ is eigenlijk een herinnering aan risicobeheer in de hele crypto-industrie. Het omvat bijna alle mogelijke problemen: gecentraliseerde controle, manipulatie van de token-economie, verkopen in het weekend, leverage crashes… In de toekomst, als vergelijkbare signalen zich opnieuw voordoen, kunnen we hopelijk leren van dit evenement en voorkomen dat we de volgende ‘bagholder’ worden.</p>
<p>Vriendelijke herinnering: DYOR (Do Your Own Research), haast je nooit blindelings naar de volgende ‘maanmunt’.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>China Z.</strong>Gate.io onderzoeker<div class="info-tips"><em>Dit artikel vertegenwoordigt alleen het standpunt van de auteur en vormt geen handelsadvies. Beleggen brengt risico's met zich mee, dus beslissingen dienen voorzichtig te 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 er juridische verantwoordelijkheden worden nagestreefd.<br></div><p></p><br></div></div></div>