SWwgUHJlc2lkZW50ZSBkaSBSaXBwbGUgcHJldmVkZSBsYSBkb21pbmFuemEgZGVsbGEgY29uZm9ybWl0w6AgRGVGaSBuZWwgMjAyNA==

2024-02-22, 10:47

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR964471"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il settore DeFi crescerà se le aziende cripto rafforzano la loro conformità normativa.</p>
<p>Gli Stati Uniti hanno ridefinito le definizioni di “dealer” e “government securities dealer” per ottenere una maggiore supervisione sul settore delle criptovalute.</p>
<p>Il ricavo medio per utente nel mercato DeFi probabilmente raggiungerà $1,378 nel 2024.</p>
<h2 id="h2-Introduzione304851"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il presidente di Ripple ha fatto luce sugli sviluppi legali del 2024 e sulle prospettive della conformità DeFi alle normative esistenti ed emergenti sulle criptovalute. Ciò accade dopo che molti governi di tutto il mondo hanno riconosciuto la necessità di stabilire e far rispettare normative chiare sulle criptovalute per promuovere l’innovazione e proteggere i cittadini dalle attività illecite legate alle criptovalute.</p>
<p>In questa analisi, approfondiamo su Monica Long, la previsione della presidente di Ripple sui principali sviluppi nel settore delle criptovalute nel 2024. Esamineremo anche il recente cambiamento nella legislazione criptata degli Stati Uniti.</p>
<h2 id="h2-La20rapida20crescita20e20evoluzione20del20settore20DeFi79218"><a name="La rapida crescita e evoluzione del settore DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La rapida crescita e evoluzione del settore DeFi</h2><p>Nel 2024, il focus principale di Ripple è sulla conformità alle varie disposizioni legali che si applicano al settore DeFi. Infatti, Monica Long, presidente di Ripple, ritiene che la dominanza della conformità DeFi diventerà una delle tendenze cripto del 2024 che contribuiranno a costruire la fiducia degli investitori e attirare il supporto dei governi.</p>
<p>La conformità legale è molto cruciale durante questo periodo dopo che molti progetti crittografici ben consolidati come TerraUSD e FTX exchange sono crollati negli ultimi due anni. L’altra cosa preoccupante è stata l’alto numero di casi di fallimento come quello di Celsius, BlockFi e Voyager che si sono verificati nel 2023.</p>
<p>I vari casi di bancarotta e le implosioni dei progetti cripto hanno creato incertezza nel settore DeFi. La fiducia degli investitori è stata ulteriormente ridotta dalle continue repressioni della criptovaluta negli Stati Uniti. Pertanto, per ripristinare la sanità mentale e la fiducia nel settore, Long ha chiesto la conformità normativa.</p>
<p>Inoltre, Long ha detto che Ripple mira a sviluppare tecnologie innovative che rispettino gli standard regolatori per proteggere gli investitori e favorire la stabilità dell’industria delle criptovalute.</p>
<p>Inoltre, Long ritiene che seguendo le regolamentazioni il settore DeFi diventerà più connesso con l’industria finanziaria tradizionale, cosa che stimolerà la sua crescita. Nel 2024, le criptovalute romperanno i cicli di hype speculativo che hanno definito i boom e le cadute del settore finora. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> L’invenzione di ‘sarà la più grande svolta nel 2024, pionieristica per la conformità nella finanza decentralizzata, <a href="https://cointelegraph.com/news/defi-compliance-top-industry-trend-2024-says-ripple-president" rel="nofollow noopener noreferrer" target="_blank">Long ha detto</a>.</p>
<p>Ha aggiunto: “La strada da percorrere è un matrimonio felice, ed è quello in cui abbiamo sempre creduto. Non puoi trasformare il modo in cui la società si muove, gestisce, tokenizza e archivia il valore se non comprendi le fondamenta e la storia del problema.”</p>
<h2 id="h2-Utilit20e20Crescita20del20DeFi20nel20Mondo20Reale856512"><a name="Utilità e Crescita del DeFi nel Mondo Reale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Utilità e Crescita del DeFi nel Mondo Reale</h2><p>In un <a href="https://cointelegraph.com/news/defi-compliance-top-industry-trend-2024-says-ripple-president" rel="nofollow noopener noreferrer" target="_blank">intervista con Cointelegraph Long</a> sostiene che l’utilità del mondo reale di DeFi guiderà la sua adozione e crescita nel prossimo futuro. Questo perché la fase di hype e speculazioni alimentata dalle offerte iniziali di monete e dai token non fungibili sta giungendo al termine.</p>
<p>Il nuovo impulso DeFi dipende non solo dalla conformità normativa ma anche dall’integrazione con sistemi esistenti come TradFi e intelligenza artificiale. Già gli analisti ritengono che DeFi esperimenterà una crescita visibile nel 2024. Secondo <a href="https://www.coingecko.com/en/categories/decentralized-finance-defi" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a> Il settore DeFi ha una capitalizzazione di mercato superiore a $79,5 miliardi.</p>
<p>Una crescita DeFi così astronomica in meno di due decenni ha attirato l’attenzione dei regolatori, spingendoli a chiedere la regolamentazione del mercato crittografico.</p>
<p>Ci sono diversi fattori che potrebbero stimolare la crescita di DeFi nel 2024 e oltre. Innanzitutto, l’aumento dell’accesso ai servizi finanziari decentralizzati è fondamentale per la crescita del settore. Ciò è dovuto al fatto che i servizi DeFi sono più trasparenti, inclusivi e accessibili rispetto ai servizi finanziari tradizionali.</p>
<p>Ad esempio, il prestito, il trading e l’assunzione decentralizzati sono più accessibili in DeFi che nel settore finanziario tradizionale. In particolare, piattaforme di scambio decentralizzate e protocolli crittografici centralizzati offrono tali prodotti. Inoltre, lo sviluppo di nuove applicazioni e casi d’uso contribuirà ulteriormente alla crescita del settore.</p>
<p>Con gli sviluppi attuali, <a href="https://www.statista.com/outlook/fmo/digital-assets/defi/worldwide" rel="nofollow noopener noreferrer" target="_blank">Statista prevede</a> che il ricavo da DeFi potrebbe superare un tasso di crescita annuale del 9,07% tra il 2024 e il 2028 portando a “un importo totale previsto di US$37.040,0 m entro il 2028.”</p>
<p>Allo stesso tempo, il mercato DeFi potrebbe raggiungere un fatturato medio per utente di $1,378.0 nel 2024. Gran parte di questo fatturato arriverà dalle borse decentralizzate (DEXs) che consentono agli utenti di scambiare asset criptati senza intermediari o autorità centrali. Allo stesso modo, il numero di utenti DeFi potrebbe aumentare fino a 22,09 milioni entro il 2028.</p>
<h2 id="h2-La20SEC20ridefinisce20i20termini20del20dealer20mantenendo20la20registrazione20ampliata20negli20Stati20Uniti161705"><a name="La SEC ridefinisce i termini del dealer, mantenendo la registrazione ampliata negli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC ridefinisce i termini del dealer, mantenendo la registrazione ampliata negli Stati Uniti</h2><p>La SEC mira a trovare un modo per sottoporre il settore DeFi alla sua supervisione regolamentare attraverso l’espansione delle definizioni di “dealer” e “dealer di titoli di Stato”. La nuova definizione di dealer espanderà la sua applicazione al settore delle criptovalute.</p>
<p>Le regole adottate dalla SEC il 6 febbraio richiederanno ai partecipanti al mercato di registrarsi presso di essa e di conformarsi alle leggi federali sulla sicurezza e alle regole del mercato. Inoltre, la SEC richiederà a ciascun partecipante al mercato di diventare membro di un’organizzazione di autoregolamentazione.</p>
<p>Fondamentalmente, i trader svolgono importanti funzioni di mercato come fornire liquidità ai compratori e ai venditori e assorbire squilibri degli ordini. Secondo un recente <a href="https://www.sec.gov/news/statement/crenshaw-statement-dealer-trader-020624" rel="nofollow noopener noreferrer" target="_blank">dichiarazione governativa viene definito un rivenditore</a> come “qualsiasi persona impegnata nell’attività di acquisto o vendita di titoli per proprio conto.”</p>
<p>Inoltre, precisa che i “dealer” forniscono il servizio di trading immediato… la fornitura di liquidità, compresa l’azione come “market maker” o “un market maker de facto.”</p>
<p><a href="https://www.sec.gov/news/statement/crenshaw-statement-dealer-trader-020624#_ftn9" rel="nofollow noopener noreferrer" target="_blank">La commissaria Caroline Crenshaw ha spiegato</a> l’importanza delle nuove regole. Ha detto: «C’è una chiara falla qui: i partecipanti al mercato con una quota significativa del volume di mercato si impegnano in attività simili a quelle svolte dai dealer, senza essere registrati come dealer».</p>
<p>“Le regole che stiamo considerando oggi contribuirebbero a chiudere questa falla regolamentare e a livellare il campo da gioco sottoponendo i partecipanti al mercato che svolgono funzioni simili a quelle dei dealer a un regime regolamentare comune”, ha aggiunto.</p>
<p>Tali sentimenti da parte di un regolatore mostrano che le definizioni ampliate di “dealer” e “dealer di titoli di Stato” probabilmente si applicheranno presto al mercato crittografico, ridefinendo così le tendenze DeFi nel 2024.</p>
<h2 id="h2-Conclusione588190"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Monica Long, che è il presidente di Ripple, ha recentemente affermato che il settore DeFi dovrebbe rispettare le normative di mercato per registrare un successo maggiore rispetto al passato. Ha sottolineato che Ripple farà molto per rispettare le leggi esistenti ed emergenti. In un’azione correlata, gli Stati Uniti mirano a modificare le definizioni di “dealer” e “dealer di titoli di Stato” per renderle applicabili al settore delle criptovalute.</p>
<h2 id="h2-Domande20frequenti20su20DeFi150848"><a name="Domande frequenti su DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su DeFi</h2><h3 id="h3-Sono20le20monete20DeFi20un20buon20investimento379698"><a name="Sono le monete DeFi un buon investimento?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sono le monete DeFi un buon investimento?</h3><p>Alcune delle monete DeFi hanno il potenziale per offrire migliori rendimenti sugli investimenti rispetto agli asset finanziari tradizionali. Criptovalute leader come <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed Ether possono offrire buoni rendimenti attraverso programmi come la fornitura di liquidità e lo staking.</p>
<h3 id="h3-Quanto2020grande20DeFi20oggi827655"><a name="Quanto è grande DeFi oggi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto è grande DeFi oggi?</h3><p>La capitalizzazione di mercato totale di DeFi è di oltre 79,5 miliardi di dollari e ha il potenziale per continuare a salire. Tuttavia, la capitalizzazione di mercato di DeFi in qualsiasi momento dipende dalle performance dei vari token e monete.</p>
<h3 id="h3-Cosa20viene20considerato20DeFi317377"><a name="Cosa viene considerato DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa viene considerato DeFi?</h3><p>DeFi, che sta per finanza decentralizzata, è una tecnologia finanziaria basata sul blockchain e utilizza criptovalute per i pagamenti peer-to-peer. Ha l’obiettivo di ridurre le alte commissioni di transazione e i ritardi nei pagamenti che esistono nel settore finanziario tradizionale.</p>
<h2 id="h2-Cosa20significa20DeFi921606"><a name="Cosa significa DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa significa DeFi?</h2><p>DeFi sta per finanza decentralizzata in cui le persone e le istituzioni utilizzano criptovalute per effettuare pagamenti attraverso un sistema peer-to-peer. Attualmente, ci sono migliaia di valute virtuali a tale scopo.</p>
<h2 id="h2-Il20DeFi2020illegale20negli20Stati20Uniti429703"><a name="Il DeFi è illegale negli Stati Uniti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il DeFi è illegale negli Stati Uniti?</h2><p>DeFi è legale negli Stati Uniti, anche se c’è bisogno che le aziende criptate come gli scambi rispettino le normative di mercato nel paese. Negli Stati Uniti le persone possono acquisire, detenere e scambiare criptovalute. Possono anche usarle per effettuare pagamenti, anche se non sono a corso legale.</p>
<h3 id="h3-Qual2020la20tendenza20DeFi20nel202024478775"><a name="Qual è la tendenza DeFi nel 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la tendenza DeFi nel 2024?</h3><p>Nel 2024 la maggior parte dei progetti DeFi intende conformarsi alle diverse normative esistenti nei vari paesi. Le aziende del settore mirano anche a stringere partnership con società che operano nel settore finanziario tradizionale per aumentare l’adozione degli asset crittografici.</p>
<h3 id="h3-Quanto2020grande20il20mercato20DeFi93374"><a name="Quanto è grande il mercato DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto è grande il mercato DeFi?</h3><p>Il mercato DeFi ha una capitalizzazione di mercato totale di oltre $79,5 miliardi con prospettive di ulteriore crescita nel 2024. Ci aspettiamo anche che nuovi progetti DeFi entrino nel mercato nel 2024 e oltre.</p>
<h3 id="h3-C20futuro20nel20DeFi884214"><a name="C’è futuro nel DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>C’è futuro nel DeFi?</h3><p>DeFi è il futuro del settore finanziario globale se molte persone e organizzazioni adottano le criptovalute. Questo perché consente pagamenti trasparenti, economici e sicuri.</p>
<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 sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>