Q29zYSDDqCBzdWNjZXNzbyBhIE1BTlRSQSAoJE9NKT8=

<p>MANTRA ($OM) è un progetto blockchain di Livello 1 per la tokenizzazione di asset del mondo reale (RWA), che è crollato da un progetto stellare a un minimo storico durante la notte. Dall’inizio del 2023, il prezzo di $OM è aumentato di 200 volte, ma in un solo giorno di aprile 2025, il prezzo è crollato di oltre il 90%, cancellando miliardi di dollari di valore di mercato. Questo articolo retrospettivo analizzerà come si è svolto passo dopo passo il sospetto evento di ‘Rug Pull’ di $OM - dal design manipolativo dell’economia dei token, alle routine di distribuzione aerea, alla reazione a catena innescata dalle vendite di mercato devastanti. Discuteremo anche famosi disastri delle criptovalute come la truffa del ‘Squid Game’ e <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> crash LUNA) per confronto e riassumere l’esperienza importante che gli investitori dovrebbero imparare: come identificare un’offerta altamente concentrata, aumenti di prezzo sospetti e altri segnali di pericolo.</p>
<h2 id="h2-OMs20200x20surge20Q42020232020Q1202025647772"><a name="OM’s 200x surge (Q4 2023 - Q1 2025)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>OM’s 200x surge (Q4 2023 - Q1 2025)</h2><p>Entro la fine del 2023, il prezzo di trading di $OM era solo di pochi centesimi, raggiungendo un minimo di $0.017 nel ottobre 2023. Tuttavia, nei successivi 18 mesi, $OM ha vissuto una crescita parabolica. All’inizio del 2025, il token era salito a quasi $9.00, più di 400 volte più alto rispetto al suo minimo storico (circa 200 volte più alto rispetto al prezzo nel Q4 2023), attirando forte attenzione nella comunità crittografica.</p>
<p>Diversi fattori chiave hanno alimentato questo aumento:<br>-<br><strong>Frenesia RWA e partnership importanti:</strong> MANTRA si posiziona come un attore significativo nella tokenizzazione di asset del mondo reale, arrivando anche a una partnership di tokenizzazione da 1 miliardo di dollari con il DAMAC Group di Dubai all’inizio del 2024 e ottenendo la licenza VARA di Dubai. Questi sviluppi l’hanno avallata, attirando una grande quantità di capitale speculativo.</p>
<p><strong>Incentivi Airdrop e premi di blocco:</strong> A metà del 2024, MANTRA ha annunciato un ‘Genesis Airdrop’ di 50 milioni di token $OM agli utenti precoci e ai detentori di NFT. Questa promessa di ‘monete gratuite’ ha attirato gli utenti a partecipare e collegare $OM alla nuova mainnet di MANTRA (lanciata nel 2024), bloccando contemporaneamente una grande quantità di token in circolazione.<br>-<br><strong>Scarsità di offerta e FOMO:</strong> Entro la fine del 2024, la distribuzione aerea è stata ripetutamente ritardata e i 50 milioni di token distribuiti gratuitamente non sono mai entrati nel mercato. Nel frattempo, nell’ottobre 2024, MANTRA ha aumentato l’offerta totale di $OM da 8,88 miliardi a 17,8 miliardi e ha adottato un modello di inflazione annuale dell’8%. Nonostante l’aumento nominale dell’offerta, i token effettivamente disponibili sono rimasti scarsi, aggravando ulteriormente lo squilibrio tra domanda e offerta. $OM è salito da $1 a oltre $3 e nel febbraio 2025 ha brevemente superato gli $8,99, con una capitalizzazione di mercato che ha raggiunto decine di miliardi di dollari.</p>
<p><strong>Dubbi sul trading del Market Maker:</strong> La comunità ha iniziato a interrogarsi se questo trend al rialzo sia reale. Alcuni trader hanno notato una profondità d’ordine e un comportamento di transazione anomali, sospettando che i market maker stiano controllando il mercato dietro le quinte. Con il senno di poi, <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Tendenza dei prezzi</a> Quasi ‘troppo perfetto’, linearmente in salita, facendo sospettare che gli addetti ai lavori stiano guidando il mercato.<br><img src="https://gimg2.gateimg.com/image/article/17446397951.png" alt=""><br>Illustrazione: $OM tra ottobre 2023 e aprile 2025 <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Tendenza dei prezzi</a> Da un balzo a $9 da meno di $0.02, per poi precipitare a $0.5. Questo aumento di 200 volte seguito da un immediato crollo è raro per un progetto apparentemente ‘legittimo’, rivelando come il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato crittografico</a> si sposta rapidamente tra frenesia e panico.</p>
<p>Entro la primavera del 2025, il valore cartaceo di $OM era aumentato vertiginosamente, e molti detentori precoci avevano raggiunto la “libertà finanziaria” (almeno sulla carta). Tuttavia, sotto la superficie, stava silenziosamente maturando una crisi: i portafogli delle balene controllavano la grande maggioranza dell’offerta, e il tanto promesso airdrop non si vedeva ancora da nessuna parte. Questi fattori alla fine culminarono nel disastro noto come il “Collasso MANTRA” il 13 aprile 2025.</p>
<h2 id="h2-9020Crash20Full20Review20Cause20Principali20e20Timeline739294"><a name="90% Crash Full Review: Cause Principali e Timeline" class="reference-link"></a><span class="header-link octicon octicon-link"></span>90% Crash Full Review: Cause Principali e Timeline</h2><h2 id="h2-Il201320aprile20202520OM2020crollato20di20oltre20il209020in20poche20ore20scendendo20da2063020a20circa2004020facendo20evaporare20un20valore20di20mercato20di20oltre20520miliardi20di20USD20Il20rapido20crollo20e20il20profondo20declino20hanno20sollevato20sospetti20di20un20rug20pull20o20vendite20interne20nonostante20laffermazione20del20team20di20unaltra20ragione20I20seguenti20sono20i20fattori20chiave20che20hanno20portato20a20questa20catastrofica20vendita20di20OM271826"><a name="Il 13 aprile 2025, $OM è crollato di oltre il 90% in poche ore, scendendo da $6,30 a circa $0,40, facendo evaporare un valore di mercato di oltre 5 miliardi di USD. Il rapido crollo e il profondo declino hanno sollevato sospetti di un ‘rug pull’ o vendite interne, nonostante l’affermazione del team di un’altra ragione. I seguenti sono i fattori chiave che hanno portato a questa ‘catastrofica vendita di $OM’:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il 13 aprile 2025, $OM è crollato di oltre il 90% in poche ore, scendendo da $6,30 a circa $0,40, facendo evaporare un valore di mercato di oltre 5 miliardi di USD. Il rapido crollo e il profondo declino hanno sollevato sospetti di un ‘rug pull’ o vendite interne, nonostante l’affermazione del team di un’altra ragione. I seguenti sono i fattori chiave che hanno portato a questa ‘catastrofica vendita di $OM’:</h2><p><strong>Il team/il controllo interno del 90% della circolazione:</strong> Uno dei problemi più grandi con $OM è l’estrema centralizzazione del token. I dati on-chain mostrano che il team principale di MANTRA controlla circa il 90% dei token circolanti, con i primi 100 indirizzi che detengono oltre il 99%. Questa struttura permette a poche persone di scaricare in qualsiasi momento, limitando anche la circolazione pubblica, rendendola favorevole al pompaggio speculativo. Anche se la comunità è stata a lungo scettica (alcuni la definiscono ‘una delle più grandi truffe’), il team non ha risposto positivamente.</p>
<h2 id="h2-20strongCambiamenti20nel20tokenomics20e20ritardi20nellairdrop20strong20A20ottobre20202420il20progetto20ha20silenziosamente20raddoppiato20lofferta20totale20e20introdotto20un20meccanismo20di20inflazione20Questa20mossa20quasi20passata20inosservata20durante20il20mercato20rialzista20dellepoca20ha20riservato20una20grande20quantit20di20token20per20il20team20Allo20stesso20tempo20i205020milioni20di20token20inizialmente20pianificati20per20lairdrop20nel20primo20trimestre20del20202520sono20stati20ritardati20pi20volte20e20ridotti20al201020disponibile20a20marzo20202520con20il20resto20posticipato20al20202720Questo20comportamento20promettente20la20luna20prolunga20il20rilascio20dellofferta20mantenendo20il20prezzo20a20un20livello20elevato920461"><a name="- <strong>Cambiamenti nel tokenomics e ritardi nell’airdrop: </strong> A ottobre 2024, il progetto ha silenziosamente raddoppiato l’offerta totale e introdotto un meccanismo di inflazione. Questa mossa, quasi passata inosservata durante il mercato rialzista dell’epoca, ha riservato una grande quantità di token per il team. Allo stesso tempo, i 50 milioni di token inizialmente pianificati per l’airdrop nel primo trimestre del 2025 sono stati ritardati più volte e ridotti al 10% disponibile a marzo 2025, con il resto posticipato al 2027. Questo comportamento ‘promettente la luna’ prolunga il rilascio dell’offerta, mantenendo il prezzo a un livello elevato." class="reference-link"></a><span class="header-link octicon octicon-link"></span>- <strong>Cambiamenti nel tokenomics e ritardi nell’airdrop: </strong> A ottobre 2024, il progetto ha silenziosamente raddoppiato l’offerta totale e introdotto un meccanismo di inflazione. Questa mossa, quasi passata inosservata durante il mercato rialzista dell’epoca, ha riservato una grande quantità di token per il team. Allo stesso tempo, i 50 milioni di token inizialmente pianificati per l’airdrop nel primo trimestre del 2025 sono stati ritardati più volte e ridotti al 10% disponibile a marzo 2025, con il resto posticipato al 2027. Questo comportamento ‘promettente la luna’ prolunga il rilascio dell’offerta, mantenendo il prezzo a un livello elevato.</h2><p><strong>I market maker operano e conducono transazioni fuori borsa:</strong> Diversi analisti chiamati $OM <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Tendenza dei prezzi</a> Viene manipolato dai market maker. Nell’ultimo anno, il trend del grafico è stato regolare con piccole fluttuazioni, sospettate di avere un intervento umano. Allo stesso tempo, ci sono segnalazioni che il team sta vendendo token a grandi detentori tramite OTC con uno sconto del 50%, consentendo loro di fare arbitraggio a un prezzo elevato sul mercato pubblico.</p>
<h2 id="h2-strongWeekend20liquidity20droughtstrong20Il20crash2020avvenuto20durante20il20fine20settimana20il20che20significa20una20liquidit20di20trading20estremamente20bassa20e20scarse20ordinazioni20di20acquisto20di20mercato20Quando20compare20una20grande20quantit20di20ordini20di20vendita20il20prezzo20crolla20senza20alcun20supporto20portando20a20una20caduta20diretta20Gli20ordini20di20stop20loss20vengono20attivati20continuamente20scatenando20ulteriormente20vendite20di20panico50745"><a name="<strong>Weekend liquidity drought:</strong> Il crash è avvenuto durante il fine settimana, il che significa una liquidità di trading estremamente bassa e scarse ordinazioni di acquisto di mercato. Quando compare una grande quantità di ordini di vendita, il prezzo crolla senza alcun supporto, portando a una caduta diretta. Gli ordini di stop loss vengono attivati continuamente, scatenando ulteriormente vendite di panico." class="reference-link"></a><span class="header-link octicon octicon-link"></span><strong>Weekend liquidity drought:</strong> Il crash è avvenuto durante il fine settimana, il che significa una liquidità di trading estremamente bassa e scarse ordinazioni di acquisto di mercato. Quando compare una grande quantità di ordini di vendita, il prezzo crolla senza alcun supporto, portando a una caduta diretta. Gli ordini di stop loss vengono attivati continuamente, scatenando ulteriormente vendite di panico.</h2><p><strong>OKX vendita incidente (trigger):</strong> Il giorno prima del crollo del mercato, l’analisi on-chain ha mostrato che un portafoglio interno ha trasferito circa 3,9 milioni di $OM (del valore di circa $25 milioni) a OKX, seguito dalla vendita di quasi 4 milioni di monete in modo continuo, scatenando il panico. Questo evento è probabilmente stata la goccia che ha fatto traboccare il vaso del mercato. Alcuni giorni prima, erano stati sbloccati e immessi sul mercato anche 5 milioni di $OM.</p>
<p><strong>Reazione a catena di panico e liquidazione:</strong> Poiché il prezzo è crollato, anche i primi grandi detentori che hanno comprato a un prezzo basso tramite OTC hanno iniziato a perdere denaro e sono stati costretti a fermare le perdite e fuggire. Alcuni investitori hanno utilizzato il leverage per longare $OM. Quando il prezzo è sceso sotto la linea di liquidazione, il sistema ha liquidato automaticamente, creando ulteriore pressione al ribasso. Un totale di $75.9 milioni di derivati di $OM sono stati liquidati in un solo giorno.</p>
<p><strong>Afflusso di fondi di scambio e accuse di Rug Pull:</strong> Molte balene hanno trasferito $OM agli scambi centralizzati prima del crollo, il che di solito segnala un’imminente vendita. La comunità ha criticato il team per aver incassato intenzionalmente e essere scappato, definendolo il ‘più grande tappeto da <a href="/price/terra-luna" target="_blank" class="blog_inner_link">terra</a> da LUNA/FTX’. Anche se il team del progetto lo ha negato, attribuendolo alle ‘balene che vengono liquidate su CEX’, il pubblico non è convinto.<br><img src="https://gimg2.gateimg.com/image/article/17446401252.png" alt=""><br>Illustrazione: Il 13 aprile 2025, $OM è sceso da $6,12 a $0,37 su Binance, evaporando oltre il 90% in sole quattro ore. L’enorme barra rossa del volume di trading nel grafico indica l’intensità del sell-off e la fragilità del libro degli ordini, avvicinandosi al caso standard di un ‘Rug Pull’ di alto livello.</p>
<p>Il team del progetto ha successivamente negato di aver venduto, affermando che il possesso del team è rimasto invariato e ha rilasciato una dichiarazione su Telegram affermando che è stata causata da ‘forza maggiore’ esterna. Tuttavia, considerando i segni precedenti di token altamente centralizzati, di distribuzioni aeree ritardate e di afflussi di fondi sulla catena, la maggior parte delle persone lo considera comunque un evento di fuga pianificato.</p>
<h2 id="h2-Confronto20con20disastri20criptici20storici20SQUID20LUNA20ecc584749"><a name="Confronto con disastri criptici storici (SQUID, LUNA, ecc.)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Confronto con disastri criptici storici (SQUID, LUNA, ecc.)</h2><h2 id="h2-La20velocit20e20lentit20del20crollo20del20token20MANTRA20hanno20rapidamente20scatenato20associazioni20con20diversi20famosi20disastri20crittografici20Alcuni20trader20esperti20hanno20fatto20notare20che20lascesa20e20il20crollo20di20OM20sono20molto20simili20agli20eventi20seguenti731610"><a name="La velocità e l’entità del crollo del token MANTRA hanno rapidamente scatenato associazioni con diversi famosi disastri crittografici. Alcuni trader esperti hanno fatto notare che l’ascesa e il crollo di OM sono molto simili agli eventi seguenti:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La velocità e l’entità del crollo del token MANTRA hanno rapidamente scatenato associazioni con diversi famosi disastri crittografici. Alcuni trader esperti hanno fatto notare che l’ascesa e il crollo di OM sono molto simili agli eventi seguenti:</h2><p><strong>Squid Coin (SQUID) Rug Pull (2021):</strong> La situazione più simile a OM è stata la truffa della ‘Squid Coin’ del 2021. SQUID è una moneta imitativa commercializzata con una serie popolare, con il suo prezzo schizzato oltre il 40.000% in pochi giorni, raggiungendo quasi i $2.860. Tuttavia, il team di sviluppo ha rapidamente drenato liquidità, causando il crollo del prezzo quasi a zero in pochi minuti, con gli investitori che vedevano il token scendere da oltre $2.800 a $0.005. Anche se OM non è sceso a zero (è sceso a circa $0.37), la sua struttura di crescita verticale seguita da un crollo istantaneo è molto simile. Entrambi hanno detenuti token altamente concentrati e situazioni in cui i token vengono scaricati quando la liquidità è scarsa. La differenza più grande tra OM e SQUID è che MANTRA sembra essere un ‘progetto legittimo’ con un team reale e registrazioni di partnership autentiche, rendendo il suo crollo ancora più scioccante.</p>
<p><strong><a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> LUNA Crash (Maggio 2022):</strong> Un’altra comparazione comunemente menzionata è <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Dopo il crollo del meccanismo delle stablecoin, il prezzo di LUNA è crollato di oltre il 99% nel giro di pochi giorni. Seguendo il crollo iniziale, c’è stato un breve rimbalzo (noto come ‘rimbalzo del gatto morto’), ma ha continuato a diminuire, intrappolando molti pescatori di fondo. Allo stesso modo, OM è anche rimbalzato da $0,37 a $1,10 il giorno dopo il crollo (un aumento del 200%), ma successivamente è sceso oltre il 92% dal suo picco. Gli analisti dei grafici sottolineano che tali rimbalzi sono comuni nelle fasi finali di un crollo ma sono di solito trappole. La tendenza attuale al rimbalzo di OM si sta gradualmente indebolendo, probabilmente per ripetere la tragedia di LUNA. Inoltre, il ‘vibro scandaloso’ che circonda MANTRA ha scatenato rabbia, facendo eco alla richiesta pubblica di regolamentazione e liquidazione dopo il crollo di LUNA anni fa. Anche se OM non è collassato a causa di un fallimento dell’algoritmo, l’evaporazione risultante di miliardi di dollari è paragonabile alle conseguenze catastrofiche di LUNA.</p>
<p>Inoltre, ci sono anche casi come il crollo di BitConnect del 2018 (una tipica moneta del sistema Ponzi) e il crollo di FTX/FTT del 2022, entrambi illustrano una cosa: se il prezzo di un token è gravemente gonfiato e controllato da pochi, il crollo è spesso solo una questione di tempo. Anche se OM opera da oltre due anni e ha partner e risorse, non riesce comunque a sfuggire alla tragedia, diventando un’altra storia esemplare.</p>
<h2 id="h2-Sommario20dellesperienza20dellinvestitore20Come20Identificare20Potenziali20Segnali20di20Pericolo46011"><a name="Sommario dell’esperienza dell’investitore: Come Identificare Potenziali Segnali di Pericolo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario dell’esperienza dell’investitore: Come Identificare Potenziali Segnali di Pericolo</h2><p>Per gli investitori che sono ancora in attesa o hanno già ‘calpestato la mina terrestre’, l’incidente OM ha portato un avvertimento profondo. Anche se è facile fare una revisione in seguito, in realtà ci sono molti segnali precoci che possono essere identificati. Ecco alcuni tipici ‘segnali d’allarme’ e suggerimenti degni di attenzione:</p>
<h2 id="h2-strongStruttura20di20detenzione20dei20token20con20eccessiva20concentrazionestrong2020cruciale20visualizzare20la20distribuzione20dei20token20onchain20Le20prime2010020direzioni20di20OM20detengono20fino20al209920dellofferta20il20che2020estremamente20poco20salutare20Quando20la20maggior20parte20dei20token2020detenuta20da20un20numero20molto20piccolo20di20persone20174464081775918520Fondamentalmente20controllato20da20loro20In20generale20i20progetti20sani20dovrebbero20evitare20tali20rischi20strutturali752259"><a name="<strong>Struttura di detenzione dei token con eccessiva concentrazione:</strong> È cruciale visualizzare la distribuzione dei token on-chain. Le prime 100 direzioni di OM detengono fino al 99% dell’offerta, il che è estremamente poco salutare. Quando la maggior parte dei token è detenuta da un numero molto piccolo di persone, {1744640817759185} Fondamentalmente controllato da loro. In generale, i progetti sani dovrebbero evitare tali rischi strutturali." class="reference-link"></a><span class="header-link octicon octicon-link"></span><strong>Struttura di detenzione dei token con eccessiva concentrazione:</strong> È cruciale visualizzare la distribuzione dei token on-chain. Le prime 100 direzioni di OM detengono fino al 99% dell’offerta, il che è estremamente poco salutare. Quando la maggior parte dei token è detenuta da un numero molto piccolo di persone, {1744640817759185} Fondamentalmente controllato da loro. In generale, i progetti sani dovrebbero evitare tali rischi strutturali.</h2><p><strong>Sudden or opaque tokenomic adjustment:</strong> Se un progetto modifica silenziosamente la sua circolazione e introduce meccanismi inflazionistici, specialmente quando nessuno sta prestando attenzione durante un mercato rialzista, è necessaria prudenza. Il raddoppio una tantum dell’offerta di MANTRA e l’introduzione di un’inflazione annua dell’8% sono una classica tattica di diluizione. Chiedersi ‘perché il cambiamento ora?’ Se la risposta è vaga, si può presumere che i rischi stiano aumentando.</p>
<p><strong>Airdrops o promesse di sblocco vengono ripetutamente ritardati:</strong> Ritardare o modificare ripetutamente le regole dopo aver promesso un grande airdrop è uno strumento tipico per ‘gonfiare’ il prezzo. L’airdrop di 50 milioni di MANTRA è stato rinviato più volte, escludendo in modo ingiusto alcuni utenti dall’essere idonei. A breve termine, questo riduce effettivamente la pressione delle vendite, ma a lungo termine indebolisce gravemente la fiducia.</p>
<p><strong>Prezzo e volume di trading anomali:</strong> Il prezzo di un progetto sano dovrebbe essere collegato alla popolarità di mercato, alla cooperazione e al progresso tecnologico. Se non ci sono buone notizie ovvie ma un continuo rialzo, e il volume degli scambi rimane insolitamente stabile, è probabile che ci sia una manipolazione di mercato. Il trend di OM è ‘troppo perfetto’, quasi come un modello di manipolazione.<br><strong>Portafoglio chiave trasferimenti agli scambi:</strong> Molti casi di rug pull hanno visto grandi quantità di token fluire verso gli exchange prima che si verifichino. Se noti che il portafoglio principale o l’indirizzo del balena stanno trasferendo monete a Binance, OKX, ecc., dovresti immediatamente essere in allerta. Strumenti come Whale  possono essere utilizzati per monitorare tali trasferimenti.</p>
<p><strong>Bassa liquidità o dipendenza da pochi market maker:</strong> Se una valuta ha solo poche coppie di trading e una debole liquidità, una leggermente maggiore pressione di vendita potrebbe innescare un <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">valanga</a>. OM è proprio un caso del genere, con una certa liquidità addirittura sospettata di essere mantenuta dal team stesso. Una volta che i market maker si ritirano, il prezzo cala bruscamente.</p>
<p><strong>Bassa trasparenza nella comunicazione del progetto:</strong> È cruciale che il team del progetto abbia una comunicazione aperta. MANTRA ha chiuso il gruppo Telegram nelle fasi iniziali dell’incidente e non ha risposto in modo positivo, il che è stato molto poco professionale. Inoltre, il suo fondatore è stato coinvolto in cause legali presso il tribunale di Hong Kong, di cui la maggior parte degli investitori non è a conoscenza. Se la comunicazione esterna del team è negativa o se c’è una storia macchiata, bisogna agire con cautela.</p>
<p><strong>Non lasciarti ingannare dal ‘calore’:</strong> La narrativa apparentemente illimitata (come RWA) non significa necessariamente che il progetto sia effettivamente atterrato. Il packaging della storia di OM è buono, ma l’attività effettiva on-chain è molto bassa. Ogni volta che una determinata criptovaluta diventa improvvisamente popolare e la comunità diffonde follemente ‘può solo salire’, è molto probabile che sia nella fase di pump. Evitate FOMO a tutti i costi, non investite pesantemente in un progetto supportato solo da storie.</p>
<h2 id="h2-Conclusione839836"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La storia di MANTRA $OM ci ricorda: il mercato delle criptovalute è pieno di miracoli e trappole. Un token che è salito di 200 volte è crollato più del 90% in un solo giorno, lasciando molti a inseguire i massimi senza ottenere nulla. Che questo crollo sia dovuto a manipolazioni maliziose o a una serie di cattive decisioni, gli investitori sono alla fine le vittime.</p>
<p>Questo incidente enfatizza ancora una volta: assicurati di condurre una dovuta diligenza sufficiente, non prendere mai alla leggera nessun progetto. Nel mondo delle criptovalute, il ‘pump and dump’ è spesso il preludio di un ‘forte calo’.</p>
<p>La questione su ‘Che fine ha fatto MANTRA ($OM)’ è in realtà un promemoria per la gestione del rischio nell’intera industria crittografica. Coinvolge quasi tutti i potenziali problemi: controllo centralizzato, manipolazione dell’economia dei token, vendite di fine settimana, crolli di leva… In futuro, quando segnali simili riappariranno, speriamo di poter imparare da questo evento e evitare di diventare il prossimo ‘bagholder’.</p>
<p>Promemoria amichevole: DYOR (Fai la tua ricerca), non correre mai ciecamente verso la prossima ‘moon coin’.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Cina Z.</strong>Ricercatore di Gate.io<div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio di trading. Gli investimenti comportano rischi, quindi le decisioni dovrebbero essere prese con cautela.<br></em><div><em></em>Questo articolo è originale e il copyright appartiene a Gate.io. Si prega di indicare l'autore e la fonte in caso di ri-stampa, in caso contrario saranno perse le responsabilità legali.<br></div><p></p><br></div></div></div>