SGV0IG9udGNpamZlcmVuIHZhbiBkZSBrcml0aWVrIHZhbiBFbGl6YWJldGggV2FycmVuIG9wIENyeXB0bw==

2023-12-25, 08:23

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR609394"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Wetgever Elizabeth Warren heeft een wetsvoorstel ingediend dat mogelijk strenge bepalingen kan creëren voor cryptocurrency-activiteiten in de Verenigde Staten.</p>
<p>Cryptocurrency regulering helpt klanten en crypto bedrijven te beschermen tegen verschillende criminele en frauduleuze praktijken.</p>
<p>Jamie Dimon, CEO van JPMorgan, wil dat de overheid cryptocurrencies verbiedt.</p>
<h2 id="h2-Introductie432394"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Wetgevers in veel landen over de hele wereld werken dag en nacht om passende regelgeving voor cryptocurrency te ontwikkelen. Sommige landen pleiten voor strenge wetgeving over digitale activa, terwijl anderen een progressieve en soepele houding ten opzichte daarvan aannemen.</p>
<p>Hoewel de Verenigde Staten in de loop der jaren toegeeflijk is geweest ten aanzien van cryptocurrencies, heeft het sinds het begin van 2023 strenger opgetreden tegen crypto-activiteiten.</p>
<p>Vandaag bekijken we de standpunten van Elizabeth Warren, een wetgever, en Jamie Dimon, CEO van JPMorgan, over cryptocurrencies. Over het algemeen hebben beiden een vergelijkbaar bredere kijk op hoe de Verenigde Staten met crypto-activa moeten omgaan.</p>
<p>Lees ook: ​​ <a href="https://www.gate.io/blog_detail/3215/jp-morgan-deposit-tokens" target="_blank">JP Morgan overweegt blockchain-aangedreven stortingstokens voor snellere transacties en lagere kosten</a></p>
<h2 id="h2-Het20perspectief20van20Elizabeth20Warren20over20cryptocurrency934080"><a name="Het perspectief van Elizabeth Warren over cryptocurrency" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het perspectief van Elizabeth Warren over cryptocurrency</h2><p>Elizabeth Warren, een Amerikaanse anti-crypto senator, beweerde onlangs dat cryptocurrency een bedreiging vormt voor de Verenigde Staten. Haar onverzettelijke aanval op cryptocurrencies volgt op een soortgelijke visie van Jamie Dimon, CEO van JPMorgan, op digitale activa. Sterker nog, Dimon zei dat de overheid cryptocurrencies zou moeten sluiten.</p>
<p>Volgens Warren worden cryptocurrencies voornamelijk gebruikt om criminele activiteiten zoals terrorisme en drugshandel te financieren. <a href="https://twitter.com/i/status/1732813883130147195" rel="nofollow noopener noreferrer" target="_blank">Ze zei</a>, “Er is een nieuwe dreiging daarbuiten -het is crypto en het wordt gebruikt voor terroristische financiering en het wordt gebruikt voor drugshandel. We kunnen dit niet laten doorgaan.”</p>
<p>Verschillende analisten zijn het echter niet eens met Warren, omdat zij beweren dat de Amerikaanse dollar meer illegale activiteiten financiert dan <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Zou dat kunnen betekenen dat de Amerikaanse regering zijn valuta moet verbieden?</p>
<p>Een X-gebruiker, <a href="https://twitter.com/natbrunell/status/1732874958894989567" rel="nofollow noopener noreferrer" target="_blank">Natalie Brunnel geplaatst</a>, “Laten we de feiten eerlijk stellen: de valuta die het meest wordt gebruikt voor omkoping, afpersing, drugshandel, mensenhandel, en <a href="https://www.gate.io/learn/articles/what-is-anti-money-laundering/81" target="_blank">witwassen van geld</a> is de Amerikaanse dollar. Er is geen echte concurrent, laat staan <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> waar elke transactie transparant is en voor altijd wordt vastgelegd.</p>
<p>Nog een crypto-enthousiasteling, <a href="https://twitter.com/diehardcubfan3/status/1732816130425655612" rel="nofollow noopener noreferrer" target="_blank">@diehardcubfan</a>, is van mening dat het verbieden van bitcoin en andere cryptocurrencies alleen in de Verenigde Staten geen betekenis heeft, omdat andere landen het zullen blijven gebruiken.</p>
<p><a href="https://twitter.com/diehardcubfan3/status/1732816130425655612" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>, “Misschien ben ik naïef, maar hoe kan een Amerikaanse wet van invloed zijn op het al dan niet gebruik van Bitcoin door Noord-Korea? Ik bezit geen BTC, maar ik vind haar argument niet authentiek.”</p>
<p>Het is belangrijk op te merken dat Warren een wetsvoorstel heeft ingediend om haar zorgen aan te pakken. <a href="https://twitter.com/i/status/1732813883130147195" rel="nofollow noopener noreferrer" target="_blank">Warren toegevoegd</a> Het ministerie van Financiën maakt duidelijk dat we nieuwe wetten nodig hebben om op te treden tegen het gebruik van crypto’s door terroristische groeperingen, schurkenstaten, drugsbaronnen, ransomware-bendes en oplichters om miljarden aan gestolen geld wit te wassen, sancties te ontlopen, illegale wapenprogramma’s te financieren en winst te maken uit verwoestende cyberaanvallen.</p>
<p>“Ik ben blij dat vijf nieuwe senatoren zich aansluiten bij de strijd om actie te ondernemen, waaronder drie leden van de Bankcommissie - ons tweeledige wetsvoorstel is het moeilijkste voorstel dat op tafel ligt om het illegale gebruik van crypto aan te pakken en regelgevers meer tools in hun gereedschapskist te geven.”</p>
<p>De Major County Sheriffs of America, Global Financial Integrity, National District Attorneys Association, Massachusetts Bankers Association, Bank Policy Institute, Transparency International U.S., AARP, National Consumer Law Center, National Consumers League en Massachusetts Sheriffs’ Association zijn voorbeelden van organisaties die het wetsvoorstel steunen, wat wijst op een streven naar de invoering van regelgeving voor cryptovaluta in de Verenigde Staten en andere landen.</p>
<p>Het nieuwe wetsvoorstel zal de bepalingen van de Bank Secrecy Act (BSA) en de Know-Your-Customer (KYC) vereisten uitbreiden. Deze ontwikkeling komt op een moment dat er een <a href="https://www.gate.io/blog_detail/2563" target="_blank">toename in de adoptie van bitcoin en andere cryptocurrencies</a>.</p>
<p>Ondanks het voorgestelde cryptowetsvoorstel de Verenigde Staten <a href="https://www.gate.io/blog_detail/3555/grayscale-pushes-spot-btc-etf &quot;Securities and Exchange Commission (SEC" rel="nofollow noopener noreferrer" target="_blank">De Securities and Exchange Commission (SEC) wordt naar verwachting in 2024 verschillende spot bitcoin verhandelde fondsen (ETF’s) goedkeuren</a> wordt verwacht dat er in 2024 verschillende spot bitcoin verhandelde fondsen (ETF’s) worden goedgekeurd.</p>
<h2 id="h2-Samenwerking20tussen20Warren20en20Dimon722971"><a name="Samenwerking tussen Warren en Dimon" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenwerking tussen Warren en Dimon</h2><p>Al meer dan tien jaar botsen Dimon en de Amerikaanse senator Warren vele malen omdat hun opvattingen over een aantal kwesties vaak verschillen. Ze redeneerden onlangs echter op dezelfde manier met betrekking tot cryptocurrency in de Verenigde Staten.</p>
<p>Ze willen allebei dat de overheid streng optreedt tegen het gebruik van cryptocurrencies in het land. Hun gemeenschappelijke perceptie is dat cryptocurrencies voornamelijk worden gebruikt voor criminele doeleinden.</p>
<p>Dimon’s kritiek <a href="/price/optimism-op" target="_blank" class="blog_inner_link">op crypto</a> resoneert met die van <a href="https://twitter.com/SenWarren/status/1732591261431836794" rel="nofollow noopener noreferrer" target="_blank">Warren die zei</a>, ‘Als het gaat om het bankenbeleid, ben ik meestal niet eens met de CEO’s van miljardenbanken. Maar <a href="https://www.gate.io/article/30683" target="_blank">handhaving van anti-witwasregels tegen crypto</a> Het beschermen van de nationale veiligheid is gezond verstand &amp; kritiek. Het is tijd voor het Congres om op te treden.</p>
<p>Wat verrassend is, is dat JPMorgan zijn JPM crypto-token heeft gelanceerd op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain, toch veroordeelt de CEO, Dimon, ze. Met hoe wijdverspreid de acceptatie van crypto is, is het verbieden ervan als het sluiten van het internet.</p>
<h2 id="h2-Implicaties20van20Cryptobeleid20en20Ken20uw20Klanten20KYC942985"><a name="Implicaties van Crypto-beleid en Ken uw Klanten (KYC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicaties van Crypto-beleid en Ken uw Klanten (KYC)</h2><p>Zowel het bredere cryptobeleid als de ken uw klantbepalingen zijn een vereiste voor de cryptosector, aangezien ze zowel investeerders als cryptobedrijven beschermen. <a href="https://www.gate.io/blog_detail/918/what-is-kyc-and-why-is-it-important" target="_blank">KYC is een wettelijke verplichting</a> in veel landen ook. Het overtreden van hun bepalingen kan dus leiden tot juridische stappen en zware straffen.</p>
<p>In het algemeen helpt KYC bij het voorkomen van verschillende vormen van fraude die zowel klanten als crypto-bedrijven zoals beurzen kunnen schaden. De KYC stelt crypto-bedrijven en de overheid in staat om gebruikersgedrag en transacties te volgen.</p>
<p>Ten tweede zorgt het gebruik van KYC voor vertrouwen en zekerheid in de sector, omdat de verschillende belanghebbenden zich beschermd voelen. Dit komt doordat de overheid gemakkelijk tekenen van witwassen van geld en financiering van terrorisme, naast andere frauduleuze en criminele activiteiten, kan opsporen.</p>
<p>Cryptocurrency-wetgeving is belangrijk bij het beschermen van cryptobedrijven tegen insolventie, faillissement en implosie. Verschillende juridische waarborgen, zoals verplichte bekendmakingen en het gebruik van reserves, zorgen ervoor dat cryptobedrijven niet betrokken zijn bij zeer risicovolle activiteiten die hun bestaan in gevaar brengen. In 2022 leidden slechte bedrijfsbeheerspraktijken van cryptobedrijven zoals FTX Exchange tot hun ineenstorting.</p>
<h2 id="h2-Conclusie407362"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Zowel wetgever Elizabeth Warren als Jamie Dimon, CEO van JPMorgan, roepen op tot strengere crypto-regelgeving om het gebruik ervan voor het financieren van criminele activiteiten zoals terrorisme en drugshandel te stoppen. Warren heeft al een crypto-wetsvoorstel ingediend dat gericht is op het uitbreiden van de bepalingen van de Bank Secrecy Act (BSA) en het Know-Your-Customer (KYC) raamwerk. Hoewel crypto-beleid noodzakelijk is, moet het land ruimte laten voor innovatie in de cryptocurrency sector.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Mashell C.</strong>, Gate.io Onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>