R2F0ZS5pbyBBTUEgY29uIERlZmljaGFpbi1OYXRpdmUgRGVjZW50cmFsaXplZCBGaW5hbmNlIHBlciBCaXRjb2lu

<p><img src="https://gimg2.gateimg.com/image/article/1675070122FfUQQ2UacAAz1RP.jpeg" alt=""></p>
<p><strong>Ora: 18 ottobre 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 l’ambasciatore di DeFiChain, Santiago nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Community di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://defichain.com/" rel="nofollow noopener noreferrer" target="_blank">https://defichain.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/defichain" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/defichain</a></strong><br><strong>Segui <a href="/price/defichain-dfi" target="_blank" class="blog_inner_link">Defichain</a> su <a href="https://t.me/FlareNetwork" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> e <a href="https://twitter.com/defichain" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/1675070298122.png" alt=""><br><strong>Santiago - Ambasciatore DeFiChain</strong></p>
<h2 id="h2-Domande20e20risposte20da20Gateio549525"><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-Q120Puoi20darci20una20breve20introduzione20su20di20te18275"><a name="Q1: Puoi darci una breve introduzione su di te?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi darci una breve introduzione su di te?</h3><p><strong>Santiago</strong>: Ciao ragazzi! Il mio nome è Santiago, faccio parte della Community DeFiChain fin dal primo giorno. Ho iniziato ad investire in criptovalute nel 2018 - dopo aver guardato e studiato tutto ciò che riguarda le criptovalute a partire dal 2016.</p>
<p>Ho studiato matematica e dopo essermi avvicinato alla Community di DeFiChain, ho iniziato il mio viaggio come imprenditore nel mondo delle criptovalute.</p>
<p>Non sono un fondatore di DeFiChain, sono coinvolto in alcuni progetti sulla blockchain. Sono il co-fondatore di DeFiChain Accelerator, che è un progetto finanziato dalla comunità per aiutare a far progredire DeFiChain. Ci occupiamo di partnership, quotazioni in borsa, marketing e altre cose per le quali normalmente è necessaria una parte centrale. Stiamo anche sviluppando e mantenendo un portafoglio web chiamato Jellywallet.</p>
<h3 id="h3-Q220Cos20DeFiChain891907"><a name="Q2: Cos’è DeFiChain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Cos’è DeFiChain?</h3><p><strong>Santiago</strong>: DeFiChain è una blockchain dedicata a rivoluzionare lo spazio DeFi cambiando l’architettura dei contratti intelligenti. DeFiChain rende gli asset del mondo reale negoziabili in modo decentralizzato. Abbiamo i cosiddetti ‘asset decentralizzati’, token che rappresentano tutte le diverse tipologie di asset!<br><img src="https://gimg2.gateimg.com/image/article/16750704491222.png" alt=""><br>DeFiChain è una blockchain dedicata che si basa su <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e si attiene agli stessi principi.</p>
<h3 id="h3-Q320Cosa20rende20DeFiChain20unico646494"><a name="Q3: Cosa rende DeFiChain unico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Cosa rende DeFiChain unico?</h3><p><strong>Santiago</strong>: Ci atteniamo alla non completezza di Turing di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> - che forse suona un po’ astratto o tecnico, ma in parole semplici significa che semplifichiamo notevolmente i contratti intelligenti, limitando la superficie di attacco.</p>
<p>Stiamo cercando di risolvere uno dei più grandi problemi che vediamo nello spazio DeFi. Le persone stanno perdendo denaro attraverso truffe, problemi di contratti intelligenti o semplicemente credendo in alcuni token che non hanno alcun reale caso d’uso nonostante siano un token di governance.</p>
<p>Su DeFiChain, c’è solo un token per tutto. DFI è il nostro token di governance nativo per il nostro exchange decentralizzato, viene utilizzato per i nostri prestiti decentralizzati e per il nostro meccanismo di consenso, poiché DeFiChain funziona su proof-of-stake.</p>
<p>È anche il ponte e il gateway per i nostri asset decentralizzati.<br><img src="https://gimg2.gateimg.com/image/article/167507042712222.png" alt=""><br>In breve: offriamo tutto ciò che puoi immaginare nello spazio DeFi, tutto su una catena senza alcun passaggio tra protocolli. Tutto in modo nativo, costruito su <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>.</p>
<h3 id="h3-Q420Puoi20approfondire20sugli20asset20decentralizzati20disponibili20su20DeFiChain448918"><a name="Q4: Puoi approfondire sugli asset decentralizzati disponibili su DeFiChain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Puoi approfondire sugli asset decentralizzati disponibili su DeFiChain?</h3><p><strong>Santiago</strong>: DeFiChain si occupa di asset decentralizzati, come azioni, materie prime ed ETF decentralizzati. Tokenizziamo questi asset e li rendiamo negoziabili. Fondamentalmente stiamo cercando di portare i derivati nell’industria blockchain, completamente decentralizzati e allineati ai principi di Bitcoin.</p>
<p>Abbiamo la nostra offerta nativa di scambio decentralizzato per tutti questi asset. Abbiamo prestiti decentralizzati e al momento stiamo lavorando su future e perpetual decentralizzati. Tutte queste funzionalità sono collegate ai nostri asset decentralizzati.</p>
<p>Le criptovalute hanno bancarizzato i non bancarizzati. DeFiChain è ora il broker per tutti coloro che non hanno accesso agli asset tradizionali.</p>
<p>Facciamo questo specchiando i prezzi di quei token di asset. I principi che ci sono dietro sono un po’ più complicati da spiegare qui, ma è molto interessante saperne di più.</p>
<h3 id="h3-Q520Il20vostro20grande20progetto20supporta20programmi20di20staking20In20caso20affermativo20come20funziona20il20vostro20sistema20di20staking20quali20sono20i20requisiti20per20gli20utenti20che20vogliono20fare20staking20sulla20vostra20piattaforma384096"><a name="Q5: Il vostro grande progetto supporta programmi di staking? In caso affermativo, come funziona il vostro sistema di staking, quali sono i requisiti per gli utenti che vogliono fare staking sulla vostra piattaforma?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Il vostro grande progetto supporta programmi di staking? In caso affermativo, come funziona il vostro sistema di staking, quali sono i requisiti per gli utenti che vogliono fare staking sulla vostra piattaforma?</h3><p><strong>Santiago</strong>: Spesso mi chiedo perché le persone facciano il “fake staking” su protocolli che non hanno nulla a che fare con il vero meccanismo di consenso di una blockchain. Se guardi ad esempio <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> 2.0, puoi fare staking del tuo ETH perché è veramente necessario per il consenso della blockchain.</p>
<p>La maggior parte degli altri protocolli usa semplicemente il termine “staking”, mentre si limita a gonfiare e distribuire il proprio token. Su DeFiChain, l’unico scopo dello staking è partecipare alla creazione dei blocchi, convalidare le transazioni e guadagnare davvero ricompense per i blocchi.</p>
<p>Abbiamo bisogno che il blockchain funzioni correttamente e tutti coloro che partecipano stiano fornendo un servizio per l’intera comunità, che è prezioso e deve essere ricompensato.</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 a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>