R2F0ZS5pbyBBTUEgY29uIExpbmVhciAtIElsIHByaW1vIHByb3RvY29sbG8gZGkgYXNzZXQgY29tcGF0aWJpbGUgY29uIENyb3NzLUNoYWluIGUgRGVsdGEtT25l

<p><img src="https://gimg2.gateimg.com/image/article/16836224151.jpg" alt=""><br><strong>Ora: 11 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 Kevin Tai, Project Lead di Linear nel <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://linear.finance/" rel="nofollow noopener noreferrer" target="_blank">https://linear.finance/</a></strong><br><strong>Twitter: <a href="https://twitter.com/LinearFinance" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/LinearFinance</a></strong><br><strong>Segui Linear su <a href="https://t.me/LinearExchangeCommunity" rel="nofollow noopener noreferrer" target="_blank">Telegramma</a> e <a href="https://discord.com/invite/nvCk356bky" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16836225402.png" alt=""><br><strong>Kevin Tai - Responsabile del progetto di Linear</strong></p>
<h2 id="h2-QampA20da20Gateio358196"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Puoi20darci20una20breve20introduzione20a20Linear20Finance567345"><a name="Q1: Puoi darci una breve introduzione a Linear Finance?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Puoi darci una breve introduzione a Linear Finance?</h3><p><img src="https://gimg2.gateimg.com/image/article/16836225523.png" alt=""><br><strong>Kevin</strong> Certamente. Quindi abbiamo lavorato su Linear Finance per oltre un anno e mezzo. Linear Finance è un protocollo di attività sintetiche decentralizzato compatibile tra le catene per creare, scambiare e gestire Liquid che sono versioni sintetiche di attività digitali, materie prime e indici. Siamo costruiti su ETH e BSC e agiamo come un’alternativa più veloce, più economica, più sicura e più facile da usare rispetto ad altri protocolli di attività sintetiche.</p>
<h3 id="h3-Q220E20come20si20inserisce20LINA20in20questo809967"><a name="Q2: E come si inserisce LINA in questo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: E come si inserisce LINA in questo?</h3><p><strong>Kevin</strong> LINA è il token di utilità e governance di Linear Finance, che è sia un token ERC-20 che BEP-20. LINA può essere utilizzato per lo staking nel pool di garanzie, il mining di liquidità, la governance (Linear DAO) e l’investimento in sintetici “Liquids” su asset di investimento con liquidità infinita e minimo o nullo slippage. Fondamentalmente, gli utenti fanno staking di LINA sulla nostra piattaforma Buildr, creano LUSD e poi possono utilizzarlo per scambiare i sintetici sulla nostra borsa.</p>
<h3 id="h3-Q320Puoi20approfondire20ulteriormente20su20Liquids20Cosa20sono20Dove20pu20la20comunit20scambiarli887916"><a name="Q3: Puoi approfondire ulteriormente su Liquids? Cosa sono? Dove può la comunità scambiarli?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Puoi approfondire ulteriormente su Liquids? Cosa sono? Dove può la comunità scambiarli?</h3><p><strong>Kevin</strong> I Liquids sono versioni sintetiche dei tuoi asset preferiti. Vanno dai cripto popolari come LBTC e LETH agli indici come LDEFI (Indice DEFI) e LPLAY (Indice NFT) dei nostri amici di PieDAO, alle materie prime e alle valute. Puoi scambiare tutti i nostri Liquids sulla Linear Exchange, puoi trovarli lì. <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> sotto:<br><a href="https://exchange.linear.finance/" rel="nofollow noopener noreferrer" target="_blank">https://exchange.linear.finance/</a></p>
<h3 id="h3-Q420Quali20sono20i20vantaggi20di20LINA20essere20compatibile20crosschain407467"><a name="Q4: Quali sono i vantaggi di LINA essere compatibile cross-chain?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Quali sono i vantaggi di LINA essere compatibile cross-chain?</h3><p><strong>Kevin</strong>:Essere su entrambi <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e BSC consente ai detentori di LINA di beneficiare di commissioni di gas basse durante la negoziazione su LinearExchange che funziona su BSC. Ma poiché siamo presenti su entrambe le reti ETH e BSC, tutti i nostri token Liquid possono essere trasferiti nuovamente su ETH per essere utilizzati nell’ecosistema ETH così come nell’ecosistema BSC … Nei prossimi mesi ci espanderemo su numerose altre reti.</p>
<h3 id="h3-Q520Hai20anche20accennato20in20precedenza20al20Linear20DAO20Di20cosa20si20tratta424597"><a name="Q5: Hai anche accennato in precedenza al Linear DAO. Di cosa si tratta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Hai anche accennato in precedenza al Linear DAO. Di cosa si tratta?</h3><p><strong>Kevin</strong> Certo. Fin dall’inizio del nostro lavoro su Linear sapevamo di voler adottare una struttura DAO per il protocollo. Ora, dopo mesi di duro lavoro, siamo orgogliosi di annunciare che il Linear DAO è ora attivo. I detentori di LINA possono ora proporre e votare sia sulle implementazioni di miglioramento che sulle nuove quotazioni che desiderano vedere diventare parte di Linear Finance. Se vuoi saperne di più sul Linear DAO, assicurati di controllare il <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> di seguito:<br><a href="https://medium.com/linear-finance/linear-governance-model-3fa81c3b3836" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/linear-finance/linear-governance-model-3fa81c3b3836</a></p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Community 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 pubblicare nuovamente l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>