NSBDb2luIFdla2VsaWprc2UgVm9vcnNwZWxsaW5nIHwgQlRDIFNOWCBYUlAgRE9UIExUQw==

2023-03-27, 03:04

<p><img src="https://gimg2.gateimg.com/blog/1678268270797826871cs2.jpeg" alt=""></p>
<h2 id="h2-TL20DR843704"><a name="【TL; DR】" class="reference-link"></a><span class="header-link octicon octicon-link"></span>【TL; DR】</h2><p>De afgelopen week heeft grotendeels geleid tot stagnatie op de cryptocurrency-markt, waarbij het merendeel van de activa minimaal in beide richtingen bewoog. Er zijn echter enkele uitzonderingen geweest binnen de top 100, met activa zoals <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> en LTC begint in prijs te versnellen, terwijl anderen zoals SNX en DOT aanzienlijk waarde hebben verloren. Vanaf 26 maart bedraagt de marktkapitalisatie van cryptocurrency $1,16T, een daling van $200 miljoen ten opzichte van de voorgaande week, maar een stijging van 1,53% in de afgelopen 24 uur.</p>
<h2 id="h2-Bitcoin2020BTC410700"><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 met $27.97k, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> was onderhevig aan enorme volatiliteit in de afgelopen week, die het van de bovenste grenzen van $26k naar het middengebied van $28k heeft geslingerd. Op de 19e dook BTC direct onder zijn 7-daagse SMA, voordat het wat waarde herstelde en zich weer boven deze drempel duwde. Deze trend duurde voort tot de 21e, toen BTC zichzelf naar een wekelijks hoogtepunt van $28.716 duwde, waarna het scherp daalde naar een wekelijks dieptepunt van $26.760 in vier uur tijd. Hierna bleef BTC ruim onder zijn 7-daagse SMA tot de 23e, waar het vervolgens steeg maar al snel weer werd ondergedompeld door de 7-daagse SMA-drempel. Als gevolg hiervan sloot BTC de week af rond de $27,7k.</p>
<p>Na de hervatting van de kwaadaardige volatiele prijstraject lijkt BTC te maken te hebben met tegenspoed in het gebied van $27,8k, waar dit lijkt te fungeren als een nieuwe weerstandszone. Als gevolg hiervan lijkt het erop dat het lagere gebied van $27k de nieuwe gemiddelde handelsprijs is geworden. In totaal daalde BTC deze week met 0,62%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679886134271679886067_.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-Synthetix20SNX362278"><a name="Synthetix (SNX)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Synthetix (SNX)</h2><p>Na de liquiditeitsinjectie van vorige week als gevolg van DWF Labs die $15M aan Synthetix verwierf, begon SNX aan een neerwaartse handelstraject toen het de week inging. SNX begon de week op $2.89, duwde kortstondig boven $3 en bereikte een wekelijkse hoogtepunt van $3.1853 voordat het progressief begon te dalen door het bovenste gebied van $2.9. Op de 20e dook SNX eindelijk onder zijn 7-daags SMA maar probeerde opnieuw stand te houden door weer omhoog te duwen, voordat het uiteindelijk definitief onder de drempel viel. In de daaropvolgende dagen daalde SNX verder naar het midden tot lagere $2-gebied en sloot uiteindelijk de week nabij zijn wekelijkse dieptepunt van $2.3809.</p>
<p>Afwijkend van de recente stijging in waarde lijkt SNX een geleidelijke neerwaartse trend te vormen die naar verwachting in de komende week zal worden gerealiseerd, waardoor het mogelijk richting zijn maandelijkse dieptepunt van $2.0372 wordt geduwd. In totaal, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> daalde afgelopen week met 15.59%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679886153281679886079_.pic.jpg" alt=""><a href="/price/synthetix-network-snx" rel="nofollow noopener noreferrer" target="_blank">snx prijs</a> Gegevens (Gegevens met dank aan CoinMarketCap)</p>
<h2 id="h2-XRP2020202020XRP203445"><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.39, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> doorgemaakte een positieve week, waarbij zijn voorliefde voor volatiliteit in zijn voordeel speelde toen het ruim boven zijn 7-daags SMA voer en het naar de doelzone van $0,50 duwde. Gedurende de 19e en de helft van de 20e, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> werd onder zijn 7-daagse SMA geduwd, voordat het scherp steeg naar een wekelijks hoogtepunt van $0,4906. Vanaf dit hoogtepunt, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> zakte naar tussen $0.425 en $0.44 en bleef relatief consistent op dit niveau in het midden van de week, ondanks pieken in waarde. Als gevolg hiervan, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> sloot de week af op $0.445.</p>
<p>Met deze immense volatiliteit, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> zal waarschijnlijk blijven ervaren in de komende maanden, wat kan worden gekoppeld aan de aankomende uitspraak in de zaak SEC vs Ripple, 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 cryptocurrency-gemeenschappen. Echter, met deze volatiliteit die begint te spelen in <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> In het voordeel van het voordeel is het mogelijk dat dit momentum zich de komende week uitbreidt en verder naar $ 0,45 duwt. In de afgelopen week, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> gestegen met 13,91%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679886173291679886091_.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-Polkadot2020DOT884505"><a name="Polkadot  (DOT)" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> (DOT)</h2><p>Gedurende de afgelopen week, <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> heeft een verwoestende daling ondergaan als gevolg van de volatiele trend van de afgelopen maand. Met een start van de week van $6,48, viel DOT scherp onder zijn 7-daagse SMA en slaagde er de rest van de week niet in om dat niveau te benaderen. DOT begon snel af te dalen door het $6-gebied gedurende de 20e en 21e, voordat het potentieel tekenen van herstel begon te tonen, waar het zich richtte op $6,4, maar dit werd snel verstoord door verdere prijsdalingen gedurende de rest van de week. DOT bereikte een wekelijks dieptepunt van $5,863 en sloot de week af rond $6.</p>
<p>Na de recente bearish trend te hebben voortgezet, lijkt DOT zich verder in een bearish spiraal te verdiepen en mogelijk opnieuw naar zijn maandelijkse dieptepunt te duwen. In de komende week is het aannemelijk dat DOT dit handelstraject zal voortzetten en dieper in de $5 zone zal duwen. In de afgelopen week daalde DOT met 7,46%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679886229301679886102_.pic.jpg" alt=""><a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">dot prijs</a> Gegevens (gegevens met dank aan CoinMarketCap)</p>
<h2 id="h2-Litecoin2020LTC207969"><a name="Litecoin  (LTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> (LTC)</h2><p>Gedurende de afgelopen week heeft LTC een progressieve stijging doorgemaakt. Aan het begin van de week op $84.7, zakte LTC door zijn 7-daagse SMA en bereikte een dieptepunt van $78.1 op de 20e. Echter, op de 22e begon LTC enige momentum te winnen en was het getuige van een scherpe stijging in waarde die het door het $80-gebied stuwde en het in staat stelde om in waarde te blijven stijgen in een relatief consistent tempo tot het een wekelijkse hoogte van $95.33 bereikte op de 23e. LTC begon vervolgens horizontaal te handelen tussen $90 en $94, wat ertoe leidde dat het de week afsloot op $92.85.</p>
<p>Met de recente volatiele neerwaartse trend lijkt te zijn verstoord, lijkt het erop dat LTC richting de $95 zone gaat en dat, mits het zijn huidige bullish prijsmomentum kan behouden, het in de komende week gerealiseerd kan worden. In de afgelopen week is LTC met 7,55% gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679886246311679886113_.pic.jpg" alt=""><a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">LTC-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 weerspiegelt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>