WmFsIFBhcmFsbGVsIEVWTSBlZW4ga2F0YWx5c2F0b3Igd29yZGVuIHZvb3IgZWVuIHN0aWVyZW5tYXJrdCBudSBkZSBwb3B1bGFyaXRlaXQgZXJ2YW4gbGFuZ3phYW0gdG9lbmVlbXQ/

2024-04-25, 09:50

<p><img src="https://gimg2.gateimg.com/image/article/1714038408sdfx.jpeg" alt=""></p>
<h2 id="h2-TLDR300391"><a name="[TL；DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]</h2><p>Onlangs ontving L1 openbare keten Monad een enorme financiering van $225 miljoen, geleid door Paradigm, wat de sterke aandacht van de markt vestigde op de parallelle EVM-technologie die door Monad wordt aangenomen.</p>
<p>Op dit moment kan parallelle EVM worden ingedeeld in vier categorieën, maar wat echt toegewijd is aan het consolideren van het EVM-ecosysteem en het veranderen van parallelle mogelijkheden van onderaf, is de verbeterde EVM-laag 1-keten. Dit is misschien ook de reden waarom Monad, dat onlangs deze oplossing heeft overgenomen, hoge investeringen heeft ontvangen in de durfkapitaalmarkt.</p>
<p>Parallel EVM zal de derde prestatieoptimalisatieoplossing worden na universele Rollup L2+Dapp, modulaire stack+Dapp Rollup (RollAPP), en zal veel technologische innovaties en grootschalige toepassingen voortbrengen.</p>
<h2 id="h2-Introductie598157"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Onlangs ontving L1 openbare keten Monad een enorme financiering van $225 miljoen onder leiding van Paradigm, wat de sterke aandacht van de markt vestigt op de parallelle EVM-technologie die in het project wordt gebruikt.</p>
<p>Parallel EVM heeft als doel de prestaties van EVM te verbeteren door parallelle verwerking om te gaan met de uitdagingen van high-performance Layer1-chains en de duurzame ontwikkeling van de te waarborgen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> EVM-ecosysteem.</p>
<p>Het verkennen van de uitbreiding van de prestaties van de keten is altijd een focus van aandacht geweest in de cryptomarkt, en dit artikel zal een voorlopige verkenning hiervan maken.</p>
<h2 id="h2-Parallel20EVM20De20ultieme20oplossing20voor20ketenschaalbaarheid20en20prestaties601195"><a name="Parallel EVM: De ultieme oplossing voor ketenschaalbaarheid en prestaties?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Parallel EVM: De ultieme oplossing voor ketenschaalbaarheid en prestaties?</h2><p>Al in 2021 was het begrip Parallel EVM ontstaan, met als kernidee om de gelijktijdige verwerking van meerdere transacties te ondersteunen, waardoor de prestaties en efficiëntie van de traditionele EVM worden geoptimaliseerd en verbeterd.</p>
<p>Op dat moment waren er al enkele representatieve praktijken in de industrie, zoals <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> Parallele EVM van ‘s werelds gebaseerd op Block STM-technologie, en de parallelle EVM ontwikkeld in samenwerking met BSC en NodeReal.</p>
<p>Tegen het einde van 2023 en de daaropvolgende maanden, raasde een golf van inschrijvingen door de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ecosysteem, met kapitaaluitstroom en FOMO-sentiment dat inies snel over andere chains laat verspreiden. Maar dit heeft ook een reeks problemen veroorzaakt. Door de toename van het aantal en de soorten inies, hebben veel blockchain-netwerken te maken met ernstige prestatieproblemen, laat staan grootschalige toepassingen die in de toekomst worden gecombineerd met de echte wereld.</p>
<p>Het is in deze context dat een nieuw verhaal dat nauw verbonden is met het optimaliseren van de prestaties van EVM geleidelijk opkomt - parallelle EVM.</p>
<p>Georgios Konstantopoulos, CTO van Paradigm, en Haseeb Qureshi, Dragonfly, noemden parallelle EVM als de sleutel tot het oplossen van prestatieknelpunten bij het vooruitkijken naar de trend in 2024.<br><img src="https://gimg2.gateimg.com/image/article/17140385121.jpeg" alt=""><br>Bron: @jdkanani</p>
<p>Er zijn verschillende optimalisatie-oplossingen geweest voor EVM, zoals sidechains, L2 en modulair. <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a>. Echter maakt parallelle EVM het mogelijk om verschillende onafhankelijke transacties of slimme contracten gelijktijdig uit te voeren, wat de verwerkingssnelheid en systeemdoorvoer van EVM aanzienlijk kan verbeteren. Daarom geven ontwikkelaars er ook de voorkeur aan en het heeft een hoog groeipotentieel.</p>
<p>Als we de marktwaarde van elke keten als voorbeeld nemen ter vergelijking, heeft de totale circulerende marktwaarde van L1 en L2 $752.123 miljard bereikt, wat behoorlijk aanzienlijk is. Echter, in vergelijking hiermee is de circulerende marktwaarde van parallelle blockchain slechts $52.539 miljard, wat slechts ongeveer 7% van de totale circulerende marktwaarde vertegenwoordigt, wat wijst op de relatief kleine schaal ervan in het gehele blockchain-veld.</p>
<p>Het is vermeldenswaard dat projecten die verband houden met parallelle EVM-verhalen een circulerende marktwaarde hebben van $2,339 miljard. Hoewel dit aantal niet klein is, vertegenwoordigt het slechts 4% van de circulerende marktwaarde van parallelle blockchain, wat aangeeft dat het marktaandeel ervan relatief klein is in dit specifieke gebied.<br><img src="https://gimg2.gateimg.com/image/article/17140385342.jpeg" alt=""><br>Bron: Gryphsis Academy</p>
<p>Over het algemeen, hoewel parallelle blockchain- en EVM-verhalen gerelateerde projecten zich ontwikkelen, is er nog enige ruimte voor verbetering in de totale marktomvang.</p>
<h2 id="h2-Vier20technische20paden20voor20parallelle20EVM188537"><a name="Vier technische paden voor parallelle EVM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vier technische paden voor parallelle EVM</h2><p>Op dit moment is er geen consensus in de sector over het implementatieplan van parallelle EVM, maar het kan worden onderverdeeld in vier categorieën op basis van technologieaanpassingstypes. Deze classificatie vereenvoudigt natuurlijk alleen ons begrip van het schema, en er zullen nieuwe perspectieven ontstaan naarmate de technologie wordt bijgewerkt en geïterat.</p>
<p>Ten eerste zijn geavanceerde EVM-laag1-ketens zoals Monad, Artela en SEI toegewijd aan het aanzienlijk verbeteren van TPS terwijl ze zeer compatibel zijn met EVM, en transacties voorzien van parallelle verwerkingsmogelijkheden in gesimuleerde EVM-omgevingen.<br><img src="https://gimg2.gateimg.com/image/article/17140385563.jpeg" alt=""><br>Bron: MONAD</p>
<p>Deze onafhankelijke parallelle EVM-laag1-ketens hebben unieke consensusmechanismen en technische kenmerken, maar hun belangrijkste doel blijft compatibel zijn en het EVM-ecosysteem uitbreiden. Deze aanpak kan worden gezien als het volledig opnieuw structureren van de EVM-keten terwijl het EVM-ecosysteem wordt bediend.</p>
<p>Ten tweede maken schaalbare layer2 EVM-compatibele ketens, zoals Eclipse en MegaETH, gebruik van de onafhankelijke consensus- en transactievoorbewerkingsmogelijkheden van layer2-ketens om transactiestatus te filteren en verwerken voordat ze batchgewijs worden verwerkt en naar het hoofdnetwerk worden verzonden.</p>
<p>Dit type oplossing maakt ook gelijktijdige selectie van uitvoeringslagen vanuit een andere keten mogelijk om uiteindelijk de transactiestatus te bepalen, om zo de abstractie en plugbare uitvoerings modulariteit van EVM te bereiken. Deze flexibiliteit stelt hen in staat om de optimale “uitvoeringslaag” te selecteren volgens hun behoeften, waardoor parallelle verwerkingsmogelijkheden worden bereikt.</p>
<p>Echter, hoewel dit type oplossing EVM bedient, gaat het verder dan de reikwijdte van traditionele EVM-kaders.</p>
<p>Het derde type is de equivalente Alt-layer1-keten, vertegenwoordigd door <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> en BSC. Deze ketens hebben tot op zekere hoogte de parallelle verwerkingsmogelijkheid van EVM bereikt, maar voornamelijk door optimalisatie op het algoritmeniveau, zonder in te gaan op optimalisatie op het consensusniveau en opslagniveau.</p>
<p>Ten slotte omvatten differentiële niet-EVM parallelle ketens <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a>, Sui, en Fuel, hoewel ze geen EVM-ketens direct implementeren, zijn compatibel met EVM-omgevingen door middleware of code-analyse vanwege hun hoge gelijktijdige uitvoeringsmogelijkheden. Als een Ethereum-laag 2 heeft Starknet parallelle mogelijkheden, maar compatibiliteit met EVM vereist nog steeds speciale mechanismen. Dit soort keten staat over het algemeen voor compatibiliteitsuitdagingen bij integratie met EVM.</p>
<p>Deze vier belangrijke oplossingen hebben elk hun nadruk, sommige benadrukken de flexibiliteit van laag 2, sommige benadrukken functieaanpassing, en sommige richten zich op het aantrekken van liquiditeit. Maar degenen die echt toegewijd zijn om het EVM-ecosysteem te consolideren en parallelle mogelijkheden vanaf de basis te veranderen, zijn de verbeterde EVM-laag 1 ketens. Dit is misschien ook de reden waarom Monad, dat onlangs deze oplossing heeft aangenomen, hoge investeringen heeft ontvangen op de durfkapitaalmarkt.</p>
<h2 id="h2-Kan20Parallel20EVM20een20nieuwe20verhaallijn20worden20die20de20bullmarkt20leidt11765"><a name="Kan Parallel EVM een nieuwe verhaallijn worden die de bullmarkt leidt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kan Parallel EVM een nieuwe verhaallijn worden die de bullmarkt leidt?</h2><p>Natuurlijk moeten we de concurrentie en uitdagingen zien waarmee het parallelle EVM-veld wordt geconfronteerd. Vanuit communicatieoogpunt is parallel EVM een veelbesproken onderwerp. Toch wijzigen en imiteren de meeste projectteams voornamelijk het OP-uitvoeringsmodel dat wordt vertegenwoordigd door Aptos’ Block STM-mechanisme zonder substantiële doorbraken gedurende lange tijd, wat het moeilijk maakt om populariteit te behouden.</p>
<p>Daarnaast zijn Layer 2 en blockchains van de tweede generatie zoals <a href="/price/aptos-apt" target="_blank" class="blog_inner_link">Aptos</a> en Sui sterke concurrenten. Ze hebben volwassen gemeenschappen en ecoen opgebouwd, wat aanzienlijke druk uitoefent op opkomende projecten. Dit biedt echter ook een kans voor parallelle EVM-projecten om te leren en te profiteren van, en om hun concurrentievermogen te versterken door middel van continue innovatie en optimalisatie.</p>
<p>Op het gebied van parallelle EVM zijn er weliswaar enkele technische overeenkomsten, zoals het OP-parallelisatiemodel dat de consensus vormt van de L1 openbare keten, maar verschillende projecten hebben ook unieke technische prestaties gedemonstreerd. Ze maken gebruik van verschillende architectonische ontwerppatronen, gegevensmodellen of voorverwerkingsmechanismen om de voortdurende vooruitgang van parallelle technologie te bevorderen.</p>
<p>Vooruitkijkend zal de golf van blockchaintechnologie meer L1- en L2-projecten stimuleren om te concurreren in parallelle EVM. Op dit spoor zal parallelle EVM de derde prestatieoptimalisatieoplossing worden na universele Rollup L2+Dapp en modulaire stack+Dapp Rollup (RollAPP), en zal het veel technologische innovaties en populaire toepassingen voortbrengen.<br><img src="https://gimg2.gateimg.com/image/article/17140385864.jpeg" alt=""><br>Bron: Eclipse</p>
<p>In deze context kunnen we voorzien dat Monad zal opvallen op basis van zijn voordelen in gespecialiseerde databases, ontwikkelaarsvriendelijkheid, uitgestelde uitvoeringsconsensus en superscaler pijplijn technologie. In de toekomst zullen soortgelijke en meer opvallende projecten opduiken en ze zullen opvallen in de concurrentie van parallelle EVM’s met hun unieke technologische voordelen en marktstrategieën. Deze projecten zullen ons meer innovatieve toepassingsglen brengen en de uitvoering van blockchain-technologie in verschillende gebieden bevorderen.</p>
<p>De verkenning van technologie is eindeloos, en parallelle EVM, als een belangrijk onderdeel van de huidige technologische innovatie, zal een steeds belangrijkere rol spelen. We kijken uit naar het zien van meer uitstekende projecten opkomen in dit vakgebied en samen een betere toekomst creëren voor blockchaintechnologie.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips">*Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br><div>*Gate.io behoudt alle rechten voorbehouden voor dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen in g van schending van het auteursrecht.<br></div>

<p></p><p></p></div><p></p><br></div></div></div><p></p>