RXRoZXJldW0ncyBQZWN0cmEgVXBncmFkZTogV2F0IGlzIGVyIG5pZXV3IG9wIGhldCBnZWJpZWQgdmFuIGdhc2tvc3RlbiBlbiBzdGFraW5nPw==

<p><img src="https://gimg2.gateimg.com/image/article/17303422161692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR241900"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Na de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Pectra-upgrade validators kunnen tussen 32 ETH en 2.048 ETH inzetten.</p>
<p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Accounts zullen functioneren als slimme contracten die bepaalde gespecialiseerde functionaliteiten kunnen uitvoeren.</p>
<p>Het team kan de Pectra-upgradeserie lanceren in 2025 en 2026.</p>
<h2 id="h2-Introductie472906"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is een van de toonaangevende blockchains die de afgelopen jaren verschillende upgrades heeft gelanceerd. Toch heeft het nog meer andere blockchain-verbeteringen te maken tussen nu en 2026. De ontwikkelaars lanceerden <a href="https://www.gate.io/learn/articles/an-in-depth-analysis-of-the-post-dencun-upgrade-era-data-and-investment-perspectives/2498" target="_blank">Dencun in maart</a> en <a href="https://www.gate.io/learn/articles/all-you-need-to-know-about-the-ethereum-shapella-upgrade/518" target="_blank">Shapella in 2023</a>. De volgende upgrade is Pectra, die dit jaar of begin 2025 zal worden gelanceerd. Deze verbetering zal enkele van de dringende uitdagingen aanpakken waarmee de Ethereum-gemeenschap wordt geconfronteerd.</p>
<h2 id="h2-Korte20introductie20van20Ethereums20aankomende20Pectraupgrade777361"><a name="Korte introductie van Ethereum’s aankomende Pectra-upgrade" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Korte introductie van Ethereum’s aankomende Pectra-upgrade</h2><p>De Pectra-upgrade <a href="https://www.gate.io/learn/articles/ethereum-pectra-the-next-major-upgrade/4407" target="_blank">komt een paar maanden na de lancering van “Dencun”</a>,” een samensmelting van Deneb en <a href="https://www.gate.io/learn/articles/overview-of-ethereum-cancun-upgrade/2122" target="_blank">Cancun-upgrades</a>, die plaatsvond in maart 2024. Het doel was om transactiekosten voor laag-2 blockchains te verlagen en de schaalbaarheid van de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain te verbeteren. Net als Dencun combineert Pectra twee upgrades - de Praag-upgrade en de Electra-upgrade. Pectra zal naar verwachting in 2025 live gaan. Deze upgrade is gericht op het verbeteren van de prestaties van de consensuslaag en de uitvoeringslaag. Hoewel het verschillende voorstellen heeft, zullen sommige ervan worden geïmplementeerd tijdens de tweede fase van Pectra.</p>
<h2 id="h2-Pectra20Upgrade20Een20tweedelige20serie512989"><a name="Pectra Upgrade: Een tweedelige serie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pectra Upgrade: Een tweedelige serie</h2><p>De Ethereum-ontwikkelaars hebben de split gemaakt <a href="https://www.gate.io/learn/articles/interpretation-of-pectra-the-next-upgrade-of-ethereum/3298" target="_blank">Pectra-upgrade</a> vanwege het grote aantal essentiële aspecten die het wil oplossen, wordt het opgedeeld in twee reeksen. Het kan een zeer complexe taak worden om aan alle voorstellen tegelijk te werken. Als gevolg daarvan zullen de ontwikkelaars dit jaar werken aan het eerste deel voordat ze zich in 2025 op het andere deel richten. De belangrijkste problemen van de Ethereum Pectra-upgrade zijn onder andere EIP-7702, bedoeld om het gebruik van alleen ETH-gasvergoedingen te elimineren, en (EIP-7251), gericht op het herstructureren van staking-beloningen voor Ethereum-validatoren.</p>
<h2 id="h2-EIP770220Eliminatie20van20alleenETHgasheffingen779883"><a name="EIP-7702: Eliminatie van alleen-ETH-gasheffingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>EIP-7702: Eliminatie van alleen-ETH-gasheffingen</h2><p>De Pectra Upgrade EIP-7702 is ontworpen om de prestaties van Ethereum digitale portefeuilles te verbeteren door ze veiliger en gemakkelijker in gebruik te maken. In feite zal de upgrade resulteren in account abstractie, wat betekent dat ze functioneren als slimme contracten. Hierdoor zullen enkele van de uitdagingen die gebruikers momenteel ervaren worden geëlimineerd. Momenteel moeten crypto gebruikers bijvoorbeeld ETH bewaren om te gebruiken als transactiekosten. Dit komt omdat ETH vereist is wanneer Ethereum portefeuilles communiceren met gedecentraliseerde applicaties.</p>
<p>Na de Pectra Upgrade kunnen Ethereum walletgebruikers echter andere activa gebruiken om transactiekosten te betalen. Bijvoorbeeld, zij kunnen USDC of DAI gebruiken. Dus, het token dat wordt overgedragen kan bepalen welk activum wordt gebruikt om de gasvergoedingen te betalen. Dit zal het netwerk zeer gebruiksvriendelijk maken. Aangezien gebruikers meer controle hebben over hoe hun portefeuilles zullen werken, kunnen ze bepaalde functies autoriseren. Als voorbeeld kunnen ze batchtransacties uitvoeren of een andere Ethereum wallet-account inschakelen om een bepaalde ETH gasvergoeding te betalen.</p>
<p>Een voordeel van EIP 7702 is de mogelijkheid voor gebruikers om meer controle te hebben over de functionaliteiten van de Ethereum-portefeuilles. Bijvoorbeeld, gebruikers kunnen hun accounts gebruiken om verschillende slimme contracten te implementeren en beheren. Dit zal de manier waarop ze interageren met verschillende gedecentraliseerde applicaties (DApps) vereenvoudigen. Dergelijke functionaliteiten zullen de noodzaak voor Ethereum-gebruikers om meerdere accounts te bezitten, elimineren. Over het algemeen zal EIP 7702 gebruikers controle geven over hun accountactiviteiten en de beveiliging van hun transacties verbeteren.</p>
<h2 id="h2-EIP725120Verbeteringen20in20Staking20Rewards20voor20Validators634334"><a name="EIP-7251: Verbeteringen in Staking Rewards voor Validators" class="reference-link"></a><span class="header-link octicon octicon-link"></span>EIP-7251: Verbeteringen in Staking Rewards voor Validators</h2><p>EIP-7251 zal Ethereum stakers en validators op verschillende manieren ten goede komen. Na de Ethereum Pectra-upgrade zal er een aanpassing zijn van het inzetbedrag en de beloningen voor validators. Elke validator kan specifiek tussen 32 ETH en 2.048 ETH inzetten en evenredige inzetbeloningen ontvangen. Deze ontwikkeling stelt sommige validators in staat om hun ingezette ETH in minder accounts te consolideren. Hierdoor wordt het aantal Ethereum validators verminderd.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/semantics-of-staking-2-re-staking/2026" target="_blank">Semantiek van Staking 2: Opnieuw staken</a></p>
<p>EIP-7702 zal de validators in staat stellen om evenredige stakingsbeloningen te verdienen van de vergrendelde ETH. Momenteel verdienen de validators die meer dan 32 ETH hebben gestaked alleen stakingsbeloning voor 32 ETH. Om een ​​voorbeeld te geven, een investeerder die 48 ETH heeft gestaked, krijgt alleen een stakingsbeloning voor 32 ETH. Dat is een groot verschil dat EIP-7702 zal aanpakken. Over het algemeen zou dit veel Ethereum-investeerders moeten motiveren om meer ETH te staken dan ze momenteel kunnen doen. Wat dit ook betekent, is dat grote validators in de nabije toekomst minder nodes kunnen exploiteren dan nu.</p>
<p>Het is ook belangrijk om op te merken dat de succesvolle lancering van EIP-6110 en EIP-7002 zal leiden tot volledig geautomatiseerde en toestemmingsloze ETH-stakepools. Met andere woorden, het systeem zal alle validators accepteren die voldoen aan de vooraf ingestelde voorwaarden van een stakepool, zoals een minimum van 32 ETH. Dit is anders dan het huidige systeem waar sommige medewerkers handmatig enkele taken uitvoeren, zoals het storten en opnemen van fondsen.</p>
<h2 id="h2-De20voordelen20afgeleid20van20Ethereumupgrades910595"><a name="De voordelen afgeleid van Ethereum-upgrades" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De voordelen afgeleid van Ethereum-upgrades</h2><p>De Ethereum Pectra zal vele voordelen bieden voor de algemene gebruikers en investeerders. Bijvoorbeeld, account abstractie zal de gebruikers in staat stellen om soepel te communiceren met verschillende gedecentraliseerde applicaties. Ook zullen de gebruikers in staat zijn om de gasvergoedingen te betalen met verschillende digitale activa. Dat zal de noodzaak voor de gebruikers om ETH in hun accounts te houden voor gasvergoedingen wegnemen. De aangepaste beveiligingsopties zullen waarschijnlijk de veiligheid van digitale activa op het Ethereum-netwerk verbeteren.</p>
<p>De stakers zullen waarschijnlijk meer verdienen aan hun gestakede ETH. Dit komt doordat de solo-stakers meer kunnen inzetten dan de vereiste minimum van 32 ETH. Bovendien krijgen ze stakingbeloningen die evenredig zijn met het bedrag dat ze hebben vergrendeld. Op dezelfde manier zal het feit dat de stakers tussen 32 en 2.048 kunnen inzetten het aantal validators verminderen. Een afname van validators zal de prestaties van het Ethereum-netwerk verbeteren. De reden hiervoor is dat te veel validators het netwerk vertragen, omdat er een hoog niveau is van peer-to-peer berichtenverkeer. Door validators samen te voegen, wordt het netwerk minder kostbaar en efficiënter dan het nu is.</p>
<p>Het succes van de aankomende Ethereum-updates kan leiden tot een stijging van de netwerkactiviteit, wat kan leiden tot een grotere instroom van fondsen in het ecosysteem. Bovendien kan dit ook leiden tot een positief marktsentiment dat kan leiden tot toekomstige <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETH crypto</a> prijsstijgingen. Echter is de mogelijkheid van een <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETH prijs</a> De stijging zal waarschijnlijk afhangen van hoe de upgrades de Ethereum blockchain technologie verbeteren en de perceptie van investeerders over de ontwikkeling.</p>
<h2 id="h2-Conclusie303494"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De Ethereum Pectra-upgrade zal waarschijnlijk veel voordelen opleveren, zoals een evenredig rendement op ingezette ETH. Ook zullen de Ethereum-portefeuilles fungeren als slimme contracten waarmee de gebruikers batchtransacties kunnen verwerken en enkele dApps kunnen inzetten. De gebruikers zullen in staat zijn om gaskosten te betalen met behulp van verschillende <a href="https://www.gate.io/learn/articles/what-is-dai/178" target="_blank">cryptocurrencies zoals DAI</a> en USDC. Uiteindelijk kan de consolidatie van validators leiden tot een efficiënter Ethereum-netwerk.</p>
<h2 id="h2-Veelgestelde20vragen20over20de20Ethereum20Pectraupgrade951898"><a name="Veelgestelde vragen over de Ethereum Pectra-upgrade" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over de Ethereum Pectra-upgrade</h2><h3 id="h3-Wat20is20de20Ethereum20Praag20upgrade890442"><a name="Wat is de Ethereum Praag upgrade?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de Ethereum Praag upgrade?</h3><p>De Ethereum Praag-upgrade is een hard fork voor de Ethereum blockchain die is ontworpen om veranderingen aan te brengen in de uitvoeringslaag van het netwerk. Zo zal het bijvoorbeeld sharding introduceren om de schaalbaarheid en efficiëntie van de blockchain te verbeteren.</p>
<h3 id="h3-Wat20is20Pectra20Ethereum678255"><a name="Wat is Pectra Ethereum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Pectra Ethereum?</h3><p>Pectra Ethereum is een Ethereum blockchain hard fork die is ontworpen om veranderingen aan de consensuslaag aan te brengen. Het doel van deze upgrade is om de schaalbaarheid, veiligheid en efficiëntie van het netwerk te verbeteren.</p>
<h3 id="h3-Wat20is20de20Ethereum20upgrade202025981071"><a name="Wat is de Ethereum upgrade 2025?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de Ethereum upgrade 2025?</h3><p>Pectra is een Ethereum-upgrade die in 2025 zal worden gelanceerd. Het is ontworpen om veranderingen aan te brengen in de consensuslaag van de blockchain om de schaalbaarheid, efficiëntie en veiligheid te verbeteren.</p>
<h3 id="h3-Wat20is20een20Ethereumupgrade242659"><a name="Wat is een Ethereum-upgrade?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een Ethereum-upgrade?</h3><p>Een Ethereum-upgrade is een verandering van de manier waarop de belangrijkste functies of componenten functioneren om de prestaties van het netwerk te verbeteren. De ontwikkelaars werken bijvoorbeeld aan het lanceren van enkele upgrades die de prestaties van de Ethereum-consensuslaag en uitvoeringslaag verbeteren.</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 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 juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>