U0VDIHN0YXB0IG92ZXIgb3Agc3VtbWllcmUgdWl0c3ByYWFrIGluIHJlY2h0c3phYWsgdGVnZW4gVGVycmFmb3JtIGVuIERvIEt3b24=

2023-11-15, 05:03

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen98898"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>De SEC heeft een verzoek ingediend voor een samenvattende uitspraak tegen Terraform en Kwon.</p>
<p>Terraform Labs is het er niet mee eens dat zijn crypto-assets zoals UST en LUNA effecten zijn.</p>
<p>Rechter Jed Rakoff is van mening dat de Howey-test beleggingsactiva niet indeelt als effecten op basis van waar ze worden verkocht en wie ze koopt.</p>
<h2 id="h2-Introductie535393"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Digitale activa zoals cryptocurrencies en niet-fungibele tokens kunnen slagen of mislukken. Er zijn bijvoorbeeld veel niet-fungibele tokens met waarden van nullen. Aan de andere kant zijn er cryptocurrencies die zijn geïmplodeerd, wat heeft geleid tot verlies van geld van investeerders.</p>
<p>Terraform Labs is een voorbeeld van een crypto-project dat ontwikkelde cryptocurrencies die in elkaar stortten. Omdat hun implosie resulteerde in verlies van beleggerfondsen, werd het geconfronteerd met rechtszaken in de Verenigde Staten.</p>
<p>In dit artikel richten we ons op de rechtszaak van de SEC tegen Terraform Labs en Do Kwon. We zullen ook de oproepen van de SEC en Terraform voor een samenvattend oordeel bespreken. Het is interessant om te ontdekken wie een betere kans maakt om de zaak te winnen.</p>
<h2 id="h2-Rechtszaak20van20de20SEC20tegen20Terraform20en20Do20Kwon509881"><a name="Rechtszaak van de SEC tegen Terraform en Do Kwon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rechtszaak van de SEC tegen Terraform en Do Kwon</h2><p>Op 2 november 2023 diende de Securities and Exchange Commission (SEC) een verzoek in voor een samenvattende uitspraak in haar rechtszaak tegen Terraform Labs <a href="https://www.gate.io/blog_detail/2238/do-kwon-reaches-5-star-wanted-level-as-sec-brings-more-fraud-charges" target="_blank">en Do Kwon</a> De basis voor <a href="https://storage.courtlistener.com/recap/gov.uscourts.nysd.594150/gov.uscourts.nysd.594150.105.0.pdf" rel="nofollow noopener noreferrer" target="_blank">Huidige positie van de SEC</a> is dat er ‘geen echt geschil is over enig materieel feit.’ De SEC stelt dat het duidelijk is dat de investeerders de tokens hebben gekocht met fiatvaluta of crypto-activa.</p>
<p>Het argument van de SEC is dat beleggers hun geld hebben geïnvesteerd in de genoemde crypto-activa in de hoop daar winst uit te halen. In dat opzicht voldoen de cryptocurrencies aan de criteria van de Howey Test. De Verenigde Staten gebruiken de Howey Test om te bepalen of een beleggingsactivum al dan niet een effect is onder de federale wetgeving.</p>
<p>In haar indiening legde de SEC de verschillende bewijsstukken uit die zij tegen Terraform Labs en Kwon heeft. De details in het document zijn in feite een samenvatting van haar beschuldigingen tegen Terraform Labs, waaronder het op de markt brengen van haar tokens als effecten, het richten op burgers van de Verenigde Staten, het positioneren van LUNA als een investeringsactivum, schending van de Amerikaanse antifraudebepalingen en haar belofte om inspanningen te leveren om winst te genereren.</p>
<p><a href="https://storage.courtlistener.com/recap/gov.uscourts.nysd.594150/gov.uscourts.nysd.594150.105.0.pdf" rel="nofollow noopener noreferrer" target="_blank">En het eindigde met te zeggen</a>“Om bovengenoemde redenen is een samenvatting van het vonnis gerechtvaardigd tegen de verweerders Terraform en Kwon met betrekking tot alle claims van de SEC.”</p>
<h2 id="h2-Belangrijkste20beschuldigingen20van20de20SEC692634"><a name="Belangrijkste beschuldigingen van de SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste beschuldigingen van de SEC</h2><p>De belangrijkste beschuldiging van de SEC tegen Terraform is dat Kwon en het bedrijf een financieel schema hebben opgezet om investeerders van hun geld te bedriegen. Als gevolg hiervan heeft Terraform investeerders van meer dan $45 miljard opgelicht die ze hadden geïnvesteerd in verschillende crypto-activa, waaronder gespiegelde activa (mAssets). <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Classic (LUNC), Mirror Protocol (MIR) en <a href="/price/terraclassicusd-ustc" rel="nofollow noopener noreferrer" target="_blank">TerraClassicUSD</a> (USTC).</p>
<p>Bovendien is de SEC van mening dat Terraform de <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> blockchain heeft ontwikkeld om de indruk te wekken dat er echte transacties waren die winst konden genereren voor de investeerders. Zo hebben ze van tijd tot tijd gelogen tegen de investeerders dat hun zogenaamde stablecoin, UST, stabiel was.</p>
<p>Toen de munt instortte, verloren de investeerders zowel hun geïnvesteerde geld als de beoogde winst. De SEC beweert ook dat de verdachten veel fiatvaluta hebben uitbetaald. Opmerkelijk is dat de Terra USD (UST), die gekoppeld was aan de Amerikaanse dollar, algoritmisch verbonden was met hun andere cryptocurrency genaamd LUNA.</p>
<p>Wat betreft dit, <a href="https://storage.courtlistener.com/recap/gov.uscourts.nysd.594150/gov.uscourts.nysd.594150.105.0.pdf" rel="nofollow noopener noreferrer" target="_blank">de SEC zei</a>, “Verdachten vertegenwoordigden ook aan het publiek dat elke UST-token veilig en automatisch gekoppeld was aan de Amerikaanse dollar via een blockchain-algoritme dat het met LUNA verbond.”</p>
<p>Volgens de SEC gebruikte Terraform een agressieve marketingstrategie om individuen en instellingen te lokken om te investeren in hun tokens. Er werd gesteld: “Verdachten beloofden investeerders dat de waarde van LUNA zou toenemen naarmate de Terra blockchain meer werd gebruikt, en prezen herhaaldelijk de management- en ondernemersinspanningen aan die zij zouden leveren en daadwerkelijk hebben geleverd om dat doel te bereiken.”</p>
<p><a href="https://storage.courtlistener.com/recap/gov.uscourts.nysd.594150/gov.uscourts.nysd.594150.105.0.pdf" rel="nofollow noopener noreferrer" target="_blank">In zijn indieningsdocument</a> De SEC benadrukte dat Kwon en Terraform misleiding hebben gebruikt om de investeerders ervan te overtuigen dat UST en LUNA waardevolle investeringsactiva waren.</p>
<p>Als voorbeeld noemde de SEC de allusie van Terraform dat Chai, een populaire Koreaanse online betaalplatform, zijn blockchain gebruikte om handelaarsbetalingen te vergemakkelijken. Om de gebruikers te overtuigen dat Terra blockchain samenwerkte met Chai, voegde het team valse transacties toe aan zijn blockchain.</p>
<p>Het uiteindelijke doel van de SEC-rechtszaken tegen Terraform en Kwon was het verkrijgen van een permanent verbod, vooroordeelsrente, teruggave van wederrechtelijk verkregen voordeel en civielrechtelijke sancties. Overigens komt het indienen van een samenvattende uitspraak door de SEC na een federale jury van 12 personen die Sam Bankman-Fried, de voormalige CEO en oprichter van de FTX crypto exchange, schuldig bevond aan verschillende aanklachten. Dit volgde ook op Terraform en Kwon’s indiening van hun eigen verzoek om een samenvattende uitspraak.</p>
<h2 id="h2-Terraform20en20Kwon20hebben20een20verzoek20tot20samenvatting20van20het20vonnis20ingediend339622"><a name="Terraform en Kwon hebben een verzoek tot samenvatting van het vonnis ingediend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Terraform en Kwon hebben een verzoek tot samenvatting van het vonnis ingediend</h2><p>De basis van Terraform en Kwon’s oproep tot samenvattingsoordeel is dat de SEC niet voorbij twijfel heeft bewezen dat Terraform en Kwon de genoemde misdaden hebben gepleegd. In feite voert de SEC al twee jaar uitgebreid onderzoek uit tegen de beklaagden om concrete bewijzen tegen hen te vinden.</p>
<p>De beklaagden hebben de aanklacht van de SEC ontkend dat ze niet-geregistreerde effecten hebben verkocht, en beweren dat hun crypto-activa niet aan alle criteria van de Howey-test voldoen. Aan de andere kant handhaaft de SEC haar standpunt dat stablecoins crypto-effecten zijn. Het juridische team van Terraform en Kwon beschuldigt ook de SEC ervan ten onrechte te beweren dat het blockchainbedrijf fondsen heeft overgemaakt naar zijn Zwitserse rekeningen.</p>
<p>De juridisch adviseur van Terraform en Kwon verzoekt daarom de federale rechtbank om <a href="https://www.gate.io/zh-tw/blog_detail/3319/sec-vs-ripple-case-extended-to-end-2024" target="_blank">Laat de zaak van de SEC tegen Terraform vallen</a>. Ondertussen probeert Kwon, de voormalig CEO van Terraform die vastzit in Montenegro, de inspanningen van de SEC om hem uitgeleverd te krijgen aan de Verenigde Staten tegen te gaan.</p>
<h2 id="h2-SEC20tegen20Terraform20en20Kwon20Case20Chronologie252410"><a name="SEC tegen Terraform en Kwon Case Chronologie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC tegen Terraform en Kwon Case Chronologie</h2><p>De SEC heeft een rechtszaak aangespannen tegen Terraform Labs, een in Singapore gevestigd bedrijf, en Kwon, de oprichter en CEO, wegens het organiseren van een crypto-investeringsregeling ter waarde van miljarden dollars. Sindsdien <a href="https://www.gate.io/blog_detail/2238/do-kwon-reaches-5-star-wanted-level-as-sec-brings-more-fraud-charges" target="_blank">de zaak van de SEC tegen Terraform</a> was voor de Amerikaanse federale rechtbank.</p>
<p>Op 31 juli wees rechter Jed Rakoff van de United States District Court for the Southern District of New York (SDNY) de motie van de verdediging af om de aanklachten af te wijzen in de zaak SEC v. Terraform Labs.</p>
<p>Rechter Rakoff weigerde ook het vonnis van rechter Analisa Torres in de SDNY op te volgen in de zaak. <a href="https://www.gate.io/blog_detail/3379/xrp-soars-sec-drops-charges-ripples-leaders" target="_blank">SEC v. Ripple Labs zaak</a> betrekking hebben op crypto-effecten. Hij heeft ook niet ingestemd met het argument dat <a href="https://www.gate.io/uk/blog_detail/2708/sec-labels-37-cryptocurrencies-as-securities-implications-for-trading" target="_blank">alle stablecoins zijn effecten</a>. Opmerkelijk is dat hij heeft gesteld dat de Howey-test beleggingsactiva niet indeelt als effecten op basis van waar ze worden verkocht en wie ze koopt.</p>
<p>De recente ontwikkelingen, zoals we eerder hebben opgemerkt, omvatten zowel de indieningen van de SEC als het Terraform Legal-team van moties voor een samenvattende afwijzing van de SEC. <a href="https://www.gate.io/es/blog_detail/2430/terra-luna-tokens-fall-steeply-on-do-kwon-s-arrest" target="_blank">vs. Do Kwon zaak</a>.</p>
<h2 id="h2-Conclusie383608"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Zowel de SEC als het juridische team van Terraform Labs hebben verzoekschriften ingediend voor een samenvattende beoordeling. Op dit moment heeft de federale rechtbank nog geen beslissing genomen over het al dan niet toewijzen van het gevraagde samenvattende oordeel. Het Terraform-team heeft betoogd dat de SEC niet heeft aangetoond dat er sprake is van een effectenaanbod. Aan de andere kant stelt de SEC dat er voldoende bewijs is om wangedrag van Terraform en Kwon te bewijzen.</p>
<h2 id="h2-Veelgestelde20vragen20over20Terraform20Labs197850"><a name="Veelgestelde vragen over Terraform Labs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Terraform Labs</h2><h3 id="h3-Wat20is20de20klacht20van20de20SEC20tegen20Terraform191840"><a name="Wat is de klacht van de SEC tegen Terraform?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de klacht van de SEC tegen Terraform?</h3><p>De belangrijkste beschuldiging van de SEC tegen Terraform is dat het bedrijf een financieel schema heeft opgezet om investeerders van hun geld te bedriegen. Het beweerde dat Terraform investeerders voor meer dan $45 miljard heeft bedrogen die ze hebben geïnvesteerd in verschillende crypto activa, waaronder gespiegelde activa (mAssets) Terra Classic (LUNC), Mirror Protocol (MIR) en Terra Classic USD (USTC).</p>
<h3 id="h3-Waarvan20beschuldigde20de20SEC20Terraform620011"><a name="Waarvan beschuldigde de SEC Terraform?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarvan beschuldigde de SEC Terraform?</h3><p>De SEC beschuldigde Terraform ervan een frauduleus financieel investeringsprogramma te exploiteren dat betrokken was bij cryptocurrencies. Het beweert dat Terraform en Kwon zijn klanten voor meer dan $45 miljard hebben opgelicht.</p>
<h3 id="h3-Wat20is20de20Terraform20controverse736061"><a name="Wat is de Terraform controverse?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de Terraform controverse?</h3><p>Terraform beschuldigde Citadel Securities ervan bij te dragen aan de TerraUSD (UST) <a href="https://www.gate.io/blog_detail/1302/the-impact-of-usdt-depegging-on-the-crypto-market" target="_blank">de-ankeringsevenement</a>. Terraform beweert dat Citadel Securities UST destabiliseerde door te shorten, wat leidde tot de ineenstorting ervan.</p>
<h3 id="h3-Wie20bezit20Terraform329815"><a name="Wie bezit Terraform?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie bezit Terraform?</h3><p>Do Kwon en Daniel Shin hebben Terraform opgericht en ontwikkeld tot een van de toonaangevende blockchains tegen 2022. Het staat bekend om zijn stablecoin, TerraUSD, en <a href="https://www.gate.io/learn/articles/what-is-luna/114" target="_blank">LUNA-token</a> die vorig jaar implodeerde.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Onderzoeker bij Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen wordt er juridische stappen ondernomen bij schending van het auteursrecht.<br></div><p></p><br></div></div></div>