R2F0ZS5pbyBBTUEgY29uIFBPS1QgLSBBY2Nlc3NvIGFwZXJ0byBhIHF1YWxzaWFzaSBibG9ja2NoYWlu

<p><img src="https://gimg2.gateimg.com/image/article/16838855611.png" alt=""><br><strong>Ora: 10 febbraio 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Adam Liposky, COO di POKT nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://www.pokt.network/" rel="nofollow noopener noreferrer" target="_blank">https://www.pokt.network/</a></strong><br><strong>Twitter: <a href="https://twitter.com/POKTnetwork" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/POKTnetwork</a></strong><br><strong>Segui POKT su <a href="https://t.me/POKTnetwork" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://discord.com/invite/pokt" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16838857122.png" alt=""><br><strong>Adam Liposky - COO di POKT</strong></p>
<h2 id="h2-QampA20da20Gateio43355"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Quindi20cominciamo20conoscendo20il20tuo20progetto20Puoi20darmi20una20breve20introduzione20di20Pocket20Network20te20stesso20il20team20e20la20tecnologia951101"><a name="Q1: Quindi cominciamo conoscendo il tuo progetto. Puoi darmi una breve introduzione di Pocket Network, te stesso, il team e la tecnologia?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Quindi cominciamo conoscendo il tuo progetto. Puoi darmi una breve introduzione di Pocket Network, te stesso, il team e la tecnologia?</h3><p><strong>Adam</strong>: Pocket è un protocollo decentralizzato per incentivare gli operatori di nodi completi a supportare qualsiasi blockchain. Proprio come la nostra rete, abbiamo un team globale, diversificato e distribuito, con hub in Nord America e Sud America e operatori di nodi in tutto il mondo.</p>
<p>Dato che abbiamo lanciato il nostro mainnet nel luglio 2020, abbiamo servito miliardi di “relays” tra i nostri clienti di 30+ mainnet &amp; testnet blockchain. Siamo fidati da alcuni dei progetti/strumenti più utilizzati nel <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ecosistema, come EthersJs, Scaffold.Eth e MyCrypto, nonché dalle stesse Fondazioni Blockchain come <a href="/price/harmony-one" rel="nofollow noopener noreferrer" target="_blank">Armonia</a>, <a href="/price/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">IoTeX</a> e altri.</p>
<p>E integrazioni con <a href="/price/algorand-algo" rel="nofollow noopener noreferrer" target="_blank">Algorand</a>, Solona, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> e molti altri protocolli e DApps ben noti.</p>
<h3 id="h3-Q220Quindi20come2020iniziato20tutto20Perch2020stata20fondata20Pocket20Network20Qual2020lobiettivo20di20Pocket303637"><a name="Q2: Quindi come è iniziato tutto? Perché è stata fondata Pocket Network? Qual è l’obiettivo di Pocket?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Quindi come è iniziato tutto? Perché è stata fondata Pocket Network? Qual è l’obiettivo di Pocket?</h3><p><strong>Adam</strong>: Il nostro obiettivo è quello di realizzare l’infrastruttura <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> nel modo giusto, in modo che la visione di un’economia di proprietà più equa e inclusiva sia garantita per decenni a venire. Pocket Network è stata fondata dopo aver identificato un collo di bottiglia centralizzato nello stack tecnologico dello sviluppo di DApp, dove <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Si basava pesantemente su un unico fornitore di servizi SaaS per fornire dati API accurati. Come molti progetti crittografici, sono decentralizzati a livello di protocollo ma si affidano pesantemente a fornitori di servizi centralizzati per recuperare i dati - risolviamo per una piena decentralizzazione, il che significa che il software e il suo hosting e l’amministrazione delle DApps diventano anche decentralizzati. 100% di uptime!</p>
<p>Siamo già una parte fondamentale del mondo multi-chain che serve gran parte dell’industria crittografica e cresce rapidamente.</p>
<h3 id="h3-Q320E20quindi20passiamo20ora20alla20tokenomica20Quali20sono20le20tue20economie20di20token20e20quali20sono20i20suoi20vantaggi20in20termini20di20utilit20e20consentendo20alla20rete20di20crescere59603"><a name="Q3: E quindi passiamo ora alla tokenomica. Quali sono le tue economie di token e quali sono i suoi vantaggi in termini di utilità e consentendo alla rete di crescere?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: E quindi passiamo ora alla tokenomica. Quali sono le tue economie di token e quali sono i suoi vantaggi in termini di utilità e consentendo alla rete di crescere?</h3><p><strong>Adam</strong>: Negli ultimi 90 giorni gli sviluppatori hanno instradato ~16 miliardi di relè. Ciò significa che la rete ha generato oltre $215 milioni di entrate totali del protocollo e distribuito l’89% ai node runners. Pocket ha generato circa $191 milioni di incentivi in token USD per gli operatori dei nodi nel mese di gennaio.</p>
<p>Da un lato, gli sviluppatori di app puntano POKT per ottenere accesso a una quantità assegnata di chiamate API (relè) in perpetuità. Se decidono di lasciare la rete, possono rimuovere il proprio stake e rivendere quel POKT su un mercato aperto. Ciò porta i loro costi a quasi 0 nel tempo rispetto a una fattura mensile consistente (probabilmente crescente) nel tempo.</p>
<p>Ciò significa che non c’è alcun costo irrecuperabile. POKT trasforma l’infrastruttura in un asset.</p>
<p>Dall’altro lato del protocollo, i Node Runners scommettono POKT per partecipare al servizio della rete. I Node Runners devono garantire la qualità del servizio alle reti blockchain che scelgono per essere ricompensati per il loro servizio.</p>
<h3 id="h3-Q420E20ho20anche20notato20che20Pocket2020elencato20come20secondo20protocollo20generatore20di20entrate20su20Token20Terminal20Come20ha20raggiunto20Pocket20questo20obiettivo20In20cosa20ti20differenzi20dagli20altri679546"><a name="Q4: E ho anche notato che Pocket è elencato come secondo protocollo generatore di entrate su Token Terminal. Come ha raggiunto Pocket questo obiettivo? In cosa ti differenzi dagli altri?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: E ho anche notato che Pocket è elencato come secondo protocollo generatore di entrate su Token Terminal. Come ha raggiunto Pocket questo obiettivo? In cosa ti differenzi dagli altri?</h3><p><strong>Adam</strong>: Pocket ha raggiunto questo obiettivo raggiungendo la sua adattabilità protocollo/mercato l’anno scorso essendo il leader nell’infrastruttura decentralizzata multi-chain.</p>
<p>Pocket si differenzia dagli altri perché fornisce un livello base, il bisogno fondamentale di tutti i blockchain, i dati dei nodi RPC. Pocket Network esegue nodi completi quindi di fatto può essere un fornitore di servizi per loro. Inoltre, la maggior parte di questi progetti non è costruita per supportare i blockchain di medie/piccole dimensioni o nuove catene al loro lancio, a cui Pocket è perfettamente posizionata. Come recente esempio, Pocket Network è il fornitore di infrastrutture predefinito e partner di lancio per <a href="/price/evmos-evmos" rel="nofollow noopener noreferrer" target="_blank">Evmos</a>, che è la prima catena compatibile con EVM nell’ecosistema Cosmos IBC.</p>
<p>Ci sono delle importanti sfumature nel modo in cui i numeri sono classificati, anche se le nostre metriche on-chain parlano da sole e la crescita esponenziale degli ultimi 6 mesi è testimonianza del nostro team e della naturale necessità del nostro ruolo nell’industria.</p>
<h3 id="h3-Q520E20guardando20al20futuro20Come20appare20Pocket20tra20120anno20Descrivi20il20futuro20della20liquidit20del20token20dellespansione20dellindustria20e20del20prodotto591574"><a name="Q5: E guardando al futuro. Come appare Pocket tra 1 anno? Descrivi il futuro della liquidità del token, dell’espansione dell’industria e del prodotto." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: E guardando al futuro. Come appare Pocket tra 1 anno? Descrivi il futuro della liquidità del token, dell’espansione dell’industria e del prodotto.</h3><p><strong>Adam</strong> Prevediamo che Pocket Network l’anno prossimo elabori molti miliardi di relè al giorno, al momento ne stiamo facendo 1 miliardo a settimana e stiamo crescendo rapidamente, questo si traduce anche in entrate reali e valore accumulato per i nostri detentori.</p>
<p>Ci aspettiamo che si aprano canali di liquidità man mano che il nostro protocollo diventa sempre più indispensabile in termini di utilità per l’industria, dove stiamo sostituendo gli intermediari con i middleware e continuiamo a eliminare le inefficienze intrinseche nel modo in cui l’industria delle criptovalute è supportata dai fornitori di cloud computing e hosting. Essere più economici, più veloci e migliori è una formula vincente che continueremo ad attuare e scalare.</p>
<p>Per quanto riguarda il prodotto, questo ha un timeline un po’ più lunga, ma la ricerca attuale mira a far sì che Pocket Network abbia la capacità di supportare trilioni a quadrilioni di relay, attraverso milioni di nodi: non c’è un limite concettuale a Pocket Network, ci vorrà solo un’ingegneria attenta per scalare correttamente ma Il futuro è eccitante e abbiamo tutte le cose giuste al loro posto.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità 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 riposting dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>