RGFnZWxpamtzIG5pZXV3cyB8IFdlcmVsZHdpamRlIG1hcmt0ZW4gcmVhZ2VyZW4gb3AgZGUgc2x1aXRpbmcgdmFuIFNpbHZlcmdhdGUgQmFuaywgd2F0IGxlaWR0IHRvdCAkMzAwIG1pbGpvZW4gYWFuIGxpcXVpZGF0aWVzIGluIGRlIGNyeXB0b3NlY3Rvcg==

2023-03-10, 01:43

<p><img src="https://gimg2.gateimg.com/image/article/16784125950310.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Wereldwijde20markten20reageren20op20de20sluiting20van20Silvergate20Bank20waarbij20verwacht20wordt20dat20Aziatische20markten20zullen20volgen309358"><a name="Crypto Daily Digest: Wereldwijde markten reageren op de sluiting van Silvergate Bank, waarbij verwacht wordt dat Aziatische markten zullen volgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Wereldwijde markten reageren op de sluiting van Silvergate Bank, waarbij verwacht wordt dat Aziatische markten zullen volgen</h2><p>Goedemorgen, handelaren! Het is een wilde rit geweest, maar laat die verliezen je niet ontmoedigen. We hebben een hele nieuwe dag om te veroveren, dus laten we ons vastmaken en het weekend in knallen! 🚀</p>
<p>De Amerikaanse aandelenmarkt leed donderdag een daling, waarbij de S&amp;P 500 daalde naar het laagste punt sinds 19 januari. Dit werd veroorzaakt door zorgen over mogelijke problemen in de banksector, wat leidde tot een daling van financiële bedrijven in de index met meer dan 4%, en de KBW Bank Index, die regionale kredietverstrekkers omvat, daalde met 7,7%. Deze daling was te wijten aan de ineenstorting van Silvergate Capital Corp. en de neergang van SVB Financial Group na een aandelenuitgifte om verliezen op te vangen. De daling zorgde ervoor dat cryptocurrencies gleden, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ervaart de grootste daling sinds november. Beleggers wachten nu op de Fed-vergadering en het maandelijkse banenrapport van de Amerikaanse economie.</p>
<p>De daling van bankaandelen had invloed op de Aziatische aandelenmarkten, die ook naar verwachting zullen lijden. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> daalde met 8% en de yen boekte de grootste winst in een maand als gevolg van de meltdown van Silvergate. De Amerikaanse arbeidsmarkt vertoonde echter tekenen van verbetering, met een stijging van het aantal werkloosheidsaanvragen tot 211.000, hoger dan de verwachtingen van 195.000. Het maandelijkse banenrapport van vrijdag zal naar verwachting bevestigen dat de Amerikaanse economie blijft groeien met een sterk tempo.</p>
<p>De sluiting van Silvergate Bank heeft een aanzienlijke impact gehad op de cryptocurrency markt. Silvergate Capital heeft aangekondigd dat Silvergate Bank zijn activa zal liquideren en de operaties zal stopzetten. Dit heeft bezorgdheid veroorzaakt over de toekomst van crypto banking en kan het moeilijker maken voor nieuwe investeerders om de markt te betreden. Andere grote cryptocurrencies, zoals Ether (ETH), hebben ook aanzienlijke prijsdalingen meegemaakt.</p>
<p>De plotselinge daling van cryptocurrencies heeft investeerders verrast, wat heeft geleid tot een sterke stijging van langdurige liquidaties en heeft in de afgelopen 24 uur geleid tot $300 miljoen aan liquidaties. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> handelaren leden het meest verlies van $ 110 miljoen, en ether-liquidaties overschreden $ 70 miljoen.</p>
<h2 id="h2-Onderwerp20van20de20dag20Is20de20recente202020Bitcoin2020selloff20een20teken20van20problemen20of20een20koopkans876934"><a name="Onderwerp van de dag: Is de recente   Bitcoin  selloff een teken van problemen of een koopkans?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de dag: Is de recente <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> selloff een teken van problemen of een koopkans?</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De grootste cryptocurrency ter wereld, , heeft een verkoopgolf meegemaakt waardoor de waarde met maar liefst 8,8% daalde tot ongeveer $20.000, het laagste niveau sinds medio januari. Deze daling werd veroorzaakt door negatief sentiment op de digitale activamarkt na twee belangrijke gebeurtenissen: de ineenstorting van Silvergate Capital Corp. en juridische stappen van de staat New York tegen het crypto-platform gate. <a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a> De verkoopgolf werd verder verergerd door een plotselinge daling van de inheemse token van de gate. <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> uitwisseling nadat de procureur-generaal van New York beschuldigde <a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a> zonder vergunning in de staat opereren.</p>
<p>De recente gebeurtenissen hebben een negatieve achtergrond gecreëerd voor de cryptocurrency-industrie en hernieuwde onrust heeft sommige investeerders op scherp gezet. De situatie is verslechterd door verliezen in de Amerikaanse aandelensector, die zijn toegenomen te midden van een verkoopgolf in de banksector. De implicaties van deze uitverkoop voor de langetermijnvooruitzichten van de crypto-industrie zijn gemengd.</p>
<p>Enerzijds kan de negatieve stemming rond cryptocurrencies leiden tot een verhoogd regelgevend toezicht, wat mogelijk de groei van de sector kan beperken. Bovendien kan de recente verkoopgolf het vertrouwen van investeerders ondermijnen, wat kan leiden tot verminderde investeringen in de crypto sector.</p>
<p>Aan de andere kant hebben sommige marktwaarnemers opgemerkt dat recent negatief nieuws de cryptoprijzen niet zozeer heeft beïnvloed als in het verleden. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is sinds het begin van het jaar ongeveer 26% gestegen, wat een indrukwekkende stijging is, en deze rally kan wijzen op een groeiende acceptatie van digitale activa door institutionele beleggers. Bovendien kan de recente verkoopdruk een koopkans bieden voor langetermijnbeleggers die geloven in de toekomst van cryptocurrencies.</p>
<p>Samenvattend kan worden gesteld dat de daling van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> De waarde van ’s en de ongunstige marktsentiment in de digitale activabranche zouden zowel gunstige als ongunstige effecten kunnen hebben op de langetermijnperspectieven van de cryptosector. Terwijl strengere regelgeving en afnemend investeerdersvertrouwen de uitbreiding van de branche kunnen beperken, zou de recente opleving van de prijzen en toenemend institutioneel enthousiasme voor cryptocurrencies kunnen wijzen op een optimistischer toekomst voor de markt voor digitale activa.</p>
<h2 id="h2-Bitcoin2020BTC2020045201562020Neutrale20Outlook204293"><a name="Bitcoin  (BTC) $20045 (-1.56%) - Neutrale Outlook" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC) $20045 (-1.56%) - Neutrale Outlook</h2><p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde dagelijkse steunzone: 19858 - 19379</em></strong></li><li><strong><em>Dichtstbijzijnde dagelijkse weerstandszone: 20469 - 21128</em></strong></li><li><strong><em>Key Level: 19858 (Maandelijkse afsluiting van dec. 2017)</em></strong></li></ul>
<p><img src="https://gimg2.gateimg.com/image/article/1678412542Untitled03101.png" alt=""><img src="https://gimg2.gateimg.com/image/article/1678412563Untitled03102.png" alt=""></p>
<p>BTC kende donderdag een aanzienlijke daling, met een verlies tot 7,62% voordat het sloot op -6,17%. De verkoop ging door toen de Aziatische markten opengingen, wat resulteerde in een extra verlies van 2,5%. Verwacht wordt dat deze trend zich zal voortzetten totdat BTC het wekelijkse 61,8% Fibonacci-retracementniveau van 19379 bereikt, wat enige verlichting kan bieden. Het maandelijkse niveau van 19858 heeft voorlopig als bufferzone gediend. De uitverkoop werd veroorzaakt door angst die voortkwam uit de laatste Silvergate-ontwikkeling aan de fundamentele kant, evenals technische factoren, zoals het potentieel voor massale liquidaties als gevolg van een groot aantal stop-loss-orders op het niveau van $ 21,5K. Op het wekelijkse tijdsbestek heeft BTC snel de gouden zone van Fibonacci bereikt, en idealiter zouden handelaren en investeerders enige consolidatie binnen deze zone zien om zichzelf te herpositioneren. Het worstcasescenario is echter dat BTC onder het 78,6% Fibonacci-niveau van 18134 zou sluiten, wat de bullish vooruitzichten van de vorige rally in januari ongeldig zou maken.</p>
<p><strong>Dagelijkse weerstandszones</strong></p>
<ol>
<li>20469 - 21128</li><li>21344 - 21717</li><li>21874 - 23233</li></ol>
<p><strong>Dagelijkse ondersteuningszones</strong></p>
<ol>
<li>19858 - 19379</li><li>19253 - 18628</li><li>18476 - 17507</li></ol>
<div class="blog-details-info"><br><div>Auteur:<strong> Peter L.</strong>, gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>