V2Fhcm9tIHppam4gZGUgRXRoZXJldW0ta29zdGVuIHpvIGhvb2cgaW4gMjAyNT8=

2022-03-02, 05:22

<p><img src="https://gimg2.gateimg.com/image/1202506061908206301467738.png" alt="">
</p><p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk, als een pionier van slimme contracten en ERC-20 gebaseerde projecten, heeft hoge transactiekosten en trage snelheden in vergelijking met andere blockchains.</p>
<p>In de afgelopen jaren heeft de exponentiële groei de prijs van vergoedingen beïnvloed. Voor de EIP-1559-update werden vergoedingen op basis van wie het eerst komt, het eerst maalt, verwerkt op basis van de hoogste bieder, terwijl de update het transformeerde in een automatisch systeem.</p>
<p>Naarmate 2025 vordert, vertonen Ethereum-kosten aanzienlijke veranderingen. De implementatie van de consensuslaag heeft enige verlichting gebracht, waarbij de gemiddelde transactiekosten fluctueren tussen de 5 en 15 dollar tijdens normale activiteitperiodes, oplopend tot 25 tot 40 dollar tijdens drukke verkeersgebeurtenissen. Layer 2-oplossingen zijn cruciaal geworden, met Optimism, Arbitrum en zkSync die aanzienlijk lagere kosten bieden variërend van 0,15 tot 0,45 dollar.</p>
<p>De EIP-1559-update heeft de kosten aanzienlijk verbeterd, hoewel ze tijdens drukke momenten nog steeds duur blijven - de kosten worden nu over het netwerk verdeeld in plaats van het vorige biedsysteem te gebruiken. De introductie van de prototype danksharding (EIP-4844) verhoogt verder het vermogen van het netwerk om een toename van het transactievolume aan te kunnen, waardoor de kosten met ongeveer 45% worden verlaagd vergeleken met de niveaus in 2023.</p>
<p>Hoewel er aanzienlijke verbeteringen zijn aangebracht door middel van protocolupgrades, blijven de Ethereum-kosten een uitdaging voor particuliere gebruikers die deelnemen aan DeFi-toepassingen, vooral voor kleinere transacties waarbij de kosten een groot deel van de totale waarde kunnen uitmaken.</p>
<p>Als je ooit Ethereum-tokens of andere tokens op het Ethereum-netwerk op basis van ERC-20 hebt verhandeld, moet je een significant verschil van deze blockchain ten opzichte van andere hebben opgemerkt: de transactiekosten op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> zijn extreem hoog.</p>
<p>Bovendien lijken deze kosten alleen maar te stijgen naarmate het netwerk probeert uit te breiden en te voldoen aan de toenemende vraag. Maar wat veroorzaakt de hoge Ethereum-kosten en zijn er oplossingen voor dit probleem?</p>
<p>In dit artikel zullen we een gedetailleerde blik werpen op de Ethereum-kosten, waarom ze steeds lijken te stijgen en hoe we dit probleem kunnen aanpakken.</p>
<h2 id="h2-Verwachte20Ethereumkosten20in202025589637"><a name="Verwachte Ethereum-kosten in 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verwachte Ethereum-kosten in 2025</h2><p>Naarmate 2025 nadert, tonen de Ethereum-netwerkvergoedingen significante ontwikkelingen in vergelijking met voorgaande jaren. De implementatie van de consensuslaag (voorheen bekend als Ethereum 2.0) heeft enige verlichting gebracht in de kostenstructuur, hoewel het het probleem niet volledig heeft opgelost.</p>
<p>Huidige gegevens tonen aan dat tijdens normale netwerkactiviteit de gemiddelde transactie kosten fluctueren tussen de 5-15 dollar, en tijdens piek vraag kunnen ze stijgen tot 30-50 dollar - aanzienlijk lager dan de extreme kosten van 100+ dollar die in voorgaande jaren zijn ervaren, maar nog steeds hoger dan die van concurrerende laagoplossingen.</p>
<p>Laag 2 schalingsoplossingen zijn tegen 2025 een noodzaak geworden voor Ethereum-gebruikers:</p>
<table>
<thead>
<tr>
<th>Oplossing</th>
<th>Gemiddelde vergoeding</th>
<th>transacties per seconde</th>
</tr>
</thead>
<tbody>
<tr>
<td><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a></td>
<td>0,25-0,45 USD</td>
<td>2.000+</td>
</tr>
<tr>
<td>Arbitrum</td>
<td>0,30-0,50 USD</td>
<td>2.500+</td>
</tr>
<tr>
<td>zkSync</td>
<td>0,15-0,35 USD</td>
<td>3.000+</td>
</tr>
</tbody>
</table>
<p>De introductie van het prototype danksharding (EIP-4844) heeft het vermogen van het netwerk verbeterd om een toename van het transactievolume aan te kunnen, waardoor de extreme kostenpieken die eerder voorkwamen, worden vermeden. Deze verbetering biedt gebruikers een betere voorspelbaarheid van de kosten, terwijl de netwerkbeveiliging wordt behouden.</p>
<p>Ondanks deze vooruitgangen zullen de Ethereum-kosten in 2025 nog steeds een belangrijke overweging zijn voor gebruikers, vooral voor kleinere transacties, waarbij de kosten nog steeds een aanzienlijk deel van de totale transactiewaarde kunnen vertegenwoordigen.</p>
<h2 id="h2-202520Ethereum20Kostenoverzicht790046"><a name="2025 Ethereum Kostenoverzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2025 Ethereum Kostenoverzicht</h2><p>De vergoedingensituatie van Ethereum in 2025 presenteert een complexe werkelijkheid. Hoewel er aanzienlijke verbeteringen zijn aangebracht door protocol-upgrades, blijft netwerkcongestie een uitdaging naarmate de adoptie blijft uitbreiden.</p>
<p>Huidige indicatoren tonen aan dat de transactiekosten tijdens standaardperiodes gemiddeld tussen de 8-12 dollar liggen, en tijdens drukke evenementen (zoals belangrijke NFT-lanceringen of DeFi-liquiditeitsmigraties) kunnen ze oplopen tot 25-40 dollar. Dit is een verbetering vergeleken met historische pieken, maar het blijft duur voor kleinere transacties.</p>
<p>Layer 2-oplossingen zijn een belangrijk onderdeel van het Ethereum-ecosysteem geworden:</p>
<table>
<thead>
<tr>
<th>Oplossing</th>
<th>Gemiddelde Kosten</th>
<th>Transactie Definitieve Bevestiging</th>
</tr>
</thead>
<tbody>
<tr>
<td><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a></td>
<td>0,30-0,45 USD</td>
<td>1-5 minuten</td>
</tr>
<tr>
<td>Arbitrum</td>
<td>0,25-0,40 USD</td>
<td>1-7 minuten</td>
</tr>
<tr>
<td>zkSync</td>
<td>0,15-0,30 USD</td>
<td>Minder dan 1 minuut</td>
</tr>
</tbody>
</table>
<p>De implementatie van het prototype danksharding (EIP-4844) biedt significante verlichting, waardoor layer 2-oplossingen transactiegegevens efficiënter kunnen publiceren, wat de kosten met ongeveer 45% verlaagt vergeleken met de niveaus van 2023.</p>
<p>Ondanks enige vooruitgang blijft de kostenstructuur van Ethereum toegankelijkheidsuitdagingen met zich meebrengen, vooral voor particuliere gebruikers die deelnemen aan DeFi-toepassingen. Meerdere platforms promoten nu actief cross-chain interoperabiliteitsoplossingen om deze beperkingen te verlichten terwijl de veiligheid behouden blijft.</p>
<h2 id="h2-Waarom20zijn20de20kosten20op20Ethereum20zo20hoog885551"><a name="Waarom zijn de kosten op Ethereum zo hoog?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom zijn de kosten op Ethereum zo hoog?</h2><p>Het Ethereum-netwerk is het eerste netwerk voor slimme contracten en is gebaseerd op ERC-20. In vergelijking met andere blockchains zijn de transactiekosten zeer hoog, maar de transactiesnelheid is extreem traag.</p>
<p>In de afgelopen jaren heeft de exponentiële groei in schaal ook een significante impact gehad op de prijs van vergoedingen. Voordat de EIP-1559-upgrade het tot een automatisch systeem maakte, werden deze vergoedingen geprioriteerd op basis van de volgorde van de hoogste bieder.</p>
<p>Maar de belangrijkste reden voor de stijging van de kosten in de afgelopen twee jaar is de opkomst van DeFi. Sinds Ethereum slimme contracten heeft gecreëerd, zijn de meeste DeFi-projecten gebaseerd op zijn blockchain, dus kan worden gezegd dat al zijn tools afhankelijk zijn van het netwerk om te functioneren—staking, lenen, rendement, liquiditeitspools, yield farming, NFT’s, enz.</p>
<p>De update van EIP-1559 heeft het probleem van hoge kosten aanzienlijk verbeterd, hoewel ze nog steeds duur zijn en nog duurder tijdens drukke periodes—nu zijn de kosten over het hele netwerk verdeeld, in plaats van het vorige biedsysteem te gebruiken.</p>
<p>Ethereum 2.0 en andere aankomende nieuwe technologieën bieden hoop voor verbetering van dit probleem, maar volgens mede-oprichter Vitalik Buterin kan een andere aanzienlijke innovatie jaren duren.</p>
<p>Als je ooit Ethereum-tokens of andere op ERC-20 gebaseerde tokens op het Ethereum-netwerk hebt verhandeld, heb je zeker opgemerkt dat dit blockchain, in vergelijking met andere blockchains, enkele zeer kenmerkende eigenschappen heeft: de transactiekosten op Ethereum zijn extreem hoog.</p>
<p>Naarmate netwerken proberen op te schalen terwijl ze reageren op de groeiende vraag, lijken ze alleen maar duurder te worden. Maar wat zorgt ervoor dat de kosten op Ethereum zo hoog zijn, en is er een oplossing voor het probleem?</p>
<p>In dit artikel geven we een gedetailleerd overzicht van de Ethereum-kosten, hoe deze zijn gestegen en hoe we dit probleem kunnen aanpakken.</p>
<h2 id="h2-Wat20is20gasvergoeding49190"><a name="Wat is gasvergoeding?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is gasvergoeding?</h2><p>De operationele kosten van het Ethereum-netwerk lijken dag na dag te stijgen. Het is niet ongebruikelijk dat de transactiekosten $30, $40 en soms zelfs $100 bedragen—ongeacht de werkelijke overdrachtswaarde.</p>
<p>Deze factor is direct gerelateerd aan gaskosten, die een belangrijke rol spelen in het Ethereum-netwerk.</p>
<p>Gas kosten zijn gerelateerd aan het werk dat op het netwerk wordt verricht. Deze meting van werk wordt gas eenheden genoemd. Aangezien Ethereum slechts een beperkt aantal gas eenheden tegelijk kan verwerken, moeten degenen die mijnen met hardware in het netwerk de belangrijkste operaties kiezen die ze zullen uitvoeren, anders kan dit de blockchain overweldigen en ervoor zorgen dat deze stopt - dit is tot nu toe niet gebeurd.</p>
<p>Dit zogenaamde gasapparaatfilter houdt rekening met hoeveel elke miner die deelneemt aan het netwerk zal verdienen aan de transactie, een factor aangeduid als de gasprijs. Daarom moeten degenen die proberen hun transacties voor anderen te prioriteren een hogere gasprijs betalen. Omgekeerd, als je niet haast hebt om een transactie te verzenden of te ontvangen, blijft de bestelling in verschillende pools met lage opbrengsttransacties totdat een miner deze selecteert. Deze aanpak brengt echter het risico met zich mee van transactieannulering, in welk geval je het bestelproces opnieuw moet voltooien.</p>
<p>De uitdagingen waarmee Ethereum te maken heeft op het gebied van transactie kosten zijn niet toevallig. Onlangs had het EnthUM-netwerk een gemiddelde dagelijkse transactievolume van $1,2 miljard, met een piek van $1,7 miljard in mei 2021. Het handelsvolume is extreem groot.</p>
<p>Echter, de toenemende populariteit van de cryptografische technologie van Ethereum is niet de enige reden voor de hoge vraag naar dit netwerk. Er is ook DeFi, dat, als een bloeiend crypto-ecosysteem, een aanzienlijke verantwoordelijkheid kan dragen.</p>
<h2 id="h2-Hoe20DeFi20de20kosten20van20Ethereum20laat20stijgen987876"><a name="Hoe DeFi de kosten van Ethereum laat stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe DeFi de kosten van Ethereum laat stijgen</h2><p>Eigenlijk is het principe heel eenvoudig: omdat de meeste DeFi nog steeds op het Ethereum-netwerk werkt. Naarmate DeFi groeit, neemt de vraag naar de Ethereum-blockchain vanzelfsprekend toe.</p>
<p>In de afgelopen twee jaar heeft de bloeiende ontwikkeling van de DeFi-markt geleid tot een significante toename van het handelsvolume. Terwijl meer gebruikers proberen prioriteitsoverdrachtsrechten te verwerven, zijn de algemene gaskosten in het netwerk dienovereenkomstig gestegen. Binnen het consensusbereik van gemiddelde gaskosten, heeft dit de Ethereum-kosten nog duurder gemaakt.</p>
<p>Natuurlijk is de werking van het Ethereum-netwerk niet alleen afhankelijk van het transactievolume: dit project is baanbrekend vooral vanwege de creatie van smart contracts, die het DeFi-ecosysteem in staat stelt om zich verder te ontwikkelen. Want naast de vraag naar transacties zorgt DeFi ook voor congestie van het netwerk door verschillende bestaande functies in decentrale financiën: staking, leningen, liquiditeits pools, yield farming, loterijen, NFT’s, enzovoort.</p>
<p>Als gevolg hiervan hebben de Ethereum-transacties + DeFi-transacties + DeFi-smart contracts en platforms een sneeuwbaleffect van steeds hogere kosten gecreëerd. Met de groeiende ontwikkeling van deze projecten komen er steeds meer op ERC-20 gebaseerde tokens op de markt, wat het al hoge kostenprobleem op Ethereum alleen maar zal verergeren.</p>
<p>Gezien deze factoren, wat is de oplossing?</p>
<h2 id="h2-EIP1559updateprotocol20of20Londen20hard20forkprotocol716775"><a name="EIP-1559-updateprotocol, of Londen hard fork-protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>EIP-1559-updateprotocol, of Londen hard fork-protocol</h2><p>Tijdens jaren van ontwikkeling werd de London hard fork officieel uitgebracht in augustus 2021. Dit protocol introduceerde verschillende belangrijke verbeteringen en werd geleidelijk geïmplementeerd op het Ethereum-netwerk, inclusief hoe netwerkkosten gedefinieerd worden.</p>
<p>Het protocol is bedoeld om de handels efficiëntie te verbeteren, terwijl het ook de voordelen van Ethereum benadrukt, waardoor andere concurrenten verbleken. Eerder was er een veiling systeem in de blockchain, zoals eerder vermeld, dat kon bepalen welke transacties door elk blok zouden gaan.</p>
<p>Hoe meer gebruikers bereid zijn te betalen, hoe hoger de Ethereum-kosten zullen zijn. Over het algemeen geldt: hoe meer gebruikers er het netwerk gebruiken, hoe hoger de netwerkkosten zullen zijn. Daarom moeten gebruikers rekening houden met het niveau van congestie in het netwerk op dat moment om te beslissen of ze echt op dat moment een transactie willen uitvoeren.</p>
<p>Toen Ethereum de London Hard Fork lanceerde, werd dit veiling systeem vervangen door een geautomatiseerde handelsstructuur die gemakkelijk vergoedingen verzamelt zonder handmatige invoer. Bovendien werd er een fooi-mechanisme geïntroduceerd om een peer-to-peer verbinding tussen gebruikers en miners te bieden - ondanks het nieuwe automatiseringssysteem zijn gebruikers nog steeds bereid om hogere vergoedingen voor transacties te betalen, en betalen ze miners direct. Daarnaast is er een optie om een limietvergoeding in te stellen om transacties te annuleren wanneer de prijzen te hoog zijn.</p>
<p>Mensen zijn ervan overtuigd dat dit nieuwe systeem Ethereum-transacties goedkoper zal maken. Hoewel de transactiekosten zijn verlaagd en gebruikers nu prijsgrenzen kunnen instellen, is Ethereum momenteel nog steeds het netwerk met de hoogste operationele kosten.</p>
<p>Er kunnen echter meer complete oplossingen zijn die de hoge kosten van Ethereum permanent kunnen verbeteren.</p>
<h2 id="h2-Samenvatting377230"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Sinds de lancering in 2015 heeft het Ethereum-netwerk zich behoorlijk goed ontwikkeld, waardoor slimme contracten de weg vrijmaken om mainstream te domineren en de wereldvisie op cryptocurrencies en hun nutten te veranderen.</p>
<p>Ondanks de London hard fork die het protocol heeft bijgewerkt, wat het netwerkgebruik en de kosten heeft verhoogd, moet Ethereum zich voortdurend ontwikkelen en verbeteren om te concurreren met alternatieven op de markt en zijn marktpositie te behouden. Netwerksnelheid congestie is een ander probleem dat moet worden aangepakt, en Ethereum heeft dit probleem aangepakt in de aankomende 2.0-update (nu de consensuslaag genoemd). Echter, als de voorspelling van medeoprichter Vitalik Buterin correct is, kan het nog 7 jaar duren voordat Ethereum 2.0 officieel live kan gaan.</p>
<p>Desondanks is de populariteit van Ethereum, als het op één na meest populaire netwerk sinds de lancering, evident voor de markt en gebruikers - nieuwe gebruikers verschijnen elke dag, en de trend is consistent omhoog. Echter, met de toenemende snelheid van blockchain-transacties en de dalende kosten, zal Ethereum een geheel nieuw niveau bereiken - een open, hoogpresterende industriegigant worden, en misschien zal het op een dag het leidende crypto-platform van de wereld worden.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U moet altijd onafhankelijk professioneel advies inwinnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="4">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>