SWwgcHJpbW8gSVBPIGRpIHN0YWJsZWNvaW4gw6ggcXVpISBDaXJjbGUgc2kgcXVvdGEgYWwgTllTRSwgcmFjY29nbGllbmRvIDEsMSBtaWxpYXJkaSBkaSBkb2xsYXJp

2025-06-05, 09:51

<p><img src="https://gimg2.gateimg.com/image/cir202506051750221120324714.png" alt="">
</p><p>Oggi (5 giugno 2025), il gigante globale delle stablecoin Circle Internet Group ha ufficialmente fatto il suo ingresso alla Borsa di New York, con il codice azionario CRCL, diventando il primo emittente di stablecoin al mondo a completare un’IPO. L’azienda ha emesso 34 milioni di azioni a un prezzo di $31 per azione, superando il precedente intervallo di prezzo previsto di $27-28, con un importo totale di raccolta fondi che ha raggiunto $1,1 miliardi e una valutazione che è schizzata a $6,9 miliardi (fino a $8,1 miliardi completamente diluiti). Questa quotazione non è solo un traguardo per Circle dopo sette anni di impegno, ma segna anche l’ingresso ufficiale delle stablecoin nel mercato dei capitali mainstream.</p>
<h2 id="h2-Sovrascrizione20di202520volte20fiducia20del20mercato20dietro20gli20acquisti20istituzionali177479"><a name="Sovrascrizione di 25 volte, fiducia del mercato dietro gli acquisti istituzionali." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sovrascrizione di 25 volte, fiducia del mercato dietro gli acquisti istituzionali.</h2><p>Il processo di IPO di Circle può essere descritto come un banchetto di domanda. Inizialmente, era previsto emettere 24 milioni di azioni a un prezzo di $24-26, ma a causa dell’elevato entusiasmo degli investitori, l’emissione finale è aumentata a 34 milioni di azioni, con il prezzo che è salito a $31. Gli ordini di sottoscrizione hanno superato le azioni disponibili di 25 volte, con giganti come BlackRock (che prevede di sottoscrivere il 10% delle azioni) e l’ARK Investment Management di “Cathie Wood” (intenzionata a sottoscrivere $150 milioni) che entrano in gioco. Il team di sottoscrizione è guidato da JPMorgan Chase, Citigroup e Goldman Sachs, e hanno ricevuto ulteriori 5,1 milioni di azioni in diritti di sovrallocazione.</p>
<p>Il mercato è <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">ottimismo</a> verso CRCL deriva da due logiche fondamentali:</p>
<ol>
<li>Barriere di conformità: Circle detiene più licenze, inclusa la BitLicense di New York, subisce audit regolari da parte delle Big Four e costruisce un fossato in mezzo a normative sempre più rigide.</li><li>Dividendi della polizza: il Senato degli Stati Uniti avanza il GENIUS Act, Hong Kong emette le regolamentazioni sulle stablecoin e il quadro normativo globale si chiarisce, accelerando l’ingresso delle istituzioni finanziarie tradizionali.</li></ol>
<h2 id="h2-LImpero20di20USDC459417"><a name="L’Impero di USDC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’Impero di USDC</h2><p>Come asset principale di Circle, lo stablecoin USD USDC ha attualmente una circolazione di 61 miliardi di dollari, che rappresenta il 29% della quota di mercato globale degli stablecoin, secondo solo a <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT (che rappresenta il 64%). Il suo modello di business è altamente focalizzato:</p>
<ul>
<li>Struttura dei ricavi: Nel 2024, il fatturato totale sarà di 1,676 miliardi di USD, il 99% proviene dagli interessi dei fondi di riserva USDC (principalmente investiti in titoli di Stato americani a breve termine e depositi bancari);</li><li>Meccanismo di condivisione dei ricavi: Secondo l’accordo con Coinbase, Circle deve condividere il 50% dei profitti rimanenti dopo aver dedotto i costi operativi con l’altra parte, portando i costi di distribuzione a rappresentare fino al 61% del reddito di riserva nel 2024.</li></ul>
<p>I punti salienti delle performance finanziarie evidenziano le caratteristiche del settore: Utile netto di 268 milioni di dollari nel 2023, che scende a 156 milioni di dollari nel 2024, principalmente influenzato dalla contrazione dei servizi di trading, ma raggiungere la redditività per due anni consecutivi è già un benchmark nello spazio crypto.</p>
<h2 id="h2-Mercato20da20mille20miliardi20di20dollari20e20rischi20del20rinoceronte20grigio20il20futuro20duplice20delle20stablecoin121137"><a name="Mercato da mille miliardi di dollari e rischi del rinoceronte grigio: il futuro duplice delle stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato da mille miliardi di dollari e rischi del rinoceronte grigio: il futuro duplice delle stablecoin</h2><p>La quotazione di Circle arriva in un momento di esplosivo crescita per l’industria delle stablecoin: la capitalizzazione di mercato globale ha superato i 250 miliardi di USD e potrebbe raggiungere i 3 trilioni di USD entro cinque anni. Il momentum di crescita è chiaro:</p>
<ul>
<li>Domanda di infrastrutture crypto: Come mezzo di scambio e riserva di valore, gli stablecoin sono l’infrastruttura principale della DeFi e dei pagamenti transfrontalieri;</li><li>Infiltrazione della finanza tradizionale: istituzioni come PayPal (PYUSD) e Fidelity stanno entrando nel mercato, promuovendo la tokenizzazione degli RWA (attività del mondo reale) e la profonda integrazione delle stablecoin.</li></ul>
<p>Ma l’ombra del rischio non può essere ignorata neanche:</p>
<ul>
<li>Sensibilità ai tassi d’interesse: Secondo il prospetto, una riduzione del tasso dell’1% da parte della Federal Reserve potrebbe comportare una diminuzione di 441 milioni di dollari nel fatturato di Circle;</li><li>Rischio di corsa alla banca: Durante la crisi della Silicon Valley Bank del 2023, Circle ha affrontato un temporaneo disallineamento di USDC a causa di 3,3 miliardi di dollari di riserve bloccate. Gli economisti avvertono che se le stablecoin evolvono in “banche ombra”, riscatti su larga scala potrebbero scatenare una svendita di Treasury statunitensi, minacciando la stabilità finanziaria.</li></ul>
<p>Quando suona la campana nella sala di negoziazione della NYSE per CRCL, un trader ha commentato: “Questa non è solo una vittoria per Circle, ma anche un punto di svolta per l’integrazione delle criptovalute nel sistema finanziario tradizionale.”</p>
<p>Poiché le riserve di USDC superano i 53 miliardi di dollari (gestite da BlackRock) e RWA accelera la sua attuazione in scenari come l’energia verde e il regolamento transfrontaliero, la quotazione di Circle potrebbe dare il via a una nuova era di allocazione globale degli asset on-chain—purché possa superare i “doppi ancore” della regolamentazione e della fiducia del mercato.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui presente non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere decisioni di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso totale o parziale 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="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>