R2F0ZS5pbyBBTUEgY29uIFN0YWRlci1CcmluZyAxIE1JTElBUkRPIGRpIHBlcnNvbmUgYSBTdGFraW5nIGUgRGVGaQ==

<p><img src="https://gimg2.gateimg.com/image/article/16818008711.jpg" alt=""><br><strong>Ora: 29 marzo 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione di AMA (Ask-Me-Anything) con Gautam Midha, Capo della Strategia &amp; dell’Espansione presso Stader in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di Gate.io Exchange</a>.</strong><br><strong>Sito Web Ufficiale: <a href="https://www.staderlabs.com/" rel="nofollow noopener noreferrer" target="_blank">https://www.staderlabs.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/staderlabs" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/staderlabs</a></strong><br><strong>Segui Stader su <a href="https://twitter.com/staderlabs" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/staderlabs" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16818010882.png" alt=""><br><strong>Gautam Midha - Capo della Strategia e dell’Espansione presso Stader</strong></p>
<h2 id="h2-QampA20da20Gateio679910"><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-Q120Possiamo20iniziare20con20una20breve20introduzione20di20Stader20per20favore401315"><a name="Q1: Possiamo iniziare con una breve introduzione di Stader per favore?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Possiamo iniziare con una breve introduzione di Stader per favore?</h3><p><strong>Gautam</strong> Certamente, Stader risolve i problemi principali che gli staker affrontano oggi. I problemi sono presenti lungo tutta la catena del valore dello staking: scoprire i validatori, gestire le ricompense di staking, richiedere gli airdrop, trovare strategie sulle ricompense di staking, ecc. Stiamo semplificando e automatizzando tutto questo con i nostri contratti intelligenti modulari. Inoltre, stiamo creando token liquidi che possono essere ulteriormente sfruttati nei protocolli DeFi per massimizzare i rendimenti.</p>
<p>In fondo, stiamo creando un ecosistema di staking con la nostra suite di prodotti di staking che si rivolgono a tutti i tipi di staker - dai principianti ai degens.</p>
<h3 id="h3-Q220E20quale20sarebbe20la20visione20di20Stader246133"><a name="Q2: E quale sarebbe la visione di Stader?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: E quale sarebbe la visione di Stader?</h3><p><strong>Gautama</strong>: La visione di Stader è quella di portare a bordo dei prossimi 1 miliardo di utenti nello staking. Probabilmente siamo l’unica piattaforma di staking multi-prodotto e multi-chain che è un diretto risultato dell’approccio segmentato ai prodotti di staking.</p>
<p>Onboarderemo i prossimi 1B utenti costruendo un’infrastruttura middleware di staking chiave per le reti Proof-of-Stake (PoS) che può essere sfruttata per diversi segmenti di clienti, tra cui gli utenti di criptovaluta al dettaglio, le borse, i custodi e i principali attori FinTech. I contratti intelligenti modulari di Stader sono costruiti in modo che, in futuro, terze parti possano sfruttare i loro componenti e incorporare soluzioni personalizzate.</p>
<p>Stader sta costruendo smart contract nativi su più blockchain, inclusa <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a>, <a href="/price/hedera-hbar" rel="nofollow noopener noreferrer" target="_blank">Hedera</a>, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, e costruendo un ecosistema economico per far crescere e sviluppare soluzioni come il reindirizzamento del rendimento con ricompense, lo staking liquido, le piattaforme di lancio, i giochi e altro ancora.</p>
<p>Posizionandoci per una crescita a lungo termine, cercheremo di concentrarci sulla cura di terze parti per sviluppare diverse applicazioni di staking con l’infrastruttura di Stader.</p>
<h3 id="h3-Q320E20puoi20parlarci20del20team20del20progetto46259"><a name="Q3: E puoi parlarci del team del progetto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: E puoi parlarci del team del progetto?</h3><p><strong>Gautam</strong>: Il nostro team è composto da alcuni dei più esperti e talentuosi leader di business e tecnologia, nonché sviluppatori.</p>
<p>Amitej Gajjala, cofondatore e CEO di Stader Labs, ha più di 10 anni di esperienza nella strategia aziendale, nello sviluppo di startup in India, SEA e Europa. Sul fronte dell’istruzione, è un alunno dell’IIT e dell’IIM.<br>Ha avviato Stader Labs nella metà del 2021 con Sidhartha, nostro cofondatore e CTO, che vanta un decennio di esperienza tecnologica e criptovalutaria. È un alunno di Columbia e IIT.</p>
<p>Dheeraj, il nostro terzo co-fondatore e responsabile del protocollo, ha più di 10 anni di esperienza nella costruzione e scalabilità delle applicazioni tecnologiche in importanti aziende della Silicon Valley, tra cui Linkedin e Paypal.</p>
<p>Oltre ai co-fondatori, il gruppo dirigente comprende Vijay, il nostro responsabile del prodotto, insieme a Vibin e a me, che guidiamo i nostri progetti di espansione. Abbiamo 30+ anni di esperienza combinata in piattaforme tecnologiche come Booking.com, Swiggy, i-banking, consulenza e investimenti.</p>
<h3 id="h3-Ok20buono20sapersi20sembra20che20ci20sia20molta20buona20esperienza20tra20i20membri20chiave20del20team20Parliamo20dei20Prodotti20Chiave20e20della20Tracciabilit20di20Mercato20Come2020stato20finora20il20percorso942431"><a name="Ok, buono sapersi, sembra che ci sia molta buona esperienza tra i membri chiave del team. Parliamo dei Prodotti Chiave e della Tracciabilità di Mercato. Come è stato finora il percorso?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ok, buono sapersi, sembra che ci sia molta buona esperienza tra i membri chiave del team. Parliamo dei Prodotti Chiave e della Tracciabilità di Mercato. Come è stato finora il percorso?</h3><p><strong>Gautam</strong>: Sì, e naturalmente a gestire le cose c’è un team di oltre 30 persone veramente talentuose tra tecnologia, marketing e prodotto, sono le vere star dello spettacolo.</p>
<p>È stato un viaggio fantastico finora, dal lancio il 23 novembre 2021, le nostre soluzioni hanno ottenuto un’enorme trazione in <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Nell’ecosistema DeFi di Gate.io, abbiamo:<br>30k+ portafogli unici in staking<br>8.5 M+ Luna in staking<br>1.6 M Luna su LunaX &lt;&gt; Luna LP<br>Comunità forte di oltre 60.000 persone</p>
<p>Abbiamo anche avuto una vendita CoinList con un record di 1,2 milioni di registrazioni sulla piattaforma.</p>
<h3 id="h3-Q520Quali20sono20alcuni20dei20tuoi20obiettivi20a20lungo20termine807583"><a name="Q5: Quali sono alcuni dei tuoi obiettivi a lungo termine?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quali sono alcuni dei tuoi obiettivi a lungo termine?</h3><p><strong>Gautam</strong> Entro la fine del 2022, prevediamo di lanciare contratti di staking Stader e infrastrutture su almeno 10+ reti PoS. I nostri contratti attraverso <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/hedera-hbar" rel="nofollow noopener noreferrer" target="_blank">Hedera</a>, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Poligono</a> sarà lanciato nelle prossime settimane. Man mano che ci espandiamo ad altre blockchain, continueremo a costruire utenti fedeli e membri attivi della comunità e far crescere la famiglia Stader molto di più.</p>
<p>Oltre al segmento al dettaglio, diversi clienti istituzionali (inclusi la maggior parte dei nostri investitori) stanno già sfruttando i contratti intelligenti di Stader per scommettere la loro Luna attraverso Stake Pools, Stake+ e LunaX. Siamo andati oltre e stiamo costruendo integrazioni di prodotto anche con custodi e scambi.</p>
<p>Mentre espandiamo le nostre soluzioni a diverse reti PoS, l’offerta aggregata di tutte le reti PoS staking (liquid e stake pools) con un’unica integrazione sarà un’offerta potente e irresistibile di Stader Labs per i clienti istituzionali/aziendali.</p>
<h3 id="h3-Q620Quali20diresti20che20sono20le20utilit20dei20token20SD93070"><a name="Q6: Quali diresti che sono le utilità dei token SD?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Quali diresti che sono le utilità dei token SD?</h3><p><strong>Gautam</strong>: Ci saranno 4 principali utilità per i token Stader.</p>
<p>In primo luogo, i validatori dovranno scommettere una quantità minima di token SD. La quantità di deleghe che verranno distribuite ai diversi validatori in un pool sarà in qualche modo proporzionale alla loro scommessa di token. Allo stesso tempo, questi token SD verranno utilizzati come assicurazione contro i rischi di taglio.</p>
<p>In secondo luogo, chiunque depositi token SD otterrà uno sconto sulle commissioni che addebiteremo attraverso le nostre soluzioni di staking.</p>
<p>La terza utilità è che i detentori di token Stader possono depositare coppie SD-LUNA, SD-UST, SD-liquid LUNA su Stader e guadagnare ricompense per farlo.</p>
<p>La quarta utilità principale è basata sulla governance. Gli stakeholder del token SD avranno la possibilità di proporre e votare per diversi tipi di politiche come l’aggiunta di validatori, l’uscita dei validatori, il fissare le soglie, ecc.</p>
<h3 id="h3-Q720Il20finanziamento20e20la20sostenibilit20dei20progetti20sono20anche20un20argomento20importante20Cosa20diresti20essere20la20fonte20di20ricavo20di20Stader423433"><a name="Q7: Il finanziamento e la sostenibilità dei progetti sono anche un argomento importante. Cosa diresti essere la fonte di ricavo di Stader?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Il finanziamento e la sostenibilità dei progetti sono anche un argomento importante. Cosa diresti essere la fonte di ricavo di Stader?</h3><p><strong>Gautam</strong>: Domanda molto importante e sono contento che tu l’abbia fatta. Stiamo adottando un approccio a lungo termine per costruire Stader, vogliamo restare in gioco per decenni invece di mesi o anni. Con questo obiettivo in mente, l’autosufficienza finanziaria è davvero importante per noi e abbiamo un modello di generazione di entrate solido in cui i soldi fluiscono verso il protocollo attraverso tre meccanismi:</p>
<ol>
<li>Commissione sulle strategie di ricompensa: commissioni di gestione del 3-10% sulle ricompense per lo staking, se eletto dai sostenitori della governance.</li><li>Commissione sui token di staking liquido: commissione del 5-10% sulle ricompense per lo staking, se eletto dai sostenitori della governance.</li><li>Commissione di distribuzione dai validatori: commissioni di distribuzione del 10-20% sulle commissioni dei validatori, se eletto dai sostenitori della governance.</li></ol>
<p>La distribuzione dei token Stader è stata pianificata per incentivare gli utenti e gli stakeholder chiave a partecipare attivamente alla rete, riservando anche una porzione adeguata di token Stader per incentivare terze parti a costruire sulla piattaforma Stader.</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 ripubblicare l'articolo a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>