VG9wIDUgUHJpanN2b29yc3BlbGxpbmcgV2VrZWxpamtzZSBWb29yc3BlbGxpbmc=

2023-03-20, 03:19

<p><img src="https://gimg2.gateimg.com/blog/1678268270797826871cs2.jpeg" alt=""></p>
<h2 id="h2-TL20DR913400"><a name="【TL; DR】" class="reference-link"></a><span class="header-link octicon octicon-link"></span>【TL; DR】</h2><p>De afgelopen week heeft een aanzienlijke stijging in volume en waardering voor de gehele cryptocurrency markt laten zien. Na weken van volatiliteit die de markt hebben getroffen, lijkt het eindelijk losgekomen te zijn van deze bearish handelstrajectorie en beweegt het zich richting een periode van herstel. Op 20 maart bedraagt de marktkapitalisatie van de cryptocurrency $1.18T, een stijging van $150M ten opzichte van de vorige week en een stijging van 1.8% in de afgelopen 24 uur.</p>
<h2 id="h2-Bitcoin2020BTC99129"><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 $21.98k, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bleef gedurende de hele week sterk boven zijn 7-daagse SMA en onderging een scherpe stijging in waarde op de 13e die zich uitstrekte tot de 14e, waardoor het dieper in de respectievelijke zones van $24k en $25k werd geduwd. Van de 15e tot de 17e bleef BTC horizontaal tussen $24k en $25k, voordat de 17e een progressieve stijging markeerde die zich gedurende het laatste deel van de week uitstrekte en leidde tot een sluiting van de week op een hoogtepunt van $28.21k, wat neerkomt op een hoogtepunt van meerdere maanden.</p>
<p>Afwijking van de recente volatiele handelstraject, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> lijkt een positieve correctieperiode door te maken waarbij de ware waarde geleidelijk meer wordt gerealiseerd in termen van volume en waardering. Het is waarschijnlijk dat deze opwaartse trend zich kan uitstrekken tot in de komende week, mogelijk ruimte makend voor een meer bullish handelspatroon in de komende weken. In totaal steeg BTC deze week met 28,18%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167928224151679281836_.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-Ethereum2020ETH687706"><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>Aan het begin van de week bewoog ETH zich onder zijn 7-daagse SMA op $1.589, waarna het op de avond van de 13e kort onder dit gebied dook, voordat het op de 14e in waarde versnelde en verder in de $1.700 zone werd geduwd. Op de 15e daalde ETH langzaam naar het middelste-tot-lagere $1.600 gebied, waar het tot de vroege uren van de 18e bleef. Op de 18e begon ETH wat momentum te krijgen en zichzelf te lanceren in het lagere $1.800 gebied. Dit leidde ertoe dat het de week afsloot op ongeveer $1.810, na een korte periode in de buurt van $1.840.</p>
<p>Na zijn recente trend van het onderschatten van zijn waarde in het begin van de week voordat het begon te versnellen, lijkt het erop dat ETH klaar is om uit te breken in de komende week en mogelijk dieper in de $1.800 zone te duwen, wat er mogelijk toe kan leiden dat het de nieuw vastgestelde weerstand van $1.840 verder test. In totaal, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is de afgelopen week met 13,98% gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167928226461679281849_.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-XRP2020202020XRP20550635"><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>Bij het begin van de week op $0.37, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> onderging aanzienlijke pieken in waarde gedurende de week. Op de 13e, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> aanzienlijk gedaald onder zijn 7-daagse SMA en verhuisde naar het lagere $0,36 gebied, voordat het scherp steeg op de 14e naar $0,39. Deze trend herhaalde zich op de 15e, wat er vervolgens toe leidde dat het stevig in het $0,26 gebied bleef tot het middaguur op de 17e. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> begon toen wat momentum te krijgen en duwde zichzelf door de weerstand van $0,37 en duwde zichzelf richting de drempel van $0,40, waardoor het de week afsloot op $0,39.</p>
<p>Met deze enorme volatiliteit, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> zal waarschijnlijk de komende maanden dit blijven ervaren, wat kan worden gekoppeld aan het aanstaande vonnis in de SEC vs Ripple-rechtszaak, wat heeft geleid tot een gemengd sentiment in het hele <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> gemeenschap en bredere cryptogemeenschappen. In de komende week. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> kan een vergelijkbaar niveau van volatiliteit vertonen. Over de afgelopen week, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> met 5.66% gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167928228871679281862_.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-Cardano2020ADA638409"><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> is onderhevig geweest aan immense volatiliteit, wat leidde tot scherpe stijgingen en vergelijkbare dalingen. Na de week te zijn begonnen op $0,33, begon ADA snel te bewegen in de $0,34 zone en duwde zichzelf richting $0,37, met een wekelijks hoogtepunt van $0,3682. Echter, dit <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> was van korte duur, want <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> daalde op de 15e en dook in het midden tot bovenste $0,32 gebied. Op de 17e begon ADA echter weer op te krabbelen en drong door tot het lagere $0,35 gebied en bleef stabiel tussen $0,34 en $0,35 gedurende het laatste deel van de week.</p>
<p>Na te zijn losgekomen van de recente bearish trend, lijkt ADA deze week weer terrein te winnen, waarbij de prijs eindelijk richting de weerstandszone van $0,37 duwt. In de komende week, als ADA deze momentum kan behouden, is het waarschijnlijk dat het deze regio verder kan testen. Gedurende de afgelopen week, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> steeg met 5,95%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167928230681679281876_.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-BNB2020202020BNB20144567"><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 een progressieve stijging ondergaan. Aan het begin van de week stond het op $289, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Op de 13e daalde het onder de grens van $300 en streed het om deze prijs vast te houden, waarbij het tussen $300 en $318 van eigenaar wisselde tot de 16e. Op de 16e, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> wierp zichzelf in het $330-gebied en begon gedurende de rest van de week te klimmen, waardoor het op de 18e boven de $340 duwde en de week afsloot op een veelbelovende $339.</p>
<p>Nu de recente volatiele streak lijkt te zijn verstoord, is het waarschijnlijk dat het nu een nieuwe prijsbodem rond $ 300 vestigt en $ 350 op het oog heeft als een nieuwe weerstandszone. Op voorwaarde dat het zijn huidige momentum kan behouden, is het aannemelijk dat het deze regio de komende week zou kunnen testen en mogelijk verder zou kunnen graven in de richting van $ 360. In de afgelopen week, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> is met 17,51% gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167928232691679281887_.pic.jpg" alt=""><a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB prijs</a> Gegevens (Gegevens 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 mening van de onderzoeker en vormt geen beleggingsadvies.<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>