Q2hlIGNvc1wnw6ggUldBPyBDb21lIHB1w7IgUldBIGFjY2VuZGVyZSBsYSBwcm9zc2ltYSByaXZvbHV6aW9uZSBmaW5hbnppYXJpYT8=

2025-06-18, 08:35

<p><img src="https://gimg2.gateimg.com/image/rwa202506181632572287689548.png" alt="">
</p><p>“L’entità di finanziamento è passata dalle imprese a beni di alta qualità,” ha dichiarato Zhao Wenbiao, CEO del braccio tecnologico digitale di Ant Group, riassumendo la differenza essenziale della tokenizzazione degli RWA (Real World Assets). Ha paragonato questa innovazione a un “mini-IPO,” che ha completamente cambiato le regole del gioco tradizionale del finanziamento.</p>
<p>Langxin Technology ha emesso 100 milioni di RWA attraverso oltre 9.000 colonnine di ricarica per energia nuova come beni ancorati sulla blockchain; un vigneto a Jiading, Shanghai, ha emesso con successo 10 milioni di token RWA ed è stato sottoscritto da capitali internazionali, con l’intero processo dalla piantagione al raccolto registrato sulla blockchain. Questi casi stanno ridefinendo la nostra comprensione della liquidità degli attivi.</p>
<h2 id="h2-Analisi20degli20RWA20la20nuova20ondata20di20attivi20onchain220013"><a name="Analisi degli RWA, la nuova ondata di attivi on-chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi degli RWA, la nuova ondata di attivi on-chain</h2><p>RWA si riferisce essenzialmente alla migrazione digitale dei diritti sugli asset. Trasforma asset tangibili o intangibili del mondo reale, come immobili, materie prime, obbligazioni, opere d’arte e persino diritti futuri sui ricavi da stazioni di ricarica e vigneti, in token digitali on-chain attraverso la tecnologia blockchain.</p>
<p>Questo processo è chiamato “Tokenizzazione”, che conferisce agli asset nel mondo fisico le caratteristiche di essere divisibili, programmabili e scambiabili digitalmente a livello globale.</p>
<p>Le differenze fondamentali tra il finanziamento tradizionale e il finanziamento RWA sono significative. La finanza tradizionale si basa fortemente sulla solvibilità dell’entità (come le valutazioni aziendali), le banche richiedono forti garanzie o addirittura controgaranzie per concedere prestiti, con conseguenti soglie elevate e processi lunghi.</p>
<p>RWA si concentra quindi sul credito dell’asset stesso: finché il progetto è di alta qualità e ha aspettative di entrate stabili, i token possono essere emessi on-chain per raccogliere fondi da investitori globali. Wang Wei, CTO di Ant Group, ha sottolineato: “Simile al finanziamento delle imprese, è necessaria una due diligence, e il finanziamento degli asset fisici deve anche condurre indagini credibili, e <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> La tecnologia ha risolto il problema di fiducia degli asset fisici.</p>
<h2 id="h2-Perch2020necessaria20la20RWA20Valore20e20rischio20coesistono613650"><a name="Perché è necessaria la RWA? Valore e rischio coesistono" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché è necessaria la RWA? Valore e rischio coesistono</h2><p>L’esplosione delle RWA deriva dalla sua capacità di affrontare i punti critici della finanza tradizionale. Il Boston Consulting Group (BCG) prevede che entro il 2030, la dimensione del mercato globale delle RWA potrebbe raggiungere $16 trilioni, rappresentando il 10% del PIL globale. Citigroup stima che la tokenizzazione degli asset di aziende private non pubbliche crescerà più di 80 volte entro il 2030, raggiungendo circa $4 trilioni. I suoi vantaggi principali si riflettono in cinque dimensioni:</p>
<ul>
<li>Abbassare la soglia: Proprietà del valore di milioni o merci in grandi quantità possono essere suddivise in piccoli token (ad es., $100 per azione), consentendo agli investitori al dettaglio di partecipare.</li><li>Migliorare la liquidità: Gli attivi illiquidi (come immobili e crediti) possono essere scambiati on-chain24⁄7, riducendo il ciclo di conversione.</li><li>Abbattere le barriere geografiche: L’interoperabilità globale della blockchain rende più conveniente l’investimento transfrontaliero.</li><li>Migliorare la trasparenza e la sicurezza: I dati delle transazioni sono immutabili sulla blockchain, e i contratti smart eseguono automaticamente la condivisione dei profitti, riducendo il rischio di intervento umano.</li><li>Ridurre i costi: La disintermediazione elimina le alte commissioni di banche, avvocati e altri.</li></ul>
<p>I rischi non devono essere ignorati:</p>
<ul>
<li>Ambiguità Normativa: Molti paesi non hanno ancora chiarito il quadro giuridico RWA, rendendo complessa la conformità transfrontaliera.</li><li>Rischio di fiducia: L’autenticità degli asset dipende dall’emittente e dalle verifiche di terze parti. Se il custode commette frode, i token on-chain perdono il loro supporto.</li><li>Vulnerabilità tecnica: Se ci sono difetti nel contratto intelligente, potrebbe essere suscettibile ad attacchi informatici.</li><li>Volatilità degli asset: Il valore intrinseco può deprezzarsi (ad esempio, i prezzi degli immobili diminuiscono del 15%), richiedendo una valutazione dinamica.</li></ul>
<h2 id="h2-Panoramica20dei20progetti20RWA20ben20noti369295"><a name="Panoramica dei progetti RWA ben noti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica dei progetti RWA ben noti</h2><p>L’ecosistema RWA ha formato un percorso diversificato, con i seguenti progetti rappresentativi:</p>
<h3 id="h3-Token20dOro20La20Moneta20Forte20degli20Attivi20Fisici792305"><a name="Token d’Oro: La “Moneta Forte” degli Attivi Fisici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Token d’Oro: La “Moneta Forte” degli Attivi Fisici</h3><ul>
<li><p><a href="/price/pax-gold-paxg" rel="nofollow noopener noreferrer" target="_blank">PAX Gold</a> (PAXG): Emesso da Paxos, ogni token è ancorato a 1 oncia troy di oro fisico conservato a Londra, e il riscatto è supportato.</p>
</li><li><p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Gold (XAUT): Lanciato da Tether, sostenuto da oro custodito in caveau svizzeri, si affianca a PAXG come un token d’oro di uso comune.</p>
</li></ul>
<h3 id="h3-Bond20Token20Democratizzare20i20rendimenti20del20Tesoro20USA553915"><a name="Bond Token: “Democratizzare” i rendimenti del Tesoro USA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bond Token: “Democratizzare” i rendimenti del Tesoro USA</h3><ul>
<li><p>Ondo Finance (OUSG): Obbligazioni a breve termine del Tesoro degli Stati Uniti tokenizzate, con un rendimento annualizzato di circa il 5,1% e una soglia minima di investimento di 500 $.</p>
</li><li><p>Franklin FOBXX: Fondo monetario del governo tokenizzato, con il 99,5% delle attività allocate in obbligazioni del Tesoro statunitense e liquidità, disponibile per l’abbonamento a $20.</p>
</li></ul>
<h3 id="h3-Innovazione20nei20beni20fisici20una20svolta20per20il20microfinanziamento196875"><a name="Innovazione nei beni fisici: una svolta per il microfinanziamento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Innovazione nei beni fisici: una svolta per il microfinanziamento</h3><ul>
<li>Langxin Technology Charging Pile RWA: Ancorato dai diritti sui redditi futuri di oltre 9.000 stazioni di ricarica, ha raccolto 100 milioni di yuan in finanziamenti a Hong Kong attraverso la tecnologia Ant Chain, pioniera nella tokenizzazione degli asset di nuova energia in Cina.</li><li>Token Immobiliare RealT: Suddivide la proprietà immobiliare indipendente, consentendo ai detentori di token di ricevere il reddito da affitto in modo proporzionale, realizzando il modello del “proprietario frammentato”.</li></ul>
<h3 id="h3-Espansione20degli20asset20alternativi20Agricoltura20e20crediti20di20carbonio229190"><a name="Espansione degli asset alternativi: Agricoltura e crediti di carbonio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Espansione degli asset alternativi: Agricoltura e crediti di carbonio</h3><ul>
<li>Vigna di Jiading a Shanghai: L’intero processo di coltivazione dell’uva è su blockchain, emettendo 10 milioni di RWA per il finanziamento dell’espansione.</li><li>Tokenizzazione dei crediti di carbonio: Xiao Gang ha menzionato che i crediti di carbonio, come beni intangibili, possono liberare valore attraverso RWA.</li></ul>
<h2 id="h2-Sandbox20di20Hong20Kong20e20il20percorso20di20conformit20il20futuro20punto20di20ancoraggio20degli20RWA519705"><a name="Sandbox di Hong Kong e il percorso di conformità, il futuro punto di ancoraggio degli RWA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sandbox di Hong Kong e il percorso di conformità, il futuro punto di ancoraggio degli RWA</h2><p>Hong Kong sta diventando un campo di prova per la conformità per RWA. L’Autorità Monetaria di Hong Kong ha lanciato il progetto Ensemble sandbox, con il caso di Longshine Technology selezionato come uno dei primi progetti, costruendo un’architettura “due catene e un ponte”:</p>
<ul>
<li>Catena degli Asset (Continente): Gli asset fisici sono tokenizzati in prodotti digitali commerciabili.</li><li>Catena di Trading (Hong Kong): La valuta fiat è tokenizzata, completando transazioni transfrontaliere all’interno della sandbox.</li></ul>
<p>Questo design fornisce un modello per il flusso transfrontaliero di RWA. Xiao Gang ha sottolineato che il focus normativo dovrebbe essere su “autenticità degli asset, conformità e volatilità”, e che i rischi dovrebbero essere rigorosamente controllati off-chain mentre si frena la speculazione on-chain.</p>
<h2 id="h2-Prospettive20future20RWA733417"><a name="Prospettive future RWA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future RWA</h2><p>Goldman Sachs, HSBC e UBS stanno competendo per entrare nel mercato, portando la proprietà dell’oro e la tokenizzazione delle obbligazioni sulla blockchain. Il Chief Scientist di Ant Chain, Yan Ying, ha sottolineato che “le prestazioni ultime e la sicurezza sono le ricerche eterne di <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> tecnologia.”</p>
<p>Con la maturità dell’architettura blockchain che offre prestazioni di centinaia di migliaia di TPS e un’elaborazione dei dati a livello PB, i futuri ricavi delle stazioni di ricarica, dei vigneti e persino di una foresta saranno trasformati in codice fluente sulla catena.</p>
<p>Quando il valore del mondo reale viene riprogrammato, ciò che possediamo non sono più biglietti freddi, ma veri frammenti di asset verificabili: questo è il futuro di uguaglianza finanziaria promesso dagli RWA.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui presente non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o di una parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="5">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>