VG9wIDUgUHJpanN2b29yc3BlbGxpbmcgV2VrZWxpamtzZSBQcm9nbm9zZQ==

2023-03-06, 03:11

<p><img src="https://gimg2.gateimg.com/blog/1678268270797826871cs2.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen820682"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>In de afgelopen week is de cryptocurrency-markt opnieuw in volume gedaald na het opwaartse momentum van de vorige week. Een meerderheid van de top 20 assets daalde met maximaal 10% in de afgelopen week, wat resulteerde in een marktkapitalisatiedaling van 600 miljoen, waarbij de totale marktkapitalisatie $1,02T bedroeg. Deze progressieve daling in volume over de afgelopen twee weken lijkt indicatief te zijn voor een marktbrede prijscorrectie, waardoor veel van de top 100 in een neerwaartse spiraal terechtkomen omdat assets beginnen te naderen naar een nieuwe stabiele prijsregio.</p>
<h2 id="h2-Bitcoin2020BTC882772"><a name="Bitcoin  (BTC)" 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)</h2><p>De week begint op $23.55k, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bleef sterk tot de 28e, voordat het scherp daalde boven zijn 7-daagse SMA en handelde in de lagere regionen van de $ 23k zone. Op 1 maart echter, herstelde BTC zich kort, bereikte een wekelijks hoogtepunt van $ 23.847,51, voordat het opnieuw begon af te nemen in de vroege uren van de 2e. Vanaf de 2e onwards, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> onderging een enorme waardedaling, zakte op de 3e alleen al van de middelste $23k-zone naar de middelste $22k-zone, voordat het voor het grootste deel van deze week horizontaal in de laatste regio handelde. Als gevolg hiervan bereikte BTC een wekelijks dieptepunt van $22.238. en steeg boven de drempel van $25k en bereikte een wekelijks hoogtepunt van</p>
<p>Na de neerwaartse trend die de voorgaande week werd ingezet, is het waarschijnlijk op basis van de gegevens die in de tweede helft van deze week zijn vastgesteld dat BTC horizontaal zal blijven handelen tussen $22,6k en $22,2k. In totaal daalde BTC met 4,63% deze week.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167807319810371678071715_.pic.jpg" alt=""><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> Gegevens (gegevens met dank aan CoinMarketCap)</p>
<h2 id="h2-Ethereum20ETH299776"><a name="Ethereum (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>(ETH)</h2><p>Na aan het begin van de week onder zijn 7-daagse SMA op $1.640 te hebben gehangen, begon ETH boven deze drempel te herstellen op de 28e, waarna het steeg naar de regio van $1.660. ETH begon vervolgens progressief te dalen, op de rand van $1.610 te balanceren, voordat het opnieuw boven zijn 7-daagse SMA piekte en hier consequent boven bleef gedurende de 1e en de 2e, wat leidde tot een wekelijks hoogtepunt van $1.670. Op de ochtend van de 3e werd ETH echter geconfronteerd met een scherpe daling, die het richting het middengebied van $1.500 deed kelderen, wat vervolgens leidde tot een wekelijks dieptepunt van $1.551. ETH heeft sindsdien horizontaal rond deze zone gehandeld.</p>
<p>Afwijking van zijn recente trend van waardeverlies in het begin van de week voordat het in waarde versnelde, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> lijkt te zijn gebleven in een correctiehandelstraject, wat het verder richting de $1.500-zone duwt. In totaal, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> daalde afgelopen week met 4,53%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167807323910381678071737_.pic.jpg" alt=""><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> Gegevens (Gegevens Met Dank aan CoinMarketCap)</p>
<h2 id="h2-XRP2020202020XRP20932408"><a name="XRP  (   XRP )" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ( <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>)</h2><p>Aan het begin van de week op $0,377, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> werd gedurende de hele week onderworpen aan enorme volatiliteit, waardoor het scherp heen en weer bewoog en op de 2e een wekelijkse hoogtepunt van $0.3841 bereikte, nadat het boven en onder zijn 7-daagse SMA was geslagen. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> begon toen te dalen vanaf dit hoogtepunt, wat leidde tot een scherpe daling op de 3e, in totaal in een wekelijks dieptepunt van $ 0,3602. Vanaf dit punt <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> begon geleidelijk aan weer op te krabbelen, wat leidde tot een slot van de week op $0.367.</p>
<p>Met deze immense volatiliteit, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> zal waarschijnlijk blijven ervaren dit in de komende maanden, die kan worden geassocieerd met de aanstaande SEC vs Ripple rechtszaak uitspraak, die heeft geleid tot gemengde sentiment in het hele <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> gemeenschap en de bredere cryptocurrency-wereld. In de komende week, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> kan na een initiële periode van horizontale handelsactiviteit een vergelijkbaar niveau van volatiliteit betreden en demonstreren. In de afgelopen week is er een soortgelijk patroon geweest. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> daalde met 2,70%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167807328710391678071754_.pic.jpg" alt=""><a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">xrp prijs</a> Gegevens (Gegevens met dank aan CoinMarketCap)</p>
<h2 id="h2-Cardano2020ADA480509"><a name="Cardano  (ADA)" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> (ADA)</h2><p>Gedurende de afgelopen week, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> heeft onderhevig geweest aan immense volatiliteit, nadat het de week begon op $0.37, begon ADA snel onder zijn 7-daagse SMA te dalen en af te nemen tot respectievelijk de $0.36 en $0.35 regio’s. Op de 3e daalde ADA verder, waardoor het een wekelijks dieptepunt van $0.3294 bereikte, maar het begon weer wat terrein te winnen en richting $0.35 te duwen. Als gevolg daarvan sloot ADA de week af op $0.34.</p>
<p>Met een plotselinge bearish momentum lijkt ADA zich te hebben gericht op een neerwaartse prijskoers die naar verwachting gedurende de komende week zal voortduren, gezien de recent vastgestelde wekelijkse weerstand in de buurt van $0,35. Gedurende de afgelopen week, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> daalde met 8,39%.</p>
<p><img src="https://gimg2.gateimg.com/image/167807298514460773910401678071771_.pic.jpg" alt=""><a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">ada prijs</a> Gegevens (gegevens met dank aan CoinMarketCap)</p>
<h2 id="h2-BNB2020202020BNB20396569"><a name="BNB  (   BNB )" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> ( <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>)</h2><p>Gedurende de afgelopen week, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> is opnieuw onderhevig geweest aan aanzienlijke volatiliteit. Na deze week te zijn ingegaan op $308, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> daalde scherp en piekte gedurende de 28e-2e, voordat het scherp daalde op de 3e en begon te duwen naar een wekelijks dieptepunt, dat werd gerealiseerd op de 5e, in totaal $ 287,07. Sindsdien <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> steeg kortstondig en begon horizontaal te handelen tussen $290 en $293, wat leidde tot een sluiting van de week op een laag niveau van $289.</p>
<p>De opmerkelijke volatiliteit die is waargenomen door <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> deze week en de voorgaande week zullen waarschijnlijk doorgaan in de komende week, wat erop wijst dat het waarschijnlijk is <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> kan mogelijk verder gedwongen worden onder de $290, met weinig tekenen van het doorbreken van de onlangs vastgestelde wekelijkse weerstandszone van $293. Gedurende de afgelopen week, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> is met 6,43% gedaald.</p>
<p><img src="https://gimg2.gateimg.com/image/167807298550604108410411678071781_.pic.jpg" alt=""><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB prijs</a> Gegevens (Data met dank aan CoinMarketCap)</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Matthew Webster-Dowsing</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat 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>