UHJvdG9jb2xsbyBFaWdlbkxheWVyOiBSaWRpc2VnbmFyZSBFdGhlcmV1bSBlIFBvdGVuemlhbGkgUHJlb2NjdXBhemlvbmkgcGVyIGxhIFNhbHV0ZSBkZWxsYSBSZXRl

2023-06-20, 09:16

<p><img src="https://gimg2.gateimg.com/blog/1679447253500249423shendu.jpeg" alt=""></p>
<h2 id="h2-TL20DR414586"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il protocollo EigenLayer consente <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> i validatori devono reinvestire i loro ETH per proteggere altre reti.</p>
<p>Sia la rete <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> che il protocollo EigenLayer ridurranno gli ETH in gioco dei validatori se agiscono in modo maligno.</p>
<p>Restaking porta i validatori a ottenere più ricompense rispetto prima in quanto possono ottenere incentivi da due protocolli.</p>
<p>Attualmente, gli investitori possono depositare i token di staking liquidi (LST) che includono token cbETH, stETH e rETH.</p>
<h2 id="h2-Introduzione224562"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La verità è che i settori blockchain e cripto hanno molte possibilità che le persone potrebbero non immaginare in un certo momento. Possiamo dire che in connessione con il Protocollo EigenLayer che ora consente alle persone di ristakare i loro token staked.</p>
<p>In questo articolo, discuteremo di come il protocollo EigenLayer consente ai validatori di rimettere in gioco i propri token e ottenere ricompense da due fonti.</p>
<h2 id="h2-Comprensione20del20protocollo20EigenLayer957811"><a name="Comprensione del protocollo EigenLayer" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprensione del protocollo EigenLayer</h2><p>L’EigenLayer, il <a href="https://www.gate.io/learn/course/ethereum-fundemental" target="_blank">Ethereum</a> Il protocollo di restaking ha suscitato grande entusiasmo tra gli investitori di criptovalute in quanto consente alle persone di avere due flussi di reddito da <a href="https://www.gate.io/learn/articles/how-to-stake-eth/209 &quot;their staked Ether (ETH" rel="nofollow noopener noreferrer" target="_blank">il loro Ether (ETH) bloccato</a> Questo probabilmente creerà una nuova dimensione su come alcune applicazioni decentralizzate come oracoli e rollups funzionano.</p>
<p>Il protocollo EigenLayer, costruito sulla blockchain Ethereum, è un mercato decentralizzato per validatori e operatori di nodi che consente loro di ristabilire il proprio ETH su altre reti. Di conseguenza, le reti che utilizzano il protocollo EigenLayer sono in grado di sfruttare la rete di fiducia di Ethereum.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-ethereum-2-0/102" target="_blank">Cosa è Ethereum 2.0? Comprendere la Fusione</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/16872523443761687250048_.pic.jpg" alt=""><br>EigenLayer - Thetie</p>
<p>Significativamente, il protocollo EigenLayer risolve uno dei problemi attuali della blockchain Ethereum. Il fatto è che lo strato di esecuzione e il protocollo di consenso che costituiscono la rete fiduciaria della blockchain Ethereum sono accoppiati, il che significa che è impossibile separarli.</p>
<p>Tuttavia, la capacità di restaking del protocollo EigenLayer aiuta a superare tale vincolo poiché consente ai validatori della rete Ethereum di proteggere altri middleware come oracoli e ponti cross-chain. In questo modo, le reti esistenti possono anche utilizzare altri livelli di esecuzione e protocolli di consenso.</p>
<h2 id="h2-Cosa20significa20restaking186482"><a name="Cosa significa restaking?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa significa restaking?</h2><p>Restaking è un nuovo concetto sulla blockchain. Tuttavia, significa semplicemente che l’ETH che è staked su una rete può essere staked nuovamente su un altro protocollo. In altre parole, l’ETH che i validatori della blockchain di Ethereum hanno staked può essere utilizzato per garantire altre reti come blockchain non EVM o sidechain.</p>
<p>Già, EigenLayer prevede di facilitare il restaking di ETH che viene prelevato dalla Beacon Chain <a href="https://www.gate.io/learn/articles/all-you-need-to-know-about-the-ethereum-shapella-upgrade/518" target="_blank">dopo l’aggiornamento Shapella</a>. Questo crea nuova utilità per ETH e ETH <a href="https://www.gate.io/blog_detail/328/what-is-cryptocurrency-staking" target="_blank">Picchettamento</a> che dovrebbe aumentare la sua domanda nel medio-lungo termine.</p>
<p>Secondo il tracker di Ultrasound Money, ci sono 17,9 milioni di ETH, del valore di circa 33,6 miliardi di dollari, bloccati sulla Beacon Chain. Con l’ausilio del protocollo EigenLayer, una tale quantità di ETH può essere riposizionata e creare un valore aggiuntivo per l’intero ecosistema.</p>
<p>Il restaking di ETH da parte di EigenLayer aumenta la sicurezza di vari middleware come bridge e oracoli. Questo perché l’ampia capitalizzazione di mercato di ETH offre anche una maggiore sicurezza e stabilità del middleware. Inoltre, è probabile che la possibilità di rimettere in staking gli ETH prelevati incoraggi un’ulteriore partecipazione alla rete Ethereum e ad altre reti che dipendono dalla blockchain di Ethereum.</p>
<p>In modo più significativo, la capacità di riposizionare ETH crea spazio per migliori ricompense per gli scommettitori e i validatori.</p>
<p>Informazioni importanti: <a href="https://www.gate.io/price/view/eth-20-staking" target="_blank">Primi token e monete crittografiche di staking eth-20 per capitalizzazione di mercato</a></p>
<h2 id="h2-Lo20stato20attuale20del20protocollo20EigenLayer565174"><a name="Lo stato attuale del protocollo EigenLayer" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo stato attuale del protocollo EigenLayer</h2><p>Il protocollo EigenLayer è stato testato utilizzando la rete di test Goerli. Tuttavia, verrà testato in tre fasi che coinvolgono vari partecipanti nell’ecosistema. Il mainnet del protocollo EigenLayer dovrebbe essere lanciato nel terzo trimestre (Q3) del 2023.</p>
<p>Il progetto sta procedendo bene poiché ha un grande supporto finanziario. A marzo ha raccolto oltre 50 milioni di dollari in una fase di finanziamento Serie A in cui hanno partecipato i giganti delle finanze tecnologiche Coinbase Ventures, Polychain Capital, Blockchain Capital, Finality Capital Partner ed Electric Capital.</p>
<p>Leggi anche: <a href="https://www.gate.io/article/30342" target="_blank">Gate.io Supporta i Prelievi di Staking di Ethereum ETH2.0</a></p>
<h2 id="h2-Rischi20del20restaking20ETH652545"><a name="Rischi del restaking ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rischi del restaking ETH</h2><p>Come sappiamo, i validatori della blockchain di Ethereum usavano scommettere i loro ETH per partecipare al processo di convalida della rete. Il loro ruolo principale è stato quello di verificare le transazioni sulla blockchain e guadagnare ricompense sotto forma di ETH in cambio.</p>
<p>Tuttavia, ci sono alcuni disincentivi per agire in modo malintenzionato. Se un validatore agisce in modo maligno, perde parte del suo ETH scommesso attraverso un processo chiamato slashing. Riconsiderare l’ETH significa che i scommettitori devono attenersi alle condizioni degli altri protocolli. Se si comportano male, perdono anche il loro ETH attraverso lo slashing in modo simile a quello che fa la blockchain di Ethereum.</p>
<p>Ciò significa che i validatori rischiano di perdere i loro ETH condivisi attraverso la riduzione dei due protocolli. Ad esempio, se gli ETH condivisi di un validatore vengono ridotti da un protocollo diverso dalla rete Ethereum, si verificherà una doppia riduzione. Il motivo è che la rete Ethereum riduce anche gli ETH anche se il validatore non ha violato i suoi termini.</p>
<p>Secondo le attuali regole intelligenti della rete Ethereum, un validatore che agisce in modo contrario allo standard previsto perde la metà dei 32 ETH scommessi. Se il validatore avesse violato le regole stabilite di un altro protocollo, EigenLayer taglierebbe l’altra metà rimanente. Questo significa che taglierebbe 8 ETH dai restanti 16. Questo diventa un duro colpo per il validatore.</p>
<p>Tuttavia, è importante notare che il convalidatore che ha reinvestito i propri ETH riceverebbe doppi premi. Egli/ella ottiene un premio dalla rete Ethereum e dall’altra rete collegata al protocollo EigenLayer.</p>
<p>Tuttavia, gli analisti hanno anche sottolineato che il restaking dell’ETH potrebbe creare rischi per la rete Ethereum e il suo consenso sociale.</p>
<h2 id="h2-Punti20di20vista20di20Vitalik20Buterin20sul20restaking20di20ETH146308"><a name="Punti di vista di Vitalik Buterin sul restaking di ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti di vista di Vitalik Buterin sul restaking di ETH</h2><p>Anche se Vitalik Buterin, co-fondatore della blockchain di Ethereum, crede che non ci sia nulla di male nel fare il restaking di ETH, <a href="https://vitalik.ca/general/2023/05/21/dont_overload.html?ref=bankless.ghost.io" rel="nofollow noopener noreferrer" target="_blank">ha chiaramente indicato</a> le applicazioni che si basano sull’ETH reinvestito per la sicurezza non dovrebbero “acquisire il suo consenso sociale”. In altre parole, tali protocolli non dovrebbero puntare a fare affidamento su un fork per recuperare eventuali perdite. Inoltre, se il protocollo si comporta male, il consenso sociale di Ethereum non lo aiuterà.</p>
<p>Secondo Buterin, ci sono due tipi di rischi che derivano dal restaking di Ethereum allo scopo di garantire altri protocolli diversi dalla rete Ethereum. In primo luogo, c’è un basso rischio di riutilizzo “dove, anche se tutto si rompe completamente, le perdite sono contenute ai validatori e agli utenti che hanno scelto di partecipare e utilizzare il tuo protocollo.”</p>
<p>Inoltre, ci sono anche applicazioni ad alto rischio che finiscono per sovraccaricare il consenso sociale della rete Ethereum. Ciò potrebbe influire significativamente su diverse applicazioni o protocolli sia on-chain che off-chain.</p>
<h2 id="h2-Ci20sar20una20EigenLayer20Crypto510092"><a name="Ci sarà una EigenLayer Crypto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ci sarà una EigenLayer Crypto?</h2><p>EigenLayer non ha annunciato l’intenzione di introdurre una criptovaluta nativa. Il tempo dirà se lancerà un token EigenLayer. Quello che sappiamo al momento è che gli investitori possono depositare token di staking liquido (LST) nel protocollo EigenLayer.</p>
<p>Attualmente supporta i token cbETH di Coinbase, stETH di Lido e <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Piscina a razzo</a> rETH di ’. Tuttavia, ha piani per introdurre più LST.</p>
<h2 id="h2-Conclusione372908"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il recente lancio del protocollo EigenLayer sulla blockchain Ethereum segna un nuovo sviluppo per l’intero ecosistema. Il restaking di EigenLayer aumenterà le ricompense dei validatori creando al contempo maggiore utilità per ETH. Finora, il protocollo EigenLayer non ha ancora suggerito il rilascio del suo token. Tuttavia, gli utenti possono depositare. <a href="https://www.gate.io/price/view/liquid-staking-tokens &quot;various liquid staking tokens (LSTs" rel="nofollow noopener noreferrer" target="_blank">diversi token di staking liquido (LST)</a>”).</p>
<h2 id="h2-Domande20frequenti20sul20Protocollo20EigenLayer377154"><a name="Domande frequenti sul Protocollo EigenLayer" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sul Protocollo EigenLayer</h2><h3 id="h3-Come20funziona20lEigenLayer426800"><a name="Come funziona l’EigenLayer?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona l’EigenLayer?</h3><p>L’EigenLayer è un marketplace per validatori e operatori di nodi che consente loro di reimmettere il proprio ETH. L’ETH reimmeso può garantire altre blockchain che esistono sulla blockchain di Ethereum.</p>
<h3 id="h3-Quali20sono20i20rischi20del20protocollo20EigenLayer898082"><a name="Quali sono i rischi del protocollo EigenLayer?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono i rischi del protocollo EigenLayer?</h3><p>I validatori che agiscono in modo maligno perderanno la maggior parte dei loro ETH. Ciò avviene perché sia la rete Ethereum che EigenLayer possono ridurre drasticamente il loro ETH scommesso.</p>
<h3 id="h3-Eigenlayer20ha20un20token431669"><a name="Eigenlayer ha un token?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eigenlayer ha un token?</h3><p>Attualmente, EigenLayer non ha un token e non ha ancora annunciato l’intenzione di averne uno. Tuttavia, gli investitori possono depositare token di staking liquido (LST) che includono token cbETH, stETH e rETH.</p>
<h3 id="h3-Chi2020il20fondatore20del20protocollo20EigenLayer358487"><a name="Chi è il fondatore del protocollo EigenLayer?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chi è il fondatore del protocollo EigenLayer?</h3><p>Sreeram Kannan è il fondatore di EIgenLayer. EigenLayer è un protocollo che consente ai validatori di Ethereum e agli operatori di nodi di reinvestire i propri ETH.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>