UHJlenpvIFBZVEggb2dnaTogY29zXCfDqCBQeXRoIE5ldHdvcms/

2025-05-14, 10:23

<p><img src="https://gimg2.gateimg.com/image/article/1747218141pyth.png" alt="">
</p><p>Secondo i dati di mercato di Gate, al 14 maggio 2025, il prezzo di PYTH è di $0.1914, con un volume di scambi di 24 ore di $92 milioni in tutta la rete. Il valore di mercato circolante di PYTH è attualmente di $695 milioni, classificandosi al 104º posto nel mercato delle criptovalute. Nonostante una diminuzione di oltre l’80% rispetto al suo massimo storico di $1.15 nel marzo 2024, il sentiment di mercato recente è significativamente migliorato, con un aumento del 44.5% di PYTH negli ultimi 7 giorni, indicando che i fondi stanno rapidamente affluendo nella traccia dell’oracolo.</p>
<p>Da un punto di vista tecnico, l’attuale indice RSI (68) di PYTH si trova nell’intervallo neutro, SMA ha superato la media mobile dei 200 giorni, formando una “crociera dorata”, e potrebbe affrontare pressioni di ritorno a breve termine, ma il trend medio- a lungo termine è ottimistico.</p>
<h2 id="h2-Cos20la20rete20PYTH130021"><a name="Cos’è la rete PYTH?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è la rete PYTH?</h2><p>La rete PYTH è <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Un protocollo oracle decentralizzato nativo della catena, focalizzato sulla fornitura di dati di mercato finanziario ad alta precisione e a bassa latenza per le blockchain, coprendo oltre 380 categorie di asset come criptovalute, azioni, scambio estero e materie prime. La sua innovazione principale risiede nel modello di aggiornamento dei prezzi, in cui gli utenti possono richiamare dati in tempo reale aggregati on-chain secondo necessità, anziché la modalità push programmata degli oracle tradizionali, comprimendo il tempo di aggiornamento dei singoli dati a 400 millisecondi e riducendo i costi del gas del 90%.</p>
<p>Pyth Network attualmente supporta la maggior parte delle blockchain principali (incluse Solana, Ethereum, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, ecc.), con un valore totale bloccato (TVS) superiore a $15 miliardi. Ad aprile 2025, il volume di trading mensile ha superato i $67 miliardi, diventando l’infrastruttura principale per i derivati DeFi e il trading algoritmico.</p>
<h3 id="h3-Vantaggi20tecnici290199"><a name="Vantaggi tecnici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vantaggi tecnici</h3><ul>
<li>Fonti di dati di prima parte: Dati di mercato diretti aggregati da oltre 90 istituzioni finanziarie di primo piano come Jump Trading, Jane Street, Nasdaq, ecc., per evitare deviazioni di dati secondari.</li><li>Compatibilità cross-chain: Sincronizza i dati su più di 70 blockchain tramite il protocollo Wormhole, coprendo il 95% dei principali protocolli DeFi.</li><li>Modello economico del token: il 52% dei token è utilizzato per incentivare l’ecosistema, il 22% è allocato ai fornitori di dati per favorire la partecipazione alla rete. A maggio 2025, verranno sbloccati 2,13 miliardi di PYTH (corrispondenti al 21,3% dell’offerta totale); se c’è una forte domanda istituzionale, potrebbe alleviare la pressione delle vendite e aumentare i prezzi.</li></ul>
<h3 id="h3-Posizionamento20di20mercato705696"><a name="Posizionamento di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Posizionamento di mercato</h3><p>Nonostante Chainlink continui a dominare il mercato degli oracoli con un TVS di $35.5 miliardi, Pyth ha registrato una crescita esplosiva con il modello Transaction Volume Oracle (TTV) raggiungendo $800 miliardi nel volume di trading on-chain entro il 2024, con un tasso di crescita annuo superiore a 10 volte, catturando in particolare una quota del 70% nei derivati come Drift Protocol.</p>
<p>La differenza fondamentale tra i due risiede in:</p>
<ul>
<li>Velocità: Chainlink aggiorna i dati ogni 1 ora o scatena una fluttuazione dei prezzi dello 0,5%, mentre PYTH effettua aggiornamenti 3 volte al secondo per soddisfare le esigenze di trading ad alta frequenza.</li><li>Struttura dei costi: Chainlink si basa sulle commissioni di abbonamento al servizio dei nodi, PYTH addebita in base al numero di chiamate, il che si allinea maggiormente con il trend ‘paghi-come-vai’ di DeFi 2.0.</li></ul>
<h2 id="h2-PYTH20Previsione20del20prezzo485948"><a name="PYTH Previsione del prezzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>PYTH Previsione del prezzo</h2><p>A breve termine, PYTH si trova di fronte a due importanti catalizzatori:</p>
<ol>
<li>Gestione dello sblocco dei token: Se i 213 milioni di token sbloccati a maggio vengono assorbiti in modo ordinato dalle istituzioni, il prezzo potrebbe salire a $0.50 - $1.20.</li><li>Politica normativa: La SEC affronta ancora rischi nel determinare gli ‘attributi dei titoli’ degli oracoli, ma la politica favorevole alle criptovalute dell’amministrazione Trump potrebbe alleviare la pressione.</li></ol>
<p>Il potenziale a lungo termine dipende dall’espansione dell’ecosistema:</p>
<ul>
<li>Aggiornamento tecnico: il meccanismo di stake dell’Integrità dell’Oracle verrà lanciato nel Q3 2025 per migliorare l’accuratezza dei dati tramite un meccanismo di penalità di stake.</li><li>Cooperazione istituzionale: La profonda integrazione con giganti finanziari tradizionali come Cboe e Jump Crypto potrebbe spingere PYTH nei portafogli di gestione patrimoniale mainstream.</li></ul>
<p>Secondo CoinCodex, a giugno 2025, si prevede che PYTH raggiungerà $0.653 (un aumento del 229.49% rispetto al livello attuale). In uno scenario ottimista, se cattura il 10% della quota di mercato di Chainlink, il suo valore di mercato potrebbe superare i $5 miliardi, corrispondente a un prezzo di $1.38.</p>
<h2 id="h2-Prospettive20future20della20rete20PYTH781137"><a name="Prospettive future della rete PYTH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future della rete PYTH</h2><p>Pyth Network, con la visione di ‘dati finanziari in tempo reale on-chain’, sta ridefinendo lo strato di infrastruttura di DeFi. Nonostante la concorrenza da Chainlink e la pressione dello sblocco dei token, i suoi vantaggi tecnologici e la crescita ecologica lo rendono comunque il progetto di oracolo più promettente da seguire nel 2025. Per gli investitori, è essenziale monitorare attentamente la reazione del mercato all’evento di sblocco di maggio e alla dinamica regolamentare della SEC, catturando i dividendi degli investitori istituzionali <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">onde</a> nelle fluttuazioni.</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. Gli investimenti comportano rischi e gli utenti devono prendere decisioni oculate.<br><div></div>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br><p></p><br></em></div></div></div>