U2lsdmVyZ2F0ZSBzb3NwZW5kZSBsYSByZXRlIGRpIHBhZ2FtZW50aSBjcml0dG9ncmFmaWNpIGUgYWx0cm8=

2023-03-20, 01:04

<p><img src="https://gimg2.gateimg.com/image/article/1679273618热点追踪 封面.jpg" alt=""></p>
<h2 id="h2-TL20DR696632"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>La Silvergate Bank ha chiuso la Silvergate Exchange Network a seguito di sfide finanziarie e regolamentari.</p>
<p>L’implosione di FTX e della sua azienda sorella Alameda Research ha contribuito alle difficoltà finanziarie di Silvergate.</p>
<p>Galaxy Digital, LedgerX, Coinbase, Circle, Paxos e Bitstamp hanno concluso le loro partnership commerciali con Silvergate Bank.<br>Entro la fine di febbraio, il prezzo delle azioni di Silvergate Capital Corp è diminuito dell’89% rispetto al suo massimo storico di novembre 2021.</p>
<h2 id="h2-Introduzione255985"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il crollo delle criptovalute iniziato all’inizio del 2022 continua a seminare il caos nel settore, poiché alcuni progetti legati alle criptovalute stanno chiudendo le loro operazioni. Recentemente, Silvergate Capital Corp ha annunciato che sta <a href="https://www.gate.io/es/blog_detail/2280/%E7%AC%AC%E4%B8%80%E8%A1%8C%E6%83%85-silvergate%E9%93%B6%E8%A1%8C%E5%85%B3%E9%97%AD%E5%BC%95%E5%8F%91%E5%85%A8%E7%90%83%E5%B8%82%E5%9C%BA%E6%8A%9B%E5%94%AE-%E5%AF%BC%E8%87%B4%E5%8A%A0%E5%AF%86%E9%A2%86%E5%9F%9F3%E4%BA%BF%E7%BE%8E%E5%85%83%E6%B8%85%E7%AE%97" target="_blank">interrompere la Silvergate Exchange Network</a>. Oggi discutiamo delle possibili cause del declino</p>
<h2 id="h2-La20chiusura20di20Silvergate20Exchange20Network20SEN341758"><a name="La chiusura di Silvergate Exchange Network (SEN)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La chiusura di Silvergate Exchange Network (SEN)</h2><p>Il 8 marzo 2023 Silvergate Capital Corp, la società di comodo per Silvergate Exchange Network, <a href="https://ir.silvergate.com/news/news-details/2023/Silvergate-Capital-Corporation-Announces-Intent-to-Wind-Down-Operations-and-Voluntarily-Liquidate-Silvergate-Bank/default.aspx" rel="nofollow noopener noreferrer" target="_blank">ha annunciato di aver interrotto SEN</a>, la sua rete di pagamento criptovaluta. Sebbene l’azienda non abbia divulgato il motivo esatto della sua azione, ha dichiarato che si tratta di una decisione basata sul rischio, il che significa che l’organizzazione potrebbe essere confrontata a sfide di sostenibilità o di liquidità.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679274141Silvergate 1.png" alt=""><br>Banca Silvergate- <a href="https://www.coindesk.com/resizer/dGftW-u-990-Yi-qN1MAHjHBlfE=/1056x594/filters:quality(80" rel="nofollow noopener noreferrer" target="_blank">Coindesk</a>:format(webp)/cloudfront-us-east-1.images.arcpublishing.com/coindesk/GNWQ2ZAWD5C4HKPIBBC6KH5FCU.png “Coindesk”)<br>La chiusura di Silvergate Exchange Network (SEN) arriva pochi giorni dopo che l’agenzia di rating Moody’s l’ha declassata da Ba3 a Caa1 a seguito della mancata presentazione del suo rapporto annuale alla Securities and Exchange Commission (SEC) degli Stati Uniti. Tuttavia, Silvergate Bank ha affermato che tutti gli altri “servizi relativi ai depositi rimangono operativi”.</p>
<p>Leggi anche: <a href="https://www.gate.io/th/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><br>L’annuncio di interrompere la Silvergate Exchange Network arriva una settimana dopo che Silvergate Capital Corp ha informato la SEC che stava valutando la sua capacità di continuare a operare come un’impresa in corso e che aveva venduto ulteriori strumenti di debito con una perdita. Ha sottolineato che la vendita aggiuntiva dei suoi titoli con una perdita comporterebbe che la banca diventasse “meno capitalizzata”.</p>
<p>Le prestazioni finanziarie del terzo trimestre 2022 della banca mostrano che potrebbe trovarsi di fronte a difficoltà finanziarie. Ciò è dovuto al fatto che durante quel periodo ha accumulato una perdita di 886 milioni di dollari dalla vendita dei suoi titoli subacquei. Silvergate Bank ha deciso di vendere i titoli a seguito di una caduta del 68% dei depositi correlati alle criptovalute nello stesso periodo.</p>
<p>Nel particolare, la Banca aveva l’intenzione di raccogliere i fondi necessari per saldare $9,9 milioni a BlockFi, un’istituzione di prestiti criptati, secondo l’ordine di un giudice fallimentare statunitense.</p>
<p>La discontinuità di Silvergate Bank dalla Silvergate Exchange Network (SEN) potrebbe essere un segnale che non è più interessata a qualsiasi attività legata alle criptovalute. Già alcuni dei suoi partner chiave nel settore delle criptovalute come Coinbase e gli emittenti di stablecoin, Paxos e Circle, hanno interrotto le loro relazioni commerciali esistenti con essa.</p>
<h2 id="h2-Comprendere20la20Silvergate20Exchange20Network20SEN312642"><a name="Comprendere la Silvergate Exchange Network (SEN)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprendere la Silvergate Exchange Network (SEN)</h2><p>Silvergate Exchange Network (SEN) era un’organizzazione correlata alla crittografia che facilitava la conversione di criptovalute in valute fiat e viceversa tra scambi di criptovalute, investitori istituzionali e altri clienti. Entro il terzo trimestre del 2022, SEN aveva più di 1.600 clienti, tra cui scambi di criptovalute e investitori istituzionali, con un deposito totale di oltre $12 miliardi.</p>
<h2 id="h2-Le20possibili20cause20della20cessazione20della20Silvergate20Bank20della20Silvergate20Exchange20Network20SEN572501"><a name="Le possibili cause della cessazione della Silvergate Bank della Silvergate Exchange Network (SEN)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le possibili cause della cessazione della Silvergate Bank della Silvergate Exchange Network (SEN)</h2><p>Ci sono diversi fattori che probabilmente hanno contribuito alla discontinuità della Silvergate Exchange Network (SEN). Questi potrebbero includere la pressione del governo, il crollo criptato di FTX, le relazioni interrotte con i suoi partner e il significativo calo del valore delle sue azioni.</p>
<h2 id="h2-Il20Crollo20di20FTX701932"><a name="Il Crollo di FTX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il Crollo di FTX</h2><p>I problemi attuali della Silvergate Bank sono iniziati quando lo scambio di criptovalute FTX e la sua azienda sorella Alameda Research sono crollati nel terzo trimestre del 2022. Dopo questo incidente criptovalutario, i clienti di FTX hanno ritirato $8.1 miliardi di depositi. Per far fronte a questo alto prelievo, la Silvergate Bank ha preso un prestito dal sistema di prestiti bancari domestici, un’organizzazione federale che fornisce alle banche finanziamenti a basso costo.<br>Leggi anche: <a href="https://www.gate.io/blog_detail/2268/uk-crypto-regulation-ftx-collapse" target="_blank">Gran Bretagna si prepara a regolamentare la criptovaluta dopo il crollo di FTX</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/1679274187Silvergate 2.png" alt=""><br>Crollo di FTX- Paybito</p>
<p>Quel prestito ha suscitato scalpore tra i legislatori federali che temevano che se la Silvergate Bank non avesse restituito l’importo preso in prestito, la Federal Deposit Insurance Corp potesse essere gravemente colpita, il che avrebbe potuto portare a una protesta pubblica. Di conseguenza, è stato chiesto alla Silvergate di restituire immediatamente il prestito.<br>Per ripagare quel prestito, la Silvergate Bank ha venduto i suoi titoli subendo una perdita totale di 886 milioni di dollari.</p>
<h2 id="h2-Pressione20governativa774339"><a name="Pressione governativa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pressione governativa</h2><p>La Silvergate Bank era anche sotto intenso scrutinio dei procuratori statunitensi per la frode del Dipartimento di Giustizia relativa alle sue operazioni finanziarie con FTX e Alameda Research.</p>
<p>Da qualche tempo, i regolatori stavano interrogando Silvergate Bank per non aver rilevato le transazioni finanziarie sospette tra FTX e la sua società controllata Alameda Research. Al momento del suo collasso, Silvergate deteneva 1 miliardo di dollari in depositi da FTX.</p>
<p>Alla luce di queste accuse e di altri sviluppi nel settore delle criptovalute, Silvergate ha ritenuto necessario procedere alla liquidazione volontaria di Silvergate Exchange Network (SEN).</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1804/key-lessons-from-the-collapse-of-ftx-and-the-implosion-of-ftt" target="_blank">Lezioni chiave dal crollo di FTX e dall’implosione di FTT</a></p>
<h2 id="h2-Costante20diminuzione20del20valore20delle20sue20azioni737958"><a name="Costante diminuzione del valore delle sue azioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Costante diminuzione del valore delle sue azioni</h2><p>Il valore delle azioni di Silvergate è stato minacciato fin dal <a href="https://www.gate.io/blog_detail/1792/ftx-event-and-its-domino-effects" target="_blank">collasso di FTX e Alameda Research</a>. Attualmente, il prezzo delle sue azioni è diminuito di circa il 65,8% dall’inizio dell’anno. Peggio ancora, il prezzo delle sue azioni è diminuito dell’89% rispetto al suo massimo storico nel novembre 2021. Questa costante diminuzione del valore delle sue azioni e l’attuale mercato delle criptovalute instabile hanno influenzato Silvergate Bank a interrompere la Silvergate Exchange Network (SEN).</p>
<h2 id="h2-Relazione20con20i20suoi20partner689566"><a name="Relazione con i suoi partner" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Relazione con i suoi partner</h2><p>La maggior parte dei suoi partner ha interrotto le loro relazioni commerciali con Silvergate in seguito all’annuncio che avrebbe ritardato la presentazione del suo rapporto annuale. Ad esempio,<br><strong>Galaxy Digital, LedgerX, Coinbase, Circle, Paxos e Bitstamp</strong> dichiarato pubblicamente che hanno <a href="https://cointelegraph.com/news/circle-paxos-bitstamp-and-galaxy-join-coinbase-in-scaling-back-partnerships-with-silvergate-bank" rel="nofollow noopener noreferrer" target="_blank">terminato le loro partnership con Silvergate Bank</a>.</p>
<h2 id="h2-La20breve20storia20di20Silvergate20Bank294939"><a name="La breve storia di Silvergate Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La breve storia di Silvergate Bank</h2><p>Silvergate Bank ha iniziato come un’associazione di prestiti e risparmi nel 1988 in California, Stati Uniti. Nel 1996 Dennis Frank e Derek J. Eisele hanno ricapitalizzato Silvergate e l’hanno trasformata in una banca commerciale che fornisce servizi di prestito e bancari come conti bancari per immobili commerciali e aziendali. È una banca che è stata disposta a collaborare con aziende di criptovalute e supportare i loro servizi di criptovaluta.</p>
<h2 id="h2-Conclusione661803"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>L’8 marzo 2023 Silvergate Bank ha annunciato di interrompere la Silvergate Exchange Network (SEN). Sebbene non abbia specificato le ragioni esatte, diversi fattori hanno contribuito a tale decisione. Questi includono l’implosione di FTX e Alameda, il calo dei prezzi delle sue azioni e la pressione regolamentare governativa.</p>
<h2 id="h2-Domande20frequenti20su20Silvergate20Bank303510"><a name="Domande frequenti su Silvergate Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Silvergate Bank</h2><p><strong>Silvergate è una banca?</strong></p>
<p>Silver Gate Bank è una banca commerciale che è stata fondata nel 1996 e opera attualmente negli Stati Uniti. Inizialmente, è stata costituita come associazione di prestiti e risparmio nel 1988 in California. Offre vari servizi commerciali come prestiti e immobili.</p>
<p><strong>Quanto è grande Silvergate Bank?</strong></p>
<p>Silvergate Bank è una grande istituzione finanziaria che conta molti clienti istituzionali poiché offre vari servizi come risparmi aziendali, mercato monetario, certificati di deposito, gestione del denaro, servizi bancari online e di elaborazione. È stata fondata negli Stati Uniti nel 1996.</p>
<p><strong>È Silvergate Bank buono?</strong></p>
<p>Silvergate è una banca di grande reputazione che offre servizi a vari clienti, tra cui investitori istituzionali. È diventata molto popolare quando ha creato la sua Silvergate Exchange Network che ha aiutato i suoi clienti a scambiare criptovalute con denaro fiat. È sempre stata in grado di soddisfare i suoi obblighi finanziari verso i suoi clienti.</p>
<p>Chi possiede Silvergate Capital?</p>
<p>Martin S. Friedman è il più grande azionista individuale di Silvergate Capital. Tuttavia, ci sono anche alcuni altri azionisti individuali oltre a molti detentori di equity istituzionale.</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 ripostare l'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>