Vml0YWxpayBCdXRlcmluIG9udGh1bHQgRXRoZXJldW0ncyBoZWxkZXJlIHRvZWtvbXN0IG5hIERlbmN1bjogRWVuIHNwcm9uZyBuYWFyIHNjaGFhbGJhYXJoZWlkIGVuIGVmZmljacOrbnRpZQ==

2024-04-09, 07:06

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR33350"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Op 13 maart <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> lanceerde de Dencun hard fork die de efficiëntie van het netwerk zal verbeteren.</p>
<p>De Dencun-upgrade zal de schaalbaarheid, kosteneffectiviteit en interoperabiliteit van het Ethereum-netwerk verbeteren.</p>
<p>Niettemin kijkt <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> uit naar verdere verbetering van schaalbaarheid en veiligheid.</p>
<h2 id="h2-Introductie788351"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Al meerdere jaren ondergaat de Ethereum blockchain voortdurende veranderingen om de uitdagingen zoals schaalbaarheidsproblemen en hoge transactiekosten te overwinnen. De echte reis naar totale transformatie begon met de samensmelting.</p>
<p>Van daaruit had de blockchain andere upgrades zoals de Shanghai Upgrade en de Shapella-upgrade. Tenslotte, op <a href="https://www.gate.io/post/KQQDFis7c1RwWRIVGAoGBB5QX1sO0O0O/status/5006512" target="_blank">13 maart lanceerde Ethereum de Dencun Hard Fork</a> die verschillende veranderingen introduceert en een sterke basis legt voor toekomstige ontwikkelingen. Dit artikel bespreekt de implicaties van de Dencun Upgrade en de toekomst van de Ethereum blockchain.</p>
<h2 id="h2-De20Dencun20Hard20Fork20Een20Game20Changer20voor20Ethereum587929"><a name="De Dencun Hard Fork: Een Game Changer voor Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Dencun Hard Fork: Een Game Changer voor Ethereum</h2><p>De toekomstige ontwikkelingen van Ethereum zijn afhankelijk van de Dencun hard fork die op 13 maart op het Mainnet is gelanceerd. Deze upgrade is een belangrijke stap richting <a href="https://www.gate.io/learn/articles/dencun-upgrades-impact-on-ethereum-l2-competition/2176" target="_blank">het ontwikkelen van een layer-2 gecentreerd ecosysteem Ethereum</a>.</p>
<p>Sinds de lancering van de <a href="https://www.gate.io/learn/articles/all-you-need-to-know-about-the-ethereum-shapella-upgrade/518" target="_blank">Shapella upgrade in april 2023</a> De Dencun hard fork is de meest significante ontwikkeling op het Ethereum blockchain-netwerk, waarmee het intrekken van gestapelde ETH mogelijk wordt gemaakt. In feite is het doel van de Dencun hard fork het verbeteren van de schaalbaarheid van het netwerk en het monsteren van gegevensbeschikbaarheid in Ethereum via proto-danksharding.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/learn/articles/dencun-will-make-ethereum-cypherpunk-again/2197" target="_blank">Dencun zal Ethereum opnieuw cypherpunk maken</a></p>
<p>De Dencun-upgrade zal veel opmerkelijke veranderingen brengen op de Ethereum-blockchain. Zo zal het naast het verbeteren van de schaalbaarheid leiden tot verlaging van de Ethereum-transactiekosten op layer-2-netwerken. Dit zal mogelijk zijn door het gebruik van rollups om gegevens op de blockchain te plaatsen. In feite zullen de gasvergoedingen naar verwachting met minstens 10 keer afnemen.</p>
<p>Hoge transactiekosten waren de grootste zorg waar de blockchain sinds zijn ontstaan mee te maken had. Op dit moment zou dat verleden tijd moeten zijn, wat resulteert in een meer competitief netwerk.</p>
<p>De Dencun Hard Fork bestaat uit 9 verbeteringsvoorstellen (EIP’s), waaronder EIP-6780 EIP 7623 Ethereum, EIP-1153, EIP-4788, EIP-5656, EIP-6493 en EIP-4844 Ethereum, waarbij elementen uit twee belangrijke worden samengevoegd. <a href="https://www.gate.io/learn/articles/community-views-on-ethereum-after-cancun-deneb-upgrade/2344" target="_blank">upgrades Cancun, die zich richt op de uitvoeringslaag, en de Deneb die gericht is op de consensuslaag</a>.</p>
<p>Deze twee upgrades zullen de schaalbaarheid van Ethereum verbeteren en de algehele functionaliteit verbeteren doordat ze transactieverwerking en consensusmechanismen stroomlijnen. Bovendien zal de Dencun-upgrade resulteren in beveiligingsverbeteringen van Ethereum, waardoor de functionaliteiten van gedecentraliseerde applicaties op de blockchain worden verbeterd.</p>
<h2 id="h2-De20verschuiving20naar20een20layer220centrisch20ecosysteem20en20de20implicaties20voor20Ethereum115088"><a name="De verschuiving naar een layer-2 centrisch ecosysteem en de implicaties voor Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De verschuiving naar een layer-2 centrisch ecosysteem en de implicaties voor Ethereum</h2><p>De verschuiving van het Ethereum-netwerk naar een Layer 2-gericht ecosysteem zal de decentralisatie verder verbeteren en veel layer-1-toepassingen in staat stellen over te stappen naar layer-2. Vitalik Buterin Ethereum sprak over het belang van een aparte dataspace die de schaalbaarheid van Ethereum-toepassingen verbetert.</p>
<p>Als een feit maakt aparte gegevensruimte het mogelijk voor L2-projecten om gegevens op te slaan in een gedeelte van een blok dat niet toegankelijk is voor de Ethereum Virtual Machine (EVM). Deze functie maakt het mogelijk om de gegevens afzonderlijk van de blokken uit te zenden en te verifiëren, wat een belangrijke innovatie is die de basis legt voor schaalbaarheid door middel van gegevensbeschikbaarheidssteekproeven.</p>
<p>Een andere belangrijke eigenschap van deze innovatie is dat het de uitbreiding van de gegevenscapaciteit van Ethereum mogelijk maakt zonder negatieve gevolgen voor de beveiliging van de Ethereum layer-2 protocollen. Opnieuw is het niet nodig dat ontwikkelaars ingrijpende wijzigingen aanbrengen in hun en.</p>
<h2 id="h2-ProtoDanksharding20Het20herstellen20van20de20schaalbaarheid20van20Ethereum644231"><a name="Proto-Danksharding: Het herstellen van de schaalbaarheid van Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Proto-Danksharding: Het herstellen van de schaalbaarheid van Ethereum</h2><p>Waarschijnlijk is het belangrijkste verbeteringsvoorstel (EIP) van Dencun EIP-4844 Ethereum of proto-danksharding, dat de weg vrijmaakt voor het gebruik van rollups om gegevens op Ethereum te posten. Momenteel gebruiken de rollups calldata om transacties op Ethereum te plaatsen. Aangezien de blockchain de calldata permanent opslaat en de uitvoeringslaag of EVM toegang geeft, draagt dit meer dan 90% bij aan de rollup-kosten. Niettemin zal proto-danksharding Ethereum een nieuwe transactietype genaamd een blob gebruiken.</p>
<p>Een blob is vergelijkbaar met een blok, maar de transactiegegevens komen rechtstreeks van een rollup. Als gevolg hiervan is de verificatie van de gegevens gebaseerd op een referentiehash in plaats van de volledige gesharde gegevens in blobs. De blobs maken daarom transactieverificaties off-chain en op een eenvoudige manier.</p>
<p>Met proto-danksharding zal het Ethereum-netwerk gebundelde transacties verwerken die afkomstig zijn van layer-2 rollups zonder ze permanent op te slaan. Daarom, <a href="https://www.gate.io/learn/articles/explore-ethereum-s-dencun-upgrade-and-potential-opportunities/1920" target="_blank">Het belangrijkste aspect van de EIP 4844 is dat alle layer-2 rollups worden geaggregeerd</a> en verwerken alle transacties off-chain wat Ethereum netwerkcongestie vermindert. Dit zal de netwerksnelheid verbeteren, de doorvoer verhogen en gebruikerskosten verminderen.</p>
<p>Een Grayscale-rapport bevestigt het standpunt dat de Dencun-upgrade de concurrentiekracht van Ethereum binnen het blockchain-ecosysteem zal vergroten. <a href="https://www.grayscale.com/research/reports/ethereums-coming-of-age-dencun-and-eth-2.0" rel="nofollow noopener noreferrer" target="_blank">rapporten zeggen</a> dat Ethereum voortaan “het potentieel heeft om de schaalbaarheid en het concurrentievermogen van Ethereum ten opzichte van snellere ketens te verbeteren”.</p>
<h2 id="h2-Ethereums20Roadmap20Focus20op20Efficintie20en20Veiligheid208117"><a name="Ethereum’s Roadmap: Focus op Efficiëntie en Veiligheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum’s Roadmap: Focus op Efficiëntie en Veiligheid</h2><p>Vitalik Buterin’s Ethereum heeft een duidelijke routekaart uitgestippeld om verschillende doelen te bereiken, waaronder decentralisatie van Ethereum en verbeterde Ethereum-staking. Het team zal zich ook richten op het voorkomen van Ethereum blockchain-opblazen, wat een bron van grote zorg is onder ontwikkelaars.</p>
<p>Ten eerste zei Buterin dat het team plannen heeft om gegevenscompressie te optimaliseren om de beveiliging van het netwerk te verbeteren. Bovendien zal Ethereum slimme cryptografie introduceren waardoor de identiteit van de huidige block voorsteller privé wordt gehouden om DOS-aanvallen te voorkomen.</p>
<p>De volgende fase zal de implementatie van gegevensbeschikbaarheidsonderzoek bij Ethereum omvatten om de capaciteit van elke blob te verbeteren tot 16 MB per slot. Tegelijkertijd zal het team werken aan het optimaliseren van layer-2 oplossingen door middel van optimistische uitvoering en gegevenscompressie, onder andere technieken.</p>
<p>De volgende fase van Ethereum, de Scourge, zal netwerkdecentralisatie, censuurbestendigheid bevorderen en protocolrisico’s verminderen van miner extractable value (MEV).</p>
<p>Later zal het team zich richten op Verkle-bomen, de gebruikerservaring van Ethereum en single-slot finaliteit, wat Buterin ziet als minder significant dan de verbeteringen op het gebied van beveiliging en netwerk decentralisatie. Dergelijke ontwikkelingen die PeerDAS Ethereum en ZKEVMs Ethereum aanvullen, zullen het tot een favoriete blockchain maken.</p>
<p>Gerelateerd artikel: <a href="https://www.gate.io/learn/articles/bitcoin-eco-vs-ethereum-eco-who-will-be-the-next-leader/2376" target="_blank">Bitcoin VS Ethereum, Welk ecosysteem zal de volgende leiding nemen?</a></p>
<h2 id="h2-Conclusie944267"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Vitalik Buterin heeft een rooskleurige toekomst voor de Ethereum blockchain voor ogen, na de succesvolle lancering van de Dencun hard fork op 13 maart. De upgrade zal vele voordelen met zich meebrengen, zoals lagere transactiekosten, een betere gebruikerservaring, grotere netwerkdecentralisatie en protocolinteroperabiliteit. Vooruitkijkend richt het Ethereum-team zich op verdere verbetering van de netwerkbeveiliging en censuurbestendigheid.</p>
<h2 id="h2-Veelgestelde20vragen20over20Ethereum955690"><a name="Veelgestelde vragen over Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Ethereum</h2><h3 id="h3-Wie20bezit20Ethereum20blockchain763811"><a name="Wie bezit Ethereum blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie bezit Ethereum blockchain?</h3><p>Vitalik Buterin, Charles Hoskinson, Anthony Di Iorio en Mihai Alisie waren de oprichters van Ethereum. Echter, aangezien Ethereum een open source gedecentraliseerd netwerk is, wordt het onderhouden door duizenden ontwikkelaars van over de hele wereld.</p>
<h3 id="h3-Wanneer20is20Ethereum20uitgevonden867554"><a name="Wanneer is Ethereum uitgevonden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wanneer is Ethereum uitgevonden?</h3><p>Ethereum werd uitgevonden in 2013 en gelanceerd in 2015. Vitalik Buterin, een Russisch-Canadese programmeur, bedacht het idee van Ethereum.</p>
<h3 id="h3-Is20Ethereum20gedecentraliseerd94267"><a name="Is Ethereum gedecentraliseerd?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Ethereum gedecentraliseerd?</h3><p>Ethereum is een open-source en gedecentraliseerd netwerk, aangezien het wordt onderhouden door duizenden ontwikkelaars uit verschillende landen. Vitalik Buterin, Charles Hoskinson, Anthony Di Iorio en Mihai Alisie richtten Ethereum op in 2013.</p>
<h3 id="h3-Wat20is20de20inheemse20cryptocurrency20voor20het20Ethereumnetwerk455308"><a name="Wat is de inheemse cryptocurrency voor het Ethereum-netwerk?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de inheemse cryptocurrency voor het Ethereum-netwerk?</h3><p>Ether, populair bekend als ETH, is de inheemse cryptocurrency van Ethereum. Het is de nutsmunt die wordt gebruikt voor het doen van betalingen op het netwerk, zoals transactiekosten.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt zich alle rechten voor op dit artikel. Het is toegestaan om het artikel te herpubliceren op voorwaarde dat Gate.io wordt genoemd. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>