R2F0ZS5pbyBBTUEgY29uIEludGVybGF5LU9uZSBkQXBwLCBUdXR0byBzdSBCaXRjb2lu

<p><img src="https://gimg2.gateimg.com/image/article/16842289191.jpg" alt=""><br><strong>Ora: 24 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 Alexei, co-fondatore e CEO di Interlay in <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Web ufficiale: <a href="https://www.interlay.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.interlay.io/</a></strong><br><strong>Cinguettare: <a href="https://twitter.com/interlayHQ" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/interlayHQ</a></strong><br><strong>Segui Interlay su <a href="https://t.me/interlay_community" rel="nofollow noopener noreferrer" target="_blank">Telegramma</a> e <a href="https://discord.com/invite/interlay" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16842291572.jpg" alt=""><br><strong>Alexei - Co-fondatore e CEO di Interlay</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio28110"><a name="Domande e risposte da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande e risposte da Gate.io</h2><h3 id="h3-Q120Puoi20presentarti20brevemente20e20presentare20Interlay20alla20nostra20comunit20Quali20sono20la20visione20e20la20missione20di20Interlay763173"><a name="Q1: Puoi presentarti brevemente e presentare Interlay alla nostra comunità? Quali sono la visione e la missione di Interlay?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi presentarti brevemente e presentare Interlay alla nostra comunità? Quali sono la visione e la missione di Interlay?</h3><p><strong>Alexei</strong>: Interlay è una rete decentralizzata dedicata a collegare criptovalute come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> con piattaforme DeFi come <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>. La rete Interlay sarà ospitata come <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> parachain e sarà collegata a Cosmos, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e altre importanti reti DeFi.</p>
<p>La nostra visione è un futuro in cui le blockchain si connettono e interagiscono in modo trasparente: chiunque può utilizzare qualsiasi asset digitale su qualsiasi blockchain, senza fiducia e senza limitazioni.</p>
<p>interBTC, il prodotto di punta di Interlay, è <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> su qualsiasi blockchain. A 1:1 <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Asset sostenuto, completamente garantito, interoperabile e resistente alla censura. Ad alto livello, interBTC è per BTC ciò che MakerDAO/DAI è per il dollaro USA - ma meglio. Una stablecoin algoritmica, garantita da una polizza multi-collaterale e 1:1 supportata da e rimborsabile in BTC.</p>
<p>Kintsugi è la rete canarina di Interlay, un esperimento con un vero valore economico implementato su <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a> Kintsugi e Interlay condividono la stessa base di codice, con la differenza che Kintsugi si concentra rigorosamente sull’innovazione e sarà sempre avanti in termini di funzionalità.<br><img src="https://gimg2.gateimg.com/image/article/16842292403.jpg" alt=""><br>interBTC consente agli utenti di investire, guadagnare e pagare con BTC su qualsiasi blockchain nel vero modo DeFi:</p>
<ul>
<li>Protetto da assicurazione: gli utenti possono uscire indietro verso <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> in qualsiasi momento lo desiderino, o saranno completamente rimborsati in asset di garanzia.</li><li>Radicalmente aperto: chiunque può contribuire a garantire il sistema decentralizzato e gli utenti non possono essere censurati.<br><img src="https://gimg2.gateimg.com/image/article/16842291904.jpg" alt=""><br>Il processo è semplice:<br>1) Bloccare BTC,<br>2) Creare interBTC<br>3) Utilizzare interBTC in DeFi - mentre i tuoi BTC sono protetti da un’assicurazione decentralizzata multi-collateralizzata,<br>4) Riscattare interBTC per BTC in qualsiasi momento.</li></ul>
<h3 id="h3-Q220Puoi20raccontarci20brevemente20i20tuoi20aggiornamenti20dellultimo20anno20e20come2020cresciuto20il20tuo20team20e20la20tua20comunit599497"><a name="Q2: Puoi raccontarci brevemente i tuoi aggiornamenti dell’ultimo anno e come è cresciuto il tuo team e la tua comunità?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Puoi raccontarci brevemente i tuoi aggiornamenti dell’ultimo anno e come è cresciuto il tuo team e la tua comunità?</h3><p><strong>Alexei</strong>: Ecco alcuni dei nostri punteggi più memorabili!</p>
<ul>
<li>Da un’azienda di pochi membri, siamo cresciuti in un team straordinario di 18 persone provenienti da tutto il mondo. Siamo al 100% remoti e distribuiti in tutto il mondo. I nostri membri del team hanno lavorato in precedenza presso PwC, Accenture, Google, WorldPay, Trivago, TEAM, Morgan Stanley, Hyperledger (open source) e stiamo assumendo in tutti i dipartimenti (raddoppiando il team nei prossimi 8 mesi!) <a href="https://apply.workable.com/interlay/?lng=en" rel="nofollow noopener noreferrer" target="_blank">https://apply.workable.com/interlay/?lng=it</a></li><li>La nostra community si è espansa da poche centinaia a oltre 30k+ su Twitter (@interlayHQ, @kintsugi_btc, @inter_btc), 6000+ su Discord e 4000+ su Telegram in soli 6 mesi.</li><li>In soli 4 mesi, siamo riusciti a lanciare un solido programma di ambasciatori e ora oltre 100 ambasciatori si offrono volontari per testare, educare e far crescere la comunità. Abbiamo team di traduzione per il russo, il cinese e presto anche lo spagnolo, il turco, ecc. La nostra tesoreria on-chain finanzierà attivamente eventi, contenuti, traduzioni e comunità per aiutare le persone ad accedere a BTC e utilizzarlo tramite interBTC dove è più necessario.</li><li>Abbiamo raccolto 9,5 milioni di dollari in capitale di rischio tramite finanziamenti azionari per stimolare la crescita e lo sviluppo e abbiamo scritto decine di migliaia di righe di codice;</li><li>Abbiamo completato 2 audit di sicurezza (NCC e sistemi informali) e ne stiamo facendo altri 2 nel Q1 2022 (Quarkslab e una prima “scansione” di SR Labs)</li><li>Ci sono stati assegnati 2 Grant: proseguendo il grant della <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Foundation il <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> e avviare una nuova collaborazione con la Interchain Foundation di Cosmos.</li></ul>
<h3 id="h3-D320Puoi20anche20condividere20con20noi20come20Interlay20ha20vinto20lo20slot20parachain20di20Kusama20e20landamento20del20crowdloan20in20Polkadot429018"><a name="D3: Puoi anche condividere con noi come Interlay ha vinto lo slot parachain di Kusama e l’andamento del crowdloan in Polkadot?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>D3: Puoi anche condividere con noi come Interlay ha vinto lo slot parachain di <a href="/price/kusama-ksm" target="_blank" class="blog_inner_link">Kusama</a> e l’andamento del crowdloan in Polkadot?</h3><p><strong>Alexei</strong> Uno dei nostri più grandi successi, dopo due anni di duro lavoro, abbiamo vinto un <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a> slot di parachain con Kintsugi, la rete canarina di Interlay, con 200.000 KSM (~USD 50mm) bloccati da oltre 11.000 sostenitori.</p>
<p>A dicembre, Kintsugi è stato lanciato come una rete completamente decentralizzata seguendo il nostro impegno a rimanere fedeli a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La visione di ’ di creare un nuovo, radicalmente aperto sistema finanziario. Il KINT di Kintsugi è già stato arruolato su Gate, Kraken e MEXC.</p>
<p>Parallelamente, la rete Interlay sta partecipando al <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> aste tramite un crowdloan (puoi controllare e supportare qui: <a href="https://crowdloan.interlay.io/" rel="nofollow noopener noreferrer" target="_blank">https://crowdloan.interlay.io/</a> Finora, il nostro crowdloan ha raccolto 2,7 milioni di DOT da oltre 19.000 sostenitori.</p>
<p>E siamo a pochi minuti dal vincere ufficialmente <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> slot di parachain 10!!</p>
<h3 id="h3-Q420Come2020stata20la20performance20di20Kusama20negli20ultimi20mesi20Qual2020la20stabilit20della20rete20e20quali20progetti20si20sono20uniti20al20tuo20ecosistema485960"><a name="Q4: Come è stata la performance di Kusama negli ultimi mesi? Qual è la stabilità della rete e quali progetti si sono uniti al tuo ecosistema?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Come è stata la performance di Kusama negli ultimi mesi? Qual è la stabilità della rete e quali progetti si sono uniti al tuo ecosistema?</h3><p><strong>Alexei</strong>: In questo momento, ci stiamo preparando a lanciare kBTC su Kintsugi ( <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a>). Kintsugi è già al 100% decentralizzato - governato dal token di governance KINT.</p>
<p>kBTC - senza fiducia <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> su <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a>, verrà lanciato a marzo.</p>
<p>I prossimi passi prima del lancio sono:<br>1) Attivazione dello staking<br>2) Avvio delle casseforti e permettere la coniazione di kBTC<br>3) Integrazione con tutte le principali parachains su <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a><br>Stiamo già integrando con Moonriver e Karura. Il canale XCM verso MOVR entrerà in funzione la prossima settimana, Karura seguirà a breve. Molte altre parachain seguiranno presto: funzionalità di privacy tramite la rete Calamari di Manta o Khala, più DeFi tramite Basilisk, Parallel Heiko e Picasso. Parallelamente, stiamo lavorando su integrazioni con portafogli (Talisman, Nova, Fearless), esploratori (Subscan) e forum di governance (Opensquare).<br><a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a>/ <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> sono solo l’inizio però!</p>
<p>Non ci sono praticamente limiti a dove puoi utilizzare kBTC/interBTC e non vediamo l’ora di vedere cosa la comunità riesce a creare.</p>
<p>Immagina di poter utilizzare interBTC su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Cosmos, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>, … e nessuno può fermarti. Nessuno scambio centralizzato o custodi che possono perdere, rubare o avere il tuo BTC sequestrato dai governi.</p>
<p>Questa è la visione di Interlay.</p>
<p>Abbiamo appena annunciato anche la nostra ultima competizione di testnet prima del lancio di kBTC!</p>
<p><a href="https://medium.com/interlay/kintsugi-whizzes-we-are-running-a-lottery-beacbded2786" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/interlay/kintsugi-whizzes-we-are-running-a-lottery-beacbded2786</a></p>
<p>Aiutaci a testare lo stress della rete di prova Kintsugi e avere la possibilità di guadagnare airdrop di KINT.</p>
<h3 id="h3-Q520Quando20si20prevede20che20verr20lanciato20su20Polkadot20E20poi20quali20sono20i20vostri20piani20e20le20vostre20priorit20per20il20futuro766959"><a name="Q5: Quando si prevede che verrà lanciato su Polkadot? E poi quali sono i vostri piani e le vostre priorità per il futuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quando si prevede che verrà lanciato su Polkadot? E poi quali sono i vostri piani e le vostre priorità per il futuro?</h3><p><strong>Alexei</strong>: Come accennato, stiamo per garantire il <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> slot di parachain (in 28 minuti effettivamente). Abbiamo ricevuto il supporto da oltre diecimila partecipanti.</p>
<p>Una volta che Interlay vince uno slot di parachain, la rete principale andrà online a marzo/aprile con tutte le funzionalità.<br>Stiamo lavorando a stretto contatto con tutti i principali <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> team - le prime integrazioni avverranno su <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a> con Moonriver e Karura.</p>
<p>Attraverso <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> Con i ponti di Ethreum di Gate.io, presto porteremo anche kBTC e interBTC a <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>- quindi avrai finalmente un’alternativa decentralizzata al wBTC centralizzato e istituzionalizzato.</p>
<p>Infine, stiamo per coinvolgere comunità che dipendono attivamente da BTC come mezzo di pagamento - dove le persone non si fidano della valuta del governo o dell’USD. Qui, interBTC offrirà finalmente un modo veloce, efficiente e affidabile per utilizzare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</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 ripostaggio 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>