UHVmZmVyIEZpbmFuY2UncyBpbm5vdmF0aWV2ZSBzcHJvbmc6IEhldCBvdmVyYnJ1Z2dlbiB2YW4gZGUgbGlxdWlkaXRlaXRza2xvdmVuIHZhbiBFdGhlcmV1bSBtZXQgQmFzZSBSb2xsdXBz

2024-07-10, 01:54

<p><img src="https://gimg2.gateimg.com/image/article/1720576532sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR670502"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Met Puffer Finance <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> validators kunnen nu 1 ETH inzetten.</p>
<p>Het Ethereum-netwerk wordt veiliger dan voorheen door de deelname van veel validators.</p>
<p>Het staken en opnieuw staken van Puffer Finance zal een hoger rendement genereren voor Ethereum-stakers dan voorheen.</p>
<h2 id="h2-Inleiding160184"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Puffer Finance, dat opereert op de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain, is een van de toonaangevende platforms die crypto staking en restaking services aanbiedt. Het protocol heeft het voor stakers gemakkelijker gemaakt om deel te nemen aan het validatieproces van Ethereum door de vereiste gestaakte ETH te verminderen. In dit artikel wordt de technologie besproken die Puffer Finance gebruikt om zijn visie te realiseren. We zullen ook kijken naar de bijdrage ervan aan het Ethereum-ecosysteem en de hele blockchainsector.</p>
<h2 id="h2-Puffer20Finances20Focus20op20Liquid20Staking20Derivaten20LSD20Haar20Bijdrage20aan20het20Ethereumecosysteem855188"><a name="Puffer Finance’s Focus op Liquid Staking Derivaten (LSD): Haar Bijdrage aan het Ethereum-ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Puffer Finance’s Focus op Liquid Staking Derivaten (LSD): Haar Bijdrage aan het Ethereum-ecosysteem</h2><p>Puffer Finance, a <a href="https://www.gate.io/learn/articles/what-is-puffer-finance-all-you-need-to-know-about-pufeth/2330" target="_blank">blockchain-gebaseerd project</a> Puffer Finance, gebouwd op het Eigenlayer-protocol van Ethereum en gericht op het staken van vloeibare derivaten (LSD), heeft een partnerschap gesloten met de Ethereum Foundation om rollups te ontwikkelen op basis van beveiliging na het veiligstellen van $18 miljoen aan durfkapitaal. Het belangrijkste doel van Puffer Finance is om zijn mainnet te lanceren, een platform waar stakers en validators hun crypto-activa zullen staken en opnieuw zullen staken.</p>
<p>Based rollups zijn een technologie om de operaties van layer-1 blockchains te stroomlijnen door transacties off-chain te verwerken, waardoor congestie wordt verminderd en schaalbaarheid wordt verbeterd. De rollups bundelen vervolgens de transacties in één definitieve transactie. Puffer Finance, met een TVL van $1,7 miljard, is trending in de crypto nieuwssector vanwege zijn opbrengstgeneratie en gedecentraliseerde validatieprovisies.</p>
<p>In feite biedt Puffer Finance crypto-investeerders een lucratieve verdienmogelijkheid. Het stelt investeerders in staat <a href="https://www.gate.io/learn/articles/staking-innovation-an-in-depth-look-at-puffer-finance/2981" target="_blank">om ETH te staken en staking en restaking opbrengst in ruil te krijgen</a>. Dus, afgezien van het staken van ETH als het primaire actief, kunnen de investeerders ook het protocol’s Native Liquid Restaking Token (nLRT) opnieuw inzetten. Puff Finance’s nLRT, bekend als pufETH, gebruikt ETH als onderpand in plaats van de traditionele Liquid Staking Tokens (LST’s). Als gevolg hiervan profiteren de investeerders van traditionele PoS-opbrengsten en opbrengsten uit opnieuw inzetten. <a href="https://www.gate.io/learn/articles/puffer-finance-overcoming-the-centralization-dilemma-of-the-lst-lrt-track/3148" target="_blank">gegenereerd via Eigenlayer slimme contracten</a>. Let ook op dat de pufETH-stakers beloningen verdienen van protocollen waarmee Puff Finance heeft samengewerkt.</p>
<h2 id="h2-Puffer20Finances20Scaling20Solution20Het20gebruik20van20Base20Roll20Ups20en20Sequencing12702"><a name="Puffer Finance’s Scaling Solution: Het gebruik van Base Roll Ups en Sequencing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Puffer Finance’s Scaling Solution: Het gebruik van Base Roll Ups en Sequencing</h2><p>Rollups en op sequentie gebaseerde sequentiëring vormen de basis van Puff Finance’s beoogde architectuur die de interoperabiliteit tussen slimme contracten zal verbeteren om liquiditeitsfragmentatie die op dit moment de dienst uitmaakt in de DeFi-sector te verminderen of te elimineren. Liquiditeitsfragmentatie verwijst naar het bestaan van liquiditeitspools die onafhankelijk van elkaar zijn in de DeFi-sector. Met andere woorden, er is geen geconsolideerde en gemakkelijk toegankelijke liquiditeitsmarkt in de branche.</p>
<p>Amir Fourouzani, medeoprichter van Puffer Finance, ziet liquiditeitsfragmentatie als een van de belangrijkste uitdagingen die bestaan ​​in de DeFi-sector. Tijdens een <a href="https://cointelegraph.com/news/ethereum-lsd-solution-puffer-finance-moves-to-base-rollups" rel="nofollow noopener noreferrer" target="_blank">In een interview met Cointelegraph zei Fourouzani</a>, “Momenteel is er een uitdaging in het Ethereum-ecosysteem die bekend staat als liquiditeitsfragmentatie. Dit probleem ontstaat doordat huidige L2-projecten elk hun eigen ‘superketens’ creëren, wat leidt tot geïsoleerde liquiditeitspools.”</p>
<p>De technologie die sommige crypto-projecten zoals <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, Arbitrum en ZKSync maken gebruik van het bevorderen van onafhankelijke ‘super chains’ die liquiditeitspools scheiden, wat resulteert in fragmentatie. Zo heeft de technologie van Puff Finance (gebaseerde sequentiëring en gebaseerde rollups) geleid tot een DeFi-revolutie waarbij appchains communiceren en liquiditeit delen.</p>
<p>Fourouzani voegde eraan toe: “Om dit aan te pakken, heeft de industrie oplossingen nodig zoals based-sequencing en based rollups om interoperabiliteit en communicatie tussen deze ketens te waarborgen.” Om dit te bereiken legde Fourouzani uit dat Puff Finance een methode heeft bedacht om pre-bevestigingen op Ethereum-lagen te organiseren op een manier die het netwerk gedecentraliseerd houdt. De samenwerking tussen Ethereum Foundation en Puff Finance toont het streven van beide organisaties om schaalbaarheid en interoperabiliteit te verbeteren via based-sequencing en rollups.</p>
<p>In reactie hierop zei hij: <a href="https://cointelegraph.com/news/ethereum-lsd-solution-puffer-finance-moves-to-base-rollups" rel="nofollow noopener noreferrer" target="_blank">Fourouzani zei</a>, ‘Het heeft ons jaren gekost om dit te ontwerpen en te ontwikkelen, maar nu hebben we het. Dit is het huidige centrale onderzoeksgebied van de Ethereum Foundation. De thought leaders daar proberen dit vooruit te stuwen met leiders zoals Justin Drake en anderen,’.<br>Hij gaf ook details van een mogelijke scenario waarin protocollen liquiditeit delen. ‘In de toekomst zal elk bedrijf zijn eigen host AppChain hebben. Laten we zeggen, <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> heeft zijn eigen AppChain en liquidatie gaat <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> treffen; nou, het wordt vertegenwoordigd op <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> onmiddellijk op Uniswap’s AppChain. Dit is de ultieme droom. <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> en Aave hoeven niet via een governance token te gaan of afhankelijk te zijn van een governance proces.</p>
<p>Dezelfde expert legde uit hoe interoperabele app-ketens de bloei van yield farming binnen het Ethereum-ecosysteem mogelijk zullen maken. Hij zei: ‘Veel gebruikers hebben liever dat hun tokens rendement genereren zonder moeite in hun portefeuilles, in plaats van deze alleen op de basisketen te houden.’ De interoperabiliteit die de AppChain zal verbeteren, zal dit mogelijk maken.</p>
<p>Lees ook: <a href="https://www.gate.io/how-to-buy/pufeth-pufeth &quot;How to Buy pufETH (PUFETH" rel="nofollow noopener noreferrer" target="_blank">Hoe pufETH (PUFETH) te kopen</a>”)</p>
<h2 id="h2-Het20onmogelijke20mogelijk20maken20Hoe20de20LSDtechnologie20van20Puffer20Finance20werkt604216"><a name="Het onmogelijke mogelijk maken: Hoe de LSD-technologie van Puffer Finance werkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het onmogelijke mogelijk maken: Hoe de LSD-technologie van Puffer Finance werkt</h2><p>Puffer Finance heeft nog een geweldige innovatie in de vorm van zijn LSD-technologie waarmee Ethereum-validatoren slechts 1 ETH in plaats van 32 ETH kunnen staken. Deze technologie stelt de validatoren in staat om Puffer vloeibare restakingtokens (nLRT’s) te verdienen en daardoor extra inkomen te genereren. Daarom kunnen de stakers de nLRT-tokens opnieuw inzetten en beloningen daarvoor verdienen.</p>
<p>In zijn Medium-post, <a href="https://medium.com/puffer-fi/introduction-to-puffer-finance-57f5483a5cee" rel="nofollow noopener noreferrer" target="_blank">Puffer Finance zei</a>, “We verlagen de toetredingsdrempels aanzienlijk om een validator te laten draaien; waar een typische validator een 32 ETH-borg moet inzetten om deel te nemen, stelt Puffer iedereen in staat om een validator te bedienen met slechts ‘1 ETH’. Deze verminderde toetredingseis stelt Node Operators in staat om vergelijkbare opbrengstpotentieel te behalen als traditionele ETH-stakers, waardoor hun rendement wordt verhoogd zonder significante initiële investering, terwijl tegelijkertijd het decentrale en robuuste kader van Ethereum behouden blijft.”</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/the-hype-of-restaking-narratives-what-are-the-restaking-projects-beyond-the-ethereum-eco/1699" target="_blank">De Hype van Restaking Narratieven</a></p>
<h2 id="h2-De20toekomst20van20Puffer20Finance20in20het20Ethereumecosysteem20en20DeFi579626"><a name="De toekomst van Puffer Finance in het Ethereum-ecosysteem en DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De toekomst van Puffer Finance in het Ethereum-ecosysteem en DeFi</h2><p>Puffer Finance heeft veel te bieden aan het Ethereum-ecosysteem. Ten eerste bevordert het de decentralisatie van het netwerk door de kapitaalvereisten voor Ethereum-validatoren te verlagen. Dit komt doordat veel validatoren zullen deelnemen aan het netwerk.</p>
<p>De toename van het aantal validators zal de beveiliging en integriteit van het netwerk verder versterken. Hierover gesproken, <a href="https://medium.com/puffer-fi/introduction-to-puffer-finance-57f5483a5cee" rel="nofollow noopener noreferrer" target="_blank">Puff Finance zei</a>, ‘Laten we onze kernmissie onderstrepen: het verbeteren, beveiligen en decentraliseren van het Ethereum-ecosysteem door middel van innovatieve restaking-oplossingen.’</p>
<p>Het vervolgde: “Puffer gaat niet alleen over het aanbieden van een platform voor staking; we stellen nieuwe normen in hoe het Ethereum-netwerk werkt, zorgen ervoor dat het robuust, gedecentraliseerd en winstgevend blijft. Door native te integreren <a href="https://www.gate.io/learn/articles/why-has-re-staking-dominated-social-media/2075" target="_blank">herbeleggen op EigenLayer</a>, we breiden levensvatbare inkomstenstromen uit voor node operators en stakers, zodat iedereen die betrokken is, kan genieten van verbeterde beloningen en meer veiligheid.</p>
<p>Lees ook meer over <a href="https://www.gate.io/learn/articles/staking-restaking-and-lrtfi/2003" target="_blank">Staken, opnieuw staken en LRTfi</a></p>
<h2 id="h2-Conclusie685222"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Puffer Finance heeft veel te bieden aan het Ethereum-ecosysteem en de DeFi-sector in het algemeen. Zo heeft het ruimte gecreëerd voor veel mensen om te investeren in ETH en de DeFi-sector. Veel investeerders kunnen nu validators worden dankzij Puff Finance, dat hen in staat stelt deel te nemen aan het validatieproces door slechts 1 ETH te staken. Het Ethereum-netwerk zal ook veiliger worden dan voorheen door de actieve betrokkenheid van veel validators.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em> Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt genoemd. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>