TGEgZ2FyYSBkZWwgcmVzdGFraW5nIMOoIGluIHBpZW5vIHN2b2xnaW1lbnRvLCB1biBudW92byBtb3RvcmUgcGVyIHVuIG1lcmNhdG8gcmlhbHppc3RhIMOoIHByb3ByaW8gZGkgZnJvbnRlIGEgbm9p

2024-02-29, 08:24

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR396482"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Come protocollo leader di restaking nel <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’ecosistema, EigenLayer migliora la sicurezza della rete <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e offre maggiori opportunità di ricompensa per gli stakers consentendo agli utenti di scommettere LST su altre side chain, macchine oracle, middleware, ecc.</p>
<p>Il settore della Restaking ha molteplici macro ambienti favorevoli, tra cui nuove tendenze, nidificazione a più livelli per migliorare l’efficienza del capitale, e l’aggiornamento e la divisione a Cancun. Questa pista ha guadagnato rapidamente popolarità e non mostra segni di raffreddamento.</p>
<p>Il restaking ha rilasciato la liquidità dell’ETH e migliorato l’efficienza del capitale per gli investitori, ma lo sviluppo del nesting comporta anche multe, concentrazione, contratti e rischi a più livelli, e la partecipazione deve essere fatta entro la propria capacità.</p>
<h2 id="h2-Introduzione192202"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La tecnologia e l’innovazione del prodotto sono sempre state la forza trainante dello sviluppo dell’industria crittografica. Di recente, con l’avvicinarsi dell’aggiornamento di Ethereum Cancun, in particolare con la crescita di EigenLayer, il valore totale bloccato (TVL) di molti progetti di restaking è aumentato significativamente, e il percorso di restaking della liquidità (LRT) ha iniziato a ricevere ampia attenzione.</p>
<p>Questo articolo esplorerà il potenziale e l’impatto di EigenLayer e dei suoi progetti di restaking correlati da molteplici prospettive, nonché il loro impatto sull’ecosistema di Ethereum, per rivelare il valore di ogni progetto.</p>
<h2 id="h2-EigenLayer20scatena20una20nuova20tendenza20nel20restaking309311"><a name="EigenLayer scatena una nuova tendenza nel restaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>EigenLayer scatena una nuova tendenza nel restaking</h2><p>Il restaking è stato proposto per la prima volta da @sreeramkannan, che si riferisce a consentire all’ETH che è già stato messo in gioco su Ethereum di essere rimesso in gioco su altri protocolli di consenso, al fine di ottenere la condivisione sicura degli asset.</p>
<p>In realtà, questo modello di condivisione sicura non è unico per EigenLayer. Blockchains come <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a>, Cosmos e <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Valanga</a> adotta anche meccanismi di condivisione sicura simili.</p>
<p>Come leader nei protocolli di restaking nell’ecosistema Ethereum, EigenLayer ha ulteriormente promosso l’applicazione di questo concetto e è diventato un progetto leader in questo campo. Questo protocollo consente agli utenti di restake ETH, lsdETH (ETH staked in liquidità) e LP Token su altri side chain, macchine oracolari, middleware, ecc., per ricevere ricompense di verifica. Questa innovazione fondamentale non solo aumenta la sicurezza della rete Ethereum, ma fornisce anche più opportunità di ricompensa per gli stakeholder, raggiungendo una situazione vantaggiosa per tutti.<img src="https://gimg2.gateimg.com/image/article/17091948141.jpg" alt=""><br>Sorgente: @DWFVentures</p>
<p>Secondo la descrizione nel white paper, il nucleo del meccanismo di implementazione di EigenLayer si basa su due pilastri: sicurezza condivisa e governance di mercato aperta.</p>
<p>Il principio di funzionamento del meccanismo di sicurezza di pooling è che i validatori di Ethereum possono vincolare i loro voucher di prelievo della catena di beacon con i contratti intelligenti di EigenLayer e costruire nuovi moduli basati su EigenLayer. Questi moduli impongono condizioni di riduzione aggiuntive sull’ETH scommesso dai validatori che vi aderiscono. Come ricompensa, i validatori possono non solo ricevere premi dai voucher scommessi, ma anche guadagnare entrate aggiuntive dai progetti che utilizzano i Servizi di Verifica Attiva (AVS).</p>
<p>Il meccanismo di governance del libero mercato è una caratteristica principale di EigenLayer, che costruisce un ambiente di mercato aperto che consente ai validatori di scegliere liberamente se unirsi o uscire da ciascun modulo in base a EigenLayer. Questo meccanismo di mercato garantisce che i validatori abbiano incentivi sufficienti quando allocano la loro sicurezza raggruppata, considerando anche una riduzione potenziale del rischio aggiuntivo, i validatori contribuiranno a determinare quali moduli valga la pena allocare più sicurezza raggruppata.</p>
<p>In termini di meccanismi di punizione, Eigenlayer ha adottato anche misure rigorose. Attraverso l’esecuzione di smart contract, gli attaccanti malintenzionati affronteranno una penalità fino al 50% dell’ETH scommesso, aumentando significativamente il costo degli attacchi malintenzionati. Questa misura garantisce la sicurezza e la stabilità dell’ecosistema EigenLayer.</p>
<p>In sintesi, il valore principale di EigenLayer risiede nell’affittare il livello di sicurezza di ETH a più Dapp/Blockchain per raccogliere tasse di sicurezza, risolvendo il problema della difficoltà di trasmettere ed espandere l’economia crittografica originale del blockchain verso altri protocolli nell’ecosistema.</p>
<p>Secondo le statistiche dei dati di Dune, alla data di scrittura, EigenLayer ha scommesso su oltre 110000 indirizzi ETH per LST, con una quantità che supera i 2,87 milioni, equivalente a un valore superiore a $9,7 miliardi.<br><img src="https://gimg2.gateimg.com/image/article/17091948592.jpg" alt=""><br>Sorgente: Dune</p>
<h2 id="h2-Lo20sfondo20dei20ricavi20LEGO20caldi20di20Restaking646948"><a name="Lo sfondo dei ricavi LEGO caldi di Restaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo sfondo dei ricavi LEGO caldi di Restaking</h2><p>La ragione per cui la traccia di Restaking è diventata un importante focus della nuova narrazione in questo mercato al rialzo è principalmente perché eredita intelligentemente la strategia di “nesting” della comunità Ethereum, che utilizza i LEGO per impilare i BUFF e aumentare i profitti allo stesso modo della DeFi Summer nel precedente mercato al rialzo.</p>
<p>Dal punto di vista dei principi, il processo di ETH che passa attraverso LST e LRT è il seguente:</p>
<p>Innanzitutto, investi ETH nei protocolli LSD (come Lido) come collaterale per ottenere lsdETH (come stETH). Durante questo processo, puoi godere degli interessi di inflazione PoS di ETH e, se il protocollo LSD non emette monete, potresti anche ricevere ricompense airdrop.</p>
<p>Successivamente, l’utente ha ri-staked il LST in cambio di un nuovo voucher di ri-staking, dimostrando che il LST è stato ri-staked, ma solo l’ETH rimane come asset sottostante originale.</p>
<p>In breve, fare staking di ETH per ottenere LST e fare di nuovo staking di LST per ottenere LRT, questo processo ripetuto di staking è chiamato Restaking.</p>
<p>In realtà, gli utenti che detengono LST/LRT possono partecipare a operazioni finanziarie più ampie, come il re-staking, il prestito, i derivati con leva, ecc., aumentando l’opportunità di utilizzare la liquidità per guadagnare profitti con ogni staking.<br><img src="https://gimg2.gateimg.com/image/article/17091949083.jpg" alt=""><br>Origine: Messari</p>
<p>Combinato con il meccanismo di Eigenlayer e altri protocolli di guadagno degli interessi come Pendle e <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> Finanza, la liquidità è stata accelerata e è stata lanciata una nuova fase di arbitraggio dei token, equivalente a una versione potenziata dell’estate di DeFi.</p>
<p>Di conseguenza, sotto la molteplice stimolazione dell’hype, del nesting a più livelli per migliorare l’efficienza del capitale e dell’aggiornamento e dimezzamento di Cancun nel nuovo percorso, il percorso ha rapidamente guadagnato popolarità e finora non ha mostrato segni di raffreddamento.</p>
<h2 id="h2-Lecosistema20del20restaking20sta20diventando20sempre20pi20perfetto20e20si2020formato20una20spirale20positiva985187"><a name="L’ecosistema del restaking sta diventando sempre più perfetto, e si è formato una spirale positiva" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ecosistema del restaking sta diventando sempre più perfetto, e si è formato una spirale positiva</h2><p>Lo sviluppo del mercato del restaking è lontano dall’arrestarsi presso EigenLayer. Sono sorti numerosi progetti di catene e derivati, nonché varie infrastrutture, come funghi dopo la pioggia. Questi progetti hanno mostrato un notevole potenziale all’interno del quadro del restaking, arricchendo notevolmente l’ecosistema di questo settore.</p>
<p>Dal punto di vista dei vari tipi di progetti, questa sezione include non solo LSD Restaking, Liquid LSD Restaking, Native Restaking, Liquid Native Restaking, ecc. Pendle, Swell, Ether. fi, Eigenpie, Renzo, Puffer Finance e altri progetti sono particolarmente interessanti, ognuno con meccanismi di restaking unici e prospettive di rendimento, attirando un gran numero di partecipanti e investimenti, e ampliando il TVL di EigenLayer.</p>
<p>Dal punto di vista delle applicazioni multi-chain, lo sviluppo dell’ecosistema di stacking/restaking al di fuori di Ethereum è altrettanto impressionante, come ad esempio il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> protocollo di staking Babylon, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosistema Picasso, ecosistema LiNear e Octopus Network, tutti e tre hanno vissuto un hype narrativo simile.<br><img src="https://gimg2.gateimg.com/image/article/17091949604.jpg" alt=""><br>Origine: Babylonchain</p>
<p>Dal punto di vista dell’infrastruttura del restaking, come le piattaforme di prestiti Ion Protocol, Astrid, Rollup, AltLayer, le catene pubbliche di L2 Supermeta, Tenet, ecc., specificamente utilizzate per il restaking, riducono notevolmente la soglia dell’utente per il restaking e aumentano ulteriormente il tetto dell’ecosistema.</p>
<p>Naturalmente, non si può ignorare che lo stile di spirale positiva di nidificazione è spesso accompagnato da vari rischi, come il rischio di multa, il rischio di concentrazione, il rischio contrattuale e la sovrapposizione di rischi a più livelli, che tutti i partecipanti dovrebbero valutare attentamente.</p>
<p>Attualmente, l’impatto positivo di questa nuova traccia è chiaramente più accettato dal mercato. Eigenlayer ha con successo liberato il potenziale di nidificazione di Ethereum e, guidato dalla tendenza della modularità, ha trasformato il consenso di sicurezza di Ethereum in un layer modulare. Questa innovazione consente ad Ethereum di espandersi verso altre catene eterogenee, compensando la sua mancanza di capacità di disponibilità dei dati (DA).</p>
<p>In sintesi, nel contesto dell’incessante emergere di catene emergenti, il progetto di restaking rappresentato da Eigenlayer ha iniettato nuova vitalità nella vecchia catena pubblica di Ethereum e promosso una nuova ondata di innovazione e prosperità in vari prodotti di ogni catena.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'articolo a condizione che Gate.io sia citato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>