R2F0ZS5pbyBBTUEgbWV0IEludGVybGF5LU9uZSBkQXBwLCBBbGxlcyBvdmVyIEJpdGNvaW4=

<p><img src="https://gimg2.gateimg.com/image/article/16842289191.jpg" alt=""><br><strong>Tijd: 24 februari 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> heeft een AMA (Ask-Me-Anything) sessie gehost met Alexei, medeoprichter en CEO van Interlay in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a> Officiële website: <a href="https://www.interlay.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.interlay.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/interlayHQ" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/interlayHQ</a></strong><br><strong>Volg Interlay op <a href="https://t.me/interlay_community" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://discord.com/invite/interlay" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16842291572.jpg" alt=""><br><strong>Alexei - Medeoprichter en CEO van Interlay</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio143475"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Q120Kun20je20jezelf20en20Interlay20kort20voorstellen20aan20onze20gemeenschap20Wat20zijn20de20visie20en20missie20van20Interlay242527"><a name="Q1: Kun je jezelf en Interlay kort voorstellen aan onze gemeenschap? Wat zijn de visie en missie van Interlay?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je jezelf en Interlay kort voorstellen aan onze gemeenschap? Wat zijn de visie en missie van Interlay?</h3><p><strong>Alexei</strong>: Interlay is een gedecentraliseerd netwerk dat zich richt op het verbinden van cryptovaluta zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> met DeFi-platforms zoals <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het Interlay-netwerk zal gehost worden als een <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> parachain en zal verbonden worden met Cosmos, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en andere grote DeFi-netwerken.</p>
<p>Onze visie is een toekomst waarin blockchains naadloos met elkaar verbinden en communiceren: iedereen kan elk digitaal bezit op elke blockchain gebruiken, zonder vertrouwen en zonder beperkingen.</p>
<p>interBTC, het vlaggenschipproduct van Interlay, is <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> op elke blockchain. Een 1:1 <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Een door activa ondersteunde, volledig gecollateraliseerde, interoperabele en censuurbestendige stabiele munt. Op hoog niveau is interBTC voor BTC wat MakerDAO/DAI is voor de USD - maar dan beter. Een algoritmische stabiele munt, beveiligd door multi-collaterale verzekering en 1:1 ondersteund door en inwisselbaar voor BTC.</p>
<p>Kintsugi is Interlay’s kanarie netwerk, een experiment met echte economische waarde ingezet op <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a> Kintsugi en Interlay delen dezelfde codebasis - met het verschil dat Kintsugi zich strikt richt op innovatie en altijd voorop zal lopen qua functies.<br><img src="https://gimg2.gateimg.com/image/article/16842292403.jpg" alt=""><br>interBTC stelt gebruikers in staat om te investeren, te verdienen en te betalen met BTC op elk blockchain op de echte DeFi-manier:</p>
<ul>
<li>Beveiligd door verzekering: gebruikers kunnen terugkeren naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Op elk moment kunnen ze dat willen, of ze worden volledig vergoed in onderpand activa.</li><li>Radicaal open: iedereen kan helpen om het gedecentraliseerde systeem te beveiligen en gebruikers kunnen niet worden gecensureerd.<br><img src="https://gimg2.gateimg.com/image/article/16842291904.jpg" alt=""><br>Het proces is eenvoudig:<br>1) Vergrendel BTC,<br>2) Mint interBTC<br>3) Gebruik interBTC in DeFi - terwijl uw BTC worden beveiligd door gedecentraliseerde multi-collaterale verzekering,<br>4) Wissel interBTC te allen tijde in voor BTC.</li></ul>
<h3 id="h3-Q220Kunt20u20ons20kort20vertellen20over20uw20updates20in20het20afgelopen20jaar20en20hoe20uw20team20en20gemeenschap20zijn20gegroeid166480"><a name="Q2: Kunt u ons kort vertellen over uw updates in het afgelopen jaar en hoe uw team en gemeenschap zijn gegroeid?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kunt u ons kort vertellen over uw updates in het afgelopen jaar en hoe uw team en gemeenschap zijn gegroeid?</h3><p><strong>Alexei</strong>: Hier zijn enkele van onze meest memorabele prestaties!</p>
<ul>
<li>Van een bedrijf met slechts enkele leden groeiden we uit tot een buitengewoon team van 18 mensen van over de hele wereld. We zijn 100% op afstand en verspreid over de hele wereld. Onze teamleden werkten eerder bij PwC, Accenture, Google, WorldPay, Trivago, TEAM, Morgan Stanley, Hyperledger (open source), en we werven voor alle afdelingen (we verdubbelen het team in de komende 8 maanden!) <a href="https://apply.workable.com/interlay/?lng=en" rel="nofollow noopener noreferrer" target="_blank">https://apply.workable.com/interlay/?lng=nl</a></li><li>Onze community breidde zich uit van een paar honderd naar meer dan 30k+ op Twitter (@interlayHQ, @kintsugi_btc, @inter_btc), 6000+ op Discord en 4000+ op Telegram in slechts 6 maanden.</li><li>In slechts 4 maanden zijn we erin geslaagd om een solide ambassadeursprogramma te lanceren en nu bieden meer dan 100 ambassadeurs zich vrijwillig aan om de gemeenschap te testen, op te leiden en te laten groeien. We hebben vertaalteams voor Russisch, Chinees en binnenkort ook Spaans, Turks, enz. Onze on-chain treasury zal actief evenementen, content, vertalingen en communities financieren om mensen te helpen toegang te krijgen tot BTC en het via interBTC te gebruiken waar het het meest nodig is.</li><li>We hebben $ 9,5 miljoen aan durfkapitaal opgehaald via aandelenfinanciering om groei en ontwikkeling te stimuleren, en tienduizenden regels code geschreven;</li><li>We hebben 2 beveiligingsaudits afgerond (NCC en Informal s) en doen er nog 2 in Q1 2022 (Quarkslab en een eerste SR Labs “scan”)</li><li>We hebben 2 beurzen toegekend gekregen: voortzetting van de <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Foundation-subsidie op <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> en het aangaan van een nieuwe samenwerking met de Interchain Foundation van Cosmos.</li></ul>
<h3 id="h3-Q320Kun20je20ook20met20ons20delen20hoe20Interlay20de20parachainslot20van20Kusama20heeft20gewonnen20en20de20voortgang20van20de20crowdloan20in20Polkadot226963"><a name="Q3: Kun je ook met ons delen hoe Interlay de parachain-slot van Kusama heeft gewonnen en de voortgang van de crowdloan in Polkadot?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Kun je ook met ons delen hoe Interlay de parachain-slot van <a href="/price/kusama-ksm" target="_blank" class="blog_inner_link">Kusama</a> heeft gewonnen en de voortgang van de crowdloan in Polkadot?</h3><p><strong>Alexei</strong> Een van onze grootste prestaties, na twee jaar hard werken, hebben we een gewonnen <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a> parachain-slot met Kintsugi, het kanarische netwerk van Interlay, met 200.000 KSM (~ USD 50 mm) vergrendeld door 11.000+ supporters.</p>
<p>In december werd Kintsugi gelanceerd als een 100% gedecentraliseerd netwerk, in navolging van onze toewijding om trouw te blijven aan <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De visie van ‘s op het creëren van een nieuw, radicaal open financieel systeem. Kintsugi’s KINT is al ingeschreven op Gate, Kraken en MEXC.</p>
<p>Parallel hieraan neemt het Interlay-netwerk deel aan het <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> veilingen via een crowdloan (u kunt hier controleren en ondersteunen: <a href="https://crowdloan.interlay.io/" rel="nofollow noopener noreferrer" target="_blank">https://crowdloan.interlay.io/</a> Tot nu toe heeft onze crowdloan 2,7 miljoen DOT verzameld van meer dan 19.000 supporters.</p>
<p>En we zijn slechts enkele minuten verwijderd van officieel winnen <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> parachain slot 10!!</p>
<h3 id="h3-Q420Hoe20is20de20prestatie20van20Kusama20in20de20afgelopen20maanden20Hoe20is20de20netwerkstabiliteit20en20welke20projecten20hebben20zich20bij20uw20ecosysteem20aangesloten450210"><a name="Q4: Hoe is de prestatie van Kusama in de afgelopen maanden? Hoe is de netwerkstabiliteit en welke projecten hebben zich bij uw ecosysteem aangesloten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Hoe is de prestatie van Kusama in de afgelopen maanden? Hoe is de netwerkstabiliteit en welke projecten hebben zich bij uw ecosysteem aangesloten?</h3><p><strong>Alexei</strong>: Op dit moment zijn we bezig met de lancering van kBTC op Kintsugi ( <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a> Kintsugi is al 100% gedecentraliseerd - geregeerd door de KINT governance token.</p>
<p>kBTC - trustloos <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> op <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a>, wordt gelanceerd in maart.</p>
<p>De volgende stappen vóór de lancering zijn:<br>1) Activering van staken<br>2) Start Vaults en sta minting van kBTC toe<br>3) Integratie met alle belangrijke parachains op <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a><br>We zijn al aan het integreren met Moonriver en Karura. Het XCM-kanaal naar MOVR gaat volgende week live, Karura zal kort daarna volgen. Veel meer parachains zullen binnenkort volgen: privacyfuncties via het Calamari-netwerk van Manta of Khala, meer DeFi via Basilisk, Parallel Heiko en Picasso. Daarnaast werken we aan integraties met wallets (Talisman, Nova, Fearless), verkenner (Subscan) en governance-fora (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> zijn slechts het begin!</p>
<p>Er zijn in feite geen beperkingen aan waar je kBTC/interBTC kunt gebruiken en we kunnen niet wachten om te zien wat de gemeenschap bedenkt.</p>
<p>Stel je voor dat je interBTC zou kunnen gebruiken op <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>, … en niemand kan je tegenhouden. Geen gecentraliseerde beurzen of bewaarders die je BTC kunnen verliezen, stelen of in beslag kunnen nemen door overheden.</p>
<p>Dit is de visie van Interlay.</p>
<p>We hebben ook zojuist onze laatste testnetwedstrijd aangekondigd vóór de lancering van 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-runnen-een-loterij-beacbded2786</a></p>
<p>Help ons om de Kintsugi testnet stresstest uit te voeren en maak kans op KINT luchtdroppings.</p>
<h3 id="h3-Q520Wanneer20wordt20het20verwacht20te20lanceren20op20Polkadot20En20wat20zijn20jullie20plannen20en20prioriteiten20voor20de20toekomst399825"><a name="Q5: Wanneer wordt het verwacht te lanceren op Polkadot? En wat zijn jullie plannen en prioriteiten voor de toekomst?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Wanneer wordt het verwacht te lanceren op Polkadot? En wat zijn jullie plannen en prioriteiten voor de toekomst?</h3><p><strong>Alexei</strong>: Zoals vermeld, staan we op het punt om de te beveiligen <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> parachain slot (in 28 minuten eigenlijk). We hebben steun ontvangen van meer dan tienduizend deelnemers.</p>
<p>Zodra Interlay een parachain-slot wint, zal het hoofdnetwerk in maart/april live gaan met alle functies.<br>We werken nauw samen met alle belangrijke <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> teams - de eerste integraties zullen plaatsvinden op <a href="/price/kusama-ksm" rel="nofollow noopener noreferrer" target="_blank">Kusama</a> met Moonriver en Karura.</p>
<p>Via <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> Met ’s Ethreum-bruggen zullen we binnenkort ook kBTC en interBTC naar Nederland brengen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>- dus je zult eindelijk een gedecentraliseerd alternatief hebben voor de gecentraliseerde en geïnstitutionaliseerde wBTC.</p>
<p>Uiteindelijk gaan we gemeenschappen aan boord halen die actief vertrouwen op BTC als betaalmiddel - waar mensen geen vertrouwen hebben in de valuta van de overheid of de USD. Hier zal interBTC eindelijk een snelle, efficiënte en vertrouwensloze manier bieden om te gebruiken. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>