RkJJIGdlZWZ0IHdhYXJzY2h1d2luZyB1aXQgb3ZlciBuaWV0LWdlcmVnaXN0cmVlcmRlIGNyeXB0by1kaWVuc3RlbiB0ZSBtaWRkZW4gdmFuIHpvcmdlbiBvdmVyIGZyYXVkZQ==

2024-05-08, 02:01

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR274510"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De FBI heeft zijn burgers gewaarschuwd om te stoppen met investeren in niet-geregistreerde crypto-bedrijven.</p>
<p>Crypto-gebruikers kunnen bij FinCEN controleren of een crypto-bedrijf zijn diensten heeft geregistreerd bij de Verenigde Staten.</p>
<p>Know your customer and anti-money laundering measures can help to prevent crypto frauds.</p>
<h2 id="h2-Inleiding569999"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De Verenigde Staten nemen, via verschillende regulerende instanties zoals de FBI, het voortouw bij het handhaven van hun financiële regelgeving die van toepassing is op de blockchainsector. Hoewel het zich in het verleden alleen richtte op gerechtelijke maatregelen, is het onlangs begonnen met het voorlichten van zijn burgers over het investeren in niet-gelicentieerde crypto-diensten.</p>
<p>Vandaag analyseren we de waarschuwing van de FBI aan zijn burgers om af te zien van investeringen in niet-geregistreerde crypto bedrijven. We zullen ook bespreken hoe crypto investeerders kunnen controleren of een crypto bedrijf al dan niet een vergunning heeft om actief te zijn in de Verenigde Staten.</p>
<h2 id="h2-FBI20Waarschuwing20Crypto20Services414400"><a name="FBI Waarschuwing Crypto Services" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FBI Waarschuwing Crypto Services</h2><p>De Amerikaanse Federal Bureau of Investigation (FBI) heeft zijn burgers gewaarschuwd om geen gebruik te maken van crypto-geld verzendservices die niet zijn geregistreerd als Money Services Businesses (MSB), zoals de federale wet van de Verenigde Staten voorschrijft. De regulerende autoriteit legde uit welke risico’s dergelijke bedrijven met zich meebrengen voor hun gebruikers.</p>
<p>In de meeste glen schieten dergelijke bedrijven tekort op het gebied van <a href="https://www.gate.io/learn/articles/what-is-anti-money-laundering/81" target="_blank">naleving van anti-witwaspraktijken</a> crypto. Het Federal Bureau of Investigation (FBI) verduidelijkte de positie van de Verenigde Staten over de registratie en werking van Money Services Businesses (MSB) via een persbericht van de overheid.<br><img src="https://gimg2.gateimg.com/image/article/17151332701.jpg" alt=""><br>De FBI waarschuwde Amerikanen om geen gebruik te maken van niet-gelicenseerde geldovermakingsdiensten - FBI</p>
<p>In principe moeten alle cryptogeldtransmissiediensten in de Verenigde Staten zich registreren bij het Financial Crimes Enforcement Network (FinCEN) voordat ze kunnen opereren.</p>
<p>Daarom is het beste dat investeerders kunnen doen om te controleren of een crypto-project is gelicenseerd, om te controleren bij FinCEN. Desalniettemin benadrukte de FBI dat het feit dat een crypto-bedrijf bij FinCEN is geregistreerd, niet betekent dat het legitiem en veilig is om te gebruiken. Elke investeerder moet daarom aanvullend onderzoek uitvoeren.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/384/cryptocurrency-laws-in-united-states-and-other-countries" target="_blank">Cryptocurrencywetten in de Verenigde Staten en andere landen</a></p>
<p>Een van de dingen die een investeerder moet valideren, is of het investeringsplatform Know Your Customer (KYC crypto) informatie verzamelt. Ken uw klant is een reeks stappen die bedrijven nemen om de identiteit van klanten te verifiëren als een manier om hun financiële risico’s en gerelateerde activiteiten te begrijpen.</p>
<h2 id="h2-Hoe20kunnen20cryptogebruikers20die20ongeregistreerde20cryptogeldtransmissiediensten20gebruiken20worden20benvloed961435"><a name="Hoe kunnen cryptogebruikers die ongeregistreerde cryptogeldtransmissiediensten gebruiken, worden beïnvloed?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kunnen cryptogebruikers die ongeregistreerde cryptogeldtransmissiediensten gebruiken, worden beïnvloed?</h2><p>Er zijn verschillende manieren waarop investeerders die ongeregistreerde geldovermakingsdiensten gebruiken, beïnvloed kunnen worden. Het eerste risico is dat sommige van deze illegale cryptobedrijven mogelijk niet legitiem zijn, wat kan leiden tot direct verlies van geïnvesteerde fondsen. Zo kunnen sommigen van hen hun bedrijven sluiten en verdwijnen met investeringsfondsen. Aan de andere kant kunnen sommigen het geld van investeerders verduisteren.</p>
<p>Ten tweede kunnen de diensten van mensen die investeren in bedrijven die niet voldoen aan KYC crypto tijdens gerechtelijke procedures worden onderbroken. Bijvoorbeeld, Amerikaanse regelgevers kunnen juridische handhavingsacties gebruiken om de activiteiten van bepaalde bedrijven op tijdelijke of permanente basis stop te zetten. Zo kan de FBI dit bijvoorbeeld doen als de cryptomunten van de klant vermengd zijn met fondsen die illegaal zijn verkregen.</p>
<p>Onlangs <a href="https://www.ic3.gov/Media/Y2024/PSA240425" rel="nofollow noopener noreferrer" target="_blank">persbericht verklaarde de FBI</a>, “Cryptocurrency money transmitting services die opzettelijk de wet overtreden of bewust illegale transacties vergemakkelijken, zullen worden onderzocht door wetshandhavingsinstanties. Het gebruik van een dienst die niet voldoet aan haar wettelijke verplichtingen, kan ertoe leiden dat u het risico loopt om toegang tot fondsen te verliezen nadat wetshandhavingsoperaties zich richten op die bedrijven.”</p>
<p>Hoewel de recente FBI-waarschuwing tegen het gebruik van Money Services Businesses die niet voldoen aan de bestaande Know Your Customer (KYC) en Anti-Money Laundering (AML) wetten algemeen lijkt, geloven sommige analisten dat het vooral gericht is tegen cryptomixingdiensten zoals Tornado Cash en Samourai.</p>
<p>Hierover citeerde een publicatie van Cointelegraph <a href="https://cointelegraph.com/news/fbi-warning-crypto-money-transmitter-appears-aimed-samouri-wallet" rel="nofollow noopener noreferrer" target="_blank">Michael Balcina, de digitale activapartner bij Piper Alderman Advocaten, zoals gezegd</a>, “Hoewel dit een poging lijkt te zijn om consumenten weg te houden van privacytools die worden aangedreven door slimme contracten zoals Samouri of Tornado Cash, is het een zeer brede waarschuwing die een groot deel van de nuance in de werking van gedecentraliseerde en mist.”</p>
<p>En Bacina gelooft dat elk optreden van de Verenigde Staten tegen ongelicentieerde cryptobedrijven zal helpen om investeerders te beschermen. Hij voegde eraan toe: ‘Hoe eerder regelgeving die geschikt is voor cryptogeld, en duidelijke richtlijnen in plaats van handhaving, de betere resultaten zullen zijn voor consumenten.’</p>
<p>In een X-post suggereerde Ryan Sean Adams, medeoprichter van Bankless, dat de FBI zich richt op private ontwikkelaars, zoals blijkt uit de volgende screenshot.<br><img src="https://gimg2.gateimg.com/image/article/17151334172.jpg" alt=""><br>Bron: x.com</p>
<h2 id="h2-Rode20vlaggen20hoe20u20nietgeregistreerde20cryptodiensten20kunt20identificeren20en20vermijden998326"><a name="Rode vlaggen: hoe u niet-geregistreerde cryptodiensten kunt identificeren en vermijden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rode vlaggen: hoe u niet-geregistreerde cryptodiensten kunt identificeren en vermijden</h2><p>In haar verklaring aan het publiek legde de FBI duidelijk uit hoe haar burgers gemakkelijk ongeregistreerde crypto-dienstverlenende bedrijven kunnen identificeren. Geregistreerde crypto-diensten vragen meestal om Know Your Customer (KYC) informatie. Dergelijke KYC-protocollen beoordelen doorgaans nauwgezet de risico’s die gepaard gaan met investeerders, wat het aantal glen van crypto fraude kan verminderen.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/learn/articles/how-blockchain-technology-will-impact-the-banking-industry/2696" target="_blank">Hoe Blockchain Technologie de Banksector zal Beïnvloeden</a></p>
<p>Het Bureau waarschuwt voor financiële diensten die geen KYC-informatie vragen, zoals naam, geboortedatum, adres en ID, voordat u geld of cryptocurrency kunt verzenden of ontvangen.</p>
<p>Zoals eerder aangegeven, heeft de instantie het publiek geadviseerd om te controleren of een MSB is geregistreerd bij de <a href="https://www.fincen.gov/msb-state-selector" rel="nofollow noopener noreferrer" target="_blank">Financiële Criminaliteitsbestrijdingsnetwerk van het Amerikaanse Ministerie van Financiën</a>(FinCEN). Echter, het waarschuwde verder tegen investeren in een KYC-protocol alleen omdat het is geregistreerd bij FinCEN. Het legde uit: “De opname van een bedrijf op de webpagina MSB Registrant Search is geen aanbeveling, certificering van legitimiteit of goedkeuring van het bedrijf door een overheidsinstantie.”</p>
<p>De FBI adviseerde ook de Amerikaanse burgers om een app niet alleen te gebruiken omdat deze te vinden is in de App Store of op andere gerelateerde platforms. De reden hiervoor is dat sommige van de apps die op dergelijke platforms worden gevonden mogelijk niet voldoen aan de crypto-wetgeving van de Verenigde Staten.</p>
<h2 id="h2-Correlatie20tussen20het20ontbreken20van20KYCprotocollen20en20de20verhoogde20kans20op20oplichting604306"><a name="Correlatie tussen het ontbreken van KYC-protocollen en de verhoogde kans op oplichting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Correlatie tussen het ontbreken van KYC-protocollen en de verhoogde kans op oplichting</h2><p>De FBI heeft ook vastgesteld dat crypto platforms die geen KYC-protocollen hebben, zeer waarschijnlijk de locaties zijn van criminele activiteiten, zoals oplichting. Dit komt doordat gebruikers niet gescreend worden, waardoor criminelen op dergelijke platforms kunnen opereren. Het verifiëren van gebruikers met behulp van KYC tijdens de onboarding zal voornamelijk helpen bij het opsporen van criminele activiteiten en het voorkomen van witwassen van geld.</p>
<p>KYC helpt vertrouwen en vertrouwen op te bouwen in crypto-investeringsplatforms zoals beurzen, omdat klanten zich ervan bewust zijn dat alle deelnemers zijn geverifieerd. Over het algemeen voeren crypto-platforms met KYC-protocollen doorlopende controles uit. <a href="https://www.gate.io/learn/articles/top-10-crypto-scams-and-how-to-avoid-them/2556" target="_blank">die fraude voorkomen</a> en andere gerelateerde criminele activiteiten.</p>
<h2 id="h2-Casestudy20De20handhavingsmaatregel20tegen20Samourai20Wallet209378"><a name="Casestudy: De handhavingsmaatregel tegen Samourai Wallet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Casestudy: De handhavingsmaatregel tegen Samourai Wallet</h2><p>De waarschuwing van de FBI voor cryptodiensten kwam enkele dagen nadat het Amerikaanse ministerie van Justitie (DOJ) handhavingsmaatregelen nam tegen Keonne Rodriguez en William Lonergan Hill, de mede-eigenaars van Samourai—a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> portemonnee en crypto-mixingservice - voor het exploiteren van een niet-gelicentieerd geldovermakingsbedrijf, het uitvoeren van meer dan $2 miljard aan onwettige transacties en het witwassen van meer dan $100 miljoen aan criminele opbrengsten.</p>
<p>Hill werd in Portugal gearresteerd, en de Amerikaanse autoriteiten proberen zijn uitlevering te bewerkstelligen. Bovendien hebben de VS, in samenwerking met IJsland, de web servers en domein van Samourai in beslag genomen. In een persbericht beweerde het DOJ dat Hill en Rodriguez wisten dat ze geld witwassen faciliteerden.</p>
<p>Damian Williams, een Amerikaanse officier van justitie, <a href="https://www.justice.gov/usao-sdny/pr/founders-and-ceo-cryptocurrency-mixing-service-arrested-and-charged-money-laundering" rel="nofollow noopener noreferrer" target="_blank">zei</a>, “Keonne Rodriguez en William Lonergan Hill zijn verantwoordelijk voor de ontwikkeling, marketing en exploitatie van Samourai, een cryptocurrency mixing service die meer dan $2 miljard aan onwettige transacties heeft uitgevoerd en diende als een schuilplaats voor criminelen om zich bezig te houden met grootschalige witwaspraktijken.</p>
<p>“Rodriguez en Hill <a href="https://www.gate.io/profile/LBMdFR0AW1xZWCcOAREFAF9YHlUIDAO0O0OO0O0O" target="_blank">naar verluidt bewust de witwaspraktijken van meer dan $100 miljoen gefaciliteerd</a> van criminele opbrengsten van de Silk Road, Hydra Market en tal van andere computervredebreuk en fraudecampagnes.” Als ze schuldig worden bevonden, kunnen ze tot 25 jaar gevangenisstraf krijgen.</p>
<p>Ondertussen verklaarde Rodriguez, die in een rechtbank in Manhattan verscheen, onschuldig te zijn aan de aanklachten. De handhavingsactie van Samourai Wallet benadrukt de noodzaak voor crypto-bedrijven om een balans te vinden tussen wettelijke naleving en privacy. Het informeert ook crypto-gebruikers over het gebruik van cryptogeldtransmissiediensten die voldoen aan de cryptowetgeving in de Verenigde Staten en andere landen.</p>
<h2 id="h2-Conclusie971876"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De Amerikaanse federale recherche (FBI) heeft cryptogebruikers in de Verenigde Staten gewaarschuwd om geen gebruik te maken van niet-geregistreerde cryptobedrijven, aangezien hun diensten mogelijk worden beëindigd als onderdeel van handhavingsmaatregelen. Bijvoorbeeld, de <a href="https://www.gate.io/post/CryptoNews_/status/5538868" target="_blank">DOJ stopte de activiteiten van Samourai</a> die het beschuldigde van het plegen van witwassen en het exploiteren van niet-vergunde geldovermakingsdiensten.</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 mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>