Q2hlIGNvc1wnw6ggaWwgTmFzZGFxIENyeXB0byBJbmRleCBlIHBlcmNow6kgw6ggaW1wb3J0YW50ZT8=

2025-06-20, 08:42

<p><img src="https://gimg2.gateimg.com/image/nasdq202506201640467162539565.png" alt="">
</p><p>Il 2 giugno 2025, il Nasdaq Crypto Index (NCI) e il suo sottogruppo statunitense (NCIUS) hanno subito una ristrutturazione fondamentale: <a href="/price/stellar-xlm" rel="nofollow noopener noreferrer" target="_blank">Stellare</a> Lumens (XLM) è entrato nel NCI, sostituendo <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> (AVAX), mentre l’indice NCIUS ha incorporato simultaneamente <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> (ADA), <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (SOL), XLM e <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> I quattro principali token hanno superato il framework binario di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> per la prima volta.<br>Questo aggiustamento non è solo un cambiamento nei componenti, ma anche una ricalibrazione del valore strutturale degli asset crittografici del sistema finanziario tradizionale.
</p><h2 id="h2-Riconfigurazione20dellindice20Riflettere20Dinamicamente20lEvoluzione20del20Mercato20delle20Criptovalute539231"><a name="Riconfigurazione dell’indice: Riflettere Dinamicamente l’Evoluzione del Mercato delle Criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riconfigurazione dell’indice: Riflettere Dinamicamente l’Evoluzione del Mercato delle Criptovalute</h2><p>L’Indice Crypto Nasdaq non è un prodotto statico, ma subisce regolari aggiustamenti ai suoi componenti ogni sei mesi per garantire la sua rappresentatività e allineamento con l’influenza del mercato. La riconfigurazione per il primo semestre del 2025 è stata eseguita il 2 giugno, basata su rigorosi standard di liquidità, conformità e capitalizzazione di mercato.</p>
<p>Modifiche nei Componenti dell’Indice NCI: Nuova Aggiunta <a href="/price/stellar-xlm" rel="nofollow noopener noreferrer" target="_blank">Stellare</a> Lumens (XLM) e rimosso <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> (AVAX). L’NCI aggiustato include nove tipi di asset crittografici, coprendo più settori come pagamenti, contratti intelligenti e trading decentralizzato.</p>
<p>Espansione dell’Indice NCIUS: Come indice di riferimento per i prodotti finanziari conformi negli Stati Uniti, il NCIUS in precedenza includeva solo BTC ed ETH. Questa volta, ha aggiunto quattro tipi di asset in un colpo solo: <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> (ADA), <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> (SOL), <a href="/price/stellar-xlm" target="_blank" class="blog_inner_link">Stellar</a> Lumens (XLM), e <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> (XRP).<br>Questo cambiamento abbassa direttamente la soglia per gli investitori statunitensi per accedere a asset crittografici diversificati.
</p><h2 id="h2-Proposta20della20SEC20Aprire20la20Porta20alla20Diversificazione20Istituzionale870505"><a name="Proposta della SEC: Aprire la Porta alla Diversificazione Istituzionale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Proposta della SEC: Aprire la Porta alla Diversificazione Istituzionale</h2><p>Il 2 giugno, il Nasdaq ha presentato una proposta di modifica delle regole (SR-NASDAQ-2025-016) alla SEC, pianificando di includere ufficialmente i quattro tipi di token sopra menzionati nell’indice Nasdaq Crypto Index (NCI) e di consentire prodotti ETF collegati a questi asset.</p>
<p>Il nucleo di questa proposta è affrontare il dilemma dell’”errore di tracciamento” dei prodotti ETF attuali. Prendendo come esempio l’Hashdex Nasdaq Crypto Index US ETF (NCIQ), il suo obiettivo è tracciare l’Indice NCI (che include nove token), ma a causa delle normative statunitensi, può detenere solo BTC ed ETH, portando a una deviazione significativa.</p>
<p>La SEC ha esteso il periodo di revisione fino al 2 novembre 2025. Il mercato si aspetta che, se approvato, NCIQ diventerà il primo ETF su un indice di criptovalute multi-asset negli Stati Uniti, con attivi che coprono BTC, ETH, XRP, SOL, ADA, XLM, LINK, LTC e UNI.</p>
<h2 id="h2-Ingresso20Istituzionale20Abbassare20le20Barriere20e20Aumentare20la20Liquidit658734"><a name="Ingresso Istituzionale: Abbassare le Barriere e Aumentare la Liquidità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ingresso Istituzionale: Abbassare le Barriere e Aumentare la Liquidità</h2><p>L’inclusione degli indici crea un ciclo positivo per i token stessi. L’afflusso previsto di fondi istituzionali dovrebbe migliorare significativamente la liquidità e l’efficienza della scoperta dei prezzi. I dati storici mostrano che dopo che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è stato incluso negli indici e nelle approvazioni degli ETF, la sua volatilità a 30 giorni è diminuita del 18%.</p>
<p>Il caso di <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> è particolarmente tipico: nell’aprile 2025, la sentenza finale del tribunale ha riconosciuto la sua natura di non sicurezza, eliminando i principali ostacoli alla conformità. In oltre sei mesi, il suo prezzo è aumentato del 7%, con una capitalizzazione di mercato che ha raggiunto i 130,93 miliardi di dollari. La sua selezione per l’indice rafforza ulteriormente la sua posizione come valuta di pagamento.</p>
<p>Il capitale tradizionale è stato a lungo pronto a partire. Entro la fine del 2024, gli asset in gestione degli ETF su Bitcoin ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> negli Stati Uniti raggiungeranno i 138 miliardi di dollari, e il nuovo indice aprirà la porta a centinaia di miliardi di fondi incrementali.</p>
<h2 id="h2-Nuovo20Punto20di20Riferimento20del20Mercato20delle20Criptovalute788794"><a name="Nuovo Punto di Riferimento del Mercato delle Criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nuovo Punto di Riferimento del Mercato delle Criptovalute</h2><p>La ricostruzione dell’indice Nasdaq non è solo un aggiustamento dei componenti, ma segna anche l’accelerazione del processo di standardizzazione per la classificazione degli asset crittografici. Dalle piattaforme di trading ai fornitori di indici, fino agli emittenti di ETF, le infrastrutture finanziarie tradizionali hanno penetrato completamente il campo della crittografia.</p>
<p>L’indice NCIUS funge da benchmark di conformità e i suoi token costitutivi devono soddisfare criteri rigorosi: devono essere quotati su piattaforme di trading regolamentate negli Stati Uniti o fungere da attività sottostanti conformi per i derivati. Questa definizione costringerà le piattaforme di trading globali a rafforzare le loro operazioni di conformità.</p>
<p>Con l’avvicinarsi della finestra di approvazione della SEC a novembre, il mercato si sta concentrando sulle tendenze di prodotti come NCIQ. Il volume degli scambi di questo ETF è notevolmente aumentato di recente, con un volume di scambi in un singolo giorno che ha raggiunto 243.500 azioni il 16 giugno, indicando un’intenzione di allocazione anticipata dei fondi.</p>
<p>Gli ingranaggi del mondo della crittografia e di Wall Street stanno accelerando il loro coinvolgimento. Dopo la ristrutturazione dell’indice Nasdaq, Solana si è fermamente affermata tra le prime cinque per capitalizzazione di mercato a un prezzo di $150, mentre il volume di scambi giornaliero di XRP è aumentato del 40%, con gli ordini istituzionali che superano per la prima volta quelli al dettaglio.</p>
<p>Gli asset crittografici non sono più in perlustrazione ai margini della finanza; hanno tracciato le loro coordinate nel sistema indice delle più grandi borse del mondo.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui 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 totale o parziale dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto dell'Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="10">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>