UHXDsiBpbCBtb2RlbGxvIGRpIG5pZGlmaWNhemlvbmUgcml2aXRhbGl6emFyZSBFdGhlcmV1bSBtZW50cmUgYXVtZW50YSBsYSBjb25jb3JyZW56YSBzdWxsYSBwaXN0YSBkZWwgcmUtc3Rha2luZz8=

2024-04-10, 07:32

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR652803"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Tecnologie innovative nei campi del Restaking e DeFi, come Babylon Chain e Eigenlayer, stanno aprendo la strada per lo sviluppo futuro.</p>
<p>Sono emersi progetti di restaking per le catene PoS come Picasso e LiNEAR, sbloccando il valore di liquidità di più catene e portando nuove opportunità di crescita agli investitori.</p>
<p>Re-staking è una narrativa importante nel <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’ecosistema, e Eigenlayer ha dimostrato ampi prospettive di sviluppo migliorando l’efficienza operativa degli asset e il consenso sulla sicurezza.</p>
<h2 id="h2-Introduzione374062"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>In questo mercato toro in rapida crescita di quest’anno, e l’altamente attesa AI, RWA, DePIN e <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Nell’ecosistema, la traccia di Restaking ha un punto focale altamente immaginativo.</p>
<p>Si prevede che questa traccia continuerà a svolgere un ruolo importante durante il mercato al rialzo con la sua narrazione unica di guadagni nidificati e distribuzione di token attraverso punti puntati, diventando una delle tracce che gli investitori non possono ignorare.</p>
<p>Condivideremo gli ultimi sviluppi in questa traccia, analizzeremo il suo significativo impatto sulla ripresa di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e guarderemo alle future opportunità di partecipazione al mercato.</p>
<h2 id="h2-Il20TVL20del20Restaking20Track20continua20a20salire20con20numerosi20progetti20emergenti579178"><a name="Il TVL del Restaking Track continua a salire, con numerosi progetti emergenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il TVL del Restaking Track continua a salire, con numerosi progetti emergenti</h2><p>Con l’emergere del Restaking, la controffensiva di Ethereum è essenzialmente iniziata silenziosamente, segnando la graduale formazione di una nuova fase del panorama competitivo.</p>
<p>Il fondatore di Eigenlayer ha introdotto il concetto di Restaking, che è un prodotto dell’evoluzione continua della traccia di staking.</p>
<p>A settembre 2022, Ethereum ha effettuato con successo la transizione da Proof of Work (POW) a Proof of Stake (POS), il che significa che i detentori di Ethereum possono diventare validatori di rete ponendo in gioco ETH, mantenendo così la sicurezza e il funzionamento stabile della rete. Tuttavia, l’alto requisito (richiedendo 32 ETH) e il periodo di blocco del ponimento di Ethereum sono diventati un importante punto dolente.</p>
<p>Per affrontare questi problemi, sono emersi i derivati di staking di liquidità (LSD), che aggregano gli ETH scommessi degli investitori al dettaglio. Gli scommettitori possono ottenere token derivati ERC-20 corrispondenti in un rapporto 1:1 (come ad esempio lo stETH emesso da Lido), che hanno una forte liquidità e sono facili da scambiare e riscattare.</p>
<p>Successivamente, anche i prodotti di re-staking sono stati lanciati in linea con la tendenza. Come suggerisce il nome, il re-staking è il ristaking secondario degli asset staked, che risulta interessante per ottenere ricompense di staking e potenziali airdrop di progetti.</p>
<p>Il motivo per cui Eigenlayer propone il re-staking è che molte applicazioni del mondo reale come Oracle, Decentralized Finance (DeFi) e DA Layer richiedono un’elevata sicurezza. Quando i fondi del progetto sono insufficienti e rendono difficile l’installazione di nodi di verifica di proprietà. Pertanto, Eigenlayer soddisfa questa esigenza di sicurezza introducendo il concetto di re-staking.</p>
<p>Dall’esperienza generale di mercato, quando un progetto adotta la sicurezza fornita dal re-staking, il mercato generalmente si aspetta di ricevere ricompense sotto forma di airdrop come incentivi, il che in qualche misura amplia l’entusiasmo degli investitori a partecipare al Restaking, e molti prodotti LSTfi e strutture di supporto correlate arrivano in gran numero.</p>
<p>Alla data di scrittura, secondo le statistiche di DefiLlama, il TVL del settore Restaking è salito a $13.86 miliardi.<br><img src="https://gimg2.gateimg.com/image/article/17127339591.jpg" alt=""><br>Fonte: DeFiLlama</p>
<h2 id="h2-La20crescita20dei20progetti20di20restaking20di20liquidit20multichain353508"><a name="La crescita dei progetti di restaking di liquidità multi-chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La crescita dei progetti di restaking di liquidità multi-chain</h2><p>Sulla base delle nostre osservazioni, lo sviluppo del circuito di restaking non è più limitato al puro protocollo meta di restaking di Ethereum. Questo concetto di sicurezza condivisa ha iniziato a espandersi anche ad altre catene e persino all’intera catena, dando origine a molte fondazioni e strutture finanziarie basate su restaking. Ciò migliorerà ulteriormente l’efficienza dell’utilizzo del valore di liquidità degli asset in ogni catena e espanderà ulteriori scenari di potenziamento.</p>
<h2 id="h2-Ristaking20di20Bitcoin20Babylon20Chain354045"><a name="Ristaking di Bitcoin: Babylon Chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ristaking di Bitcoin: Babylon Chain</h2><p>Babylon Chain è un protocollo di staking di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> mirato a migliorare la sicurezza di altre catene PoS sfruttando la sicurezza dell’economia delle criptovalute di Bitcoin, che supera i 1 trilioni di dollari.<img src="https://gimg2.gateimg.com/image/article/17127339992.jpg" alt=""><br>Origine: Babylon Chain</p>
<p>Crea un mercato bilaterale che consente ai detentori di Bitcoin di attaccare in modo sicuro il loro BTC e scegliere le catene PoS e le DApp da supportare e trarre profitto. La chiave del funzionamento di Babilonia risiede nell’applicazione del meccanismo di penalità e nel superamento dei difetti della funzionalità del contratto intelligente di Bitcoin mediante la combinazione di tecnologia avanzata di crittografia e l’ottimizzazione del linguaggio di programmazione dello  Bitcoin.</p>
<p>Babylon utilizza una delle caratteristiche chiave di Bitcoin - il timestamp - per registrare regolarmente i checkpoint di altre reti PoS sulla blockchain di Bitcoin, fornendo un livello di sicurezza per le transazioni. Qualsiasi attaccante che cerchi di interrompere la rete PoS utilizzando Babylon Chain dovrà attaccare la stessa blockchain di Bitcoin, creando così una sicurezza equivalente a Bitcoin per queste catene.</p>
<p>L’architettura di Babilonia è composta da tre parti: Bitcoin come servizio di timestamp, Babylon Chain come la zona Cosmos del livello intermedio e aggregatore, e altre zone Cosmos come consumatori di sicurezza.</p>
<p>Questa architettura consente a Babilonia di aggregare i checkpoint da diverse zone e di eseguire la verifica dei timestamp attraverso la catena di Bitcoin, garantendo la sicurezza di tutte le transazioni.</p>
<p>Inoltre, Babylon accelera anche il periodo di sblocco inviando checkpoint alla catena di Bitcoin, riducendo il tempo di prelievo che potrebbe richiedere giorni o addirittura settimane a poche ore.</p>
<h2 id="h2-Solana20Restaking20Picasso825434"><a name="Solana Re-staking: Picasso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Solana Re-staking: Picasso</h2><p>Picasso è uno strato di infrastruttura focalizzato sull’interoperabilità DeFi, che utilizza la tecnologia Cosmos SDK per connettere più ecosistemi estendendo il protocollo IBC.<br><img src="https://gimg2.gateimg.com/image/article/17127340353.jpg" alt=""><br>Sorgente: Picasso</p>
<p>Picasso ha lanciato un testnet per Ethereum e IBC nel mese di ottobre 2023 e ha pianificato di raggiungere la connettività IBC tra Ethereum e <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> nel secondo trimestre del 2024. Utilizza i token PICA per proteggere la sicurezza della rete.</p>
<p>Per quanto riguarda Solana, Picasso ha costruito uno strato di ristaking, noto come “visitor blockchain”, come strato di convalida per rendere <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> compatibile con IBC. Questo strato deve essere convalidato e utilizzare asset con staking per proteggere la propria sicurezza, mentre SOL e i suoi derivati possono fungere da garanzia.</p>
<p>Per guidare la liquidità, Picasso ha lanciato l’evento Mantis Games, che è diviso in tre fasi, tra cui aste NFT, partite di staking di squadra e partite di scambio con un sistema di punteggio.</p>
<p>Inoltre, Picasso ha progettato un servizio di convalida attiva (AVS) per facilitare l’interoperabilità tra Solana e altre catene. Nella commissione di ponte, il 20% viene dato allo staker PICA e il 40% ai ristaker.</p>
<p>Un altro punto saliente di questo protocollo è che il Protocollo di Roma fungerà da secondo AVS per utilizzare Picasso Solana come livello di riepilogo, e si prevede che verranno annunciati ulteriori dettagli a breve.</p>
<h2 id="h2-Near20Restaking20LiNEAR782953"><a name="Near Re-staking: LiNEAR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Near Re-staking: LiNEAR</h2><p>LiNEAR è un progetto che migliora la sicurezza della rete di astrazione della catena di NEAR attraverso il re-staking. In quanto principale protocollo DeFi di NEAR, migliora la sicurezza della rete e la decentralizzazione attraverso innovativi algoritmi di stake di liquidità e ottimizzazione automatica dei validatori.<br><img src="https://gimg2.gateimg.com/image/article/17127340864.jpg" alt=""><br>Sorgente: LiNEAR</p>
<p>LiNEAR si impegna a semplificare la partecipazione degli utenti nelle reti decentralizzate, soprattutto mentre l’ecosistema NEAR avanza nell’astrazione della catena.</p>
<p>L’astrazione della catena consente agli utenti di attraversare facilmente transazioni su più blockchain senza comprendere le tecnologie sottostanti. Pertanto, LiNEAR si concentra sul re-staking e sulla riduzione della soglia di ingresso per gli ecosistemi multi-chain.</p>
<p>La sua strategia principale è il re-staking della liquidità dell’intera catena, garantendo la sicurezza dell’infrastruttura di astrazione della catena e evitando le insidie delle soluzioni centralizzate e permissive. Utilizzando i meccanismi di sicurezza esistenti delle blockchain, migliorando l’efficienza del capitale e promuovendo l’integrazione stretta del layer sottostante e della blockchain, il re-staking protegge efficacemente l’infrastruttura dell’astrazione della catena.</p>
<p>Le funzioni di astrazione della catena di NEAR includono l’autenticazione sociale, l’aggregazione degli account e la firma della catena, fornendo agli utenti un account e un’interfaccia unificati. Per realizzare questa visione, LiNEAR sta sviluppando nuove infrastrutture decentralizzate come reti MPC a firma a catena e relè Gas multi-chain.</p>
<h2 id="h2-Ristaking20a20catena20completa20StackStone80173"><a name="Ri-staking a catena completa: StackStone" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ri-staking a catena completa: StackStone</h2><p>StackStone è un protocollo di liquidità completo che dimostra un’elevata scalabilità supportando vari pool di staking ed è compatibile con il prossimo Restaking. StackStone ha inoltre creato un mercato di liquidità multi-chain basato sui suoi token nativi LST e STONE, offrendo agli utenti maggiori casi d’uso e opportunità di guadagno.<img src="https://gimg2.gateimg.com/image/article/17127341765.jpg" alt=""><br>Sorgente: StakeStone</p>
<p>I principali punti salienti di StackStone includono:</p>
<ol>
<li><p>Protocollo di staking integrato decentralizzato: mirato a stabilire un mercato di liquidità cross-chain LST, connettendo Ethereum e altre blockchain, e risolvere il problema della liquidità e della frammentazione degli asset tra la rete principale e altre reti.</p>
</li><li><p>Meccanismo OPAP (Ottimizzazione del portafoglio di investimento e suggerimenti di allocazione): Fornisce una soluzione decentralizzata per lo staking di liquidità, consentendo agli utenti di depositare ETH nei protocolli in cambio di token STONE. Man mano che il fatturato del protocollo aumenta, il valore di STONE (tasso di cambio rispetto all’ETH) continuerà a salire.</p>
</li><li><p>Compatibilità cross-chain: Basato su un design LayerZero, supporta il trasferimento e l’allineamento senza soluzione di continuità di asset e prezzi tra più blockchain. Attualmente, supporta le catene pubbliche come Ethereum, Manta, Base, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, Mantle, Linea, etc.</p>
</li><li><p>OTTIMIZZAZIONE automatica del reddito: Utilizzando il meccanismo OPAP, l’allocazione degli asset sottostanti viene automaticamente regolata per garantire che i detentori di STONE possano ottenere il reddito di staking ottimale.</p>
</li><li><p>Sicurezza: StackStone si impegna a fornire agli utenti i servizi di gestione dei ricavi più sicuri.</p>
</li></ol>
<h2 id="h2-Per20riassumere962967"><a name="Per riassumere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Per riassumere</h2><p>Questo è un mercato emergente in rapida crescita, con non solo iniziatori come Eigenlayer ma anche aggregatori come StackStone dedicati ad espandere la liquidità completa della catena. Si concentrano nello sviluppo di soluzioni e nell’espansione continua di nuovi scenari di ritorno finanziario nei protocolli di restaking della liquidità.</p>
<p>Attualmente, la pista è ancora al bivio tra gli oceani blu e rosso, e ci si aspettano ulteriori cambiamenti nel modello di mercato nelle prossime settimane e mesi.</p>
<p>Naturalmente, questo metodo di nidificazione per creare nuovi asset attraverso il deposito ripetuto di ETH e altri asset nativi comporta anche molti rischi.</p>
<p>Ad esempio, gli utenti potrebbero avere riserve sull’uso dei token nativi di EigenLayer in quanto possono scommettere direttamente ETH per ricevere ricompense.</p>
<p>Se una grande quantità di ETH viene riposizionata in altri protocolli, una volta che si verifica una vulnerabilità di sicurezza, potrebbe influenzare la sicurezza della rete Ethereum. C’è anche il problema dell’allocazione delle ricompense in token; se i partecipanti al riposizionamento ricevono troppe ricompense, potrebbe compromettere l’economia dei token del protocollo.</p>
<p>Il re-staking comporta anche il rischio di annullare il periodo di staking e problemi di gestione dell’ETH.</p>
<p>Nonostante i rischi, nel mercato rialzista, l’emissione di questi nuovi asset può essere vista come il processo di creazione di una schiuma, che è cruciale per ampliare il valore degli asset e ottenere rendimenti in eccesso.</p>
<p>Nel frattempo, con lo sviluppo di tecnologie come la modularità e l’astrazione della catena, il modello di Eigenlayer offre la possibilità ai progetti di distribuire applicazioni in modo rapido, conveniente e a basso costo.</p>
<p>La domanda attuale di mercato per i protocolli di riciclaggio di EigenLayer e Liquid indica che stiamo intraprendendo un viaggio interessante di esplorazione. Anche se l’emergere di nuove tecnologie e aziende comporta rischi, questi rischi meritano di essere valutati e controllati piuttosto che arrendersi e reprimere.</p>
<p>Per quanto riguarda quali nuovi protocolli e paradigmi di prodotto emergeranno in futuro e come potranno integrarsi e persino potenziare l’ecosistema Ethereum, questo sarà un problema a lungo termine e continueremo a monitorare da vicino lo sviluppo di questo settore.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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 il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>