RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1oYW5kZWxhcmVuIGFuZ3N0aWcgb21kYXQgV2FsbCBTdHJlZXQga2VsZGVydCBlbiBCaXRjb2luIHJlYWdlZXJ0IG9wIGRlIEZPTUMtcmVudGUgdmVyaG9naW5n

2023-03-23, 01:37

<p><img src="https://gimg2.gateimg.com/image/article/16795350590323.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Wall20Streethandelaren20bezorgd20nu20Powell20weerstand20biedt20tegen20renteverlagingen202020Bitcoin2020Daalt20onder20de2027k180069"><a name="Crypto Daily Digest: Wall Street-handelaren bezorgd nu Powell weerstand biedt tegen renteverlagingen,   Bitcoin  Daalt onder de $27k" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Wall Street-handelaren bezorgd nu Powell weerstand biedt tegen renteverlagingen, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Daalt onder de $27k</h2><p>Goedemorgen, handelaren! Laten we deze donderdag meedogenloos grijpen en er het beste van maken! 🚀</p>
<p>Op woensdag zorgde de aankondiging van minister van Financiën Janet Yellen dat de overheid geen brede depositoverzekering zou bieden om het banksysteem te stabiliseren voor een daling van financiële aandelen, en de verklaring van voorzitter van de Federal Reserve Jerome Powell dat hoop op renteverlagingen dit jaar de grond in boorde, zorgde voor angst onder Wall Street-handelaren. De S&amp;P 500 veegde een rally uit die bijna 1% naderde en eindigde de dag met een daling van 1,7%, terwijl de Treasury-rendementen van twee jaar scherp daalden met 23 basispunten tot 3,94%, en alle 22 aandelen in de KBW Bank Index daalden bijna 5%.</p>
<p>Ondanks toenemende verwachtingen van renteverlagingen, verklaarde Powell dat functionarissen geen renteverlagingen verwachten dit jaar en de rente meer zullen verhogen dan verwacht indien nodig. Het Federal Open Market Committee stemde unaniem voor een verhoging van het streefcijfer voor de federal funds rate met een kwart procentpunt naar een bereik van 4,75% tot 5%.</p>
<p>Als gevolg van de weerstand van de Fed om dit jaar de rente te verlagen en de neergang op Wall Street, hebben Aziatische aandelen op donderdag te maken met tegenwind, en zijn de rendementen op staatsobligaties in de regio lager geopend, hoewel de zwakte van de Amerikaanse dollar de activa in Azië kan ondersteunen.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> de waarde daalde tot onder de $27.000 toen het Amerikaanse Federal Open Market Committee (FOMC) aankondigde dat de rente nog eens met een kwart procentpunt zou worden verhoogd, onder verwijzing naar zorgen over inflatie. Ondanks de negatieve effecten van de renteverhoging op risicovolle activa, zijn analisten van mening dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> kan nog steeds profiteren omdat het wordt beschouwd als een toonaangevend risico-op-activum en een financiële reddingsboot in het g van een bankencrisis. De recente bankencrisis kan echter ook volatiliteit met zich meebrengen in de toekomst, terwijl de markt marcheert naar een recessie of een kredietgebeurtenis.</p>
<p>In ander nieuws heeft de Amerikaanse Securities and Exchange Commission (SEC) een rechtszaak aangespannen tegen Justin Sun, de <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> Stichting, de <a href="/price/bittorrent-btt" rel="nofollow noopener noreferrer" target="_blank">BitTorrent</a> Stichting, en <a href="/price/bittorrent-btt" rel="nofollow noopener noreferrer" target="_blank">BitTorrent</a> voor naar verluidt het verkopen en airdroppen van niet-geregistreerde effecten, marktmanipulatie en fraude. De SEC beschuldigde Sun ervan het handelsvolume van op te blazen <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> De eigen token van , TRX, werd op grote schaal witgewassen door middel van een uitgebreid witwas handelsschema, waarbij zijn eigen werknemers meer dan 600.000 witwas transacties van TRX uitvoerden tussen twee door hem gecontroleerde handelsaccounts voor crypto-activa.</p>
<h2 id="h2-Onderwerp20van20de20dag20De20twee20cryptofactoren20die20het20rentebesluit20van20het20FOMC20overtroefden72660"><a name="Onderwerp van de dag: De twee cryptofactoren die het rentebesluit van het FOMC overtroefden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderwerp van de dag: De twee cryptofactoren die het rentebesluit van het FOMC overtroefden</h2><p>De beslissing van de FOMC om de rente te verhogen is belangrijk voor de financiële markten, maar in de wereld van crypto is de impact van de stablecoin-aanbod en de winstgevendheid van korte termijn significant. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Beleggers zijn waarschijnlijk net zo belangrijk voor beleggers.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679535676Untitled0323 00.png" alt=""></p>
<p>Een van de belangrijkste indicatoren is de hoge winstgevendheid van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> 97,5% van de circulerende voorraad wordt nu in bezit gehouden door kortetermijnbeleggers, dankzij de huidige prijs die hoger is dan hun gemiddelde kostprijs, volgens een rapport van Coindesk.</p>
<p>Deze situatie kan echter snel veranderen als beleggers de opmerkingen van Federal Reserve-voorzitter Jerome Powell als bearish beschouwen, wat leidt tot extra verkoopdruk op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Aan de andere kant, als de markt zijn opmerkingen als bullish interpreteert, kunnen korte termijn houders hun posities behouden en overgaan naar de categorie van lange termijn houders, wat hun geloof in de toekomstige prijs van signaleert. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>De totale voorraad van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> in handen van langetermijnbeleggers is ook het afgelopen jaar met 5% gestegen, wat wijst op een sterk investeerdersvertrouwen in het digitale bezit. Langetermijnbeleggers zijn doorgaans minder geneigd om te verkopen of uit te geven <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, het bieden van een ondersteunende basis van relatief illiquide aanbod dat de prijs van BTC kan ondersteunen.</p>
<p>Naast het monitoren van het gedrag op korte en lange termijn, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> houders, investeerders moeten ook letten op de voorraad aan stablecoins. Stablecoins zijn belangrijk omdat ze dienen als een mechanisme waarmee een groot deel van digitale activa zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en ether worden gekocht.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679535708Untitled0323 0.png" alt=""></p>
<p>De netto verandering in de totale aanbodpositie van de vier belangrijkste stabiele munten is sinds april 2022 gestaag afgenomen, volgens Glassnode-gegevens. Een toename van het aanbod van stabiele munten zou wijzen op een toename van het kapitaal dat beschikbaar is voor inzet, wat aantrekkelijk zou zijn voor investeerders met een optimistische kijk op BTC.</p>
<p>Over het algemeen moeten beleggers deze crypto-indicatoren nauwlettend in de gaten houden om de toekomstige richting van te bepalen. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> prijs. Hoewel de beslissing van de FOMC om de rentetarieven te verhogen invloed kan hebben op de bredere financiële markten, is het gedrag van korte termijn en lange termijn <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> houders, evenals de voorraad van stablecoins, die waarschijnlijk een groter effect zullen hebben op het digitale activum.</p>
<h2 id="h2-Bitcoin20BTC20272909200162020Neutrale20Vooruitzichten803363"><a name="Bitcoin (BTC) $27290.9 (+0.16%) - Neutrale Vooruitzichten" 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) $27290.9 (+0.16%) - Neutrale Vooruitzichten</h2><p><strong>Overzicht:</strong></p>
<ul>
<li><strong><em>Dichtstbijzijnde dagelijkse ondersteuningszone: 26909 - 26593</em></strong></li><li><strong><em>Dichtstbijzijnde dagelijkse weerstandszône: 27459 - 27760</em></strong></li><li><strong><em>Sleutelniveau: 26283 (Wekelijkse afsluiting van 21-28 december 2020)</em></strong></li></ul>
<p><img src="https://gimg2.gateimg.com/image/article/1679535173Untitled0323 1.png" alt=""></p>
<p><img src="https://gimg2.gateimg.com/image/article/1679535192Untitled0323 2.png" alt=""></p>
<p>Op de wekelijkse grafiek ondervond BTC zijn eerste afwijzing van een weerstandszone tussen het wekelijkse Fibonacci-extensieniveau van 28540 en het maandelijkse niveau van 29300. Met de RSI die overgekochte omstandigheden signaleert, is het waarschijnlijk dat BTC dit niveau opnieuw zal bezoeken voordat een significante retracement nodig is om voldoende momentum te winnen om een eerdere aanbodzone [29917 - 32400] te overtreffen.</p>
<p>Op het dagelijkse tijdsbestek toonde de rode kaars van woensdag aan dat stieren op dit moment nog steeds overwegen boven beren, aangezien het zich terugtrok van een dieptepunt dat bijna de kaars van 18 maart omhulde. Op de handelsdag van donderdag bevindt BTC zich op een kritiek punt.</p>
<p>Als het terugvalt naar de dagelijkse vraagzone [26909 - 26583], zullen beren waarschijnlijk de momentum benutten om het naar beneden te duwen naar de dagelijkse gouden zone [25941 - 25512], en vervolgens naar de wekelijkse gouden zone [25100 - 24325].</p>
<p>Als de stieren echter kunnen voorkomen dat BTC de vraagzone bereikt en erin slagen om de dagelijkse aanbodzone opnieuw te testen [27969 - 28385], zijn er twee mogelijkheden:</p>
<ol>
<li><p>BTC zal doorbreken en het maandelijkse niveau van 29300 bereiken;</p>
</li><li><p>BTC zal een langere periode van consolidatie doormaken tussen de dagelijkse aanbod- en vraagzones. Het moet worden opgemerkt dat de dagelijkse RSI aangeeft dat de koopmomentum afneemt, dus handelaren moeten het vermijden om de prijzen na te jagen en in plaats daarvan geduldig wachten op het beste instapmoment.</p>
</li></ol>
<p><strong>Dagelijkse weerstandszones</strong></p>
<ol>
<li>27459 - 27760</li><li>27969 - 28385</li><li>28540 - 29300</li></ol>
<p><strong>Dagelijkse ondersteuningszones</strong></p>
<ol>
<li>26909 - 26593</li><li>25941 - 25512</li><li>25100 - 24325</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 mening van de onderzoeker en vormt geen investeringssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herposten van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen wordt juridische stappen ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>