TGEgY29udHJvdmVyc2lhIHN1bGxvIHN0YWtpbmcgbGlxdWlkbyBkaSBMaWRvOiBlc2FtaW5hcmUgbGEgZ292ZXJuYW5jZSBlIGlsIGNvbnRyb2xsbw==

<p><img src="https://gimg2.gateimg.com/image/article/1692587501guide.jpeg" alt=""><br>Parole chiave: Liquid staking, protocollo Lido, protocollo di proof-of-stake, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain, ETH staked, token di staking liquido (LST), token derivato di staking, governance di Lido, staking liquido ETH, dominio di Lido nello staking liquido di ETH, centralizzazione di Lido, delega di ETH</p>
<h2 id="h2-Introduzione814319"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La liquid staking è uno degli investimenti crittografici più redditizi che coinvolgono <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e altri token basati su protocolli che <a href="https://www.gate.io/learn/articles/what-is-proof-of-stake/60" target="_blank">utilizzare il meccanismo di consenso del proof-of-staking</a> Un problema sorprendente relativo allo staking liquido è l’esistenza di un token ombra che può generare ricompense aggiuntive per l’investitore.</p>
<p>In questo articolo, esploreremo come funziona lo staking liquido sul protocollo Lido. Discuteremo anche la controversia attuale che circonda la piattaforma di staking di Lido.</p>
<p>Leggi anche: <a href="/price/safepal-sfp" rel="nofollow noopener noreferrer" target="_blank">Cos’è il Proof of Stake in leasing (LPoS)](https://www.gate.io/learn/articles/what-is-leased-proof-of-stake-and-how-does-it-work/374 “What Is Leased Proof of Stake (LPoS)”) e [criptovaluta SafePal</a>?“)</p>
<h2 id="h2-Liquid20Staking364619"><a name="Liquid Staking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Liquid Staking</h2><p>Prima di concentrarci sugli aspetti specifici, prendiamoci del tempo per capire cos’è lo staking liquido. Lo staking liquido è una soluzione di investimento cripto che consente agli utenti di accedere alla liquidità delle criptovalute che hanno scommesso. Inoltre, gli investitori guadagnano una ricompensa aggiuntiva per lo staking di una moneta come ETH.</p>
<p>La liquidazione dello staking supera il problema chiave degli investitori in <a href="https://www.gate.io/learn/articles/what-is-pos-staking/10" target="_blank">Prova di puntata</a> I protocolli utilizzati per affrontare. Gli investitori che un tempo contribuivano con le proprie monete per garantire una rete come Ethereum non erano in grado di utilizzare le proprie monete in gioco.</p>
<p>In passato, i nodi che convalidavano le transazioni sulla blockchain di Ethereum avrebbero scommesso i propri ETH per periodi indefiniti. Ciò significava che non era possibile per loro utilizzare le monete scommesse. Ad esempio, non potevano utilizzare gli ETH scommessi come garanzia quando volevano ottenere prestiti DeFi.</p>
<p>La liquid staking risolve questo problema. Questo perché l’investitore ottiene un token che rappresenta l’ETH in staking e che può utilizzare per altri scopi come il yield farming.</p>
<p>L’investitore può utilizzare il token di staking liquido (LST) in diversi modi. Ad esempio, può scambiarlo su scambi di criptovalute, creando così un altro flusso di reddito. Inoltre, l’investitore può trasferire il LST ad altre piattaforme o spenderlo senza influire sul suo ETH staked.</p>
<p>Tuttavia, è importante notare che l’investitore dovrà restituire il LST allo staking <a href="https://www.gate.io/learn/articles/what-is-lido/171" target="_blank">piattaforma come Lido</a> per richiedere il suo ETH in gioco. Quando tu <a href="https://www.gate.io/how-to-buy/lido-staked-ether-steth" target="_blank">stake ETH su Lido ottieni stETH</a>, il suo token di staking liquido, che ha lo stesso valore di ETH.</p>
<h2 id="h2-Cos20Lido838572"><a name="Cos’è Lido?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Lido?</h2><p>Lido è un protocollo di staking liquido che fornisce i suoi servizi di staking per diversi blockchain, tra cui Ethereum. La piattaforma consente ai suoi utenti di fare staking dei loro token del protocollo senza bloccarli.</p>
<p>Tuttavia, <a href="https://www.gate.io/how-to-buy/lido-dao-ldo" target="_blank">Lido</a> è ben noto per consentire agli investitori di Ethereum di mettere in gioco il proprio ETH e ottenere il token derivato di staking liquido (LST) <a href="https://www.gate.io/price/lido-staked-ether-steth" target="_blank">chiamato stETH</a>. Lido quindi delega l’ETH scommesso a operatori di nodi diversi <a href="https://www.gate.io/blog_detail/2905/a-comprehensive-guide-on-verifying-ethereum-transactions" target="_blank">chi verifica le transazioni sulla rete Ethereum</a>.</p>
<p>Gli investitori di ETH possono utilizzare il loro stETH per altri scopi come il prestito. Uno dei principali vantaggi di Lido è che consente agli investitori con meno di 32 ETH di metterli in gioco e guadagnare una quota delle ricompense dei blocchi Ethereum.</p>
<p>In modo più significativo, Lido utilizza un sistema di custodia autonoma per i token del protocollo come ETH. Ciò significa che i token scommessi rimangono sempre sotto la custodia dell’investitore. Dal momento in cui l’investitore scommette il token fino al momento in cui viene assegnato a un validatore, rimane di sua proprietà.</p>
<h2 id="h2-Governance20di20Lido633785"><a name="Governance di Lido" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Governance di Lido</h2><p>Attualmente, Lido utilizza la stessa struttura di governance di molte organizzazioni autonome decentralizzate (DAO), in cui i detentori di token del protocollo hanno il diritto di contribuire al processo decisionale.</p>
<p>In questo caso, i detentori del token di governance nativo di Lido, LDO, partecipano alla presa di decisioni attraverso il suo meccanismo di voto. È interessante notare che Lido utilizza un sistema di voto ponderato dal token, il che significa che un investitore che possiede molti token LDO ha molto più potere di voto rispetto a qualcuno con meno token. I detentori di LDO votano in catena per le proposte date.</p>
<p>Tuttavia, c’è una proposta per modificare il sistema di governance di Lido. La comunità propone di introdurre un sistema di governance duale in cui sia i detentori di LDO che di stETH avranno il diritto di veto su determinate proposte. Ciò garantirà che gli interessi degli investitori di stETH siano protetti in ogni momento.</p>
<h2 id="h2-Lido20mantiene20molto20controllo20sulla20staking20liquido478296"><a name="Lido mantiene molto controllo sulla staking liquido" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lido mantiene molto controllo sulla staking liquido</h2><p>Alcuni analisti hanno sottolineato che Lido controlla gran parte dello staking liquido di ETH. In particolare, Lido controlla oltre il 33% degli ETH in staking, qualcosa che una certa parte del mercato di ETH non è felice.</p>
<p>Con circa un terzo degli ETH in gioco sotto il controllo di Lido, alcuni critici ritengono che la rete ethereum sia sotto minaccia. Chiedono ad altre piattaforme di staking liquido di trovare modi per aumentare gli ETH in gioco.</p>
<h2 id="h2-Preoccupazioni20e20critiche20sulla20dominanza20di20Lido20nello20staking20liquido20di20ETH575900"><a name="Preoccupazioni e critiche sulla dominanza di Lido nello staking liquido di ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Preoccupazioni e critiche sulla dominanza di Lido nello staking liquido di ETH</h2><p>La più grande critica sulla dominanza di Lido nello staking liquido di ETH è che crea centralizzazione. Ciò potrebbe influire negativamente sulla sicurezza della blockchain di Ethereum se succede qualcosa di brutto a Lido.</p>
<p>Alcuni analisti hanno sostenuto che il dominio di Lido potrebbe portare a una manipolazione esterna della rete Ethereum che potrebbe destabilizzare la sua stabilità. La manipolazione della rete potrebbe influenzare il sistema di governance della rete off-chain di Ethereum.</p>
<p>La seconda preoccupazione riguardante la dominanza di Lido in <a href="https://www.gate.io/blog_detail/3103/analyzing-eth-price-impact-eth-staking" target="_blank">ETH staking</a> è che la sicurezza della rete Ethereum viene minacciata se il protocollo viene hackerato e la maggior parte, se non tutta, l’ETH in staking viene rubata.</p>
<p>Allo stesso modo, la concentrazione di ETH puntato sotto Lido alla fine mina la natura decentralizzata della blockchain di Ethereum. Evan Van Ness, uno sviluppatore di Ethereum, ha criticato la predominanza di Lido su X (precedentemente Twitter). Ha scritto: “Lido potrebbe essere il più grande attacco alla decentralizzazione di Ethereum nella nostra intera storia”.</p>
<p>Nonostante abbia molte organizzazioni autonome decentralizzate sotto di essa, Lido potrebbe centralizzare il modo in cui operano e si governano. Esiste anche la possibilità di collusioni tra gli operatori dei nodi. Pertanto, possono avere una grande influenza sulla finalità dei blocchi di Ethereum.</p>
<p>L’altro problema potrebbe sorgere se Lido dovesse affrontare una minaccia da parte di governi forti come quello degli Stati Uniti. Una tale minaccia potrebbe costringere Lido a censurare alcune attività per evitare accuse penali da parte del governo. Ad esempio, potrebbe bloccare le transazioni stETH di determinati portafogli digitali come quelli sanzionati dal governo federale.</p>
<p>Articoli correlati:<br><a href="https://www.gate.io/blog_detail/328/what-is-cryptocurrency-staking" target="_blank">Cos’è il posizionamento delle criptovalute?</a> <a href="https://www.gate.io/blog_detail/1826/how-does-crypto-staking-work" target="_blank">Come funziona lo staking di criptovaluta?</a></p>
<h2 id="h2-Argomenti20contro20la20teoria20della20centralizzazione979000"><a name="Argomenti contro la teoria della centralizzazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Argomenti contro la teoria della centralizzazione</h2><p>Mentre la questione della centralizzazione può sembrare molto logica, ci sono forti argomenti contrari. In primo luogo, Lido ha molti operatori di nodi e moduli di staking, il che rende impossibile per tutti loro colludere e manipolare la rete Ethereum.</p>
<p>Inoltre, anche se Lido sviluppa e protegge la piattaforma di staking, non può influenzare gli operatori dei nodi a fare qualcosa che potrebbe minacciare la rete ethereum. Questo perché gli operatori dei nodi non possono mai seguire ciecamente i dettami di Lido poiché rischiano di perdere le loro ricompense in blocchi.</p>
<p>Hanno paura di tagliare, una penalità per i validatori che si comportano male. In pratica, potrebbero perdere i loro ETH in gioco se vanno contro i requisiti della rete Ethereum. Ad esempio, se danneggiano la rete o ostacolano la conclusione delle transazioni, perderanno porzioni dei loro ETH in gioco oltre al reddito previsto.</p>
<p>In realtà, l’obiettivo principale di Lido è decentralizzare la rete. Crea un equilibrio nell’ecosistema di Ethereum incorporando molti operatori di nodi nel sistema di convalida.</p>
<p>Molte persone apprezzano Lido perché consente agli individui di partecipare al processo di staking che ha impedito a pochi investitori balenotteri di ETH di assicurare la rete. È da notare che Lido non ha concentrato ETH in pochi operatori di nodi, il che ha ulteriormente decentralizzato il sistema di convalida di Ethereum.</p>
<p>Altri critici hanno fatto notare che le persone che attaccano Lido per la creazione di centralizzazione lo fanno come espediente pubblicitario per promuovere le proprie piattaforme di staking liquido. In realtà, Lido sta lavorando per aumentare il numero di operatori di nodi a 5.000, il che scoraggerà comportamenti anticoncorrenziali tra di loro.</p>
<h2 id="h2-Come20la20polemica20di20Lido20potrebbe20influenzare20il20sistema20di20staking20liquido20pi20ampio763687"><a name="Come la polemica di Lido potrebbe influenzare il sistema di staking liquido più ampio?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come la polemica di Lido potrebbe influenzare il sistema di staking liquido più ampio?</h2><p>Alla luce degli effetti percepiti della centralizzazione di Lido, altre piattaforme di staking liquido di Ethereum stanno lavorando duramente per ridurne la dominanza. Puffer Finance, StakeWise, Stader Labs, <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a> e Diva Staking, le altre principali piattaforme di staking liquido hanno promesso di aumentare la loro quota di mercato al fine di ridurre la dominanza di Lido.</p>
<p>Molti esperti ritengono che il coordinamento <a href="https://www.gate.io/price/view/liquid-staking-tokens" target="_blank">nel settore dello staking liquido</a> è più importante della concorrenza. Questo perché la polarizzazione nel delegare ETH a scopo di convalida potrebbe creare minacce per l’intero sistema di convalida.</p>
<p>Già, gli altri protocolli di liquid staking si sono imposti un’autolimitazione del 22% degli ETH in staking. Tuttavia, Lido non è d’accordo e punta alla supremazia. Questo potrebbe costringere le altre piattaforme ad aumentare il volume degli ETH in staking per contrastare la mossa di Lido.</p>
<h2 id="h2-Conclusion710198"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>La piattaforma di liquid staking di Lido ha aumentato la sua dominanza, controllando il 33% degli ETH attualmente staked. Tuttavia, le altre piattaforme di liquid staking come Puffer Finance, StakeWise, Stader Labs, <a href="/price/rocket-pool-rpl" target="_blank" class="blog_inner_link">Rocket Pool</a> e Diva Staking mirano ad aumentare la loro quota di mercato. Molti analisti di blockchain ritengono che la dominanza di Lido nello staking di ETH non rappresenti una seria minaccia per la rete Ethereum.</p>
<h2 id="h2-Domande20frequenti20su20Liquid20Staking827026"><a name="Domande frequenti su Liquid Staking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Liquid Staking</h2><h3 id="h3-Lido2020sicuro20per20lo20staking369626"><a name="Lido è sicuro per lo staking?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lido è sicuro per lo staking?</h3><p>In generale, Lido è sicuro per lo staking di ETH, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e altri token di protocollo. La piattaforma ha un valore totale bloccato di oltre $14 miliardi in asset cripto. Ha inoltre subito vari audit di protocollo per migliorare la sua sicurezza. Tuttavia, come qualsiasi altro protocollo basato su smart contract, Lido potrebbe avere bug in futuro.</p>
<h3 id="h3-Come20fare20lo20staking20su20Gateio184892"><a name="Come fare lo staking su Gate.io?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come fare lo staking su Gate.io?</h3><p>Gli investitori possono scommettere i loro asset cripto su Gate.io attraverso la partecipazione al programma Hold and Earn. Dopo aver verificato il proprio account, l’investitore dovrebbe visitare <a href="https://www.gate.io/hodl" target="_blank">Sezione Hold and Earn di Gate.io</a> dove lui/lei seleziona la criptovaluta da puntare. L’investitore può bloccare la sua criptovaluta per un periodo compreso tra 7 e 90 giorni.</p>
<h3 id="h3-Staking20ETH20con20Lido2020rischioso564096"><a name="Staking ETH con Lido è rischioso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Staking ETH con Lido è rischioso?</h3><p><a href="https://www.gate.io/learn/articles/how-to-stake-eth/209" target="_blank">È sicuro scommettere ETH</a> con Lido puoi guadagnare una ricompensa per questo. Quando scommetti ETH, ottieni token di liquid staking (LST) equivalenti all’importo dei tuoi ETH scommessi. Tuttavia, il protocollo potrebbe sviluppare bug che potrebbero mettere a rischio gli ETH scommessi.</p>
<h3 id="h3-Qual2020la20percentuale20di20staking20a20Lido274309"><a name="Qual è la percentuale di staking a Lido?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la percentuale di staking a Lido?</h3><p>Lido offre un rendimento del 3,5% per lo staking di Ethereum. Tuttavia, la piattaforma addebita anche una commissione del 10% sulle ricompense dello staking, che viene divisa tra l’operatore del nodo e il tesoro DAO.</p>
<h3 id="h3-Lido2020staking20liquido140024"><a name="Lido è staking liquido?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lido è staking liquido?</h3><p>Lido è un protocollo che offre servizi di staking liquido per diversi token o monete di protocollo. L’investitore riceve i suoi token di staking liquido (LST) il cui valore è equivalente a quello del token staked. Pertanto, l’investitore può scambiare i LST o investirli altrove.</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 alcun suggerimento 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, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>