Q0ZUQyB3aW50IGhpc3RvcmlzY2hlIGJvZXRlIHZhbiAkMyw0IG1pbGphcmQgaW4gZWVuIGVub3JtZSBCaXRjb2luLWZyYXVkZXphYWs=

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR818146"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De CFTC heeft een historische boete van $3,4 miljard gewonnen voor MTI en Steynberg fraude aanklachten.</p>
<p>De winst van $3,4 miljard zal ontmoedigen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> oplichters en andere cryptocriminelen om investeerders op te lichten.</p>
<p>De CFTC-zaak tegen de MTI-fraude benadrukt de noodzaak van standaardcrypto-regelgeving.</p>
<h2 id="h2-Introductie994710"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De cryptoreguleringsomgeving verandert met belangrijke precedentzaken die worden vastgelegd. We hebben glen gezien waarin landen, vooral de Verenigde Staten, mensen en cryptobedrijven uit andere landen hebben vervolgd omdat ze digitale transacties hebben uitgevoerd die hebben geleid tot verlies van geld voor Amerikaanse burgers. Dit artikel bespreekt de recente overwinning van <a href="https://www.gate.io/blog_detail/1158/main-takeaways-from-the-crypto-bipartisan-bill-by-cynthia-lummis-and-kirsten-gillibrand" target="_blank">CFTC</a> in zijn zaak tegen Steynberg en MTI.</p>
<h2 id="h2-CFTUs20overwinning20tegen20Mirror20Trading20International20Proprietary20Limited20MTI432337"><a name="CFTU’s overwinning tegen Mirror Trading International Proprietary Limited (MTI)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CFTU’s overwinning tegen Mirror Trading International Proprietary Limited (MTI)</h2><p>De Amerikaanse financiële toezichthouder Commodity Futures Trading Commission (CFTC) behaalde een historische overwinning tegen Steynberg, de oprichter en CEO van Mirror Trading International Proprietary Limited (MTI) en zijn bedrijf (MTI), een cryptobedrijf achter de grootste <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> fraude, stelt een geweldig precedent in de industrie.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16837761762001683776135_.pic_hd.jpg" alt=""><br>CFTC - Coindesk</p>
<p>De CFTC heeft een boete van $3,4 miljoen opgelegd aan MIT en Steynberg voor een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gerelateerde fraudezaak waar ze beschuldigd werden van het oplichten van geld van vele Amerikaanse burgers en andere investeerders over de hele wereld.</p>
<p>Rechter Lee Yeakel, de rechter van de districtsrechtbank van Texas, heeft bevolen dat Cornelius Johannes Steynberg en MTI het bedrag moeten betalen voor het frauduleuze grondstoffenschema met bitcoins en vreemde valuta. Van de $1,73 miljard zal $1,73 miljard worden besteed aan het restitueren van de slachtoffers van cryptofraude, terwijl de extra $1,73 miljard een civiele geldboete is.</p>
<p>Hoewel de boete van $3,4 miljoen de grootste is in de geschiedenis van cryptozaken, werd deze toegekend op basis van het feit dat het frauduleuze schema van MIT en Steynberg ook de grootste was in de geschiedenis van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en andere digitale activa. Als zodanig is de straf bedoeld als een strenge waarschuwing tegen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> oplichters en andere daders van frauduleuze crypto-schema’s die hopen de toorn van de wet te ontlopen.</p>
<p>Lees ook: <a href="https://www.gate.io/es/blog_detail/1698/recent-regulatory-actions-and-reports-show-the-cftc-is-more-eager-to-oversee-non-security-cryptocurrencies?lang=en" target="_blank">Recente regelgevende acties en rapporten tonen aan dat de CFTC meer bereid is om toezicht te houden op niet-beveiligde cryptocurrencies.</a></p>
<h2 id="h2-Achtergrondinformatie578356"><a name="Achtergrondinformatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Achtergrondinformatie</h2><p>In juni 2022 heeft de Commodity Futures Trading Commission een civiele handhavingsactie aangespannen tegen Cornelius Johannes Steynberg uit Stellenbosch, een Zuid-Afrikaanse burger en de CEO van Mirror Trading International Proprietary Limited (MTI), een in Zuid-Afrika geregistreerd en opererend bedrijf, wegens fraude en schending van de registratievoorwaarden.</p>
<p>Het g is dat Steynberg, via MTI, een wereldwijde vreemde valuta grondstoffenpool heeft gecreëerd en geëxploiteerd, waardoor investeerders kunnen investeren. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en buitenlandse valuta genereren om inkomstenstromen te genereren. Als gevolg hiervan hebben de depositohouders in totaal $1.733.838.372 bijgedragen aan het schema.</p>
<p>In zijn rechtszaak, <a href="https://www.cftc.gov/PressRoom/PressReleases/8549-22" rel="nofollow noopener noreferrer" target="_blank">de CFTC verklaarde dat</a> het eiste ‘volledige restitutie aan opgelichte investeerders, teruggave van onrechtmatig verkregen winsten, civiele geldboetes, permanente registratie- en handelsverboden, en een permanent verbod op toekomstige overtredingen van de Commodity Exchange Act en CFTC-regels’.</p>
<p>Steynberg gebruikte in feite socialemediaplatforms om argeloze investeerders te verleiden deel te nemen aan het genoemde grondstoffenpoolschema dat MTI exploiteerde. In totaal kreeg het bedrijf 29.421. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> van 23.000 niet-ECP’s uit de Verenigde Staten en andere landen over de hele wereld. De CFTC beweerde dat de beklaagde de investeerders direct en indirect heeft opgelicht.</p>
<p>De CFTC heeft echter duidelijk gemaakt dat de slachtoffers mogelijk geen restitutie kunnen krijgen omdat de beklaagde mogelijk niet over de vereiste middelen beschikt om dit te doen. Via een persbericht, de <a href="https://www.cftc.gov/PressRoom/PressReleases/8696-23" rel="nofollow noopener noreferrer" target="_blank">CFTC zei ook dat</a>“Steynberg is permanent verboden om zich bezig te houden met gedrag dat in strijd is met de Commodity Exchange Act (CEA), zoals ten laste gelegd, zich te registreren bij de CFTC en te handelen op alle CFTC-gereguleerde markten.”</p>
<p>Echter beweerden Steynberg en MTI aan hun kant dat ze bezig waren met een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> investeringspool waar ze BTC off-chain verhandelden via een softwareprogramma of bot-handelsalgoritmen. In feite beweerden ze dat de handelsbots dagelijkse winsten genereerden uit de handelsactiviteiten die ze deelden met de storters.</p>
<p>In reactie hierop zegt de CFTC dat de handelssoftware-bots nep waren en nooit werden gebruikt. In plaats daarvan kwam het geld dat sommige investeerders ontvingen van andere storters. Ook beweert de CFTC dat MTI de verliezen die het leed verborgen hield.</p>
<p>De beschuldiging tegen Steynberg en zijn medewerkers is dat ze een deel van de fondsen hebben geïnvesteerd in dure horloges, onroerend goed en luxe voertuigen. Na het multi-level marketing schema betrokken te hebben <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> Steynberg faalde en werd een voortvluchtige, maar werd opgepakt door Interpol, de internationale criminele politieorganisatie, en wordt vastgehouden in de Republiek Brazilië.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16837763012011683776148_.pic.jpg" alt=""><br>Interpol volgt criminelen - Bitcoinnieuws</p>
<h2 id="h2-Implicaties20van20de20historische20boete20van203420miljard20voor20Steynberg20en20MTI294151"><a name="Implicaties van de historische boete van $3,4 miljard voor Steynberg en MTI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicaties van de historische boete van $3,4 miljard voor Steynberg en MTI</h2><p>Deze zaak heeft aangetoond dat er individuen zijn die plannen bedenken om veel beleggers te bedriegen in de veronderstelling dat de wet hen niet kan pakken. Het feit dat Steynberg en MTI, gevestigd in Zuid-Afrika, zijn veroordeeld door een rechtbank in de Verenigde Staten, is een belangrijk precedent dat zou moeten voorkomen dat potentiële oplichters vergelijkbare BTC-oplichtingsregelingen opzetten of <a href="https://www.gate.io/learn/articles/pyramid-and-ponzi-schemes/154" target="_blank">gerelateerde</a>.</p>
<p>Ten tweede heeft deze zaak het belang van samenwerking tussen verschillende landen en organisaties aangetoond. In dit g werkten de regering van Zuid-Afrika en de regering van Brazilië samen met de Verenigde Staten om Steynberg te arresteren en veroordelen.</p>
<p>In deze context, <a href="https://www.cftc.gov/PressRoom/PressReleases/8696-23" rel="nofollow noopener noreferrer" target="_blank">CFTC zei</a>, “De CFTC waardeert de hulp van de Zuid-Afrikaanse Financial Sector Conduct Authority, de Financial Services Commission van Belize, de Texas State Securities Board, de Alabama Securities Commission, de North Carolina Secretary of State, Securities Division, en de Mississippi.”</p>
<p>In een verwante zin laat de betrokkenheid van Interpol zien dat het niet uitmaakt waar een crypto-fraudeur naartoe verhuist, hij/zij kan worden gearresteerd en geconfronteerd worden met de relevante wet.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/384/" target="_blank">Cryptocurrency wetten in de Verenigde Staten en andere landen</a></p>
<p>Bovendien heeft de CFTC bevestigd dat het altijd waakzaam zal blijven om op te treden tegen personen die de wet overtreden door haar burgers te bedriegen. Ze zei: “De CFTC zal blijven strijden voor de bescherming van klanten en ervoor zorgen dat de daders verantwoordelijk worden gehouden.”</p>
<p>De vervolging van Steynberg heeft aangetoond dat regeringen proactief zijn in het omgaan met misdaden die verband houden met cryptocurrencies. Dat toont ook aan dat nationale regeringen niet langer achterover kunnen leunen wanneer criminelen hun bevolking bedriegen. Op dit moment verwacht de markt dat overheden een toezichthoudende rol zullen blijven spelen in wat er in de cryptocurrency-sector gebeurt.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/768/crypto-pump-and-dump-scams-are-never-worth-it-here-is-why" target="_blank">Crypto Pump and Dump Scams zijn het nooit waard, hier is waarom</a></p>
<p>Opnieuw is de succesvolle vervolging van MTI en Steynberg voor de cryptofraudezaak een duidelijke boodschap aan cryptobedrijven dat zij zich moeten houden aan nationale wetten en cryptowetgeving in landen waar hun klanten wonen. Het is ook opmerkelijk dat de Verenigde Staten geen enkel bedrijf kunnen toestaan om zijn burgers te bedriegen. Daarom moeten cryptoprojecten transparant en verantwoordelijk zijn in hun activiteiten.</p>
<p>Desalniettemin zou de verklaring van CFTC dat haar overwinning in dit g mogelijk niet leidt tot restitutie van het geld van de investeerders, regeringen moeten dwingen om strikte wetgeving op te stellen om crypto-investeerders te beschermen.</p>
<h2 id="h2-Conclusie901525"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De overwinning van CFTC in zijn juridische strijd tegen Steynberg en MTI heeft een sterke precedent geschapen dat crypto criminelen zoals oplichters kunnen worden opgepakt en vervolgd, ongeacht hun geografische locatie. Het heeft ook de noodzaak benadrukt van samenwerking tussen regeringen en andere organisaties bij de bestrijding van cryptovaluta misdaden.</p>
<h2 id="h2-Veelgestelde20vragen438142"><a name="Veelgestelde vragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen</h2><h3 id="h3-Hoe20onderzoek20je20cryptocurrency20fraude785268"><a name="Hoe onderzoek je cryptocurrency fraude?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe onderzoek je cryptocurrency fraude?</h3><p>Men kan een cryptocurrency fraude onderzoeken door gebruik te maken van open-source intelligence en Know Your Customer om de eigenaar van het adres dat de fraude heeft gepleegd te identificeren. Van daaruit schakelt u wetshandhavingsagenten in om aanvullende gegevens te verzamelen.</p>
<h3 id="h3-Kan20ik20mijn20geld20terugkrijgen20als20ik20opgelicht20word20met20bitcoin925172"><a name="Kan ik mijn geld terugkrijgen als ik opgelicht word met bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan ik mijn geld terugkrijgen als ik opgelicht word met bitcoin?</h3><p>Aangezien het niet mogelijk is om een om te keren. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bij transactie kunt u alleen uw <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> terug als de persoon naar wie je het stuurt besluit het terug te sturen. Je kunt het ook terugkrijgen als de oplichter die wordt geïdentificeerd en vervolgd, ermee instemt het terug te geven.</p>
<h3 id="h3-Kan20een20crypto20oplichter20worden20opgespoord438854"><a name="Kan een crypto oplichter worden opgespoord?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan een crypto oplichter worden opgespoord?</h3><p>Een crypto-zwendelaar kan worden opgespoord met behulp van open-source intelligence en Know Your Customer (KYC). Niettemin kunnen niet alle crypto-zwendelaars worden opgespoord.</p>
<h3 id="h3-Kan20bitcoin20naar20mij20worden20teruggeleid756771"><a name="Kan bitcoin naar mij worden teruggeleid?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> naar mij worden teruggeleid?</h3><p>De enige manier waarop mensen de afzender kunnen identificeren <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is via zijn/haar digitale portemonnee adres. Ze kunnen u niet identificeren aan de hand van uw naam of andere gegevens.</p>
<h3 id="h3-Wat20kunt20u20doen20als20u20bent20opgelicht20met20cryptocurrency144830"><a name="Wat kunt u doen als u bent opgelicht met cryptocurrency?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat kunt u doen als u bent opgelicht met cryptocurrency?</h3><p>Als u opgelicht wordt met cryptocurrency, kunt u de transactie melden bij de relevante autoriteit in uw land. Als er geen autoriteit is die verdachte cryptocurrency-transacties behandelt in uw land, kunt u niets doen.</p>
<h3 id="h3-Wie20kan20u20helpen20bij20cryptofraude171083"><a name="Wie kan u helpen bij cryptofraude?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie kan u helpen bij cryptofraude?</h3><p>Een relevante autoriteit in uw land kan u helpen als u <a href="https://www.gate.io/learn/course/crypto-security-fraud-safety-and-hack" target="_blank">te maken krijgen met crypto fraude</a>. Echter, als er geen geautoriseerde instantie in uw land is om glen van crypto fraude af te handelen, kunt u er niets aan doen.</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 op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>