Q2lyY2xlIHNpIGFmZmlkYSBhIHVuYSByaXNlcnZhIGRpIGRlbmFybyBkYSAxIG1pbGlhcmRvIGRpIGRvbGxhcmkgaW4gbWV6em8gYWxsYSBzY2Fyc2l0w6AgZGkgb2ZmZXJ0YSBlIGFsbGEgZmVyb2NlIGNvbmNvcnJlbnph

2023-08-22, 12:57

<p><img src="https://gimg2.gateimg.com/image/article/1692707523RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-Troppo20lungo20non20letto845695"><a name="Troppo lungo; non letto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Troppo lungo; non letto</h2><p>La quota di mercato e la capitalizzazione di USDC sono diminuite dall’inizio del 2023.</p>
<p>PYUSD è probabile che dia a USDC la più grande concorrenza una volta che arriva sul mercato.</p>
<p>Il CEO di Circle ha promesso di riattivare il potenziale di USDC attraverso partnership e crescita del mercato.</p>
<h2 id="h2-Introduzione554645"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le aziende che affrontano una forte concorrenza dovrebbero creare strategie abilitanti per mantenere la propria vitalità e espandere le proprie operazioni. Non c’è dubbio che il settore delle criptovalute sia pieno di concorrenza a causa della mancanza di regolamentazione. In questo articolo, esploreremo le misure che Circle, un emittente di stablecoin americano, sta adottando per affrontare l’aumento della concorrenza nel settore.</p>
<p>Circle ha messo da parte 1 miliardo di dollari di riserve in contanti per affrontare eventuali minacce di mercato in seguito alla diminuzione della sua offerta circolante. Circle, nota per la sua stablecoin USDC, sta affrontando una crescente concorrenza dall’industria della tecnologia cripto e dai giocatori della finanza tradizionale.</p>
<p>PayPal, che ha recentemente lanciato la sua stablecoin PYUSD, ha creato molta concorrenza per Circle. Sappiamo già che il USDC di Circle, la seconda stablecoin più grande per capitalizzazione di mercato, sta competendo con altre stablecoin forti come <a href="/price/binance-usd-busd" rel="nofollow noopener noreferrer" target="_blank">Binance USD</a> (BUSD), <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USD (USDT), DAI, <a href="/price/trueusd-tusd" rel="nofollow noopener noreferrer" target="_blank">TrueUSD</a>, <a href="/price/frax-frax" target="_blank" class="blog_inner_link">FRAX</a> e <a href="/price/usdd-usdd" rel="nofollow noopener noreferrer" target="_blank">USDD</a>, tra gli altri. La seguente tabella elenca le principali stablecoin.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1692708971Circle 1.png" alt=""><br>Top 6 stablecoins - <a href="https://www.coingecko.com/en/categories/stablecoins" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Come indica la tabella, USDC con una capitalizzazione di mercato di $25,991,517,319, si classifica al secondo posto tra le stablecoin. Tuttavia, il mercato di Circle si è ridotto nei sette mesi scorsi.</p>
<p>Jeremy Allaire, CEO di Circle, ha confermato durante un’intervista con Bloomberg che c’è una forte concorrenza nel settore. Ha detto: “Mi aspetto che vedrai molte, molte, non solo società di pagamento su internet, ma anche tutti i tipi di società di servizi finanziari e altri iniziare a essere più coinvolti in questo. È fantastico avere questa nuova concorrenza. Credo che porterà sempre più aziende nel campo.”</p>
<p>In sostanza, l’azienda Circle Fintech utilizzerà la riserva di denaro di 1 miliardo di dollari per coprire eventuali sviluppi negativi nel settore. Attualmente, l’azienda si concentra sull’espansione del proprio flusso di entrate e sulla promozione di una maggiore adozione di USDC. Gran parte delle sue entrate proviene dagli interessi guadagnati dagli asset di investimento che sostengono USDC, compresi i titoli di Stato a breve termine e i depositi in dollari.</p>
<p>Secondo Allaire, molte altre società introdurranno le loro stablecoin seguendo l’esempio di PayPal, il che probabilmente aumenterà la concorrenza e diminuirà la quota di mercato di Circle. Tuttavia, ha anche osservato che molte stablecoin crolleranno in futuro dopo che vari regolatori introdurranno regolamentazioni criptate.</p>
<p>Leggi anche: <a href="https://www.gate.io/de/hot_news/detail/88/what-you-need-to-know-when-buying-bitcoin-with-paypal" target="_blank">Cosa devi sapere quando acquisti Bitcoin con PayPal</a></p>
<h2 id="h2-Declino20del20mercato20USDC616074"><a name="Declino del mercato USDC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Declino del mercato USDC</h2><p>Sebbene Circle abbia registrato un profitto durante il primo semestre di quest’anno, principalmente dagli interessi guadagnati, la quota di mercato di USDC è diminuita nei mesi scorsi. Ad esempio, la sua quota di mercato è scesa da 45 miliardi di dollari all’inizio del 2023 a 26 miliardi di dollari a luglio. Ci sono diverse ragioni che hanno contribuito alla diminuzione della quota di mercato di USDC.</p>
<p>È importante notare che l’offerta circolante di USDC è diminuita di oltre il 53% da giugno 2022, quando aveva una capitalizzazione di mercato di $56 miliardi. Purtroppo, la sua quota di mercato è anche diminuita al 21%. Ciò significa che c’è stato un calo nel numero di individui e istituzioni che promuovono i pagamenti in USDC.</p>
<p>Secondo il CEO di Circle, Allaire, il principale fattore che ha contribuito alla diminuzione della fornitura circolante di USDC è stato il ritiro di Binance dalla moneta a favore della propria stablecoin, <a href="/price/binance-usd-busd" target="_blank" class="blog_inner_link">Binance USD</a> (BUSD), attualmente classificata come la quarta migliore stablecoin in base alla capitalizzazione di mercato.</p>
<p>In secondo luogo, la stablecoin USDC è stata <a href="https://www.gate.io/blog_detail/2303/svb-crash-caused-the-butterfly-effect-in-the-crypto-market-what-should-investors-do" target="_blank">colpito dalla bancarotta di Silicon Valley Bank</a> durante il primo trimestre dell’anno. In realtà, le riserve di 3,3 miliardi di dollari USDC di Circle erano bloccate presso la Silicon Valley Bank, una delle banche crypto-friendly, che i regolatori statunitensi hanno chiuso, causando il distacco dell’USDC.</p>
<p>Dopo la crisi bancaria degli Stati Uniti e la disconnessione di USDC, la sua capitalizzazione di mercato è diminuita di quasi la metà. Questo perché molti investitori hanno perso fiducia a causa della sua disconnessione.<br>Inoltre, la repressione delle attività criptovalutarie negli Stati Uniti ha avuto un impatto negativo sulle prestazioni di mercato di USDC.</p>
<h2 id="h2-Il20CEO20di20Circle2020ancora20ottimista20su20USDC20e20altri20stablecoin582256"><a name="Il CEO di Circle è ancora ottimista su USDC e altri stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il CEO di Circle è ancora ottimista su USDC e altri stablecoin</h2><p>Secondo il CEO di Circle, c’è ancora molta speranza nelle stablecoin nonostante l’aumento della concorrenza. Al momento, Circle mira ad esplorare nuovi flussi di reddito e ad aumentare l’adozione globale di USDC per frenare la diminuzione della sua quota di mercato. Per migliorare la sua espansione globale, Circle sta lavorando alla creazione di diverse partnership e all’aumento della trasparenza attraverso tempestivi rapporti di mercato.</p>
<p>Allo stesso modo, l’azienda mira a rimanere adattabile all’evoluzione del contesto normativo. Per questo motivo si sta concentrando sul miglioramento dei propri standard per posizionarsi favorevolmente per la crescita globale. Nonostante le sue prestazioni finanziarie negative degli ultimi sette mesi, Circle ha beneficiato <a href="https://www.gate.io/blog_detail/1804/key-lessons-from-the-collapse-of-ftx-and-the-implosion-of-ftt" target="_blank">dal crollo di FTX</a> e <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD che ha potenziato la crescita della sua quota di mercato in quel momento.</p>
<h2 id="h2-PYUSD20di20PayPal20in20competizione20con20USDC20di20Circle706619"><a name="PYUSD di PayPal in competizione con USDC di Circle" class="reference-link"></a><span class="header-link octicon octicon-link"></span>PYUSD di PayPal in competizione con USDC di Circle</h2><p>In precedenza, abbiamo detto che il calo di USDC è dovuto a un aumento della concorrenza, tra gli altri fattori. Infatti, c’è stato un aumento del numero di stablecoin sul mercato. Oltre a <a href="https://www.gate.io/blog_detail/3034/daily-news-paypal-launched-a-us-dollar-stablecoin-pyusd-monetary-authority-of-singapore-supports-innovation-in-web3-industry-btc-volatility-dropped-to-historical-lows" target="_blank">PYUSD di PayPal</a>, <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> L’algoritmo GHO di ‘s e il First Digital USD (FDUSD) supportato da Binance sono recentemente entrati sul mercato.</p>
<p>Tuttavia, Circle si aspetta di ricevere la maggior concorrenza da parte di PYUSD. PayPal insiste sul fatto che la sua stablecoin sarà completamente garantita da depositi in dollari statunitensi. Inoltre, le persone potranno comprarla e venderla tramite la sua applicazione.</p>
<p>Inoltre, le persone utilizzeranno PYUSD per effettuare pagamenti peer-to-peer. Possono trasferire la moneta da e verso altri portafogli digitali adatti. In modo più interessante, PYUSD supporterà tutte le valute che PayPal ha. Ciò significa che gli utenti di PYUSD possono convertire la moneta in una qualsiasi di queste valute nazionali.</p>
<p>Dan Schulman, presidente e CEO di PayPal, ha menzionato il motivo principale per il lancio della propria stablecoin. Ha detto: “Il passaggio alle valute digitali richiede uno strumento stabile che sia nativo digitalmente e facilmente collegato alle valute fiat come il dollaro statunitense.”</p>
<p>Paxos, un’azienda con sede a New York che offre infrastrutture blockchain regolamentate a vari progetti cripto, è l’emittente di PYUSD che esiste <a href="https://www.gate.io/learn/articles/what-is-ethereum/42" target="_blank">sulla blockchain di Ethereum</a>. Già nel 2022, PayPal ha ottenuto la sua licenza BitLicense di New York, che consente ai suoi clienti di acquistare e vendere criptovalute.</p>
<p>La decisione di PayPal di sviluppare la propria stablecoin non è sorprendente considerando che la sua attività include l’acquisto, la vendita e il trasferimento di criptovalute come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, ETH, <a href="https://www.gate.io/price/litecoin-ltc" target="_blank">Litecoin</a> e <a href="https://www.gate.io/price/bitcoin-cash-bch" target="_blank">Bitcoin Cash</a>.</p>
<h2 id="h2-Conclusion836144"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Circle ha messo da parte $1 miliardo di riserve per proteggere la stablecoin USDC contro sviluppi di mercato negativi. La principale minaccia che la USDC sta affrontando è la concorrenza da altre stablecoin che includono <a href="https://www.gate.io/price/tether-usdt" target="_blank">Tether USDT</a>, <a href="https://www.gate.io/price/binance-usd-busd" target="_blank">BUSD</a>, PYUSD e <a href="https://www.gate.io/price/dai-dai" target="_blank">DAI</a>. Tuttavia, Circle sta mettendo in atto misure per affrontare tale concorrenza.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-dai/178" target="_blank">Che cos’è Dai? Tutto ciò che devi sapere su DAI</a></p>
<h2 id="h2-Domande20frequenti20su20USDC49746"><a name="Domande frequenti su USDC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su USDC</h2><h3 id="h3-Circle2020una20societ20di20criptovalute314697"><a name="Circle è una società di criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Circle è una società di criptovalute?</h3><p>Circle è una società Fintech e cripto che possiede e gestisce il <a href="https://www.gate.io/price/usd-coin-usdc" target="_blank">USDC</a> stablecoin. Offre inoltre la sua infrastruttura blockchain a progetti crittografici che mirano a sfruttare le blockchain pubbliche e le stablecoin per i pagamenti online.</p>
<h3 id="h3-Circle2020una20stablecoin835263"><a name="Circle è una stablecoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Circle è una stablecoin?</h3><p>Circle è una società fintech che ha un’infrastruttura blockchain valida che altri progetti criptovaluta possono utilizzare. Possiede USDC, una stablecoin ancorata al dollaro statunitense. Pertanto, Circle non è una stablecoin.</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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>