Q29tcHJlbmRlcmUgbCdpbmZyYXN0cnV0dHVyYSBEZUZpOiBEZUZpIHByZW5kZXLDoCBpbCBjb250cm9sbG8gZGVsIG1vbmRvPw==

<p><img src="https://gimg2.gateimg.com/blog/165042832718348369crypto101_web.jpg" alt=""></p>
<h3 id="h3-TL20DR116131"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h3><ul>
<li>La finanza decentralizzata è una tecnologia basata sul blockchain che consente transazioni peer-to-peer.</li><li>DeFi utilizza contratti intelligenti durante l’esecuzione delle transazioni, mentre la finanza tradizionale ha intermediari.</li><li>Le applicazioni DeFi sono trasparenti, interoperabili e programmabili</li><li>Esempi di componenti di DeFi sono token avvolti, stablecoin, yield farming, assicurazione, staking, scambi decentralizzati e prestiti.</li></ul>
<h2 id="h2-Introduzione943739"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Al momento, esistono due ampi sistemi finanziari, la finanza decentralizzata (DeFi) e la finanza tradizionale (TradFi). Attualmente, i due sistemi coesistono, ma interagiscono in vari modi. Il sistema finanziario tradizionale comprende autorità centralizzate come banche e compagnie di assicurazione. Queste istituzioni utilizzano intermediari nelle loro operazioni, mentre il settore decentralizzato non utilizza terze parti per facilitare le transazioni. Questo articolo si concentrerà sull’infrastruttura della finanza decentralizzata (DeFi).</p>
<h2 id="h2-Cos20la20Finanza20Decentralizzata20DeFi428776"><a name="Cos’è la Finanza Decentralizzata (DeFi)?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è la Finanza Decentralizzata (DeFi)?</h2><p>La finanza decentralizzata, popolarmente conosciuta come DeFi, è una tecnologia in cui gli utenti interagiscono tra loro utilizzando smart contract. Non utilizzano intermediari come banche, compagnie di assicurazione o società di intermediazione per autorizzare le transazioni.</p>
<p>In sostanza, DeFi è una tecnologia basata su milioni di computer sparsi in tutto il mondo anziché su un singolo server. Tutte le transazioni avvengono utilizzando la blockchain e Internet, che collegano chi cerca servizi e chi li fornisce.</p>
<p>La blockchain, che è decentralizzata, immutabile, senza permessi e trasparente, consente a molti computer (nodi) di archiviare tutti i record delle transazioni.</p>
<h2 id="h2-Panoramica20della20DeFi929471"><a name="Panoramica della DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica della DeFi</h2><p>Uno degli aspetti importanti dell’infrastruttura DeFi sono le applicazioni decentralizzate che consentono agli utenti di connettersi tra loro. Quando utilizzi le applicazioni, interagisci direttamente con un contratto intelligente.</p>
<p>Ci sono varie applicazioni decentralizzate che includono piattaforme di prestito, asset sintetici, stablecoin e scambi decentralizzati. Queste applicazioni hanno molte cose in comune. Ad esempio, sono interoperabili, trasparenti, open source, programmabili e senza permessi. Spieghiamo alcune di queste.</p>
<p><strong>Trasparenza:</strong> Le transazioni vengono registrate sulla blockchain e chiunque abbia accesso a internet può visualizzarle.</p>
<p><strong>Interoperabile: </strong>Le applicazioni decentralizzate che esistono su un protocollo interagiscono tra di loro.</p>
<p><strong>Programmabile: </strong> Gli sviluppatori possono programmare le applicazioni in modo che interagiscano con altre dApp nell’ecosistema.</p>
<p>Open source e Permissionless: non ci sono restrizioni su chi può utilizzare le applicazioni purché le persone abbiano i portafogli e la connessione internet richiesti. Gli utenti possono inviare o ricevere asset digitali come stablecoin.</p>
<h2 id="h2-Limportanza20del20DeFi949811"><a name="L’importanza del DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’importanza del DeFi</h2><p>La verità è che DeFi è un catalizzatore nel settore finanziario. Ha molti casi d’uso. Ad esempio, consente alle persone di inviare e ricevere denaro senza restrizioni geografiche. Gli utenti possono prendere in prestito fondi purché rispettino le regole dei contratti intelligenti, come una certa quantità di garanzia se vogliono prendere in prestito fondi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16757544261.png" alt=""><br>Smart Contracts- Inc42</p>
<p>Anche le persone fisiche possono prestare le proprie attività digitali come le stablecoin. <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e Ether (ETH) ad altre persone e guadagnare interessi. Inoltre, le criptovalute offrono agli investitori la possibilità di investire in modi diversi come salvare i loro token e monete.</p>
<p>Come hai notato, DeFi offre utilità in vari settori dell’economia come il servizio assicurativo, la gestione patrimoniale, il farming di rendimento, il prestito e l’imprestito e il settore dei giochi. In sostanza, DeFi risolve seri problemi che esistono nel settore finanziario tradizionale.</p>
<h2 id="h2-Quali20problemi20risolve20DeFi222232"><a name="Quali problemi risolve DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali problemi risolve DeFi?</h2><p>Fondamentalmente, DeFi utilizza reti peer-to-peer durante le transazioni commerciali. Ciò significa che le istituzioni DeFi non utilizzano intermediari che costano molto denaro e creano molti ritardi. Di conseguenza, DeFi elimina problemi chiave che sono intrinseci nel sistema finanziario tradizionale, come l’inefficienza e l’accesso limitato alle risorse finanziarie per determinate sezioni della società.</p>
<p>Il sistema finanziario tradizionale è estremamente inefficiente poiché ha intermediari. Gli intermediari richiedono commissioni elevate e utilizzano procedure burocratiche. Ad esempio, quando un investitore desidera scambiare un’attività, la procedura è lunga. Con DeFi, l’esecuzione e il saldo della transazione sono quasi istantanei e simultanei.</p>
<p>Molte persone non possono accedere a alcune risorse finanziarie in TradeFi. Ciò avviene a causa di varie restrizioni. Ad esempio, gli utenti devono avere banche, garanzie e soddisfare determinati requisiti legali come avere carte d’identità nazionali. Poiché oltre 1,78 miliardi di persone nel mondo non hanno un conto bancario, non possono accedere alle risorse finanziarie. Tuttavia, DeFi non richiede alle persone di avere banche o soddisfare la maggior parte di questi requisiti restrittivi.</p>
<p>C’è una mancanza di interoperabilità all’interno del settore finanziario tradizionale. Questo perché ci sono molte barriere che impediscono alle diverse istituzioni all’interno del sistema finanziario tradizionale di interagire tra di loro. Ad esempio, chiunque voglia aprire un conto di trading online potrebbe dover trasferire fondi dal suo conto bancario. Questo richiede molto tempo e risorse. Tuttavia, le applicazioni DeFi possono facilmente interagire tra di loro.</p>
<h2 id="h2-Applicazioni20e20componenti20DeFi707932"><a name="Applicazioni e componenti DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Applicazioni e componenti DeFi</h2><p>DeFi ha diverse applicazioni, strumenti e componenti. Facciamo un breve riepilogo di questi componenti che includono stablecoin, scambi decentralizzati e monete wrapped.</p>
<h3 id="h3-Prestiti20e20prestiti20DeFi20266841"><a name="Prestiti e prestiti DeFi :" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="https://www.gate.io/lend-earn" target="_blank">Prestiti e prestiti DeFi</a>:</h3><p>Le persone hanno la possibilità di prestare i propri soldi a coloro che desiderano prenderli in prestito. I mutuatari devono pagare interessi per l’uso dei fondi, che di solito sono sotto forma di stablecoin.</p>
<p><strong>Scambi decentralizzati (Dexs): </strong>Gli scambi decentralizzati consentono alle persone di scambiare le proprie criptovalute <a href="https://www.gate.io/help/guide/sacurity/22495/How-to-Obtain-KYC-ID-Verification" target="_blank">senza bisogno di KYC</a>. Inoltre, i Dex sono senza permessi e permettono agli utenti di scambiare i propri asset in modo anonimo.</p>
<p><strong>Stablecoins: </strong>Queste sono criptovalute il cui valore è costante perché sono ancorate ad altri asset come l’oro e <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. Ad esempio, la maggior parte delle stablecoin sono ancorate al dollaro statunitense. Tuttavia, in alcuni casi il prezzo di alcuni <a href="https://www.gate.io/price/[Tether](https://www.gate.io/trade/USDT_USDT" target="_blank">stablecoin rimangono costanti</a>-usdt “le stablecoin rimangono costanti”) a causa degli algoritmi che ne controllano l’offerta e la domanda.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16757543072.png" alt=""><a href="https://www.gate.io/trade/USDT_USDT" target="_blank">Cavezza</a> USDT è una stablecoin popolare - Cryptonomist</p>
<p>Yield farming: coinvolge gli investitori che mettono in staking le loro criptovalute per guadagnare interessi. In quanto tali, guadagnano un reddito passivo senza impegnarsi molto e con un rischio molto basso.</p>
<p><strong>Monete incartate:</strong> Queste sono criptovalute che rappresentano altre monete e che esistono su diverse blockchain. Questo è importante perché aumenta l’interoperabilità, l’adozione delle criptovalute e porta a transazioni veloci in alcune situazioni. Ad esempio, wrapped <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> (wBTC) è un token che rappresenta <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> ma esiste sulla blockchain Ethereum. Mantiene lo stesso valore di <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>.</p>
<p><strong>Mercati delle previsioni:</strong> I mercati di previsione sono piattaforme in cui le persone fanno previsioni sui possibili risultati di determinati eventi o attività. Le scommesse coprono campi come lo sport, il trading, il forex e le criptovalute o la politica. Ad esempio, gli appassionati di sport scommettono sul possibile esito delle partite di calcio.</p>
<p><strong>Gestione degli asset: </strong>Gli utenti ora hanno modi per controllare i loro asset in modo trasparente attraverso DeFi. Possono facilmente trasferire o vendere i loro asset digitali senza l’uso di terze parti. Inoltre, possono acquistare gli asset di cui hanno bisogno senza vincoli.</p>
<p><strong>Portafogli elettronici:</strong> I portafogli digitali, anche chiamati e-wallet, aiutano le persone a interagire con diverse applicazioni. Questi portafogli funzionano indipendentemente dagli scambi di criptovalute e dalle altre dApp. In sostanza, il <a href="https://www.gate.io/blog_detail/1280/The-top-7-best-crypto-wallets" target="_blank">i portafogli ti permettono di controllare i tuoi asset digitali</a> dato che possiedi le chiavi private.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672367740screenshot-20221230-103526.png" alt=""></p>
<p>Altri componenti e applicazioni: l’elenco della DeFi<br>l’elenco delle applicazioni, componenti e strumenti è lungo. Oltre a quelli di cui abbiamo parlato sopra, abbiamo anche assicurazioni, app dell’industria del gioco, banche DeFi e molto altro.</p>
<h2 id="h2-DeFi20vs20infrastruttura20FinTech20tradizionale823756"><a name="DeFi vs infrastruttura FinTech tradizionale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFi vs infrastruttura FinTech tradizionale</h2><p>Come abbiamo detto in precedenza, ci sono chiare differenze tra la finanza tradizionale e DeFi. Con la finanza tradizionale, gli utenti devono svolgere processi lunghi per registrarsi e ottenere l’approvazione per utilizzare i loro servizi. Purtroppo, ci sono anche pregiudizi e discriminazioni nei confronti dei beneficiari.</p>
<p>Tuttavia, con DeFi il processo di imbarco è molto semplice. L’utente ha solo bisogno di un portafoglio digitale per interagire con le applicazioni DeFi. Le piattaforme non effettuano verifiche o controlli di sfondo. Racecapital utilizza una tabella semplice per confrontare TradeFi e DeFi.<br><img src="https://gimg2.gateimg.com/image/article/1672367851screenshot-20221230-103720.png" alt=""></p>
<p>Differenze tra TradeFi e DeFi - Racecapital</p>
<p>Ci sono diverse differenze tra la finanza tradizionale e la finanza decentralizzata. Tuttavia, DeFi ha il sopravvento sulla finanza tradizionale. Ad esempio, nel settore della finanza tradizionale le istituzioni detengono gli asset, mentre in DeFi gli utenti hanno la custodia dei propri asset.</p>
<p>Il settore finanziario tradizionale utilizza valute fiat mentre DeFi ha asset digitali come stablecoin. Ci sono intermediari in TradeFi ma contratti intelligenti in DeFi. Il settore finanziario tradizionale utilizza camere di compensazione mentre DeFi utilizza contratti intelligenti per effettuare le transazioni. Anche se esiste un collaterale su entrambi i lati, DeFi utilizza una sovra-collateralizzazione per garantire gli asset presi in prestito.</p>
<h2 id="h2-Applicazioni20DeFi42872"><a name="Applicazioni DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Applicazioni DeFi</h2><p>Le blockchain possono avere diverse applicazioni decentralizzate basate sui prodotti e servizi che offrono. Inoltre, alcune blockchain hanno diverse strutture come il livello di base e il livello 2. Il livello di base può ospitare varie applicazioni come i dApp di prestito e gestione degli asset. Il diagramma seguente mostra le diverse applicazioni che esistono sulla blockchain <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> e su quella di Ethereum.</p>
<p>Alcune blockchain come <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> hanno blockchain di livello 2. Le blockchain di livello 2 offrono soluzioni di scalabilità alle catene di livello 1 e principalmente conducono le transazioni offline. <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> e Arbitrum sono esempi di blockchain di livello 2 che esistono sulla blockchain di Ethereum.</p>
<h2 id="h2-Il20futuro20delle20applicazioni20finanziarie20decentralizzate584805"><a name="Il futuro delle applicazioni finanziarie decentralizzate" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il futuro delle applicazioni finanziarie decentralizzate</h2><p>Sebbene DeFi sembri avere caratteristiche e componenti migliori, ha ancora bisogno di miglioramenti. Soprattutto, gli sviluppatori possono migliorare le future applicazioni per renderle più user-friendly e aumentare la loro utilità.</p>
<h3 id="h3-Applicazioni20per20consumatori22285"><a name="Applicazioni per consumatori:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Applicazioni per consumatori:</h3><p>Il futuro di DeFi dovrebbe comprendere applicazioni per i consumatori che migliorano l’esperienza utente poiché gli utenti non interagiscono direttamente con il protocollo sottostante. Ciò può semplificare le interfacce utente dello spazio DeFi e migliorare l’esperienza utente.</p>
<h3 id="h3-Gestione20della20relazione20con20il20cliente20CRM764483"><a name="Gestione della relazione con il cliente (CRM):" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gestione della relazione con il cliente (CRM):</h3><p>Attualmente, DeFi non utilizza la gestione delle relazioni con i clienti in quanto non raccoglie informazioni personali degli utenti. Questo è positivo perché migliora la privacy. Tuttavia, se DeFi utilizza il CRM, i clienti otterranno prodotti e servizi che meglio soddisfano le loro esigenze e preferenze.</p>
<p>Non ci sono notifiche nel settore DeFi. In futuro le notifiche miglioreranno la comunicazione con gli utenti.</p>
<h3 id="h3-Annullamenti20delle20transazioni381180"><a name="Annullamenti delle transazioni:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Annullamenti delle transazioni:</h3><p>Attualmente, se un utente commette un errore durante l’elaborazione di una transazione, non può annullarla. I rollback delle transazioni aiuteranno gli utenti a annullare le transazioni che effettuano per errore.</p>
<h3 id="h3-Identit966484"><a name="Identità:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Identità:</h3><p>In DeFi gli utenti effettuano le loro transazioni in modo anonimo. Ciò ha portato alcuni attori malintenzionati a utilizzare le piattaforme DeFi per condurre attività commerciali illegali come il traffico di droga. A causa di questa pseudonimia, è molto difficile per gli agenti di polizia rintracciare e catturare i colpevoli. Pertanto, in futuro dovrebbe esserci un modo per identificare i cattivi attori come gli hacker.</p>
<h2 id="h2-Conclusione859712"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Le transazioni della finanza decentralizzata (DeFi) avvengono sulla blockchain e richiedono una connessione internet. La DeFi è diversa dalla finanza tradizionale perché non coinvolge intermediari. D’altra parte, il TradeFi coinvolge terze parti nell’esecuzione di alcune transazioni. Inoltre, la DeFi utilizza smart contract che consentono transazioni peer-to-peer.</p>
<h2 id="h2-FAQ336140"><a name="FAQ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FAQ</h2><h3 id="h3-Quali20sono20i20componenti20della20finanza20decentralizzata523121"><a name="Quali sono i componenti della finanza decentralizzata?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono i componenti della finanza decentralizzata?</h3><p>Prestiti e prestiti DeFi, scambi decentralizzati, stablecoin, farming di rendimento, monete avvolte e portafogli elettronici sono componenti di DeFi.</p>
<h3 id="h3-Cos20linfrastruttura20DeFi320527"><a name="Cos’è l’infrastruttura DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è l’infrastruttura DeFi?</h3><p>L’infrastruttura DeFi è la rete blockchain che supporta i contratti intelligenti.</p>
<h3 id="h3-Quali20sono20le20caratteristiche20dei20portafogli20DeFi319706"><a name="Quali sono le caratteristiche dei portafogli DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono le caratteristiche dei portafogli DeFi?</h3><p>I portafogli DeFi sono non custodiali, basati su chiave, accessibili e compatibili con i contratti intelligenti.</p>
<h3 id="h3-Quali20sono20gli20strumenti20DeFi84276"><a name="Quali sono gli strumenti DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono gli strumenti DeFi?</h3><p>Gli strumenti DeFi sono il software necessario per accedere ai servizi DeFi.</p>
<h3 id="h3-Qual2020la20spina20dorsale20del20DeFi455195"><a name="Qual è la spina dorsale del DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la spina dorsale del DeFi?</h3><p>Il pilastro di DeFi è il contratto intelligente.</p>
<div><br><div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di 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, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>