SG9lIHByZXN0ZWVydCBkZSBVU0RDLWFhbmRlZWw/IFN0YWJsZWNvaW4tcmV1cyBDUkNMIG92ZXJzY2hyaWpkdCAkMzAgbWlsamFyZCBhYW4gbWFya3RrYXBpdGFsaXNhdGll

2025-06-18, 09:58

<p><img src="https://gimg2.gateimg.com/image/circle202506181757229910904632.png" alt="">
</p><p>Op 5 juni 2025 vond er een historische doorbraak plaats op de New York Stock Exchange in de cryptocurrency-industrie. Circle, de uitgever van de op één na grootste stablecoin ter wereld, USDC (aandelencode: CRCL), debuteerde op de NYSE tegen een prijs van $31, die bij de opening omhoog schoot naar $69, een stijging van 122%. Tijdens de handelsessie overschreed de aandelenprijs tijdelijk de $100, om uiteindelijk te sluiten op $83,23, met een dagelijkse stijging van 168%.</p>
<p>De markenthousiasme stopte daar niet. De volgende dag steeg de CRCL-aandelenprijs opnieuw met 29,4%, met een cumulatieve stijging van meer dan 200% in twee dagen, en een handelsvolume van 6,46 miljard USD. Op 18 juni was de aandelenprijs gestegen tot 151 USD, bijna vijf keer de emissieprijs, en de marktkapitalisatie steeg naar 33,6 miljard USD.</p>
<h2 id="h2-Marktcarnaval20De20Drie20Motoren20Achter20Aandelenprijs20Curves100404"><a name="Marktcarnaval: De Drie Motoren Achter Aandelenprijs Curves" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktcarnaval: De Drie Motoren Achter Aandelenprijs Curves</h2><p>De beleidsmatige impuls stimuleert de markenthousiasme. De Amerikaanse Senaat heeft op 21 mei de GENIUS Act aangenomen, waarmee het eerste nationale regelgevingskader voor USD-stablecoins is vastgesteld, met de verwachting dat de wetgeving in augustus zal worden afgerond. Dit beleid drijft rechtstreeks geldstromen naar de stablecoinsector.</p>
<p>De kernbepalingen van het wetsvoorstel vereisen dat alle USD-stablecoins 100% gedekt zijn door USD of equivalente liquide activa. De compliancevoordelen van Circle worden onmiddellijk vergroot, waarbij investeerders verwachten dat het de stablecoin-markt zal domineren in het tijdperk van regelgeving.</p>
<p>Het businessmodel toont een sterke capaciteit om fondsen aan te trekken. De inkomstenmotor van Circle is sterk gefocust: in het eerste kwartaal van 2025 bereikte de omzet $578,6 miljoen, een jaar-op-jaar stijging van 58,5%. Van dit bedrag komt 99% van de omzet uit de rente-inkomsten van de USDC-reserveactiva.</p>
<p>In eenvoudige termen gebruikt Circle de door gebruikers gestorte Amerikaanse dollars om Amerikaanse staatsobligaties te kopen, waarmee het de renteverschillen verdient. In de huidige omgeving van hoge rentetarieven is dit een efficiënte “geldmachine” geworden.</p>
<p>Schaarste premie drijft waarderingen omhoog. Als ‘s werelds eerste beursgenoteerde pure stablecoinbedrijf staat CRCL in schril contrast met traditionele cryptocurrency-exchanges (zoals Coinbase) en mijnbedrijven. Het winstmodel is stabieler en de cash <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flow</a> is voorspelbaarder, wat natuurlijk leidt tot een hogere waarderingspremie.</p>
<p>De huidige marktkapitalisatie van 33,6 miljard USD is al meer dan de helft van de beheerde reserve van 61,5 miljard USDC.</p>
<h2 id="h2-Compliance20Moat20De20Vooruitgangen20en20Zorgen20van20USDC682635"><a name="Compliance Moat: De Vooruitgangen en Zorgen van USDC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Compliance Moat: De Vooruitgangen en Zorgen van USDC</h2><p>De strijd om marktaandeel onder regelgevende arbitrage. Momenteel heeft de wereldwijde markt voor stablecoins een omvang bereikt van 251,1 miljard USD, met USDC dat ongeveer 25% van het marktaandeel in handen heeft, na Tether’s USDT (60%). Echter, naleving wordt de sleutel tot het doorbreken van de impasse.</p>
<p>Na de implementatie van de EU MiCA-regelgeving staat USDT voor compliance-uitdagingen vanwege problemen met reserve-transparantie, terwijl USDC institutionele voorkeur heeft gewonnen dankzij zijn volledig contante en kortlopende transparante reserves in Amerikaanse staatsobligaties, beheerd door BlackRock.</p>
<p>De groeicurve van het handelsvolume is steiler geworden. In april 2025 bereikte het maandelijkse handelsvolume van USDC op gecentraliseerde beurzen $21,9 miljard, meer dan verdubbeld ten opzichte van $10,65 miljard in januari 2024. Op Binance steeg het marktaandeel van USDC van 10% aan het einde van vorig jaar naar bijna 20%.</p>
<p>Kostendrukken bestaan naast competitieve schaduwen. De distributieovereenkomst tussen Circle en Coinbase vereist dat ze 50% van het reserve-inkomensdeel betalen, wat resulteert in een stijging van 68,2% in handels- en distributiekosten in het eerste kwartaal van 2025.</p>
<p>De toetreding van traditionele financiële instellingen zoals PayPal’s PYUSD en Fidelity in de stablecoin-ruimte drukt op de compliance-dividend van USDC.</p>
<h2 id="h2-Het20kritieke20punt20nadert20en20het20iPhonemoment20herstructureert20de20financile20infrastructuur185468"><a name="Het kritieke punt nadert, en het “iPhone-moment” herstructureert de financiële infrastructuur." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het kritieke punt nadert, en het “iPhone-moment” herstructureert de financiële infrastructuur.</h2><p>De aftelling naar wetgeving is begonnen, wat de industrie herschikt. De Amerikaanse Senaat zal op 17 juni een finale stemming houden over de GENIUS Act. De auditdrempel van $50 miljard in het wetsvoorstel (de huidige USDC-grootte van Circle is $61,6 miljard) kan de nalevingskosten verhogen, maar zal ook kleinere spelers uitschakelen, waardoor het leiderschapseffect wordt versterkt.</p>
<p>Programmeerbaar geld opent de deur naar een sprongetje in waarde. De metafoor “iPhone-moment” die werd voorgesteld door Circle CEO Jeremy Allaire wijst op de kwalitatieve verandering van stablecoins van handelsinstrumenten naar financiële infrastructuur.</p>
<p>Wanneer stablecoins worden gecombineerd met slimme contracten, ontgrendelt dit innovatieve scenario’s zoals geautomatiseerde betalingen en voorwaardelijk geactiveerde overmakingen. Tegen 2024 is de activa-schaal die is vergrendeld in DeFi-protocollen op basis van stablecoins gestegen tot $240 miljard, met een <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">verbeteren</a> jaarlijkse groei van meer dan 150%.</p>
<p>Het wereldwijde betalingssysteem is in reconstructie. Traditionele financiële reuzen hebben stilletjes hun plannen uitgelegd: Visa en PayPal gebruiken USDC voor internationale overmakingen; JPMorgan Private Bank heeft het opgenomen in zijn lijst van in aanmerking komende onderpanden; het cryptocurrencyfonds van BlackRock heeft zijn aandelen in Circle in het eerste kwartaal met 12% verhoogd. Deze positieve cyclus van “regelgeving naleving - institutionele toetreding - marktcapitalisatie-uitbreiding” versnelt.</p>
<p>De GENIUS-wet gaat de aftelling in voor een Senaatsstem. Als de wet wordt aangenomen, zullen stablecoin-uitgevende instellingen met meer dan $50 miljard verplicht jaarlijkse audits ondergaan, wat de toetredingsbarrières voor de sector aanzienlijk verhoogt.</p>
<p>Analisten van Goldman Sachs wijzen in een recent rapport op: “De waarderingspremie van Circle weerspiegelt de prijsstelling van de markt voor de toekomst van programmeerbare valuta, maar een dynamische koers-winstverhouding van 400 vereist het handhaven van een samengestelde groei van meer dan 60% in de komende drie jaar om verteerbaar te zijn.”</p>
<p>Op het elektronische scherm in de handelszaal van de New York Stock Exchange fluctueert de prijscurve van CRCL nog steeds dramatisch. Deze curve draagt niet alleen het lot van Circle, maar weerspiegelt ook de eeuwlange veranderingen in de digitale economie en het financiële systeem.</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="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>