SW5zdG9ydGVuZGUgYmFua2VuIGR1d2VuIGNyeXB0byByaWNodGluZyBlZW4gc3RpZXJlbm1hcmt0

2023-03-31, 08:53

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR205566"><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 en Silvergate Bank zijn in maart om verschillende redenen ingestort.</p>
<p>De belangrijkste redenen voor het falen van deze banken waren financieel wanbeheer en de scherpe dalingen in de waarde van hun aandelen.</p>
<p>De Zwitserse regering greep in om te voorkomen dat Credit Suisse, een financiële kredietverstrekker, zou crashen.</p>
<p>De prijzen van BTC, ETH en andere cryptocurrencies stegen scherp een paar dagen na de ineenstorting van Silicon Valley Bank, Signature Bank en Silvergate Bank.</p>
<h2 id="h2-Introductie722027"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Drie grote banken in de Verenigde Staten, Silicon Valley Bank, Signature Bank en Silvergate Bank, zijn binnen een week, van 7 tot 14 maart 2023, achtereenvolgens omglen. In het bijzonder, 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>, respectievelijk 10 en 12 maart.</p>
<p>Deze banken werden beïnvloed door vergelijkbare omstandigheden, zoals de verhogingen van de rentetarieven van de Fed, slecht management en blootstelling aan cryptocurrencies. Deskundigen zijn echter van mening dat de impact van de blootstelling aan cryptocurrencies op de ineenstorting van deze banken minimaal was. Laten we kort kijken naar de gebeurtenissen die hebben geleid tot de ineenstorting van elk van deze banken.</p>
<h2 id="h2-Handtekening20bank826696"><a name="Handtekening bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Handtekening bank</h2><p>Silvergate leed in 2022 een verlies van meer dan $1 miljard als gevolg van de bestaande macro-economische omstandigheden en <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">de implosie van FTX exchange</a>. Als gevolg hiervan heeft de bank haar personeelsbestand met 40% verminderd. En om het nog erger te maken, is het Amerikaanse ministerie van Justitie (DO) begonnen met een onderzoek naar haar financiële transacties met FTX. Bovendien heeft Silvergate Bank haar 10K-indiening bij de SEC gemist, wat een slecht signaal was voor de cryptomarkt.</p>
<p>Als reactie hierop hebben verschillende bedrijven, waaronder Coinbase, Paxos Trust Company, Circle en Ledger <a href="https://www.gate.io/blog_detail/2326/silvergate-suspends-crypto-payments-network-and-more" target="_blank">beëindigde hun samenwerking met Silvergate</a>. Dat werd gevolgd door een scherpe daling van de aandelenkoers, waarvan de waarde met 97% daalde, van $219.75 naar $5.41.</p>
<h2 id="h2-Silicon20Bank864748"><a name="Silicon Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Silicon Bank</h2><p>De toezichthouders hebben op 10 maart aangekondigd dat Silicon Valley Bank gaat sluiten. De belangrijkste oorzaak van deze ramp was de investering in langlopende effecten, waaronder hypotheekobligaties en Amerikaanse staatsobligaties. Als gevolg van de voortdurende renteverhogingen door de Fed daalde de waarde van deze instrumenten aanzienlijk. Als gevolg hiervan daalde de prijs van de aandelen een week voor de sluiting met 67%.</p>
<p>Om zijn balans te versterken, stelde Silicon Valley Bank voor om gewone aandelen en converteerbare preferente aandelen uit te geven. Toen de klanten op de hoogte waren van zijn financiële problemen, verloren ze het vertrouwen en trokken ze in grote aantallen hun geld terug, wat leidde tot een bankrun.</p>
<h2 id="h2-Signature20Bank573448"><a name="Signature Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Signature Bank</h2><p>Signature Bank heeft verschillende financiële uitdagingen doorgemaakt die begonnen toen Celsius, een van zijn belangrijkste klanten, werd gesloten. De implosie van FTX maakte de situatie erger dan voorheen. Aan de andere kant diende Statistica Capital, een algorithmische handelsfirma, een rechtszaak in tegen Signature Bank waarin het beschuldigd werd van het toestaan van ‘het vermengen van FTX-klantenfondsen binnen zijn eigen blockchain-gebaseerde betalingsnetwerk, Signet’.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680252050581680252005_.pic.jpg" alt=""><br>Signature bank - Livemint</p>
<p>Helaas, na de sluiting van Silvergate Bank, dook het aandeel van Signature Bank naar beneden, waardoor het gedwongen werd te stoppen met handelen. Kort daarna namen de toezichthouders het in beslag, wat leidde tot de sluiting.</p>
<h2 id="h2-Credit20Suisse136007"><a name="Credit Suisse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Credit Suisse</h2><p>Een andere ontwikkeling die angst heeft veroorzaakt in de financiële sector heeft betrekking op de problemen waarmee Credit Suisse, een Zwitserse kredietverlener, enkele dagen na de sluiting van bovengenoemde Amerikaanse banken te maken kreeg. Specifiek daalde op 15 maart 2023 de waarde van de aandelen van Credit Suisse met 20% na de bekendmaking van de Saudi National Bank dat het geen verdere financiële ondersteuning zou bieden.</p>
<p>Echter, de Zwitserse regering greep in om de ineenstorting van Credit Suisse te voorkomen. Sterker nog, het dwong de USB om Credit Suisse over te nemen voor $2.7 miljard. De centrale bank van Zwitserland legde uit dat ze ingrepen om de financiële stabiliteit in het land te verbeteren en de Zwitserse economie te beschermen.</p>
<h2 id="h2-Hoe20reageerde20de20cryptomarkt556564"><a name="Hoe reageerde de cryptomarkt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe reageerde de cryptomarkt?</h2><p>De prijzen van belangrijke cryptocurrencies stegen na de instorting van de drie banken in de Verenigde Staten. Bijvoorbeeld, de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> bereikte <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">het hoogste punt in negen maanden</a>. Met name tussen 10 en 17 maart steeg de waarde van BTC met 36,06%. Over het algemeen is het sinds het begin van het jaar met 70% gestegen, waarbij de prijs enkele dagen na de ineenstorting van de banken steeg tot $28.085.</p>
<p>In feite, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> En andere cryptocurrencies zijn veerkrachtig gebleven ondanks de financiële onrust in de traditionele financiële sector.</p>
<p>In dezelfde periode, van 10 tot 17 maart, steeg ETH met 26,67% en bereikte een hoogtepunt van 1.750 dollar. Afgezien van ETH en BTC waren er andere cryptocurrencies die het in dezelfde periode goed deden. Zo steeg de prijs van CFX, het utility-token van Conflux Network, met 105,99%. Evenzo is de prijs van STX, het utility-token van <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a>- de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>‘s smart contract laag is met 100.13% gestegen en gesloten op US$1.09.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680252605591680252015_.pic.jpg" alt=""><br>Belangrijke cryptocurrencies piekten - Freepik</p>
<p>Er zijn verschillende verklaringen voor de opleving van de belangrijkste cryptocurrency na de sluiting van de drie banken. Een belangrijke reden is dat de markt heeft ingezien dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en andere cryptocurrencies dienen nog steeds hun oorspronkelijke doel, namelijk een alternatief zijn voor traditionele financiën. Als zodanig bieden ze bescherming tegen onverwachte dalingen in de waarde van fiatvaluta’s.</p>
<p>Crypto-investeerders verwachten ook dat de Fed waarschijnlijk een versoepeld standpunt zal innemen over de rentetarieven om het oude financiële systeem te beschermen. Dit komt omdat hoge rentetarieven ook een negatieve invloed hebben gehad op de cryptomarkt.</p>
<p>Er is ook een prospect dat de inflatie waarschijnlijk zal dalen. In dit perspectief zei Simon Peters, een crypto-analist bij eToro, ‘Naar alle waarschijnlijkheid hebben we nu de piek van inflatie in de VS gezien en hoewel sommige componenten hardnekkig blijven, beginnen we nu over het algemeen een daling van het hoofdgetal te zien.’</p>
<h2 id="h2-Is20Crypto20het20nieuwe20veilige20handelsproduct653365"><a name="Is Crypto het nieuwe veilige handelsproduct?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Crypto het nieuwe veilige handelsproduct?</h2><p>De huidige economische situatie en de recente sluiting van banken, evenals de dalende prijzen van aandelen laten zien dat cryptocurrencies een veilige grondstof blijven.</p>
<p>Sommige crypto-analisten hebben al opgemerkt dat de recente turbulentie in de traditionele financiële en aangeeft dat de huidige bear markt ten einde loopt. Zo zei een respectabele bearish strateeg, Michael Wilson van Morgan Stanley, dat de tussenkomst van de Federal Reserve en de Federal Deposit Insurance Corp in de banksector het begin van het einde van de bear markt betekent, omdat de afnemende beschikbaarheid van krediet de groei uit de economie knijpt.</p>
<p>Echter, Wilson gelooft nog steeds dat de cryptomarkt mogelijk nog wat prijsvolatiliteit kan ervaren. Hij voegde eraan toe: ‘Het laatste deel van de berenmarkt kan meedogenloos en zeer gecorreleerd zijn. De prijzen dalen scherp door een piek in het eigen vermogen risicopremie die erg moeilijk te voorkomen of te verdedigen is in iemands portefeuille.’</p>
<h2 id="h2-Conclusie685771"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Hoewel de ineenstorting van Silicon Valley Bank, Signature Bank en Silvergate Bank veel angst bracht in de traditionele financiële sector en de aandelenmarkt, had dit geen negatieve invloed op de cryptosector. In plaats daarvan wonnen de meeste grote cryptocurrencies na hun ineenstorting. Volgens sommige analisten duiden deze turbulenties in de legacy financiële sector erop dat de berenmarkt ten einde loopt.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>