TCdlbWl0dGVudGUgZGkgVVNEQyBTdGFibGVjb2luIHN0cmluZ2UgYW1pY2l6aWEgY29uIENyb3NzIFJpdmVyIEJhbms=

2023-03-31, 09:09

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR288891"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il crollo di Silicon Bank, Silvergate Bank e Signature Bank ha lasciato un vuoto nel settore bancario poiché poche banche offrono i servizi richiesti dalle imprese di criptovalute.</p>
<p>Bank of New York Mellon e Cross River Bank sono esempi di banche che offrono servizi limitati legati alle criptovalute.</p>
<p>Deutsche Bank (DB), Santander (SAN), HSBC (HSBA), Western Alliance, Mercury, Series Financial Multis, Bank Prove and Bridge hanno mostrato interesse nell’offrire i servizi che le aziende criptografiche preferiscono.</p>
<p>Paesi come gli Stati Uniti hanno rafforzato la loro supervisione normativa a seguito di una serie di furti e crimini di criptovalute, nonché del crollo di progetti crittografici come FTX.</p>
<h2 id="h2-Introduzione346170"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il crollo di tre banche chiave che supportavano le criptovalute negli Stati Uniti ha sconvolto il modo in cui gli investitori di criptovalute conducono le loro attività. La chiusura di Silicon Bank, Silvergate Bank e Signature Bank in rapida successione ha influenzato la liquidità nel settore delle criptovalute. Questo perché Silvergate forniva l’infrastruttura che supportava il settore delle criptovalute quotidianamente.</p>
<h2 id="h2-I20capitali20di20rischio20che20sono20stati20colpiti740126"><a name="I capitali di rischio che sono stati colpiti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I capitali di rischio che sono stati colpiti</h2><p>Il crollo di queste tre banche ha significato che diverse aziende tecnologiche e di venture capital non possono ottenere i servizi di cui hanno bisogno. Ad esempio, Silicon Valley Bank era un fornitore di prestiti per molte startup. D’altra parte, la maggior parte delle società crypto e delle startup sostenute da venture capital faceva affidamento su Silvergate Bank e Signature Bank. Di conseguenza, il loro crollo ha lasciato un vuoto nel settore delle criptovalute. Di conseguenza, queste società crypto devono cercare banche adatte che soddisfino le loro esigenze e preferenze speciali.</p>
<p>Grandi aziende cripto come Finance.US, Kraken e Gemini hanno fatto affari con Silvergate Bank e Signature Bank. D’altra parte, aziende di asset digitali, venture capital e aziende tech come Circle, Trace Finance, Roku, BlockFi e Roblox hanno fatto affari con la Silicon Valley Bank (SVB).</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680253626641680253569_.pic.jpg" alt=""><br>Silicon Valley Bank- NPR.org</p>
<p>La chiusura di queste importanti istituzioni finanziarie negli Stati Uniti potrebbe essere una mossa deliberata del governo per impedire alle aziende cripto di accedere a un servizio bancario affidabile al fine di interrompere le loro attività. Tuttavia, sembra che ci siano altre banche, come Cross River Bank, istituto finanziario con sede nel New Jersey, disposte a servire il settore cripto.</p>
<h2 id="h2-La20Banca20Cross20River20sembra20una20mossa20naturale609854"><a name="La Banca Cross River sembra una mossa naturale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Banca Cross River sembra una mossa naturale</h2><p>Dopo la chiusura di Silvergate Bank e Silicon Valley Bank, Circle, una società tecnologica di pagamenti peer-to-peer e l’emittente di <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a>(USDC) ha collaborato con Cross River Bank per garantire che la stablecoin mantenga un ancoraggio di 1,1 con il dollaro statunitense. Già Cross River Bank sta lavorando con altre società criptografiche, tra cui lo scambio Coinbase.</p>
<p>Circle vuole continuare con l’emissione e il rimborso automatizzati di USDC. Prima della nuova partnership bancaria, Circle aveva una relazione lavorativa con Silicon Valley Bank, dove aveva bloccato 3,3 miliardi di dollari. Purtroppo, l’USDC si è scollegato l’11 marzo, costringendo Circle a bruciare 2,34 miliardi di dollari in USDC per mantenere il suo ancoraggio al dollaro statunitense.</p>
<p>Pubblicando su Twitter, Jeremy Allaire, il co-fondatore e CEO di Circle, ha affermato che l’azienda ha scelto Cross River Bank per garantire che i fondi dei clienti rimangano al sicuro in USDC. In sostanza, Circle evita la banca a riserva frazionaria poiché espone la sua stablecoin, USDC, a rischi.</p>
<p>Inoltre, è importante per Circle stringere una partnership con una banca affidabile per evitare il distacco di USDC. Di recente, quando ha annunciato la sua esposizione a Silicon Valley Bank, l’USDC si è staccato fino a $0.87. Tuttavia, la stablecoin ha già riconquistato il suo ancoraggio.</p>
<p>Inoltre, è essenziale capire che Circle non sta limitando la sua partnership nel settore bancario a Cross River Bank. Ha anche una relazione bancaria esistente con la Bank of New York Mellon (BNY Mellon) che ha già offerto servizi di custodia degli asset di Circle. Di recente, Circle ha annunciato di aver trasferito il denaro che era rimasto nella Silicon Valley Bank a Cross River Bank.</p>
<p>Ci sono forti motivi per cui Circle ha scelto di fare affari con Cross River Bank. Prima di tutto, la banca è supportata da diversi venture capitalist che hanno interesse per gli asset digitali, come KKR, Ribbit Capital, Andreessen Horowitz e Battery Ventures. Ha anche rapporti finanziari con aziende esposte alle criptovalute come Stripe e Affirm. Inoltre, ha un forte sostegno da parte di JPMorgan e Pathword, dove deposita i fondi dei suoi clienti.</p>
<h2 id="h2-Cos20Cross20River20Bank977583"><a name="Cos’è Cross River Bank?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Cross River Bank?</h2><p>Ora che abbiamo discusso di come Cross River Bank supporta i servizi di criptovaluta, cerchiamo di capire cos’è e cosa offre.</p>
<p>Cross River Bank è una banca assicurata dalla FDIC, con sede nel New Jersey, che offre vari servizi bancari ai clienti, tra cui le aziende di criptovalute. Ha l’infrastruttura necessaria per offrire prestiti e facilitare le conversioni cripto-fiat. Dopo la chiusura di Silvergate Bank, Silicon Valley Bank e Signature Bank, molte istituzioni che forniscono servizi criptografici hanno scelto di stabilire partnership con essa.</p>
<h2 id="h2-Altre20banche20che20possono20supportare20istituzioni20che20operano20con20asset20digitali358670"><a name="Altre banche che possono supportare istituzioni che operano con asset digitali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altre banche che possono supportare istituzioni che operano con asset digitali</h2><p>Oltre alla Cross River Bank e alla Bank of New York Mellon, ci sono altre banche che offrono servizi bancari alle società criptate.</p>
<p>Secondo il Digital Currency Group (DCG), una delle più grandi organizzazioni crittografiche che sta cercando potenziali partner bancari, ci sono molte banche disposte a offrire servizi correlati alle criptovalute. Queste includono, ma non si limitano a Deutsche Bank (DB), Santander (SAN), HSBC (HSBA), Western Alliance, Mercury, Series Financial Multis, Bank Prove e Bridge.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680253696651680253579_.pic.jpg" alt=""><br>Gruppo di valute digitali - Cryptotimes</p>
<p>Già Western Alliance e Bridge Bank stanno negoziando con società di criptovalute che desiderano i loro servizi bancari come servizi di bonifico di terze parti, mercati monetari e brokeraggio limitato. Altre banche cripto-friendly sono First Foundation Bank, Sutton Bank, Quontic Bank, Customers Bank, Evolve Bank &amp; Trust e Cermak.</p>
<h2 id="h2-Controllo20regolamentare742420"><a name="Controllo regolamentare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Controllo regolamentare</h2><p>A seguito del crollo di diverse banche che offrivano vari servizi legati alle criptovalute, c’è un aumento della supervisione regolamentare negli Stati Uniti. Ad esempio, di recente l’OCC <a href="https://www.occ.gov/news-issuances/news-releases/2021/nr-occ-2021-121.html" rel="nofollow noopener noreferrer" target="_blank">detto</a> che le banche nazionali dovrebbero dimostrare di avere controlli adeguati prima di poter intraprendere determinate attività di criptovalute, registro distribuito e stablecoin.</p>
<p>Attualmente, c’è una proposta per estendere la regola di custodia in una ‘regola di custodia sicura’ che richiede ‘l’uso di un custode qualificato per tutti gli asset dei clienti (inclusi, esplicitamente, gli asset digitali), anziché solo per gli asset dei clienti che costituiscono ‘titoli dei clienti’ o ‘fondi dei clienti’.</p>
<p>Il crollo di FTX e l’elevata incidenza di furti di criptovalute e altri reati nel 2022 hanno aumentato la necessità di un controllo normativo più attento.</p>
<h2 id="h2-Conclusione498617"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>L’evoluzione dell’ambiente crittografico ha dimostrato che ci sono varie banche disposte a offrire servizi relativi alle criptovalute. Ciò segue il crollo di tre banche, Silvergate Bank, Silicon Valley Bank e Signature bank, che offrivano servizi di conversione da criptovaluta a fiat. Ad esempio, Circle ha collaborato con Cross River Bank e Bank of New York Mellon per ottenere i servizi bancari di cui ha bisogno.</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>