RXRoZXJldW0gKEVUSCkgcHJpanMgd29yc3RlbHQ6IGZhY3RvcmVuIGFjaHRlciB6aWpuIG1hcmt0b25kZXJwcmVzdGF0aWU=

2024-09-25, 09:51

<p><img src="https://gimg2.gateimg.com/image/article/17272575081690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR178285"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Gedurende de afgelopen twee maanden heeft Ether te maken gehad met sterke bearish druk.</p>
<p><a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">solana](/price/</a><a  rel="nofollow noopener noreferrer"  href=")-sol”" target="“_blank”" class="“blog" _binnen_="" [link<="" a=""> Solana, SUI en </a><a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">aptos</a>-apt” target=“_blank” class=“blog_inner_link”&gt;Aptos zijn voorbeelden van layer-1 blockchains die concurreren met <a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">ethereum</a>-eth” target=”_blank” class=”blog_inner_link”&gt;Ethereum.</p>
<p>De terugkerende netto-uitstroom van ETH ETF’s heeft bijgedragen aan het afnemen van het vertrouwen van Ether-investeerders.</p>
<h2 id="h2-Introductie78114"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Hoewel cryptocurrencies het goed deden tijdens de eerste helft van het jaar, ontbreekt zo’n momentum dit keer. Zelfs de toonaangevende digitale valuta’s zoals Ether en <a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a>-btc” target=“_blank” class=“blog_inner_link”&gt;bitcoin presteren ondermaats. Ondanks enkele marktbrede factoren zoals de economische omgeving die hun prestaties beïnvloeden, hebben sommige digitale valuta interne uitdagingen. Zo beperken verschillende factoren de marktprestaties van ETH.</p>
<h2 id="h2-Ethereum20Marktprestaties20Oorzaken20van20recente20neerwaartse20trend20in20ETHprijs644065"><a name="Ethereum Marktprestaties: Oorzaken van recente neerwaartse trend in ETH-prijs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum Marktprestaties: Oorzaken van recente neerwaartse trend in ETH-prijs</h2><p>Volgens VanEck presteert ETH ondermaats <a href="https://www.gate.io/learn/articles/ethereums-struggles-a-reflection-of-web3s-development-challenges/3852" target="_blank">is zichtbaar op de markt</a>. Op het gebied van marktprestaties staat het op de 13e plaats onder de 22 toonaangevende layer-1 blockchains. De blockchain had een jaarrendement van 62% in vergelijking met de 138% van bitcoin. Gedurende dezelfde periode had <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> een rendement van 624%. Op dezelfde manier presteerde <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> de afgelopen 90 dagen ook slecht. Bijvoorbeeld, ETH (-30%), dat op de 12e plaats staat, werd overtroffen door TRX (+37%), <a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">bnb</a>-bnb” target=“_blank” class=“blog_inner_link”&gt;BNB (-5%) en TON (-3%).</p>
<p>Zonder twijfel heeft ETH een moeilijke periode doorgemaakt, aangezien de prijs voortdurend is gedaald. Zo daalde de munt bijvoorbeeld met 5,2% gedurende de periode van 24 uur die liep van 3 tot 4 september. Als gevolg van de hoge bearish druk waarmee het te maken heeft gehad, verloor het in de afgelopen 30 dagen 8,1%. De onderstaande prijsgrafiek toont hoe slecht ETH heeft gepresteerd in de afgelopen 30 dagen.<img src="https://gimg2.gateimg.com/image/article/17272575941.jpg" alt=""><br>ETH Maandelijkse Prijsgrafiek - CoinGecko</p>
<p>Zoals waargenomen op <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">de grafiek</a>, de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETH prijs</a> is sinds 25 augustus aan het dalen. Zelfs daarvoor bevond het zich al in een bearish periode. Hoewel op 25 augustus ETH werd verhandeld voor $2.776, staat het nu geprijsd op $2.420. Er zijn verschillende factoren geweest <a href="https://www.gate.io/price-prediction/ethereum-eth" target="_blank">bijdragend aan zijn bearish vooruitzichten</a>.</p>
<p>Onzekerheden over de renteverlagingen in de Verenigde Staten: De afgelopen maanden is er onzekerheid geweest over de uiteindelijke beslissing van de Federal Reserve over renteverlagingen. Verwacht wordt dat de Fed de rente in september zal aanpassen. Nu de veranderingen in de non-farm payrolls lager zijn dan verwacht, is het niet duidelijk hoe de Federal Reserve de rente zal aanpassen. Een expansief monetair beleid zou het beste zijn voor de cryptosector. Vanwege de angst voor een recessie kunnen investeerders echter hun geld verschuiven van de cryptosector naar veiliger investeringen zoals aandelen en obligaties. Daarom heeft de onzekerheid over de wijzigingen in het monetair beleid van de Fed geleid tot een neerwaartse druk. <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a>.</p>
<p>Afnemende netwerkkosten: De Ethereum opbrengsten zijn afgenomen vanwege de <a href="https://www.gate.io/learn/articles/value-analysis-of-ethereum-layer-2/2004" target="_blank">prestaties van layer-2 blockchains</a> Deze netwerken halen omzet uit het Ethereum-ecosysteem. Als gevolg van dergelijke ontwikkelingen zijn de Ethereum-netwerkkosten sinds de lancering van de Dencun-upgrade in maart met 99% gedaald. Deze upgrade, die de netwerkkosten voor laag-2-blockchains verlaagde, leidde tot een toename van het aantal Ethereum-laag-2-netwerken.</p>
<p>Het hoge aantal layer-2 oplossingen heeft bijgedragen aan de daling van de Ethereum-netwerkvergoedingen. Dit komt doordat er minder activiteit is op het basislaagnetwerk van Ethereum. Als voorbeeld vielen op 31 augustus de Ethereum-netwerkvergoedingen tot het laagste niveau in vier jaar. De reden voor deze situatie is het zwakke compensatiemodel van Ethereum dat ten koste gaat van het basisnetwerk ten gunste van layer-2 oplossingen. Een analist, Cygaar, is een van de personen die kritiek heeft geuit op het Ethereum-compensatiemodel.<br><img src="https://gimg2.gateimg.com/image/article/17272577032.jpg" alt=""><br>Kritiek op het Ethereum compensatiemodel: x.com/Cgaar</p>
<p>Ook VanEck heeft hierop gereageerd. <a href="https://www.vaneck.com/us/en/blogs/digital-assets/matthew-sigel-vaneck-crypto-monthly-recap-for-august-2024/" rel="nofollow noopener noreferrer" target="_blank">Op zijn blog plaatste het</a>, “Als we het verlies van Ethereum van zijn pole position onder blockchains kwantificeren, is het aandeel van alle blockchain-vergoedingen dat Ethereum ontvangt sinds 2022 gedaald van 86% naar 33%, terwijl het aandeel van het DEX-volume is gedaald van 42% naar 29%.”</p>
<p>Het voegde eraan toe: “Ethereum’s oplossing om de schaalbaarheid te verbeteren door transacties naar L2-blockchains te duwen, is tot nu toe niet gelukt om waarde aan ETH toe te voegen. Niet alleen snijden de L2-blockchains steeds meer in op de economie van Ethereum via meerdere wegen, maar ze bieden ook een suboptimale gebruikerservaring terwijl ze nog steeds veel minder transactieverwerkingssnelheid bieden dan Ethereum concurrenten.”</p>
<h2 id="h2-Uitstekende20prestaties20door20Layer120Blockchains683633"><a name="Uitstekende prestaties door Layer-1 Blockchains" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uitstekende prestaties door Layer-1 Blockchains</h2><p>De andere reden die heeft bijgedragen aan de onderprestatie van ETH is de uitstekende prestaties van andere laag 1-netwerken. Er is een grote neiging voor gebruikers van digitale activa om de Ether-cryptomarkt te dumpen voor laag-1-netwerken met een hogere doorvoer zoals Solana. Feit is dat laag-1 blockchains zoals Solana, <a href="/price/aptos-apt" target="_blank" class="blog_inner_link">Aptos</a> en Sui duizenden transacties per seconde kunnen verwerken. Naast de algemene netwerkgebruikers geven ontwikkelaars de voorkeur aan blockchains met een hogere doorvoer dan Ethereum. Deze afname in de vraag naar Ethereum-producten heeft geleid tot de daling van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a>.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/10-layer-2-crypto-projects-to-watch-in-2024/3637" target="_blank">10 Layer 2 Crypto-projecten om in de gaten te houden in 2024</a></p>
<p>VanEck merkte hierover op: ‘Deze chains maken gebruik van vooruitgangen in gedistribueerde systeemtechnologie om een grotere transactieverwerking en snellere transactieverwerking mogelijk te maken. Terwijl Ethereum ongeveer 15 TPS per seconde kan verwerken met transactiebevestigingstijden van enkele minuten, kunnen chains zoals Solana, Sui en Aptos duizenden transacties per seconde verwerken met bevestigingslatentie van enkele seconden.’</p>
<p>Het ging verder: ‘Als gevolg hiervan is de gebruikerservaring voor handelaren van Ethereum onhandig en is het aantal mensen dat Ethereum kan gebruiken beperkt. Vanwege de knelpunten van Ethereum zetten ontwikkelaars die nieuwe toepassingen bouwen hun projecten steeds vaker in op ketens die een betere gebruikerservaring en meer gebruikers kunnen accommoderen.’</p>
<h2 id="h2-Onderprestatie20van20Ethereum20ETF887626"><a name="Onderprestatie van Ethereum ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onderprestatie van Ethereum ETF</h2><p>Toen investeerders de lancering van Ethereum spot ETF’s vierden, hadden ze nooit verwacht dat dit mogelijk een negatieve invloed zou hebben op de ETH-prijs. Dit komt doordat de lancering van ETH ETF’s Ether in directe concurrentie heeft gebracht met lucratieve aandelen die betere technologie hebben. Zo heeft ETH sinds januari bijvoorbeeld met ongeveer 0,98% gewonnen, terwijl sommige aandelen betere rendementen hebben behaald. Ter illustratie, sinds januari hebben Nvidia en Meta respectievelijk 122,57% en 49,26% gewonnen. Daardoor heeft de technologieaandelenbubbel geleid tot veel concurrentie voor ETH.</p>
<p>Op dezelfde manier, <a href="https://www.gate.io/learn/articles/the-impact-of-the-ethereum-etf-etf-an-analysis/3473" target="_blank">ETH ETF’s hebben geleid tot een negatief ETH-investerings sentiment</a> wat heeft geleid tot grotere uitdagingen voor Ethereum. De lage ETH instroom heeft het vertrouwen van investeerders in zowel ETH als de ETF’s verminderd. Als gevolg daarvan kiezen degenen die geïnteresseerd zijn in het investeren in crypto-ETF’s voor <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> spot exchange traded funds, aangezien ze van tijd tot tijd aanzienlijke kapitaalinstroom hebben. Helaas hebben ETH ETF’s sinds hun lancering veel netto-uitstroom ervaren. Als voorbeeld, alleen al op 12 september waren er netto-uitstromen van $20,14 miljoen, wat heeft geleid tot een cumulatieve netto-uitstroom van $582,74 miljoen.</p>
<p>Lees ook: <a href="https://www.gate.io/announcements/article/39253/gate-research-bitcoin-and-ethereum-show-modest-gains-spot-etf-outflows-continue" target="_blank">Bitcoin en Ethereum tonen bescheiden winsten, uitstroom van spot ETF’s gaat door</a><img src="https://gimg2.gateimg.com/image/article/17272578213.jpg" alt=""><br>Ethereum negatief <a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">stroom</a>-flow” target=“_blank” class=“blog_inner_link”&gt;flow: Sosovalue</p>
<p>De trend in de Ether ETF-sector is te zien in de Ether crypto-markt. En over het algemeen is er een afname van institutionele interesse in Ethereum-producten.</p>
<p>Lage Staking Rewards: Op basis van de huidige marktanalyse dragen ook de lage Ethereum staking rewards bij aan de afname van de vraag naar ETH. Hoewel het gemiddelde ETH staking reward 3,2% is, is er ook een geannualiseerd inflatiepercentage van ongeveer 0,7%. Dit betekent dat een ETH-investeerder die ETH staked, een nettorendement van minder dan 3% ontvangt. Als gevolg hiervan is de beloning van ETH staking veel lager dan het rendement van Amerikaanse staatsobligaties. Daarom zouden investeerders die op de hoogte zijn van de verschillen in rendement van diverse investeringsactiva eerder hun geld in staatsobligaties dan in ETH staking steken. Dit heeft geleid tot een daling van de vraag naar ETH, wat uiteindelijk bearish druk heeft gecreëerd.</p>
<p>Toenemende concurrentie van nieuwe tokens: het scenario voor cryptomuntinvesteringen verandert snel. Zo worden er regelmatig nieuwe tokens op de markt geïntroduceerd. Dit leidt tot een afname van het marktaandeel van bestaande cryptocurrencies zoals ETH. Zo is er bijvoorbeeld een toename geweest van het aantal meme coins op de markt. Omdat sommige van deze coins hoge rendementen genereren door de steun van hun grote gemeenschappen, kiezen veel mensen ervoor om in deze coins te investeren in plaats van in pionierende cryptocurrencies zoals ETH en bitcoin.</p>
<p>In dit opzicht, <a href="https://www.vaneck.com/us/en/blogs/digital-assets/matthew-sigel-vaneck-crypto-monthly-recap-for-august-2024/" rel="nofollow noopener noreferrer" target="_blank">VanEck zei</a>“Tegelijkertijd zijn er veel tokens gelanceerd die momenteel of in de toekomst waarde onttrekken aan het ecosysteem van Ethereum. Deze omvatten L2, gegevensbeschikbaarheid, herstaking en staking tokens. Elke van deze productgroepen biedt een concurrerende dienst aan Ethereum.”</p>
<p>Het voegde eraan toe: “Naarmate er meer projecten tokens lanceren, zal er verdere concurrentie zijn in het dienstenaanbod van Ethereum, waardoor de prijs van de kernservices van Ethereum lager wordt terwijl er concurrerende investeringsmogelijkheden worden geboden. Deze prijsdruk kan de economische taart die beschikbaar is voor ETH-houders verkleinen, terwijl de concurrentie om investeerdersinteresse toeneemt.”</p>
<h2 id="h2-Conclusie107943"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Ether presteert niet zoals de markt verwacht, aangezien het de op één na grootste digitale valuta is in de cryptomarkt. Verschillende factoren dragen bij aan de onderprestatie van Ether. Deze omvatten hevige concurrentie van andere layer-1-netwerken, onzekerheid over het monetair beleid van de Verenigde Staten en lage beloningen voor staking. Hoewel het niets kan doen aan de externe factoren, zou het zich moeten richten op interne problemen met betrekking tot de layer-2 chains.</p>
<div class="blog-details-info"><br><div>Auteur: Mashell C., 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 op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>