T250ZGVra2luZyB2YW4gZGUgRXRoZXJldW0gQ2FuY3VuLXVwZ3JhZGUgLSBkZSB2b2xnZW5kZSBrYW5zIHZhbiAxMDAgbWlsamFyZCBtYXJrdGthcGl0YWxpc2F0aWU/

2024-01-30, 03:02

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR856412"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Na een jaar van onderdrukking begint <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> eindelijk een nieuw verhaal te vertellen. Het Goerli-testnetwerk voor de upgrade van KanKun is succesvol voltooid en de upgrade van het mainnet wordt naar verwachting eind februari voltooid.</p>
<p>Het meest opvallende is het EIP-4844-voorstel, waarbij ontwikkelaars proberen om door middel van een nieuwe transactietype genaamd Blob meer ruimte te bieden voor schaalbaarheid op de blockchain en zo de transactiekosten van Layer 2 blockchains te verlagen.</p>
<p>Ethereum Layer2, gegevensbeschikbaarheidslaag, gedecentraliseerde opslag en verschillende DAPP’s in verschillende gebieden kunnen profiteren van deze upgrade.</p>
<h2 id="h2-Inleiding920384"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Na goedkeuring van de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF voor contanten werd Ethereum, dat een jaar lang onderdrukt was, langzaam een centraal gespreksonderwerp: de lancering van een Ethereum ETF in mei, de upgrade naar Cancun en Restaking, en vooral opvallend is de eerste upgrade naar Cancun die zal plaatsvinden. Dit artikel zal de planning, het thema van de upgrade naar Cancun en de impact ervan op de toekomstige markt bespreken.</p>
<h2 id="h2-Cancun20Upgradetijdlijn576415"><a name="Cancun Upgradetijdlijn" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cancun Upgradetijdlijn</h2><p>Eigenlijk heeft de Ethereum Foundation al in april vorig jaar besloten tot de volgende belangrijke wijziging, namelijk de Cancun-upgrade. Destijds werd verwacht dat het plan officieel zou worden gelanceerd in november van dat jaar tijdens de 160e kernontwikkelaars-teleconferentie.</p>
<p>Maar vanwege technische problemen werd het uitgesteld tot eind 2023. In feite werd het later uitgesteld tot 2024 vanwege het mislukken van de testnetlancering in september en het ontbreken van de Holesky-release van de Cancun-upgrade in oktober.</p>
<p>Op 28 december vorig jaar publiceerde Vitalik een artikel met de titel ‘Make ‘. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> In zijn artikel ‘Cypherpunk Again’ deelde hij zijn visie op de toekomst van cryptocurrencies.</p>
<p>Hij benadrukte dat een van de belangrijkste redenen voor de beperking van de huidige blockchain-technologie de voortdurende stijging van transactiekosten is. Hoge netwerktransactiekosten maken mensen meer geneigd om speculanten van blockchain-netwerken te worden, in plaats van echte gebruikers. Om de brede toepassing en implementatie van blockchain-technologie te realiseren, moeten de transactiekosten aanzienlijk worden verlaagd. Hoewel de opkomst van Layer 2 de netwerkkosten heeft verlaagd, is het nog steeds niet genoeg in vergelijking met het Ethereum-mainnet.</p>
<p>Daarom is Vitalik van mening dat Ethereum meer maatregelen moet nemen om transactiekosten te verlagen om de adoptie en toepassing van blockchain-technologie te bevorderen. Dit artikel kan worden beschouwd als de toon van Vitalik voor de KanKun-upgrade.</p>
<p>Onlangs is het schema eindelijk vastgesteld. Op 4 januari ‘s avonds vond de online vergadering van de Ethereum Core Developers (ACDE #178) plaats. Tijdens deze vergadering werd de voorgestelde planning voor de upgrade van het Dencun testnetwerk, die op 21 december tijdens ACDE #177 werd voorgesteld, definitief bevestigd. Er werd ook prioriteit gegeven aan de discussie over de plannen voor de Pectra-upgrade.</p>
<p>Volgens de vergadering op het Goerli-testnet is de Dencun-upgrade op 17 januari voltooid en is de normale werking succesvol hersteld. Vervolgens zullen ontwikkelaars respectievelijk op 30 januari en 7 februari upgrades uitvoeren op het Sepolia-testnet en het Holesky-testnet.<img src="https://gimg2.gateimg.com/image/article/1706583514img_v3_027j_68f41087-70d7-4609-b494-3fb42ca8d6ix.jpg" alt=""><br>Ontwikkelaars kondigen het succes van het goerli-testnetwerk aan Figuur 1 Bron: @parithosh_j</p>
<p>Zodra de bovengenoemde drie testnetwerken soepel draaien, zal snel de lancering van het mainnet worden gepland.</p>
<p>Maar de meeste ontwikkelaars vinden dat dit tijdschema een beetje krap is, bijvoorbeeld ontwikkelaar potuz1 heeft hier twijfels over geuit, en vindt dat de upgrade-interval (13 dagen) tussen de Goerli-testnet en het Sepolia-testnet te kort is, mogelijk niet genoeg om potentiële problemen te observeren.</p>
<p>Het is vermeldenswaard dat in de notulen van de lightclient geen tijdsplanning voor de upgrade van het mainnet wordt vermeld. Maar tijdens de discussie in ACDE #177 hebben de ontwikkelaars gesproken over het implementeren van deze upgrade op het mainnet eind februari. Aangezien ACDE #178 de tijdplanning voor de upgrade van het testnet niet heeft uitgesteld, kunnen we nog steeds aan deze verwachting voldoen.</p>
<h2 id="h2-De20EIP484420die20zich20richt20op20kostenverlaging20en20capaciteitsuitbreiding20is20een20belangrijke20upgrade20van20de20kern694036"><a name="De EIP-4844, die zich richt op kostenverlaging en capaciteitsuitbreiding, is een belangrijke upgrade van de kern." class="reference-link"></a><span class="header-link octicon octicon-link"></span>De EIP-4844, die zich richt op kostenverlaging en capaciteitsuitbreiding, is een belangrijke upgrade van de kern.</h2><p>Sterker nog, al eind september vorig jaar verscheen onze blogpost “ <a href="https://www.gate.io/blog_detail/3253/%E9%9D%A2%E4%B8%B4%E6%8E%A8%E8%BF%9F%E7%9A%84%E5%9D%8E%E6%98%86%E5%8D%87%E7%BA%A7-%E8%BF%98%E8%83%BD%E5%B8%A6%E6%9D%A5%E5%93%AA%E4%BA%9B%E6%8A%95%E8%B5%84%E6%9C%BA%E4%BC%9A" target="_blank">Welke investeringsmogelijkheden kan de uitgestelde upgrade van Cancun nog opleveren?</a> In het vorige artikel zijn de belangrijkste punten van de upgrade van Cancun kort beschreven, en in dit artikel zullen we dit nogmaals in eenvoudige bewoordingen uitleggen.</p>
<p>Deze upgrade wordt zeer verwacht door de Ethereum gemeenschap, omdat het een cruciale rol zal spelen bij het schalen van Ethereum, inclusief het verlagen van de kosten en het verbeteren van de efficiëntie van Layer2, wat de concurrentiekracht van Ethereum op Layer2 aanzienlijk zal versterken.</p>
<p>Van de vijf betrokken Ethereum Improvement Proposals (EIP’s) zijn de meest besproken voorstellen onder andere EIP-4844, EIP-1153 en EIP-4788.</p>
<p>EIP-4844 is het kernvoorstel voor deze upgrade en is essentieel voor het schalen van Ethereum. Kort gezegd proberen ontwikkelaars meer schaalbaarheid te realiseren door een nieuwe transactietype genaamd Blob te introduceren, wat meer ruimte biedt voor uitbreiding van de blockchain en zo de transactiekosten van Layer 2 blockchains verlaagt.<img src="https://gimg2.gateimg.com/image/article/1706583576img_v3_027j_3f748c9e-9be2-4355-94c6-7982b2a711ix.jpg" alt=""><br>Vergelijkende grafiek van L2-kosten 2 Bron: l2fees.info</p>
<p>Het oorspronkelijke plan van Ethereum om de transactieverwerkingssnelheid te verhogen door middel van sharding-technologie bleek moeilijk te ontwikkelen en maakte langzaam vorderingen. In vergelijking daarmee heeft het schaalvergrotingsplan Rollup zich snel ontwikkeld en voldaan aan een deel van de schaalvergrotende behoeften, wat heeft geleid tot de verschuiving van Ethereum naar datafragmentatie gericht op Rollup. De upgrade van Dencun zal Proto-Danksharding introduceren, waarbij blob als eerste in de blokruimte wordt geïntroduceerd om de kosteneffectiviteit van gegevensbeschikbaarheid te optimaliseren en de schaalbaarheid van L2 te verbeteren.</p>
<p>Proto-Danksharding is not only the core content of Dencun upgrade, but also the first step of comprehensive expansion of Ethereum. It lays the foundation for subsequent realization of complete Danksharding, separation of block proposers and builders, and sampling of data availability. <img src="https://gimg2.gateimg.com/image/article/1706583603img_v3_027j_6573ec2c-54ec-47ce-a3d4-3f17e2ca76ix.jpg" alt=""><br>Veranderingen in blokupgrades Figuur 3 Bron: a16zcrypto.com</p>
<p>Volgens een voorlopige schatting van marktwaarnemers kunnen de transactiekosten met 10-100 keer worden verlaagd.</p>
<p>Hierdoor is de titel van het verbeteringsprotocol van EIP-4844 gewijzigd van ‘Proto-danksharding’ naar ‘Shard Blob-transacties’, oftewel ‘Shard Blob-transacties’.</p>
<p>Daarnaast zijn er nog andere belangrijke voorstellen:</p>
<p>EIP-1153 voegt een tijdelijke opslag opcode toe om het probleem van interne communicatie in blokken op te lossen, met als voordeel een lagere Gas Fee.</p>
<p>EIP-6780 wijzigt de functionaliteit van de SELFDESTRUCT opcode ter voorbereiding op de Verkle Tree-architectuur van toekomstige Ethereum-toepassingen.</p>
<p>EIP-4788 maakt de wortel van de beacon chain blokken openbaar in de Ethereum Virtual Machine, wat helpt bij het ontwikkelen van use cases en het verbeteren van het protocol.</p>
<p>EIP-5656 introduceert de MCOPY-instructie, die wordt gebruikt om geheugenruimte te kopiëren en nuttig is voor bewerkingen met een grote berekening.</p>
<p>EIP-7516 introduceert de BLOBBASEFEE opcode en retourneert de basisvergoeding voor Blob volgens het EIP-4844-protocol.</p>
<h2 id="h2-Welke20sectoren20zullen20profiteren20van20de20upgrade20van20Cancun483765"><a name="Welke sectoren zullen profiteren van de upgrade van Cancun?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke sectoren zullen profiteren van de upgrade van Cancun?</h2><p>Met de verbetering van de efficiëntie van gegevensopslag en de verlaging van de kosten, zullen de gasvergoedingen voor Layer2-gebruikers ook worden verlaagd. Deze verandering zal meer aandacht trekken voor Ethereum Layer2, de laag voor gegevensbeschikbaarheid, gedecentraliseerde opslag en diverse soorten DAPP’s, en deze gebieden kunnen betere ontwikkelingsmogelijkheden krijgen als gevolg van de verlaging van de gasvergoedingen.</p>
<p><strong>L2 public chain</strong><br>Arbitrum blijft de leider op de Ethereum L2-markt en… <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> Elke heeft zijn eigen concurrentievoordeel. Arbitrum loopt voorop in protocoldiversiteit op basis van Arbitrum One, terwijl <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> voorop loopt in de diversiteit van het inter-ecosysteem op basis van OP Stack.<br><img src="https://gimg2.gateimg.com/image/article/1706583655img_v3_027j_2a943960-5d15-4c0e-8bb6-b499294b26ix.jpg" alt=""><br>ARBPrijs trend Figuur 4 Bron: Gate.io</p>
<p>Arbitrum heeft momenteel de meest uitgebreide protocolcategorieën en de handelsvolumes zijn 3 keer hoger dan die van Optimism. Daarom zal het, gezien de hoge handelsvolumes en TPS-optimalisatie van Arbitrum, een van de grootste begunstigden zijn van de upgrade van Dencun. Arbitrum promoot ook actief de talen Arbitrum Orbit en Stylus om het netwerkeffect te versterken.</p>
<p>Optimism richt zich op het bouwen van het Optimism SuperChain-netwerk op basis van de OP Stack, waarvan de waarde nauw verbonden is met de netwerkwaarde van het netwerk. Optimism profiteert van een upgrade-premie in combinatie met de netwerkwaarde van zijn ecosysteem. Als de upgrade van Dencun meer nieuwe L2’s voortbrengt, kunnen deze nieuwe L2’s ervoor kiezen om OP Stack te gebruiken en Optimism dichter bij zijn ultieme visie van een super-ecosysteem brengen.</p>
<p><strong>Cloudopslag</strong><br>Het is te voorzien dat de upgrade van Cancun zal leiden tot <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a>、 <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a> Oudere gedecentraliseerde opslagprojecten zoals Storj brengen meer praktische behoeften voor gedecentraliseerde opslag. In feite kan Arweave, dat zich richt op eenmalige betaling en permanente opslag, mogelijk een deel van de L2-statusgegevens die door blob zijn verlaten opvangen, en zo meer groei realiseren in het opslaan van L2-statusgegevens.</p>
<p><strong>Sorteermachine</strong><br>Het probleem met een gecentraliseerde sorter is altijd een punt van kritiek geweest in de markt, en het heeft veel kritiek gekregen vanwege meerdere uitvaltijden tijdens de Mingwen-hype vorig jaar. De komende Dencun-upgrade kan het risico van single point of failure verergeren.</p>
<p>Om dit probleem op te lossen, neemt Metis innovatieve maatregelen en streeft ernaar de eerste gedecentraliseerde PoS-sorter op Ethereum L2 te worden. Nodes die 20.000 METIS-tokens inzetten, kunnen sorteerdiensten verlenen en moeten gezamenlijk ondertekenen om gegevens naar L1 te uploaden. Bovendien zorgt een steekproefonderzoek onder validators ervoor dat de transactievolgorde correct is.</p>
<p><strong>Een reeks DAPP’s gebaseerd op L2</strong><br>Sommige DeFi, DAO, Game, RWA-toepassingen op L2 zullen ook waardevermeerdering krijgen vanwege het lage kosten- en hoge efficiëntienetwerk. We hebben er al over gesproken in ‘Welke investeringsmogelijkheden kan de uitgestelde Cancun-upgrade nog bieden?’ en zullen het hier niet verder bespreken.</p>
<h2 id="h2-samenvatting235746"><a name="samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>samenvatting</h2><p>Na de voltooiing van de consensus upgrade in Parijs en de activarealisatie in Shanghai, zal Ethereum zich nu richten op het aanpakken van schaalbaarheidsproblemen tijdens de Cancun-upgrade. Op dit moment wordt de meest opvallende EIP4844 gebruikt om de gebruikerskosten te verlagen door middel van tijdelijke opslag en ophalen van gegevens buiten de keten, waardoor de schaalbaarheid en efficiëntie van Ethereum verder worden verbeterd.</p>
<p>Terugkeren naar de secundaire markt, eigenlijk hebben een reeks van Kan Kun-upgrade conceptmunten zoals ARB, OP en METIS onlangs een golf van enthousiasme gekend, maar recentelijk is er enige druk ontstaan door de neerwaartse druk van Bitcoin op deze sector.</p>
<p>Niettemin kijken we reikhalzend uit naar de komende upgrade van Cancun, terwijl Bitcoin ETF zich naar het grote publiek begeeft en de adoptiegraad in de echte wereld vergroot, geloven we dat de geleidelijke upgrade van Ethereum ook een bron van innovatieve dynamiek zal zijn voor de welvaart van de cryptomarkt.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Carl Y.</strong>, Gate.io Researcher<div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.<br>  </em><div><em></em>本文内容为原创，版权为Gate.io所有，如需转载请注明作者和出处，否则将追究法律责任。<br></div><p></p><br></div></div></div>