QmluYW5jZSB2cyBTRUMgRXJpYyBoYSByYWdnaXVudG8gaWwgcGljY28/IExlIG5vdGl6aWUgZGVnbGkgYWNjb3BwaWFtZW50aSBkZWxsYSBzZXR0aW1hbmE=

2023-06-28, 09:25

<p><img src="https://gimg2.gateimg.com/blog/1679447253500249423shendu.jpeg" alt=""></p>
<h2 id="h2-TL20DR486632"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La SEC ha citato in giudizio Binance per aver fornito servizi correlati ai titoli senza registrarsi presso di essa.</p>
<p>La SEC sostiene che Binance e Changpeng Zhao hanno messo a rischio i fondi investiti dai suoi cittadini consegnandoli a terzi.</p>
<p>Il valore di <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> è sceso dopo che la SEC ha citato in giudizio Binance.<br>Alcuni analisti di mercato ritengono che il prezzo di <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> possa scendere al suo minimo del 2022 di $180.</p>
<h2 id="h2-Introduzione571249"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La repressione delle attività criptate degli Stati Uniti sembra continuare poiché ha intentato cause contro grandi borse di criptovalute che operano nel paese, Binance e Coinbase. La Securities and Exchange Commission (SEC) ha accusato le due borse di violare le leggi sulla sicurezza degli Stati Uniti.</p>
<p>Oggi ci concentriamo sulla causa della SEC contro Binance. Discuteremo anche la reazione di Binance a questo sviluppo legale.</p>
<h2 id="h2-Cause20legali20della20SEC20contro20gli20scambi20di20criptovalute512384"><a name="Cause legali della SEC contro gli scambi di criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cause legali della SEC contro gli scambi di criptovalute</h2><p>Il 5 e 6 giugno, la Securities and Exchange Commission (SEC) ha annunciato le sue accuse legali contro Binance, la più grande criptovaluta operante negli Stati Uniti. Questa mossa mostra la tenacia della volontà degli Stati Uniti di imporre la propria autorità sulle questioni legate alle criptovalute.</p>
<p>Il crollo della borsa FTX ha dato alla SEC un ulteriore impulso per regolamentare le attività crypto per proteggere i consumatori. Nonostante i casi della SEC contro Coinbase e Binance siano leggermente diversi, hanno qualcosa in comune.<br><img src="https://gimg2.gateimg.com/image/article/16879439514171687943937_.pic_hd.jpg" alt=""><br>CEO di Binance - Changpeng Zhao</p>
<p>La SEC accusa entrambi gli scambi di non aver registrato alcune criptovalute come titoli dopo la recente designazione di 68 asset crittografici in tale categoria. Secondo le leggi degli Stati Uniti, tutte le aziende che si occupano di titoli dovrebbero prima registrare tali asset di investimento prima di consentire al pubblico di acquistarli.</p>
<p>In un <a href="https://www.sec.gov/news/press-release/2023-101" rel="nofollow noopener noreferrer" target="_blank">comunicato stampa, datato 5 giugno, la SEC accusa “Binance</a> e BAM Trading di operare scambi di titoli nazionali non registrati, intermediari, e agenzie di compensazione.</p>
<p>Accusa inoltre: “Binance e BAM Trading di offerta e vendita non registrate di criptovalute di Binance, tra cui un cosiddetto token di scambio, BNB, una cosiddetta stablecoin, <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a> (BUSD), alcuni prodotti di crypto-lending e un programma di staking come servizio.”</p>
<p>In modo significativo, la SEC sotto la guida del presidente Gensler, è determinata a designare molte criptovalute come titoli. Infatti, Gensler ha recentemente affermato che quasi tutte le criptovalute sono titoli. Tuttavia, il tempo dirà se la SEC designa tutti gli asset crittografici come titoli.</p>
<p>Leggi anche: <a href="https://www.gate.io/ru/blog_detail/2448/cz-sued-by-cftu-another-turn-of-the-crypto-saga" target="_blank">CZ Sued by CFTU: Another Turn of The Crypto Saga</a></p>
<h2 id="h2-Le20accuse20contro20Binance771723"><a name="Le accuse contro Binance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le accuse contro Binance</h2><p>Discutiamo brevemente le accuse che la SEC ha mosso contro Binance. Il 5 giugno di quest’anno, la SEC ha presentato 13 accuse contro Binance Holdings Ltd, il fondatore e CEO di Binance Exchange Changpeng Zhao e BAM Trading Services Inc. (“BAM Trading”), che collabora con Binance per gestire la piattaforma di trading di asset crittografici.</p>
<p>La SEC ha accusato che, nonostante Binance affermi di limitare gli utenti residenti negli Stati Uniti dal fare trading sulla sua piattaforma, essi permette clandestinamente ai suoi cittadini di alto valore di fare trading con loro.</p>
<p>Si afferma anche che, sebbene Binance.US sostenga di essere indipendente da Binance Global Unit, in realtà ricade sotto il suo controllo e supervisione.</p>
<p>Un’altra accusa è che Binance eserciti molto controllo sugli asset dei suoi clienti al punto da mescolarli e dirottarli verso altri usi ed entità come Sigma Chain, che Zhao controlla.</p>
<p>La SEC ritiene anche che Binance e/o Zhao abbiano svolto attività manipolative. In un <a href="https://www.sec.gov/news/press-release/2023-101" rel="nofollow noopener noreferrer" target="_blank">nel comunicato stampa si è detto</a> “La denuncia della SEC sostiene inoltre che BAM Trading e BAM Management US Holdings, Inc. (“BAM Management”) hanno ingannato gli investitori sui controlli di trading inesistenti sulla piattaforma Binance.US, mentre Sigma Chain si è impegnata in un trading manipolativo che ha gonfiato artificialmente il volume degli scambi della piattaforma”.</p>
<p>Le accuse contro il CEO di Binance Zhao si basano sul fatto che egli è colui che controlla le attività di Binance e BAM Trading. Inoltre, la SEC ritiene che le due entità siano “borse valori nazionali non registrate, broker-dealer e agenzie di compensazione”.</p>
<p>La dichiarazione del presidente della SEC Gary Gensler riassume chiaramente le accuse contro Binance, BAM Trading e il CEO Changpeng Zhao. Ha detto: “Attraverso tredici accuse, sosteniamo che Zhao e le entità di Binance siano state coinvolte in una vasta rete di inganni, conflitti di interesse, mancanza di divulgazione e evasione calcolata della legge.”</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2238/do-kwon-reaches-5-star-wanted-level-as-sec-brings-more-fraud-charges" target="_blank">La SEC accusa Terraform Labs e Do Kwon per aver orchestrato una multi-miliardaria sicurezza di asset crittografici</a></p>
<h2 id="h2-Potenziali20rischi20delle20attivit20di20Binance20sui20fondi20degli20investitori20SEC71466"><a name="Potenziali rischi delle attività di Binance sui fondi degli investitori: SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potenziali rischi delle attività di Binance sui fondi degli investitori: SEC</h2><p>Una delle accuse nel processo della SEC contro Binance è che Zhao e Binance hanno messo a rischio i fondi degli investitori. Si afferma in modo sintetico che i fondi dei clienti sono a discrezione di Binance e di Zhao, che si sono arricchiti di miliardi di dollari statunitensi.</p>
<p>Ha supportato la sua posizione affermando che Binance e BAM Trading hanno intenzionalmente aggirato la vigilanza regolamentare degli Stati Uniti offrendo servizi relativi a titoli non registrati ai suoi cittadini. Ha detto: “[Questo] mette a rischio la sicurezza di miliardi di dollari di capitale degli investitori statunitensi e alla mercé di Binance e Zhao.”</p>
<p>Secondo la SEC, i rischi derivano dalla commistione dei fondi dei clienti di Binance e Binance.US in un conto controllato da Merit Peak Limited, un’entità di cui Zhao è proprietario e controlla. Pertanto, Binance di solito trasferisce i fondi dei suoi clienti statunitensi nelle mani di un terzo per scopi di acquisto e vendita di criptovalute.</p>
<p>Inoltre, i regolatori ritengono che questo accordo abbia fornito a Zhao la libertà di utilizzare i miliardi di dollari depositati dagli investitori statunitensi senza la supervisione regolamentare delle autorità competenti. Di conseguenza, il 6 giugno i regolatori degli Stati Uniti hanno presentato una mozione per un ordine di restrizione contro Binance per operare senza licenza e gestire in modo improprio i fondi investiti dai suoi cittadini. Hanno inoltre richiesto il congelamento dei fondi di Biance.US.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2763/amended-class-action-against-elon-musk" target="_blank">L’azione collettiva emendata allega l’insider trading di Elon Musk in Dogecoin</a></p>
<h2 id="h2-Binance20potrebbe20aver20ingannato20i20legislatori20statunitensi20con20la20sua20dichiarazione578016"><a name="Binance potrebbe aver ingannato i legislatori statunitensi con la sua dichiarazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance potrebbe aver ingannato i legislatori statunitensi con la sua dichiarazione</h2><p>Una delle lamentele dei regolatori statunitensi nei confronti di Binance è che potrebbe aver fornito loro dichiarazioni fuorvianti relative alle sue attività commerciali negli Stati Uniti. Ad esempio, all’inizio dell’anno Binance ha dichiarato che Binance US è indipendente dalla sua entità globale. Tuttavia, la Securities and Exchange Commission ritiene che Binance US e l’entità globale di Binance siano mescolate insieme.</p>
<p>A seguito di questo sospetto, i senatori degli Stati Uniti hanno chiesto al Dipartimento di Giustizia di indagare se Binance abbia fatto una rappresentazione distorta dei fatti al Congresso attraverso la sua dichiarazione. I senatori pensano che Binance potrebbe aver frainteso il suo rapporto con la sua unità locale per evitare sanzioni, eludere la supervisione regolamentare degli Stati Uniti e facilitare il riciclaggio di denaro.</p>
<p>Jack Graves, un professore di legge presso l’Università di Syracuse, ha detto a Cointelegraph che se Binance ha una forte relazione finanziaria o ha il controllo dell’Unità statunitense, ci sono chiare implicazioni legali.</p>
<p>Ha detto: “Se non li mantieni indipendenti, allora i regolatori statunitensi attaccheranno Binance International e diranno che abbiamo giurisdizione perché stai agendo attraverso l’entità statunitense. E infatti, penso che la SEC stia guardando a quello.”</p>
<p>La SEC potrebbe desiderare chiarezza sulla relazione tra le due entità poiché ciò ha implicazioni legali nel caso l’unità statunitense diventi fallita. Se le due entità stanno mescolando i fondi, significa che l’unità globale di Binance avrà l’obbligo di pagare i debiti di Binance US in caso di fallimento.</p>
<p>Secondo Graves, tuttavia, se “Binance.US è completamente indipendente e finisce in bancarotta, Binance International non è obbligata a pagare i debiti di Binance.US.” Questi scenari potrebbero essere la ragione per cui i senatori statunitensi desiderano chiarezza sulla questione.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2285/new-york-regulators-probes-stablecoin-issuer-paxos" target="_blank">I regolatori di New York indagano sul fornitore di stablecoin, Paxos</a></p>
<h2 id="h2-Binance20US20sospende20i20depositi20degli20Stati20Uniti954634"><a name="Binance US sospende i depositi degli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance US sospende i depositi degli Stati Uniti</h2><p>In risposta alla causa legale e alle indagini degli Stati Uniti, Binance ha sospeso tutti i depositi e prelievi in USD a partire dal 13 giugno. Inoltre, ha incoraggiato i suoi clienti a prelevare USD tramite bonifici bancari. Secondo Binance, ciò è dovuto al fatto che la situazione è disperata.</p>
<p>Ha spiegato: “La SEC ha adottato tattiche estremamente aggressive e intimidatorie nella sua campagna ideologica contro l’industria degli asset digitali americana. Binance.US e i nostri partner commerciali non sono stati risparmiati nell’uso di queste tattiche, il che ha creato sfide per le banche con cui lavoriamo.”</p>
<h2 id="h2-Binance20vs20SEC20La20traiettoria20discendente20di20BNB20e20il20suo20potenziale20limite706009"><a name="Binance vs SEC: La traiettoria discendente di BNB e il suo potenziale limite" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Binance vs SEC: La traiettoria discendente di BNB e il suo potenziale limite</h2><p>Nonostante il suo slancio rialzista all’inizio di giugno, BNB ha ceduto alla pressione esercitata dalla SEC su Binance. Già nella seconda settimana di giugno, il prezzo di BNB era sceso del 15%. È interessante notare che nello stesso periodo Binance ha interrotto la negoziazione di diverse coppie, tra cui <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Le attuali cause legali contro gli scambi di criptovalute, inclusa Binance, hanno portato a una diminuzione della domanda di Binance Coin. Tuttavia, alcuni indicatori tecnici hanno mostrato che BNB era ancora rialzista durante la seconda settimana di giugno nonostante avesse perso slancio. In particolare, la coppia BNB/USD ha mostrato la possibilità di un rimbalzo a breve termine. Tale possibilità è supportata dal fatto che l’indice di forza relativa (RSI) è entrato nella regione ipervenduta, al di sotto di 30.</p>
<p>Tuttavia, alcuni analisti prevedono che il valore di BNB diminuirà nei prossimi mesi. Ad esempio, TraderSZ, un <a href="https://twitter.com/trader1sz/status/1666473070867914752" rel="nofollow noopener noreferrer" target="_blank">l’analista di mercato pensa</a> che il prezzo di BNB potrebbe scendere a $180 a causa delle cause legali in corso contro gli scambi di criptovalute, inclusa Binance.</p>
<p>Al momento della scrittura, il 18 giugno, il prezzo di BNB è di $246.94 dopo aver registrato un aumento del 4.5% negli ultimi 7 giorni. Nel complesso, però, ha perso il 20.1% negli ultimi 30 giorni. Il diagramma di seguito riporta un riassunto delle statistiche importanti.<br><img src="https://gimg2.gateimg.com/image/article/16879442474181687944231_.pic.jpg" alt=""><br>Movimenti dei prezzi BNB negli ultimi 30 giorni - Coingecko</p>
<p>Come indica il diagramma, il prezzo di BNB è sceso significativamente da $300.85 il 5 giugno a $224.47 il 12 giugno. Tuttavia, è in ripresa dal 15 giugno.</p>
<h2 id="h2-Conclusion970966"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Binance US ha interrotto il deposito di USD a seguito della denuncia della SEC contro di essa. Allo stesso tempo, ha recentemente consigliato ai suoi clienti di prelevare i loro USD tramite bonifico bancario. In primo luogo, la SEC ha citato in giudizio Binance per offrire servizi relativi a titoli senza registrarli presso di essa. Inoltre, l’attuale indagine su Binance e l’applicazione delle leggi sulla sicurezza da parte della SEC nei confronti delle criptovalute in operazione negli Stati Uniti hanno portato alla riduzione della domanda di asset criptovalutari come BNB.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2708/sec-labels-37-cryptocurrencies-as-securities-implications-for-trading" target="_blank">La SEC classifica 37 criptovalute come titoli: Implicazioni per il trading</a></p>
<h3 id="h3-C20una20causa20legale20contro20Binance120487"><a name="C’è una causa legale contro Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>C’è una causa legale contro Binance?</h3><p>Il 5 giugno la Securities and Exchange Commission (SEC) ha intentato una causa contro Binance accusandolo di offrire servizi di titoli non registrati al pubblico. Nel complesso, Binance affronta tredici accuse dalla SEC.</p>
<h3 id="h3-Perch20la20SEC20ha20citato20in20giudizio20Binance664124"><a name="Perché la SEC ha citato in giudizio Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché la SEC ha citato in giudizio Binance?</h3><p>La SEC ha citato in giudizio Binance per aver offerto al pubblico titoli crittografici non registrati. Ciò segue la designazione della SEC di 68 criptovalute come titoli.</p>
<h3 id="h3-Il20mio20denaro2020al20sicuro20su20Binance758283"><a name="Il mio denaro è al sicuro su Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il mio denaro è al sicuro su Binance?</h3><p>I fondi degli investitori, che includono criptovalute e USD, sono al sicuro su Binance nonostante le recenti cause legali. Non vi è alcun segnale che indichi che perderanno i loro asset poiché la SEC mira a proteggere gli investimenti dei cittadini.</p>
<h3 id="h3-Cosa20sta20succedendo20con20Binance128051"><a name="Cosa sta succedendo con Binance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa sta succedendo con Binance?</h3><p>La Securities and Exchange Commission (SEC) ha citato in giudizio Binance il 5 giugno 2023, accusandolo di vendere servizi di titoli non registrati. Ciò accade dopo che la SEC ha designato 68 criptovalute come titoli.</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. Sarà consentito il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>