Z2F0ZUxpdmUgQU1BIFJlY2FwLVBlbmNpbHMgUHJvdG9jb2w=

2024-09-27, 06:15

<p><img src="https://gimg2.gateimg.com/image/article/1727417536dapp.png" alt=""></p>
<h2 id="h2-Q120Come20il20tuo20Scroll20Native20Gateway20migliora20lutilizzo20delle20risorse20E20condividi20i20suoi20punti20salienti20con20il20pubblico111946"><a name="Q1. Come il tuo Scroll Native Gateway migliora l’utilizzo delle risorse? E condividi i suoi punti salienti con il pubblico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1. Come il tuo Scroll Native Gateway migliora l’utilizzo delle risorse? E condividi i suoi punti salienti con il pubblico?</h2><p>Prodotti principali:<br>Due colonne portanti principali:</p>
<ol>
<li>Una colonna portante è l’aggregazione del rendimento. Abbiamo due diverse linee di prodotti in questa categoria adattate a diversi appetiti di rischio degli utenti.</li></ol>
<ul>
<li>Yield Farming offre opportunità a basso rischio e stabili per gli utenti avversi al rischio di guadagnare rendimenti e ricompense multistrato.</li><li>I Vault sono un polo più innovativo per gli utenti in cerca di rischio, alla ricerca di rendimenti leva attraverso le nostre strategie diversificate, tra cui farming a leva, sintetici on-chain, opzioni esotiche, delta natural, e altre opportunità specifiche di esposizione al rischio.</li></ul>
<ol>
<li>L’altro pilastro è l’Asta e i Negozi: non offriamo solo vari tipi di lancio di asset token, ma supportiamo anche asset token non standard come componenti di gioco, NFT, nodi e RWA. Serve come ingresso del traffico degli utenti fornendo opportunità di accesso anticipato redditizie.</li></ol>
<p>Siamo supportati da importanti istituzioni nello spazio come OKX Ventures, Galxe, Animoca Brands, ecc. e di recente abbiamo annunciato anche una nuova raccolta fondi del valore di 80M da Taisu, DePIN X, Bing Ventures e altri.</p>
<p>🚀 Forte trazione sociale:</p>
<ul>
<li>No.1 Native dApp su 📜 Scroll</li><li>No.3 Farming dApp su tutte le catene</li><li>TVL al settembre 2024: $350M+</li><li>I nostri utenti attivi verificati tramite zk: 550K+</li></ul>
<h2 id="h2-Q220Potresti20fornire20maggiori20dettagli20sullutilit20del20token20DAPP20e20su20come20beneficia20gli20utenti20allinterno20dellecosistema20del20Protocollo20Pencils20E20quali20meccanismi20deflazionistici20governano20la20buona20circolazione20e20lofferta20di20DAPP148105"><a name="Q2. Potresti fornire maggiori dettagli sull’utilità del token $DAPP e su come beneficia gli utenti all’interno dell’ecosistema del Protocollo Pencils? E quali meccanismi deflazionistici governano la buona circolazione e l’offerta di $DAPP?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2. Potresti fornire maggiori dettagli sull’utilità del token $DAPP e su come beneficia gli utenti all’interno dell’ecosistema del Protocollo Pencils? E quali meccanismi deflazionistici governano la buona circolazione e l’offerta di $DAPP?</h2><p><strong>Governance:</strong> I token $DAPP svolgono un ruolo vitale all’interno dell’ecosistema di Pencils Protocol, offrendo sia utilità pratica che potenziale upside. Gli utenti possono scommettere $DAPP per guadagnare token di governance ($pDAPP) in un rapporto 1:1. E votare sulle decisioni importanti del protocollo.</p>
<p><strong>Token Farming:</strong> Per incoraggiare il coinvolgimento a lungo termine della comunità, il programma di staking del token $DAPP verrà lanciato dopo il TGE. I detentori di token possono fare staking di $DAPP nelle Pencils Protocol Farms per ricevere $pDAPP, che possono poi essere ulteriormente staked o forniti come liquidità per il DEX per permettere agli utenti di partecipare all’ecosistema.</p>
<p><strong>Garanzia della Piattaforma d’Asta: </strong>Per elencare gli asset sulla Piattaforma d’Asta, i venditori devono depositare $DAPP. Questo meccanismo di deposito funge da salvaguardia contro attività dannose, con la comunità che supervisiona il processo di asta. In caso di comportamenti scorretti, i $DAPP depositati vengono redistribuiti tra i membri della comunità.</p>
<p><strong>Mappatura dei diritti del sistema di punti:</strong> I partecipanti precoci al Protocollo Pencils riceveranno punti Pencils, che corrispondono ai diritti in $DAPP. In futuro, $DAPP sostituirà alcune delle funzioni di Pencils. I detentori di $DAPP godranno anche di accesso prioritario a nuovi metodi di farming e politiche preferenziali. Questi privilegi includono moltiplicatori di leva più elevati e accesso prioritario a prodotti strategici esclusivi e limitati.</p>
<p><strong>Negozio virtuale:</strong> Nel negozio virtuale, gli utenti possono sfruttare $DAPP (la valuta della piattaforma) per il trading di margine in NFT, attività reali (RWA), punti e derivati, ampliando l’utilità e l’applicazione dei loro asset all’interno dell’ecosistema del protocollo Pencils.</p>
<p><strong>Meccanismo deflazionario:</strong> Un motore di crescita per il valore del token $DAPP</p>
<p>Una delle caratteristiche più entusiasmanti del nostro prodotto Vaults è l’allocazione del 30% dei ricavi dei vault da inviare a un indirizzo void come $DAPP. Questo meccanismo deflazionistico contribuirà all’apprezzamento a lungo termine del token $DAPP. Inoltre, il restante 70% dei ricavi sarà <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">flusso](/price/</a><a  rel="nofollow noopener noreferrer"  href=")-flow”" target="“_blank”" class="“blog" _interno_="" [gate<="" a=""> &gt;flussi nell’ecosistema e nel fondo di sviluppo della comunità, che fornirà incentivi per diverse fasi di crescita, supportando lo sviluppo sostenibile dell’ecosistema e il coinvolgimento futuro degli utenti.</a></p><a  rel="nofollow noopener noreferrer"  href=")-flow”" target="“_blank”" class="“blog" _interno_="" [gate<="" a="">
</a><h2 id="h2-Q320Come20il20nuovo20prodotto20Vaults20Protocol20di20Pencils20Protocol20aumenter20i20guadagni20attraverso20la20leva20degli20asset20e20il20mining20di20liquidit867785"><a  rel="nofollow noopener noreferrer"  href=")-flow”" target="“_blank”" class="“blog" _interno_="" [gate<="" a=""></a><a name="Q3. Come il nuovo prodotto Vaults Protocol di Pencils Protocol aumenterà i guadagni attraverso la leva degli asset e il mining di liquidità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3. Come il nuovo prodotto Vaults Protocol di Pencils Protocol aumenterà i guadagni attraverso la leva degli asset e il mining di liquidità?</h2><p>Il Yield Farming offre opportunità stabili a basso rischio per gli utenti avversi al rischio di ottenere rendimenti e ricompense multistrato.</p>
<p>Il prodotto Vaults è un centro più innovativo per gli utenti che cercano rischi per inseguire un rendimento leva tramite le nostre strategie diversificate tra cui farming leva, sintetici on-chain, opzioni esotiche, delta naturale e altre opportunità di esposizione a rischi specifici.</p>
<p>Pencils Protocol mira a unificare le varie fasi delle fonti di rendimento nella nuova linea di prodotti Vaults:</p>
<ol>
<li><p>Ricompense a monte dalla catena di supporto (Scroll, uno dei più grandi L2 su <a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">ethereum</a> Infrastrutture di staking ETH come StakeStone, Puffer, Kelp, Etherfi, LSD, LRT, ecc. con possibilità di riposizionamento; e protocollo Solv per asset solvBTC. I rendimenti si basano su diverse attività degli utenti, tra cui prestiti, prestiti e leva.</p>
</li><li><p>Ricompense a valle, stiamo espandendoci negli ecosistemi di AI e FHE (Fully Homomorphic Encryption). Gli asset depositati nel Protocollo Pencils forniranno certificati che conferiscono potere di voto - quello che chiamiamo ‘votanti remoti’. Questi votanti remoti fungeranno da meccanismo di Proof-of-Stake (PoS) per progetti di AI e FHE, tra cui Zama, Fhenix, Singularity, BitTensor, Myshell e altri, che offrono un ulteriore livello di ricompense ai nostri utenti.</p>
</li></ol>
<p>In sostanza, il protocollo Pencils unifica DeFi, AI e FHE all’interno di un singolo ecosistema attraverso le nostre linee di prodotto Farming e Vaults.</p>
<h2 id="h2-Q420Rispetto20ad20altri20Defi20ti20preghiamo20di20spiegare20il20merito20dellutilizzo20di20Pencils20Protocol600394"><a name="Q4: Rispetto ad altri Defi, ti preghiamo di spiegare il merito dell’utilizzo di Pencils Protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Rispetto ad altri Defi, ti preghiamo di spiegare il merito dell’utilizzo di Pencils Protocol</h2><p>Mentre concludiamo, voglio sottolineare alcuni punti chiave sul Protocollo Pencils e su ciò che lo rende particolare nello spazio DeFi. Prima di tutto, parliamo di DeFi e Aggregazione dei Rendimenti. La nostra piattaforma offre opportunità uniche che soddisfano sia gli utenti avversi al rischio che coloro che cercano strategie più avventurose.</p>
<p>Per coloro che preferiscono un rischio più basso, le nostre opzioni di yield farming offrono rendimenti stabili, affidabili e ricompense a più livelli. Ciò lo rende una scelta interessante per gli utenti che vogliono guadagnare rendimenti senza assumere troppi rischi.</p>
<p>D’altra parte, il nostro prodotto Vaults è progettato per coloro che cercano rendimenti più elevati. Funge da hub innovativo per gli utenti desiderosi di perseguire rendimenti con leva attraverso una varietà di strategie. Stiamo parlando di farming con leva, sintetici on-chain, opzioni esotiche, strategie delta neutral e altre opportunità di esposizione mirata al rischio.</p>
<p>Uno dei nostri obiettivi principali presso Pencils Protocol è unificare diverse fonti di rendimento all’interno della nostra nuova linea di prodotti Vaults. Ecco come lo facciamo:<br>I premi a monte provengono dal supporto di catene come Scroll, che è una delle più grandi soluzioni di Layer 2 su Ethereum. Incorporiamo anche infrastrutture di restaking e protocolli LSD/LRT, come StakeStone, Puffer, Kelp e Etherfi per gli asset di staking ETH, insieme a Solv Protocol per gli asset solvBTC. Questi premi si basano su varie attività degli utenti, tra cui prestiti, prestiti e leva finanziaria.</p>
<p>Le ricompense a valle si stanno espandendo in settori interessanti come gli ecosistemi di Intelligenza Artificiale e Crittografia Omomorfica Completamente (FHE). Quando si depositano gli asset in Pencils Protocol, si ricevono certificati che concedono il potere di voto, che chiamiamo ‘votanti remoti’. Questi votanti remoti funzionano come meccanismo di Proof-of-Stake per progetti di Intelligenza Artificiale e FHE, tra cui Zama, Fhenix, Singularity, BitTensor, Myshell, e altro ancora, portando un ulteriore livello di ricompense per i nostri utenti.</p>
<p>In sostanza, Pencils Protocol si trova all’incrocio tra DeFi, AI e FHE, unificando questi mondi all’interno delle nostre linee di prodotto Farming e Vaults.</p>
<h2 id="h2-Q520Quali20sono20i20prossimi20piani20e20sviluppi20per20il20Protocollo20Pencils20a20cui20la20comunit20dovrebbe20guardare20avanti317505"><a name="Q5: Quali sono i prossimi piani e sviluppi per il Protocollo Pencils a cui la comunità dovrebbe guardare avanti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quali sono i prossimi piani e sviluppi per il Protocollo Pencils a cui la comunità dovrebbe guardare avanti?</h2><p>1.I vault sono stati lanciati il 26 settembre, con una narrazione basata sull’IA, in collaborazione con le reti mentali.<br>2.I token DAPP sono esauriti su Tokensoft, Bounce e Coresky dal 18 al 22 settembre<br>3.TGE il 27, su Bybit e Gate<br>4.Prasta attivo per l’asta dei token in ottobre<br>5.Nuovo Vault con RWA &amp; Payfi nel Q4<br>6.Vendita dei nodi sulla nostra funzione Shop alla fine dell’anno.</p>
<div class="blog-details-info"><br><div>Autore: <strong>GateLive</strong>, Team 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, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>