U2FmZU1vb24gc3RhcnQgQ2hhcHRlciA3IGZhaWxsaXNzZW1lbnQsIFNGTSBkYWFsdCBtZXQgNDIl

2023-12-29, 08:57

<p><img src="https://gimg2.gateimg.com/image/article/1703839920RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-TL20DR409786"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Op 14 december <a href="/price/safemoon-sfm" rel="nofollow noopener noreferrer" target="_blank">SafeMoon</a> heeft zich failliet verklaard volgens hoofdstuk 7.<br>SafeMoon heeft geen intentie om het bedrijf nieuw leven in te blazen en is bezig met het afbouwen van de werkzaamheden.</p>
<p>De SEC heeft <a href="/price/safemoon-sfm" target="_blank" class="blog_inner_link">SafeMoon</a> utives aangeklaagd voor verschillende misdrijven, waaronder schending van effectenwetten.</p>
<h2 id="h2-Inleiding437002"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Sinds het begin van 2022 zijn verschillende cryptoprojecten ingestort en failliet verklaard. Verschillende op blockchain gebaseerde bedrijven zoals FTX hebben faillissement aangevraagd aan het begin van 2022. In een andere trieste ontwikkeling heeft SafeMoon onlangs faillissement aangevraagd onder Hoofdstuk 7. Vandaag bespreken we de mogelijke oorzaken van de insolventie van SafeMoon.</p>
<h2 id="h2-SafeMoon20dient20een20faillissementsaanvraag20in20voor20hoofdstuk207821458"><a name="SafeMoon dient een faillissementsaanvraag in voor hoofdstuk 7" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SafeMoon dient een faillissementsaanvraag in voor hoofdstuk 7</h2><p>Op 14 december 2023 daalde de Safemoon-prijs met ongeveer 42% na de indiening van het faillissement van hoofdstuk 7 van het bedrijf bij de faillissementsrechtbank van de Verenigde Staten voor het district Utah. Advocaat Mark Rose diende het vrijwillige verzoekschrift in omdat het cryptobedrijf te kampen had met ernstige financiële beperkingen.</p>
<p>Op de dag dat het crypto bedrijf Safemoon faillissement aanvroeg, daalde de prijs van zijn token binnen slechts 5 uur met ongeveer 31%. Specifiek, de <a href="https://www.gate.io/price/safemoon-sfm" target="_blank">SFM-tokenprijs</a> daalde van $0.000065 naar $0.000045. Desalniettemin herstelde het zich aan het einde van de dag naar $0.000061.</p>
<p>De Safemoon dalende prijs zorgde ervoor dat de token werd verhandeld op ongeveer 98,2% lager dan de hoogste prijs van $0,0033, behaald op 5 januari 2022. Nog erger is dat de marktkapitalisatie daalde van meer dan $1 miljard naar $34,5 miljoen.</p>
<p>De belangrijkste reden voor het indienen van hoofdstuk 7 van het Safemoon crypto-bedrijf is om zijn schuldeisers af te betalen. Het bedrijf beweert dat het tussen de 50 en 99 schuldeisers heeft waar het bedragen aan verschuldigd is die variëren tussen $10 miljoen en $50 miljoen aan activa. Het heeft ook tussen de $100.000 en $500.000 aan uitstaande contante betalingen.</p>
<p>Hoofdstuk 7 faillissement resulteert in liquidatie van de activa van de schuldenaars om crediteuren terug te betalen. Het verschilt van hoofdstuk 11 faillissement waarbij een bedrijf een pauze neemt van de bedrijfsvoering om de onderneming te herstructureren. In het g van Safemoon heeft een curator tijdelijke controle over de activiteiten en activa. Het belangrijkste doel van de SafeMoon-bewindvoerder is om de activiteiten af te bouwen en de schuldeisers van het bedrijf te betalen.</p>
<p>Safemoon-medewerkers zijn enkele van de belangrijkste crediteuren van het bedrijf. Op dit moment is het bedrijf al ongeveer drie jaar operationeel sinds John Karony, Kyle Nagy en Thomas Smith het hebben opgericht op 1 maart 2021. Daarna lanceerde het bedrijf zijn token, SFM, in december van hetzelfde jaar.</p>
<h2 id="h2-SafeMoon20wordt20geconfronteerd20met20strafrechtelijke20aanklachten20in20de20Verenigde20Staten310801"><a name="SafeMoon wordt geconfronteerd met strafrechtelijke aanklachten in de Verenigde Staten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SafeMoon wordt geconfronteerd met strafrechtelijke aanklachten in de Verenigde Staten</h2><p>SafeMoon heeft een maand na het indienen van het Eastern District of New York Department of Justice (DOJ) en de SEC zijn leidinggevenden aangeklaagd voor verschillende misdaden, waaronder fraude en verduistering van fondsen, faillissement aangevraagd.</p>
<p>Het DOJ klaagde SafeMoon-utives aan omdat ze klantengeld uitgaven aan luxe voertuigen en onroerend goed, onder andere. Ze beschuldigden hen van samenzwering tot witwassen van geld en samenzwering om draadfraude te plegen. De twee toezichthoudende autoriteiten beweren dat het SafeMoon-team investeringsfondsen gebruikte om zichzelf te verrijken.</p>
<p>Specifiek heeft het DOJ aanklachten ingediend tegen Kyle Nagy, de oprichter van Safemoon, en Thomas Smith, de voormalige Chief Technology Officer van het bedrijf, wegens verduistering van klantengelden.</p>
<p>De specifieke beschuldigingen zijn dat deze leidinggevenden meer dan $200 miljoen hebben gebruikt om huizen en luxe auto’s te kopen, onder andere. Als zodanig hebben ze investeerdersfondsen opgenomen die ze beweerden te hebben vergrendeld.</p>
<p>In dit verband, de <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">Het DOJ zei</a>, “Naarmate de marktkapitalisatie van SFM groeide tot meer dan $8 miljard, hebben de beklaagden op frauduleuze wijze miljoenen dollars aan vermeende ‘geblokkeerde’ SFM-liquiditeit afgeleid en verduisterd voor hun eigen voordeel. Eerder vandaag werd Karony gearresteerd in Provo, Utah, en Smith werd gearresteerd in Bethlehem, New Hampshire. Nagy is nog op vrije voeten.”</p>
<p>United States Attorney Breon Peace breidde verder uit door te zeggen: “Zoals beweerd, hebben de beklaagden investeerders opzettelijk misleid en miljoenen dollars omgeleid om hun hebzuchtige plan te voeden en zichzelf te verrijken door de aankoop van een op maat gemaakte Porsche sportwagen, andere luxe voertuigen en onroerend goed.”</p>
<p>De Securities and Exchange Commission (SEC) heeft ook de SafeMoon utives aangeklaagd wegens schending van effectenwetten. In dit g heeft de SEC SafeMoon aangeklaagd voor de verkoop van een niet-geregistreerd effect, SFM. Specifiek heeft het Kyle Nagy, Braden John Karony, de Chief utive en Thomas Smith vervolgd.</p>
<p>David Hirsch, Chief of the SEC Enforcement Division’s Crypto Assets and Cyber Unit (CACU) shed more light on the case. Hij zei: “Decentralized finance beweert transparantie en voorspelbare uitkomsten te leveren, maar niet-geregistreerde aanbiedingen ontberen de openbaarmaking en verantwoording die de wet vereist, en ze trekken oplichters aan zoals Kyle Nagy, die deze kwetsbaarheden gebruiken om zichzelf te verrijken ten koste van anderen.”</p>
<p>De SEC beweert dat SafeMoon zijn investeerders beloofde dat de SFM-token unieke kenmerken had die de prijs ervan binnen een relatief korte periode zeer hoog konden drijven. Desalniettemin daalde de prijs van de token in plaats van te stijgen, wat leidde tot aanzienlijk verlies voor investeerders.</p>
<p>De SEC beweert ook dat SafeMoon de markt heeft gemanipuleerd om de waarde van zijn token op te krikken. Het feit is dat tussen 12 maart en 20 april 2021 de waarde van de SFM-token met meer dan 55.000% is gestegen tot een marktkapitalisatie van $5,7 miljard. Niettemin daalde de waarde later met 50%, wat SafeMoon ertoe bracht de markt te manipuleren. In dit g gebruikte Karony verduisterde activa om Safemoon (SFM) te kopen.</p>
<p>Karony opende ook een handelsaccount om SFM in grote hoeveelheden te kopen en verkopen om de indruk te wekken dat de token in grote vraag was en om de daling van Safemoon te stoppen in waarde.</p>
<p>De recente ontwikkelingen van Safemoon hebben veel angst veroorzaakt bij investeerders en supporters die zich opgelicht voelen. Een Reddit-gebruiker met de naam <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 zei</a>, “Wel, het is officieel officieel: Safemoon dient een faillissement in en zal ophouden te bestaan. Het spel is voorbij. Ik heb verkocht wat voor POS ‘moon’ ik nog over had en het omgeruild naar MATIC.”</p>
<p>Hij/zij voegde eraan toe: “Ik wil nooit praten over hoe erg we allemaal zijn opgelicht en vooral over het geld dat ik heb verloren. Aan de die nog steeds denken dat Safemoon een kans heeft en “naar de maan zal gaan: zoek hulp.”</p>
<p>Als gevolg van de Safemoon-zaak waarschuwde Jorge G. Tenreiro, plaatsvervangend chef van de CACU, mensen die willen investeren in cryptocurrencies om extra voorzichtig te zijn.</p>
<p><a href="https://www.sec.gov/news/press-release/2023-229" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>, “We dringen er bij beleggers op aan om uiterste voorzichtigheid te betrachten in deze ruimte, aangezien oplichters profiteren van de populariteit van crypto-activa om astronomische winsten te beloven, maar vaak alleen een crashlanding bezorgen.”</p>
<h2 id="h2-Conclusie929374"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Op 14 december 2023 heeft SafeMoon een faillissement volgens hoofdstuk 7 aangevraagd in de Verenigde Staten, waarbij het zijn intentie toont om de activiteiten permanent te sluiten. De aanvraag komt enkele dagen nadat de Amerikaanse SEC en DOJ zijn leidinggevenden hebben aangeklaagd voor verschillende misdaden, waaronder samenzwering tot witwassen van geld, schendingen van effectenwetten en samenzwering tot het plegen van wirefraude.</p>
<h2 id="h2-Veelgestelde20vragen20over20SafeMoon682857"><a name="Veelgestelde vragen over SafeMoon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over SafeMoon</h2><h3 id="h3-Wat20is20Safemoon495703"><a name="Wat is Safemoon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Safemoon?</h3><p>Safemoon is een memecoin gelanceerd op 1 maart 2021, die zich richt op gemeenschap en veiligheid. Hoewel de token sterk begon, is de waarde ervan in de loop der jaren aanzienlijk gedaald door verschillende controverses. Op 14 december 2023, <a href="/price/safemoon-sfm" rel="nofollow noopener noreferrer" target="_blank">SafeMoon crypto</a> Het bedrijf heeft faillissement aangevraagd volgens hoofdstuk 7.</p>
<h3 id="h3-Heeft20Safemoon20een20toekomst14984"><a name="Heeft Safemoon een toekomst?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Heeft Safemoon een toekomst?</h3><p>De toekomst van Safemoon ziet er somber uit nadat het SafeMoon crypto-bedrijf op 14 december 2023 faillissement heeft aangevraagd onder hoofdstuk 7. De Amerikaanse SEC heeft het bedrijf ook aangeklaagd voor het aanbieden van een niet-geregistreerde beveiliging, SFM. Daarnaast hebben de SEC en het DOJ SafeMoon utives aangeklaagd voor verschillende misdrijven, waaronder witwassen van geld en schendingen van de Amerikaanse effectenwetten.</p>
<h3 id="h3-Heeft20Safemoon20enige20waarde42627"><a name="Heeft Safemoon enige waarde?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Heeft Safemoon enige waarde?</h3><p>Safemoon (SFM) wordt momenteel verhandeld tegen $0.00003243, wat betekent dat het nog steeds een waarde heeft. De prijs is echter gedaald sinds 14 december toen <a href="/price/safemoon--old--safemoon" target="_blank" class="blog_inner_link">SafeMoon crypto</a> bedrijf faillissement aanvroeg volgens hoofdstuk 7.</p>
<h3 id="h3-Hoe20legitiem20is20Safemoon106039"><a name="Hoe legitiem is Safemoon?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe legitiem is Safemoon?</h3><p>Sinds de lancering in 2021 <a href="https://www.gate.io/article/24652 &quot;Safemoon (SFM" rel="nofollow noopener noreferrer" target="_blank">Safemoon (SFM)</a>”) leek legitiem omdat het werd beheerd door een verantwoordelijk team. De SEC en DOJ hebben echter de SafeMoon leidinggevenden aangeklaagd wegens het plegen van verschillende crypto misdaden.</p>
<h3 id="h3-Is20het20veilig20om20Safemoonmunt20te20kopen932560"><a name="Is het veilig om Safemoon-munt te kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is het veilig om Safemoon-munt te kopen?</h3><p>Op dit moment <a href="https://www.gate.io/blog_detail/273/is-safemoon-a-good-investment" target="_blank">Het lijkt niet veilig om te investeren in Safemoon crypto</a> aangezien er een rechtszaak is tegen het bedrijf en zijn leidinggevende omdat ze de token in de Verenigde Staten hebben verkocht zonder deze te registreren. Erger nog, de waarde van de SFM-token is gedaald sinds Safemoon faillissement heeft aangevraagd volgens Hoofdstuk 7. Hier is een lijst van de beste <a href="https://www.gate.io/hot_news/detail/127/a-reliable-exchange-to-trade-safemoon" target="_blank">beurzen om SafeMoon te kopen of verkopen</a>.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>