NSBDb2luIFdla2VsaWprc2UgVm9vcnNwZWxsaW5nIHwgQlRDIEVUSCBQRVBFIFhSUCBTT0w=

2023-05-01, 00:59

<p><img src="https://gimg2.gateimg.com/blog/1678268270797826871cs2.jpeg" alt=""></p>
<p>【TL; DR】<br>Afgelopen week waren er bijna voor elk activum in de top 100 groene candlesticks te zien, aangezien de markt lijkt te herstellen van enkele recente negatieve prijsacties. Met PEPE aan kop, die bijna 3000% steeg, waren andere stijgingen veel gematigder, met een maximum van ongeveer 9%. Op 1 mei staat de cryptocurrency-markt op $1,21 biljoen, een matige daling ten opzichte van de vorige week, en een daling van -0,07% in de afgelopen 24 uur.</p>
<h2 id="h2-Bitcoin2020BTC894311"><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,54k, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> BTC dook kort onder zijn 7-daagse SMA, waardoor het dieper in de zone van $27,2k terechtkwam. Op de 26e herstelde BTC echter snel en schoot omhoog richting $30k, waardoor het een wekelijks hoogtepunt bereikte van ongeveer $29.970. BTC dook net voor de 27e weer onder zijn 7-daagse SMA en viel naar ongeveer $27,53, voordat het weer omhoog schoot naar de drempel van $29,2k. Op de 28e schoot BTC weer boven de $29,6k en begon het horizontaal te handelen op een gemiddelde van $29.387 voor de rest van de week.</p>
<p>Na een uiterst volatiele week lijkt BTC klaar te zijn om opnieuw de $30k-zone te testen en mogelijk dieper in deze zone door te dringen. Als gevolg hiervan is het mogelijk dat <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> kan volgende week boven de drempel van $30k eindigen. In totaal steeg BTC met 6,8% afgelopen week.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168290263311.png" 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-Ethereum2020ETH709543"><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 het immense succes van de Shanghai-upgrade lijkt de instroom van volume af te nemen, wat leidt tot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> om met volatiliteit te worden gedwarsboomd in de afgelopen week. Aan het begin van de week net onder de rand van zijn 7-daagse SMA op $1,851, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> begon geleidelijk af te dalen naar de lagere $1.810 zone gedurende de 25e en 26e. ETH begon vervolgens wat terrein terug te winnen en schoot boven de $1.960 grens, voordat het snel weer daalde richting $1.800. Hierna begon ETH weer te stijgen tot ongeveer $1.920 en handelde zijwaarts op dit niveau voor de rest van de week.</p>
<p>Na te zijn afgeweken van de recente positieve groeitrajectorie die in april werd uiteengezet, lijkt ETH klaar te zijn voor nog een week van volatiliteit nu de bullish push van de Shanghai Upgrade afneemt. Dit zou kunnen leiden tot verdere daling richting $1.800, mits het momentum resulteert in een negatieve handelstraject. In totaal, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is deze week met 2,41% gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168290265022.png" 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-Pepe20PEPE421732"><a name="Pepe (PEPE)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pepe (PEPE)</h2><p>Na een ongelooflijk succesvolle eerste twee weken, waarin PEPE met meer dan 3.000% steeg, zette deze trend zich voort gedurende de afgelopen week. PEPE opende de week rond de $ 0,00000003038, dook onder zijn 7-daagse SMA en trok zich door deze lagere grens tot de 29e toen het momentum begon te krijgen en omhoog ging. Op de 30e versnelde PEPE naar een wekelijks hoogtepunt van $ 0,00000008124 langs een steile groeitraject. PEPE is sindsdien matig gedaald, maar lijkt sterk te blijven.</p>
<p>Met zo’n significante groei te hebben aangetoond sinds de oprichting op 14 april, is het waarschijnlijk dat PEPE deze groeitrajectorie zal voortzetten en mogelijk de $0,0000001-zone zal gaan testen. Gedurende de afgelopen week is PEPE met bijna 3000% gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168290267033.png" alt=""><br>PEPE Prijsgegevens (Gegevens met dank aan CoinMarketCap)</p>
<h2 id="h2-XRP2020202020XRP20316391"><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>Na een zeer veelbelovend Q1-rapport waarin de indrukwekkende volume en aankoop van werd gedetailleerd <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> gedurende het eerste deel van het jaar, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> is in een staat van volatiliteit terechtgekomen. Aan het begin van de week onder zijn 7-daagse SMA op $0,46, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> snel versneld boven de $0,48, om vervolgens snel onder de 7-daagse SMA te vallen. De 26e verleend <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> genoeg momentum om de $0.48 zone opnieuw te testen voordat het daalde naar een wekelijkse laag van ongeveer $0.44 op een enkele kaars. Gelukkig, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> was in staat om het momentum terug te winnen, wat het snel weer op ongeveer $0,48 bracht tegen de 29e. Als gevolg daarvan, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> heeft de rest van de week horizontaal rond dit niveau gehandeld.</p>
<p>Afgedwaald van de verwoestende bearish trend die heeft getroffen <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> prestaties van de afgelopen weken <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> lijkt weer op te veren en positieve gemeenschapsgevoelens te verzamelen als gevolg van gegevensbevindingen. Het is dus aannemelijk dat in de komende weken, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> zou kunnen stijgen naar $0.4. In de afgelopen week, <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> steeg met 2.6%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168290268444.png" 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-Solana2020SOL749473"><a name="Solana  (SOL)" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (SOL)</h2><p>Over de afgelopen week, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> is afgeweken van zijn recente bearish trend en begint belangrijke tekenen van prijsstijging te vertonen. Aan het begin van de week stond het op $21,3, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> begon naar $22 te duwen, maar zonder succes, waardoor het onder zijn 7-daagse SMA zakte tot de 26e, waar het vervolgens omhoog duwde en begon te testen in de $23 zone. Toch was dit momentum van korte duur omdat SOL naar $20.71 zakte. Gelukkig herwon SOL wat momentum en doorstond het een stapsgewijs handelspatroon dat het boven $23.5 duwde en leidde tot een sluiting van de week op een wekelijks hoogtepunt van $23.91.</p>
<p>Met de recente volatiele neerwaartse trend die lijkt te zijn onderbroken, lijkt het erop dat SOL op weg is naar de doelzone van $24, en dat het, mits het zijn huidige bullish prijsmomentum kan behouden, dit in de komende week zou kunnen realiseren en verder zou kunnen afwijken van zijn recente bearishheid. In de afgelopen week is SOL met 8,7% gestegen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168290270755.png" alt=""><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">sol prijs</a> Gegevens (Gegevens met dank aan CoinMarketCap)</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Matthew W-D</strong>, Gate.io Onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt 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 is toegestaan om het artikel opnieuw te plaatsen, op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div>