RGUgUmFjZSB2YW4gUmVzdGFrZW4gaXMgaW4gdm9sbGUgZ2FuZywgZWVuIG5pZXV3ZSBtb3RvciB2b29yIGVlbiBzdGllcmVubWFya3Qgc3RhYXQgcmVjaHQgdm9vciBvbnMu

2024-02-29, 08:24

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR693018"><a name="[TL；DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]:</h2><p>Als een toonaangevend restaking protocol in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> EigenLayer versterkt het beveiligingssysteem van het Ethereum-netwerk en biedt meer beloningsmogelijkheden voor stakers door gebruikers in staat te stellen LST te staken op andere side chains, orakelmachines, middleware, etc.</p>
<p>De Restaking sector heeft meerdere gunstige macro-omgevingen, waaronder nieuwe hype, multi-layer nesting om de kapitaalefficiëntie te verbeteren, en upgrading en halvering van Cancun. Deze sector heeft snel aan populariteit gewonnen en vertoont geen tekenen van afkoeling.</p>
<p>Restaking heeft de liquiditeit van ETH vrijgegeven en de kapitaalefficiëntie voor investeerders verbeterd, maar nestontwikkeling brengt ook boetes, concentratie, contracten en meerlaagse risico’s met zich mee, en deelname moet binnen de eigen capaciteit worden gedaan.</p>
<h2 id="h2-Inleiding416861"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Technologie en productinnovatie zijn altijd de drijvende kracht geweest achter de ontwikkeling van de cryptobranche. Onlangs is, met de naderende upgrade van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Cancun en vooral met de opkomst en groei van EigenLayer, de totale vergrendelde waarde (TVL) van meerdere restaking-projecten aanzienlijk toegenomen, en de liquiditeit restaking (LRT) track begint veel aandacht te krijgen.</p>
<p>Dit artikel zal de potentie en impact van EigenLayer en de bijbehorende restaking-projecten vanuit meerdere dimensies onderzoeken, evenals hun impact op het Ethereum-ecosysteem, om de waarde van elk project te onthullen.</p>
<h2 id="h2-EigenLayer20veroorzaakt20een20nieuwe20trend20in20restaken967026"><a name="EigenLayer veroorzaakt een nieuwe trend in restaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>EigenLayer veroorzaakt een nieuwe trend in restaken</h2><p>Restaking werd voor het eerst voorgesteld door @sreeramkannan, wat verwijst naar het toestaan van ETH die al is gestaked op Ethereum om opnieuw gestaked te worden op andere consensusprotocollen, om zo een veilige deling van activa te bereiken.</p>
<p>In feite is dit veilige deelmodel niet uniek voor EigenLayer. Blockchains zoals <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>, Cosmos en <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> adopteren ook vergelijkbare beveiligde deelmechanismen.</p>
<p>Als leider in restaking-protocollen in het Ethereum-ecosysteem heeft EigenLayer het gebruik van dit concept verder bevorderd en is het een toonaangevend project geworden op dit gebied. Dit protocol stelt gebruikers in staat om ETH, lsdETH (liquidity staked ETH) en LP Token op andere side chains, orakel machines, middleware, enz. opnieuw in te zetten om verificatiebeloningen te ontvangen. Deze kerninnovatie verhoogt niet alleen de beveiliging van het Ethereum-netwerk, maar biedt ook meer beloningsmogelijkheden voor stakers, waardoor een win-winsituatie wordt gecreëerd.<img src="https://gimg2.gateimg.com/image/article/17091948141.jpg" alt=""><br>Bron: @DWFVentures</p>
<p>Volgens de beschrijving in het whitepaper ligt de kern van het EigenLayer-implementatiemechanisme in twee pijlers: gepoolde beveiliging en open marktbestuur.</p>
<p>Het werkingsprincipe van het pooling-beveiligingsmechanisme is dat Ethereum-validatoren hun beacon chain-opnamemiddelen kunnen binden met EigenLayer slimme contracten en nieuwe modules kunnen bouwen op basis van EigenLayer. Deze modules leggen aanvullende verminderingvoorwaarden op aan de ETH die is ingezet door de validators die zich bij hen voegen. Als beloning kunnen validators niet alleen beloningen ontvangen van ingezette vouchers, maar ook extra inkomsten verdienen uit projecten die gebruikmaken van Active Verification Services (AVS).</p>
<p>Het mechanisme van marktbestuur is een belangrijk kenmerk van EigenLayer, dat een open marktomgeving creëert waarin validators vrij kunnen kiezen of ze zich willen aansluiten bij of uittreden uit elk module op basis van EigenLayer. Dit marktmechanisme zorgt ervoor dat validators voldoende prikkels hebben bij het toewijzen van hun verzamelde beveiliging, terwijl ze rekening houden met potentiële extra risicovermindering, zullen validators helpen bepalen welke modules het waard zijn om meer verzamelde beveiliging toe te wijzen.</p>
<p>Wat betreft strafmechanismen heeft Eigenlayer ook strenge maatregelen genomen. Door het uitvoeren van slimme contracten zullen kwaadwillende aanvallers een boete krijgen tot 50% van hun ingezette ETH, wat de kosten van kwaadwillige aanvallen aanzienlijk verhoogt. Deze maatregel waarborgt de veiligheid en stabiliteit van het EigenLayer-ecosysteem.</p>
<p>Samengevat ligt de kernwaarde van EigenLayer in het huren van de beveiligingslaag van ETH aan meerdere Dapp/Blockchains om beveiligingsbelastingen te innen, waardoor het probleem van de oorspronkelijke cryptoeconomiebeveiliging van blockchain dat moeilijk te verzenden en uit te breiden is naar andere protocollen in het ecosysteem wordt opgelost.</p>
<p>Volgens de gegevensstatistieken van Dune heeft EigenLayer op de schrijfdatum meer dan 110.000 ETH-adressen ingezet voor LST, met een hoeveelheid van meer dan 2,87 miljoen, equivalent aan een waarde van meer dan $9,7B.<img src="https://gimg2.gateimg.com/image/article/17091948592.jpg" alt=""><br>Bron: Dune</p>
<h2 id="h2-De20hete20LEGO20omzetachtergrond20van20Restaking787830"><a name="De hete LEGO omzetachtergrond van Restaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De hete LEGO omzetachtergrond van Restaking</h2><p>De reden waarom de Restaking-track een belangrijk aandachtspunt is geworden in het nieuwe verhaal in deze bullmarkt, is voornamelijk omdat het op een slimme manier de strategie van het ‘nesting’ van de Ethereum-community erft, die LEGO gebruikt om BUFFs te stapelen om winsten te verhogen op dezelfde manier als de DeFi-zomer in de vorige bullmarkt.</p>
<p>Vanuit een principieel perspectief verloopt het proces van ETH door LST en LRT als volgt:</p>
<p>Ten eerste, investeer ETH in LSD-protocollen (zoals Lido) als onderpand om lsdETH (zoals stETH) te verkrijgen. Tijdens dit proces kunt u genieten van de PoS-inflatiebelangen van ETH en als het LSD-protocol geen munten uitgeeft, kunt u ook airdrop-beloningen ontvangen.</p>
<p>Vervolgens heeft de gebruiker de LST opnieuw gestaked in ruil voor een nieuwe stakingsvoucher, wat bewijst dat de LST opnieuw is gestaked, maar alleen ETH blijft als de oorspronkelijke onderliggende activa.</p>
<p>In het kort, ETH staken om LST te verkrijgen, en LST opnieuw staken om LRT te verkrijgen, dit herhaalde stakingsproces wordt Restaking genoemd.</p>
<p>In feite kunnen gebruikers met LST/LRT meer financiële operaties uitvoeren, zoals opnieuw inzetten, lenen, hefboomderivaten, enz., waardoor de mogelijkheid wordt vergroot om liquiditeit te gebruiken om winst te maken met elke inzet.<img src="https://gimg2.gateimg.com/image/article/17091949083.jpg" alt=""><br>Bron: Messari</p>
<p>Gecombineerd met het mechanisme van Eigenlayer en andere rente-verdienende protocollen zoals Pendle en <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> Financiën, liquiditeit is versneld en er is een nieuwe ronde van token-arbitrage gelanceerd, equivalent aan een verbeterde versie van DeFi Summer.</p>
<p>Als gevolg hiervan heeft het spoor onder invloed van meerdere stimuli, zoals hype, het meervoudig nesten om de kapitaalefficiëntie te verbeteren, en de upgrading en halvering van Cancun op het nieuwe spoor, snel aan populariteit gewonnen en tot nu toe geen tekenen van afkoeling vertoond.</p>
<h2 id="h2-Het20restakingecosysteem20wordt20steeds20perfecter20en20er20heeft20zich20een20positieve20spiraal20gevormd766857"><a name="Het restaking-ecosysteem wordt steeds perfecter en er heeft zich een positieve spiraal gevormd." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het restaking-ecosysteem wordt steeds perfecter en er heeft zich een positieve spiraal gevormd.</h2><p>De ontwikkeling van de restakingmarkt houdt bij EigenLayer zeker niet op. Meerdere keten- en afgeleideprojecten en diverse infrastructuur zijn als paddenstoelen na regen uit de grond geschoten. Deze projecten hebben opmerkelijk potentieel getoond binnen het restakingkader en hebben het ecosysteem van deze sector aanzienlijk verrijkt.</p>
<p>Vanuit het perspectief van verschillende projecttypes omvat deze sectie niet alleen LSD Restaking, Liquid LSD Restaking, Native Restaking, Liquid Native Restaking, enz. Pendle, Swell, Ether. fi, Eigenpie, Renzo, Puffer Finance en andere projecten vallen bijzonder op, elk met unieke restakingmechanismen en rendementsvooruitzichten, waardoor een groot aantal deelnemers en investeringen worden aangetrokken en EigenLayer’s TVL wordt uitgebreid.</p>
<p>Vanuit het perspectief van multi-chain toepassingen is de ontwikkeling van het stacking/restaking ecosysteem buiten Ethereum even indrukwekkend, zoals de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> stakingprotocol Babylon, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem Picasso, ecosysteem LiNear en Octopus Network, die allemaal een vergelijkbare hype hebben meegemaakt.<img src="https://gimg2.gateimg.com/image/article/17091949604.jpg" alt=""><br>Bron: Babylonchain</p>
<p>Vanuit het perspectief van de infrastructuur van restaking, zoals leningsplatforms Ion Protocol, Astrid, Rollup, AltLayer, L2 openbare ketens Supermeta, Tenet, enz., die specifiek worden gebruikt voor restaking, wordt de gebruiker drempel voor restaking aanzienlijk verlaagd en wordt het plafond van het ecosysteem verder verhoogd.</p>
<p>Natuurlijk kan niet worden genegeerd dat de positieve spiraal van nestingstijl vaak gepaard gaat met verschillende risico’s, zoals fijn risico, concentratierisico, contractrisico en het stapelen van risico’s op meerdere niveaus, die allemaal de moeite waard zijn om door de deelnemers te worden overwogen.</p>
<p>Op dit moment wordt het positieve effect van deze nieuwe ontwikkeling duidelijk meer geaccepteerd door de markt. Eigenlayer heeft succesvol het nestpotentieel van Ethereum ontketend en heeft Ethereum’s veiligheidsconsensus getransformeerd naar een modulaire laag, gedreven door de trend van modulariteit. Deze innovatie stelt Ethereum in staat om uit te breiden naar andere heterogene ketens en compenseert voor het gebrek aan gegevensbeschikbaarheid (DA) mogelijkheden.</p>
<p>Samengevat heeft het restakingproject, vertegenwoordigd door Eigenlayer, in de context van de voortdurende opkomst van opkomende ketens, nieuwe vitaliteit geïnjecteerd in de oude publieke keten van Ethereum en een nieuwe ronde van innovatie en welvaart bevorderd in verschillende producten van elke keten.</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 enkele beleggingsaanbeveling.<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 actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>