R2F0ZS5pbyBBTUEgbWV0IFNvdnJ5biAtIEVFTiBXRVJFTEQgT1AgQklUQ09JTiBCT1VXRU4=

<p><img src="https://gimg2.gateimg.com/image/article/16907852961.jpeg" alt=""><br><strong>Tijd: 24 september 2021, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hield een AMA (Ask-Me-Anything) sessie met The Gimp, communityleider bij Sovryn in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële website: <a href="https://sovryn.com/" rel="nofollow noopener noreferrer" target="_blank">https://sovryn.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/SovrynBTC" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/SovrynBTC</a></strong><br><strong>Volg Sovryn op Twitter en Telegram</strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16907854422.png" alt=""><br><strong>De Gimp - communityleider bij Sovryn</strong></p>
<h2 id="h2-Vragen20en20antwoorden20van20Gateio919330"><a name="Vragen en antwoorden van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vragen en antwoorden van Gate.io</h2><h3 id="h3-Laten20we20het20eerst20hebben20over20de20industrie2020er20is20geen20twijfel20dat20DeFi20op20dit20moment20een20hot20topic20is20in20de20cryptocurrencymarkt20Echter20in20deze20enorme20ecosysteem20lijkt20Bitcoin20de20koning20van20de20crypto20activa20afwezig20te20zijn20Wat20denk20je20dat20de20reden20is20voor20deze20situatie232573"><a name="Laten we het eerst hebben over de industrie … er is geen twijfel dat DeFi op dit moment een hot topic is in de cryptocurrency-markt. Echter, in deze enorme ecosysteem, lijkt Bitcoin, de koning van de crypto activa, afwezig te zijn. Wat denk je dat de reden is voor deze situatie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Laten we het eerst hebben over de industrie … er is geen twijfel dat DeFi op dit moment een hot topic is in de cryptocurrency-markt. Echter, in deze enorme ecosysteem, lijkt Bitcoin, de koning van de crypto activa, afwezig te zijn. Wat denk je dat de reden is voor deze situatie?</h3><p><strong>Gimp</strong>: Tot nu toe was er geen manier om dit te doen op Bitcoin. Het is niet zo dat mensen het niet wilden… niemand wil decentralisatie meer dan Bitcoiners, maar de technologie was niet in staat om complexe financiële processen mogelijk te maken op <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Een reden waarom Sovryn opwindend is, is dat het technologie zoals Lightning en rootstock samenbrengt en het nu mogelijk maakt om op <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> alles te doen wat haalbaar is op andere chains zoals <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>Er is nu een enorme kans om DeFi op te bouwen op het meest betrouwbare en veilige systeem, maar zoals bij alles kost dit tijd. We bouwen bewust langzaam en organisch en zijn voorzichtig in de ontwikkeling en beveiligingskeuzes om echte duurzaamheid te waarborgen. Ik geloof dat alleen een oplossing op Bitcoin dit kan bereiken.</p>
<h3 id="h3-Q220Maar20er20gebeurt20veel20in20de20nieuwe20financile20wereld20Wat20is20uw20mening20over20de20huidige20blockchain20financile20ecologie725643"><a name="Q2: Maar er gebeurt veel in de nieuwe financiële wereld. Wat is uw mening over de huidige blockchain financiële ecologie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Maar er gebeurt veel in de nieuwe financiële wereld. Wat is uw mening over de huidige blockchain financiële ecologie?</h3><p><strong>Gimp</strong>: Dus ik denk dat op de lange termijn we veel ketens zullen hebben, maar slechts een paar munten - nogal anders dan het huidige landschap.</p>
<p>Mensen denken dat L1-en zoals <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, Ethereum, Bitcoin hebben netwerkeffecten. Maar wat we zien is dat ze dat niet hebben. Gebruik verplaatst zich altijd naar de goedkoopste ketens - behalve voor Bitcoin omdat het de meest veilige is en veruit de meest aantrekkelijke voor grotere spelers.</p>
<p>Wat netwerkeffecten heeft, is het actief: Bitcoin of USD en de en die rond die activa zijn gebouwd. Dus op de lange termijn is het waarschijnlijk dat (bijna) alles zal worden opgenomen in het bitcoin-ecosysteem, aangezien het het meest veilig is en al laag in kosten - oplossingen zoals lightning versnellen dit voordeel nog meer. Naar mijn mening zijn we nog steeds aan het begin van een snelle uitbreiding.</p>
<h3 id="h3-V320Ok20en20wat20denk20je20dat20er20nodig20is20om20hiermee20verder20te20gaan20Waarom20denk20je20dat20Sovryn20de20nieuwe20Bitcoinrevolutie20zal20leiden303757"><a name="V3: Oké en wat denk je dat er nodig is om hiermee verder te gaan? Waarom denk je dat Sovryn de nieuwe Bitcoin-revolutie zal leiden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V3: Oké en wat denk je dat er nodig is om hiermee verder te gaan? Waarom denk je dat Sovryn de nieuwe Bitcoin-revolutie zal leiden?</h3><p><strong>Gimp</strong>: Ik denk dat bitcoin en de ontwikkeling ervan de laatste jaren enigszins in zelfgenoegzaamheid zijn beland. Het oorspronkelijke geniale ontwerp en het verhaal van de waardeopslag hebben het tot nu toe gebracht en zullen waarschijnlijk blijven doen. Maar we zouden zoveel meer kunnen doen. Een nieuwe fase van bitcoin is dringend nodig.</p>
<p>Sovryn geeft Bitcoin een nieuwe impuls. Het is een super jong project, maar is al de snelst groeiende tak van het ecosysteem. Sovryn heeft de manier veranderd waarop veel Bitcoin Maxis denken - en het heeft een super toegewijde en enthousiaste gemeenschap van bouwers.</p>
<p>Sovryn combineert de beste onderdelen van andere DeFi-en in één systeem en is de brug die Bitcoin verbindt met alle andere chains.</p>
<p>Hierdoor is het, ondanks dat het pas 5 maanden live is, nu al het meest complete DeFi-systeem waar dan ook. Leningen (binnenkort 0% leningen!), handelen, stablecoins (binnenkort bitcoin-gesteunde stablecoin!), NFT’s, volledige launchpad, subprotocollen en subsidiemogelijkheden, enzovoort, de lijst gaat maar door en door.</p>
<p>Ik denk dat het essentieel is dat wij (Sovryn) en andere projecten blijven verkennen van de functionaliteit van Bitcoin buiten het winkelwaarde-verhaal.</p>
<h3 id="h3-Q420Ok20erg20interessant20Maar20hoe20zit20het20met20de20beveiliging20Beveiliging20is20een20zorg20voor20veel20gebruikers20Hoe20garandeert20Sovryn20als20financieel20platform20de20transactiekwaliteit20en20veiligheid20voor20gebruikers454869"><a name="Q4: Ok, erg interessant… Maar hoe zit het met de beveiliging? Beveiliging is een zorg voor veel gebruikers. Hoe garandeert Sovryn als financieel platform de transactiekwaliteit en -veiligheid voor gebruikers?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ok, erg interessant… Maar hoe zit het met de beveiliging? Beveiliging is een zorg voor veel gebruikers. Hoe garandeert Sovryn als financieel platform de transactiekwaliteit en -veiligheid voor gebruikers?</h3><p><strong>Gimp</strong>: Beveiliging staat op de eerste plaats, boven alles. Als de beveiliging in gevaar komt, wordt het hele verhaal, de revolutie en de vrijheid die we proberen te brengen aan iedereen over de hele wereld, beschadigd. Sovryn is gebouwd voor beveiliging en betrouwbaarheid. We proberen iets te bouwen dat generaties lang mee zal gaan in de toekomst. Daarom bouwen we op het meest solide systeem: Bitcoin.</p>
<p>We hebben de security-first cultuur van Bitcoin naar DeFi gebracht. Elke code push wordt intern en extern gecontroleerd. Elke kleine verandering. Elke regel code.</p>
<p>Niets is ooit perfect, maar dat is ons doel. Dit is een systeem dat individuen, instellingen en zelfs landen kunnen gebruiken - dus dat is het niveau van betrouwbaarheid waar Sovryn naar streeft om te behouden en verwacht te leveren.</p>
<p>Als iemand geïnteresseerd is in het ontdekken van bugs of het proberen te kraken van de Sovryn-code, verwelkomen we dat. We hebben een doorlopende (ongeclaimde) bug bounty met een hoofdprijs van $1.000.000 in samenwerking met Immunefi. Als u aanzienlijke beveiligings-/hackervaring heeft, nodig ik iedereen van harte uit om het te bekijken.</p>
<h3 id="h3-V520Om20af20te20ronden20voordat20we20verder20gaan20met20vragen20van20ons20publiek20Welke20nieuwe20technologien20gebruikt20Sovryn20Wat20zijn20de20hoogtepunten20en20voordelen20van20Sovryn20in20vergelijking20met20andere20vergelijkbare20platforms20op20de20markt838814"><a name="V5: Om af te ronden voordat we verder gaan met vragen van ons publiek. Welke nieuwe technologieën gebruikt Sovryn? Wat zijn de hoogtepunten en voordelen van Sovryn in vergelijking met andere vergelijkbare platforms op de markt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V5: Om af te ronden voordat we verder gaan met vragen van ons publiek. Welke nieuwe technologieën gebruikt Sovryn? Wat zijn de hoogtepunten en voordelen van Sovryn in vergelijking met andere vergelijkbare platforms op de markt?</h3><p><strong>Gimp</strong>: Iets wat ik moet vermelden is dat Sovryn tot nu toe is gebouwd op RSK (Rootstock), een bitcoin-side-chain - wat betekent dat transacties worden gemined en beveiligd door bitcoin-miners. Momenteel wordt RSK samengevoegd met ongeveer 65% van de Bitcoin-miners en erft het enkele van de PoW-beveiligingskenmerken van Bitcoin, waardoor RSK het 2e veiligste netwerk ter wereld is, achter alleen Bitcoin.</p>
<p>Het belangrijke deel van RSK is dat het EVM-compatibel is, wat betekent dat ALLES wat mogelijk is op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> kan worden overgenomen op Bitcoin met behulp van Solidity-code. Bovendien is het inheemse activum bitcoin, worden de kosten betaald op het netwerk aan bitcoin miners, waardoor het beveiligingsbudget van het grootste liquiditeitspool in crypto wordt verhoogd - voor mij is het gewoon logisch dat we hier in het centrum van alles zijn.</p>
<p>Ik wil echter benadrukken dat Sovryn technologisch neutraal is. We zullen elke veelbelovende technologie adopteren. De enige dingen waar we om geven als het om technologie gaat, zijn</p>
<ul>
<li>Veiligheid</li><li>Bitcoin als het belangrijkste actief</li><li>Levensduur (realistisch gezien zo dicht mogelijk bij multigenerationele garanties)</li></ul>
<p>Dat maakt deel uit van de nieuwe filosofie die we naar Bitcoin brengen. Geen Bitcoin maximalisme. Bitcoin supermutanten. Sovryn is Bitcoin met superkrachten.</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 enkele beleggingsaanbevelingen.<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 vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>