V2F0IGlzIGRlIE5hc2RhcSBDcnlwdG8gSW5kZXggZW4gd2Fhcm9tIGlzIGhldCBiZWxhbmdyaWprPw==

2025-06-20, 08:42

<p><img src="https://gimg2.gateimg.com/image/nasdq202506201640467162539565.png" alt="">
</p><p>Op 2 juni 2025 onderging de Nasdaq Crypto Index (NCI) en zijn Amerikaanse sub-index (NCIUS) een belangrijke herstructurering: <a href="/price/stellar-xlm" rel="nofollow noopener noreferrer" target="_blank">Stellar</a> Lumens (XLM) is binnengekomen in de NCI, ter vervanging van <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> (AVAX), terwijl de NCIUS-index tegelijkertijd opnam <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 en <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> De vier belangrijkste tokens hebben door het binaire kader gebroken van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> voor de eerste keer.<br>Deze aanpassing is niet alleen een verandering in componenten, maar ook een herkalibratie van de structurele waarde van encryptieactiva in het traditionele financiële systeem.
</p><h2 id="h2-Indexherconfiguratie20Dynamisch20de20Evolutie20van20de20Encryptiemarkt20Weerspiegelen360914"><a name="Indexherconfiguratie: Dynamisch de Evolutie van de Encryptiemarkt Weerspiegelen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Indexherconfiguratie: Dynamisch de Evolutie van de Encryptiemarkt Weerspiegelen</h2><p>De Nasdaq Crypto Index is geen statisch product, maar ondergaat regelmatig aanpassingen aan zijn componenten elke zes maanden om zijn representativiteit en afstemming op de invloed van de markt te waarborgen. De herconfiguratie voor de eerste helft van 2025 werd uitgevoerd op 2 juni, op basis van strikte normen voor liquiditeit, naleving en marktkapitalisatie.</p>
<p>Wijzigingen in NCI-indexcomponenten: Nieuwe toevoeging <a href="/price/stellar-xlm" rel="nofollow noopener noreferrer" target="_blank">Stellar</a> Lumens (XLM) en heeft <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> (AVAX) verwijderd. De aangepaste NCI omvat negen soorten encryptie-activa, die meerdere tracks dekken zoals betalingen, slimme contracten en gedecentraliseerde handel.</p>
<p>NCIUS Index Uitbreiding: Als de benchmarkindex voor conforme financiële producten in de Verenigde Staten, omvatte NCIUS voorheen alleen BTC en ETH. Deze keer zijn er in één keer vier soorten activa toegevoegd: <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), en <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> (XRP).<br>Deze wijziging verlaagt rechtstreeks de drempel voor Amerikaanse investeerders om toegang te krijgen tot gediversifieerde encryptie-activa.
</p><h2 id="h2-SEC20Voorstel20De20Deur20Openzetten20voor20Institutionele20Diversificatie949976"><a name="SEC Voorstel: De Deur Openzetten voor Institutionele Diversificatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC Voorstel: De Deur Openzetten voor Institutionele Diversificatie</h2><p>Op 2 juni diende Nasdaq een voorstel voor een wijziging van de regel (SR-NASDAQ-2025-016) in bij de SEC, met de bedoeling de hierboven genoemde vier soorten tokens officieel op te nemen in de bredere Nasdaq Crypto Index (NCI) en ETF-producten die aan deze activa zijn gekoppeld toe te staan.</p>
<p>De kern van dit voorstel is om het probleem van de “tracking error” van huidige ETF-producten aan te pakken. Neem de Hashdex Nasdaq Crypto Index US ETF (NCIQ) als voorbeeld; het doel is om de NCI-index (die negen tokens omvat) te volgen, maar door de Amerikaanse regelgeving kan het alleen BTC en ETH aanhouden, wat leidt tot een aanzienlijke afwijking.</p>
<p>De SEC heeft de beoordelingsperiode verlengd tot 2 november 2025. De markt verwacht dat, indien goedgekeurd, NCIQ de eerste multi-asset encryptie index ETF in de Verenigde Staten zal worden, met activa die BTC, ETH, XRP, SOL, ADA, XLM, LINK, LTC en UNI dekken.</p>
<h2 id="h2-Institutionele20Toegang20Drempels20Verlagen20en20Liquiditeit20Verhogen578496"><a name="Institutionele Toegang: Drempels Verlagen en Liquiditeit Verhogen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Institutionele Toegang: Drempels Verlagen en Liquiditeit Verhogen</h2><p>De opname van indices creëert een positieve cyclus voor de tokens zelf. De verwachte instroom van institutionele fondsen zal naar verwachting de liquiditeit en de efficiëntie van prijsontdekking aanzienlijk verbeteren. Historische gegevens tonen aan dat na de opname van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in indices en goedkeuringen van ETF’s, de 30-daagse volatiliteit met 18% afnam.</p>
<p>De zaak van <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> is bijzonder typisch: in april 2025 erkende de uiteindelijke uitspraak van de rechtbank de niet-beveiligingsstatus ervan, waardoor belangrijke nalevingsobstakels werden geëlimineerd. Gedurende zes maanden steeg de prijs met 7%, met een marktkapitalisatie van $130,93 miljard. De selectie voor de index versterkt verder zijn positie als betaalvaluta.</p>
<p>Traditioneel kapitaal is al lange tijd klaar om te gaan. Tegen het einde van 2024 zullen de beheerde activa van Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s in de Verenigde Staten $138 miljard bereiken, en de nieuwe index zal de deur openen naar honderden miljarden aan extra middelen.</p>
<h2 id="h2-Nieuwe20Waterscheiding20van20de20Encryptiemarkt37446"><a name="Nieuwe Waterscheiding van de Encryptiemarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nieuwe Waterscheiding van de Encryptiemarkt</h2><p>De reconstructie van de Nasdaq-index is niet alleen een aanpassing van de componenten, maar markeert ook de versnelling van het standaardisatieproces voor de classificatie van encryptie-activa. Van handelsplatforms tot indexaanbieders, en vervolgens naar ETF-uitgevers, heeft de traditionele financiële infrastructuur zich volledig door het encryptieveld heen geworteld.</p>
<p>De NCIUS-index dient als een nalevingsbenchmark, en de samenstellende tokens moeten aan strikte criteria voldoen: ze moeten genoteerd zijn op gereguleerde handelsplatforms in de Verenigde Staten of fungeren als conforme onderliggende activa voor derivaten. Deze definitie zal wereldwijde handelsplatforms dwingen hun nalevingsoperaties te versterken.</p>
<p>Naarmate de goedkeuringsperiode van de SEC in november nadert, richt de markt zich op de trends van producten zoals NCIQ. Het handelsvolume van deze ETF is de laatste tijd aanzienlijk gestegen, met een handelsvolume op één dag van 243.500 aandelen op 16 juni, wat wijst op een intentie voor vroege fondsallocatie.</p>
<p>De tandwielen van de encryptiewereld en Wall Street versnellen hun samenwerking. Na de herstructurering van de Nasdaq-index heeft Solana zich stevig gevestigd in de top vijf op basis van marktkapitalisatie met een prijs van $150, terwijl het dagelijkse handelsvolume van XRP met 40% is toegenomen, met institutionele orders die voor het eerst de particuliere orders overtreffen.</p>
<p>Encryptieactiva dwalen niet langer aan de rand van de financiën; ze hebben hun coördinaten in het indexsysteem van de grootste beurzen ter wereld gegraveerd.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U dient altijd onafhankelijk professioneel advies in te winnen voordat u enige investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <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>