RGUgTGlkbyBMaXF1aWQgU3Rha2luZyBDb250cm92ZXJzZTogT25kZXJ6b2VrIG5hYXIgR292ZXJuYW5jZSBlbiBDb250cm9sZQ==

<p><img src="https://gimg2.gateimg.com/image/article/1692587501guide.jpeg" alt=""><br>Trefwoorden: Liquid staking, Lido-protocol, proof-of-stake-protocol, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain, gestaked ETH, vloeibaar stakings token (LST), stakings afgeleide token, Lido governance, vloeibaar staken van ETH, dominantie van Lido in vloeibaar staken van ETH, centralisatie van Lido, delegeren van ETH</p>
<h2 id="h2-Introductie994921"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Liquid staking is een van de meest winstgevende crypto-investeringen waarbij <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en andere tokens betrokken zijn op basis van protocollen die <a href="https://www.gate.io/learn/articles/what-is-proof-of-stake/60" target="_blank">gebruik het proof-of-staking consensusmechanisme</a>. Een opvallend probleem met betrekking tot vloeibaar staken is het bestaan van een schaduwtoken dat extra beloningen kan opleveren voor de belegger.</p>
<p>In dit artikel onderzoeken we hoe vloeibaar staken werkt op het Lido-protocol. We zullen ook de huidige controverse rondom het Lido-stakingsplatform bespreken.</p>
<p>Lees ook: <a href="/price/safepal-sfp" rel="nofollow noopener noreferrer" target="_blank">Wat is Leased Proof of Stake (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)”) en [SafePal crypto</a>?“)</p>
<h2 id="h2-Vloeibare20staking470782"><a name="Vloeibare staking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vloeibare staking</h2><p>Laten we de tijd nemen om te begrijpen wat vloeibaar staken is voordat we ons concentreren op de specifieke aspecten ervan. Vloeibaar staken is een crypto-investeringsoplossing waarmee gebruikers liquiditeit kunnen krijgen voor de cryptocurrencies die ze gestaked hebben. Bovendien verdienen de investeerders een extra beloning voor het staken van een munt zoals ETH.</p>
<p>Liquid staking overwint het belangrijkste probleem waar investeerders in <a href="https://www.gate.io/learn/articles/what-is-pos-staking/10" target="_blank">bewijs van aandeel</a> gebruikte protocollen om mee te maken. De investeerders die hun munten gebruikten om een netwerk zoals Ethereum te beveiligen, konden hun ingezette munten niet gebruiken.</p>
<p>In het verleden zouden de knooppunten die transacties valideerden op de Ethereum blockchain hun ETH voor onbepaalde tijd inzetten. Dat betekende dat ze de ingezette munten niet konden gebruiken. Zo konden ze bijvoorbeeld de ingezette ETH niet als onderpand gebruiken wanneer ze DeFi-leningen wilden krijgen.</p>
<p>Liquid staking lost dit probleem op. Dit komt doordat de investeerder een token krijgt dat de gestaakte ETH vertegenwoordigt, dat hij/zij voor andere doeleinden kan gebruiken, zoals yield farming.</p>
<p>De belegger kan de vloeibare staking token (LST) op verschillende manieren gebruiken. Bijvoorbeeld, hij/zij kan het verhandelen op cryptobeurzen wat een extra inkomstenstroom creëert. Opnieuw kan de belegger de LST overdragen naar andere platforms of uitgeven zonder zijn/haar gestaakte ETH te beïnvloeden.</p>
<p>Desalniettemin is het belangrijk op te merken dat de investeerder de LST moet teruggeven aan het staken. <a href="https://www.gate.io/learn/articles/what-is-lido/171" target="_blank">platform zoals Lido</a> om zijn/haar gestaakte ETH op te eisen. Wanneer je <a href="https://www.gate.io/how-to-buy/lido-staked-ether-steth" target="_blank">zet ETH in bij Lido en krijg stETH</a>, zijn vloeibare stakings-token, dat dezelfde waarde heeft als ETH.</p>
<h2 id="h2-Wat20is20Lido156619"><a name="Wat is Lido?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Lido?</h2><p>Lido is een liquid staking protocol dat zijn staking services biedt voor verschillende blockchains, waaronder Ethereum. Het platform stelt gebruikers in staat om hun protocol tokens te staken zonder ze vast te zetten.</p>
<p>Desalniettemin, <a href="https://www.gate.io/how-to-buy/lido-dao-ldo" target="_blank">Lido</a> is bekend om Ethereum-investeerders in staat te stellen hun ETH te staken en de vloeibare stakingsafgeleide token (LST) te verkrijgen <a href="https://www.gate.io/price/lido-staked-ether-steth" target="_blank">genaamd stETH</a>. Lido delegeert vervolgens de gestaakte ETH naar verschillende node operators <a href="https://www.gate.io/blog_detail/2905/a-comprehensive-guide-on-verifying-ethereum-transactions" target="_blank">mensen die transacties verifiëren op het Ethereum-netwerk</a>.</p>
<p>De ETH-investeerders kunnen hun stETH gebruiken voor andere doeleinden zoals lenen. Een van de belangrijkste voordelen van Lido is dat het investeerders met minder dan 32 ETH in staat stelt om ze in te zetten en een deel van de Ethereum-blokprijzen te verdienen.</p>
<p>Belangrijker nog, Lido gebruikt een zelfbeheerd systeem voor protocoltokens zoals ETH. Dit betekent dat de ingezette tokens te allen tijde onder de hoede van de investeerder blijven. Vanaf het moment dat de investeerder de token inzet tot het moment dat deze aan een validator is toegewezen, blijft deze onder zijn/haar eigendom.</p>
<h2 id="h2-Lido20Governance970180"><a name="Lido Governance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lido Governance</h2><p>Op dit moment maakt Lido gebruik van dezelfde governance structuur als veel gedecentraliseerde autonome organisaties (DAO’s) waar de houders van het protocoltoken het recht hebben om bij te dragen aan het besluitvormingsproces.</p>
<p>In dit g nemen de houders van Lido’s eigen governance-token, LDO, deel aan de besluitvorming via het stemmechanisme. Interessant is dat Lido een token-gewogen stemsysteem gebruikt, wat betekent dat een investeerder die veel LDO-tokens bezit veel meer stemkracht heeft dan iemand met minder tokens. De LDO-houders stemmen on-chain voor de gegeven voorstellen.</p>
<p>Er is echter een voorstel om het Lido-bestuurssysteem te wijzigen. De gemeenschap stelt voor om een dubbel bestuurssysteem in te voeren waarbij zowel LDO- als stETH-houders het recht hebben om een veto uit te spreken over bepaalde voorstellen. Dit zal ervoor zorgen dat de belangen van stETH-investeerders te allen tijde worden beschermd.</p>
<h2 id="h2-Lido20behoudt20veel20controle20over20Liquid20Staking587176"><a name="Lido behoudt veel controle over Liquid Staking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lido behoudt veel controle over Liquid Staking</h2><p>Sommige analisten hebben erop gewezen dat Lido een groot deel van het vloeibare staken van ETH in handen heeft. Specifiek controleert Lido meer dan 33% van de gestaakte ETH, iets waar een bepaald kwart van de ETH-markt niet blij mee is.</p>
<p>Met ongeveer een derde van de ingezette ETH onder controle van Lido, zijn sommige critici van mening dat het ethereum-netwerk wordt bedreigd. Ze roepen andere liquid staking-platforms op om manieren te vinden om hun ingezette ETH te verhogen.</p>
<h2 id="h2-Zorgen20en20kritiek20over20de20dominantie20van20Lido20in20ETH20Liquid20Staking499521"><a name="Zorgen en kritiek over de dominantie van Lido in ETH Liquid Staking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zorgen en kritiek over de dominantie van Lido in ETH Liquid Staking</h2><p>De grootste kritiek op de dominante positie van Lido in ETH liquid staking is dat het centralisatie creëert. Dit kan een negatieve invloed hebben op de veiligheid van het Ethereum blockchain als er iets slechts gebeurt met Lido.</p>
<p>Sommige analisten hebben betoogd dat de dominantie van Lido kan leiden tot externe manipulatie van het Ethereum-netwerk, wat zijn stabiliteit kan destabiliseren. Netwerkmanipulatie kan van invloed zijn op het off-chain netwerkgouvernancesysteem van Ethereum.</p>
<p>Het tweede punt van zorg met betrekking tot de dominantie van Lido in <a href="https://www.gate.io/blog_detail/3103/analyzing-eth-price-impact-eth-staking" target="_blank">ETH staking</a> is dat de beveiliging van het Ethereum-netwerk in gevaar komt als het protocol wordt gehackt en het grootste deel, zo niet alle, van de ingezette ETH wordt gestolen.</p>
<p>Op dezelfde manier ondermijnt de concentratie van gestapelde ETH onder Lido uiteindelijk de gedecentraliseerde aard van het Ethereum-blockchain. Evan Van Ness, een Ethereum-ontwikkelaar, bekritiseerde de dominantie van Lido op X (voorheen Twitter). Hij schreef: ‘Lido kan de grootste aanval zijn op de decentralisatie van Ethereum in onze hele geschiedenis.’</p>
<p>Ondanks dat Lido veel gedecentraliseerde autonome organisaties onder zich heeft, kan het de manier waarop ze opereren en zichzelf besturen centraliseren. Er is ook een mogelijkheid van samenspanning tussen de node-operators. Hierdoor kunnen ze een grote invloed hebben op de definitieve Ethereum-blokken.</p>
<p>Een ander probleem kan ontstaan als Lido wordt bedreigd door sterke overheden zoals de Verenigde Staten. Zo’n bedreiging kan Lido dwingen om sommige activiteiten te censureren om strafrechtelijke vervolging door de overheid te vermijden. Zo kan het bijvoorbeeld stETH-transacties blokkeren van bepaalde digitale portefeuilles zoals degene die worden gesanctioneerd door de federale overheid.</p>
<p>Gerelateerde artikelen:<br><a href="https://www.gate.io/blog_detail/328/what-is-cryptocurrency-staking" target="_blank">Wat is Cryptocurrency Staking?</a> <a href="https://www.gate.io/blog_detail/1826/how-does-crypto-staking-work" target="_blank">Hoe werkt Crypto Staking?</a></p>
<h2 id="h2-Argumenten20tegen20de20Centralisatietheorie752287"><a name="Argumenten tegen de Centralisatietheorie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Argumenten tegen de Centralisatietheorie</h2><p>Hoewel het probleem van centralisatie zeer logisch lijkt, zijn er sterke argumenten tegen. Ten eerste heeft Lido veel node-operators en staking-modules, waardoor het onmogelijk is dat ze allemaal samenspannen en het Ethereum-netwerk manipuleren.</p>
<p>Bovendien kan Lido, hoewel het de stakingsplatform ontwikkelt en beveiligt, de node-operators niet beïnvloeden om iets te doen wat het ethereum-netwerk in gevaar kan brengen. Dit komt doordat de node-operators nooit blindelings de bevelen van Lido kunnen opvolgen, aangezien ze het risico lopen hun blokbeloningen te verliezen.</p>
<p>Ze zijn bang voor slashing, een straf voor validators die zich misdragen. Kortom, ze kunnen hun ingezette ETH verliezen als ze tegen de vereisten van het Ethereum-netwerk ingaan. Als ze bijvoorbeeld het netwerk schaden of de afronding van transacties belemmeren, verliezen ze delen van hun ingezette ETH, evenals de verwachte inkomsten.</p>
<p>In feite is het echte doel van Lido om het netwerk te decentraliseren. Het creëert een balans in het Ethereum-ecosysteem door veel knoopoperators op te nemen in het validatiesysteem.</p>
<p>Veel mensen houden van Lido omdat het individuen in staat stelt deel te nemen aan het staking proces, wat voorkomt dat enkele ETH whale investeerders het netwerk beveiligen. Opvallend is dat Lido ETH niet heeft geconcentreerd bij een paar node operators, wat het validatiesysteem van Ethereum verder gedecentraliseerd heeft.</p>
<p>Andere critici hebben erop gewezen dat degenen die Lido aanvallen omdat het centralisatie creëert, dit doen als een marketingstunt om hun eigen vloeibare stakingsplatforms te promoten. Lido werkt feitelijk aan het vergroten van het aantal node-operators tot 5.000, wat anti-concurrentiegedrag onder hen ontmoedigt.</p>
<h2 id="h2-Hoe20kan20de20controverse20van20Lido20het20bredere20liquid20staking20systeem20benvloeden76153"><a name="Hoe kan de controverse van Lido het bredere liquid staking systeem beïnvloeden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kan de controverse van Lido het bredere liquid staking systeem beïnvloeden?</h2><p>Gezien de waargenomen effecten van de centralisatie van Lido werken andere Ethereum vloeibare stakingsplatforms hard om zijn dominantie te verminderen. Puffer Finance, StakeWise, Stader Labs, <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a> en Diva Staking, de andere toonaangevende liquid staking platforms hebben beloofd hun marktaandeel te vergroten om de dominantie van Lido te verminderen.</p>
<p>Veel experts geloven dat coördinatie <a href="https://www.gate.io/price/view/liquid-staking-tokens" target="_blank">in de sector van vloeibaar staken</a> is belangrijker dan concurrentie. Dit komt doordat polarisatie bij het delegeren van ETH voor validatiedoeleinden bedreigingen kan creëren voor het gehele validatiesysteem.</p>
<p>Tot nu toe hebben de andere vloeibare stakingsprotocollen zichzelf een zelfbeperking opgelegd van 22% van de gestaakte ETH. Lido is het hier echter niet mee eens en gaat voor dominantie. Dit kan de andere platforms dwingen om de hoeveelheid gestaakte ETH te verhogen om de zet van Lido tegen te gaan.</p>
<h2 id="h2-Conclusie702521"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Het vloeibare stakingsplatform van Lido heeft zijn dominantie vergroot, aangezien het 33% van de momenteel gestaakte ETH controleert. Desalniettemin streven de andere vloeibare stakingsplatforms zoals Puffer Finance, StakeWise, Stader Labs, <a href="/price/rocket-pool-rpl" target="_blank" class="blog_inner_link">Rocket Pool</a> en Diva Staking ernaar om hun marktaandeel te vergroten. Veel blockchain-analisten geloven dat de dominantie van Lido in ETH-staking waarschijnlijk geen ernstige bedreiging vormt voor het Ethereum-netwerk.</p>
<h2 id="h2-Veelgestelde20vragen20over20Liquid20Staking553847"><a name="Veelgestelde vragen over Liquid Staking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Liquid Staking</h2><h3 id="h3-Is20Lido20veilig20voor20staking65868"><a name="Is Lido veilig voor staking?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Lido veilig voor staking?</h3><p>Over het algemeen is Lido veilig voor het inzetten van ETH, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en andere protocol tokens. Het platform heeft een totale waarde vergrendeld van meer dan $14 miljard aan crypto activa. Het heeft ook verschillende protocol audits ondergaan om de beveiliging te verbeteren. Echter, zoals elk ander smart contract gebaseerd protocol kan Lido in de toekomst bugs hebben.</p>
<h3 id="h3-Hoe20kan20ik20staken20op20Gateio738472"><a name="Hoe kan ik staken op Gate.io?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kan ik staken op Gate.io?</h3><p>Beleggers kunnen hun crypto-activa op Gate.io inzetten door deel te nemen aan het Hold and Earn-programma. Na het verifiëren van zijn account, moet een belegger de <a href="https://www.gate.io/hodl" target="_blank">Gate.io Houd en Verdien Sectie</a> waar hij/zij de cryptocurrency selecteert om te staken. De investeerder kan zijn/haar cryptocurrency voor een periode van tussen 7 en 90 dagen vastzetten.</p>
<h3 id="h3-Is20het20riskant20om20ETH20te20staken20met20Lido542283"><a name="Is het riskant om ETH te staken met Lido?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is het riskant om ETH te staken met Lido?</h3><p><a href="https://www.gate.io/learn/articles/how-to-stake-eth/209" target="_blank">Het is veilig om ETH te staken</a> met Lido kun je daarvoor een beloning verdienen. Wanneer je ETH staked, ontvang je Liquid staking tokens (LST) die equivalent zijn aan het bedrag van je gestakede ETH. Desalniettemin kan het protocol bugs ontwikkelen die het gestakede ETH in gevaar kunnen brengen.</p>
<h3 id="h3-Wat20is20het20percentage20van20staking20bij20Lido578295"><a name="Wat is het percentage van staking bij Lido?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het percentage van staking bij Lido?</h3><p>Lido biedt 3,5% staking beloningen voor Ethereum. Echter, het platform brengt ook een 10% vergoeding in rekening over de staking beloningen, die het verdeelt tussen de node-operator en de DAO-schatkist.</p>
<h3 id="h3-Is20Lido20vloeibaar20staken703764"><a name="Is Lido vloeibaar staken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Lido vloeibaar staken?</h3><p>Lido is een protocol dat liquid staking-diensten aanbiedt voor verschillende protocoltokens of -munten. De belegger ontvangt zijn Liquid staking tokens (LST’s) waarvan de waarde gelijk is aan die van de gestakede token. Daarom kan de belegger de LST’s verhandelen of ergens anders beleggen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em> Gate.io behoudt alle rechten voor dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>