Z2F0ZUxpdmUgQU1BIFJlY2FwLVBvdGxvZGVuIFByb3RvY29s

<p><img src="https://gimg2.gateimg.com/image/article/1727417536dapp.png" alt=""></p>
<h2 id="h2-Q120Hoe20verbetert20uw20Scroll20Native20Gateway20het20gebruik20van20activa20En20deel20de20belangrijkste20hoogtepunten20met20het20publiek8262"><a name="Q1. Hoe verbetert uw Scroll Native Gateway het gebruik van activa? En deel de belangrijkste hoogtepunten met het publiek?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1. Hoe verbetert uw Scroll Native Gateway het gebruik van activa? En deel de belangrijkste hoogtepunten met het publiek?</h2><p>Kernproducten:<br>Twee belangrijke pijlers:</p>
<ol>
<li><p>Een pijler is yield aggregatie. We hebben twee verschillende productlijnen in deze categorie, afgestemd op verschillende risicobereidheid van gebruikers.<br>-Yield Farming biedt laag risico, stabiele kansen voor risicomijdende gebruikers om rendementen en meerlaagse beloningen te verdienen.<br>-Vaults product is een innovatief centrum voor risicozoekende gebruikers om te streven naar geheven rendement via onze gediversifieerde strategieën, waaronder geheven farming, on-chain synthetica, exotische opties, delta natural, en andere specifieke risico-exposure kansen.</p>
</li><li><p>De andere pijler is Veilingen &amp; Winkels: we bieden niet alleen verschillende soorten token asset-lanceringen aan, maar ondersteunen ook niet-standaard token assets zoals game-onderdelen, NFT’s, nodes en RWA. Het dient als de toegang tot gebruikersverkeer door lucratieve vroege toegangsmogelijkheden te bieden.</p>
</li></ol>
<p>We worden ondersteund door topinstellingen in de ruimte, zoals OKX Ventures, Galxe, Animoca Brands, enzovoort, en we hebben onlangs ook aangekondigd dat we een nieuwe financiering van 80M waardering hebben ontvangen van Taisu, DePIN X, Bing Ventures en meer.</p>
<p>🚀Sterke sociale tractie:</p>
<ul>
<li>Geen.1 Inheemse dApp op 📜 Scroll</li><li>Geen.3 Farming dApp over alle ketens</li><li>TVL per sep 2024: $350M+</li><li>Onze actieve zk-geverifieerde gebruikersaantallen: 550K+</li></ul>
<h2 id="h2-Q220Kunt20u20meer20details20geven20over20het20nut20van20de20DAPPtoken20en20hoe20het20gebruikers20ten20goede20komt20binnen20het20Pencils20Protocolecosysteem20En20welke20deflationaire20mechanismen20beheren20de20goede20circulatie20en20aanvoer20van20DAPP212481"><a name="Q2. Kunt u meer details geven over het nut van de $DAPP-token en hoe het gebruikers ten goede komt binnen het Pencils Protocol-ecosysteem? En welke deflationaire mechanismen beheren de goede circulatie en aanvoer van $DAPP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2. Kunt u meer details geven over het nut van de $DAPP-token en hoe het gebruikers ten goede komt binnen het Pencils Protocol-ecosysteem? En welke deflationaire mechanismen beheren de goede circulatie en aanvoer van $DAPP?</h2><p><strong>Governance:</strong> $DAPP-tokens vervullen een essentiële rol binnen het ecosysteem van het Pencils Protocol, waarbij ze zowel praktisch nut als potentieel rendement bieden. Gebruikers kunnen $DAPP inzetten om governance-tokens ($pDAPP) te verdienen in een verhouding van 1:1. En stemmen over de belangrijke beslissingen van het protocol.</p>
<p><strong>Token Farming: </strong>Om langdurige betrokkenheid van de gemeenschap te bevorderen, zal het $DAPP-tokenstakingprogramma worden gelanceerd na TGE. Tokenhouders kunnen $DAPP inzetten in Pencils Protocol Farms om $pDAPP te ontvangen, die vervolgens verder kunnen worden ingezet of als liquiditeit kunnen worden verstrekt voor DEX, zodat gebruikers kunnen deelnemen aan het ecosysteem.</p>
<p><strong>Onderpand van het veilingplatform: </strong>Om activa op het veilingplatform te plaatsen, moeten verkopers $DAPP inzetten. Dit staking-mechanisme dient als bescherming tegen kwaadaardige activiteiten, waarbij de gemeenschap toezicht houdt op het veilingproces. Bij glen van wangedrag wordt het ingezette $DAPP herverdeeld onder de leden van de gemeenschap.</p>
<p><strong>Puntensysteem Rechten Mapping:</strong> Vroege deelnemers aan het Pencils Protocol zullen Pencils-punten ontvangen, die overeenkomen met rechten in $DAPP. In de toekomst zal $DAPP sommige functies van Pencils vervangen. Houders van $DAPP zullen ook voorrang krijgen bij nieuwe farming-methoden en preferentiële beleidsmaatregelen. Deze privileges omvatten hogere hefboomwerking en voorrang bij exclusieve, beperkte strategieproducten.</p>
<p><strong>Virtuele Winkel:</strong> In de virtuele winkel kunnen gebruikers $DAPP (de platformvaluta) gebruiken om te handelen met marge in NFT’s, Real-World Assets (RWAs), punten en derivaten, waarmee de bruikbaarheid en toepassing van hun bezittingen binnen het Pencils Protocol-ecosysteem wordt uitgebreid.</p>
<p><strong>Deflationair Mechanisme:</strong> Een groeimotor voor de waarde van $DAPP-token</p>
<p>Eén van de meest spannende kenmerken van ons Vaults Product is de toewijzing van 30% van de opbrengst van de kluis naar een leeg adres als $DAPP. Dit deflatoire mechanisme zal bijdragen aan de langdurige waardering van de $DAPP-token. Daarnaast zal de overige 70% van de opbrengst <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">stroom](/price/</a><a  rel="nofollow noopener noreferrer"  href=")-flow&quot;" target="_blank" class="blog _binnen_ [koppeling</a> >stroom in het ecosysteem en het ontwikkelingsfonds van de gemeenschap, dat prikkels zal bieden voor verschillende groeistadia, ter ondersteuning van de duurzame ontwikkeling van het ecosysteem en toekomstige gebruikersbetrokkenheid.</p>
<h2 id=" h2-q320hoe20zal20het20nieuwe20vaultsproduct20van20pencils20protocol20de20inkomsten20verhogen20door20middel20van20activahefboomwerking20en20liquiditeitsmining365346"=""></a><a name="Q3. Hoe zal het nieuwe Vaults-product van Pencils Protocol de inkomsten verhogen door middel van activa-hefboomwerking en liquiditeitsmining?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3. Hoe zal het nieuwe Vaults-product van Pencils Protocol de inkomsten verhogen door middel van activa-hefboomwerking en liquiditeitsmining?</p><p>Yield Farming biedt lage risico’s, stabiele kansen voor risicomijdende gebruikers om opbrengsten en meerlaagse beloningen te verdienen.</p>
<p>Vaults-product is een meer innovatieve hub voor risicozoekende gebruikers om te jagen op geheven opbrengst via onze gediversifieerde strategieën, waaronder geheven landbouw, on-chain synthetica, exotische opties, delta natuurlijk en andere specifieke blootstellingsmogelijkheden aan risico’s.</p>
<p>Pencils Protocol streeft ernaar om verschillende fasen van opbrengstbronnen te verenigen in de nieuwe Vaults-productlijn:</p>
<ol>
<li><p>Bovenstroomse beloningen vanaf de ondersteunende keten (Scroll, een van de grootste L2 op <a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">ethereum</a>-eth” target=”_blank” class=”blog_inner_link”&gt;Ethereum) en restaking infrastructuur, LSD, LRT, zoals StakeStone, Puffer, Kelp, Etherfi etc voor ETH staking activa; en Solv Protocol voor solvBTC-activa. Rendementen zijn gebaseerd op diverse gebruikersactiviteiten, waaronder lenen, uitlenen en hefboomwerking.</p>
</li><li><p>Bij neerwaartse beloningen breiden we uit naar AI- en FHE (Fully Homomorphic Encryption) ecoen. Activa die in Pencils Protocol zijn gestort, zullen certificaten verstrekken die stemrecht verlenen - wat we ‘op afstand stemmers’ noemen. Deze op afstand stemmers zullen fungeren als een Proof-of-Stake (PoS) mechanisme voor AI- en FHE-projecten, waaronder Zama, Fhenix, Singularity, BitTensor, Myshell en meer, wat een extra laag beloningen oplevert voor onze gebruikers.</p>
</li></ol>
<p>In wezen verenigt Pencils Protocol DeFi, AI en FHE in een enkel ecosysteem door middel van onze Farming en Vaults productlijnen.</p>
<h2 id="h2-Q420Vergelijk20met20andere20Defi20leg20alsjeblieft20de20verdienste20uit20van20het20gebruik20van20Potloden20Protocol51738"><a name="Q4: Vergelijk met andere Defi, leg alsjeblieft de verdienste uit van het gebruik van Potloden Protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Vergelijk met andere Defi, leg alsjeblieft de verdienste uit van het gebruik van Potloden Protocol</h2><p>Terwijl we afronden, wil ik graag een paar belangrijke punten benadrukken over het Pencils Protocol en waarom het opvalt in de DeFi-ruimte. Laten we het eerst hebben over DeFi en Yield Aggregation. Ons platform biedt unieke kansen die zowel geschikt zijn voor risicomijdende gebruikers als voor degenen die op zoek zijn naar meer avontuurlijke strategieën.</p>
<p>Voor degenen die liever minder risico nemen, bieden onze yield farming opties stabiele, betrouwbare opbrengsten en meerlaagse beloningen. Dit maakt het een aantrekkelijke keuze voor gebruikers die rendement willen verdienen zonder te veel risico te nemen.</p>
<p>Aan de andere kant is ons Vaults-product ontworpen voor degenen die hogere rendementen zoeken. Het fungeert als een innovatieve hub voor gebruikers die bereid zijn om geheven opbrengsten na te streven via een verscheidenheid aan strategieën. We hebben het over geheven farming, on-chain synthetica, exotische opties, delta-neutrale strategieën en andere gerichte risicobelichtingsmogelijkheden.</p>
<p>Een van onze belangrijkste doelen bij Pencils Protocol is het verenigen van verschillende bronnen van opbrengsten binnen onze nieuwe Vaults productlijn. Dit is hoe we het doen:<br>Upstream beloningen komen van ondersteunende ketens zoals Scroll, dat een van de grootste Layer 2 oplossingen op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> is. We nemen ook restaking-infrastructuur en LSD/LRT-protocollen op, zoals StakeStone, Puffer, Kelp en Etherfi voor ETH staking activa, samen met Solv Protocol voor solvBTC activa. Deze beloningen zijn gebaseerd op verschillende gebruikersactiviteiten, waaronder lenen, uitlenen en hefboomwerking.</p>
<p>Downstream rewards breiden zich uit naar spannende gebieden zoals AI en volledig homomorfe encryptie (FHE) ecoen. Wanneer u activa stort in het Pencils Protocol, ontvangt u certificaten die stemkracht verlenen - wat wij ‘externe stemmers’ noemen. Deze externe stemmers fungeren als een Proof-of-Stake mechanisme voor AI en FHE projecten, waaronder Zama, Fhenix, Singularity, BitTensor, Myshell, en meer, wat een extra laag beloningen oplevert voor onze gebruikers.</p>
<p>In wezen bevindt Pencils Protocol zich op het snijvlak van DeFi, AI en FHE, waarbij deze werelden worden verenigd binnen onze Farming- en Vaults-productlijnen.</p>
<h2 id="h2-Q520Wat20zijn20de20aanstaande20plannen20en20ontwikkelingen20voor20het20Pencils20Protocol20waar20de20gemeenschap20naar20uit20moet20kijken424955"><a name="Q5: Wat zijn de aanstaande plannen en ontwikkelingen voor het Pencils Protocol waar de gemeenschap naar uit moet kijken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Wat zijn de aanstaande plannen en ontwikkelingen voor het Pencils Protocol waar de gemeenschap naar uit moet kijken?</h2><p>1.Vaults gelanceerd op 26 sept, met AI-verhaal, samenwerking met geestnetwerken.<br>2.DAPP-tokens uitverkocht op Tokensoft, Bounce en Coresky van 18 tot 22 september<br>3.TGE op 27e, op Bybit en Gate<br>4.Eerste token asset veiling in okt<br>5.Nieuwe Vault met RWA &amp; Payfi in Q4<br>6.Nodes verkoop op onze Shop-functie aan het einde van het jaar.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> GateLive</strong>, Team van Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is 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>