SWwgU0VDIFZpZXRhcmUgbG8gU3Rha2luZyBkaSBDcmlwdG92YWx1dGUgbmVnbGkgVVNB

<p><img src="https://gimg2.gateimg.com/image/article/1678714733热点追踪 封面.jpg" alt=""></p>
<h2 id="h2-TL20DR306679"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>La Securities and Exchange Commission accusa Kraken di offrire un servizio di staking al dettaglio non registrato.</p>
<p>Il motivo per cui la SEC vieta i servizi di staking di token non registrati è quello di proteggere i consumatori.</p>
<p>Kraken ha accettato di interrompere il suo programma di servizio di staking al dettaglio.</p>
<p>Vietare lo staking costringerà le aziende blockchain a smettere di investire negli Stati Uniti e a trasferirsi in paesi cripto-friendly.</p>
<h2 id="h2-Introduzione816436"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dopo il crollo di FTX, la Securities and Exchange Commission (SEC) degli Stati Uniti sta facendo sforzi concertati per regolamentare le criptovalute. Il suo obiettivo principale è proteggere i consumatori da affari di investimento in criptovalute senza scrupoli. A tal scopo, uno dei suoi attuali obiettivi è monitorare e controllare i servizi di staking non regolamentati.</p>
<p>Al momento, sta gestendo la questione di Kraken per cui addebita per offrire servizi di staking al dettaglio non regolamentati.</p>
<h2 id="h2-Il20motivo20per20cui20la20SEC20ha20preso20provvedimenti20contro20Kraken490572"><a name="Il motivo per cui la SEC ha preso provvedimenti contro Kraken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il motivo per cui la SEC ha preso provvedimenti contro Kraken</h2><p>La Securities and Exchange Commission ha accusato Kraken di offrire un programma di staking di criptovalute non registrato come servizio, che secondo alcune fonti non si basa affatto sullo staking. Con questo servizio, gli utenti di criptovalute mettono in gioco le proprie criptovalute con Kraken che ha alti rendimenti fino al 21%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1678715458Kraken1.png" alt=""><br>Divieto di staking di Kraken - Gfinityesport</p>
<p>Tuttavia, le due parti hanno raggiunto un accordo secondo il quale Kraken dovrebbe interrompere il servizio di staking al dettaglio con effetto immediato e pagare $30 milioni in sanzioni civili, interessi pregiudizievoli e confisca.</p>
<p>In una dichiarazione via email resa pubblica, il portavoce di Kraken ha detto: “A partire da oggi, ad eccezione dell’ether messo in gioco, gli asset iscritti al programma di staking on-chain da parte dei clienti statunitensi saranno automaticamente messi in gioco e non guadagneranno più ricompense per lo staking. Inoltre, i clienti statunitensi non potranno mettere in gioco ulteriori asset, incluso ETH.”</p>
<p>Il servizio di staking di Kraken è attivo da molto tempo. Secondo la SEC, offre il servizio di staking dal 2019. In questo caso, Kraken raggrupperebbe le risorse crittografiche dei suoi utenti e le investirebbe collettivamente per conto loro.</p>
<p>In parole semplici, lo staking è un tipo di investimento in cui gli investitori bloccano le loro criptovalute in un protocollo con l’obiettivo di ottenere una ricompensa. Lo staking delle criptovalute aiuta a garantire una rete poiché i validatori verificano le transazioni che avvengono sulla blockchain.</p>
<p>La SEC afferma che qualsiasi intermediario che offre prestiti, staking come servizio o qualsiasi tipo di investimento per conto degli investitori dovrebbe essere trasparente nei loro rapporti. In questo caso, dovrebbe fornire le informazioni che la legge specifica.</p>
<p>L’indagine della SEC, condotta da Laura D’Allaird e Elizabeth Goody, sotto la supervisione di un team composto da Sachin Verma, Eugene Hansen, Paul Kim, Jorge G. Tenreiro, James Connor e David Hirsch, ha concluso che Kraken non si è registrato presso il servizio e non ha fornito le comunicazioni richieste.</p>
<p>Leggi anche: <a href="https://www.gate.io/uk/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world" target="_blank">Come vengono attualmente regolamentate le criptovalute nei paesi di tutto il mondo?</a></p>
<h2 id="h2-Motivo20della20SEC20per20vietare20il20programma20di20staking20di20Kraken328012"><a name="Motivo della SEC per vietare il programma di staking di Kraken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Motivo della SEC per vietare il programma di staking di Kraken</h2><p>Come già accennato, il principale motivo della SEC per vietare il programma di staking dei token di Kraken è proteggere il consumatore. Sostiene che anche se Kraken offre il servizio di staking da molto tempo, non si è conformata alla regolamentazione necessaria. Non ha fornito la necessaria divulgazione finanziaria per dimostrare la sua capacità di pagare i rendimenti del programma di staking.</p>
<p>La SEC ha anche sostenuto che il programma di staking al dettaglio di Kraken soddisfa il test di Howey per la sicurezza poiché offre ricompense alle persone per proteggere le reti di criptovalute. Inoltre, lo staking ha i suoi rischi che possono causare agli investitori di perdere i loro fondi investiti. In circostanze simili, alcune società imbrogliano o fraudano gli investitori.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1678715653Kraken2.png" alt=""><br>Sec per proteggere i consumatori- Cryptoslate</p>
<p>Tuttavia, le diverse dichiarazioni fatte dal presidente della SEC, Gary Gensler, mostrano che l’intenzione non è quella di imporre un divieto di staking cripto su reti come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il suo scopo è quello di portare trasparenza agli scambi centralizzati di criptovalute come Kraken. Questo perché queste entità dovrebbero attenersi alle stesse regole che si applicano alle tradizionali aziende finanziarie.</p>
<p>Tuttavia, ci sono persone di spicco nel settore delle criptovalute che ritengono che classificare lo staking come un titolo di sicurezza sia inappropriato. Ad esempio, il direttore esecutivo della Proof of Stake Alliance (POSA), Alison Mangiero, ha affermato che “la sua organizzazione si oppone a qualsiasi affermazione che lo staking costituisca un titolo di sicurezza non registrato.”</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1695/understanding-how-the-merge-puts-ethereum-in-sec-s-crosshair" target="_blank">Capire come il Merge mette Ethereum nel mirino della Sec</a></p>
<p>Lei ha detto: “”Lo staking tende a essere frainteso con attività non correlate come il prestito, ma lo staking è fondamentalmente un modo per chiunque di partecipare fornendo sicurezza per le reti di proof-of-stake.” Ha aggiunto “L’esistenza dei fornitori di servizi di staking consente agli americani di tutti i giorni di partecipare allo staking, il che democratizza il consenso e la convalida della rete ed è fondamentale per la crescita continua dell’internet decentralizzato globale. Qualsiasi azione regolamentare che vada contro questo fraintende la natura dello staking e ostacola gli sforzi in corso dell’America per promuovere l’innovazione tecnologica nazionale”.</p>
<p>Il CEO di Coinbase, Brian Armstrong, ha espresso un sentimento simile sulla possibilità del divieto di staking di criptovalute negli Stati Uniti. Ha twittato: “Spero che non sia così, perché credo che sarebbe una terribile strada per gli Stati Uniti se ciò fosse permesso.”</p>
<p>Leggi anche: <a href="https://www.gate.io/pt/blog_detail/2049" target="_blank">Proof-of-work contro Proof-of-Stake: quale è migliore?</a></p>
<h2 id="h2-Perch20il20divieto20di20staking20crittografico20rappresenta20una20minaccia20per20gli20Stati20Uniti875601"><a name="Perché il divieto di staking crittografico rappresenta una minaccia per gli Stati Uniti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché il divieto di staking crittografico rappresenta una minaccia per gli Stati Uniti?</h2><p>Se gli Stati Uniti vietano lo staking di criptovalute, ci sono diverse possibili conseguenze. Innanzitutto, gli investitori che fanno staking su exchange regolamentati come Kraken opteranno per investire in exchange decentralizzati. Purtroppo, gli exchange decentralizzati sono più rischiosi rispetto a quelli centralizzati, il che esporrà i cittadini degli Stati Uniti a ‘operatori opachi’ dove ci sono maggiori rischi di attori malevoli che possono causare danni economici.</p>
<p>In secondo luogo, vietare lo staking di criptovalute soffocherà l’innovazione negli Stati Uniti poiché le aziende blockchain sono inclini a investire in destinazioni più favorevoli alle criptovalute. Inoltre, gli Stati Uniti diventeranno meno competitivi nelle loro attività blockchain rispetto ad altri paesi.</p>
<h2 id="h2-Come20fare20lo20staking20su20Gateio573849"><a name="Come fare lo staking su Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come fare lo staking su Gate.io</h2><p>Gate.io ti consente di guadagnare dalla criptovaluta che possiedi in una moltitudine di modi entusiasmanti. A differenza del deposito, alcuni prodotti e servizi su Gate.io ti consentono di ottenere un rendimento sulla criptovaluta senza vincoli o rischi di perdere il tuo capitale.</p>
<p>Modi per guadagnare rendimenti sul tuo crypto:</p>
<ol>
<li>Prestare e Guadagnare</li><li>HODL e Guadagnare</li><li>Mining di Liquidità</li><li>Prestito di Crypto</li><li>Mining su Cloud</li><li>Copy Trading</li></ol>
<h2 id="h2-Conclusion375577"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Nel suo impegno per proteggere i consumatori negli Stati Uniti, la Securities and Exchange Commission (SEC) degli Stati Uniti ha accusato Kraken di offrire un servizio di token staking non registrato.</p>
<p>Tuttavia, gli analisti ritengono che un divieto totale dello staking di criptovalute metterebbe a rischio la dominanza degli Stati Uniti nel settore della blockchain, in quanto alcune società di blockchain potrebbero scegliere di investire in altri paesi.</p>
<p><strong>Posso prendere la mia criptovaluta fuori dallo staking?</strong></p>
<p>Un investitore può prelevare la criptovaluta dallo staking dopo la scadenza del periodo di staking. Durante il periodo di staking si guadagnerà una ricompensa. Se si desidera ritirare la criptovaluta, prima si deve fare l’unstaking alla fine del periodo.</p>
<p><strong>Come fare staking di criptovalute?</strong></p>
<p>La prima fase quando si desidera mettere in palio una determinata criptovaluta è comprarla e trasferirla alla piattaforma in cui si desidera metterla in palio. Tuttavia, a volte è possibile mettere in palio i token che sono nel proprio portafoglio. Quando la criptovaluta è nel portafoglio giusto, si attiva il comando di mettere in palio.</p>
<p><strong>C’è qualche motivo per non fare stake di criptovalute?</strong></p>
<p>Ci sono diverse ragioni che possono impedire a un investitore di investire la crypto. Ad esempio, potresti non investire i tuoi token se il tasso di rendimento è molto basso. Inoltre, potresti scegliere di non investire la tua criptovaluta se la piattaforma di investimento non è molto sicura poiché potresti perderla.</p>
<p><strong>Lo staking è considerato una sicurezza?</strong></p>
<p>Lo staking non è considerato un titolo di sicurezza secondo la maggior parte delle leggi nazionali, incluso quello degli Stati Uniti. Inoltre, non soddisfa i requisiti per essere considerato un titolo di sicurezza secondo il test di Howey. Fondamentalmente, lo staking serve allo stesso scopo del mining, ovvero quello di garantire la sicurezza di una blockchain.</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 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 venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>