UHJldmlzaW9uZSBkZWwgcHJlenpvIGRlbCB0b2tlbiBKVVAgMjAyNTogRXNwZXJpbWVudGVyw6AgR2lvdmUgdW5hIGdyYW5kZSBlc3Bsb3Npb25lPw==

<h2 id="h2-Sviluppi20recenti20e20progressi20ecologici20di20Giove454458"><a name="Sviluppi recenti e progressi ecologici di Giove" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sviluppi recenti e progressi ecologici di Giove</h2><p>Secondo i dati di mercato di Gate.io, <a href="/trade/JUP_USDT" rel="nofollow noopener noreferrer" target="_blank">JUP</a> Il token attualmente è quotato a $0,71, con una diminuzione del 2,5% nelle ultime 24 ore. La circolazione attuale di JUP è di $1,87 miliardi, posizionandosi al 50º posto nel mercato globale. In precedenza, Jupiter ha annunciato il lancio della rete a catena completa Jupnet, il lancio del nuovo sito web della piattaforma jup.com e l’acquisizione della maggioranza delle azioni di Moonshot. Inoltre, il co-fondatore di Jupiter ha annunciato a gennaio che il 50% del ricavato della piattaforma sarebbe stato utilizzato per il riacquisto di JUP e il 30% dei token JUP sbloccati sarebbe stato bruciato.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1739969026jupiter-jup.jpeg" alt=""></p>
<p>Guardando indietro al 2022, l’evento di chiusura di FTX ha inflitto un duro colpo a <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, causando una significativa perdita di fondi e progetti nel suo ecosistema, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">prezzo SOL</a> Dall’alto storico, è sceso tutto il ​​cammino fino a meno di $10. Tuttavia, nel 2023 <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Forte ripresa, che supera molti asset delle catene pubbliche mainstream, in particolare il progetto DeFi Jupiter, con un volume di scambi a dicembre 2023 superiore di dieci volte rispetto a gennaio, e il lancio del più grande airdrop di token JUP nella storia.</p>
<p>Entro la fine di gennaio 2024, l’airdrop del token JUP è ufficialmente iniziato, attirando un’attenzione di mercato senza precedenti, con il numero di indirizzi attivi su <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> che supera per la prima volta 1 milione. L’alta attenzione a JUP è dovuta alla capacità di Jupiter di sfruttare l’alta velocità e i vantaggi a basso costo di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> e di innovare continuamente il potenziale futuro dei progetti DeFi.</p>
<p>Alla data della stesura di questo testo, il programma di riacquisto dei token JUP è stato lanciato e Jupiter promette di utilizzare il 50% del fee del protocollo per riacquistare JUP e bloccarlo per tre anni; Inoltre, Jupiter ha dichiarato che il piano rimarrà trasparente e ci si aspetta che il cruscotto dei dati correlati vada online la prossima settimana per la supervisione della comunità.</p>
<p>L’ecosistema di Jupiter sta attivamente dispiegando:</p>
<ul>
<li>Ad aprile 2024, acquisire Ultimate Wallet, lanciare Jupiter Mobile, entrare nel mercato mobile e creare un gateway di trading indipendente.</li><li>A settembre 2024, acquisire SolanaFM per potenziare le capacità di analisi dei dati on-chain, fornire un monitoraggio trasparente delle transazioni e semplificare i servizi di visualizzazione on-chain.</li><li>A settembre 2024, acquisì Coinhall, integrando strumenti di analisi dei dati di mercato, potenziato <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Tendenza dei prezzi</a> e capacità di analisi del volume di trading per ottimizzare l’esperienza di trading dell’utente.</li><li>Nel gennaio 2025, l’acquisizione di Sonarwatch ha rafforzato la funzione di tracciamento del portafoglio, supportato il monitoraggio degli asset multi-chain e completato la strategia di rete a catena completa di Jupiter (Jupnet).</li><li>A gennaio 2025, acquisire una quota di maggioranza in Moonshot per rafforzare il controllo sulle fonti di liquidità, consolidare la posizione di mercato delle criptovalute Memetiche e ampliare i canali di deposito della valuta fiat.</li></ul>
<p>Questi layout strategici di Giove indicano che il progetto si sta muovendo verso una direzione di sviluppo ecologico più ampio, e si prevede che continuerà ad attirare molta attenzione e raggiungere una crescita a lungo termine in futuro. La piattaforma di analisi on-chain Nansen mostra che da settembre 2024, il numero di indirizzi delle balene che detengono più di 1 milione di JUP è aumentato del 27%, mentre le riserve di JUP all’interno dello scambio sono diminuite al 11% della circolazione (il livello più basso nella storia). Allo stesso tempo, il tasso di staking di JUP è passato dal 35% al 52%, indicando che la fiducia degli investitori nel valore a lungo termine si è rafforzata.</p>
<h2 id="h2-Previsione20del20prezzo20del20JUP20nel20202520Risonanza20tecnica20e20fondamentale66308"><a name="Previsione del prezzo del JUP nel 2025: Risonanza tecnica e fondamentale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsione del prezzo del JUP nel 2025: Risonanza tecnica e fondamentale</h2><h3 id="h3-Analisi20tecnica20segnale20di20rottura20del20livello20chiave20di20resistenza569119"><a name="Analisi tecnica: segnale di rottura del livello chiave di resistenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi tecnica: segnale di rottura del livello chiave di resistenza</h3><p>Dal punto di vista del grafico settimanale, JUP si trova attualmente sul lato destro di una formazione a doppio minimo, consolidandosi nell’intervallo $0.45-0.48 con un forte supporto. L’indicatore MACD mostra una divergenza rialzista sotto l’asse zero, mentre l’RSI è salito a 45, indicando l’esaurimento della dinamica ribassista. Se il prezzo supera $1.13 (livello di ritracciamento Fibonacci al 61,8%), potrebbe avviare un nuovo trend al rialzo con target a $1.8 (massimo storico del 2024).</p>
<h3 id="h3-Fattori20guida20fondamentali992202"><a name="Fattori guida fondamentali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fattori guida fondamentali</h3><ul>
<li>L’ecosistema di Solana è in piena espansione: il client Firedancer di Solana sarà completamente lanciato nel 2025, con un aumento previsto del throughput della rete a 1 milione di transazioni al secondo e una riduzione del 90% delle commissioni Gas. Come ingresso del traffico nell’ecosistema Solana, anche il volume delle transazioni e la base di utenti di Jupiter esploderanno in modo sincrono.</li><li>Rivalutazione del valore narrativo cross-chain: se Jupiter integra con successo la liquidità multi-chain, la sua logica di valutazione passerà da un singolo aggregatore di ecosistemi a un’infrastruttura di trading full-chain. Con riferimento al livello di valutazione <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a>(valore di mercato della versione cross-chain di 4 miliardi di USD), si prevede che il tetto del valore di mercato di JUP superi i 5 miliardi di USD (valore di mercato attuale 1,87 miliardi).</li><li>Rafforzamento del modello deflazionistico: entro il 2025, il tasso di inflazione di JUP scenderà al 3,8%, combinato con il meccanismo di blocco dello staking, la circolazione effettiva potrebbe diminuire di oltre il 40%, formando uno squilibrio tra domanda e offerta per guidare l’aumento dei prezzi.</li></ul>
<h3 id="h3-Modello20di20previsione20dei20prezzi466800"><a name="Modello di previsione dei prezzi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Modello di previsione dei prezzi</h3><ul>
<li>Scenario conservativo: Supponendo che il Valore Totale Bloccato (TVL) dell’ecosistema Solana raggiunga i 120 miliardi di dollari nel 2025 (attualmente intorno agli 82 miliardi di dollari) e che Jupiter mantenga il 70% della quota di mercato degli aggregator DEX, la capitalizzazione di mercato di JUP potrebbe raggiungere i 3,5 miliardi di dollari, corrispondenti a un prezzo di JUP di 1,4 dollari.</li><li>Scenario ottimista: Se il progresso cross-chain supera le aspettative e il tasso di staking JUP supera il 70%, ci si aspetta che il valore di mercato sfidi gli 8 miliardi di dollari statunitensi (rispetto a <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> Valutazione del 50% di JUP, il prezzo corrispondente è di 2,8-3 dollari USA.</li><li>Scenario di mercato toro estremo: Nel contesto di Solana che guida le transazioni multi-chain e JUP diventando il Token di governance DeFi principale, il prezzo potrebbe toccare brevemente i $5 (simile al 2021 <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">SUSHI</a> picco della speculazione).</li></ul>
<h2 id="h2-Rischi20e20Sfide20Variabili20Ingnorabili909330"><a name="Rischi e Sfide: Variabili Ingnorabili" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rischi e Sfide: Variabili Ingnorabili</h2><h3 id="h3-Cerchiato20dai20concorrenti179385"><a name="Cerchiato dai concorrenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cerchiato dai concorrenti</h3><ul>
<li><a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> Il meccanismo Hook di V4 consente agli sviluppatori di personalizzare la logica del pool di liquidità, potenzialmente deviando la domanda di trading di asset a coda lunga di Giove.</li><li><a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a> La modalità Fusione ora supporta le transazioni della catena Solana, rappresentando una minaccia per Giove con la sua base utenti multi-chain.</li></ul>
<h3 id="h3-Incertezza20normativa54901"><a name="Incertezza normativa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Incertezza normativa</h3><ul>
<li>La SEC degli Stati Uniti ha recentemente intensificato il suo controllo sul DEX. Se JUP è considerato un titolo non registrato, può innescare un’ondata di vendita a breve termine;</li><li>Le normative dell’UE richiedono che i DEX implementino la verifica KYC, oppure aumentino i costi di conformità di Jupiter.</li></ul>
<h3 id="h3-Rischio20Tecnico353323"><a name="Rischio Tecnico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rischio Tecnico</h3><ul>
<li>La stabilità della rete Solana rimane una variabile chiave. Se si verificasse un’interruzione su larga scala o una vulnerabilità della sicurezza, ciò influirebbe direttamente sul prezzo di JUP.</li></ul>
<h2 id="h2-Prospettive20future20Tempistica20del20layout20JUP20e20suggerimenti20strategici473560"><a name="Prospettive future: Tempistica del layout JUP e suggerimenti strategici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future: Tempistica del layout JUP e suggerimenti strategici</h2><p>Giove ha dimostrato il potenziale di diventare il “DeFi blue chip” dell’ecosistema Solana con le sue iterazioni tecnologiche, il posizionamento ecologico e il modello economico del token ottimizzato. Al prezzo attuale (circa $0.71), JUP è ancora sottovalutato, specialmente considerando che il suo racconto cross-chain non è stato pienamente riflesso nel prezzo di mercato.</p>
<p>Raccomandazione strategica per gli investitori:</p>
<ul>
<li>Layout a lungo termine: Acquista a lotti nell’intervallo di $0.45-0.6 e mantieni fino alla fine del 2025;</li><li>Event-driven: focus sull’andamento del buyback e del burning di JUP;</li><li>Copertura del rischio: Allocare non più del 15% del portafoglio cripto e impostare $0.38 come linea di stop loss.</li></ul>
<p>Se il team di Jupiter riesce a continuare a rispettare la tabella di marcia, l’esplosione del token JUP nel 2025 non sarà solo un balzo nei numeri dei prezzi, ma anche una ridefinizione della logica del valore della traccia dell’aggregatore DeFi.</p>
<div class="blog-details-info"><br>  <div>作者：<strong>Glassa</strong>,Gate.io 研究员  <div class="info-tips"><em>本文仅代表作者观点，不构成任何交易建议。 投资有风险，用户需谨慎决策。  </em><div><em></em>Questo contenuto è originale, tutti i diritti sono di Gate.io. Per ripubblicare, si prega di citare l'autore e la fonte; in caso contrario, verranno perseguite responsabilità legali.<br></div><p></p><br></div></div></div>