V2F0IGlzIExhYWcgMyBEYXQgc3RlZWRzIHBvcHVsYWlyZGVyIHdvcmR0Pw==

2024-04-12, 09:56

<p><img src="https://gimg2.gateimg.com/image/article/1692587569kepu.jpeg" alt=""></p>
<h2 id="h2-TLDR817729"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De populariteit van Degen Chain en andere projecten heeft Layer 3 onder de aandacht gebracht en de opkomst van deze technologie zal zorgen voor een hogere schaalbaarheid en interoperabiliteit van blockchain-netwerken, met op maat gemaakte oplossingen voor verschillende toepassingsscenario’s.</p>
<p>Onder de opkomende Layer 3 use cases hebben Arbitrum Orbit en Starknet de meest opvallende prestaties laten zien en kunnen ze schitteren in gebieden zoals Game en DeFi.</p>
<p>Als laag 3 wil doorbreken, moet het blijven werken aan het verbeteren van de technologie en meer grootschalige toepassingen zoeken om de doorbraak te ondersteunen.</p>
<h2 id="h2-Introductie63753"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Op de dag voor 1 april van dit jaar maakten sommige encryptieprojecten gebruik van de thema’s Layer 4 en Layer 5 om grappige grappen te maken. Daaronder, <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a> maakte zelfs grappen over de inhoud van “de nieuwe versie zal gebouwd worden op L4”, wat sommige media zelfs misleidde en het als echt nieuws verspreidde.</p>
<p>En deze grap is natuurlijk gebaseerd op de toenemende populariteit van Laag 3. Wat betreft Laag 3, waar iedereen zich over het algemeen zorgen over maakt, is of het een inter-chain nesting pop is of een aangepaste uitbreiding, en of het potentieel heeft voor schaalbaarheid. Dit artikel zal zich richten op deze controverse om lezers te vermaken.</p>
<h2 id="h2-Laag20320is20populair20geworden20en20heeft20intense20gemeenschapsdebatten20veroorzaakt931735"><a name="Laag 3 is populair geworden en heeft intense gemeenschapsdebatten veroorzaakt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laag 3 is populair geworden en heeft intense gemeenschapsdebatten veroorzaakt</h2><p>Onlangs is de populariteit van Laag 3 aanzienlijk toegenomen en trekt het veel aandacht.</p>
<p>Vooral de uitstekende prestaties van Layer 3 tokens zoals Degen Chain, zoals de kortetermijnstijging van meer dan 150% door DEGEN, en de historische hoogtepunten van GHST-prijzen na de transformatie van Aavegotchi naar Base Series Layer 3, benadrukken verder het potentieel van Layer 3.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17129156241.jpg" alt=""><br>Bron: degen.tips</p>
<p>In de traditionele definitie is Laag 2 het afwikkelingsnetwerk op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> mainnet en heeft schaalbaarheid. Laag 3 daarentegen is gebouwd op laag 2 en vertrouwt erop voor afwikkeling, waardoor een meer schaalbaar netwerk wordt geboden.</p>
<p>Het concept van Laag 3 werd in eerste instantie voorgesteld door het Starknet (destijds StarkWare) team in het artikel ‘Fractal Scaling: Van L2 naar L3.’ In de visie van Starknet fungeert de Layer 2 virtuele machine als een gedecentraliseerde universele rekenlaag, met behoud van een hoge mate van samenstelbaarheid. Daarentegen zou Laag 3 moeten dienen als een applicatie-specifieke keten, die flexibel voldoet aan de unieke behoeften van verschillende toepassingen. Turing-volledigheid biedt een solide basis voor deze hiërarchische structuur. In theorie kan, zolang er Turing-volledigheid aanwezig is, elke mogelijke toepassing worden geconstrueerd.</p>
<p>De achtergrond voor het voorstellen van dit idee was dat Starknet de Cairo-taal en Cairo VM heeft ontwikkeld om op een efficiëntere manier bewijzen te genereren, maar deze waren niet volledig compatibel met Ethereum. Op dit punt kunnen Layer 3-ketens hun rol spelen en de nodige beveiligingsgaranties bieden voor deze toepassingen. Via deze benadering is Layer 3 een effectief middel geworden om de beperkingen van Layer 2 te overwinnen en verder de ontwikkeling van blockchaintechnologie te bevorderen.</p>
<p>Vanuit technisch oogpunt overtreft Laag 3 bestaande L1- en L2-oplossingen door blockchain-netwerken aan L2 te verankeren, waardoor een hogere beveiliging mogelijk is en mogelijk exponentiële schaalbaarheidsvoordelen worden behaald. Echter, aangezien zowel Laag 2 als Laag 3 afhankelijk zijn van het hoofdnetwerk voor afwikkeling, zijn hun gegevenscompressie- en synchronisatiemechanismen het onderwerp van discussie geworden.</p>
<p>In de context van Layer 2 worden transactiegegevens verpakt, gecomprimeerd en gesynchroniseerd met het Ethereum-netwerk. Evenzo zal Layer 3 een soortgelijk mechanisme gebruiken om zijn transactiegegevens te comprimeren en te synchroniseren met het Layer 2-netwerk.</p>
<p>Deze benadering, vergelijkbaar met het opnieuw toepassen van Rollup op Rollup, is echter in twijfel getrokken en bekritiseerd. Omdat als we doorgaan met het bedenken van hogere netwerken zoals Laag 4 en Laag 5 met deze architectuur, we het probleem van de limiet van gegevenscompressie zullen tegenkomen, aangezien gegevens niet oneindig gecomprimeerd kunnen worden.</p>
<p>Bijvoorbeeld, sommige instellingen zoals <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> Laboratoria hebben expliciet verklaard dat zij geen Layer 3 zullen ontwikkelen, terwijl <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">dYdX</a> zelfs spot met de grillige ideeën van Layer 3 door Layer 4 te creëren. Zelfs Vitalik heeft onlangs verklaard dat Layer 3 de verwerkingskracht niet magisch verbetert. Deze stemmen weerspiegelen de voorzichtige houding van de industrie ten opzichte van de haalbaarheid en praktische toepasbaarheid van Layer 3-technologie.<br><img src="https://gimg2.gateimg.com/image/article/17129156642.jpg" alt=""><br>Bron: @VitalikButerin</p>
<h2 id="h2-Inventariseer20die20Layer203instantieprojecten230531"><a name="Inventariseer die Layer 3-instantieprojecten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inventariseer die Layer 3-instantieprojecten</h2><p>Laag 3 heeft tot doel de interoperabiliteitsproblemen tussen blockchains aan te pakken en te voldoen aan de aangepaste behoeften van ontwikkelaars, waardoor het voor het publiek gemakkelijk te gebruiken en te implementeren is, inclusief governance mechanismen, regels en functies. Door off-chain verwerking van transacties kan Laag 3 de netwerkcongestie en transactiekosten verder verminderen op basis van Laag 2, waardoor de kostenefficiëntie wordt verbeterd.</p>
<p>Op dit moment hebben Arbitrum Orbit en Starknet onder de opkomende Layer 3-gebruiksscenario’s de meest uitstekende prestaties getoond en kunnen ze schitteren op gebieden zoals Game en DeFi.</p>
<h3 id="h3-Arbitrumbaan244292"><a name="Arbitrum-baan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Arbitrum-baan</h3><p>In 2023 lanceerde de Arbitrum Foundation een nieuwe functie - Arbitrum Orbit, een Layer 3 blockchain gebouwd op het Arbitrum Nitro platform. Naast het bieden van lagere transactiekosten en hogere schaalbaarheid, stelt Arbitrum Orbit ontwikkelaars in staat om zelfbeheerde, toegewijde blockchains te creëren op Arbitrum Nitro.</p>
<h3 id="h3-Starknet20Stack719173"><a name="Starknet Stack" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Starknet Stack</h3><p>In tegenstelling tot de eenvoudige stapelmethode kent Starknet verschillende verantwoordelijkheden toe aan L2 en L3 in het nieuwere L3-framework. Het benadrukt dat L3 zich moet richten op het bieden van aangepaste functies zoals privacybescherming of applicatiespecifieke optimalisatie in plaats van alleen schaalbaarheid nastreven.<br><img src="https://gimg2.gateimg.com/image/article/17129157033.jpg" alt=""><br>Bron: Starknet</p>
<p>In februari van dit jaar heeft Starknet officieel aangekondigd dat ze een samenwerking aangaan met Celestia om gezamenlijk een hoog doorvoerlaags 3-netwerk te bouwen. Echter, gezien het feit dat Starknet gebruik maakt van unieke zk STARK-proof technologie, die momenteel relatief onvolwassen is, zal het nog enige tijd duren voordat Starknet Stack wordt gelanceerd.</p>
<h3 id="h3-Orbs132979"><a name="Orbs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Orbs</h3><p>Orbs, als een nieuwe Layer 3 blockchain, heeft als doel om de schaalbaarheidsproblemen van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> aan te pakken en samen te werken met bestaande Layer 1 en Layer 2 protocollen.</p>
<p>Orbs Layer 3 is een “verbeterde uitvoering”-laag waarmee ontwikkelaars slimme contracten kunnen uitvoeren en ontwikkelen op een gedecentraliseerde servercloud. Dit betekent dat ontwikkelaars zich kunnen concentreren op het schrijven en implementeren van slimme contracten zonder zich zorgen te hoeven maken over de onderliggende netwerkinfrastructuur of het onderhouden van fysieke servers.</p>
<p>Op dit moment ondersteunt Orbs het gebruik van meerdere Layer 1 en Layer 2 protocollen zoals Ethereum, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Keten, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>, Polygon, etc.</p>
<h3 id="h3-zkSync20Hyperchains265140"><a name="zkSync Hyperchains" class="reference-link"></a><span class="header-link octicon octicon-link"></span>zkSync Hyperchains</h3><p>Een andere opmerkelijke technologie is de zkSync Hyperchains gelanceerd door het zkSync-team, die kan worden beschouwd als Laag 3 en gebruikt voor afwikkeling met behulp van Laag 2.</p>
<p>Deze Hyperchains worden aangedreven door dezelfde zkEVM-engine op de ZK Stack, waardoor consistentie wordt gegarandeerd voor alle ZKP-circuits op het platform en de beveiliging van Layer 1 wordt geërfd.</p>
<p>Een belangrijk voordeel van deze architectuur is dat het sneller berichtenverkeer mogelijk maakt tussen Laag 3 die zich op dezelfde Laag 2 bevindt en interoperabiliteit bevordert binnen een breder ecosysteem.</p>
<h2 id="h2-Samenvattend247888"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h2><p>Laag 3 lost voornamelijk de schaalbaarheid, complexe dApp-ondersteuning, blockchain-interoperabiliteit, aanpassing, kosteneffectiviteit en toegankelijkheid van blockchain op.</p>
<p>Het verbetert niet alleen de schaalbaarheid van blockchain en ondersteunt complexe dApp-ontwikkeling, maar fungeert ook als een brug tussen verschillende blockchains, waardoor cross-platform mogelijk is. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stromen</a> Laag 2 verwerkt transacties en data, terwijl Laag 3 aanpassingen mogelijk maakt op basis van de behoeften van ontwikkelaars, waardoor de transactiekosten worden verlaagd, de kosteneffectiviteit wordt verbeterd en de blockchain-technologie toegankelijker wordt voor het publiek.</p>
<p>Echter kan laag 3 niet alleen door eenvoudig stapelen prestatiesprongen bereiken, vanuit de evolutie van encryptietechnologie. Hoewel aanpassing specifieke voordelen kan bieden, beperkt het verlies van universaliteit de haalbaarheid van stapelen.<img src="https://gimg2.gateimg.com/image/article/17129157504.jpg" alt=""><br>Bron: LK Venture</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"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op 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 wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>