TGEgdHJhY2NpYSBSV0EgZG9taW5hIGRpIG51b3ZvIGxvIHNjaGVybW8sIHR1dHRvIGNpw7IgY2hlIGRldmkgc2FwZXJlIHN1bGxlIG51b3ZlIG9wcG9ydHVuaXTDoA==

2024-06-13, 01:25

<p><img src="https://gimg2.gateimg.com/image/article/1718241707sdfx.jpeg" alt=""></p>
<h2 id="h2-TLDR458269"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>Con lo spot degli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il settore degli RWA, che attrae un gran numero di fondi tradizionali e il Congresso degli Stati Uniti discute attivamente di questioni correlate, ha mostrato una performance relativamente forte.</p>
<p>Attualmente, la negoziazione on-chain di asset come stablecoin e titoli di stato ha dimostrato la fattibilità della tokenizzazione degli asset, e sempre più progetti stanno esplorando attivamente l’inclusione di più tipi di asset nel campo della blockchain.</p>
<p>Sebbene la tokenizzazione di asset su blockchain pubbliche non autorizzate possa sfruttare la liquidità on-chain, a causa della sua natura senza fiducia, potrebbe affrontare un rigoroso controllo normativo, che attualmente rappresenta la sfida più urgente per la tecnologia crittografica per passare alle applicazioni pratiche.</p>
<h2 id="h2-Introduzione742122"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Quando si esplora l’argomento relativamente persistente della crittografia in mezzo alla recente caduta del mercato e alla volatilità, occorre menzionare una traccia non meno competitiva di AI, MEME e DePIN - la tokenizzazione di Asset del mondo reale (RWA).</p>
<p>Con l’approvazione degli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e degli ETF <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> negli Stati Uniti, una grande quantità di fondi di asset reali si è riversata nel mercato delle criptovalute, e i progetti RWA in forte crescita rappresentati da Ondo Finance (ONDO) hanno ulteriormente attirato l’attenzione del mercato. Questo articolo fornirà ulteriori informazioni sullo stato di sviluppo del settore RWA e sulle opportunità di investimento.</p>
<h2 id="h2-Nuove20opportunit20per20RWA20sotto20la20narrazione20degli20ETF20Spot477028"><a name="Nuove opportunità per RWA sotto la narrazione degli ETF Spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nuove opportunità per RWA sotto la narrazione degli ETF Spot</h2><p>Se parliamo della narrazione più significativa di questo mercato rialzista, non possiamo fare a meno degli ETF spot di Bitcoin ed Ethereum, che hanno portato sempre più fondi e attenzione al mercato delle criptovalute. Tuttavia, i prodotti ETF si concentrano principalmente su Bitcoin ed Ethereum, e non ci sono segni di propagazione verso altri settori di altcoin. Pertanto, di recente si sono svolti dibattiti sul forte squilibrio tra i settori mainstream e altcoin di questo mercato rialzista.</p>
<p>Tuttavia, l’emergere dei prodotti RWA ha colmato questo squilibrio cognitivo, poiché l’acquisto di mercato tradizionale sta riversandosi nel mercato cripto attraverso gli ETF spot. Come una <a href="/price/terra-luna" target="_blank" class="blog_inner_link">terra</a> vergine che promuove l’integrazione dei mercati finanziari tradizionali e della tecnologia cripto, RWA sta diventando il settore più vantaggioso nel contesto di tassi di adozione cripto in continua espansione.</p>
<p>Specialmente nel contesto dell’attuale discussione attiva sulla tokenizzazione di beni reali da parte del Sottocomitato degli attivi digitali dei servizi finanziari della Camera dei rappresentanti degli Stati Uniti e dell’aumento del rendimento dei titoli di stato decennali, RWA è emersa da una performance relativamente indipendente.<br><img src="https://gimg2.gateimg.com/image/article/17182417921.jpeg" alt=""><br>Origine: Gate.io</p>
<p>Da una prospettiva più ampia, con molti ritardi nella stretta regolamentazione e aspettative di politica monetaria accomodante, i grandi investitori di mercato stanno cercando opportunità di investimento più robuste e prive di rischi. Allo stesso tempo, i cambiamenti macroeconomici e l’aumento dei rendimenti dei bond statunitensi hanno reso la tokenizzazione di asset del mondo reale una stella luminosa nel mercato delle criptovalute, diventando un canale importante per gli investitori per catturare valore.</p>
<p>In effetti, da una prospettiva di sviluppo più ampia, il mercato sta cercando modi per portare gli asset del mondo reale sulla catena sin dall’avvento della tecnologia blockchain. Oggi, istituzioni finanziarie tradizionali ben note come Goldman Sachs, Hamilton Alley, Siemens e KKR stanno cercando attivamente di collegare i loro asset del mondo reale. Nel frattempo, alcuni dei principali protocolli di finanza decentralizzata (DeFi) nel campo delle criptovalute, come MakerDAO e <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a>, si stanno costantemente adattando le loro strategie per adattarsi e abbracciare la tendenza delle RWA.</p>
<p>La tokenizzazione degli asset del mondo reale (RWA) converte il valore patrimoniale di beni tangibili o intangibili (come diritti di proprietà, diritti di reddito e diritti di utilizzo) in token digitali, consentendo lo stoccaggio e il trasferimento diretti degli asset sulla blockchain senza intermediari centrali tradizionali. Questo processo non solo dota questi asset delle caratteristiche uniche delle criptovalute, come la decentralizzazione, la sicurezza e l’anonimato, ma porta loro anche un’efficienza e una trasparenza delle transazioni senza precedenti.</p>
<p>Abbiamo scoperto che nel contesto attuale di debole volatilità del mercato, il settore RWA è uno dei pochi settori che ha mantenuto calore e potenziale di innovazione del valore rispetto ai settori AI, MEME, DePIN e altri che sono stati frequentemente discussi in passato. Secondo i dati di CoinMarketCap, alla data di scrittura, ci sono 142 progetti nel settore RWA, tra cui Ondo (ONDO), MakerDAO (MKR), Polymesh (POLYX), ecc., con un valore di mercato totale di oltre $40 miliardi, corrispondente solo al 0,16% della capitalizzazione di mercato totale del mercato delle criptovalute. C’è un grande potenziale per lo sviluppo in crescita.</p>
<p>In termini di dati commerciali, secondo i dati di DeFiLlama, il mercato RWA è ora entrato nell’undicesima categoria più grande nel campo DeFi, con 14 protocolli RWA inclusi e un valore totale bloccato superiore a $4,1 miliardi.</p>
<p>Come si può vedere dalla figura qui sotto, dopo il turbolento aprile e maggio, il mercato RWA dominato dai bond del tesoro USA basati su token ha ripreso il trend al rialzo. Questo potrebbe essere correlato al recupero del mercato cripto globale e agli investitori che si spostano verso rendimenti più elevati nel campo del prestito DeFi e del re-staking della liquidità.<br><img src="https://gimg2.gateimg.com/image/article/17182418202.jpeg" alt=""><br>Fonte: DeFiLlama</p>
<h2 id="h2-Quali20sono20i20punti20salienti20innovativi20della20pista20RWA599952"><a name="Quali sono i punti salienti innovativi della pista RWA?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono i punti salienti innovativi della pista RWA?</h2><p>RWA non è un semplice business tokenizzato on-chain di bond del tesoro statunitense. Secondo le nostre osservazioni, ci sono stati molti punti salienti innovativi nello sviluppo di questo settore.</p>
<h3 id="h3-120Digitalizzazione20degli20asset20raggiungere20unintegrazione20senza20soluzione20di20continuit20del20valore20degli20asset995824"><a name="1. Digitalizzazione degli asset: raggiungere un’integrazione senza soluzione di continuità del valore degli asset" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Digitalizzazione degli asset: raggiungere un’integrazione senza soluzione di continuità del valore degli asset</h3><p>La tokenizzazione delle RWA consente la rappresentazione digitale del valore degli asset, consentendo agli asset tradizionali di integrarsi senza soluzione di continuità nel mondo digitale. Questa innovazione rende più facile il commercio e la circolazione degli asset che originariamente erano difficili da circolare e scambiare, come immobili, arte, ecc.</p>
<p>Prendendo come esempio la piattaforma RWA on-chain per immobili di Sol Parcl, i proprietari di case possono convertire il reddito da affitto di vari progetti immobiliari sotto il loro controllo in asset digitali e condurre transazioni nell’ecosistema DeFi attraverso questa piattaforma. Ciò offre agli investitori una scelta più diversificata di investimenti e nuovi canali di finanziamento per gli sviluppatori immobiliari, raggiungendo il massimo valore degli asset.</p>
<h3 id="h3-220Trading20decentralizzato20riduzione20dei20costi20di20transazione20e20miglioramento20dellefficienza20delle20transazioni178647"><a name="2. Trading decentralizzato: riduzione dei costi di transazione e miglioramento dell’efficienza delle transazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Trading decentralizzato: riduzione dei costi di transazione e miglioramento dell’efficienza delle transazioni</h3><p>RWA negozia nell’ecosistema DeFi senza coinvolgere intermediari finanziari tradizionali, riducendo così i costi e i rischi delle transazioni. L’esecuzione automatica delle condizioni di transazione tramite smart contract riduce il rischio di intervento umano e operazioni erronee.</p>
<p>Nel frattempo, i token RWA o gli asset digitali hanno custodia professionale e piattaforme di trading, in particolare DePIN. Questa piattaforma fornisce una soluzione più on-chain e nativa per l’emissione e l’ancoraggio degli asset RWA, garantendo la sicurezza e l’efficienza delle transazioni.</p>
<h3 id="h3-320Opzioni20di20investimento20ricche20espansione20dellambito20dellallocazione20di20attivit309372"><a name="3. Opzioni di investimento ricche: espansione dell’ambito dell’allocazione di attività" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3. Opzioni di investimento ricche: espansione dell’ambito dell’allocazione di attività</h3><p>È ovvio che rispetto alla narrazione limitata all’Offerta Iniziale di Monete / Offerta di Token Sicure (ICO/STO) nel 2018, l’RWA di oggi ha condizioni, copertura e potenziale di sviluppo innovativi più ampi.</p>
<p>Le RWA basate su token consentono agli investitori di accedere a categorie di attività più diversificate, come immobili, arte, oro, bond del tesoro, ecc. La tokenizzazione di questi beni non solo arricchisce le scelte di investimento degli investitori, ma migliora anche l’efficienza dell’allocazione delle risorse.</p>
<p>In particolare, gli asset token dei titoli di stato del Tesoro degli Stati Uniti, che attualmente occupano la quota più alta del mercato RWA, non solo hanno rendimenti stabili e bassi rischi, ma anche alta liquidità e negoziabilità. Gli investitori possono comprare e vendere questi token dei titoli di stato del Tesoro in qualsiasi momento e ovunque, realizzando una comoda allocazione di asset globali.</p>
<p>Ad esempio, Galaxy Digital Holdings LP sta espandendo il suo business dei prestiti a nuovi gruppi di clienti. L’ultima transazione è un prestito di milioni di dollari garantito da un violino che un tempo apparteneva all’imperatrice russa Caterina II. Il violino sarà custodito da un custode a Hong Kong e portarlo via richiede che sia il mutuatario, Yat Siu, che Galaxy, a firmare un accordo.<br><img src="https://gimg2.gateimg.com/image/article/17182418703.jpeg" alt=""><br>Origine: informazioni pubbliche</p>
<h3 id="h3-420Smart20contracts20garantire20lautomazione20e20lintelligenza20delle20transazioni757379"><a name="4. Smart contracts: garantire l’automazione e l’intelligenza delle transazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>4. Smart contracts: garantire l’automazione e l’intelligenza delle transazioni</h3><p>La tecnologia dei contratti intelligenti basati su blockchain rende le transazioni RWA più automatizzate e intelligenti. I contratti intelligenti possono eseguire automaticamente le condizioni delle transazioni, riducendo il rischio di intervento umano e operazioni errate. Nel frattempo, i contratti intelligenti possono regolare automaticamente le strategie di trading in base alle condizioni di mercato, ottenendo una gestione intelligente delle risorse e l’ottimizzazione.</p>
<p>Ad esempio, Ondo Finance non solo ha reso accessibili gli ETF tradizionali sulla blockchain attraverso una serie di innovative strategie di tokenizzazione, ma ha anche promosso l’attività di trading delle azioni tokenizzate. La loro mossa riduce significativamente il divario tra i titoli tradizionali e la tecnologia blockchain, evidenziando ulteriormente l’integrazione tra DeFi (finanza decentralizzata) e finanza tradizionale.</p>
<h2 id="h2-Il20rischio20e20lopportunit20coesistono20RWA20apre20trilioni20di20dollari20di20spazio20di20capitalizzazione20di20mercato926021"><a name="Il rischio e l’opportunità coesistono, RWA apre trilioni di dollari di spazio di capitalizzazione di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il rischio e l’opportunità coesistono, RWA apre trilioni di dollari di spazio di capitalizzazione di mercato</h2><p>Come componente importante della tecnologia blockchain e DeFi, la traccia RWA sta mostrando gradualmente il suo unico valore e potenziale di applicazione.</p>
<p>I dati globali sulle valute e sui mercati mostrano che gli asset del mondo reale come argento, oro, azioni, obbligazioni globali, immobili e derivati costituiscono una dimensione di mercato enorme, superando di gran lunga le stesse valute digitali. Attraverso metodi innovativi come la digitalizzazione degli asset, il trading decentralizzato, scelte di investimento diverse e contratti intelligenti, il mercato RWA sta entrando in un periodo d’oro di sviluppo rapido.</p>
<p>Secondo il Boston Consulting Group, ci si aspetta che il mercato globale della tokenizzazione degli asset finanziari raggiunga uno straordinario valore di 16 trilioni di dollari entro il 2030. Questa tendenza non indica solo che il ponte tra la finanza tradizionale (TradFi) e la finanza decentralizzata (DeFi) sta gradualmente prendendo forma, ma pone anche una solida base per la creazione del mercato della prossima generazione.<br><img src="https://gimg2.gateimg.com/image/article/17182418924.jpeg" alt=""><br>Fonte: Boston Consulting Group</p>
<p>Attualmente, la negoziazione on-chain di asset come stablecoin e titoli di stato ha dimostrato la fattibilità della tokenizzazione degli asset, e sempre più progetti stanno esplorando attivamente l’inclusione di più tipi di asset nel campo della blockchain.</p>
<p>Tuttavia, la tokenizzazione di RWA affronta anche una serie di sfide. Sebbene la tokenizzazione di asset su blockchain pubbliche non licenziate possa sfruttare la liquidità on-chain, a causa della sua natura trustless, potrebbe affrontare una rigorosa regolamentazione, che attualmente rappresenta la sfida più pressante per la tecnologia crittografica per spostarsi verso applicazioni pratiche.</p>
<p>Sebbene gli asset tokenizzati su reti private ed ecosistemi possano soddisfare i requisiti normativi, potrebbero essere più limitati nell’attrarre utenti e investitori.</p>
<p>Inoltre, un problema urgente rimane: come aumentare la domanda di asset tokenizzati, migliorare la loro liquidità e praticità, e bilanciare l’esperienza operativa, i costi di transazione e i rischi tecnici.</p>
<p>Con il continuo avanzamento della tecnologia e il miglioramento del quadro normativo, ci si aspetta che il mercato RWA inietti nuova vitalità nell’innovazione e nello sviluppo dell’industria finanziaria globale. È prevedibile che le transazioni blockchain di asset negoziabili più realistici diventeranno più tracciabili, trasparenti, efficienti e sicure, aprendo una nuova era nella gestione e nel trading degli asset. Abbiamo motivo di credere che RWA sarà la prossima frontiera degna di nota nel campo delle criptovalute.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore Gate.io<br><div>Traduttore: Joy Z.<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 a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>