U2FmZU1vb24gYXZ2aWEgaWwgZmFsbGltZW50byBkZWwgY2FwaXRvbG8gNywgU0ZNIHByZWNpcGl0YSBkZWwgNDIl

2023-12-29, 08:57

<p><img src="https://gimg2.gateimg.com/image/article/1703839920RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR882368"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Il 14 dicembre <a href="/price/safemoon-sfm" rel="nofollow noopener noreferrer" target="_blank">SafeMoon</a> ha presentato istanza di fallimento per il capitolo 7.<br>SafeMoon non ha intenzione di riavviare l’attività e sta procedendo alla chiusura delle operazioni.</p>
<p>La SEC ha accusato i dirigenti di <a href="/price/safemoon-sfm" target="_blank" class="blog_inner_link">SafeMoon</a> di diversi crimini, tra cui violazione delle leggi sui titoli.</p>
<h2 id="h2-Introduzione388531"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dal principio del 2022 diversi progetti di criptovalute sono collassati e hanno dichiarato bancarotta. Diverse aziende basate su blockchain, come FTX, hanno dichiarato bancarotta all’inizio del 2022. In un altro triste sviluppo, SafeMoon ha recentemente dichiarato bancarotta del Capitolo 7. Oggi discutiamo delle possibili cause dell’insolvenza di SafeMoon.</p>
<h2 id="h2-SafeMoon20presenta20domanda20di20fallimento20del20Capitolo20723094"><a name="SafeMoon presenta domanda di fallimento del Capitolo 7" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SafeMoon presenta domanda di fallimento del Capitolo 7</h2><p>Il 14 dicembre 2023 il prezzo di Safemoon è sceso di circa il 42% a seguito della richiesta di fallimento del capitolo 7 della società presso il Tribunale fallimentare degli Stati Uniti per il Distretto dello Utah. L’avvocato Mark Rose ha presentato la petizione volontaria poiché la società di criptovalute si trovava di fronte a gravi difficoltà finanziarie.</p>
<p>Il giorno in cui la società criptata Safemoon ha presentato istanza di fallimento ai sensi del Capitolo 7, il prezzo del suo token è sceso di circa il 31% in soli 5 ore. In particolare, il <a href="https://www.gate.io/price/safemoon-sfm" target="_blank">Prezzo del token SFM</a> è precipitato da $0.000065 a $0.000045. Tuttavia, alla fine della giornata è rimbalzato a $0.000061.</p>
<p>Il prezzo in caduta libera di Safemoon ha portato al trading del token a circa il 98,2% in meno rispetto al suo prezzo più alto di $0,0033, raggiunto il 5 gennaio 2022. Peggio ancora, la sua capitalizzazione di mercato è crollata da oltre $1 miliardo a $34,5 milioni.</p>
<p>Il motivo principale del deposito del capitolo 7 della società criptata di Safemoon è quello di saldare i propri creditori. La società afferma di avere tra 50 e 99 creditori a cui deve importi che vanno da 10 a 50 milioni di dollari in attività. Ha inoltre pagamenti in contanti in sospeso tra 100.000 e 500.000 dollari.</p>
<p>Il fallimento del capitolo 7 comporta la liquidazione dei beni del debitore per ripagare i creditori. È diverso dal fallimento del capitolo 11, dove un’azienda fa una pausa dalle operazioni per ristrutturare il business. Nel caso di Safemoon, un custode ha il controllo temporaneo sulle sue operazioni e i suoi beni. Principalmente, il Fiduciario di SafeMoon mira a liquidare le operazioni e a pagare i creditori dell’azienda.</p>
<p>I dipendenti di Safemoon sono alcuni dei principali creditori dell’azienda. Al momento, l’azienda è operativa da circa tre anni, dal momento in cui John Karony, Kyle Nagy e Thomas Smith l’hanno fondata l’1 marzo 2021. Dopo di che, l’azienda ha lanciato il suo token, SFM, nel dicembre dello stesso anno.</p>
<h2 id="h2-SafeMoon20Affronta20Accuse20Penali20negli20Stati20Uniti238643"><a name="SafeMoon Affronta Accuse Penali negli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SafeMoon Affronta Accuse Penali negli Stati Uniti</h2><p>SafeMoon ha presentato istanza di fallimento un mese dopo che il Dipartimento di Giustizia (DOJ) del distretto orientale di New York e la SEC hanno citato in giudizio i suoi dirigenti per vari crimini che includono frode e appropriazione indebita di fondi.</p>
<p>Il DOJ ha citato in giudizio gli esecutivi di SafeMoon per aver speso i fondi dei clienti in veicoli di lusso e immobili, tra gli altri. Li ha accusati di cospirazione per il riciclaggio di denaro e cospirazione per commettere frode tramite mezzi telematici. Le due autorità di regolamentazione sostengono che il team di SafeMoon abbia utilizzato i fondi degli investitori per arricchirsi.</p>
<p>In particolare, il DOJ ha presentato accuse contro Kyle Nagy, fondatore di Safemoon, e Thomas Smith, ex Chief Technology Officer dell’azienda, per l’appropriazione indebita dei fondi dei clienti.</p>
<p>Le accuse specifiche sono che questi dirigenti hanno utilizzato più di 200 milioni di dollari per comprare case e auto di lusso, tra le altre cose. Pertanto, hanno prelevato fondi degli investitori che sostenevano di avere bloccato.</p>
<p>A tal fine, il <a href="https://www.justice.gov/usao-edny/pr/founders-and-utives-digital-asset-company-charged-multi-million-dollar" rel="nofollow noopener noreferrer" target="_blank">DOJ ha detto</a>“Poiché la capitalizzazione di mercato di SFM è cresciuta a oltre 8 miliardi di dollari, i querelati hanno fraudolentemente deviato e appropriato milioni di dollari di liquidità presumibilmente “bloccata” di SFM a proprio vantaggio personale. In precedenza, oggi stesso, Karony è stato arrestato a Provo, Utah, e Smith è stato arrestato a Bethlehem, New Hampshire. Nagy è ancora latitante.”</p>
<p>L’Avvocato degli Stati Uniti Breon Peace ha ampliato ulteriormente, dicendo: “Come affermato, gli imputati hanno deliberatamente ingannato gli investitori e dirottato milioni di dollari per alimentare il loro avido piano e arricchirsi acquistando una Porsche sportiva personalizzata, altre auto di lusso e immobili.”</p>
<p>La Securities and Exchange Commission (SEC) ha anche citato in giudizio i dirigenti di SafeMoon per violazione delle leggi sulla sicurezza. In questo caso, la SEC ha accusato SafeMoon di vendere un titolo non registrato, SFM. In particolare, ha perseguito Kyle Nagy, Braden John Karony il Chief utive e Thomas Smith.</p>
<p>David Hirsch, capo della Divisione di Enforcement della SEC per gli Asset Crypto e l’Unità Cyber (CACU), ha fatto luce sul caso. Ha detto: “La finanza decentralizzata sostiene di offrire trasparenza e risultati prevedibili, ma le offerte non registrate mancano delle divulgazioni e della responsabilità richieste dalla legge, e attraggono truffatori come Kyle Nagy, che sfruttano queste vulnerabilità per arricchirsi a spese degli altri.”</p>
<p>Il caso della SEC è che SafeMoon ha promesso ai suoi investitori che il token SFM aveva caratteristiche uniche che avrebbero potuto far salire molto il suo prezzo nel giro di un periodo relativamente breve. Tuttavia, il prezzo del token è diminuito invece di salire, causando ingenti perdite agli investitori.</p>
<p>La SEC afferma anche che SafeMoon ha manipolato il mercato per sostenere il valore del proprio token. Il fatto è che tra il 12 marzo e il 20 aprile 2021 il valore del token SFM è aumentato di oltre il 55.000% raggiungendo una capitalizzazione di mercato di $5,7 miliardi. Tuttavia, il suo valore è successivamente diminuito del 50%, spingendo SafeMoon a manipolare il mercato. In questo caso, Karony ha utilizzato asset sottratti per acquistare Safemoon (SFM).</p>
<p>Karony ha aperto anche un conto di trading per comprare e vendere SFM in grandi quantità al fine di creare l’impressione che il token fosse molto richiesto e fermare il calo del valore di Safemoon.</p>
<p>Gli recenti sviluppi di Safemoon hanno causato molta ansia tra gli investitori e i sostenitori che si sentono truffati. Un utente di Reddit di nome <a href="https://www.reddit.com/r/SafeMoon/comments/18ilrtv/at_a_loss_for_words/?rdt=52049" rel="nofollow noopener noreferrer" target="_blank">u/anonyamon42069 ha detto</a>, “Beh, è ufficialmente ufficiale: Safemoon sta presentando istanza di fallimento e cesserà di esistere. È finita. Ho venduto qualsiasi ‘moon’ POS che mi era rimasta e l’ho scambiata con MATIC.”</p>
<p>Ha aggiunto: “Non voglio nemmeno parlare di quanto siamo stati truffati tutti e soprattutto dei soldi che ho perso. A quegli idioti che ancora pensano che Safemoon abbia una possibilità e che “andrà sulla luna”: cercate aiuto.”</p>
<p>A seguito del caso Safemoon, Jorge G. Tenreiro, vice capo del CACU, ha avvertito le persone che desiderano investire in criptovalute di prestare particolare attenzione.</p>
<p><a href="https://www.sec.gov/news/press-release/2023-229" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>“Esortiamo gli investitori a continuare a esercitare estrema cautela in questo settore, poiché i truffatori sfruttano la popolarità degli asset crittografici per promettere profitti astronomici, ma troppo spesso si finisce solo con un crollo.”</p>
<h2 id="h2-Conclusione361110"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il 14 dicembre 2023 SafeMoon ha presentato istanza di fallimento ai sensi del Capitolo 7 negli Stati Uniti, manifestando l’intenzione di chiudere definitivamente l’attività. La richiesta è arrivata pochi giorni dopo che la SEC e il DOJ degli Stati Uniti hanno citato in giudizio i suoi dirigenti per vari crimini, tra cui cospirazione per il riciclaggio di denaro, violazioni delle leggi sui titoli e cospirazione per commettere frode telematica.</p>
<h2 id="h2-Domande20frequenti20su20SafeMoon404035"><a name="Domande frequenti su SafeMoon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su SafeMoon</h2><h3 id="h3-Cos20Safemoon313606"><a name="Cos’è Safemoon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Safemoon?</h3><p>Safemoon è una criptovaluta meme lanciata l’1 marzo 2021 che si concentra sulla comunità e sulla sicurezza. Anche se il token ha iniziato con forza, il suo valore è diminuito significativamente nel corso degli anni a causa di diverse controversie. Il 14 dicembre 2023, <a href="/price/safemoon-sfm" rel="nofollow noopener noreferrer" target="_blank">criptovaluta SafeMoon</a> La società ha presentato istanza di fallimento ai sensi del Capitolo 7.</p>
<h3 id="h3-Safemoon20ha20un20futuro253268"><a name="Safemoon ha un futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Safemoon ha un futuro?</h3><p>Il futuro di Safemoon è cupo dopo che l’azienda criptografica SafeMoon ha presentato istanza di bancarotta ai sensi del Capitolo 7 il 14 dicembre 2023. La SEC degli Stati Uniti ha anche citato in giudizio l’azienda per aver offerto un titolo non registrato, SFM. Inoltre, la SEC e il DOJ hanno citato in giudizio i dirigenti di SafeMoon per vari crimini, tra cui il riciclaggio di denaro e violazioni delle leggi sulla sicurezza degli Stati Uniti.</p>
<h3 id="h3-Safemoon20ha20un20valore616503"><a name="Safemoon ha un valore?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Safemoon ha un valore?</h3><p>Safemoon (SFM) sta attualmente scambiando a $0,00003243, il che significa che ha ancora un valore. Tuttavia, il suo prezzo è stato in caduta libera dal 14 dicembre, quando la società criptografica SafeMoon ha presentato istanza di fallimento del Capitolo 7.</p>
<h3 id="h3-Quanto2020legittimo20Safemoon583658"><a name="Quanto è legittimo Safemoon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto è legittimo Safemoon?</h3><p>Dal suo lancio nel 2021 <a href="https://www.gate.io/article/24652 &quot;Safemoon (SFM" rel="nofollow noopener noreferrer" target="_blank">Safemoon (SFM)</a> Sembrava legittimo poiché era gestito da un team responsabile. Tuttavia, la SEC e il DOJ hanno citato in giudizio gli esecutivi di SafeMoon per aver commesso vari crimini criptati.</p>
<h3 id="h3-20sicuro20comprare20la20moneta20Safemoon245259"><a name="È sicuro comprare la moneta Safemoon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>È sicuro comprare la moneta Safemoon?</h3><p>Al momento <a href="https://www.gate.io/blog_detail/273/is-safemoon-a-good-investment" target="_blank">Non sembra sicuro investire nella criptovaluta Safemoon</a> dato che c’è una causa legale contro l’azienda e il suo dirigente per la vendita del token negli Stati Uniti senza registrarlo. Peggio ancora, il valore del token SFM è in calo da quando Safemoon ha presentato istanza di fallimento del capitolo 7. Ecco una lista dei migliori <a href="https://www.gate.io/hot_news/detail/127/a-reliable-exchange-to-trade-safemoon" target="_blank">scambi per comprare o vendere SafeMoon</a>.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il ripostaggio dell'articolo sarà consentito a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>