MjAyNSBDcnlwdG8gTmlldXdzIFZvb3JzcGVsbGluZzogU09MIEVURiBHb2Vka2V1cmluZyBXYWFyc2NoaWpubGlqaywgQUkgb20gaGV0IENyeXB0byBMYW5kc2NoYXAgdGUgVmVyc3RvcmVu

2025-06-26, 07:16

<p><img src="https://gimg2.gateimg.com/image/soletf202506261514427274642318.png" alt="">
</p><p>Tegen medio 2025 herstructureert de markt voor crypto-activa het wereldwijde financiële landschap in een verbluffend tempo. Steno Research stelt dat 2025 het beste jaar in de geschiedenis van crypto-activa zal zijn, met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> verwacht wordt dat het $150.000 zal doorbreken en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> uitdagen van de $8.000-grens, de basis leggend voor een epische “altcoin-seizoen.” De voorspellingen van VanEck zijn zelfs nog gedurfder en suggereren dat de huidige bullmarkt in het eerste kwartaal een tussentijdse piek zal bereiken (Bitcoin $180.000 / <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> $6.000), gevolgd door een korte correctie voordat er tegen het einde van het jaar nieuwe recordhoogtes worden bereikt. Deze optimistische verwachting komt voort uit drie kernfactoren: institutionele fondsen die continu binnenstromen via spot ETF’s, regulatoire versoepeling aangedreven door de Trump-administratie, en de diepe doordringing van blockchain-technologie in de traditionele financiën en alledaagse scenario’s.</p>
<h2 id="h2-Beleidsdraaipunt20Nationale20Strategische20Voorzieningen20en20Wereldwijde20Regelgevende20Samenwerking55225"><a name="Beleidsdraaipunt: Nationale Strategische Voorzieningen en Wereldwijde Regelgevende Samenwerking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beleidsdraaipunt: Nationale Strategische Voorzieningen en Wereldwijde Regelgevende Samenwerking</h2><p>De dramatische verandering in de regulatoire omgeving in de VS is de grootste variabele in 2025. Trump benoemde verschillende pro-crypto functionarissen op sleutelposities (Vice-President JD Vance, SEC Voorzitter Paul Atkins, enz.), wat systematisch een einde maakte aan het “de-banking” beleid en de verschuiving naar het positioneren van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> als een nationale strategische activa. Belangrijke ontwikkelingen zijn onder andere:</p>
<ul>
<li>Pilotprogramma’s voor Bitcoin-reserves op staatsniveau: Pennsylvania, Florida of Texas kunnen de eersten zijn die 1% - 10% van de staatsmiddelen toewijzen aan Bitcoin als een financieel afdekkingsinstrument;</li><li>ETF 2.0 Revolutie: De SEC kan goedkeuren. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Spot ETF, Ethereum ETF zal stakingsbeloningen ondersteunen, terwijl Bitcoin ETF fysieke abonnementen en terugbetalingen zal openen, wat de trackingfouten en handelsfrictie aanzienlijk vermindert;</li><li>Wereldwijde regelgevingscompetitie: Het EU MiCA-kader is volledig geïmplementeerd, en Hong Kong en Singapore versnellen de formulering van stablecoin-regelgeving, wat een beleid inhaalslagtrend vormt met de Verenigde Staten.</li></ul>
<h2 id="h2-Stabiele20munt20explosie20Van20handelsmiddel20naar20wereldwijde20betalingsinfrastructuur429165"><a name="Stabiele munt explosie: Van handelsmiddel naar wereldwijde betalingsinfrastructuur" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stabiele munt explosie: Van handelsmiddel naar wereldwijde betalingsinfrastructuur</h2><p>Stabiele munten hebben de beperkingen doorbroken van slechts “encryptie handelsmiddelen” en zijn uitgegroeid tot een killerapplicatie die traditionele grensoverschrijdende betalingen uitdaagt:</p>
<ul>
<li>Schaal sprong: De totale marktwaarde zal naar verwachting met 48% groeien tot $193 miljard in 2024, met een dagelijkse afwikkelingsvolume dat naar verwachting $300 miljard zal bereiken in 2025, wat gelijk staat aan 5% van traditionele clearinginstellingen zoals DTCC;</li><li>Giganten betreden de markt: Stripe heeft het stabiele brugprotocol Bridge overgenomen voor $1,1 miljard, Visa integreert het USDC-afwikkelingsnetwerk, en Apple en Google verkennen stabiele munt betalingsgateways, wat leidt tot een scherpe toename van commerciële adoptie;</li><li>Technologische upgrades: Ethereum L2’s (zoals Base), <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> en andere low-cost ketens zijn het belangrijkste strijdtoneel voor stabiele munten, met on-chain overdracht kosten die bijna nul naderen.</li></ul>
<h2 id="h2-DeFi20en20RWA20Institutioneel20Kapitaal20Opent20een20Markt20van2010020Miljard410087"><a name="DeFi en RWA: Institutioneel Kapitaal Opent een Markt van $100 Miljard" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFi en RWA: Institutioneel Kapitaal Opent een Markt van $100 Miljard</h2><p>Decentralized Finance (DeFi) maakt een sterke comeback nadat de bubbel is verdwenen, vertrouwend op echte rendementen en conforme paden:</p>
<ul>
<li>TVL bereikt nieuwe hoogtes: De totale waarde die is vergrendeld, wordt verwacht meer dan $200 miljard te overschrijden, met het aandeel van DEX-handelsvolume dat stijgt van 8% in 2023 naar 14%, terwijl de dominantie van CEX blijft verzwakken;</li><li>Explosieve groei in RWA: De schaal van getokeniseerde Amerikaanse staatsobligaties, particuliere krediet en andere reële activa is gestegen van $8,4 miljard in 2023 naar $13,5 miljard, met de potentie om $50 miljard te overschrijden tegen 2025. BlackRock en Franklin Templeton bevorderen de tokenisatie van on-chain fondsen, ondersteunen 24⁄7 directe terugbetaling;</li><li>De opkomst van Bitcoin L2: Expansieoplossingen zoals Bitcoin Hyper integreren de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> virtuele machine (SVM), het aantrekken van BTC-staking om door de 100.000 munten heen te breken, het activeren van het DeFi-scenario van het Bitcoin-ecosysteem.</li></ul>
<h2 id="h2-AI20x20Crypto20Intelligente20Economie20en20OnChain20Gegevens20Revolutie445164"><a name="AI x Crypto: Intelligente Economie en On-Chain Gegevens Revolutie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>AI x Crypto: Intelligente Economie en On-Chain Gegevens Revolutie</h2><p>De integratie van kunstmatige intelligentie en blockchain is van concept naar realiteit gegaan, wat heeft geleid tot een nieuw economisch paradigma:</p>
<ul>
<li>AI-agenten worden actieve entiteiten on-chain: Het aantal autonome AI-agenten zal meer dan 1 miljoen bedragen, die taken uitvoeren zoals geautomatiseerde handel en cross-protocol arbitrage, wat nieuwe modellen van Gasverbruik stimuleert;</li><li>De gedecentraliseerde computerkrachtmarkt rijpt: Platforms zoals io.net aggregeren GPU-hulpmiddelen om goedkope modeltrainingsdiensten op Solana te bieden, wat een uitdaging vormt voor de gecentraliseerde cloudservices van AWS;</li><li>AI-gestuurde fondsen komen op: Kwantitatieve strategieën die activa beheren op basis van on-chain gegevens en sentimentanalyse nemen toe, met transparantie en voordelen van realtime portfoliowijzigingen die traditionele kapitaal aantrekken.</li></ul>
<h2 id="h2-Revolutie20in20Gebruikerservaring20Het20Abstractie20van20Technologie20Stimuleert20Mainstream20Acceptatie610743"><a name="Revolutie in Gebruikerservaring: Het Abstractie van Technologie Stimuleert Mainstream Acceptatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Revolutie in Gebruikerservaring: Het Abstractie van Technologie Stimuleert Mainstream Acceptatie</h2><p>Het elimineren van complexiteit is de sleutel tot gebruikersgroei in 2025:</p>
<ul>
<li>Popularisering van Account Abstraction (AA) wallets: Gebruikers kunnen naadloos binnenkomen <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> zonder het beheren van mnemonische zinnen, met sociale inlogmogelijkheden en gasloze betalingservaringen;</li><li>Ketensabstractie cross-chain protocollen: Eén-stop operatie van multi-chain activa (zoals Bitcoin, SOL, Ethereum), waarbij het onderliggende cross-chain proces onzichtbaar is voor gebruikers;</li><li>Upgrade van Telegram handelsbots: Bots zoals Photon hebben een omzet van $210 miljoen opgebouwd, met concurrerende kosten die de ervaring optimaliseren en zich verspreiden naar platforms zoals WhatsApp, LINE, enz.</li></ul>
<h2 id="h2-Conclusie20De20Driehoek20van20Technologie20Kapitaal20en20Regulering21265"><a name="Conclusie: De Driehoek van Technologie, Kapitaal en Regulering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie: De Driehoek van Technologie, Kapitaal en Regulering</h2><p>De cryptocurrency-industrie in 2025 zal een unieke traject van institutionalisering en popularisering presenteren: aan de ene kant zal BlackRock triljoenen aan traditionele activa beheren via RWA-tokenisatie, terwijl aan de andere kant Vietnamese gamers nieuw gelanceerde Meme-munten verhandelen met behulp van Telegram-bots. De verbetering van regelgevingskaders (zoals de intrekking van SAB 121 in de Verenigde Staten) zal obstakels wegnemen voor banken om crypto-activa te bewaren, terwijl de opkomst van AI-agenten de onderwerpen van on-chain economische activiteiten kan hervormen.</p>
<p>De markt bouwt altijd een bodem in angst, stijgt in twijfel en bereikt een piek in enthousiasme. Wanneer de voorpagina van de Wall Street Journal de “AI Token Word Rijk Gids” toont, herinner je dan VanEck’s belangrijkste signaal: de BTC niet-gerealiseerde winstverhouding overschrijdt 70%, of de marktkapitalisatie van altcoins breekt 60%.</p>
<p>Op dit moment in de crypto wereld zijn technologische revoluties, financiële herstructureringen en geopolitieke spelletjes met elkaar verweven om een ongekende historische keerpunt te creëren — in 2025 staan we aan de oever van een nieuw financieel tijdperk.</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 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="6">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>