UHJldmlzaW9uZSBkZWwgcHJlenpvIGRpIE9ORE8gMjAyNTogVmVkcsOgIE9uZG8gRmluYW5jZSBsYSBjcmVzY2l0YSBkaSBSV0E/

2025-02-19, 13:10

<h2 id="h2-Recenti20sviluppi20e20layout20della20pista20RWA20di20Ondo20Finance46814"><a name="Recenti sviluppi e layout della pista RWA di Ondo Finance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recenti sviluppi e layout della pista RWA di Ondo Finance</h2><p>Come progetto leader nel percorso di tokenizzazione degli Asset del Mondo Reale (RWA), Ondo Finance (ONDO) ha recentemente accelerato l’integrazione degli asset finanziari tradizionali e della blockchain attraverso l’innovazione dei prodotti, la cooperazione conforme e l’espansione ecologica; il posizionamento strategico e l’efficienza dell’esecuzione hanno gettato le basi per il valore a lungo termine del token ONDO.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1739970340ondo-finance-ondo-token-coin.png" alt=""></p>
<h2 id="h2-Innovazione20del20prodotto20Obbligazioni20governative20tokenizzate20e20liquidit20di20grado20istituzionale307486"><a name="Innovazione del prodotto: Obbligazioni governative tokenizzate e liquidità di grado istituzionale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Innovazione del prodotto: Obbligazioni governative tokenizzate e liquidità di grado istituzionale</h2><p>Nel 2024, Ondo Finance ha lanciato il prodotto obbligazionario del governo degli Stati Uniti tokenizzato OUSG, che ha portato l’ETF obbligazionario del Tesoro a breve termine di BlackRock (ICSH) sulla blockchain, consentendo agli utenti di acquistare azioni frammentate utilizzando la stablecoin USDC. Entro 6 mesi dal lancio, l’AUM del prodotto ha superato i 750 milioni di USD, con un tasso di rendimento annualizzato stabile del 4,8%-5,2%, rendendolo uno dei casi d’uso di maggior successo nel campo delle RWA.</p>
<p>Di recente, ONDO ha lanciato ulteriormente OUSG V2, supportando il dispiegamento multi-chain <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, Sui) e introducendo automatico <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">composto</a> interesse, riducendo significativamente la soglia di partecipazione per gli investitori piccoli e medi. I dati on-chain mostrano che dopo il lancio della versione V2, il volume di trading giornaliero di OUSG è aumentato del 300%, il numero di indirizzi di detenzione ha superato 120.000, diventando il punto di riferimento per i ‘rendimenti senza rischio’ nel mercato DeFi.</p>
<h2 id="h2-Innovazione20in20materia20di20conformit20profonda20collaborazione20con20i20giganti20della20TradFi796127"><a name="Innovazione in materia di conformità: profonda collaborazione con i giganti della TradFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Innovazione in materia di conformità: profonda collaborazione con i giganti della TradFi</h2><p>Il processo di conformità di ONDO ha fatto progressi significativi nel 2024, queste collaborazioni non solo migliorano l’approvazione del credito di OUSG, ma aprono anche la strada ai fondi istituzionali tradizionali per entrare in RWA:</p>
<ul>
<li>Investimenti Strategici di Morgan Stanley: A settembre 2024, Morgan Stanley ha guidato un finanziamento di Serie B da 50 milioni di dollari per ONDO attraverso il suo fondo blockchain e ha pianificato di includere OUSG nel suo pool di prodotti di gestione patrimoniale;</li><li>Domanda di licenza MAS di Singapore: La controllata di Ondo, Ondo Asia, ha presentato una domanda di licenza dei servizi di mercato dei capitali (CMS) all’Autorità monetaria di Singapore (MAS). Se approvata, diventerà il primo accordo RWA a ricevere l’approvazione regolamentare mainstream;</li><li>Accesso alla rete di compensazione del Tesoro degli Stati Uniti: ONDO ha raggiunto una cooperazione con DTCC (Depository Trust &amp; Clearing Corporation) per realizzare il regolamento in tempo reale delle azioni del Tesoro degli Stati Uniti on-chain con il sistema di compensazione TradFi.</li></ul>
<h2 id="h2-Aggiornamento20del20modello20economico20del20token20Rafforzamento20del20valore20dello20staking20e20della20governance848054"><a name="Aggiornamento del modello economico del token: Rafforzamento del valore dello staking e della governance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aggiornamento del modello economico del token: Rafforzamento del valore dello staking e della governance</h2><p>Nel Q4 2024, ONDO rilascerà il modello economico ONDO 2.0, con aggiustamenti principali tra cui:</p>
<ul>
<li>Diversificazione dei premi di staking: il 40% del ricavo del protocollo sarà allocato agli stakeholder di ONDO (aumentato dal 25%), e le fonti dei premi saranno ampliate per includere commissioni di trading, differenziali sui bond governativi e commissioni di servizi istituzionali;</li><li>Meccanismo di Masterizzazione dei Token: il 10% del reddito netto viene utilizzato per il riacquisto mensile e la masterizzazione di ONDO, con una prevista riduzione della circolazione dell’8%-12% entro il 2025;</li><li>Decentralizzazione del potere decisionale: permettere ai detentori di ONDO di votare sull’aggiunta di tipi di attività RWA supportate (come obbligazioni aziendali, REIT immobiliari).</li></ul>
<p>Attualmente, il tasso di staking di ONDO è aumentato dal 18% al 34%, e il numero di indirizzi dei whale (che detengono più di 1 milione di ONDO) è aumentato del 22%, indicando una maggiore fiducia tra i detentori a lungo termine.</p>
<h2 id="h2-Previsione20del20prezzo20ONDO20202520Onda20RWA20e20Rivalutazione20del20Valore800271"><a name="Previsione del prezzo ONDO 2025: Onda RWA e Rivalutazione del Valore" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsione del prezzo ONDO 2025: Onda RWA e Rivalutazione del Valore</h2><h3 id="h3-Tendenza20di20mercato20Soglia20di20Rottura20del20Tracciato20RWA701676"><a name="Tendenza di mercato: Soglia di Rottura del Tracciato RWA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenza di mercato: Soglia di Rottura del Tracciato RWA</h3><p>Secondo la previsione del Boston Consulting Group (BCG), ci si aspetta che le dimensioni del mercato globale dei token RWA raggiungano i 160 trilioni di dollari entro il 2030, con un tasso di crescita annuo composto del 68%. Il 2025 sarà un punto di svolta chiave:</p>
<ul>
<li>Ciclo di taglio dei tassi della Fed: se la Fed inizia a tagliare i tassi nel 2025, la diminuzione dei rendimenti dei bond statunitensi potrebbe spingere i fondi verso alternative ad alto rendimento come RWA (come OUSG);</li><li>L’ingresso istituzionale si accelera: giganti della gestione patrimoniale come BlackRock e Fidelity hanno avviato piloti RWA e ONDO, come benchmark di conformità, potrebbe diventare il partner preferito;</li><li>Chiarimento del quadro normativo: le normative dell’UE MiCA, i dettagli della classificazione di RWA da parte della SEC degli Stati Uniti vengono attuati, riducendo l’incertezza di mercato.</li></ul>
<h3 id="h3-Analisi20tecnica20possibilit20di20superare20i20massimi20storici285172"><a name="Analisi tecnica: possibilità di superare i massimi storici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi tecnica: possibilità di superare i massimi storici</h3><p>Dal punto di vista dei dati, ONDO è stato in crescita dal suo lancio su Gate.io nel gennaio 2024, con un prezzo di apertura di $0.03. Ad oggi, l’incremento ha superato le 40 volte. Attualmente, la tendenza di ONDO ha formato un modello di triangolo ascendente, con l’indicatore RSI stabile sopra i 50 e l’istogramma MACD che converge gradualmente verso l’asse zero, indicando un graduale controllo rialzista. Se supera i $2.1 (massimo storico del 2024), non ci sono significative resistenze al di sopra, e il target teorico potrebbe essere alto fino a $3.4 (livello di estensione Fibonacci al 161,8%).</p>
<h2 id="h2-Rischio20e20sfida20le20variabili20principali20dellimplementazione20di20RWA59421"><a name="Rischio e sfida: le variabili principali dell’implementazione di RWA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rischio e sfida: le variabili principali dell’implementazione di RWA</h2><h3 id="h3-Incertezza20delle20politiche20regolamentari28118"><a name="Incertezza delle politiche regolamentari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Incertezza delle politiche regolamentari</h3><ul>
<li>Differenziazione di atteggiamento della SEC degli Stati Uniti: se la SEC classifica il debito nazionale tokenizzato come token di sicurezza, potrebbe richiedere a ONDO di richiedere una licenza da Broker-Dealer, aumentando i costi di conformità;</li><li>Barriere alla compensazione transfrontaliera: Differenze normative tra i paesi sulle transazioni transfrontaliere <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">fluire</a> Il limite degli asset on-chain potrebbe limitare l’espansione globale di OUSG.</li></ul>
<h3 id="h3-La20controffensiva20della20finanza20tradizionale429057"><a name="La controffensiva della finanza tradizionale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La controffensiva della finanza tradizionale</h3><ul>
<li>Valuta autoemessa da BlackRock: se BlackRock lancia la propria piattaforma di gestione patrimoniale tokenizzata (come l’estensione BUIDL), potrebbe avere un impatto diretto sulla quota di mercato di ONDO;</li><li>Banking Alliance Snipe: Le alleanze bancarie come RWA (come la piattaforma RegA+) formate da istituzioni come JPMorgan Chase e Citigroup potrebbero stringere i clienti istituzionali di Ondo con il vantaggio della rete clienti.</li></ul>
<h3 id="h3-Smart20Contract20e20rischi20di20catena20sottostanti90177"><a name="Smart Contract e rischi di catena sottostanti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Smart Contract e rischi di catena sottostanti</h3><ul>
<li>Vulnerabilità cross-chain: la strategia di distribuzione multi-chain di Ondo aumenta la superficie di attacco dei contratti intelligenti. Una volta che una catena subisce un incidente di sicurezza, scatenerà una reazione a catena di vendite;</li><li>Collo di bottiglia della performance della catena sottostante: se le commissioni di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Gas aumentano o <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Il downtime della rete potrebbe influenzare l’esperienza di riscatto di OUSG e indebolire la fiducia degli utenti.</li></ul>
<h2 id="h2-Conclusione20la20Primavera20di20RWA20e20lOpportunit20di20ONDO652643"><a name="Conclusione: la Primavera di RWA e l’Opportunità di ONDO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione: la Primavera di RWA e l’Opportunità di ONDO</h2><p>Grazie al suo vantaggio orientato alla conformità, alla progettazione di prodotti di livello istituzionale e all’ottimizzazione continua del modello economico dei token, Ondo Finance è diventato uno dei progetti più implementabili nel percorso RWA. Entro il 2025, con il cambio della politica monetaria della Federal Reserve, l’ingresso dei giganti della gestione del patrimonio tradizionale e la chiarificazione dei quadri normativi, ci si aspetta che i token ONDO entrino in un ciclo di rivalutazione del valore.</p>
<p>Consiglio strategico per gli investitori:</p>
<ul>
<li>Allocazione a lungo termine: DCA (dollar cost average) in posizioni comprese tra 4 e 5,5 dollari, con l’obiettivo di mantenerla fino alla fine del 2025;</li><li>Monitoraggio degli eventi: concentrandosi sui dati di crescita AUM di ONDO, nuovo attivo RWA online e progressi nelle licenze regolamentari;</li><li>Controllo del rischio: Imposta $3.5 come stop loss rigido per evitare l’impatto degli eventi del cigno nero.</li></ul>
<p>Se la traccia RWA erompe come previsto, ONDO non sarà solo il beneficiario della finanza tokenizzata, ma potrebbe diventare anche il ponte centrale che collega TradFi e DeFi. Superare i $10 non è fuori portata, ma è necessaria vigilanza per il doppio test della regolamentazione e dei rischi tecnologici.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Glassa</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. L'investimento comporta dei rischi e gli utenti devono prendere decisioni attente.<br></em><div><em></em>Gate.io si riserva tutti i diritti relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>