QW5hbGlzaSBkZWwgcHJlenpvIEFCOiB0ZW5kZW56ZSBhdHR1YWxpIGUgcHJvc3BldHRpdmUgY29tcGxldGUgcGVyIGlsIDIwMjU=

<p><img src="https://gimg2.gateimg.com/image/ab202506271715480183121455.png" alt="">
</p><p>A partire dal 26 giugno 2025, il prezzo in tempo reale di AB è di 0,0088 USDT, in calo del 13,22% nelle ultime 24 ore. La capitalizzazione di mercato circolante attuale di AB raggiunge i 585 milioni di dollari, classificandosi al 100° posto tra le criptovalute globali, dimostrando una resilienza unica in un mercato volatile.</p>
<h2 id="h2-Stato20di20Mercato20AB812416"><a name="Stato di Mercato AB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stato di Mercato AB</h2><p>L’attuale offerta circolante di AB è di 65 miliardi di monete, con un’offerta totale bloccata a 100 miliardi di monete, delle quali 1,17 miliardi di monete sono state distrutte.</p>
<ul>
<li>Traiettoria delle fluttuazioni di prezzo: Nell’ultima settimana, AB ha sperimentato una notevole volatilità, raggiungendo 0,016 USDT il 19 giugno e tornando a 0,00846 USDT il 27 giugno, con un calo del 33,2% in 7 giorni.</li><li>Attività di trading: Il volume di trading nelle ultime 24 ore è di 119 milioni di dollari, principalmente circolante su 56 exchange tra cui Gate.</li><li>Riferimento al picco storico: Il 21 marzo 2025, AB ha raggiunto un massimo storico di 0,01729 USDT e il prezzo attuale è diminuito del 41,8% rispetto all’ATH.</li></ul>
<p>L’analisi tecnica mostra che AB si trova a un livello di supporto critico e in una fase di contestazione, con il minimo delle ultime 24 ore di 0,0099 USDT che diventa il punto focale per i tori e gli orsi.</p>
<h2 id="h2-Progetto20Core20Larchitettura20tecnologica20e20la20trasformazione20del20modello20economico20di20AB282033"><a name="Progetto Core: L’architettura tecnologica e la trasformazione del modello economico di AB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Progetto Core: L’architettura tecnologica e la trasformazione del modello economico di AB</h2><p>AB non è un token ordinario; è originato dal Newton Project lanciato nel 2018 e ha completato il suo aggiornamento del marchio nel 2025, posizionandosi come un’infrastruttura blockchain eterogenea, con un focus centrale su tre importanti innovazioni:</p>
<ul>
<li>Attività del mondo reale su blockchain (RWA): Portare attività finanziarie tradizionali sulla blockchain attraverso meccanismi di registrazione e liquidazione decentralizzati, migliorando la liquidità e riducendo i costi di fiducia.</li><li>Architettura main chain + side chain: compatibile con ecosistemi multi-chain come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e Solana, consentendo trasferimenti di asset cross-chain senza soluzione di continuità e supportando lo sviluppo di DApp complessi.</li><li>Riconfigurazione dell’Economia dei Token: Ottimizzazione del meccanismo di rilascio basato sulla proposta NEP-63, a partire da febbraio 2025, 5,66 miliardi di AB saranno rilasciati linearmente per 12 mesi, con un focus sull’incentivare i nodi di calcolo a mantenere la sicurezza della rete.</li></ul>
<p>Diversificazione dell’utilità del token:</p>
<ul>
<li>Pagamento delle commissioni di transazione (inclusa l’esecuzione di contratti intelligenti e le transazioni cross-chain)</li><li>Diritti di voto di governance (meccanismo decisionale DAO)</li><li>Ricompense per staking (attualmente oltre 3 miliardi di AB partecipano allo staking)</li><li>Bruciatura dinamica (un totale di 1,176 miliardi di AB bruciati per contenere l’inflazione)</li></ul>
<h2 id="h2-Previsione20dei20Prezzi20Prospettive20per20il2020252020203520da20Piattaforme20Autorevoli405285"><a name="Previsione dei Prezzi: Prospettive per il 2025 - 2035 da Piattaforme Autorevoli" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Previsione dei Prezzi: Prospettive per il 2025 - 2035 da Piattaforme Autorevoli</h2><p>Numerose istituzioni hanno rilasciato AB basato su dati storici ed estrapolazione di modelli. <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Previsione dei prezzi</a> :</p>
<ul>
<li>Intervallo previsto per il 2025: Gate prevede un prezzo medio annuale di 0,009971 USDT, con un intervallo di fluttuazione di 0,007478 - 0,01096 USDT. I modelli di big data mostrano che potrebbe raggiungere 0,01031 USDT entro la fine dell’anno, rappresentando un potenziale aumento del 13,4% rispetto al livello attuale.</li><li>Curva di crescita a medio termine: Prezzo medio atteso di 0,01046 USDT nel 2026 (+4% YOY), potenzialmente in aumento a 0,01109 USDT nel 2027 guidato dall’ecosistema RWA (+11%). Il modello di big data è ottimista a 0,01776 USDT entro il 2031, con un tasso di rendimento cumulativo del 75,53%.</li><li>Prospettiva di valore a lungo termine: Gate prevede che entro il 2035, il limite superiore raggiungerà 0,02622 USDT, un aumento del 107% rispetto al prezzo attuale. Se RWA viene implementato su larga scala, potrebbe superare questo intervallo.</li></ul>
<table>
<thead>
<tr>
<th>Anno</th>
<th>Prezzo medio annuo (USDT)</th>
<th>Intervallo Potenziale (USDT)</th>
<th>Aumento attuale del prezzo</th>
</tr>
</thead>
<tbody>
<tr>
<td>2025</td>
<td>0,009971</td>
<td>0.007478 - 0.01096</td>
<td>-0,1%</td>
</tr>
<tr>
<td>2026</td>
<td>0.01046</td>
<td>0.007538 - 0.01172</td>
<td>+4,9%</td>
</tr>
<tr>
<td>2028</td>
<td>0,01226</td>
<td>0,01164 - 0,01361</td>
<td>+22,9%</td>
</tr>
<tr>
<td>2031</td>
<td>0.01418</td>
<td>0.008085 - 0.01716</td>
<td>+42,2%</td>
</tr>
<tr>
<td>2035</td>
<td>0.02065</td>
<td>0.01301 - 0.02622</td>
<td>+107,0%</td>
</tr>
</tbody>
</table>
<p><em>Analisi completa di AB <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Previsione dei Prezzi</a> (Fonte Dati: Gate)</em></p>
<h2 id="h2-Catalizzatori20di20Mercato20Tre20Grandi20Venti20A20Favore20per20lIndustria20Cripto20nel202025365123"><a name="Catalizzatori di Mercato: Tre Grandi Venti A Favore per l’Industria Cripto nel 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Catalizzatori di Mercato: Tre Grandi Venti A Favore per l’Industria Cripto nel 2025</h2><p>Le aspettative di crescita di AB sono profondamente legate alle tendenze macroeconomiche:</p>
<ul>
<li>Crescita Esplosiva degli RWA: Pantera prevede che gli RWA on-chain rappresenteranno il 30% del TVL entro il 2025 (attualmente 15%), con l’accelerazione dei titoli di stato statunitensi e delle materie prime on-chain, altamente allineata con la strategia centrale di AB.</li><li>Rottura normativa: il presidente della SEC statunitense Gensler si dimette, Trump nomina funzionari favorevoli alle criptovalute, 278 membri favorevoli alle criptovalute eletti alla Camera e l’ambiente politico si sposta verso una posizione positiva.</li><li>È iniziato il mercato rialzista delle criptovalute: Steno Research prevede che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> raggiungerà $150.000 nel 2025, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> supererà $8.000 e l’afflusso stagionale di fondi negli altcoin avvantaggerà token a media capitalizzazione come AB.</li></ul>
<p>Gli asset del mondo reale on-chain (RWA) stanno attraversando una transizione da 13,7 miliardi di dollari a una scala di centinaia di miliardi, e l’architettura eterogenea di AB è precisamente il veicolo che supporta questa onda.</p>
<h2 id="h2-Avviso20di20rischio20una20variabile20indispensabile20nelle20decisioni20di20investimento343254"><a name="Avviso di rischio: una variabile indispensabile nelle decisioni di investimento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Avviso di rischio: una variabile indispensabile nelle decisioni di investimento</h2><p>Nonostante le prospettive ottimistiche, tre rischi principali richiedono ancora vigilanza:</p>
<ul>
<li>Pressione dovuta al rilascio di token: L’importo annuale di rilascio di 5,66 miliardi di AB (che rappresenta l’8,7% della circolazione) potrebbe creare una pressione di vendita, ed è necessario osservare se le applicazioni ecologiche possono assorbire l’aumento.</li><li>Sfide nell’implementazione RWA: C’è incertezza riguardo all’accettazione degli asset on-chain da parte delle istituzioni tradizionali, e il progresso della cooperazione influenzerà direttamente la logica di valutazione.</li><li>Intensificazione della concorrenza di mercato: I progetti RWA come MANTRA ($OM) e Plume ($PLUME) stanno dividendo la quota di mercato, e AB deve continuare a dimostrare la sua differenziazione tecnologica.</li></ul>
<p>Gli investitori dovrebbero prestare attenzione agli indicatori chiave:</p>
<ul>
<li>Tasso di crescita mensile degli asset RWA on-chain</li><li>Frequenza degli annunci da parte dei partner istituzionali</li><li>Variazioni nel volume di burn dei token e nel tasso di staking</li></ul>
<p>L’analista crypto Paul Veradittakit ha sottolineato: “Nel 2025, RWA non sarà più limitato ai titoli di Stato e ai crediti; la fase di prodotti finanziari complessi on-chain come azioni ed ETF sta per iniziare.” Questo coincide strategicamente con l’obiettivo di AB di un’architettura blockchain eterogenea.</p>
<p>La traiettoria di AB nel 2025 dipenderà dall’equilibrio tra i progressi nell’implementazione tecnologica e il ritmo di rilascio dei token. Gli investitori conservatori possono concentrarsi sul livello di supporto di 0,0075 USDT per un layout graduale, mentre le strategie aggressive devono monitorare da vicino i dati di esecuzione della proposta NEP-63 e i progressi nell’ecosistema 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 proibire 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>