QmVncmlqcCBkZSBodWlkaWdlIHN0YXR1cyBlbiB0b2Vrb21zdGlnZSB0cmVuZHMgdmFuIEV0aGVyZXVtLW9udHdpa2tlbGluZyBpbiDDqcOpbiBhcnRpa2Vs

2025-04-24, 06:23

<p><img src="https://gimg2.gateimg.com/image/article/17454757963.png" alt=""></p>
<h2 id="h2-Introductie546906"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Als de op één na grootste cryptocurrency op het gebied van versleuteling, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> staat op een cruciaal kruispunt. Sinds de lancering in 2015 heeft <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> zijn leidende positie gevestigd met zijn slimme contracten en gedecentraliseerde applicatie (dApps) ecosysteem. Echter, de toekomstige ontwikkeling staat voor zware tests als gevolg van de huidige marktprestaties, technische uitdagingen en regelgeving. Dit rapport analyseert de huidige status, mogelijke trends en toekomstperspectieven van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> vanuit meerdere dimensies, met als doel investeerders en ontwikkelaars uitgebreide inzichten te bieden.</p>
<p>Handel nu in ETH:<br><a href="https://www.gate.io/trade/ETH_USDT" target="_blank">https://www.gate.io/trade/ETH_USDT</a><a href="https://www.gate.io/trade/ETH_USDT" target="_blank">https://www.gate.io/trade/ETH_USDT</a></p>
<h2 id="h2-Prijszwakte20kapitaaluitstroom20is20Ethereum20een20hasbeen521415"><a name="Prijszwakte, kapitaaluitstroom, is Ethereum een has-been?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prijszwakte, kapitaaluitstroom, is Ethereum een has-been?</h2><p>Vanaf 23 april 2025, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> Oscillerend rond $1500-1800, de grootste daling in het afgelopen jaar bedroeg 65%, ver verwijderd van het historische hoogtepunt van $4800.</p>
<p>Volgens Gate.io gegevens bedraagt de huidige totale marktwaarde van Ethereum 216 miljard Amerikaanse dollars, met een circulerende voorraad van 121 miljoen ETH, en het marktaandeel is gedaald tot 7,4%, ver onder <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> marktaandeel van Gate.io weerspiegelt een afname van de positie van Ethereum in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">cryptocurrency markt</a>.</p>
<p>Observeren de <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">stroom</a> van fondsen is het meest intuïtief. Het beheerd vermogen (AUM) van de Ethereum spot ETF is gedaald tot $45,7 miljard, wat een historisch dieptepunt bereikte. Gegevens van CoinShares tonen aan dat er de afgelopen acht weken voortdurende nettostromen van $772 miljoen zijn geweest, wat wijst op een gebrek aan vertrouwen onder institutionele beleggers. Bovendien hebben instellingen zoals Galaxy Digital en Polychain Capital een grote hoeveelheid ETH op beurzen gestort, terwijl walvissen (grote houders) de afgelopen week 140.000 ETH hebben verkocht. Zelfs sommige slapende adressen van 3-10 jaar zijn weer actief geworden en verkopen ETH.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17454756081.png" alt=""></p>
<p>Ondertussen is er een aanzienlijke daling geweest in netwerkactiviteit op Ethereum. Sinds 10 april is het aantal nieuwe adressen en actieve adressen sterk afgenomen, waarbij de gemiddelde transactiekosten zijn gedaald van $0,86 naar $0,63. Dit duidt op een afnemende vraag naar het Ethereum-netwerk, met een lage marktsentiment en geschud vertrouwen van investeerders. Daarnaast bereikte de ETH/BTC-ratio deze week een 5-jaars dieptepunt van 0,02193, wat verder de zwakke prestatie van Ethereum ten opzichte van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> weerspiegelt.</p>
<h2 id="h2-Gemeenschapskritiek20Gemeenschapspolitisering20L2oplossingen20leiden20tot20fragmentatie20van20verkeerswaarde592704"><a name="Gemeenschapskritiek: Gemeenschapspolitisering, L2-oplossingen leiden tot fragmentatie van verkeerswaarde" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gemeenschapskritiek: Gemeenschapspolitisering, L2-oplossingen leiden tot fragmentatie van verkeerswaarde</h2><p>Kritiek op Ethereum in de gemeenschap richt zich voornamelijk op de politisering van de gemeenschap, wat leidt tot een reeks stagnatie en waardedaling.</p>
<p>Zoals @0xJigglypuff bijvoorbeeld opmerkte, heeft EIP-1559 (geïntroduceerd in 2021, gericht op het bereiken van ‘ETH deflatie’ door middel van een verbrandingsmechanisme) een scheiding in de gemeenschap veroorzaakt. Hoewel het het economische model van het netwerk heeft verbeterd, heeft het ook geleid tot ontevredenheid onder langetermijnhouders. Upgrades na de Merge (in 2022) zoals Shanghai en Dencun worden door sommigen als ineffectief beschouwd, met slechts 3⁄117van de gemeenschapsleden die geloven dat deze upgrades vooruitgang hebben gebracht.</p>
<p>Maar de kernontwikkelaars hadden nooit verwacht dat Ethereum vandaag de dag zo onderbenut zou zijn… Alle metingen, transactievolume en Gwei-kosten hebben de afgelopen jaren nieuwe dieptepunten bereikt, en de winsten van ‘deflationaire activa’ zijn bijna volledig verdampt.</p>
<p>Daarnaast zijn er oplossingen van de tweede laag (L2), zoals Arbitrum, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, en zkSync zijn ontworpen om schaalbaarheid te verbeteren door middel van off-chain verwerking, maar ze krijgen kritiek. Sommigen geloven dat L2-oplossingen te overhaast zijn, wat leidt tot centralisatie en ecosysteemfragmentatie, waardoor composability en gebruikerservaring worden geschaad. De baselayer van Ethereum gebruikt momenteel slechts 2% van zijn schaalbaarheidslimiet, wat betekent dat de prestaties aanzienlijk kunnen worden verbeterd door de baselayer te optimaliseren zonder overdreven te vertrouwen op L2.</p>
<p>Een ander punt is dat de prestaties van EVM beperkt worden door de efficiëntie van de database. Het huidige gebruik van LevelDB en PebbleDB is niet geoptimaliseerd voor de adres-willekeurig nummer-gegevensstructuur van EVM. Daarentegen heeft SonicDB, als een flat file database speciaal ontworpen voor blockchain, bewezen de doorvoer met 8 keer te verhogen en de opslagvereisten met 98% te verminderen. Echter, de risicomijdende cultuur van Ethereum heeft geleid tot aarzeling bij het adopteren van dergelijke laag-risico verbeteringen.</p>
<h2 id="h2-Pectraupgrade20is20binnenkort20kan20Ethereum20terugkeren20naar20zijn20hoogtepunt181414"><a name="Pectra-upgrade is binnenkort, kan Ethereum terugkeren naar zijn hoogtepunt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pectra-upgrade is binnenkort, kan Ethereum terugkeren naar zijn hoogtepunt?</h2><p>Op dit moment heeft Ethereum een marktaandeel van 7,4%, maar leidt nog steeds op het gebied van DeFi, met een totale vergrendelde waarde (TVL) van $650 miljard (hoewel dit lager is dan de $100 miljard aan het eind van vorig jaar). Concurrenten zoals <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain hebben respectievelijk TVL’s van $9 miljard en $7,3 miljard, wat aangeeft dat Ethereum nog steeds een dominante positie inneemt in het DeFi-veld, maar dat zijn voordeel wordt aangetast.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17454756262.png" alt=""></p>
<p>En onlangs zal Ethereum de volgende technische upgrades verwelkomen:</p>
<p>Pectra upgrade: oorspronkelijk gepland voor 7 mei 2024, maar kan worden uitgesteld, gericht op het verbeteren van schaalbaarheid door verschillende optimalisaties.</p>
<p>PCRAs upgrade: Het wordt verwacht dat er native operation binding en account abstractiefuncties worden geïntroduceerd, die de behoefte aan portefeuilles en Gas-kosten kunnen elimineren, waardoor de gebruikerservaring aanzienlijk wordt verbeterd. De succesvolle implementatie van deze upgrades zal cruciaal zijn voor de toekomstige concurrentiekracht van Ethereum.</p>
<p>Echter is het volgens de auteur mogelijk dat de voordelen van deze upgrades tijdelijk zijn. Belangrijk is dat Ethereum een meer inclusief governance model nodig heeft om vertrouwen te herstellen en de gemeenschap te verenigen. Het leiderschap en het besluitvormingsproces van de stichting zullen in de komende jaren een cruciale rol spelen, met name bij de vorming van technische upgrades en gemeenschapsconsensus.</p>
<h2 id="h2-Conclusie521103"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Ethereum bevindt zich momenteel in een uitdagende maar potentieel onbeperkte fase. Ondanks de splitsingen in de gemeenschap, schaalbaarheidsproblemen, intense concurrentie en regelgevingsonzekerheid, bieden de technische upgrades van Ethereum, het robuuste ecosysteem en actieve ontwikkelaarsgemeenschap een solide basis. Als Ethereum succesvol zijn technische routekaart kan implementeren en regelgevende uitdagingen kan overwinnen, is het klaar om in de komende jaren weer momentum te krijgen, zelfs historische hoogtepunten te bereiken of te overtreffen. De sleutel tot succes ligt echter in gemeenschapseenheid, technologische innovatie en een scherp oog voor marktdynamiek.</p>
<p>Waarschuwing: Marktvolatiliteit en veranderingen in het regelgevingsbeleid kunnen van invloed zijn op de ontwikkeling van Ethereum. Beleggers moeten de risico’s zorgvuldig beoordelen.</p>
<div class="blog-details-info"><br>  <div>Auteur: Charle A., Onderzoeker bij Gate.io<div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen beleggingsadvies. Beleggen brengt risico's met zich mee, dus beslissingen moeten zorgvuldig worden genomen.<br></em><div><em></em>Deze inhoud is origineel en het auteursrecht behoort toe aan Gate.io. Als u wilt herdrukken, geef dan de auteur en bron aan, anders zullen er juridische verantwoordelijkheden worden nagestreefd.<br></div><p></p><br></div></div></div>