RkJJIGVtZXR0ZSB1biBhdnZpc28gc3VpIHNlcnZpemkgZGkgY3JpcHRvdmFsdXRhIG5vbiByZWdpc3RyYXRpIGluIG1lenpvIGEgcHJlb2NjdXBhemlvbmkgcGVyIGZyb2Rp

2024-05-08, 02:01

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR214346"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>L’FBI ha avvertito i suoi cittadini di smettere di investire in aziende criptate non registrate.</p>
<p>Gli utenti di criptovalute possono verificare presso FinCEN per scoprire se un’azienda di criptovalute ha registrato i suoi servizi presso gli Stati Uniti.</p>
<p>Le misure di conoscersi il cliente e anti-riciclaggio di denaro possono aiutare a prevenire frodi cripto.</p>
<h2 id="h2-Introduzione924457"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli Stati Uniti, attraverso le sue diverse agenzie regolatorie come l’FBI, stanno assumendo il ruolo di guida nell’applicare le proprie normative finanziarie che si applicano al settore della blockchain. Anche se in passato si era concentrato solo sulle misure di contenzioso, di recente ha iniziato a educare i suoi cittadini contro gli investimenti in servizi crittografici non autorizzati.</p>
<p>Oggi analizzeremo l’avvertimento dell’FBI ai suoi cittadini di astenersi dal investire in imprese di criptovalute non registrate. Discuteremo anche come gli investitori di criptovalute possono verificare se un’impresa di criptovalute è autorizzata a operare negli Stati Uniti.</p>
<h2 id="h2-Servizi20crittografici20di20avviso20FBI199295"><a name="Servizi crittografici di avviso FBI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Servizi crittografici di avviso FBI</h2><p>L’FBI degli Stati Uniti ha avvertito i suoi cittadini di non utilizzare servizi di trasmissione di criptovalute che non sono stati registrati come Soggetti che svolgono servizi di denaro (MSB), come stabilito dalla legge federale statunitense. L’autorità di regolamentazione ha spiegato i rischi dei servizi di criptovalute che tali attività commerciali pongono ai loro utenti.</p>
<p>Nella maggior parte dei casi, tali attività sono carenti in termini di <a href="https://www.gate.io/learn/articles/what-is-anti-money-laundering/81" target="_blank">conformità antiriciclaggio</a> crypto. Il Federal Bureau of Investigation (FBI) ha chiarito la posizione degli Stati Uniti sulla registrazione e l’operatività di Money Services Businesses (MSB) tramite un comunicato stampa governativo.<br><img src="https://gimg2.gateimg.com/image/article/17151332701.jpg" alt=""><br>FBI ha avvertito gli americani di non utilizzare servizi di trasferimento di denaro non autorizzati - FBI</p>
<p>In sostanza, tutti i servizi di trasmissione di denaro cripto negli Stati Uniti devono registrarsi presso la Financial Crimes Enforcement Network (FinCEN) prima di operare.</p>
<p>Pertanto, la cosa migliore che gli investitori possono fare per verificare se un progetto di criptovaluta è autorizzato è controllare con FinCEN. Tuttavia, l’FBI ha sottolineato che il fatto che un’azienda criptovalutaria sia registrata presso FinCEN non significa che sia legittima e sicura da utilizzare. Ogni investitore dovrebbe quindi effettuare ulteriori ricerche.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/384/cryptocurrency-laws-in-united-states-and-other-countries" target="_blank">Leggi sulle criptovalute negli Stati Uniti e in altri paesi</a></p>
<p>Una delle cose che un investitore dovrebbe convalidare è se la piattaforma di investimento raccoglie informazioni Know Your Customer (KYC crypto). Conosci il tuo cliente è un insieme di passaggi che le aziende compiono per verificare l’identità dei clienti come mezzo per comprendere i loro rischi finanziari e le attività correlate.</p>
<h2 id="h2-Come20potrebbero20essere20influenzati20gli20utenti20di20criptovalute20che20utilizzano20servizi20di20trasmissione20di20denaro20in20criptovalute20non20registrati966587"><a name="Come potrebbero essere influenzati gli utenti di criptovalute che utilizzano servizi di trasmissione di denaro in criptovalute non registrati?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come potrebbero essere influenzati gli utenti di criptovalute che utilizzano servizi di trasmissione di denaro in criptovalute non registrati?</h2><p>Ci sono diversi modi in cui gli investitori che utilizzano servizi di trasmissione di denaro non registrati possono essere influenzati. Il primo rischio è che alcune di queste attività illegali legate alle criptovalute potrebbero non essere legittime, il che potrebbe comportare la perdita diretta dei fondi investiti. Ad esempio, alcune di esse potrebbero chiudere le loro attività e sparire con i fondi degli investitori. D’altro canto, alcuni potrebbero appropriarsi dei soldi degli investitori.</p>
<p>In secondo luogo, i servizi delle persone che investono in attività non conformi a KYC crypto potrebbero essere interrotti durante i processi di lite. Ad esempio, i regolatori statunitensi potrebbero utilizzare azioni di applicazione legale per fermare le operazioni di determinate attività su base temporanea o permanente. Ad esempio, il FBI potrebbe farlo se le criptovalute dei clienti sono mescolate con fondi ottenuti illegalmente.</p>
<p>In un recente <a href="https://www.ic3.gov/Media/Y2024/PSA240425" rel="nofollow noopener noreferrer" target="_blank">comunicato stampa l’FBI ha dichiarato</a> I servizi di trasferimento di denaro delle criptovalute che violano intenzionalmente la legge o agevolano consapevolmente transazioni illegali saranno oggetto di indagini da parte delle forze dell’ordine. L’utilizzo di un servizio che non rispetta i propri obblighi legali potrebbe metterti a rischio di perdere l’accesso ai fondi dopo che le operazioni di contrasto delle forze dell’ordine hanno preso di mira tali attività commerciali.</p>
<p>Anche se l’attuale avvertimento dell’FBI contro l’uso di Money Services Businesses che non rispettano le attuali leggi sul Conosci il tuo cliente (KYC) e Anti-Money Laundering (AML) sembra generale, alcuni analisti ritengono che sia principalmente rivolto contro i servizi di mixing di criptovalute come Tornado Cash e Samourai.</p>
<p>A riguardo di questo, una pubblicazione di Cointelegraph citava <a href="https://cointelegraph.com/news/fbi-warning-crypto-money-transmitter-appears-aimed-samouri-wallet" rel="nofollow noopener noreferrer" target="_blank">Michael Balcina, il partner di Digital Asset presso Piper Alderman Lawyers, ha dichiarato</a>, “Sebbene sembri un tentativo di avvertire i consumatori riguardo agli strumenti di privacy basati su smart contract come Samouri o Tornado Cash, si tratta di un avvertimento molto generale che trascura molti dettagli su come operano i sistemi decentralizzati.”</p>
<p>E Bacina ritiene che qualsiasi azione di contrasto degli Stati Uniti contro le attività di criptovaluta non autorizzate aiuterà a proteggere gli investitori. Ha aggiunto: “Più presto la regolamentazione su misura e le indicazioni chiare per le criptovalute sostituiranno la regolamentazione tramite il contrasto, migliori saranno gli esiti per i consumatori.”</p>
<p>In un post di X, Ryan Sean Adams, co-fondatore di Bankless, ha suggerito che l’FBI sta prendendo di mira sviluppatori privati, come mostra la prossima schermata.<br><img src="https://gimg2.gateimg.com/image/article/17151334172.jpg" alt=""><br>Origine: x.com</p>
<h2 id="h2-Segnali20dallarme20come20identificare20e20evitare20i20servizi20di20cripto20non20registrati458834"><a name="Segnali d’allarme: come identificare e evitare i servizi di cripto non registrati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Segnali d’allarme: come identificare e evitare i servizi di cripto non registrati</h2><p>Nella sua dichiarazione al pubblico, l’FBI ha spiegato chiaramente come i suoi cittadini possono facilmente identificare le imprese di servizi crittografici non registrate. I servizi crittografici registrati di solito richiedono informazioni sul Conosci il tuo cliente (KYC). Tali protocolli KYC valutano di solito diligentemente i rischi associati agli investitori, il che potrebbe ridurre i casi di frode crittografica.</p>
<p>Notizie correlate: <a href="https://www.gate.io/learn/articles/how-blockchain-technology-will-impact-the-banking-industry/2696" target="_blank">Come la tecnologia blockchain avrà un impatto sull’industria bancaria</a></p>
<p>L’ufficio ha detto: “Fate attenzione ai servizi finanziari che non richiedono informazioni KYC, incluse nome, data di nascita, indirizzo e ID, prima di consentire l’invio o la ricezione di denaro o criptovalute.”</p>
<p>Come accennato in precedenza, l’agenzia ha consigliato al pubblico di verificare se un MSB è registrato con il <a href="https://www.fincen.gov/msb-state-selector" rel="nofollow noopener noreferrer" target="_blank">Financial Crimes Enforcement Network del Dipartimento del Tesoro degli Stati Uniti</a> (FinCEN). Tuttavia, ha ulteriormente messo in guardia contro l’investimento in un protocollo KYC semplicemente perché è registrato presso il FinCEN. Ha spiegato: ‘L’inclusione di un’azienda sulla pagina web della ricerca dei registranti di MSB non è una raccomandazione, una certificazione di legittimità o un’approvazione dell’azienda da parte di qualsiasi agenzia governativa.’</p>
<p>Anche l’FBI ha consigliato ai cittadini statunitensi di non utilizzare un’applicazione solo perché è presente sull’App Store o su altre piattaforme simili. Il motivo è che alcune delle app presenti su tali piattaforme potrebbero non essere conformi alla legge sulle criptovalute degli Stati Uniti.</p>
<h2 id="h2-Correlazione20tra20lassenza20dei20protocolli20KYC20e20laumento20della20probabilit20di20truffe124965"><a name="Correlazione tra l’assenza dei protocolli KYC e l’aumento della probabilità di truffe" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Correlazione tra l’assenza dei protocolli KYC e l’aumento della probabilità di truffe</h2><p>Il FBI ha anche osservato che le piattaforme crittografiche che non dispongono di protocolli KYC sono molto probabilmente i siti di attività criminali, come le truffe. Questo perché gli utenti non vengono verificati, il che consente ai criminali di operare su tali piattaforme. Verificare gli utenti utilizzando KYC durante la registrazione aiuterà principalmente a tracciare le attività criminali e prevenire il riciclaggio di denaro.</p>
<p>KYC aiuta a costruire fiducia e fiducia nelle piattaforme di investimento cripto come gli scambi poiché i clienti sono consapevoli che tutti i partecipanti sono stati verificati. In generale, le piattaforme cripto che hanno protocolli KYC effettuano controlli in corso <a href="https://www.gate.io/learn/articles/top-10-crypto-scams-and-how-to-avoid-them/2556" target="_blank">che prevengono le frodi</a> e altre attività criminali correlate.</p>
<h2 id="h2-Studio20di20caso20Lazione20esecutiva20contro20Samourai20Wallet588510"><a name="Studio di caso: L’azione esecutiva contro Samourai Wallet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Studio di caso: L’azione esecutiva contro Samourai Wallet</h2><p>L’avvertimento dell’FBI sui servizi crittografici è arrivato pochi giorni dopo che il Dipartimento di Giustizia degli Stati Uniti (DOJ) ha intrapreso azioni di contrasto contro Keonne Rodriguez e William Lonergan Hill, i co-proprietari di Samourai - una <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> servizio di portafoglio e cripto-mixing, per l’esercizio di un’attività di trasmissione di denaro non autorizzata, per la conduzione di transazioni illegali per oltre 2 miliardi di dollari e per il riciclaggio di più di 100 milioni di proventi criminali.</p>
<p>Hill è stato arrestato in Portogallo e le autorità degli Stati Uniti stanno cercando la sua estradizione. Inoltre, gli Stati Uniti, in collaborazione con l’Islanda, hanno sequestrato i server web e il dominio di Samourai. In un comunicato stampa, il DOJ ha affermato che Hill e Rodriguez sapevano di facilitare il riciclaggio di denaro.</p>
<p>Damian Williams, un procuratore degli Stati Uniti, <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">ha detto</a>, “Keonne Rodriguez e William Lonergan Hill sono responsabili dello sviluppo, marketing e operatività di Samourai, un servizio di miscelazione di criptovalute che ha eseguito oltre $2 miliardi di transazioni illecite e ha funto da rifugio per i criminali per impegnarsi in riciclaggio di denaro su larga scala.</p>
<p>“Rodriguez e Hill <a href="https://www.gate.io/profile/LBMdFR0AW1xZWCcOAREFAF9YHlUIDAO0O0OO0O0O" target="_blank">presumibilmente consapevolmente agevolato il riciclaggio di oltre 100 milioni di dollari</a> di proventi criminali dalla Silk Road, Hydra Market, e una serie di altre campagne di hacking informatico e frodi. Se riconosciuti colpevoli, possono essere imprigionati fino a 25 anni.</p>
<p>Nel frattempo, Rodriguez, comparendo in un tribunale di Manhattan, si è dichiarato innocente dalle accuse. L’azione di applicazione del portafoglio Samourai evidenzia la necessità per le aziende di criptovalute di bilanciare la conformità legale e la privacy. Inoltre, informa gli utenti di criptovalute sull’uso dei servizi di trasmissione di denaro criptato che rispettano la legge criptata negli Stati Uniti e in altri paesi.</p>
<h2 id="h2-Conclusione247616"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>L’FBI degli Stati Uniti ha avvertito gli utenti di criptovalute negli Stati Uniti di astenersi dall’uso di attività criptografiche non registrate poiché i loro servizi potrebbero essere interrotti come parte di un’azione di applicazione della legge. Ad esempio, il <a href="https://www.gate.io/post/CryptoNews_/status/5538868" target="_blank">Il DOJ ha fermato le operazioni di Samourai</a> che ha accusato di commettere riciclaggio di denaro e di operare servizi di trasferimento di denaro non autorizzati.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Mashell C.</strong>, Ricercatore 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>