SWwgY3JvbGxvIGRpIFNWQiBoYSBjYXVzYXRvIGwnZWZmZXR0byBmYXJmYWxsYSBuZWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGU/IENvc2EgZG92cmViYmVybyBmYXJlIGdsaSBpbnZlc3RpdG9yaT8=

2023-03-14, 10:00

<p><img src="https://gimg2.gateimg.com/image/article/1678845855314.jpg" alt=""><br>Il crollo di SVB ha causato l’effetto farfalla sul mercato crittografico? Cosa dovrebbero fare gli investitori?<br>Silicon Valley Bank (SVB), il secondo più grande fallimento bancario nella storia degli Stati Uniti, ha improvvisamente annunciato il suo crollo venerdì, causando turbolenze nei mercati finanziari globali ed economici, suscitando preoccupazioni per una potenziale catastrofe sistemica. Mentre gli esperti dicono che tali paure siano in gran parte esagerate, avvertono che le conseguenze del continuo aumento dei tassi d’interesse della Fed per contrastare l’aumento dell’inflazione continueranno a influenzare l’economia per molto tempo. Ora il crollo della Silicon Valley Bank si è esteso al mercato crittografico e alla seconda più grande stablecoin, <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a>, nel mercato delle criptovalute è stato coinvolto. Il 12 marzo, <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a> Il (USDC) è salito bruscamente a circa lo 0,95, ma non è ancora tornato al livello normale precedente a questo tumulto.</p>
<h2 id="h2-Panoramica20del20crollo20di20SVB75851"><a name="Panoramica del crollo di SVB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica del crollo di SVB</h2><p>La Silicon Valley Bank è la 16a banca più grande degli Stati Uniti, con un patrimonio di oltre 200 miliardi di dollari USA, principalmente al servizio delle start-up nel settore tecnologico. Si ritiene generalmente che SVB possieda un investimento relativamente conservativo, con un basso rischio del suo portafoglio di attività. Gran parte del suo portafoglio di attività è costituito da obbligazioni a basso rischio.<br>Dal crollo all’acquisizione, la Silicon Valley Bank ha vissuto 48 ore da incubo. L’8 marzo, Silicon Valley Bank Financial Group, la società madre della Silicon Valley Bank, ha annunciato di aver precedentemente completato la vendita di quasi tutti i suoi titoli negoziabili, per un totale di circa 21 miliardi di dollari, il che si tradurrà in una perdita al netto delle imposte di circa 1,8 miliardi di dollari nel primo trimestre del 2023. Nel frattempo, la Silicon Valley Bank prevede di raccogliere 2,25 miliardi di dollari attraverso varie forme di finanziamento azionario.<br>Gli investitori di mercato hanno preso questa mossa come un segnale pericoloso e la Silicon Valley Bank è crollata del 60,41% quel giorno, il calo maggiore dal 1998. L’incidente di SVB ha anche causato vendite di panico nel mercato dei capitali, facendo scendere i titoli bancari e il valore di mercato delle quattro principali banche è evaporato di 52,4 miliardi di dollari. JPMorgan Chase (133,65, 3,31, 2,54%) è scesa del 5,41%, Bank of America è scesa del 6,2%, Wells Fargo è scesa del 6,18%; Citigroup è scesa del 4,1%. Inoltre, l’indice Philadelphia Bank è crollato del 7,7%, la peggiore performance giornaliera da giugno 2020. Le quattro maggiori banche statunitensi hanno perso 47 miliardi di dollari di valore di mercato nelle contrattazioni dello stesso giorno.<br>Secondo i resoconti dei media e le analisi del settore, ci sono due ragioni principali per il crollo di SVB. Uno è stato colpito dal crollo dell’anno scorso del suo principale cliente, l’exchange di criptovalute FTX. Le indagini normative su FTX hanno innervosito i clienti della Silicon Valley Bank, innescando una corsa agli sportelli. In secondo luogo, di fronte a una corsa agli sportelli, SVB è stata costretta a vendere 21 miliardi di dollari di titoli di alta qualità, ma il valore di questi titoli è stato notevolmente deprezzato dall’impatto dei forti aumenti dei tassi di interesse della Fed. Insieme al fatto che questi titoli non sono ancora scaduti, il sell-off ha provocato direttamente una perdita di 1,8 miliardi di dollari. Molti commentatori su Internet hanno affermato che se non fosse stato per la continua imposizione di aumenti dei tassi di interesse da parte della Fed, la Silicon Valley Bank avrebbe probabilmente raccolto fondi sufficienti per far fronte alla corsa agli sportelli bancari ed evitare la bancarotta vendendo obbligazioni a prezzi normali.<br>Il Wall Street Journal afferma che la FDIC ha rilevato la Silicon Valley Bank e ha trasferito tutti i suoi depositi a una nuova banca fisica creata dalla FDIC. A partire da lunedì prossimo, i depositanti protetti saranno in grado di prelevare depositi fino a $ 250.000 presso le loro banche, ha affermato la FDIC. I depositanti con più di $ 250.000 di depositi riceveranno un certificato di amministrazione controllata e contatteranno la FDIC una settimana dopo per discutere la risoluzione.</p>
<h2 id="h2-Il20crollo20di20SVB20ha20influenzato20il20mercato20crittografico772850"><a name="Il crollo di SVB ha influenzato il mercato crittografico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il crollo di SVB ha influenzato il mercato crittografico?</h2><p>Il calore del fallimento della Silicon Valley Bank continua a bollire, diffondendosi anche al mercato delle criptovalute. USDC, la seconda stablecoin più grande nel mercato delle criptovalute, è stato coinvolto e ha subito un duro colpo. Tuttavia, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> è aumentato in mezzo al panico bancario, superando i 24.000 dollari, mentre Ether è salito del 14,87% nelle ultime 24 ore. USDC è coinvolto in eventi di rischio, ma perché lo fa <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> salire in modo anomalo? Molti investitori hanno detto che questo è una manifestazione di avversione al rischio di mercato. Dopo il crollo di USDC, ha scatenato una serie di reazioni di mercato. Molti dei principali scambi di criptovalute hanno limitato le loro transazioni correlate e gli utenti non hanno potuto vendere immediatamente. Convertirlo in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> al prezzo corrispondente può ridurre le perdite in una certa misura.</p>
<p>Ad esempio, Coinbase, la più grande piattaforma di trading di criptovalute al mondo, ha annunciato che sospenderebbe la conversione della stablecoin USDC nel fine settimana, e riprenderà quando la banca riaprirà lunedì, sottolineando che ‘gli asset degli utenti sono sicuri’. Binance (Binance) ha anche indicato che a causa delle attuali condizioni di mercato, l’elevato afflusso di asset USDC ha aumentato il carico di conversione automatica. Pertanto, Binance ha sospeso la conversione automatica di USDC in BUSD, e ha dichiarato che si tratta di una misura di gestione del rischio routinaria. Inoltre, diverse piattaforme di trading hanno annunciato la sospensione delle transazioni e dei depositi della stablecoin USDC in dollari.</p>
<p>In effetti, le esplosioni di stablecoin non sono sconosciute agli utenti. Nel maggio 2022, il prezzo della moneta LUNA conosciuta come ‘Moutai nel mercato delle criptovalute’ è sceso da circa 100 dollari a meno di 0,001 dollari in una settimana, e il valore di mercato totale è passato da 40 miliardi di dollari a ‘quasi zero’. La stablecoin algoritmica UST che l’accompagna era originariamente ancorata a 1 dollaro, ma alla fine è scesa a 0,03 dollari. L’impatto dell’incidente di esplosione della moneta LUNA è emerso gradualmente da allora. Il fallimento di Sanjian Capital e il crollo di FTX hanno continuato ad avvolgere il campo delle criptovalute in un panico di liquidità.</p>
<p>Sotto la continua trasmissione dei rischi, l’8 marzo 2023 Eastern Time, Silvergate Capital, la società madre di Silvergate Bank, ha emesso un annuncio sul proprio sito web, annunciando che chiuderà l’attività bancaria in modo ordinato in conformità alle procedure regolamentari applicabili e liquiderà volontariamente la banca. Le attuali epiche fluttuazioni nella valutazione di USDC rispetto al dollaro americano e il ritiro dei depositi da parte di un gran numero di investitori cripto principali hanno causato un disastro di liquidità nel settore. Ciò ha pienamente dimostrato che l’effetto domino causato dal crollo della banca di Silicon Valley ha iniziato a dispiegarsi.</p>
<h2 id="h2-Con20gioie20e20dolori20misti20forse20il20mercato20delle20criptovalute20ha20portato20buona20fortuna792075"><a name="Con gioie e dolori misti, forse il mercato delle criptovalute ha portato buona fortuna?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Con gioie e dolori misti, forse il mercato delle criptovalute ha portato buona fortuna?</h2><p>Nonostante il crollo di SVB abbia avuto un grande impatto sul mercato delle criptovalute, l’industria delle criptovalute non è del tutto cupa. I dati mostrano che nelle ultime 24 ore il valore di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è aumentato di oltre il 10%, raggiungendo un massimo di $24.480, il che sembra essere un buon presagio. Gli analisti ritengono che il trend al rialzo possa essere attribuito al sostegno dei regolatori per i depositi presso Silicon Valley Bank. Gli esperti si aspettano che la Federal Reserve adotti un atteggiamento più accomodante dopo il recente quasi collasso del settore bancario, il che è un segnale positivo per l’industria delle criptovalute e un potenziale sviluppo positivo che potrebbe aumentare la fluidità del sistema finanziario. Perché dimostra che gli investitori istituzionali stanno riconoscendo il potenziale di sviluppo delle valute digitali e stanno accogliendo gli investimenti in valute digitali. Oppure, dimostra anche che l’industria delle criptovalute sta svolgendo un ruolo così cruciale che i regolatori non possono ignorarla e devono adottare misure pertinenti per regolamentarla quando il mercato nel suo complesso ha un potenziale collasso.</p>
<h2 id="h2-Mantieni20la20calma20e20fai20trading20con20cautela904368"><a name="Mantieni la calma e fai trading con cautela" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mantieni la calma e fai trading con cautela</h2><p>Indipendentemente dal fatto che il crollo di SVB porterà a una reazione a catena più grave, gli investitori non devono farsi prendere dal panico, fuggire in fretta o seguire ciecamente il trend. Dopotutto, il mercato delle criptovalute ha vissuto innumerevoli tempeste sin dalla sua nascita, ma resiste ancora. Per quanto riguarda il crollo di SVB, la maggior parte degli esperti del settore ritiene che sia diverso dalla crisi finanziaria del 2008 ed è improbabile che causi una turbolenza finanziaria su vasta scala. Dal 2008, la supervisione del settore bancario statunitense è stata molto rigorosa e sono stati istituiti firewall bancari. Inoltre, dopo l’incidente, le autorità di regolamentazione statunitensi hanno rapidamente assunto il controllo della Silicon Valley Bank e hanno rapidamente avviato misure di emergenza per controllare l’effetto di ricaduta. Allo stesso tempo, i suoni del rallentamento dei rialzi dei tassi di interesse da parte della Fed stanno diventando sempre più forti, il che è senza dubbio un vangelo perduto da tempo per il mercato delle criptovalute. Ma in ogni caso, in momenti speciali, piccoli spruzzi possono far rotolare <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Waves</a>, quindi gli investitori devono essere cauti. Si consiglia di prestare maggiore attenzione alle fluttuazioni delle politiche della Fed, di utilizzare la leva con cautela, di minimizzare le perdite il più possibile e di proteggere il proprio capitale.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Copia di Gate.io Trading</strong><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 di questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa dell'infrazione del copyright.<br></div><p></p><br></div></div></div>