VW5iYW5rZWQgc2kgdHJvdmEgZGkgZnJvbnRlIGFsbGEgY2hpdXN1cmEgYSBjYXVzYSBkaSBvc3RhY29saSByZWdvbGFtZW50YXJpIGUgc2ZpZGUgZGkgZmluYW56aWFtZW50bw==

2023-06-12, 07:25

<p><img src="https://gimg2.gateimg.com/image/article/1686553887RDZZ.jpeg" alt=""></p>
<h2 id="h2-TLDR372500"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Unbanked ha interrotto le operazioni a causa dell’ambiente normativo severo negli Stati Uniti e delle sfide finanziarie che sta affrontando</p>
<p>Unbanked ha incoraggiato i suoi clienti a prelevare i loro fondi che includono USD e criptovalute</p>
<p>L’attuale sorveglianza crittografica ostile negli Stati Uniti ha costretto molte società di criptovalute a trasferirsi in altri paesi.</p>
<h2 id="h2-Introduzione301537"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’anno 2023 sarà ricordato per la chiusura di molte istituzioni finanziarie che offrono servizi cripto e per la rigorosa supervisione normativa del governo degli Stati Uniti sugli asset digitali e il settore delle criptovalute. Nel primo trimestre, diverse banche statunitensi <a href="https://www.gate.io/learn/articles/what-is-silvergate/509" target="_blank">incluso Silvergate</a> e <a href="https://www.gate.io/blog_detail/2303/svb-crash-caused-the-butterfly-effect-in-the-crypto-market-what-should-investors-do" target="_blank">La Silicon Valley Bank ha chiuso</a> a causa di cattiva gestione finanziaria e del clima economico sfavorevole. Oggi discutiamo di altre chiusure imminenti di istituzioni come Unbanked che offrono vari servizi al settore crittografico.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2397/crashing-banks-push-crypto-towards-a-bull-market" target="_blank">Le banche in crisi spingono le criptovalute verso un mercato rialzista</a></p>
<h2 id="h2-Unbanked20chiuder249503"><a name="Unbanked chiuderà" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Unbanked chiuderà</h2><p>Unbanked, il proprietario del token UNBK e fornitore di vari servizi finanziari, ha recentemente annunciato la sua intenzione di chiudere a causa di un ambiente normativo ostile e sfide finanziarie. <a href="https://unbanked.com/unbanked-will-be-winding-down/" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, “<br><strong>Oggi prendiamo la sfortunata decisione di liquidare Unbanked. Quando abbiamo avviato l’azienda nel 2018, sapevamo che la blockchain era il modo migliore per trasmettere valore sotto forma di criptovalute o stablecoin.</strong>”</p>
<p>Secondo Unbanked, ha esaurito tutte le opzioni possibili per sostenere l’attività. Ha detto, “<br><strong>Questa decisione di chiudere Unbanked non è stata presa alla leggera, ma abbiamo esaurito tutte le opzioni. La chiusura non è avvenuta per mancanza di sforzi nel valutare tutte le opzioni valide da parte del nostro team.</strong>”</p>
<p>In generale, la situazione normativa delle criptovalute negli Stati Uniti è stata ostile, il che ha costretto diverse aziende di criptovalute a chiudere. Il 9 maggio Unbanked, il fornitore di servizi finanziari criptati, ha annunciato la sua chiusura pianificata.</p>
<p>Alcuni dei servizi finanziari offerti da Unbanked includono conti bancari e carte. Ha anche permesso agli investitori di comprare e vendere criptovalute in modo conveniente, supportando la distribuzione dei premi di staking. Sin dalla sua fondazione nel 2019, Unbanked ha offerto servizi finanziari a entità statunitensi e internazionali. In pratica, aveva 25 aziende in diversi paesi che utilizzavano il suo servizio.</p>
<h2 id="h2-Sfide20regolatorie929559"><a name="Sfide regolatorie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sfide regolatorie</h2><p>È importante notare che le sfide regolamentari ed economiche negli Stati Uniti influenzano molte società cripto in tutto il mondo anche se non hanno attività dirette in quel paese. Questo perché le attività critiche che avvengono negli USA influenzano gli eventi globali poiché altri paesi seguono le loro orme e a causa dell’effetto contagio.</p>
<p>Fondamentalmente, gli Stati Uniti stanno lavorando duramente per fermare le società Fintech e le istituzioni finanziarie come le banche dall’offrire servizi criptati o dal sostenere le aziende che forniscono prodotti e servizi criptati. Al governo federale non importa se questi fornitori di servizi finanziari rispettino o meno la sua legislazione. Il paese ha preso di mira le società di servizi finanziari che supportano prodotti criptati, costringendole a chiudere o a trasferirsi in paesi con una regolamentazione criptata amichevole.</p>
<p>In una recente <a href="https://unbanked.com/unbanked-will-be-winding-down/" rel="nofollow noopener noreferrer" target="_blank">Il post del blog Unbanked ha detto</a>, “<br><strong>I regolatori statunitensi stanno cercando attivamente di impedire alle aziende (banche e società fintech) di sostenere gli asset crittografici, anche quando le aziende cercano di farlo correttamente e secondo le regole. I loro sforzi stanno funzionando e limitano in ultima analisi la capacità degli inabili di raccogliere capitali e gestire un’attività autosufficiente.</strong>”</p>
<p>Unbanked ha chiarito di aver rispettato la maggior parte dei requisiti normativi negli Stati Uniti. Tuttavia, tale conformità ha contribuito a costi elevati che hanno appesantito l’attività commerciale.</p>
<p>Ha detto: ‘Abbiamo creduto che costruire Unbanked in riva al mare negli Stati Uniti sarebbe stata la scelta intelligente a lungo termine. Mentre altre società di criptovalute crescevano rapidamente al largo dalla costa evitando una regolamentazione rigorosa, abbiamo creduto che collaborare con i regolatori e seguire i loro processi ardui avrebbe alla fine posizionato Unbanked in vantaggio. Sfortunatamente, abbiamo imparato che questo non era il caso e seguire questa strada porta a molto tempo sprecato e costi eccessivi’.</p>
<p>Unbanked non è stata l’unica istituzione che si occupa di cripto-attività che è stata negativamente colpita dagli ostacoli regolamentari che interessano il settore negli Stati Uniti. BottlePay, HotBit, Beaxy, Bittrex, Teressa e TradeBlock sono solo alcune delle altre società cripto che hanno chiuso le operazioni a causa delle rigorose condizioni regolamentari.</p>
<p>Leggi anche: <a href="https://www.gate.io/fr/blog_detail/384/" target="_blank">Leggi sulle criptovalute negli Stati Uniti e in altri paesi</a></p>
<p>Ad esempio, HotBit ha dichiarato di aver chiuso a seguito dell’indagine sulla maggior parte dei suoi membri del team da parte delle autorità regolamentari degli Stati Uniti. Bittrex, che ha presentato istanza di fallimento ai sensi del Chapter 11 in un tribunale federale del Delaware, ha dichiarato che l’ambiente regolamentare è una delle ragioni della sua decisione di interrompere le operazioni. Tuttavia, solo il braccio statunitense dell’azienda ha presentato istanza di fallimento ai sensi del Chapter 11.</p>
<p>La chiusura di Bittrex è avvenuta dopo aver ricevuto un avviso da Wells dalla Securities Exchange Commission (SEC). Questo avviso di benessere è stato dato a Bittrex sulla base del fatto che stava operando come broker dealer, una camera di compensazione e uno scambio di criptovalute senza registrazione. In cima a questo, la SEC ha elencato OMG, ALGO e <a href="/price/dash-dash" target="_blank" class="blog_inner_link">DASH</a> come titoli crittografici.</p>
<p>Purtroppo, nel primo trimestre del 2023, la Securities Exchange Commission ha avviato diverse azioni di regolamentazione contro i principali attori del settore delle criptovalute, tra cui Coinbase. D’altra parte, la SEC sta ancora perseguendo il suo caso contro Ripple. Questi esempi mostrano l’impegno della SEC nel frenare la crescita del settore delle criptovalute costringendo alcune aziende cripto a chiudere.</p>
<h2 id="h2-La20situazione20finanziaria20degli20sprovveduti860571"><a name="La situazione finanziaria degli sprovveduti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La situazione finanziaria degli sprovveduti</h2><p>La situazione finanziaria degli svincolati ha aggiunto vincoli alla loro fattibilità commerciale. Recentemente, un co-fondatore dell’azienda ha detto che si aspettavano finanziamenti aggiuntivi per sostenere le loro operazioni commerciali. Tuttavia, non ha ricevuto l’iniezione finanziaria prevista. L’azienda ritiene che la situazione regolamentare attuale possa aver causato il fallimento dell’affare.</p>
<p>La società ha spiegato: “Tre settimane fa Unbanked ha firmato un term sheet per un investimento di 5 milioni di dollari con una valutazione di 20 milioni di dollari che ci avrebbe permesso non solo di continuare le operazioni ma di espanderci. Non abbiamo ricevuto quei fondi fino a questo momento.”</p>
<p>A causa dello stato attuale delle cose, Unbanked ha implorato i suoi clienti di prelevare i loro fondi prima della chiusura. Ha detto: “Tutti i clienti di Unbanked e quelli attraverso i nostri programmi white-label dovrebbero iniziare a prelevare tutti i fondi (crypto e USD) il prima possibile.”</p>
<h2 id="h2-Il20panorama20regolamentare20degli20Stati20Uniti20mette20a20dura20prova20le20aziende20criptovalutarie369879"><a name="Il panorama regolamentare degli Stati Uniti mette a dura prova le aziende criptovalutarie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il panorama regolamentare degli Stati Uniti mette a dura prova le aziende criptovalutarie</h2><p>Poiché <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">il crollo di FTX</a> Gli Stati Uniti stanno intensificando la repressione su molte aziende di criptovalute che ritiene non conformi alle sue normative sulle criptovalute. Fondamentalmente, sta monitorando attentamente il sistema bancario tradizionale e le banche non tradizionali.</p>
<p>Leggi anche: <a href="https://www.gate.io/th/blog_detail/378/how-are-cryptocurrencies-currently-regulated-in-countries-around-the-world" target="_blank">Come sono attualmente regolamentate le criptovalute nei paesi di tutto il mondo?</a></p>
<p>La comunità crittografa sta accusando Gary Gensler, il presidente della SEC, per la sua continua aggressività nei confronti delle criptovalute. Ciò perché nei mesi scorsi la SEC ha accusato diverse società crittografiche per la loro mancata conformità alla legislazione che governa gli asset virtuali, in particolare le criptovalute. Ad esempio, a gennaio la SEC ha accusato <a href="https://www.sec.gov/news/press-release/2023-7" rel="nofollow noopener noreferrer" target="_blank">Genesis Global Capital, LLC e Gemini Trust Company</a> per la vendita di titoli non registrati. Ha anche presentato accuse contro Kraken per lo stesso reato.</p>
<p>Molti addetti al settore delle criptovalute, quindi, ritengono che l’azione della SEC soffocherà l’innovazione nel settore delle criptovalute, costringerà altre aziende a chiudere e porterà le società fintech a trasferirsi in paesi con una legislazione amichevole verso le criptovalute.</p>
<p>Oltre alla SEC, ci sono altre agenzie governative che stanno combattendo contro le criptovalute. Come esempio, di recente l’Ufficio del Controllore della Valuta (OCC), la Federal Reserve e la Federal Deposit Insurance Corporation (FDIC) <a href="https://www.axios.com/2023/02/23/major-banking-authorities-say-stablecoin-reserves-pose-liquidity-risk" rel="nofollow noopener noreferrer" target="_blank">avvertito le banche dei rischi di liquidità</a> associato alle stablecoin.</p>
<p>Durante il primo trimestre del 2023 il Dipartimento dei Servizi Finanziari di New York ha ordinato a Paxos, l’emittente di <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a>, per fermare la produzione aggiuntiva della stablecoin. Nel complesso, la repressione delle società di criptovaluta negli Stati Uniti ha costretto molte società di criptovaluta a trasferirsi in altri paesi.</p>
<p>Brad Garlinghouse, <a href="https://www.bloomberg.com/news/articles/2023-03-02/ripple-ceo-garlinghouse-expects-a-decision-on-sec-suit-this-year#xj4y7vzkg" rel="nofollow noopener noreferrer" target="_blank">il CEO di Ripple, ha detto a Bloomberg</a> che l’”industria delle criptovalute” ha iniziato a spostarsi dagli Stati Uniti verso altri paesi.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1396/the-pros-and-cons-of-crypto-and-blockchain-related-regulation" target="_blank">I pro e i contro della regolamentazione delle criptovalute e delle blockchain</a></p>
<h2 id="h2-Conclusione190487"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Unbanked, il fornitore di servizi finanziari, ha annunciato di avere l’intenzione di chiudere la propria attività a causa dell’ambiente crittografico ostile negli Stati Uniti e delle limitate risorse finanziarie. In effetti, la situazione normativa attuale negli USA ha costretto molte aziende criptografiche a chiudere o a trasferirsi in altri paesi.</p>
<h2 id="h2-FAQ20per20gli20sprovvisti20di20servizi20bancari382206"><a name="FAQ per gli sprovvisti di servizi bancari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FAQ per gli sprovvisti di servizi bancari</h2><p><strong>Cosa significa Unbanked?</strong></p>
<p>Unbanked è un fornitore di servizi finanziari che offre prodotti e servizi che si rivolgono al settore della criptovaluta. I suoi prodotti principali sono carte bancarie e conti bancari, nonché strutture per la distribuzione delle ricompense di staking.</p>
<p><strong>Quando le persone non hanno un conto in banca e quali opzioni hanno per i servizi finanziari? </strong></p>
<p>Non bancarizzati si riferisce agli adulti che non hanno accesso ai servizi finanziari tradizionali come conti bancari e carte di credito. Queste persone hanno l’opzione di utilizzare criptovalute, mandati di pagamento, prestiti payday, finanziatori non tradizionali e assegni.</p>
<p><strong>Qual è la differenza tra una banca e un fornitore di servizi finanziari? </strong></p>
<p>Una banca è un istituto finanziario che accetta depositi e offre prestiti ai propri clienti. D’altra parte, un fornitore di servizi finanziari si concentra sulla gestione dei fondi dei propri clienti attraverso assicurazioni, investimenti e altri mezzi.</p>
<p><strong>Gli Stati Uniti regolano le criptovalute?</strong></p>
<p>Gli Stati Uniti utilizzano le proprie leggi finanziarie esistenti per regolamentare le criptovalute. Il Bank Secrecy Act (BSA) è il principale strumento legislativo finanziario che gli USA utilizzano per regolamentare le criptovalute.</p>
<p><strong>Cosa sono i fornitori di servizi di cripto-asset?</strong></p>
<p>I fornitori di servizi di cripto-attività sono istituzioni che amministrano criptovalute per conto di terzi. Questi includono società che offrono servizi per la conversione di criptovalute in valute fiat e viceversa, nonché la custodia di tali attività digitali.</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 venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>