RGUgdm9vcnNwZWxsaW5nIHZhbiBTYXRvc2hpIE5ha2Ftb3RvIGt3YW0gdWl0LCBpbnZlc3RlZXJkZXJzIHpvY2h0ZW4gZWVuIGdldm9lbCB2YW4gdmVpbGlnaGVpZCBpbiBCVEMgZW4gRVRI

<p><img src="https://gimg2.gateimg.com/image/article/1678784190网页.jpeg" alt=""></p>
<h2 id="h2-Een20snelle20update535196"><a name="Een snelle update" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een snelle update</h2><h3 id="h3-De20voorspelling20van20Satoshi20Nakamoto20is20uitgekomen20en202020Bitcoin2020Steeg20tot2024000866166"><a name="De voorspelling van Satoshi Nakamoto is uitgekomen, en   Bitcoin  Steeg tot $24.000" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De voorspelling van Satoshi Nakamoto is uitgekomen, en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Steeg tot $24.000</h3><p>Na de ineenstorting van drie banken op rij werd de First Republic Bank geschorst na de crash van 67% in de pre-markt, en de West Bank of Alains werd geschorst. PacWest Bancorp activeerde de circuit breaker aan het begin van de markt.</p>
<p>Satoshi Nakamoto schreef in de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Genesis block op 3 januari 2009, dat ‘de minister van Financiën op het punt staat de bank opnieuw te redden’, wat vandaag 14 jaar later opnieuw waarheid werd - het Amerikaanse ministerie van Financiën, de Federal Reserve en de Federal Deposit Insurance Corporation hebben een verklaring uitgegeven om de markt te redden. De dag na de uitgave van de gezamenlijke verklaring verklaarde de Amerikaanse president Biden dat de snelle actie van de overheid ervoor zorgde dat Amerikanen geloven dat het Amerikaanse banksysteem veilig is. Ondertussen verklaarde Biden dat hij van het Congres en toezichthouders zou eisen dat ze de bankregels zouden versterken en een uitgebreide boekhouding zouden uitvoeren van wat er met de banken is gebeurd. ‘We zullen hier niet stoppen. We zullen alle noodzakelijke maatregelen nemen. We moeten voorkomen dat dit opnieuw gebeurt.’</p>
<p>Aan de andere kant, onder invloed van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> futures-evenementcontracttransactie gelanceerd door de Chicago Mercantile Exchange en met de steun van regelgevers voor de stortingen van Silicon Valley Bank en Signature Bank, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is in de afgelopen 24 uur bijna 10% gestegen en keert terug naar de drempel van $20.000, met de hoogste prijs van $24.488, en wordt nu genoteerd op $24.380. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> positie van ongeveer $180 miljoen werd in de afgelopen 24 uur geliquideerd, en shortposities waren ongeveer $180 miljoen. USDC en DAI hebben geleidelijk hun vastgezette prijzen hersteld en nu zijn ze hersteld tot ongeveer $0,99. Echter, Curve 3pool bevindt zich nog steeds in een gekantelde toestand, waarbij DAI en USDC meer dan 45% vertegenwoordigen en USDT slechts ongeveer 6,6%.</p>
<h3 id="h3-Beleggers20zoeken20een20gevoel20van20veiligheid20in20gate202020Bitcoin2020en202020Ethereum2020en20de20markt20wordt20verwacht20de20rentetarieven20te20verhogen75745"><a name="Beleggers zoeken een gevoel van veiligheid in gate   Bitcoin  en   Ethereum , en de markt wordt verwacht de rentetarieven te verhogen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beleggers zoeken een gevoel van veiligheid in gate <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, en de markt wordt verwacht de rentetarieven te verhogen</h3><p>Volgens de gegevens van glassnode, ongeveer 0.144% van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en 0,325% van Ether werd teruggetrokken uit de exchange reserves met het nieuws van de ineenstorting van Silicon Valley bank. In Amerikaanse dollars, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> met een totale waarde van meer dan $1,8 miljard stroomde vorige maand uit de beurs, vooral in de huidige vijandige regelgevingsomgeving, wat het vertrouwen van investeerders aantoont.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878446711401678784251_.pic.jpg" alt=""><br>Bron: glassnode</p>
<p>Ondertussen liet Twitter weten dat de on-chain data aangaf dat het verkoopsentiment was afgenomen en de markt zich begon te versterken - vooral onder langetermijnbezitters, wat het begin van de opwaartse trend kan markeren. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en de hele crypto markt.</p>
<p>Wat betreft de rentevoorspelling, volgens CME-gegevens is de waarschijnlijkheid dat de Federal Reserve de rente met 25 basispunten verhoogt 76%, en de waarschijnlijkheid dat de rente niet wordt verhoogd 24%.</p>
<h2 id="h2-Vorige20recensie20het20nieuwste20slachtoffer20van20het20FTXincident20verschijnt687159"><a name="Vorige recensie: het nieuwste ‘slachtoffer’ van het FTX-incident verschijnt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vorige recensie: het nieuwste ‘slachtoffer’ van het FTX-incident verschijnt</h2><p>Op 8 maart kondigde Silvergate Capital, dat het zich lange tijd niet kon veroorloven om te dalen, aan dat het zijn cryptocurrency-vriendelijke bank Silvergate geleidelijk zou sluiten en liquideren met het oog op industriële regulering en ontwikkeling. Tot nu toe is Silvergate het laatste “slachtoffer” geworden dat is getroffen door de FTX-crash.</p>
<p>Volgens de officiële documenten van Silvergate Capital omvat het liquidatieplan van Silvergate Bank ‘volledige terugbetaling van alle klantendeposito’s’, en wordt momenteel de beste manier geëvalueerd om het claimprobleem op te lossen en de restwaarde van zijn activa te beschermen.</p>
<p>Na de bekendmaking daalde de cryptocurrency-markt. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> viel op een gegeven moment terug naar $19.549 en $1.379. Ook de aandelenkoers van cryptocurrency-gerelateerde bedrijven daalde. De aandelenkoers van Coinbase daalde op de 9e met 7,81% en sloot op $58,09; de aandelenkoers van Signature Bank daalde met 12,18% tot $90,76; en de aandelen van Metropolitan Bank daalden met 7,98% tot $50,37.</p>
<p>Slechts twee dagen later werd Silicon Valley Bank gesloten door Canadese toezichthouders en overgenomen door de FDIC vanwege ‘onvoldoende liquiditeit en insolventie’. In slechts 48 uur faalde Silicon Valley Bank met $211 miljard aan activa en werd daarmee de grootste faillissement van een financiële instelling in de Verenigde Staten sinds de ineenstorting van Washington Mutual Bank in 2008. Gisteren werd Signature Bank de derde bank die in een week faalde. De Federal Reserve kondigde gisteren (12 februari) aan dat het Signature Bank zou sluiten en zou worden overgenomen door de FDIC met als doel ‘depositohouders te beschermen’.</p>
<h3 id="h3-De20storm20veegde20over20de20cryptomarkt20en20de20stablecoin20en20DeFi20waren20in20de20war391679"><a name="De storm veegde over de cryptomarkt en de stablecoin en DeFi waren in de war" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De storm veegde over de cryptomarkt en de stablecoin en DeFi waren in de war</h3><p>Circle, een van de reuzen van Stablecoin, staat in het middelpunt van deze turbulente storm. De ineenstorting van Silicon Valley Bank leidde rechtstreeks tot het loskoppelen van meer dan 10% van de Stablecoin USDC die is uitgegeven door Circle (Circle heeft $3,3 miljard aan reserves bij Silicon Valley Bank). Volgens eerdere gegevens van PeckShield  heeft Circle op 10 maart ongeveer $2,7 miljard aan USDC’s verbrand, waarvan Coinbase ten minste $1,78 miljard aan USDC’s heeft ingewisseld en de high-frequency trading gigant Jump Trading ongeveer $96 miljoen aan USDC’s heeft ingewisseld.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878451111411678784260_.pic.jpg" alt=""><br>De prijstrend van USDC in de afgelopen zeven dagen - bron: coingecko</p>
<p>De slechte situatie van USDC veroorzaakte een reeks dominante effecten: ongeveer 10% van de DAI met USDC als onderpand werd ontkoppeld en het laagste was $0.89; <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> met meer dan 80% blootstelling aan Circle daalde tot $0.87; Curve 3Pool helling blijft verslechteren en gebruikers zijn getroffen door paniek om USDC en DAI te ruilen voor USDT. Volgens media rapporten daalde de <a href="/trade/USDC_USDT" target="_blank" class="blog_inner_link">USDC/USDT</a> op zijn laagste punt op de 11e tot 0.93.</p>
<h2 id="h2-Prijs20omlaag20vertrouwen20omhoog313444"><a name="Prijs omlaag, vertrouwen omhoog" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prijs omlaag, vertrouwen omhoog</h2><p>Het is duidelijk dat het loskoppelen van de Stablecoins in essentie wordt veroorzaakt door paniekverkopen, maar sommige cryptocurrencyfondsen, waaronder een portemonnee die naar verluidt Vitalik Buterin heet, lijken vertrouwen te hebben in het uiteindelijke marktherstel. Volgens de inhoud van het PeckShield-rapport werd het adres dat gemarkeerd was als Vitalik gestort met 500 ethers in Reflexer, die werden geslagen tot 150.000 Reflexer (RAI), en vervolgens werd de 132.500 RAI vervangen door 378.500 USDC, en de 17.500 RAI werd vervangen door 50.000 DAI.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878453411421678784269_.pic.jpg" alt=""><br>Bron: Twitter@PeckShield</p>
<p>Volgens gegevens van lookonchain hebben bedrijven zoals Jump Trading, Wintermute Trading, Genesis Trading en BlockTower Capital USDC gekocht vóór het weekend.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878472711451678784404_.pic.jpg" alt=""></p>
<h2 id="h2-Silicon20Valley20Bank20geopend20op20maandag20veegt20de20somberheid20van20de20markt20weg768692"><a name="“Silicon Valley Bank geopend op maandag”, veegt de somberheid van de markt weg" class="reference-link"></a><span class="header-link octicon octicon-link"></span>“Silicon Valley Bank geopend op maandag”, veegt de somberheid van de markt weg</h2><p>Op de 12e hebben de Federal Reserve, de Federal Deposit Insurance Corporation (FDIC) en het Amerikaanse Ministerie van Financiën gezamenlijk een verklaring afgegeven dat vanaf 13 maart depositohouders van Silicon Valley Bank en Signature Bank vrij zijn om hun achterstanden te gebruiken, en de verliezen als gevolg van beslissingen met betrekking tot de twee banken zullen niet door belastingbetalers worden gedragen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878469411461678784426_.pic.jpg" alt=""><br>Bron: de officiële website van het Amerikaanse Ministerie van Financiën</p>
<p>De gezamenlijke verklaring brengt ongetwijfeld een sprankje hoop voor de cryptomarkt en de Stablecoins zijn weer op de goede weg. De USDC is met 4,2% gestegen in 24 uur en wordt nu aangeboden voor ongeveer $0,98; DAI steeg met 4,3% in 24 uur en wordt nu aangeboden voor ongeveer $0,99; <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> rose 4.1% in 24 uur en biedt nu ongeveer $0.98 aan. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> steeg in 24 uur met meer dan 9%, en de totale marktwaarde van de cryptomarkt keerde terug naar $1 biljoen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167878465411471678784438_.pic.jpg" alt=""><br>Top-6 Stablecoin prestaties op basis van marktwaarde - bron: coingecko</p>
<h2 id="h2-De20markttrend20is20onduidelijk20vanwege20de20frequente20acties20van20verschillende20groepen988892"><a name="De markttrend is onduidelijk vanwege de frequente acties van verschillende groepen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De markttrend is onduidelijk vanwege de frequente acties van verschillende groepen</h2><p>Tegen de tijd dat dit op de 13e wordt geschreven:</p>
<p>Volgens het rapport van PANews daalde de aandelenmarkt van de First Republic Bank of America meer dan 60% vóór de opening van de sessie;</p>
<p>HSBC UK heeft de Britse dochteronderneming van Silicon Valley Bank overgenomen voor een prijs van GBP 1;</p>
<p>JPMorgan Chase, PNC, Morgan Stanley en andere grote banken en bedrijven hebben onderhandeld over de aankoop van SVB Group, met uitzondering van de activa van Silicon Valley Bank.</p>
<p>Terwijl we worstelen met de paniek van bankfalen, moet belangrijke gegevensinformatie nog steeds worden opgevolgd. De Verenigde Staten zullen dinsdag de waarde van de CPI voor februari en de jaarlijkse kerninflatie vrijgeven.</p>
<p>Het huidige rentepercentage ligt tussen 4,5% en 4,75%, het hoogste niveau sinds oktober 2007. Ondertussen was volgens de gegevens die op 14 februari door het Amerikaanse Ministerie van Arbeid zijn vrijgegeven, de Amerikaanse CPI in januari 6,4%, veel hoger dan de verwachte 2% van de Federal Reserve. Wat betreft de morgen te publiceren waarde, is de marktvoorspelling 6% (CPI-waarde) en 5,5% (jaarlijks kerninflatiepercentage). Na publicatie van de waarde morgen zal het rentepercentage van de Federal Reserve-vergadering op 22 maart worden bepaald.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Jill Ma</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<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 auteursrechtschending.<br></div><p></p><br></div></div></div>