Q2hlIGNvc1wnw6ggVVNEQz8gQ2lyY2xlIGRpdmVudGEgcHViYmxpY28gbmVnbGkgU3RhdGkgVW5pdGku

2025-06-18, 06:33

<p><img src="https://gimg2.gateimg.com/image/crcl202506181431111166811967.png" alt="">
</p><p>Il 5 giugno 2025, la Borsa di New York ha accolto una pietra miliare nella finanza cripto. Circle Internet Financial, l’emittente del secondo stablecoin più grande al mondo, USDC (codice azionario: CRCL), ha ufficialmente quotato le proprie azioni, diventando il primo “stablecoin” quotato in borsa al mondo.</p>
<p>Nel suo primo giorno di negoziazione, il prezzo delle azioni di Circle è balzato dal prezzo di emissione di 31 USD a 69 USD all’apertura, raggiungendo un picco di 103,75 USD durante la giornata e chiudendo infine a 83,23 USD, con un aumento giornaliero del 168,48%, portando il suo valore di mercato a 18,4 miliardi USD.</p>
<h2 id="h2-La20Follia20Cripto20di20Wall20Street949574"><a name="La Follia Cripto di Wall Street" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Follia Cripto di Wall Street</h2><p>L’IPO di Circle può essere descritta come un evento fenomenale nei mercati dei capitali. Il suo multiplo di sottoscrizione ha superato le 25 volte, superando di gran lunga le aspettative del mercato. La società aveva inizialmente pianificato di emettere 24 milioni di azioni a un intervallo di prezzo di 24-26 USD, ma a causa della domanda esplosiva, ha infine emesso 34 milioni di azioni a 31 USD per azione, raccogliendo un totale di 1,05 miliardi di USD.</p>
<p>Le principali istituzioni di investimento stanno entrando nel mercato: BlackRock prevede di acquisire circa il 10% delle azioni IPO, mentre l’”Woodstock” Cathie Wood di ARK Investment Management ha investito una straordinaria somma di 373 milioni di dollari per acquistare 4,5 milioni di azioni.</p>
<p>L’aumento dei prezzi delle azioni ha anche aumentato i ritorni per i primi azionisti. China Everbright Holdings, come investitore nel 2016, ha visto il suo prezzo delle azioni salire del 34,05% nei 4 giorni di trading successivi all’annuncio della quotazione. I fondi sotto Huaxing Capital hanno anche ricevuto ritorni sostanziali grazie al loro investimento in Circle nel 2018.</p>
<h2 id="h2-USDC20Il20ponte20del20dollaro20nel20mondo20delle20criptovalute214191"><a name="USDC: Il ponte del dollaro nel mondo delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>USDC: Il ponte del dollaro nel mondo delle criptovalute</h2><p>Come prodotto principale di Circle, USDC è una stablecoin ancorata al dollaro USA con un rapporto di 1:1. Il suo valore è supportato da riserve in contante in USD e obbligazioni del Tesoro USA a breve termine, garantendo un prezzo stabile intorno a 1 USD.</p>
<p>A differenza delle criptovalute volatile come Bitcoin, gli stablecoin sono progettati specificamente per il trading, fungendo da ponte tra la finanza tradizionale e il mondo delle criptovalute.</p>
<p>A partire da giugno 2025, la capitalizzazione di mercato di USDC ha raggiunto 61,5 miliardi di USD, rappresentando circa il 29% del mercato delle stablecoin, seconda solo a <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT emesso. I suoi scenari di applicazione sono ampi:</p>
<ul>
<li>Finanza Decentralizzata (DeFi): In <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Le stablecoin dominano il volume di scambi sulla blockchain (circa il 69%), utilizzate per prestiti, fornitura di liquidità e regolamento delle negoziazioni.</li><li>Pagamenti transfrontalieri: la velocità delle transazioni raggiunge il livello dei secondi, il costo è inferiore a 1 centesimo, supportato da oltre 500 portafogli digitali e piattaforme in tutto il mondo.</li><li>Strumenti di copertura dall’inflazione nei paesi ad alta inflazione: In paesi come l’Argentina, dove il tasso di inflazione annuale supera il 200%, è diventato il modo principale per i cittadini di conservare valore.</li></ul>
<h2 id="h2-Interesse20Spesso20Una20Miniera20dOro20e20un20Rischio145819"><a name="Interesse Spesso: Una Miniera d’Oro e un Rischio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Interesse Spesso: Una Miniera d’Oro e un Rischio</h2><p>Il modello di business di Circle è semplice ed efficiente: riceve i fondi in valuta fiat dei clienti in conti di riserva, conia l’importo corrispondente di USDC e poi guadagna interessi attraverso gli attivi nei conti di riserva.</p>
<p>Nel 2024, il fatturato totale di Circle ha raggiunto 1,676 miliardi di dollari, con il 99,1% proveniente dai redditi da riserva. Queste riserve sono principalmente investite in obbligazioni del Tesoro degli Stati Uniti e fondi del mercato monetario. In un ambiente di tassi d’interesse elevati, questo modello di “trading di arbitraggio delle obbligazioni del Tesoro” ha portato profitti sostanziali a Circle.</p>
<p>Tuttavia, questo modello comporta anche dei rischi. Circle ha ammesso nel suo prospetto: “I tassi di interesse sono sia una fonte di reddito che un hotspot di rischio.” Se la Federal Reserve dovesse abbassare i tassi di interesse, una diminuzione dell’1% potrebbe ridurre il reddito dell’azienda fino a $441 milioni.</p>
<p>Il problema più grave è il rischio di una corsa agli sportelli. Durante la crisi della Silicon Valley Bank nel marzo 2023, Circle ha subito un temporaneo disaccoppiamento di USDC a causa di 3,3 miliardi di dollari di riserve coinvolte nel fallimento della banca, innescando riscatti di panico nel mercato. Un economista vincitore del Premio Nobel ha ulteriormente avvertito che le stablecoin appartengono a un nuovo tipo di sistema bancario ombra e potrebbero diventare un “rinoceronte grigio” per il sistema finanziario.</p>
<h2 id="h2-Regolamentazione20e20Conformit20LInasprimento20delle20Stablecoin405380"><a name="Regolamentazione e Conformità: L’Inasprimento delle Stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione e Conformità: L’Inasprimento delle Stablecoin</h2><p>Poco prima dell’IPO di Circle, è stato raggiunto un’importante svolta nel quadro normativo globale. Il 19 maggio 2025, il Senato degli Stati Uniti ha approvato il “Guidance and Establishment of a National Innovation Act for U.S. Stablecoins” (GENIUS Act), diventando il primo quadro normativo a livello federale per le stablecoin negli Stati Uniti.</p>
<p>Due giorni dopo, il Consiglio Legislativo di Hong Kong ha approvato il “Stablecoin Bill”, stabilendo un sistema di licenze per gli emittenti di stablecoin fiat. Entrambi i progetti di legge entreranno in vigore il 1° agosto.</p>
<p>Circle sta anche adottando misure proattive per la conformità. Il 28 maggio 2025, in conformità con un’ordinanza del tribunale, Circle ha congelato due <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> portafogli legati allo scandalo della moneta meme Libra argentina, che coinvolge fondi per un totale di 58 milioni di USDC. Il caso riguarda controversie promozionali che coinvolgono il presidente argentino ed è previsto che venga discusso il 9 giugno.</p>
<h2 id="h2-Trasparenza20nelle20Operazioni20La20Fondazione20di20Fiducia20degli20Stablecoin370999"><a name="Trasparenza nelle Operazioni: La Fondazione di Fiducia degli Stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trasparenza nelle Operazioni: La Fondazione di Fiducia degli Stablecoin</h2><p>Il USDC di Circle stabilisce un benchmark per la trasparenza nel settore. I suoi attivi di riserva sono verificati in modo indipendente dalle Big Four ogni mese, e un cruscotto pubblico è disponibile per mostrare la composizione delle riserve in tempo reale.</p>
<p>Questa operazione trasparente è in netto contrasto con le banche tradizionali. La maggior parte dei dollari nelle banche tradizionali è supportata solo da un portafoglio di prestiti, mentre ogni USDC è supportato da un equivalente ammontare di attività in dollari altamente liquide.</p>
<p>L’analista crypto Omar ha messo in discussione la valutazione di Circle, tuttavia, il voto entusiasta dei mercati finanziari ha fornito la risposta: il fondo di riserva USDC gestito da BlackRock ha superato i 50 miliardi di dollari.</p>
<h2 id="h2-Prospettive20future940985"><a name="Prospettive future" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future</h2><p>Con l’”Genius Act” degli Stati Uniti e la “Regolamentazione delle Stablecoin” di Hong Kong che entreranno in vigore il 1° agosto, il quadro normativo per le stablecoin sta rapidamente prendendo forma. L’ordine finanziario del mondo reale sta venendo ricostruito sulla blockchain, e USDC è diventato un pilastro indispensabile di questo.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l’uso di tutti o di una parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="5">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>