TGUgYmFuY2hlIGluIGNyYXNoIHNwaW5nb25vIGxlIGNyaXB0b3ZhbHV0ZSB2ZXJzbyB1biBtZXJjYXRvIHJpYWx6aXN0YQ==

2023-03-31, 08:53

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR32887"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Silicon Valley Bank, Signature Bank and Silvergate Bank collapsed in March due to various reasons.</p>
<p>Le principali ragioni del fallimento di queste banche sono state la cattiva gestione finanziaria e le forti diminuzioni dei valori delle loro azioni.</p>
<p>Il governo svizzero è intervenuto per impedire il crollo di Credit Suisse, un prestatore finanziario.</p>
<p>I prezzi di BTC, ETH e altre criptovalute sono aumentati rapidamente alcuni giorni dopo il crollo di Silicon Valley Bank, Signature Bank e Silvergate Bank.</p>
<h2 id="h2-Introduzione735494"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Tre grandi banche negli Stati Uniti, Silicon Valley Bank, Signature Bank e Silvergate Bank, sono fallite in successione nel giro di una settimana, dal 7 al 14 marzo 2023. Nello specifico, Silvergate Bank, <a href="https://www.gate.io/blog_detail/2287/daily-news-us-regulators-launch-25bn-lending-program-as-bitcoin-stabilizes-post-svb-banking-crisis-stablecoin-volatility-surges-as-usdc-depegs" target="_blank">Silicon Valley Bank (SVB)</a>, rispettivamente il 10 e il 12 marzo.</p>
<p>Queste banche sono state colpite da circostanze simili come l’aumento dei tassi di interesse della Fed, la cattiva gestione e l’esposizione alle criptovalute. Tuttavia, gli analisti ritengono che l’impatto dell’esposizione alle criptovalute sul collasso di queste banche sia stato minimo. Vediamo brevemente le serie di eventi che hanno portato al collasso di ciascuna di queste banche.</p>
<h2 id="h2-Banca20Signature682952"><a name="Banca Signature" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Banca Signature</h2><p>Silvergate ha subito una perdita di oltre 1 miliardo di dollari nel 2022 a causa delle attuali condizioni macroeconomiche e <a href="https://www.gate.io/blog_detail/1876/after-ftx-investors-are-choosing-an-exchange-with-a-long-track-record-of-best-practices-in-liquidity-and-risk-management" target="_blank">il crollo dello scambio FTX</a>. Di conseguenza, la banca ha ridotto il suo personale del 40%. Per rendere le cose peggiori, il Dipartimento di Giustizia degli Stati Uniti (DO) ha iniziato a indagare per i suoi affari finanziari con FTX. Inoltre, Silvergate Bank ha mancato la presentazione del modulo 10K con la SEC, inviando un segnale negativo al mercato crittografico.</p>
<p>In risposta, diverse società tra cui Coinbase, Paxos Trust Company, Circle e Ledger <a href="https://www.gate.io/blog_detail/2326/silvergate-suspends-crypto-payments-network-and-more" target="_blank">terminato la loro partnership con Silvergate</a>. Questo è stato seguito da un brusco calo del prezzo delle sue azioni, il cui valore è sceso del 97%, da $219.75 a $5.41.</p>
<h2 id="h2-Banca20della20silicio857909"><a name="Banca della silicio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Banca della silicio</h2><p>I regolatori hanno annunciato il 10 marzo che Silicon Valley Bank stava chiudendo. Il fattore principale che ha contribuito a questo disastro è stato il suo investimento in titoli a lunga scadenza, tra cui obbligazioni ipotecarie e titoli del Tesoro degli Stati Uniti. A causa dell’aumento costante dei tassi di interesse della Fed, il valore di questi strumenti è diminuito significativamente. Di conseguenza, una settimana prima della chiusura il prezzo delle sue azioni è crollato del 67%.</p>
<p>Per rafforzare il proprio bilancio, Silicon Valley Bank ha proposto di emettere azioni ordinarie e azioni privilegiate convertibili. Quando i clienti hanno saputo delle sue difficoltà finanziarie, hanno perso fiducia e ritirato i loro fondi in gran numero, provocando una corsa bancaria.</p>
<h2 id="h2-Signature20Bank79642"><a name="Signature Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Signature Bank</h2><p>La Signature Bank ha affrontato varie sfide finanziarie che sono iniziate quando Celsius, uno dei suoi clienti chiave, ha chiuso. L’implosione di FTX ha reso la situazione peggiore di prima. D’altra parte, Statistica Capital, una società di trading algoritmico, ha intentato una causa contro Signature Bank accusandola di permettere ‘la commistione dei fondi dei clienti di FTX all’interno della sua rete di pagamenti basata su blockchain, Signet’.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680252050581680252005_.pic.jpg" alt=""><br>Signature bank - Livemint</p>
<p>Purtroppo, dopo la chiusura di Silvergate Bank, le azioni di Signature Bank sono precipitate facendole interrompere le negoziazioni. Poco dopo, i regolatori l’hanno sequestrata portandola alla chiusura.</p>
<h2 id="h2-Credit20Suisse504565"><a name="Credit Suisse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Credit Suisse</h2><p>Un altro sviluppo che ha creato paura nel settore finanziario riguarda i problemi che Credit Suisse, un istituto di credito svizzero, ha affrontato alcuni giorni dopo la chiusura delle banche statunitensi sopra menzionate. In particolare, il 15 marzo 2023 il valore delle azioni di Credit Suisse è diminuito del 20% a seguito dell’annuncio della Banca Nazionale Saudita che non avrebbe fornito ulteriore supporto finanziario.</p>
<p>Tuttavia, il governo svizzero è intervenuto per evitare il collasso di Credit Suisse. In effetti, ha costretto l’USB ad acquisire Credit Suisse per 2,7 miliardi di dollari. La banca centrale della Svizzera ha spiegato che è intervenuta per migliorare la stabilità finanziaria nel paese e proteggere l’economia svizzera.</p>
<h2 id="h2-Come20ha20risposto20il20mercato20delle20criptovalute153568"><a name="Come ha risposto il mercato delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come ha risposto il mercato delle criptovalute?</h2><p>I prezzi delle principali criptovalute sono aumentati dopo il crollo delle tre banche negli Stati Uniti. Ad esempio, il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo di Bitcoin</a> raggiunto <a href="https://www.gate.io/blog_detail/2327/daily-news-fed-meeting-looms-amid-banking-crisis-btc-rallies-to-9-month-high-and-arbitrum-airdrop-takes-spotlight" target="_blank">il suo punto più alto in nove mesi</a>. In particolare, tra il 10 e il 17 marzo il valore di BTC è aumentato del 36,06%. Complessivamente, ha guadagnato il 70% dall’inizio dell’anno con il suo prezzo che ha raggiunto $28,085 pochi giorni dopo il crollo delle banche.</p>
<p>Fondamentalmente, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e altre criptovalute sono rimaste resilienti nonostante la turbolenza finanziaria nel settore finanziario tradizionale.</p>
<p>Nello stesso periodo, dal 10 al 17 marzo, ETH è aumentato del 26,67%, raggiungendo un massimo di 1.750 dollari statunitensi. Oltre a ETH e BTC, ci sono state altre criptovalute che si sono comportate bene nello stesso periodo. Ad esempio, il prezzo di CFX, il token di utilità di Conflux Network, è aumentato del 105,99%. Allo stesso modo, il prezzo di STX, il token di utilità di gate, è aumentato del <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a>- il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il livello del contratto intelligente di ‘s è aumentato del 100,13% per chiudere a 1,09 dollari statunitensi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680252605591680252015_.pic.jpg" alt=""><br>Le principali criptovalute hanno registrato un picco - Freepik</p>
<p>Ci sono diverse spiegazioni per il rally della principale criptovaluta dopo la chiusura delle tre banche. Una delle ragioni principali è che il mercato ha capito che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e altre criptovalute continuano a servire il loro scopo originale, quello di essere un’alternativa alla finanza tradizionale. Come tali, offrono protezione contro l’imprevista caduta dei valori delle valute fiat.</p>
<p>Gli investitori di criptovalute si aspettano anche che la Fed adotti una posizione più rilassata sui tassi di interesse per proteggere il sistema finanziario tradizionale. Questo perché i tassi di interesse elevati hanno anche avuto un impatto negativo sul mercato delle criptovalute.</p>
<p>C’è anche la prospettiva che l’inflazione sia probabile che diminuisca. In questo contesto, Simon Peters, analista di criptovalute presso eToro, ha dichiarato: “Si potrebbe dire che abbiamo visto l’apice dell’inflazione negli Stati Uniti e anche se alcuni componenti rimangono stabili, stiamo iniziando a vedere il numero principale diminuire complessivamente.”</p>
<h2 id="h2-Le20criptovalute20sono20la20nuova20merce20sicura163418"><a name="Le criptovalute sono la nuova merce sicura?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le criptovalute sono la nuova merce sicura?</h2><p>La attuale situazione economica e la recente chiusura delle banche, nonché la caduta dei prezzi delle azioni, dimostrano che le criptovalute rimangono un bene sicuro.</p>
<p>Già alcuni analisti di criptovalute hanno sottolineato che le recenti turbolenze nei sistemi finanziari tradizionali indicano che l’attuale mercato orso sta per giungere al termine. Ad esempio, un rispettabile stratega ribassista, Michael Wilson di Morgan Stanley, ha affermato che l’intervento della Federal Reserve e della Federal Deposit Insurance Corp nel settore bancario rappresenta l’inizio della fine del mercato orso, poiché la diminuzione della disponibilità di credito limita la crescita dell’economia.</p>
<p>Tuttavia, Wilson crede ancora che il mercato delle criptovalute possa sperimentare ulteriore volatilità dei prezzi. Ha aggiunto: “L’ultima parte dell’orso può essere feroce e altamente correlata. I prezzi crollano bruscamente tramite un picco del premio di rischio patrimoniale che è molto difficile da prevenire o difendere nel proprio portafoglio.”</p>
<h2 id="h2-Conclusione921025"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Sebbene il crollo di Silicon Valley Bank, Signature Bank e Silvergate Bank abbia causato molta ansia nel settore finanziario tradizionale e nel mercato azionario, non ha avuto un impatto negativo sul settore delle criptovalute. Invece, la maggior parte delle principali criptovalute ha guadagnato dopo il loro crollo. Secondo alcuni analisti, queste turbolenze nel settore finanziario tradizionale indicano che il mercato orso sta arrivando alla fine.</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 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>