NSBNdW50IFdla2VsaWprc2UgVm9vcnNwZWxsaW5nIHwgQlRDIEVUSCBET0dFIEhCQVIgQVBU

2023-04-10, 03:02

<p><img src="https://gimg2.gateimg.com/blog/1678268270797826871cs2.jpeg" alt=""></p>
<h2 id="h2-TL20DR120791"><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 voortzetting van de recente periode van prijsstabilisatie laten zien, waarbij een meerderheid van de activa op de cryptomarkt voornamelijk in waarde is gestagneerd. Er zijn echter zoals altijd enkele afwijkingen geweest op de markt, waarbij sommige activa een scherpe stijging hebben doorgemaakt, terwijl andere in een neerwaartse spiraal zijn gedaald. De likes van ETH en DOGE behoren tot de positieve uitschieters en zijn deze afgelopen week met maximaal 5% gestegen, terwijl de likes van HBAR en APT meer dan 10% hebben laten vallen. Op 9 april bedraagt de marktkapitalisatie van cryptocurrency $1,18 biljoen, een stijging van $200 miljoen ten opzichte van de voorgaande week en een stijging van 0,70% in de afgelopen 24 uur.</p>
<h2 id="h2-Bitcoin2020BTC241432"><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 $27.94k. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> onderging aanzienlijke volatiliteit gedurende de afgelopen week, waardoor het van de lagere grenzen van $27k naar het middelste gebied van $28k werd geslingerd. Op de 3e bleef BTC boven zijn 7-daagse SMA voordat het onder de drempel dook en deze trend herhaalde gedurende de komende dagen, wat leidde tot een wekelijkse laag van $27.430. Na deze laag op de 4e steeg BTC naar een wekelijkse hoogtepunt van $28.633 op de 5e. Na dit veelbelovende hoogtepunt, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> begon weer te rollen en zweeft tussen $27.779 en $28.129 voor de rest van de week, wat wijst op een voortdurende prijsstagnatie.</p>
<p>Na een voortzetting van de recente trend van volatiliteit voorafgaand aan prijsstagnatie van de middelste $27k tot de lage $28k regio’s, die lijkt te fungeren als zijn nieuwe gemiddelde handelszone. Als gevolg hiervan lijkt het erop dat de middelste $27k-zone nu fungeert als de nieuwe prijsvloer, waarbij de drempel van de middelste $28k de nieuwe primaire weerstandszone lijkt te zijn. In totaal steeg BTC deze week met 0,51%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681095637851681095376_.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-Ethereum2020ETH633398"><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>Met ETH’s Shanghai upgrade op handen, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De gemeenschap, evenals de bredere cryptomarkt, heeft te maken gehad met een opmerkelijke interessestijging in het actief. Naarmate meer investeerders enthousiast worden om hun ETH te ontgrendelen, zijn steeds meer investeerders naar voren gekomen om te profiteren van de huidige reeks ETH-stakingsmogelijkheden in de hoop de beloningen te oogsten. Als gevolg hiervan heeft ETH deze week te maken gehad met een scherpe stijging in waardering en volume. ETH begon de week op $1779 en onderging een opwaartse handelstraject dat gedurende de eerste helft van de week aanhield en het naar een wekelijks hoogtepunt van $1,922 duwde. Na dit hoogtepunt begon ETH matig te dalen en leek het op de 7e te stabiliseren, waarbij het gemiddeld voor de rest van de week werd verhandeld op $1,865.</p>
<p>Met voortzetting van de recente trend van opwaartse momentum, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is waarschijnlijk om deze handelstraject voort te zetten, vooral nu de ETH Shanghai upgrade dichterbij komt. Dit kan ETH mogelijk richting de $2.000 drempel duwen en het in staat stellen om naar een zesmaandelijkse hoogte te stijgen. In totaal, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is afgelopen week met 4.04% gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681095660861681095393_.pic.jpg" alt=""><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">eth prijs</a> Gegevens (Gegevens met dank aan CoinMarketCap)</p>
<h2 id="h2-Dogecoin2020DOGE269013"><a name="Dogecoin  (DOGE)" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> (DOGE)</h2><p>Met de recente promotie van Elon Musk, die heeft geleid tot een snelle toename van de interesse van een bredere Twitter-gemeenschap, blijft DOGE handelen op een stijgende lijn. Nadat het de week begon op $0,079, na een opmerkelijke daling na de bullish piek van vorige week, bleef DOGE onder zijn 7-daagse SMA totdat het laat in de avond van de 3e onderworpen werd aan een aanzienlijke stijging van de waardering, waardoor het steeg naar een wekelijks hoogtepunt van $0,1016. Hierna begon DOGE langzaam naar beneden te bewegen, met dit momentum dat zich gedurende het grootste deel van de week voortzette. Op de 7e leek de neerwaartse spiraal van DOGE af te vlakken, waardoor het horizontaal handelde op een gemiddelde van $0,082.</p>
<p>Met deze enorme volatiliteit zal DOGE waarschijnlijk dit handelspatroon voortzetten, mits het sentiment van de gemeenschap schommelt als gevolg van promotie door invloedrijke personen. Dit kan ertoe leiden dat het de $0.1 zone verder test. In de afgelopen week is DOGE met 5.42% gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681095688871681095406_.pic.jpg" alt=""><a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">doge prijs</a> Gegevens (Gegevens met dank aan CoinMarketCap)</p>
<h2 id="h2-Hedera2020HBAR172596"><a name="Hedera  (HBAR)" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/hedera-hbar" rel="nofollow noopener noreferrer" target="_blank">Hedera</a> (HBAR)</h2><p>Gedurende de afgelopen week, <a href="/price/hedera-hbar" rel="nofollow noopener noreferrer" target="_blank">Hedera</a> is begonnen af te wijken van zijn recente opwaartse handelspatroon, waardoor het in een neerwaartse spiraal is terechtgekomen. Aan het begin van de week beloofde het nog $0,072, maar HBAR zonk vervolgens onder zijn 7-daagse SMA en slaagde er niet in om zijn positie te herstellen, waarbij HBAR scherp daalde naar de $0,06-zone. Deze neerwaartse momentum weigerde echter af te nemen, waardoor het de week afsloot op een wekelijks dieptepunt van $0,063.</p>
<p>Nu een bearish handelspatroon is uitgesneden, lijkt het erop dat HBAR gereed is voor een reeks volatiele weken in de nabije toekomst, wat ertoe kan leiden dat het verder daalt tot respectievelijk de zones $0.06 en zelfs $0.05, mits HBAR niet in staat is om enige positieve momentum terug te winnen. Afgelopen week daalde HBAR met 10.01%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681095708881681095422_.pic.jpg" alt=""><a href="/price/hedera-hbar" rel="nofollow noopener noreferrer" target="_blank">hbar prijs</a> Gegevens (Gegevens met dank aan CoinMarketCap)</p>
<h2 id="h2-Aptos2020APT52803"><a name="Aptos  (APT)" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> (APT)</h2><p>Met <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> slechts drie weken geleden in een bullish handelspatroon te zijn geduwd, lijkt het nu weer een bearish handelsrichting te hebben hervat. Na de week te zijn begonnen op $12,12, zakte APT direct onder zijn 7-daagse SMA en daalde het af naar een scherpe rode candlestick die het richting $11 deed kelderen. Hierna streed APT tegen deze prijs tegenslag en drong herhaaldelijk door tot de bovengrenzen van de $11-zone, maar uiteindelijk leek deze weerstand vruchteloos te zijn, aangezien APT uiteindelijk in het bovenste $10-gebied is gezonken op de 9e na een wekelijkse dieptepunt van $10,82 te hebben bereikt.</p>
<p>Met de recente volatiele trend lijkt het erop dat APT op weg is naar een progressieve neerwaartse spiraal die het mogelijk dieper in de $10-zone kan dwingen, met weinig resultaat. In de afgelopen week daalde APT met 8,44%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1681095726891681095435_.pic.jpg" alt=""><a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">geschikte 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 alle rechten voorbehouden aan dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>