Vml0YWxpayBCdXRlcmluJ3MgdmlzaWUgdm9vciBFdGhlcmV1bTogSGV0IGJlcmVpa2VuIHZhbiAxMDAuMDAwIHRyYW5zYWN0aWVzIHBlciBzZWNvbmRlIG1ldCBSb2xsdXBz

2024-10-31, 03:17

<p><img src="https://gimg2.gateimg.com/image/article/17303442551692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR647881"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Ontwikkelaars streven ernaar de Surge-upgrade te lanceren, wat zal leiden tot 100.000 TPS.</p>
<p>De belangrijkste onderdelen van de rollup-gerichte routekaart omvatten schaaloplossingen van laag 2, gegevensbeschikbaarheid sampling en gegevenscompressietechnieken.</p>
<p>Enkele voordelen van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Surge omvat goedkopere en snellere transacties.</p>
<h2 id="h2-Inleiding124424"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De <a href="https://www.gate.io/learn/articles/what-is-ethereum/2882" target="_blank">Ethereum blockchain</a> host veel gedecentraliseerde applicaties en stimuleert verschillende crypto-projecten. Vanwege de constante groei van het netwerk wordt het vaak geconfronteerd met schaalbaarheid en andere prestatie-uitdagingen. Bijvoorbeeld, de blockchain ervaart meestal congestie en hoge gasvergoedingen. Dergelijke problemen zorgen ervoor dat veel investeerders het netwerk verlaten. Om een aantal van deze uitdagingen aan te pakken <a href="https://www.gate.io/blog/827/who-is-ethereum-founder-vitalik" target="_blank">Vitalik Buterin, de medeoprichter van Ethereum</a>, heeft een revolutionair verbeteringsplan aangekondigd, de Surge, waarmee het netwerk mogelijk kan opschalen naar 100.000 transacties per seconde (TPS.) Als het netwerk dat doel bereikt, zal het een dominante kracht worden in de cryptosector.</p>
<h2 id="h2-Vitalik20Buterin20streeft20naar2010000020transacties20per20seconde20TPS20Hoe20dit20te20bereiken545079"><a name="Vitalik Buterin streeft naar 100.000 transacties per seconde (TPS): Hoe dit te bereiken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vitalik Buterin streeft naar 100.000 transacties per seconde (TPS): Hoe dit te bereiken?</h2><p>Onlangs <a href="https://vitalik.eth.limo/general/2024/10/17/futures2.html" rel="nofollow noopener noreferrer" target="_blank">In zijn blogpost kondigde Buterin een routekaart aan voor Ethereum</a> het bereiken van een doel van 100.000 TPS binnen de komende twee jaar. Het team streeft ernaar dat doel te bereiken door middel van zijn schaaloplossingen van laag 2. Echter, Buterin heeft gezworen decentralisatie en een hoge beveiliging te handhaven. Het kernaspect van de routekaart is de samensmelting van sharding en rollups. Ook werkt het team eraan om ervoor te zorgen dat <a href="https://www.gate.io/learn/articles/top-12-layer-2-solutions-on-ethereum/3759" target="_blank">Layer-2 blockchains erven Ethereum kernprincipes.</a> van decentralisatie, schaalbaarheid en veiligheid. De Ethereum-upgrade heeft tot doel de compressie te verbeteren, de beschikbaarheid van gegevenssampling te verbeteren en L2-netwerken echt vertrouwensloos te maken. De uitrol van de stijging, de volgende upgrade, zal waarschijnlijk deze doelen bereiken.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/10-layer-2-crypto-projects-to-watch-in-2024/3637" target="_blank">TOP 10 Layer 2 Crypto-projecten om nu in de gaten te houden</a></p>
<h2 id="h2-The20Surge20als20de20volgende20fase20in20Ethereums20Dencun20Upgradeserie186697"><a name="‘The Surge’ als de volgende fase in Ethereum’s Dencun Upgrade-serie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>‘The Surge’ als de volgende fase in Ethereum’s Dencun Upgrade-serie</h2><p>The Surge is Ethereum’s <a href="https://www.gate.io/learn/articles/possible-futures-of-ethereum-part-2-the-surge/4471" target="_blank">volgende upgrade gericht op het verbeteren van de schaalbaarheid van het netwerk</a> door middel van laag-2 oplossingen en rollups zonder in te leveren op decentralisatie, beveiliging en interoperabiliteit. Zoals gezegd is een van de belangrijkste doelen van de groei om 100.000 TPS te bereiken over laag-1 en laag-2 netwerken. Op dit moment verwerkt <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> 5-30 TPS op zijn basislaag. Dit veroorzaakt echter vaak congestie en een piek in gasvergoedingen tijdens piekuren. Volgens de rollup-gerichte routekaart streeft de Surge ernaar dergelijke knelpunten te verwijderen en de mogelijkheid van de blockchain om verschillende wereldwijde toepassingen van grote schaal te ondersteunen verder te verbeteren.</p>
<p>Na de Surge zal Ethereum waarschijnlijk zijn pieknetwerkprestaties bereiken en de wereldwijde gemeenschap beter van dienst zijn dan nu. Een van de kernonderdelen van deze netwerkupgrade is sharding, een gedecentraliseerde technologie die de blockchain zal verdelen in kleinere en hanteerbare eenheden genaamd shards. Volgens de medeoprichter van Ethereum zal de Surge een meerstappenproces zijn dat doorbraaktechnologieën zoals multi-party computation (MPC) en Layer 2 rollups integreert. Het zijn deze technologieën die de beveiliging, schaalbaarheid en bruikbaarheid van de netwerken zullen verbeteren om te voldoen aan de groeiende vraag naar zijn producten en diensten.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/possible-futures-of-the-ethereum-protocol-part-3-the-scourge/4551" target="_blank">Mogelijke toekomstscenario’s van het Ethereum-protocol</a></p>
<h2 id="h2-Ethereum20Surge20Rollupcentric20Roadmap20en20de20Componenten20ervan271151"><a name="Ethereum Surge Rollup-centric Roadmap en de Componenten ervan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum Surge Rollup-centric Roadmap en de Componenten ervan</h2><p>Zoals hierboven aangegeven, heeft de Surge tot doel de schaalbaarheid van Ethereum te vergroten door middel van layer-2-integratie en andere technologieën zoals sharding en roll-ups. Het richt zich ook op gegevenscompressietechnieken en gegevensbeschikbaarheidsonderzoek waarop we ons zullen richten in dit gedeelte.</p>
<p>-Layer-2 Scaling Solutions: Layer-2 roll-ups zullen de Ethereum blockchain kosteneffectief maken en sneller dan het nu is. In feite bundelen de layer-2 roll-ups transacties en verwerken ze deze buiten de keten voordat ze het eindrapport naar de gedecentraliseerde basislaag sturen. Door een groot deel van de transactiegegevens van de Ethereum blockchain buiten de keten te verwerken, kan het netwerk het doel van 100.000 TPS bereiken. Op dezelfde manier verdeelt de roll-up technologie de taken tussen layer-2 netwerken en de hoofdketen. Hierdoor vermindert het multi-chain ecosysteem de belasting van de hoofdketen, wat resulteert in efficiëntere en snellere transacties dan voorheen.</p>
<p>-Gegevensbeschikbaarheidssteekproef: De Ethereum Surge heeft ook als doel het probleem van gegevensbeschikbaarheid op te lossen. Het team <a href="https://www.gate.io/learn/articles/data-availability-sampling-why-is-das-needed/1282 &quot;will adopt Data Availability Sampling (DAS" rel="nofollow noopener noreferrer" target="_blank">zal Data Availability Sampling (DAS) aannemen</a> DAS stelt knooppunten in staat om gegevens efficiënt te verifiëren zonder deze te downloaden. In een gedecentraliseerd netwerk zoals Ethereum moeten alle knooppunten de beschikbare gegevens verifiëren. Het wordt echter moeilijk als van de knooppunten wordt verwacht dat ze alle beschikbare gegevens downloaden en opslaan. Dit is waar DAS van pas komt, waardoor de knooppunten de gegevens kunnen verifiëren zonder deze volledig op te slaan. Om dit te bereiken, zal het team het aantal blobs dat aan een blok is gekoppeld, verhogen. De ontwikkelaars stellen voor om het aantal blobs te verhogen van 3 naar 64, of zelfs meer. DAS zal de efficiëntie van layer-2 oplossingen verbeteren, wat hun transactievolumes zal verhogen.</p>
<p>-Gegevenscompressietechnieken: de gegevenscompressietechniek heeft tot doel de omvang van de transactie te verkleinen. Dit kan op verschillende manieren worden bereikt, waaronder het aannemen van compressie van null-bytes, het gebruik van BLS-handtekeningen en het vervangen van transactieadressen door pointers naar historische gegevens. De BLS-handtekeningen vergemakkelijken het bundelen van meerdere handtekeningen in één enkele. Dit bespaart ruimte op het netwerk en maakt transacties sneller en efficiënter.</p>
<h2 id="h2-Ethereum20Surge20Overkomen20van20uitdagingen20bij20het20verhogen20van20de20Gaslimiet401462"><a name="Ethereum Surge: Overkomen van uitdagingen bij het verhogen van de Gaslimiet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum Surge: Overkomen van uitdagingen bij het verhogen van de Gaslimiet</h2><p>Buterin legde een belangrijke reden uit voor de Ethereum Surge-upgrade. Het zal de schaalbaarheid van de basisschil vergroten, zodat het de prestaties in evenwicht brengt met die van laag-2 oplossingen. Dit zal resulteren in uniforme cross-L2-standaarden, wat zal leiden tot operationele efficiëntie. Het is opmerkelijk dat als de laag-2 blockchains aanzienlijk schalen terwijl laag-1 niet kan omgaan met het niveau van transacties, dit een risico kan vormen voor het netwerk. De belangrijkste oplossing om met het risico om te gaan, zou zijn om de gasvergoedingen te verhogen. Dit kan echter leiden tot centralisatie van de gaslimiet. Als de gaslimiet bijvoorbeeld te hoog is, zal dit leiden tot hoge kosten voor het uitvoeren van knooppunten, wat kleinere validators uit het systeem kan dwingen. Als gevolg hiervan zullen slechts enkele gecentraliseerde validators de hoge belasting verwerken.</p>
<p>Om deze uitdaging te overwinnen, suggereert Buterin dat het netwerk een geschikte aanpak moet gebruiken. Een van de zekerste manieren om deze uitdaging te overwinnen, is bijvoorbeeld om de <a href="https://www.gate.io/learn/articles/what-is-evm/68 &quot;Ethereum Virtual Machine (EVM" rel="nofollow noopener noreferrer" target="_blank">Ethereum Virtual Machine (EVM)</a>”), het onderdeel van de blockchain waar slimme contracten worden uitgevoerd. De introductie van het Ethereum Object Format (EOF), een nieuw bytecode-formaat, zal de uitvoering van slimme contracten efficiënt en snel maken. Ook zal dit helpen om de gas kosten te verlagen. Een andere manier om de kosten te verlagen is door het aannemen van een multidimensionaal gasprijs systeem dat de gasvergoedingen voor andere operaties zal verminderen. Zo kan bijvoorbeeld de gasvergoedingen voor specifieke opcodes en precompiles worden verminderd. Daarnaast kunnen er verschillende tariefniveaus zijn voor gegevens, berekeningen en opslag. Zo zal het multidimensionale gasprijs systeem helpen om het verschil in schaalbaarheidsniveaus tussen de hoofdchain en laag-2 oplossingen te verlichten.</p>
<h2 id="h2-Ethereum20naar20een20hoger20niveau20tillen20de20behoefte20aan20blockchaininteroperabiliteit337110"><a name="Ethereum naar een hoger niveau tillen: de behoefte aan blockchain-interoperabiliteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum naar een hoger niveau tillen: de behoefte aan blockchain-interoperabiliteit</h2><p>In zijn blog sprak Buterin ook over de noodzaak om van de Ethereum blockchain een verenigd systeem te maken waarbij layer-2 blockchains efficiënt met elkaar en de gedecentraliseerde basissysteem communiceren. Op dit moment is het Ethereum ecosysteem gefragmenteerd omdat de verschillende layer-2 blockchains verschillende unieke mogelijkheden en functies hebben. Dit leidt vaak tot verwarring en verdeeldheid onder de Ethereum gebruikers. Daarom stelt Buterin zich een toekomst voor waarin de L2 blockchains naadloos met elkaar communiceren.</p>
<h2 id="h2-Conclusie58309"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De mede-oprichter van Ethereum, Vitalik Buterin, heeft uiteengezet hoe de blockchain binnen de komende twee jaar 100.000 TPS kan bereiken. Volgens hem zullen roll-ups, gegevensbeschikbaarheidssteekproeven en gegevenscompressie de hoofdketen in staat stellen te schalen. De ontwikkelaars zullen in 2025 de Surge-upgrade lanceren, waardoor de schaalbaarheid van de blockchain wordt vergroot en de gasvergoedingen worden verlaagd.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>