R2F0ZS5pbyBBTUEgY29uIFNvdnJ5bi1DT1NUUlVJUkUgVU4gTU9ORE8gU1UgQklUQ09JTg==

<p><img src="https://gimg2.gateimg.com/image/article/16907852961.jpeg" alt=""><br><strong>Ora: 24 settembre 2021, 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 The Gimp, responsabile della community di Sovryn 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://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>Segui Sovryn su Twitter e Telegram</strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16907854422.png" alt=""><br><strong>The Gimp - community lead a Sovryn</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio26784"><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-Q120Quindi20iniziamo20parlando20dellindustria20non20c20dubbio20che20DeFi20sia20un20argomento20caldo20nel20mercato20delle20criptovalute20in20questo20momento20Tuttavia20in20questo20enorme20ecosistema20Bitcoin20il20Re20degli20asset20crittografici20sembra20essere20assente20Cosa20pensi20sia20la20ragione20di20questa20situazione390502"><a name="Q1: Quindi iniziamo parlando dell’industria…. non c’è dubbio che DeFi sia un argomento caldo nel mercato delle criptovalute in questo momento. Tuttavia, in questo enorme ecosistema, Bitcoin, il Re degli asset crittografici, sembra essere assente. Cosa pensi sia la ragione di questa situazione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Quindi iniziamo parlando dell’industria…. non c’è dubbio che DeFi sia un argomento caldo nel mercato delle criptovalute in questo momento. Tuttavia, in questo enorme ecosistema, Bitcoin, il Re degli asset crittografici, sembra essere assente. Cosa pensi sia la ragione di questa situazione?</h3><p><strong>Gimp</strong>: Fino ad ora, non c’era modo di farlo su Bitcoin. Non è che le persone non volessero… nessuno desidera la decentralizzazione più dei Bitcoiners, ma la tecnologia non era pronta per consentire processi finanziari complessi su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Un motivo per cui Sovryn è eccitante è che avvolge insieme tecnologie come Lightning e rootstock e rende ora possibile fare su <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> tutto ciò che è realizzabile su altre catene come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>Ora c’è un’enorme opportunità di costruire DeFi sul sistema più affidabile e sicuro, ma come tutte le cose ci vorrà del tempo. Stiamo costruendo intenzionalmente lentamente, in modo organico e facendo attenzione nelle scelte di sviluppo e sicurezza per garantire una vera sostenibilità. Credo che solo una soluzione su Bitcoin possa raggiungere questo.</p>
<h3 id="h3-Q220Ma20poi20c20molto20da20fare20nel20nuovo20mondo20della20finanza20Qual2020la20tua20opinione20sullattuale20ecologia20finanziaria20blockchain256959"><a name="Q2: Ma poi c’è molto da fare nel nuovo mondo della finanza. Qual è la tua opinione sull’attuale ecologia finanziaria blockchain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ma poi c’è molto da fare nel nuovo mondo della finanza. Qual è la tua opinione sull’attuale ecologia finanziaria blockchain?</h3><p><strong>Gimp</strong> Quindi penso che a lungo termine avremo molte catene ma solo poche monete - piuttosto diverso dal panorama attuale.</p>
<p>Le persone pensano che i sistemi L1 come <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, Ethereum, Bitcoin hanno effetti di rete. Ma quello che vediamo è che non lo hanno. L’utilizzo si sposta sempre sulle catene più economiche, tranne Bitcoin perché è il più sicuro e di gran lunga il più attraente per i grandi giocatori.</p>
<p>Ciò che ha effetti di rete è l’asset: Bitcoin o USD e i sistemi costruiti attorno a questi asset. Quindi, nel lungo periodo, è probabile che (quasi) tutto venga assorbito nell’ecosistema Bitcoin poiché è il più sicuro e già a basso costo - soluzioni come il lightning accelerano ulteriormente questo vantaggio. Direi che, secondo la mia opinione, siamo ancora all’inizio di una rapida espansione.</p>
<h3 id="h3-Q320Ok20e20cosa20pensi20che20sia20necessario20per20andare20avanti20con20questo20Perch20pensi20che20Sovryn20guider20la20nuova20rivoluzione20di20Bitcoin230416"><a name="Q3: Ok e cosa pensi che sia necessario per andare avanti con questo? Perché pensi che Sovryn guiderà la nuova rivoluzione di Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ok e cosa pensi che sia necessario per andare avanti con questo? Perché pensi che Sovryn guiderà la nuova rivoluzione di Bitcoin?</h3><p><strong>Gimp</strong>: Penso che il bitcoin e il suo sviluppo siano caduti un po’ nella compiacenza negli ultimi anni. Il genio originale della progettazione e il racconto del valore di conservazione lo hanno portato fin qui e probabilmente continueranno a farlo. Ma potremmo fare molto di più. Un nuovo stadio del bitcoin è disperatamente necessario.</p>
<p>Sovryn sta avviando questa nuova fase per Bitcoin. È un progetto ancora molto giovane ma è già la parte a più rapida crescita dell’ecosistema. Sovryn ha cambiato il modo in cui molti massimalisti di Bitcoin pensano - ed ha una comunità di costruttori super dedicata ed entusiasta.</p>
<p>Sovryn combina le migliori parti di altri sistemi DeFi in un unico sistema ed è il ponte che collega Bitcoin a tutte le altre catene.</p>
<p>A causa di ciò, anche se è attivo solo da 5 mesi, è già il sistema DeFi più completo in assoluto. Prestiti (prestazioni al 0% presto!), trading, stablecoin (presto stablecoin basata su bitcoin!), NFT, launchpad completo, sottoprotocolli e opportunità di finanziamento, eccetera, la lista continua.</p>
<p>Penso che sia fondamentale che noi (Sovryn) e altri progetti continuiamo a esplorare la funzionalità di Bitcoin al di là della narrazione del valore deposito.</p>
<h3 id="h3-Q420Ok20molto20interessante20Ma20per20quanto20riguarda20la20sicurezza20La20sicurezza2020una20preoccupazione20per20molti20utenti20Come20piattaforma20finanziaria20come20garantisce20Sovryn20la20qualit20e20la20sicurezza20delle20transazioni20agli20utenti988563"><a name="Q4: Ok, molto interessante… Ma per quanto riguarda la sicurezza? La sicurezza è una preoccupazione per molti utenti. Come piattaforma finanziaria, come garantisce Sovryn la qualità e la sicurezza delle transazioni agli utenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Ok, molto interessante… Ma per quanto riguarda la sicurezza? La sicurezza è una preoccupazione per molti utenti. Come piattaforma finanziaria, come garantisce Sovryn la qualità e la sicurezza delle transazioni agli utenti?</h3><p><strong>Gimp</strong>: La sicurezza è al primo posto, sopra ogni cosa. Se la sicurezza viene compromessa, l’intera narrazione, rivoluzione e libertà che stiamo cercando di portare a tutti nel mondo è danneggiata. Sovryn è costruito per la sicurezza e l’affidabilità. Stiamo cercando di costruire qualcosa che durerà per le generazioni future. Ecco perché stiamo costruendo sul sistema più solido: Bitcoin.</p>
<p>Abbiamo portato la cultura della sicurezza di Bitcoin a DeFi. Ogni push del codice viene sottoposto a revisione interna ed esterna. Ogni piccola modifica. Ogni riga di codice.</p>
<p>Niente è mai perfetto, ma questo è il nostro obiettivo. Questo è un sistema che individui, istituzioni e persino paesi possono utilizzare, quindi questo è il livello di affidabilità che Sovryn si impegna a mantenere e si aspetta di offrire.</p>
<p>Se qualcuno è interessato a scoprire bug o a cercare di rompere il codice Sovryn, lo accogliamo con favore. Abbiamo una ricompensa per bug in corso (non reclamata) con una ricompensa massima di $1,000,000 in collaborazione con Immunefi. Se hai un’esperienza significativa in materia di sicurezza/hacking, ti incoraggerei vivamente a darci un’occhiata.</p>
<h3 id="h3-Q520Quindi20per20concludere20prima20di20passare20alle20domande20del20nostro20pubblico20Quali20nuove20tecnologie20sta20utilizzando20Sovryn20Quali20sono20i20punti20salienti20e20i20vantaggi20di20Sovryn20rispetto20ad20altre20piattaforme20simili20presenti20sul20mercato492272"><a name="Q5: Quindi per concludere prima di passare alle domande del nostro pubblico. Quali nuove tecnologie sta utilizzando Sovryn? Quali sono i punti salienti e i vantaggi di Sovryn rispetto ad altre piattaforme simili presenti sul mercato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quindi per concludere prima di passare alle domande del nostro pubblico. Quali nuove tecnologie sta utilizzando Sovryn? Quali sono i punti salienti e i vantaggi di Sovryn rispetto ad altre piattaforme simili presenti sul mercato?</h3><p><strong>Gimp</strong>: Una cosa che devo menzionare è che fino ad ora Sovryn è costruito su RSK (Rootstock), una side-chain di bitcoin, il che significa che le transazioni vengono estratte e garantite dai minatori di bitcoin. Attualmente RSK viene estratto in merge con circa il 65% dei minatori di Bitcoin ed eredita alcune caratteristiche di sicurezza PoW di Bitcoin, rendendo RSK la seconda rete più sicura al mondo dietro solo a Bitcoin.</p>
<p>La parte importante di RSK è che è compatibile con EVM, il che significa CHE QUALSIASI COSA che è possibile su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> può essere adottata su Bitcoin utilizzando il codice Solidity. Inoltre, l’asset nativo è bitcoin, le commissioni pagate sulla rete vanno ai minatori di bitcoin, aumentando il budget di sicurezza del pool di liquidità più grande nel settore delle criptovalute - per me ha semplicemente senso essere qui, al centro di tutto.</p>
<p>Tuttavia, mi piacerebbe sottolineare che Sovryn è tecnologicamente agnostico. Adotteremo qualsiasi tecnologia che sia promettente. Le uniche cose a cui ci interessa quando si tratta di tecnologia sono</p>
<ul>
<li>Sicurezza</li><li>Bitcoin come principale asset</li><li>Longevità (realisticamente il più vicino possibile alle garanzie multigenerazionali che possiamo ottenere)</li></ul>
<p>Fare parte della nuova filosofia che portiamo a Bitcoin. Non il massimalismo di Bitcoin. Sovryn è Bitcoin con superpoteri.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il repostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>