TGEgU0VDIGV0aWNoZXR0YSAzNyBjcmlwdG92YWx1dGUgY29tZSB0aXRvbGk6IGltcGxpY2F6aW9uaSBwZXIgaWwgdHJhZGluZw==

2023-06-01, 03:43

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR342197"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>La SEC ha classificato 37 criptovalute, tra cui <a href="/price/decentraland-mana" rel="nofollow noopener noreferrer" target="_blank">Decentraland</a> (MANA), <a href="/price/dash-dash" target="_blank" class="blog_inner_link">DASH</a> (DASH) <a href="/price/algorand-algo" rel="nofollow noopener noreferrer" target="_blank">Algorand</a> (ALGO), <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (UST) e <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a> (TRX), come titoli.</p>
<p>Tutti gli scambi di criptovalute che operano negli Stati Uniti devono registrare i 37 titoli criptati presso la SEC prima di consentire al pubblico di fare trading.</p>
<p>Dichiarare alcune criptovalute come titoli soffocherà la crescita del settore blockchain e dell’industria delle criptovalute. I trader di criptovalute devono conoscere il tipo corretto di criptovalute prima di investire in esse per evitare i rischi di sicurezza associati.</p>
<h2 id="h2-Introduzione599797"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Molti governi in tutto il mondo non hanno ancora definito la legislazione crittografica. Tuttavia, alcuni paesi utilizzano le normative finanziarie esistenti per monitorare le attività crittografiche. Uno dei più grandi dibattiti che infuria in tutto il mondo è su come classificare le criptovalute: dovrebbero essere classificate come materie prime come l’oro o come titoli come le azioni. Questo articolo discute la recente classificazione degli Stati Uniti di 37 criptovalute come titoli e le sue implicazioni.</p>
<h2 id="h2-Posizione20della20SEC20sulle20criptovalute417756"><a name="Posizione della SEC sulle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Posizione della SEC sulle criptovalute</h2><p>Nel suo tentativo di regolamentare gli asset crittografici, la Securities and Exchange Commission (SEC) degli Stati Uniti ha classificato 37 criptovalute come titoli, qualcosa che ha molte implicazioni per gli investitori, gli scambi di criptovalute e il settore più ampio della blockchain.</p>
<p>La SEC ha categorizzato queste criptovalute come titoli in base agli standard del Securities Act del 1933 e alle decisioni giudiziarie correlate sugli asset crittografici. Il caso di rilievo della SEC v. W. J. Howey Co ha stabilito i criteri del Test di Howey che determinano se uno strumento di investimento è un titolo o meno.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16855908512981685590831_.pic_hd.jpg" alt=""><br>SEC - Stati Uniti - Fibogroup</p>
<p>I criteri del Test di Howey valutano se un investimento in un’impresa viene effettuato con l’obiettivo principale di generare un profitto dall’attività di un terzo o del promotore. In altre parole, se gli investitori realizzano un profitto dalla vendita di un asset di investimento o attraverso la raccolta di dividendi o interessi maturati, tale strumento di investimento è un titolo.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1689/the-sec-took-action-against-kim-kardashian-for-endorsing-ethereum-max-emax" target="_blank">La SEC ha preso provvedimenti contro Kim Kardashian per aver sponsorizzato Ethereum max EMAX</a></p>
<p>In termini semplici, un titolo rappresenta uno strumento di investimento che rappresenta una pretesa sull’emittente. In altre parole, un titolo dà all’investitore il diritto di ricevere flussi di cassa futuri da un terzo. Esempi di titoli sono azioni, obbligazioni e derivati che sono <a href="https://www.gate.io/blog_detail/384/" target="_blank">regolamentato dalla SEC negli Stati Uniti</a>.</p>
<p>Pertanto, la SEC ha identificato diverse criptovalute che soddisfano i criteri dell’Howey Test.</p>
<h2 id="h2-I20seguenti20sono20titoli20crittografici687887"><a name="I seguenti sono titoli crittografici:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I seguenti sono titoli crittografici:</h2><p><a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> (XRP), Telegram Gram Token (TON), LBRY Credits (LBC), <a href="/price/decentraland-mana" target="_blank" class="blog_inner_link">Decentraland</a> (MANA), DASH (DASH), Power Ledger (POWR), OmiseGo (OMG), <a href="/price/algorand-algo" target="_blank" class="blog_inner_link">Algorand</a> (ALGO), Naga (NGC), TokenCard (TKN), IHT Real Estate (IHT), Kik (KIN), Salt Lending (SALT), Beaxy Token (BXY), DragonChain (DRGN), Tron (TRX), <a href="/price/bittorrent-btt" rel="nofollow noopener noreferrer" target="_blank">BitTorrent</a> (BTT), <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> USD (UST), Luna (LUNA), Mirror Protocol mAssets (Simboli multipli), Mirror Protocol (MIR), Mango (MNGO), Ducat (DUCAT), Locke (LOCKE), EthereumMax (EMAX), Hydro (HYDRO), BitConnect (BCC), Meta 1 Coin (META1), Rally (RLY), DerivaDAO (DDX), XYO Network (XYO), Rari (RGT), Liechtenstein Cryptoasset Exchange (LCX), DFX Finance (DFX), Kromatica (KROM), FlexaCoin (AMP) e <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> (FIL).</p>
<h2 id="h2-Ramificazioni20legali20della20sicurezza20del20trading20di20criptovalute950151"><a name="Ramificazioni legali della sicurezza del trading di criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ramificazioni legali della sicurezza del trading di criptovalute</h2><p>Alla luce della classificazione delle suddette criptovalute come titoli, è importante comprendere le implicazioni legali di ciò. Ad esempio, diventa illegale per gli scambi con sede negli Stati Uniti vendere titoli crittografici non registrati. Pertanto, gli scambi dovrebbero registrare tutte le criptovalute classificate come titoli presso la SEC prima di offrirle in vendita pubblica.</p>
<p>Secondo la regolamentazione crittografica stabilita negli Stati Uniti, la vendita di titoli crittografici non registrati comporta pesanti sanzioni che possono includere il disgorgimento dei profitti o multe. Pertanto, gli scambi che elencano queste criptovalute saranno soggetti a una maggiore attenzione da parte delle autorità. Quello che sappiamo è che la maggior parte degli scambi di criptovalute negli Stati Uniti vende diversi di questi titoli crittografici.</p>
<p>Leggi anche: <a href="https://www.gate.io/th/blog_detail/2564/g7-sets-out-to-strengthen-crypto-regulations" target="_blank">Il G7 si impegna a rafforzare la regolamentazione delle criptovalute</a></p>
<p>Anche dopo aver registrato queste criptovalute, gli exchange devono fare molto di più. Ci sono altre normative e requisiti di divulgazione sulle criptovalute della SEC a cui dovrebbero aderire. Ad esempio, dovrebbero rispettare le norme in materia di protezione degli investitori, negoziazione e segnalazione.</p>
<p>Questa classificazione di alcune criptovalute come titoli significa che i loro emittenti dovranno rispettare la regolamentazione statunitense delle criptovalute durante il crowdfunding. Ad esempio, devono registrare i loro asset criptografici prima di utilizzare le Offerte iniziali di moneta (ICO) per raccogliere fondi per i loro progetti. Poiché molte ICO mancano di trasparenza e responsabilità, l’autorità di regolamentazione come la SEC potrebbe intraprendere determinate azioni contro di loro.</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">Do Kwon raggiunge il livello di ricerca a 5 stelle mentre la SEC presenta ulteriori accuse di frode</a></p>
<p>La classificazione delle criptovalute identificate come titoli ha implicazioni legali dirette o indirette anche per gli investitori. Prima di fare trading di criptovalute, un investitore dovrebbe assicurarsi che l’asset digitale sia registrato secondo la legge. Questo perché c’è il pericolo che l’asset in cui investe possa essere delistato da diverse borse in futuro, il che riduce la sua liquidità e l’esposizione al mercato.</p>
<p>Tuttavia, questa potrebbe essere una buona notizia per alcuni investitori di criptovalute che sono avversi al rischio. Questo perché le leggi federali li proteggono dalle cattive pratiche che alcune borse e progetti di criptovalute portano avanti. Inoltre, gli investitori acquisiscono fiducia nelle criptovalute, il che consente loro di investire di più in esse.</p>
<h2 id="h2-Effetti20della20classificazione20delle20criptovalute20come20titoli20sul20blockchain630923"><a name="Effetti della classificazione delle criptovalute come titoli sul blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Effetti della classificazione delle criptovalute come titoli sul blockchain</h2><p>Non c’è dubbio che classificare alcune criptovalute come titoli danneggerà lo sviluppo e l’espansione del settore blockchain e dell’industria delle criptovalute. Ad esempio, sarà più difficile per alcuni progetti criptografici raccogliere fondi utilizzando le ICO.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2664/historic-florida-enacts-groundbreaking-legislation-cbdcs" target="_blank">Storico: la Florida promulga una legislazione innovativa contro le CBDC</a></p>
<p>Inoltre, sarà difficile per alcuni progetti e startup crypto con sede negli Stati Uniti investire in alcuni progetti crypto. Ad esempio, alcuni progetti basati su blockchain situati al di fuori degli Stati Uniti potrebbero bloccare gli indirizzi IP di individui o startup statunitensi.</p>
<p>Inoltre, i costi legali che alcuni progetti cripto affrontano per aver violato le normative cripto degli Stati Uniti avranno un impatto negativo sul loro denaro. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> e stabilità finanziaria. Ciò potrebbe portare alla chiusura di alcuni progetti basati su blockchain.</p>
<p>Inoltre, il mercato delle criptovalute si ridurrà. Sappiamo già che gli Stati Uniti sono il paese con il maggior numero di investitori in criptovalute. Ciò significa che questi individui probabilmente ridurranno i loro investimenti in attività dichiarate illegali dal loro paese.</p>
<h2 id="h2-Verso20la20trasparenza20normativa506567"><a name="Verso la trasparenza normativa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verso la trasparenza normativa</h2><p>Qualsiasi ente di regolamentazione come la SEC dovrebbe creare regolamentazioni trasparenti che proteggano i consumatori e favoriscano l’innovazione nel settore. Ad esempio, dovrebbero fornire linee guida chiare per la registrazione delle criptovalute, nonché requisiti di reportistica e divulgazione.</p>
<p>Tutte le parti coinvolte, come gli emittenti di monete e altri progetti DeFi, dovrebbero conoscere le regole che si applicano nello spazio delle criptovalute, che consentono loro di adottare le migliori politiche e pratiche operative. Ad esempio, se le autorità regolamentano gli scambi, le istituzioni finanziarie come le banche possono offrire i loro servizi per sostenere il settore.</p>
<p>Infine, le autorità di regolamentazione dovrebbero essere specifiche sui requisiti fiscali per gli asset crittografici. Ad esempio, dovrebbero indicare il tipo di tasse che gli exchange e altri progetti crittografici devono pagare. I paesi che trattano le criptovalute come materie prime possono richiedere ai detentori di criptovalute di pagare l’imposta sulle plusvalenze immobiliari.</p>
<h2 id="h2-Conclusione410629"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>La Securities and Exchange Commission (SEC) degli Stati Uniti ha classificato 37 criptovalute come titoli che possono avere un impatto sulle dimensioni del loro mercato e sulla loro liquidità. Decentraland (MANA), DASH (DASH), Algorand (ALGO), Terra USD (UST) e Tron (TRX) sono esempi di criptovalute che la SEC ha dichiarato come titoli.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti 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 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>