TmV3IFlvcmsgUmVndWxhdG9ycyBvbmRlcnpvZWt0IFN0YWJsZWNvaW4gSXNzdWVyLCBQYXhvcw==

2023-03-10, 09:25

<p><img src="https://gimg2.gateimg.com/image/article/1678440017热点.jpg" alt=""></p>
<h2 id="h2-TL20DR80140"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Het New York Department of Financial Services (NYDFS) onderzoekt Paxos op mogelijke operationele onregelmatigheden.</p>
<p>NYDFS heeft de redenen voor het onderzoeken van Paxos niet openlijk bekendgemaakt.</p>
<p>Paxos heeft aangekondigd dat het de uitgifte van BUSD zal stopzetten en de samenwerking met Binance zal beëindigen.</p>
<p>Crypto-gebruikers kunnen USDT en andere cryptocurrencies kopen op Gate.io.</p>
<h2 id="h2-Introductie37208"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De implosie van FTX en andere crypto projecten zoals <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD en <a href="https://www.gate.io/blog_detail/1241/will-blockfi-be-the-next-to-fall" target="_blank">BlockFi heeft verschillende regeringen onder druk gezet</a> om cryptoreguleringen in te voeren. We hebben al gezien dat Groot-Brittannië en de Verenigde Staten het voortouw nemen. Momenteel onderzoeken New Yorkse regelgevers Paxos Company, de uitgever van de stablecoins. <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a>(BUSD) en USDP.</p>
<h2 id="h2-De20reden20waarom20de20New20Yorkse20toezichthouders20het20Paxosbedrijf20onderzoeken965767"><a name="De reden waarom de New Yorkse toezichthouders het Paxos-bedrijf onderzoeken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De reden waarom de New Yorkse toezichthouders het Paxos-bedrijf onderzoeken</h2><p>Het New York Department of Financial Services (NYDFS) onderzoekt Paxos Company, de uitgever van stablecoins <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Paxos Dollar (USDP)](https://www.gate.io/price/pax-dollar-usdp “Paxos Dollar (USDP)”) en [Binance USD</a> (BUSD). De exacte oorzaak van het onderzoek is niet echt bekend, hoewel er speculaties zijn dat het te maken heeft met de samenwerking met Binance met betrekking tot BUSD.</p>
<p>De onderliggende drijfveer van de NYDFS voor het onderzoek is echter het beschermen van consumenten tegen de risico’s die voortvloeien uit hun investering in cryptocurrencies. Ter achtergrondinformatie is Paxos Company de uitgever van twee prominente <a href="https://www.gate.io/learn/articles/what-are-the-main-stablecoins/99" target="_blank">stablecoins, namelijk BUSD en USDP</a>.</p>
<p>De woordvoerder van NYDFS <a href="https://www.coindesk.com/policy/2023/02/09/stablecoin-issuer-paxos-is-being-investigated-by-new-york-regulator/" rel="nofollow noopener noreferrer" target="_blank">zei</a>“De afdeling staat voortdurend in contact met gereguleerde entiteiten om kwetsbaarheden en risico’s voor consumenten en de instellingen zelf te begrijpen vanwege de volatiliteit van de cryptomarkt die we ervaren.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/167844011511251678439783_.pic.jpg" alt=""></p>
<p>New York Regulators onderzoeken Paxos - Cryptotvplus<br>Overigens is Paxos een van de toonaangevende gereguleerde bedrijven in de Verenigde Staten. Bovendien heeft het een levendig blockchain-infrastructuurplatform en een open en efficiënt financieel systeem. De technologie maakt transparante afwikkeling van transacties, handel en tokenisatie van activa mogelijk.</p>
<p>In 2019 werkte Paxos samen met Binance om BUSD te ontwikkelen, de op twee na grootste stablecoin op basis van marktkapitalisatie. Aan de andere kant is Paxos Dollar (USDP) de op zes na grootste stablecoin. Afgezien hiervan heeft het een door crypto gesteunde Paxos. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">goud genaamd PAX Gold (PAXG)](https://www.gate.io/learn/articles/what-is-pax-gold/176 “gold called PAX Gold (PAXG)”) die bestaat op de [Ethereum</a> blockchain.</p>
<p>Onlangs heeft de Securities and Exchange Commission een kennisgeving van zijn voornemen om Paxos te vervolgen uitgegeven, genaamd een Wells-kennisgeving. Een betrouwbare bron heeft gezegd dat de NYDFS beweert dat Paxos Company een niet-geregistreerd effect, BUSD, heeft uitgegeven en genoteerd.</p>
<h2 id="h2-Paxos20omkeringen20voor20BUSD20en20USDP104443"><a name="Paxos’ omkeringen voor BUSD en USDP" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paxos’ omkeringen voor BUSD en USDP</h2><p>Over het algemeen heeft Paxos veel gedaan om de gebruikers te beschermen door reserves aan te houden voor zijn stablecoins. Sinds 2022 heeft Paxos volledige reserves voor zijn twee stablecoins, BUSD en USDP, aangehouden. Het is zelfs zo ver gegaan dat het op zijn website heeft verklaard dat zijn reserves in Amerikaanse dollars en Amerikaanse schatkistpapieren zijn.</p>
<p>Opmerkelijk kondigde Paxos in 2022 aan dat het voortdurend updates zou geven over zijn reserves om vertrouwen en vertrouwen bij zijn klanten te creëren. In dit opzicht geeft het maandelijks een rapport over zijn reserves. Het doel van deze rapporten is om te laten zien hoe transparant het bedrijf is bij het beveiligen van zijn stablecoins.</p>
<h2 id="h2-Afwikkeling20tussen20Paxos20en20het20New20York20Department20of20Financial20Services728148"><a name="Afwikkeling tussen Paxos en het New York Department of Financial Services" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Afwikkeling tussen Paxos en het New York Department of Financial Services</h2><p>Het laatste rapport toont aan dat Paxos een schikking heeft bereikt met het New York Department of Financial Services over de tegen haar ingediende beschuldigingen. Naar aanleiding hiervan heeft het bedrijf Paxos onlangs aangekondigd dat het met ingang van 21 februari zal stoppen met het uitgeven van BUSD. Het heeft ook verklaard dat het de huidige samenwerking met Binance zal beëindigen.</p>
<p>In feite heeft het New York Department of Financial Services Paxos gedwongen onmiddellijk te stoppen met de uitgifte van BUSD. Deze ontwikkeling toont de slechte relatie aan die bestaat tussen Binance en Amerikaanse toezichthouders. Zoals u wellicht weet, staat Binance sinds 2021 onder toezicht vanwege nalevingskwesties met de Amerikaanse anti-witwasregels.</p>
<p>Echter, de CEO van Binance, Changpeng Zhao, stelde zijn gebruikers gerust via Twitter dat hun fondsen in BUSD veilig zijn en dat ze het op elk moment kunnen inwisselen. Evenzo zei de NYDFS dat ze Paxos zullen blijven controleren om ervoor te zorgen dat consumenten hun BUSD kunnen verzilveren.</p>
<p>Lees ook: <a href="https://www.gate.io/fr/blog_detail/2146" target="_blank">Markten bereiden zich voor op de publicatie van Amerikaanse inflatiegegevens en de actie van de SEC tegen stablecoins</a></p>
<h2 id="h2-Paxos20en20iBit149464"><a name="Paxos en iBit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paxos en iBit</h2><p>Naast de gewilde BitLicense, verkregen van NYDFS, is Paxos eigenaar van iBit, een betrouwbare en toonaangevende cryptocurrency exchange gevestigd in de Verenigde Staten. De BitLicense stelt Paxos in staat digitale activiteiten uit te voeren in de staat New York. De in 2012 gelanceerde itBit Digital Asset Exchange heeft ook kantoren in Londen en Singapore. Naast iBit zijn er andere cryptocurrency exchanges zoals Gate.io die verschillende digitale producten aanbieden.</p>
<h2 id="h2-Gateio20cryptobeurs370230"><a name="Gate.io cryptobeurs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gate.io cryptobeurs</h2><p>Gate.io heeft meer dan 1.400 paren van cryptocurrencies, evenals verschillende niet-vervangbare tokens.</p>
<p>U kunt verschillende cryptocurrencies verhandelen zoals USDT, de nummer één stablecoin qua marktkapitalisatie. In feite is USDT een van de cryptocurrencies die veel paren heeft. U kunt <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">wissel USDT voor BTC</a>, TRX, ADA, MATIC, ETH en nog veel meer.</p>
<p>Het goede is dat je een creditcard kunt gebruiken om USDT te kopen en het kunt omzetten naar andere tokens en munten. Om <a href="https://www.gate.io/buy_crypto?type=buy" target="_blank">koop USDT met een creditcard</a> of bankoverschrijving, klikt u op ‘Crypto kopen’ en selecteert u een betaalmethode.</p>
<p>Conclusie<br>Samengevat onderzoekt het New York Department of Financial Services (NYDFS) het Paxos-bedrijf om te achterhalen of het voldoet aan de relevante crypto-regelgeving. Paxos heeft al aangekondigd dat het vanaf 21 februari 2023 stopt met het uitgeven van BUSD. Naast BUSD heeft Paxos andere tokens, namelijk Paxos Dollar (USDP), USDP en <a href="/price/pax-gold-paxg" rel="nofollow noopener noreferrer" target="_blank">PAX Gold</a> (PAXG).</p>
<h2 id="h2-Veelgestelde20vragen20over20Paxos887340"><a name="Veelgestelde vragen over Paxos" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Paxos</h2><h3 id="h3-Wat20is20Paxos20Trust20Company46426"><a name="Wat is Paxos Trust Company?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Paxos Trust Company?</h3><p>Paxos Trust Company is een gereguleerde uitgever gevestigd in de Verenigde Staten <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a>, Paxos Dollar (USDP) en <a href="/price/pax-gold-paxg" rel="nofollow noopener noreferrer" target="_blank">PAX Gold</a> (PAXG). Het bezit ook iBit, een in de Verenigde Staten geregistreerde cryptocurrency-beurs, met andere kantoren in Londen en Singapore.</p>
<h3 id="h3-Waarom20heeft20Paxos20BUSD20uitgegeven318365"><a name="Waarom heeft Paxos BUSD uitgegeven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom heeft Paxos BUSD uitgegeven?</h3><p>Paxos Trust Company heeft samengewerkt met Binance om uit te geven <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a> (BUSD). BUSD is een stablecoin die 1:1 gekoppeld is aan de Amerikaanse dollar en wordt verhandeld op veel cryptocurrency-beurzen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Onderzoeker bij Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt slechts de opvattingen 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>