RGUgdG9la29tc3Qgdm9ybWdldmVuOiBFZW4gYmxhdXdkcnVrIHZvb3IgaGV0IHJlZ3VsZXJlbiB2YW4gc3RhYmxlY29pbnMgaW4gZGUgVmVyZW5pZ2RlIFN0YXRlbg==

2024-05-22, 02:32

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR903123"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Hilary Allen, een rechtenprofessor aan de American University, roept op tot het verbieden van stablecoins, terwijl Marcelo M. Prates, een expert op het gebied van financieel beleid en regulering, pleit voor de invoering van een geschikte federale cryptocurrency-wet.</p>
<p>De drie pijlers van een federale stablecoin wet zijn reservevermogensbescherming bij faillissement, het uitgeven van niet-bancaire licenties en directe toegang tot centrale bankrekeningen.</p>
<p>Stablecoins moeten traditionele financiële diensten aanvullen en niet concurreren met banken.</p>
<h2 id="h2-Introductie637044"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Verschillende vooraanstaande analisten, waaronder Jeremy Allaire, CEO van Circle, geloven dat de Verenigde Staten dit jaar, in 2024, zijn regulering voor stabiele cryptovaluta zou kunnen goedkeuren, wat de toekomst van digitale betalingen zou kunnen bepalen. Momenteel wordt al een voorgesteld wetsvoorstel voor stabiele cryptovaluta, de Clarity for Payment stablecoins Act van 2023, overwogen.</p>
<p>Echter, wat de beoordeling en goedkeuring van een regelgeving voor stablecoins zou kunnen dwarsbomen, is de Amerikaanse presidentsverkiezingen. <a href="https://www.gate.io/blog_detail/4135/as-the-us-presidential-election-approaches-is-trump-meme-becoming-a-best-loved-meme" target="_blank">verkiezing gepland voor 5 november</a> Het doel van dit artikel is om de voortgang te onderzoeken die de Verenigde Staten hebben geboekt naar de lancering van een wettelijk kader voor stablecoins.</p>
<h2 id="h2-Debat20over20regulering20van20Stablecoin20in20de20VS20Marcelo20Prates20vs20Hilary20Allen738331"><a name="Debat over regulering van Stablecoin in de VS: Marcelo Prates vs. Hilary Allen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Debat over regulering van Stablecoin in de VS: Marcelo Prates vs. Hilary Allen</h2><p>De standpunten van Hilary Allen, hoogleraar rechten aan de American University, en Marcelo M. Prates, een expert op het gebied van financieel beleid en regelgeving, met betrekking tot cryptoregulering tonen de verdeeldheid binnen onze mondiale samenleving met betrekking tot digitale activa.</p>
<p>Bijvoorbeeld, <a href="https://go.skimresources.com/?id=100652X1574425&amp;isjs=1&amp;jv=15.5.0&amp;sref=https%3A%2F%2Fwww.coindesk.com%2Fopinion%2F2024%2F05%2F09%2Fhow-the-us-should-regulate-stablecoins%2F&amp;url=https%3A%2F%2Fpodcasts.apple.com%2Fus%2Fpodcast%2Fbanking-with-interest%2Fid1506774121%3Fi%3D1000654155074&amp;xs=1&amp;xtz=-120&amp;xuuid=c2b55452016114d2809ff4aae8fbc6b2&amp;xjsf=other_click__auxclick%20%5B2%5D" rel="nofollow noopener noreferrer" target="_blank">Hilary Allen denkt dat stablecoins een bedreiging vormen voor de bankensector</a> en zou daarom verboden moeten worden. Allen gelooft dat de grotere adoptie van stablecoins waarschijnlijk zal leiden tot de destabilisatie van banken tot het punt dat ze overheidssteun nodig zullen hebben.</p>
<p>De opmerkingen van Allen zijn gekomen in het kielzog van een nieuwe drive van het Amerikaanse Congres om stablecoin-wetten op federaal niveau in te voeren, die de toekomst van digitale betalingen zullen bepalen. Ook al kan het wat meer tijd kosten voordat het Congres het nieuwe wetsvoorstel goedkeurt, Allen denkt dat zo’n standpunt het publiek de tijd geeft om de voorgestelde cryptocurrency-regulering te ondersteunen. Kortom, zij denkt dat “stablecoins geen belangrijk doel dienen en eerlijk gezegd gewoon verboden zouden moeten worden.”</p>
<p>Aan de andere kant denkt Marcelo M. Prates dat stablecoins belangrijk zijn in de economie omdat ze financiële inclusie bevorderen, kosteneffectief zijn en de concurrentiepositie in het wereldwijde financiële economische systeem verbeteren.</p>
<p>Om zijn standpunt duidelijk te maken, gebruikte hij een voorbeeld van de ontwikkeling van <a href="https://www.gate.io/price/e-money-eur-eeur" target="_blank">e-money in de Europese Unie</a> Volgens Prates is elektronisch geld (e-geld) een van de grootste innovaties van de afgelopen 25 jaar geweest. In feite is e-geld de versie van geld die wordt uitgegeven door niet-bancaire instellingen. <a href="https://www.gate.io/hot_news/detail/88/what-you-need-to-know-when-buying-bitcoin-with-paypal" target="_blank">zoals PayPal</a>. Nu worden cryptocurrencies door experts geclassificeerd als e-money, omdat ze niet worden uitgegeven door banken. Echter, om goed te functioneren kunnen ze duidelijke regelgeving vereisen.</p>
<p>Een goed voorbeeld hiervan is de Europese Unie, die sinds het jaar 2000 het gebruik van elektronisch geld heeft bedacht. De EU vond het essentieel om elektronisch geld te hebben, omdat het goedkopere betalingen en gemakkelijke toegang mogelijk maakt. Het maakt ook betalingen sneller over de hele wereld. Met die visie ontwikkelde de EU financiële regelgeving voor elektronisch geld. Als gevolg daarvan kwamen FinTech-bedrijven die veilige en gereguleerde betaalinstrumenten bieden, tot stand.</p>
<p>De reden voor de EU om e-money toe te staan was om financiële inclusie te vergroten door middel van gestroomlijnde manieren van geld verzenden en ontvangen. Dit komt doordat deze e-money verzenders hun klanten niet verplichten om complexe procedures te doorlopen bij het verzenden of ontvangen van geld. Bovendien hebben e-money diensten minder risico’s en complicaties dan banken. Zo kost het bijvoorbeeld veel tijd en is het proces omslachtig om een bankrekening te openen voor het doen van elektronische geldtransfers.</p>
<p>Integendeel, het kost weinig tijd en moeite om geld te versturen via niet-bancaire financiële diensten zoals PayPal. Met e-geld ontvangen de verantwoordelijke instellingen eenvoudig fiatgeld van klanten en zetten het om in digitaal geld dat ze kunnen gebruiken voor het doen van virtuele betalingen met creditcards of betaalpassen, onder andere methoden. Uiteindelijk kan het e-geld eenvoudig weer worden omgezet in contant geld.</p>
<p>Daarom gelooft Prates dat <a href="https://www.gate.io/learn/articles/what-is-stablecoin/40" target="_blank">stablecoins werken</a> in werkwijze als e-geld dat al tientallen jaren bestaat en veilig is gebruikt om een levendig mondiaal betalingssysteem te bevorderen. Met andere woorden, de meeste zo niet alle bestaande <a href="https://www.gate.io/learn/articles/what-are-the-main-stablecoins/99" target="_blank">stablecoins ondersteund door fiat-valuta</a> zoals USDT en <a href="https://www.gate.io/learn/articles/what-is-usdc/113" target="_blank">USDC (Verenigde Staten)</a> zijn een vorm van e-geld.</p>
<p>Het belangrijkste argument voor door fiatvaluta gesteunde stablecoins is dat ze ‘e-money 2.0’ zijn, die veilig financiële transacties kunnen vergemakkelijken, net als traditionele financiële e-money. Prates suggereert echter dat de Amerikaanse federale overheid drie pijlers van stablecoin-regelgeving moet vaststellen, namelijk, reserve-actief faillissementsbescherming, het uitgeven van niet-bancaire vergunningen en directe toegang tot centrale bankrekeningen, wat financiële inclusie en stabiele betalingsen zou moeten bevorderen. Een dergelijk regelgevingskader stelt stablecoin-aanbieders in staat om te opereren in een laag-risico, gereguleerde financiële omgeving.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/lst-backed-stablecoins-a-new-frontier-in-defi-innovation-and-opportunity/2200" target="_blank">LST-Gesteunde Stablecoins: Een Nieuwe Frontier in DeFi</a></p>
<h2 id="h2-Pijlers20van20Effectieve20Stablecoin20Regulering317066"><a name="Pijlers van Effectieve Stablecoin Regulering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pijlers van Effectieve Stablecoin Regulering</h2><p>Zoals hierboven aangegeven, zijn de drie pijlers van effectieve stablecoin-regelgeving backup-asset-bankroetbescherming, het uitgeven van niet-bancaire licenties en directe toegang tot centrale bankrekeningen. Prates pleit echter voor een federale blockchain-regelgeving in plaats van op staten gebaseerde wetten voor geldoverdracht die niet uniform zijn ontworpen en gehandhaafd.</p>
<p>Verlening van een niet-bancaire vergunning: De overheid moet vergunningen verlenen aan stablecoin-uitgevers die voldoende liquide reserves moeten aanhouden voor hun stablecoins. De rol van stablecoin-uitgevers is om contanten van hun klanten te ontvangen, deze vast te houden en digitale activa uit te geven die in verhouding staan tot het bedrag aan geld dat ze hebben ontvangen en vastgehouden. Omdat ze geen geld uitlenen, is er behoefte aan digitale valutaveiligheid door het hebben van 100% reserves.</p>
<p>Zodra de stablecoin-providers te allen tijde reserves aanhouden, kunnen ze andere functies uitvoeren. Zo kunnen ze bijvoorbeeld grensoverschrijdende betalingen en de uitgifte van stablecoins bevorderen naarmate de vraag naar de munten stijgt. Door zich te houden aan de federale wetgeving inzake stablecoins en het beschermen van stablecoin-gebruikers, zullen ze een goede reputatie behouden, wat vertrouwen schept in de cryptomarkt. In de eerste plaats zou regelgeving voor cryptocurrencies de stabiliteit van de stablecoin-markt moeten verbeteren.</p>
<p>Het is ook belangrijk op te merken dat e-geld en digitale activa niet de bedoeling hebben te concurreren met banken bij het verstrekken van internationale financiële overmakingen. Als zodanig zouden centrale banken en stablecoins elkaar moeten aanvullen. Daarom zouden stablecoin-uitgevers in de Verenigde Staten vergelijkbare niet-bancaire vergunningen moeten krijgen zoals wat de E.U., het Verenigd Koninkrijk en Brazilië hebben gedaan voor e-geldverstrekkers in hun rechtsgebieden.</p>
<p>Centrale Bankrekeningen voor Ondersteunende Activa: Om de transparantie te vergroten en het risicoprofiel van stablecoin-uitgevers te verlagen, moeten zij hun reserves bij de centrale bank aanhouden. Hiermee zullen zij hun geld overboeken naar de centrale bankrekeningen of investeren in kortlopende, laagrisico-instrumenten zoals opties. De zekerste manier om risico’s met betrekking tot reserve-activa te verminderen, is door ze bij de Federal Reserve te houden.</p>
<p>Scheiding en bescherming van klantengelden: Een essentiële taak voor stablecoin-uitgevers om stablecoin-gebruikers te beschermen, is het scheiden van de klantengelden van de bedrijfsgelden. Dit betekent dat als de stablecoin faalt, het bedrijf niet failliet hoeft te gaan. Ook kunnen klanten bij liquidatie snel over hun geld beschikken. Dit komt doordat de schuldeisers van de failliete uitgever niet in staat zullen zijn om het geld van de klanten in beslag te nemen.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/an-overview-of-the-global-regulatory-landscape-for-virtual-assets/1043" target="_blank">Een overzicht van het mondiale regelgevingskader</a></p>
<h2 id="h2-Egeldregulering20in20de20EU20en20de20VS500560"><a name="E-geldregulering in de EU en de VS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>E-geldregulering in de EU en de VS</h2><p>Zowel de Europese Unie als de Verenigde Staten zijn bezig met het afronden van hun regelgeving voor stablecoins. De EU heeft MiCA, onderdeel van het pakket digitale financiën dat gericht is op het bevorderen van het gebruik van innovatieve technologieën zoals blockchain en stablecoins. MiCA biedt een duidelijk regelgevend kader met details over de aard van stablecoins en de verantwoordelijkheden van de e-gelduitgevers.</p>
<p>Aan de andere kant heeft de Verenigde Staten een voorgestelde wet met de naam de Clarity for Payment stablecoins Act. Als deze wet wordt goedgekeurd door het Congres, zal de wet duidelijkere richtlijnen bieden voor de werking van stablecoins. Zo zullen alle stablecoin-uitgevers verplicht zijn zich te registreren bij de relevante autoriteiten. Bovendien zullen zij onderworpen worden aan bankachtige regelgeving die vereist dat zij voldoende reserves aanhouden. Ook zullen staatsregulatoren zoals de Federal Reserve Board (FRB) de wet handhaven en toezicht houden op hen.</p>
<h2 id="h2-Conclusie462861"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De Verenigde Staten en de EU zijn bezig met het afronden van hun stablecoin-wetten. Terwijl de EU MiCA heeft, heeft de Verenigde Staten een wetsvoorstel dat het Congres nog moet goedkeuren, de Clarity for Payment Stablecoins Act. Marcelo M. Prates, een expert op het gebied van financieel beleid en regulering, heeft aangegeven dat de beste federale stablecoin-wetgeving drie pijlers moet hebben - bescherming tegen faillissement van backup-activa, het verstrekken van niet-bancaire vergunningen en directe toegang tot centrale bankrekeningen.</p>
<div class="blog-details-info"><br><div>Auteur: <em> Mashell C. </em>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel wordt toegestaan op voorwaarde dat Gate.io als bron wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>