TGEgcHJldmlzaW9uZSBkaSBTYXRvc2hpIE5ha2Ftb3RvIMOoIGRpdmVudGF0YSByZWFsdMOgLCBnbGkgaW52ZXN0aXRvcmkgaGFubm8gY2VyY2F0byB1biBzZW5zbyBkaSBzaWN1cmV6emEgaW4gQlRDIGUgRVRI

2023-03-13, 10:05

<p><img src="https://gimg2.gateimg.com/image/article/1678784190网页.jpeg" alt=""></p>
<h2 id="h2-Un20breve20aggiornamento142523"><a name="Un breve aggiornamento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un breve aggiornamento</h2><h3 id="h3-La20previsione20di20Satoshi20Nakamoto20si2020avverata20e202020Bitcoin202020salito20a2024000891696"><a name="La previsione di Satoshi Nakamoto si è avverata, e   Bitcoin  È salito a $24.000" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La previsione di Satoshi Nakamoto si è avverata, e <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> È salito a $24.000</h3><p>Dopo il crollo di tre banche in successione, la First Republic Bank è stata sospesa dopo il crollo del pre-mercato del 67%, e la West Bank of Alains è stata sospesa. PacWest Bancorp ha innescato il circuit breaker all’inizio del mercato.</p>
<p>Satoshi Nakamoto ha scritto nel <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Blocco genesi il 3 gennaio 2009, che “il Segretario del Tesoro è sul punto di salvare di nuovo la banca”, che si è avverato oggi 14 anni dopo - il Dipartimento del Tesoro degli Stati Uniti, la Federal Reserve e la Federal Deposit Insurance Corporation hanno emesso una dichiarazione per salvare il mercato. Il giorno dopo la pubblicazione della dichiarazione congiunta, il presidente degli Stati Uniti Biden ha dichiarato che l’azione rapida del governo ha fatto credere agli americani che il sistema bancario degli Stati Uniti è sicuro. Nel frattempo, Biden ha dichiarato che chiederà al Congresso e agli organi di controllo di rafforzare le norme bancarie e di effettuare una contabilità completa di quanto accaduto alle banche. “Non ci fermeremo qui. Prenderemo tutte le misure necessarie. Dobbiamo evitare che ciò accada di nuovo.”</p>
<p>D’altra parte, sotto l’influenza del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> contratto di evento futures lanciato dalla Chicago Mercantile Exchange con il supporto dei regolatori per i depositi di Silicon Valley Bank e Signature Bank, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è aumentato di quasi il 10% nelle ultime 24 ore, tornando alla soglia dei 20.000 dollari, con il prezzo più alto di 24.488 dollari, e ora è quotato a 24.380 dollari. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> sono state liquidate posizioni per circa $180 milioni nelle ultime 24 ore e le posizioni corte erano di circa $180 milioni. USDC e DAI hanno gradualmente recuperato i loro prezzi ancorati e ora si sono ripresi a circa $0.99. Tuttavia, Curve 3pool è ancora in uno stato inclinato, con DAI e USDC che rappresentano più del 45% e USDT che rappresenta solo circa il 6.6%.</p>
<h3 id="h3-Gli20investitori20cercano20un20senso20di20sicurezza20in202020Bitcoin2020e202020Ethereum2020e20ci20si20aspetta20che20il20mercato20aumenti20i20tassi20dinteresse465321"><a name="Gli investitori cercano un senso di sicurezza in   Bitcoin  e   Ethereum , e ci si aspetta che il mercato aumenti i tassi d’interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli investitori cercano un senso di sicurezza in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, e ci si aspetta che il mercato aumenti i tassi d’interesse</h3><p>Secondo i dati di glassnode, circa lo 0,144% di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e lo 0,325% di Ether sono stati ritirati dalle riserve di scambio con la notizia del crollo della banca della Silicon Valley. In dollari USA, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> con un valore totale di oltre $1,8 miliardi sono fuoriusciti dallo scambio il mese scorso, soprattutto nell’attuale ostile ambiente regolamentare, il che mostra il grado di fiducia degli investitori.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878446711401678784251_.pic.jpg" alt=""><br>Origine: glassnode</p>
<p>Nel frattempo, secondo Twitter, i dati on-chain hanno mostrato che il sentimento di vendita si è attenuato e il mercato ha cominciato ad aumentare le posizioni, soprattutto tra i detentori a lungo termine, il che potrebbe segnare l’inizio della tendenza al rialzo di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e l’intero mercato delle criptovalute.</p>
<p>In termini di previsione dei tassi di interesse, secondo i dati della CME, la probabilità che la Federal Reserve aumenti i tassi di interesse di 25 punti base è del 76%, mentre la probabilità che non aumenti i tassi di interesse è del 24%.</p>
<h2 id="h2-Recensione20precedente20lultimo20vittima20dellincidente20FTX20appare290374"><a name="Recensione precedente: l’ultimo “vittima” dell’incidente FTX appare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recensione precedente: l’ultimo “vittima” dell’incidente FTX appare</h2><p>L’8 marzo, Silvergate Capital, che non poteva permettersi di rimanere a lungo, ha annunciato che avrebbe gradualmente chiuso e liquidato la sua banca amica delle criptovalute Silvergate, alla luce della regolamentazione e dello sviluppo dell’industria. Finora, Silvergate è diventata l’ultima ‘vittima’ colpita dal crollo di FTX.</p>
<p>Secondo i documenti ufficiali di Silvergate Capital, il piano di liquidazione di Silvergate Bank prevede il “rimborso completo di tutti i depositi dei clienti”, e attualmente si sta valutando il modo migliore per risolvere il problema delle richieste e proteggere il valore residuo dei suoi asset.</p>
<p>Dopo la pubblicazione della notizia, il mercato delle criptovalute è sceso. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è sceso a $19,549 e $1,379 in un momento. Anche il prezzo delle azioni delle imprese collegate alle criptovalute è sceso. Il prezzo delle azioni di Coinbase è sceso del 7,81% il 9 per chiudere a $58,09; il prezzo delle azioni di Signature Bank è sceso del 12,18% a $90,76; e le azioni di Metropolitan Bank sono scese del 7,98% a $50,37.</p>
<p>Solo due giorni dopo, la Silicon Valley Bank è stata chiusa dai regolatori canadesi e presa in consegna dalla FDIC per il motivo di “liquidità insufficiente e insolvenza”. In soli 48 ore, la Silicon Valley Bank è fallita con 211 miliardi di attivi, diventando il più grande fallimento di un’istituzione finanziaria negli Stati Uniti dopo il crollo della Washington Mutual Bank nel 2008. Ieri, la Signature Bank è diventata la terza banca a fallire in una settimana. La Federal Reserve ha annunciato ieri (12 febbraio) che chiuderà la Signature Bank per essere presa in consegna dalla FDIC allo scopo di “proteggere i depositanti”.</p>
<h3 id="h3-La20tempesta20ha20travolto20il20mercato20delle20criptovalute20e20le20stablecoin20e20DeFi20sono20state20messe20in20disordine201025"><a name="La tempesta ha travolto il mercato delle criptovalute, e le stablecoin e DeFi sono state messe in disordine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La tempesta ha travolto il mercato delle criptovalute, e le stablecoin e DeFi sono state messe in disordine</h3><p>Circle, uno dei giganti delle Stablecoin, è al centro di questa tempesta turbolenta. Il crollo di Silicon Valley Bank ha portato direttamente al distacco di oltre il 10% delle Stablecoin USDC emesse da Circle (Circle detiene $3,3 miliardi di riserve presso Silicon Valley Bank). Secondo dati precedenti di PeckShield , il 10 marzo Circle ha bruciato circa $2,7 miliardi di USDC, di cui Coinbase ha riscattato almeno $1,78 miliardi di USDC e il gigante del trading ad alta frequenza Jump Trading ha riscattato circa $96 milioni di USDC.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878451111411678784260_.pic.jpg" alt=""><br>Tendenza del prezzo di USDC negli ultimi sette giorni - fonte: coingecko</p>
<p>La cattiva situazione di USDC ha causato una serie di effetti a catena: circa il 10% del DAI con USDC come collaterale è stato scollegato, e il più basso è stato $0.89; <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> con oltre l’80% di esposizione a Circle è sceso a $0,87; il tilt di Curve 3Pool continua ad aggravarsi e gli utenti sono stati colpiti dal panico per scambiare USDC e DAI con USDT. Secondo quanto riportato dai media, il rapporto <a href="/trade/USDC_USDT" target="_blank" class="blog_inner_link">USDC/USDT</a> è sceso al minimo del 0,93 l’11.</p>
<h2 id="h2-Prezzo20in20calo20fiducia20in20aumento982122"><a name="Prezzo in calo, fiducia in aumento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prezzo in calo, fiducia in aumento</h2><p>È ovvio che lo scollegamento degli Stablecoin è essenzialmente causato dalla vendita di panico, ma alcuni fondi di criptovaluta, tra cui un portafoglio presumibilmente chiamato Vitalik Buterin, sembrano essere fiduciosi nel recupero finale del mercato. Secondo il contenuto del rapporto PeckShield, l’indirizzo contrassegnato come Vitalik ha depositato 500 Ethers in Reflexer, che è stato coniato in 150.000 Reflexer (RAI), e poi i 132.500 RAI sono stati sostituiti con 378.500 USDC, e i 17.500 RAI sono stati sostituiti con 50.000 DAI.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878453411421678784269_.pic.jpg" alt=""><br>Origine: Twitter@PeckShield</p>
<p>Secondo i dati di lookonchain, aziende come Jump Trading, Wintermute Trading, Genesis Trading e BlockTower Capital hanno acquistato USDC prima del fine settimana.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878472711451678784404_.pic.jpg" alt=""></p>
<h2 id="h2-Silicon20Valley20Bank20Opened20on20Monday20Spazzando20Via20il20Triste20Quadro20del20Mercato426932"><a name="“Silicon Valley Bank Opened on Monday”, Spazzando Via il Triste Quadro del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>“Silicon Valley Bank Opened on Monday”, Spazzando Via il Triste Quadro del Mercato</h2><p>Il 12, la Federal Reserve, la Federal Deposit Insurance Corporation (FDIC) e il Tesoro degli Stati Uniti hanno emesso congiuntamente una dichiarazione secondo cui dal 13 marzo i depositanti di Silicon Valley Bank e Signature Bank saranno liberi di utilizzare i loro arretrati, e le perdite derivanti da qualsiasi decisione relativa alle due banche non saranno a carico dei contribuenti.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878469411461678784426_.pic.jpg" alt=""><br>Origine: il sito ufficiale del Dipartimento del Tesoro degli Stati Uniti</p>
<p>La dichiarazione congiunta porta indubbiamente un barlume di luce al mercato delle criptovalute e gli Stablecoin stanno tornando sulla buona strada. L’USDC è aumentato del 4,2% nelle ultime 24 ore e ora offre circa $0,98; DAI è salito del 4,3% nelle ultime 24 ore e ora offre circa $0,99; <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> è salito del 4,1% nelle ultime 24 ore e ora offre circa $0,98. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è aumentato di oltre il 9% in 24 ore e il valore di mercato totale del mercato delle criptovalute è tornato a 1 trilione di dollari.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878465411471678784438_.pic.jpg" alt=""><br>Top-6 Stablecoin performances by market value - source: coingecko</p>
<h2 id="h2-Il20trend20di20mercato2020poco20chiaro20a20causa20delle20frequenti20azioni20di20vari20gruppi322162"><a name="Il trend di mercato è poco chiaro a causa delle frequenti azioni di vari gruppi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il trend di mercato è poco chiaro a causa delle frequenti azioni di vari gruppi</h2><p>Al momento della stesura del 13:</p>
<p>Secondo il rapporto di PANews, il mercato azionario della First Republic Bank of America è sceso di oltre il 60% prima dell’apertura della sessione;</p>
<p>HSBC UK ha acquisito la controllata nel Regno Unito di Silicon Valley Bank a un prezzo di GBP 1;</p>
<p>JPMorgan Chase, PNC, Morgan Stanley e altre grandi banche e aziende hanno negoziato l’acquisto di SVB Group, escludendo gli asset di Silicon Valley Bank.</p>
<p>Mentre stiamo cercando di affrontare il panico del fallimento bancario, è ancora necessario seguire importanti informazioni sui dati. Gli Stati Uniti rilasceranno il valore del CPI di febbraio e il tasso di inflazione di base annuale martedì.</p>
<p>Il tasso di interesse attuale si attesta tra il 4,5% e il 4,75%, il livello più alto da ottobre 2007. Nel frattempo, secondo i dati pubblicati dal Dipartimento del Lavoro degli Stati Uniti il 14 febbraio, l’IPC degli Stati Uniti a gennaio è stato del 6,4%, molto più alto del 2% previsto dalla Federal Reserve. Per quanto riguarda il valore pubblicato domani, il valore previsto dal mercato è del 6% (valore IPC) e del 5,5% (tasso annuo dell’inflazione di base). Dopo la pubblicazione del valore domani, il tasso di interesse della riunione della Federal Reserve del 22 marzo sarà determinato.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Jill Ma</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à consentita la ripubblicazione 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>