S2FuIGhldCBOZXN0aW5nIE1vZGVsIEV0aGVyZXVtIG5pZXV3IGxldmVuIGluYmxhemVuIG51IGRlIGNvbmN1cnJlbnRpZSBvcCBoZXQgUmUtc3Rha2luZyBUcmFjayBlc2NhbGVlcnQ/

2024-04-10, 07:32

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR256220"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Innovatieve technologieën op het gebied van Restaken en DeFi, zoals Babylon Chain en Eigenlayer, leiden de weg voor toekomstige ontwikkeling.</p>
<p>De re-staking projecten van PoS-ketens zoals Picasso en LiNEAR zijn opgedoken, waardoor de liquiditeitswaarde van meer ketens wordt ontsloten en nieuwe groeikansen worden geboden aan investeerders.</p>
<p>Re-staking is een belangrijk verhaal in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het ecosysteem en Eigenlayer hebben brede ontwikkelingsvooruitzichten aangetoond door de efficiëntie van activiteiten en consensus over beveiliging te verbeteren.</p>
<h2 id="h2-Introductie720231"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>In de bloeiende bullmarkt van dit jaar, en de langverwachte AI, RWA, DePIN en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Binnen het ecosysteem heeft de Restaking track een zeer fantasievolle focus.</p>
<p>Deze track wordt verwacht een rol te blijven spelen gedurende de bullmarkt met zijn unieke verhaal van het nesten van winsten en de distributie van tokens via gestaakte punten, en wordt een van de tracks die investeerders niet kunnen negeren.</p>
<p>We zullen de laatste ontwikkelingen op dit gebied delen, de significante impact op het herstel van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> analyseren en uitkijken naar toekomstige kansen voor marktdeelname.</p>
<h2 id="h2-De20TVL20van20de20Restaking20Track20blijft20stijgen20met20tal20van20projecten20die20opkomen534944"><a name="De TVL van de Restaking Track blijft stijgen, met tal van projecten die opkomen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De TVL van de Restaking Track blijft stijgen, met tal van projecten die opkomen</h2><p>Met de opkomst van Restaking is de tegenaanval van Ethereum in wezen stil begonnen, wat de geleidelijke vorming van een nieuwe ronde van het concurrerende landschap markeert.</p>
<p>De oprichter van Eigenlayer heeft het concept van Restaking ontwikkeld, wat een product is van de voortdurende evolutie van de stakingstrack.</p>
<p>In september 2022 is Ethereum succesvol overgestapt van Proof of Work (POW) naar Proof of Stake (POS), wat betekent dat Ethereum houders netwerkvalidators kunnen worden door ETH in te zetten, waardoor de beveiliging en stabiele werking van het netwerk worden gehandhaafd. Echter, de hoge drempel (32 ETH vereist) en de blokkeringsperiode van Ethereum staking zijn een groot pijnpunt geworden.</p>
<p>Om deze problemen aan te pakken, zijn er liquiditeitsstakingderivaten (LSD) ontstaan, die de gestorte ETH van particuliere beleggers bundelen. Stakers kunnen overeenkomstige ERC-20-derivatentokens krijgen in een verhouding van 1:1 (zoals de stETH uitgegeven door Lido), die een sterke liquiditeit hebben en gemakkelijk verhandelbaar en inwisselbaar zijn.</p>
<p>Vervolgens werden ook de opnieuw inlegproducten gelanceerd in lijn met de trend. Zoals de naam al aangeeft, is opnieuw inleggen secundair inleggen van ingelegde activa, wat aantrekkelijk is om inlegbeloningen en mogelijke projectluchtdroppels te verkrijgen.</p>
<p>De reden waarom Eigenlayer voorstelt om opnieuw te staken, is dat in veel real-world toepassingen zoals Oracle, Decentralized Finance (DeFi) en DA Layer, hoge beveiliging vereist is. Wanneer onvoldoende projectfondsen het moeilijk maken om zelf-eigen verificatieknooppunten op te zetten. Daarom voldoet Eigenlayer aan deze beveiligingseis door het concept van opnieuw staken te introduceren.</p>
<p>Uit de algemene marktervaring, wanneer een project de beveiliging van herbelegging aanneemt, verwacht de markt over het algemeen dat het airdrop-beloningen biedt als stimulans, wat de betrokkenheid van investeerders om deel te nemen aan Restaking in zekere mate vergroot, en veel LSTfi en gerelateerde ondersteunende faciliteitenproducten komen ook in groten getale binnen.</p>
<p>Op de schrijfdatum is volgens de statistieken van DefiLlama de TVL van de Restaking-sector gestegen naar $ 13,86B.<br><img src="https://gimg2.gateimg.com/image/article/17127339591.jpg" alt=""><br>Bron: DeFiLlama</p>
<h2 id="h2-De20opkomst20van20MultiChain20Liquiditeitsrestakingprojecten307626"><a name="De opkomst van Multi-Chain Liquiditeitsrestakingprojecten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De opkomst van Multi-Chain Liquiditeitsrestakingprojecten</h2><p>Op basis van onze observatie is de ontwikkeling van het Restaking-circuit niet langer beperkt tot het pure Ethereum re-staking-meta-protocol. Dit concept van gedeelde beveiliging is ook begonnen zich uit te breiden naar andere ketens en zelfs de gehele keten, wat heeft geleid tot vele op re-staking gebaseerde stichtingen en financiële faciliteiten. Dit zal de efficiëntie van de waardebenutting van liquiditeit van activa in elke keten verder verbeteren en meer empowerment-scenario’s uitbreiden.</p>
<h2 id="h2-Bitcoin20Restaking20Babylon20Chain514755"><a name="Bitcoin Re-staking: Babylon Chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin Re-staking: Babylon Chain</h2><p>Babylon Chain is een Bitcoin-stakingprotocol dat tot doel heeft de beveiliging van andere PoS-ketens te verbeteren door gebruik te maken van de beveiliging van de meer dan $1 biljoen cryptocurrency-economie van Bitcoin.<img src="https://gimg2.gateimg.com/image/article/17127339992.jpg" alt=""><br>Bron: Babylon Chain</p>
<p>Het creëert een bilaterale markt die Bitcoin-houders in staat stelt om veilig hun BTC te staken en de PoS-kanalen en DApps te kiezen die ze willen ondersteunen en waar ze winst uit willen halen. De sleutel tot het functioneren van Babylon ligt in het afdwingen van het strafmechanisme en het overwinnen van de tekortkomingen van de slimme contractfunctionaliteit van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> door geavanceerde versleutelingstechnologie te combineren en de programmeertaal van het Bitcoin- te optimaliseren.</p>
<p>Babylon maakt gebruik van een van de belangrijkste kenmerken van Bitcoin - tijdstempel - om regelmatig checkpoints van andere PoS-netwerken op de Bitcoin-blockchain vast te leggen, waardoor een extra beveiligingslaag voor transacties ontstaat. Elke aanvaller die probeert het PoS-netwerk te verstoren door Babylon Chain te gebruiken, zal de Bitcoin-blockchain zelf moeten aanvallen, waardoor een beveiliging ontstaat die equivalent is aan Bitcoin voor deze ketens.</p>
<p>De architectuur van Babylon bestaat uit drie delen: Bitcoin als een tijdstempeldienst, Babylon Chain als de Cosmos Zone van de middelste laag en aggregator, en andere Cosmos Zones als beveiligingsconsumenten.</p>
<p>Met deze architectuur kan Babylon checkpoints van verschillende zones combineren en tijdstempelverificatie uitvoeren via de Bitcoin-keten, waardoor de veiligheid van alle transacties wordt gegarandeerd.</p>
<p>Bovendien versnelt Babylon ook de ontbindingsperiode door checkpoints naar de Bitcoin-keten te sturen, waardoor de opnametijd die dagen of zelfs weken in beslag zou kunnen nemen, wordt teruggebracht tot uren.</p>
<h2 id="h2-Solana20Opnieuw20staken20Picasso305998"><a name="Solana Opnieuw staken: Picasso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Solana Opnieuw staken: Picasso</h2><p>Picasso is een infrastructuurlaag die zich richt op DeFi-interoperabiliteit en gebruik maakt van Cosmos SDK-technologie om meerdere ecoen met elkaar te verbinden door het IBC-protocol uit te breiden.<br><img src="https://gimg2.gateimg.com/image/article/17127340353.jpg" alt=""><br>Bron: Picasso</p>
<p>Picasso lanceerde in oktober 2023 een testnet voor Ethereum en IBC, en heeft plannen om IBC-connectiviteit te realiseren tussen Ethereum en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> in het tweede kwartaal van 2024. Het maakt gebruik van PICA tokens om de netwerkbeveiliging te beschermen.</p>
<p>Met betrekking tot <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> heeft Picasso een herstakinglaag gebouwd, bekend als de ‘bezoeker blockchain’, als validatielaag om Solana compatibel te maken met IBC. Deze laag moet worden gideerd en gebruikt gestakede activa om zijn eigen beveiliging te beschermen, terwijl SOL en zijn derivaten als onderpand kunnen dienen.</p>
<p>Om de liquiditeit te begeleiden, heeft Picasso het Mantis Games-evenement gelanceerd, dat is verdeeld in drie fasen, waaronder NFT-veilingen, teamstakingswedstrijden en uitwisselingswedstrijden met een scoresysteem.</p>
<p>Bovendien heeft Picasso een Actively Validated Service (AVS) ontworpen om de interoperabiliteit tussen Solana en andere ketens te vergemakkelijken. Bij de bruggenbouwvergoeding krijgt de PICA-staker 20% en de herstakers 40%.</p>
<p>Een ander hoogtepunt van dit protocol is dat het Rome Protocol zal dienen als de tweede AVS die Picasso Solana zal gebruiken als een herstaking laag, en er worden binnenkort meer details verwacht.</p>
<h2 id="h2-Near20opnieuw20inzetten20LiNEAR890143"><a name="Near opnieuw inzetten: LiNEAR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Near opnieuw inzetten: LiNEAR</h2><p>LiNEAR is een project dat de keten abstractie netwerkbeveiliging van NEAR verbetert door opnieuw inzetten. Als toonaangevend DeFi-protocol van NEAR verbetert het de netwerkbeveiliging en decentralisatie door middel van innovatieve liquiditeitsinzet en automatische optimalisatiealgoritmen voor validators.<br><img src="https://gimg2.gateimg.com/image/article/17127340864.jpg" alt=""><br>Bron: LiNEAR</p>
<p>LiNEAR is toegewijd aan het vereenvoudigen van deelname van gebruikers aan gedecentraliseerde netwerken, vooral nu het NEAR-ecosysteem de ketenabstractie bevordert.</p>
<p>Chain abstractie stelt gebruikers in staat om gemakkelijk meerdere blockchain-transacties over te steken zonder de onderliggende technologieën te begrijpen. Daarom richt LiNEAR zich op het opnieuw inzetten en verlagen van de toegangsdrempel voor multi-chain ecoen.</p>
<p>Het kernstrategie is de liquiditeit herbeleggen van de gehele keten, zodat de beveiliging van de keten abstractie-infrastructuur wordt gegarandeerd en de valkuilen van gecentraliseerde en toegeeflijke oplossingen worden vermeden. Door gebruik te maken van bestaande blockchain-beveiligingsmechanismen, het verbeteren van de kapitaalefficiëntie en het bevorderen van de nauwe integratie van de onderliggende laag en blockchain, beschermt herbeleggen effectief de infrastructuur van de keten abstractie.</p>
<p>De ketenabstractiefuncties van NEAR omvatten sociale authenticatie, accountaggregatie en ketenondertekening, waardoor gebruikers een uniform account en interface krijgen. Om deze visie te realiseren, ontwikkelt LiNEAR nieuwe gedecentraliseerde infrastructuur zoals ketenhandtekening MPC-netwerken en multi-keten Gas-relais.</p>
<h2 id="h2-Volledige20Chain20Restaking20StackStone947161"><a name="Volledige Chain Re-staking: StackStone" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Volledige Chain Re-staking: StackStone</h2><p>StackStone is een volledig ketenherstel liquiditeitsprotocol dat een hoge schaalbaarheid demonstreert door ondersteuning te bieden voor verschillende stakingspools en compatibiliteit met aankomend Restaking. StackStone heeft ook een multi-chain liquiditeitsmarkt opgezet op basis van zijn eigen LST en STONE, waardoor gebruikers meer gebruiksmogelijkheden en inkomstenkansen hebben.<img src="https://gimg2.gateimg.com/image/article/17127341765.jpg" alt=""><br>Bron: StakeStone</p>
<p>De belangrijkste hoogtepunten van StackStone zijn onder andere:</p>
<ol>
<li><p>Gedecentraliseerd geïntegreerd stakingprotocol: gericht op het opzetten van een LST-liquiditeitscross-chain-markt, het verbinden van Ethereum en andere blockchains, en het oplossen van het probleem van liquiditeit en activafragmentatie tussen het hoofdnetwerk en andere netwerken.</p>
</li><li><p>OPAP (Optimalisatie van beleggingsportefeuille en toewijzingssuggesties) mechanisme: Biedt een gedecentraliseerde oplossing voor liquiditeitsstaking, waardoor gebruikers ETH kunnen storten in protocollen in ruil voor STONE-tokens. Naarmate de protocolopbrengsten toenemen, zal de waarde van STONE (wisselkoers tegen ETH) blijven stijgen.</p>
</li><li><p>Cross-chain compatibiliteit: Gebaseerd op het LayerZero ontwerp, ondersteunt het naadloze overdracht en uitlijning van activa en prijzen tussen meerdere blockchains. Momenteel ondersteunt het openbare ketens zoals Ethereum, Manta, Base, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Ketting, Mantel, Linea, enz.</p>
</li><li><p>Automatische inkomstenoptimalisatie: Met behulp van het OPAP-mechanisme wordt de onderliggende vermogensallocatie automatisch aangepast om ervoor te zorgen dat STONE-houders de optimale inkomsten uit staking kunnen verkrijgen.</p>
</li><li><p>Beveiliging: StackStone is toegewijd aan het bieden van gebruikers de veiligste inkomstenbeheerdiensten.</p>
</li></ol>
<h2 id="h2-Samenvattend361647"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h2><p>Dit is een snelgroeiende opkomende markt, met niet alleen initiatiefnemers zoals Eigenlayer, maar ook aggregators zoals StackStone die zich toeleggen op het uitbreiden van de volledige ketenliquiditeitsstaking. Ze richten zich op het ontwikkelen van oplossingen en het voortdurend uitbreiden van nieuwe financiële rendementsscenario’s in liquiditeits-herstakingprotocollen.</p>
<p>Op dit moment bevindt het spoor zich nog steeds op het kruispunt van de blauwe en rode oceanen, en er worden in de komende weken en maanden meer veranderingen in het marktpatroon verwacht.</p>
<p>Natuurlijk brengt deze nesting-methode om nieuwe activa te creëren door herhaaldelijk ETH en andere inheemse activa te staken ook veel risico’s met zich mee.</p>
<p>Bijvoorbeeld kunnen gebruikers aarzeling hebben om de native tokens van EigenLayer te gebruiken, omdat ze direct ETH kunnen inzetten om beloningen te ontvangen.</p>
<p>Als er een grote hoeveelheid ETH opnieuw wordt ingezet in andere protocollen, kan dit de beveiliging van het Ethereum-netwerk beïnvloeden wanneer er een beveiligingslek optreedt. Er is ook het probleem van de toewijzing van tokenbeloningen; als de deelnemers aan het opnieuw inzetten te veel beloningen ontvangen, kan dit de token-economie van het protocol verstoren.</p>
<p>Opnieuw staken brengt ook het risico met zich mee dat de stakingsperiode wordt geannuleerd en dat er ETH-beheerskwesties ontstaan.</p>
<p>Ondanks de risico’s kan de uitgifte van deze nieuwe activa in de stierenmarkt worden gezien als het proces van het creëren van schuim, dat cruciaal is om de waarde van activa te verbreden en overrendement te behalen.</p>
<p>Intussen, met de ontwikkeling van technologieën zoals modulariteit en ketenabstractie, biedt het patroon van Eigenlayer de mogelijkheid voor projecten om snel, gemakkelijk en tegen lage kosten applicaties te implementeren.</p>
<p>De huidige marktvraag naar EigenLayer en Liquid herinzetprotocollen geeft aan dat we een interessante ontdekkingsreis maken. Hoewel de opkomst van nieuwe technologieën en bedrijven gepaard gaat met risico’s, is het de moeite waard om deze risico’s te ueren en te beheersen in plaats van op te geven en hard op te treden.</p>
<p>Wat betreft welke nieuwe protocollen en productparadigma’s er in de toekomst zullen opkomen, en hoe ze kunnen integreren en zelfs het Ethereum-ecosysteem kunnen versterken, dit zal een langetermijnkwestie zijn en we zullen de ontwikkeling op dit gebied nauwlettend blijven volgen.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>