TGUgYXV0b3JpdMOgIGRpIE5ldyBZb3JrIGluZGFnYW5vIHN1bGxvIHN0YWJpbGl6emF0b3JlIFBheG9z

2023-03-10, 09:25

<p><img src="https://gimg2.gateimg.com/image/article/1678440017热点.jpg" alt=""></p>
<h2 id="h2-TL20DR492997"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il Dipartimento dei Servizi Finanziari di New York (NYDFS) sta investigando su Paxos per possibili irregolarità operative.</p>
<p>NYDFS non ha divulgato apertamente le ragioni per indagare su Paxos.</p>
<p>Paxos ha annunciato che interromperà l’emissione di BUSD e metterà fine alla sua partnership con Binance.</p>
<p>Gli utenti di criptovalute possono acquistare USDT e altre criptovalute su Gate.io.</p>
<h2 id="h2-Introduzione775316"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’implosione di FTX e altri progetti criptati come <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD e <a href="https://www.gate.io/blog_detail/1241/will-blockfi-be-the-next-to-fall" target="_blank">BlockFi ha esercitato pressioni su vari governi</a> istituire regolamenti criptovaluta. Già, abbiamo visto Gran Bretagna e Stati Uniti prendere il comando. Attualmente, i regolatori di New York stanno indagando sulla società Paxos, l’emittente delle stablecoin <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a> (BUSD) e USDP.</p>
<h2 id="h2-Il20motivo20per20cui20i20regolatori20di20New20York20stanno20indagando20sulla20societ20Paxos774862"><a name="Il motivo per cui i regolatori di New York stanno indagando sulla società Paxos" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il motivo per cui i regolatori di New York stanno indagando sulla società Paxos</h2><p>Il Dipartimento dei Servizi Finanziari di New York (NYDFS) sta indagando sulla società Paxos, l’emittente di stablecoin <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)”) e [Binance USD</a>(BUSD). La causa esatta dell’indagine non è veramente nota, anche se ci sono speculazioni che è a causa della sua partnership con Binance relativa a BUSD.</p>
<p>Tuttavia, il motivo sottostante della NYDFS per l’indagine è proteggere i consumatori dai rischi derivanti dal loro investimento in criptovalute. Come informazione di base, la società Paxos è l’emittente di due prominenti <a href="https://www.gate.io/learn/articles/what-are-the-main-stablecoins/99" target="_blank">stablecoin cioè BUSD e USDP</a>.</p>
<p>Il portavoce del 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">detto</a> Il dipartimento è in continuo contatto con entità regolamentate per comprendere le vulnerabilità e i rischi per i consumatori e le istituzioni stesse derivanti dalla volatilità del mercato delle criptovalute che stiamo vivendo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167844011511251678439783_.pic.jpg" alt=""></p>
<p>I regolatori di New York indagano su Paxos - Cryptotvplus. A proposito, Paxos è una delle principali società regolamentate negli Stati Uniti. Inoltre, ha una piattaforma di infrastruttura blockchain vibrante e un sistema finanziario aperto ed efficiente. La sua tecnologia consente la liquidazione trasparente delle transazioni, il trading e la tokenizzazione degli asset.</p>
<p>Nel 2019 Paxos ha collaborato con Binance per sviluppare BUSD, la terza stablecoin più grande in base alla capitalizzazione di mercato. D’altra parte, il Paxos Dollar (USDP) è la sesta stablecoin più grande. Oltre a queste, ha una criptovaluta Paxos supportata da <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">oro chiamato PAX Gold (PAXG)](https://www.gate.io/learn/articles/what-is-pax-gold/176 “gold called PAX Gold (PAXG)”) che esiste sul [Ethereum</a> blockchain.</p>
<p>Di recente, la Securities and Exchange Commission ha emesso un avviso della sua intenzione di perseguire Paxos chiamato Wells notice. Una fonte affidabile ha affermato che il NYDFS sostiene che la società Paxos ha emesso e quotato un titolo non registrato, BUSD.</p>
<h2 id="h2-Inversioni20di20Paxos20per20BUSD20e20USDP755242"><a name="Inversioni di Paxos per BUSD e USDP" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inversioni di Paxos per BUSD e USDP</h2><p>In generale, Paxos ha fatto molto per proteggere gli utenti attraverso il mantenimento delle riserve per i suoi stablecoin. Dal 2022, Paxos ha mantenuto che ha riserve complete per i suoi due stablecoin, BUSD e USDP. È addirittura arrivato al punto di dichiarare sul suo sito web che le sue riserve sono in dollari statunitensi e tesorerie statunitensi.</p>
<p>In particolare, Paxos ha annunciato nel 2022 che fornirà costantemente aggiornamenti sulle sue riserve al fine di creare fiducia e fiducia nei confronti dei suoi clienti. A tal fine, fornisce un rapporto mensile sulle sue riserve. Lo scopo di questi rapporti è mostrare quanto sia trasparente l’azienda nel garantire le sue stablecoin.</p>
<h2 id="h2-Regolamento20tra20Paxos20e20il20Dipartimento20dei20Servizi20Finanziari20di20New20York553605"><a name="Regolamento tra Paxos e il Dipartimento dei Servizi Finanziari di New York" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamento tra Paxos e il Dipartimento dei Servizi Finanziari di New York</h2><p>Il rapporto più recente mostra che Paxos ha raggiunto un accordo con il Dipartimento dei Servizi Finanziari di New York sulle accuse a suo carico. A tal fine, la società Paxos ha annunciato di recente che smetterà di emettere BUSD a partire dal 21 febbraio. Ha inoltre dichiarato che metterà fine alla sua attuale partnership con Binance.</p>
<p>In realtà, il Dipartimento dei Servizi Finanziari di New York ha costretto Paxos a interrompere immediatamente l’emissione di BUSD. Questo sviluppo mostra la cattiva relazione che esiste tra Binance e i regolatori degli Stati Uniti. Come potreste sapere, Binance è stata sotto sorveglianza dal 2021 a causa di problemi di conformità con le norme anti-riciclaggio degli Stati Uniti.</p>
<p>Tuttavia, il CEO di Binance, Changpeng Zhao, ha rassicurato i suoi utenti tramite Twitter che i loro fondi in BUSD sono al sicuro e che possono continuare a riscattarli in qualsiasi momento. Allo stesso modo, il NYDFS ha dichiarato che continuerà a monitorare Paxos per garantire che i consumatori possano incassare su BUSD.</p>
<p>Leggi anche: <a href="https://www.gate.io/fr/blog_detail/2146" target="_blank">I mercati si preparano per la pubblicazione dei dati sull’inflazione negli Stati Uniti e per l’azione legale della SEC sulle stablecoin</a></p>
<h2 id="h2-Paxos20e20iBit920200"><a name="Paxos e iBit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paxos e iBit</h2><p>Oltre alla sua ambita BitLicense, ottenuta dalla NYDFS, Paxos possiede iBit, un affidabile e principale exchange di criptovalute con sede negli Stati Uniti. Infatti, la BitLicense consente a Paxos di svolgere attività digitali nello Stato di New York. Lanciata nel 2012, la piattaforma di scambio di asset digitali ItBit ha anche sedi a Londra e Singapore. Oltre a iBit, ci sono altri exchange di criptovalute come Gate.io che offrono diversi prodotti digitali.</p>
<h2 id="h2-Scambio20di20criptovalute20Gateio748558"><a name="Scambio di criptovalute Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Scambio di criptovalute Gate.io</h2><p>Gate.io ha oltre 1.400 coppie di criptovalute e diversi token non fungibili.</p>
<p>È possibile scambiare diverse criptovalute come USDT, la stablecoin numero uno per capitalizzazione di mercato. In realtà, USDT è una delle criptovalute che ha molti pair. Puoi <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">scambiare USDT per BTC</a>, TRX, ADA, MATIC, ETH e molti altri.</p>
<p>La cosa positiva è che puoi utilizzare una carta di credito per acquistare USDT e convertirlo in altri token e monete. A <a href="https://www.gate.io/buy_crypto?type=buy" target="_blank">acquistare USDT utilizzando la carta di credito</a> o bonifico bancario, clicchi su “Comprare Criptovaluta” e selezioni un metodo di pagamento.</p>
<p>Conclusione<br>In sintesi, il Dipartimento dei Servizi Finanziari di New York (NYDFS) sta indagando sulla società Paxos per verificare se rispetta la normativa criptata rilevante. Già Paxos ha annunciato che cesserà di emettere BUSD con effetto dal 21 febbraio 2023. Oltre a BUSD, Paxos ha altri token, cioè Paxos Dollar (USDP), USDP e <a href="/price/pax-gold-paxg" rel="nofollow noopener noreferrer" target="_blank">PAX Oro</a> (PAXG).</p>
<h2 id="h2-Domande20frequenti20su20Paxos586743"><a name="Domande frequenti su Paxos" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Paxos</h2><h3 id="h3-Cos20Paxos20Trust20Company997103"><a name="Cos’è Paxos Trust Company?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Paxos Trust Company?</h3><p>Paxos Trust Company è un emittente regolamentato con sede negli Stati Uniti di <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a>, Paxos Dollar (USDP) and <a href="/price/pax-gold-paxg" rel="nofollow noopener noreferrer" target="_blank">PAX Oro</a> (PAXG). Possiede anche iBit, un exchange di criptovalute registrato negli Stati Uniti, con altre sedi a Londra e Singapore.</p>
<h3 id="h3-Perch20Paxos20ha20emesso20BUSD730885"><a name="Perché Paxos ha emesso BUSD?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché Paxos ha emesso BUSD?</h3><p>Paxos Trust Company ha collaborato con Binance per emettere <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a> (BUSD). BUSD è una stablecoin che è agganciata all’1:1 con il dollaro degli Stati Uniti ed è scambiata su molte criptovalute.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>