Q2lyY2xlIGNvcnJlIHZlcnNvIGxcJ0lQTyDigJQgUHXDsiBVU0RDIHNmaWRhcmUgaWwgdHJvbm8gZGkgVGV0aGVyPw==

2025-06-03, 07:30

<p><img src="https://gimg2.gateimg.com/image/circle202506031527382162592302.png" alt="">
</p><p>L’industria delle criptovalute ha raggiunto un momento fondamentale, poiché Circle, il secondo emittente di stablecoin al mondo, ufficialmente intraprende il percorso per essere quotato alla Borsa di New York, con un doppio gioco di capitale e conformità che si svolge.</p>
<p>Il 28 maggio 2025, Circle ha presentato il suo ultimo documento di IPO alla Securities and Exchange Commission (SEC) degli Stati Uniti, pianificando di emettere 24 milioni di azioni ordinarie di Classe A a un prezzo di $24 a $26 per azione, con l’obiettivo di raccogliere fino a $624 milioni in finanziamenti.</p>
<p>Se calcolato sulla base del limite superiore dell’intervallo di prezzo, la valutazione completamente diluita di Circle raggiungerà 6,7 miliardi di USD, superando di gran lunga i 5 miliardi di USD previsti ad aprile.</p>
<p>Il gigante delle criptovalute che supporta la stablecoin USDC con un valore di mercato di 60 miliardi di dollari sarà quotato alla Borsa di New York con il codice azionario CRCL. JPMorgan, Citigroup e Goldman Sachs sono i principali sottoscrittori per questa emissione.</p>
<h2 id="h2-Colpi20di20scena20e20svolte20il20marathon20dellIPO20di20Circle120716"><a name="Colpi di scena e svolte, il marathon dell’IPO di Circle" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Colpi di scena e svolte, il marathon dell’IPO di Circle</h2><p>Il percorso per la quotazione di Circle può essere descritto come accidentato. Questo è il terzo tentativo dell’azienda di approdare sul mercato pubblico.</p>
<p>Già nel 2021, Circle ha tentato di diventare pubblica attraverso una fusione con una SPAC (Special Purpose Acquisition Company), con una valutazione che raggiungeva i 9 miliardi di dollari. Tuttavia, a causa di un controllo più rigoroso da parte della SEC, l’accordo è infine fallito alla fine del 2022.</p>
<p>Nel 2018, Circle ha mostrato interesse per il mercato pubblico ma ha incontrato un mercato ribassista delle criptovalute, con un calo della valutazione del 75%, e il piano è stato accantonato.</p>
<p>La chiave del successo di questa IPO risiede nel cambiamento dell’ambiente normativo. L’amministrazione Trump ha esplicitamente sostenuto lo sviluppo delle criptovalute, promettendo di rendere gli Stati Uniti un ‘hub globale per le criptovalute’ e accelerando l’avanzamento della legislazione sulle stablecoin.</p>
<p>Il “GENIUS Act” è stato approvato con un voto nella Commissione Bancaria del Senato, richiedendo che gli asset di riserva delle stablecoin siano coperti al 100% da contante o equivalenti di contante, aprendo la strada a aziende compliant come Circle.</p>
<h2 id="h2-Il20layout20strategico20dietro20la20valutazione20di206720miliardi20di20USD804018"><a name="Il layout strategico dietro la valutazione di 6,7 miliardi di USD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il layout strategico dietro la valutazione di 6,7 miliardi di USD</h2><p>I documenti IPO recentemente divulgati rivelano le mosse strategiche di Circle: a gennaio 2025, l’azienda ha completato un’acquisizione totale della startup tokenizzata Hashnote per 99,8 milioni di dollari.</p>
<p>La transazione include 9,9 milioni di dollari in contante e circa 2,9 milioni di azioni ordinarie di Circle, evidenziando la sua ambizione di espandersi nel mercato dei Treasury statunitensi tokenizzati.</p>
<p>I fondatori di Circle, Jeremy Allaire e Sean Neville, manterranno il controllo dell’azienda. Le loro azioni di classe B hanno cinque voti per azione, garantendo che possano ancora orientare la direzione dell’azienda dopo essere diventati pubblici.</p>
<p>Gli investitori istituzionali mostrano una forte fiducia. ARK Invest, guidata da Cathie Wood, si è impegnata ad acquistare azioni Circle per un valore di 150 milioni di dollari, diventando uno dei maggiori investimenti ancorati in questa IPO.</p>
<h2 id="h2-Guerre20delle20stablecoin20vantaggi20di20conformit20vs20dimensione20del20mercato831079"><a name="Guerre delle stablecoin, vantaggi di conformità vs dimensione del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Guerre delle stablecoin, vantaggi di conformità vs dimensione del mercato</h2><p>In quanto emittente di USDC, Circle occupa una posizione chiave nel mercato delle stablecoin:</p>
<ul>
<li>Valore di mercato di 60 miliardi di USD, il secondo stablecoin in USD più grande al mondo.</li><li>Nel maggio 2024, il volume degli scambi ha raggiunto 230,8 miliardi di USD, dimostrando una forte liquidità.</li><li>Copertura di 25 trilioni di transazioni on-chain, diventando l’infrastruttura centrale dell’ecosistema DeFi.</li></ul>
<p>Il suo concorrente <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>(USDT) continua a occupare il primo posto con un valore di mercato di 140 miliardi di USD, ma i vantaggi di conformità di Circle stanno diventando sempre più evidenti.</p>
<p>Con <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> Le controverse questioni di trasparenza differiscono, poiché Circle pubblica regolarmente prove di riserva verificate da importanti società di contabilità, ha ottenuto licenze per la trasmissione di denaro in diversi stati degli Stati Uniti e ha raggiunto importanti traguardi normativi in mercati chiave come Europa e Giappone.</p>
<p>Con il progresso del GENIUS Act, <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> affronta una maggiore pressione normativa, mentre la strategia di trasparenza di Circle potrebbe diventare un’arma chiave nella sua battaglia per la quota di mercato.</p>
<h2 id="h2-Modello20di20profitto20la20stampa20dellera20digitale500743"><a name="Modello di profitto, la “stampa” dell’era digitale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Modello di profitto, la “stampa” dell’era digitale?</h2><p>La logica commerciale degli stablecoin è piuttosto ingegnosa: dopo che gli utenti scambiano i loro dollari statunitensi per USDC, Circle investe i fondi in attivi a basso rischio come i titoli di stato statunitensi e i fondi del mercato monetario per guadagnare spread sugli interessi.</p>
<p>Durante il ciclo di alti tassi di interesse dal 2022 al 2024, i rendimenti dei Treasury statunitensi hanno superato brevemente il 5%, portando profitti sostanziali agli emittenti di stablecoin.</p>
<p>Nel 2024, Circle ha raggiunto un fatturato di 1,68 miliardi di dollari, un aumento rispetto a 1,5 miliardi di dollari nel 2023. Tuttavia, il reddito netto è diminuito da 268 milioni di dollari nel 2023 a 156 milioni di dollari.</p>
<p>Al contrario, i profitti di <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> hanno raggiunto un massimo di 13 miliardi di dollari nel 2024, superando persino la più grande società di gestione patrimoniale al mondo, BlackRock. Questo evidenzia l’importanza per Circle di espandere la scala di USDC per migliorare la redditività.</p>
<h2 id="h2-Londata20di20IPO20di20criptovalute20un20segnale20per20il20capitale20tradizionale20di20entrare323789"><a name="L’ondata di IPO di criptovalute, un segnale per il capitale tradizionale di entrare." class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ondata di IPO di criptovalute, un segnale per il capitale tradizionale di entrare.</h2><p>L’IPO di Circle è un evento fondamentale per le aziende di criptovalute che abbracciano i mercati dei capitali tradizionali. Bitwise prevede che entro il 2025 potrebbero esserci 5 aziende di criptovalute che si quotano in borsa, tra cui Kraken, Figure, Anchorage Digital e Chainalysis.</p>
<p>Questa diventerà la più grande IPO di una compagnia di criptovalute da quando Coinbase è diventata pubblica nel 2021.</p>
<p>La partnership tra Coinbase e Circle offre a quest’ultima vantaggi unici. Nel 2018, le due aziende hanno lanciato congiuntamente USDC, con Coinbase che non solo detiene partecipazioni in Circle, ma promuove anche attivamente l’applicazione di USDC attraverso la sua piattaforma.</p>
<p>Con i recenti IPO di successo di aziende di criptovalute come Galaxy Digital, la domanda di allocazione di capitale tradizionale nel settore blockchain sta accelerando la sua liberazione attraverso il canale IPO.</p>
<p>La campana nella sala di contrattazione della Borsa di New York sta per suonare per il codice CRCL. I documenti di quotazione di Circle mostrano che i fondatori dell’azienda, Jeremy Allaire e Sean Neville, manterranno il controllo dell’azienda detenendo azioni di classe B con super voto.</p>
<p>Allo stesso tempo, l’ARK Invest di Cathie Wood si è impegnata ad acquistare azioni per un valore di 150 milioni di dollari, diventando il più grande investitore ancorato in questa emissione.</p>
<p>Dopo un listing di successo, Circle diventerà la più grande azienda di criptovalute ad entrare nel mercato principale degli Stati Uniti dal 2021, quando è stata Coinbase. Le sue performance metteranno alla prova il livello di riconoscimento da parte del capitale tradizionale del modello di business delle stablecoin e influenzeranno le decisioni di listing di aziende crypto come Kraken e Figure.</p>
<p>La seconda metà della guerra delle stablecoin cambierà il panorama competitivo con il rifornimento di munizioni nel mercato dei capitali.</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 d’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 l’Accordo dell’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>