V2F0IHppam4gY3J5cHRvIHN0YWJsZWNvaW5zPyBEZSBrZXJub2JqZWN0aWV2ZW4gYWNodGVyIGRlIEFtZXJpa2FhbnNlIHN0YWJsZWNvaW4gd2V0

2025-06-05, 07:38

<p><img src="https://gimg2.gateimg.com/image/usdc202506051536511109105063.png" alt="">
</p><p>Op 29 mei 2025, om de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Conferentie in Las Vegas, VS, Vice-President Vance kondigde aan aan 50 miljoen Amerikaanse Bitcoin-houders: “Stablecoins gekoppeld aan de dollar, vooral na de goedkeuring van de GENIUS Act, zullen alleen de Amerikaanse economie en de dollar ten goede komen.”</p>
<p>Op dit moment bevordert het Amerikaanse Congres energiek twee baanbrekende regelgevingwetten voor stablecoins: de “STABLE Act” van het Huis en de “GENIUS Act” van de Senaat. Het belangrijkste doel van deze twee wetten is het opzetten van een federale regelgevingsstructuur voor de dollar stablecoins, die in marktwaarde zijn gestegen tot bijna $250 miljard.</p>
<h2 id="h2-Wat20is20een20stablecoin653497"><a name="Wat is een stablecoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een stablecoin?</h2><p>Een stablecoin is een speciaal type cryptocurrency waarvan het belangrijkste ontwerppunt is om een stabiele waarde te behouden. In tegenstelling tot volatiele crypto-activa zoals Bitcoin, worden stablecoins doorgaans gekoppeld aan de waarde van fiat-valuta’s zoals de Amerikaanse dollar of fysieke activa zoals goud, waarbij een 1:1 wisselkoers wordt gehandhaafd via specifieke mechanismen.</p>
<p>Volgens het onderpandmechanisme worden stablecoins voornamelijk onderverdeeld in drie categorieën:</p>
<ul>
<li>Fiat stablecoins: zoals USDT, USDC, worden 1:1 gedekt door contanten of equivalente middelen in Amerikaanse dollars van bankrekeningen.</li><li>Product stablecoin: zoals <a href="/price/pax-gold-paxg" rel="nofollow noopener noreferrer" target="_blank">PAX Gold</a>(PAXG), elke token vertegenwoordigt eigendom van één ounce fysiek goud.</li><li>Cryptocurrency-backed stablecoins: zoals DAI van MakerDAO, gegenereerd door overcollateralizatie van cryptocurrencies zoals Ethereum.</li></ul>
<p>De werking van stablecoins is afhankelijk van drie belangrijke verankeringsmechanismen: gedekte schuldenposities (gebruikers vergrendelen onderpand om stablecoins te genereren), arbitragemechanismen (marktdeelnemers kopen en verkopen prijsverschillen om de koppeling te handhaven), en elastische aanbod (algoritmen passen de totale hoeveelheid tokens aan om de prijs te beïnvloeden).</p>
<p>Vanwege hun stabiliteit zijn stablecoins de hoeksteen van cryptocurrency handel geworden - ze ondersteunen meer dan twee derde van de cryptocurrency transacties, met een handelsvolume van maximaal $28 biljoen in 2024, wat de totale transacties van Visa en Mastercard overtreft.</p>
<h2 id="h2-Het20kernframework20van20de20STABLE20en20GENIUS20wetsvoorstellen652568"><a name="Het kernframework van de STABLE en GENIUS wetsvoorstellen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het kernframework van de STABLE en GENIUS wetsvoorstellen</h2><p>Op 19 mei 2025 heeft de Amerikaanse Senaat de procedurele wetgeving van de “GENIUS Act” aangenomen met een stemverhouding van 66 tegen 32, wat de weg vrijmaakt voor een definitieve stemming. De “STABLE Act” van het Huis van Afgevaardigden vordert ook gelijktijdig.</p>
<p>Hoewel er verschillen in details zijn tussen de twee wetsvoorstellen, construeren ze gezamenlijk het kernkader voor de regulering van stablecoins:</p>
<h3 id="h3-Uitgevende20beperkingen694872"><a name="Uitgevende beperkingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uitgevende beperkingen</h3><p>Slechts drie soorten entiteiten kunnen stablecoins uitgeven: dochterondernemingen van verzekerde deposito-instellingen, door de OCC goedgekeurde niet-bankentiteiten en gekwalificeerde staatscharterentiteiten.</p>
<h3 id="h3-1120reservevereiste20voor20activa746046"><a name="1:1 reservevereiste voor activa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1:1 reservevereiste voor activa</h3><p>Alle stablecoins moeten voor 100% gedekt zijn door zeer liquide activa zoals contant geld in USD, termijndeposito’s en kortlopende Amerikaanse staatsobligaties die binnen 93 dagen vervallen, en een maandelijkse openbare rapportage over de samenstelling van de reserves moet worden gecertificeerd door de CEO en CFO.</p>
<h3 id="h3-Verbod20op20rente20betalingen204241"><a name="Verbod op rente betalingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verbod op rente betalingen</h3><p>Om te voorkomen dat stablecoins evolueren tot vervangers voor bankdeposito’s, verbieden beide wetsvoorstellen het betalen van rente aan houders.</p>
<h3 id="h3-Duallayer20regulerend20kader148143"><a name="Dual-layer regulerend kader" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dual-layer regulerend kader</h3><p>Federale en staatsregelgeving bestaan naast elkaar: De staatsregelgevende kaders moeten “substantieel gelijkwaardig aan” (GENIUS) of “voldoen aan of beter zijn dan” (STABLE) de federale normen, en het ministerie van Financiën heeft de bevoegdheid om staatscertificeringen te vetoën.</p>
<h3 id="h3-Verduidelijk20juridische20attributen781253"><a name="Verduidelijk juridische attributen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verduidelijk juridische attributen</h3><p>De wet wijzigt de Effectenwet om te verduidelijken dat conforme stablecoins niet worden geclassificeerd als “effecten”, waardoor ze buiten de jurisdictie van de SEC vallen; de GENIUS Act sluit ze verder uit van de definitie van “grondstoffen”, waardoor CFTC-interventie wordt vermeden.</p>
<h2 id="h2-De20dubbele20motoren20van20de20dollarhegemonie20en20de20vertering20van20de20Amerikaanse20schulden780142"><a name="De dubbele motoren van de dollarhegemonie en de vertering van de Amerikaanse schulden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De dubbele motoren van de dollarhegemonie en de vertering van de Amerikaanse schulden</h2><p>De Amerikaanse druk voor regulering van stablecoins is geen toeval. Achter het wetsvoorstel liggen twee kernstrategische doelen:</p>
<h3 id="h3-De20herstructurering20van20de20digitale20dollarhegemonie772431"><a name="De herstructurering van de digitale dollarhegemonie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De herstructurering van de digitale dollarhegemonie</h3><p>De proportie van de Amerikaanse dollar in de wereldwijde vreemde valutareserves is gedaald tot het laagste niveau sinds 1995 (57,8% tegen het einde van 2024), en veel landen zijn op zoek naar manieren om Amerikaanse dollarafrekeningen in bilaterale handel te omzeilen.</p>
<p>De Amerikaanse dollar stablecoin is een krachtig hulpmiddel geworden voor goedkope uitbreiding van invloed: de wereldwijde circulatie van elke conforme stablecoin breidt de gebruiksscenario’s van de dollar uit. Minister van Financiën Basent verklaarde openhartig: “We zullen stablecoins gebruiken om de positie van de dollar als ‘s werelds primaire reservevaluta te behouden.”</p>
<h3 id="h3-Absorbeer20een20enorme20uitgifte20van20Amerikaanse20staatsobligaties116033"><a name="Absorbeer een enorme uitgifte van Amerikaanse staatsobligaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Absorbeer een enorme uitgifte van Amerikaanse staatsobligaties</h3><p>Het rapport van Standard Chartered Bank voorspelt: Tegen 2028 zal de uitgifte van stablecoins $2 biljoen bereiken, wat resulteert in een extra vraag van $1,6 biljoen voor de aankoop van Amerikaanse kortlopende staatsobligaties—“voldoende om alle nieuwe uitgifte van kortlopende staatsobligaties tijdens de tweede termijn van Trump te absorberen.”</p>
<p>Tegen 2024 zijn stablecoin-uitgevers de derde grootste kopers van Amerikaanse kortlopende staatsobligaties geworden. USDT alleen houdt 98 miljard USD aan Amerikaanse obligaties. Republikeinse senator Bill Hagerty voorspelt verder dat stablecoin-uitgevers tegen 2030 de grootste houders van Amerikaanse staatsobligaties ter wereld zullen worden.</p>
<h2 id="h2-Potentieel20Risico141688"><a name="Potentieel Risico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potentieel Risico</h2><h3 id="h3-6620biljoen20aan20depositouitstroom20in20de20banksector939673"><a name="$6,6 biljoen aan deposito-uitstroom in de banksector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>$6,6 biljoen aan deposito-uitstroom in de banksector</h3><p>Volgens een rapport van Bank of America Securities: de efficiënte betalingsfuncties van stablecoins en de leencapaciteiten van DeFi kunnen leiden tot een uitstroom van $6,6 biljoen aan deposito’s uit het traditionele banksysteem, waarbij kleine en middelgrote banken het meest worden getroffen.</p>
<p>De American Independent Community Bankers Association waarschuwt: De uitstroom van fondsen uit gemeenschapsbanken zal invloed hebben op belangrijke economische sectoren—zij verstrekken 60% van de kleine zakelijke leningen en 80% van de landbouwleningen in het hele land.</p>
<h3 id="h3-Digitale20run20bedreigt20financile20stabiliteit616323"><a name="“Digitale run” bedreigt financiële stabiliteit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>“Digitale run” bedreigt financiële stabiliteit</h3><p>De Bank voor Internationale Betalingen waarschuwt: Stablecoin runs kunnen directe impact hebben op de Amerikaanse schatkismarkt—Een verkoop van schatkistpapier ter waarde van $3,5 miljard is voldoende om de rendementen met 6 tot 8 basispunten te laten stijgen, wat een ketenreactie in gang zet.</p>
<p>Het de-pegging evenement van USDC in maart 2023 was een voorbode: toen Circle aankondigde dat zijn $3,3 miljard aan reserves bij Silicon Valley Bank werd gehouden, veroorzaakte dit onmiddellijk een golf van paniek bij de inlossing.</p>
<h3 id="h3-Hernieuwing20van20de20waarde20van20het20betalingssysteem655840"><a name="Hernieuwing van de waarde van het betalingssysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hernieuwing van de waarde van het betalingssysteem</h3><p>Het traditionele “vijf-partijen betalingsmodel” (Visa, MasterCard, enz.) staat onder druk. Voorstanders van blockchain-technologie beweren dat de transactiekosten van stablecoins minder dan $0,01 per transactie kunnen zijn, wat bijna verwaarloosbaar is in vergelijking met de 300 basispunten kosten van creditcards.</p>
<h2 id="h2-Toekomstige20vooruitzichten710153"><a name="Toekomstige vooruitzichten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstige vooruitzichten</h2><p>Aangezien de regering-Trump “het ondertekenen van de stablecoin-wet vóór augustus” tot prioriteit heeft gemaakt, is Wall Street begonnen zich opnieuw te positioneren. Berkshire Hathaway, onder leiding van Buffett, heeft in het eerste kwartaal zijn aandelen in Amerikaanse bankaandelen aanzienlijk verminderd en zijn positie in Citigroup volledig verlaten.</p>
<p>Deutsche Bank voorspelt dat de wetgeving zal leiden tot een gereguleerde dollar stablecoin-ecosysteem vóór augustus, waardoor stablecoins de reguliere valuta binnenkomen. Wanneer stablecoin-uitgevers $2 biljoen aan reserve-activa en $6,6 biljoen aan bankdeposito’s hebben die migratie ondergaan, wordt de machtsstructuur van het financiële systeem stilletjes herstructureerd op de blockchain.</p>
<p>De US dollar stablecoin is zowel een instrument voor de VS om zijn financiële hegemonie te consolideren als een zwaard van Damocles dat boven traditionele banken hangt - en dit alles zal de toon zetten in het laatste spel van wetgeving in de komende maanden.</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>