Q29zYSBzb25vIGxlIHN0YWJsZWNvaW4gY3J5cHRvPyBHbGkgb2JpZXR0aXZpIHByaW5jaXBhbGkgZGlldHJvIGlsIHByb2dldHRvIGRpIGxlZ2dlIHN1bGxlIHN0YWJsZWNvaW4gbmVnbGkgU3RhdGkgVW5pdGk=

2025-06-05, 07:38

<p><img src="https://gimg2.gateimg.com/image/usdc202506051536511109105063.png" alt="">
</p><p>Il 29 maggio 2025, presso il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Conferenza a Las Vegas, USA, il Vicepresidente Vance ha annunciato a 50 milioni di detentori di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> americani: “Le stablecoin ancorate al dollaro, specialmente dopo l’entrata in vigore del GENIUS Act, beneficeranno solo l’economia americana e il dollaro.”</p>
<p>In questo momento, il Congresso degli Stati Uniti sta portando avanti con vigore due progetti di legge innovativi sulla regolamentazione delle stablecoin: il “STABLE Act” della Camera e il “GENIUS Act” del Senato. L’obiettivo principale di questi due progetti di legge è quello di stabilire un quadro normativo federale per le stablecoin legate al dollaro, il cui valore di mercato è salito quasi a 250 miliardi di dollari.</p>
<h2 id="h2-Che20cos20una20stablecoin274627"><a name="Che cos’è una stablecoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è una stablecoin?</h2><p>Una stablecoin è un tipo speciale di criptovaluta il cui obiettivo di design principale è mantenere un valore stabile. A differenza degli asset crittografici volatili come Bitcoin, le stablecoin sono tipicamente collegate al valore di valute fiat come il dollaro statunitense o a beni fisici come l’oro, mantenendo un rapporto di cambio 1:1 attraverso meccanismi specifici.</p>
<p>Secondo il meccanismo di garanzia, le stablecoin sono principalmente suddivise in tre categorie:</p>
<ul>
<li>Stablecoin fiat: come USDT, USDC, sono garantite 1:1 da contante o equivalenti in dollari statunitensi provenienti da conti bancari.</li><li>Stablecoin di prodotto: come <a href="/price/pax-gold-paxg" rel="nofollow noopener noreferrer" target="_blank">PAX Gold</a> (PAXG), ogni token rappresenta la proprietà di un’oncia di oro fisico.</li><li>Stablecoin supportate da criptovalute: come DAI di MakerDAO, generate attraverso l’over-collateralization di criptovalute come Ethereum.</li></ul>
<p>Il funzionamento delle stablecoin si basa su tre principali meccanismi di ancoraggio: posizioni di debito collateralizzate (gli utenti bloccano collaterale per generare stablecoin), meccanismi di arbitraggio (i partecipanti al mercato comprano e vendono differenze di prezzo per mantenere il peg) e offerta elastica (algoritmi regolano l’offerta totale di token per influenzare il prezzo).</p>
<p>Grazie alla loro stabilità, le stablecoin sono diventate la pietra angolare del trading di criptovalute, supportando più di due terzi delle transazioni in criptovalute, con un volume di scambi che raggiungerà i 28 trilioni di dollari nel 2024, superando il totale delle transazioni di Visa e Mastercard.</p>
<h2 id="h2-Il20framework20centrale20dei20progetti20di20legge20STABLE20e20GENIUS408962"><a name="Il framework centrale dei progetti di legge STABLE e GENIUS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il framework centrale dei progetti di legge STABLE e GENIUS</h2><p>Il 19 maggio 2025, il Senato degli Stati Uniti ha approvato la legislazione procedurale del “GENIUS Act” con un voto di 66 a 32, aprendo la strada a un voto finale. Anche il “STABLE Act” della Camera dei Rappresentanti sta progredendo simultaneamente.</p>
<p>Sebbene ci siano differenze nei dettagli tra i due progetti di legge, essi costruiscono congiuntamente il nucleo del quadro normativo per le stablecoin:</p>
<h3 id="h3-Restrizioni20dellemittente252283"><a name="Restrizioni dell’emittente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Restrizioni dell’emittente</h3><p>Solo tre tipi di entità possono emettere stablecoin: sussidiarie di istituzioni di deposito assicurate, entità non bancarie approvate dall’OCC e entità qualificate chartered dallo stato.</p>
<h3 id="h3-requisito20di20riserva2011705124"><a name="requisito di riserva 1:1" class="reference-link"></a><span class="header-link octicon octicon-link"></span>requisito di riserva 1:1</h3><p>Tutti gli stablecoin devono essere supportati al 100% da attivi altamente liquidi come contante in USD, depositi a vista e titoli di Stato USA a breve termine che scadono entro 93 giorni, e un rapporto pubblico mensile sulla composizione delle riserve deve essere certificato dal CEO e dal CFO.</p>
<h3 id="h3-Divieto20di20pagamenti20di20interessi149501"><a name="Divieto di pagamenti di interessi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Divieto di pagamenti di interessi</h3><p>Per prevenire che gli stablecoin si evolvano in sostituti dei depositi bancari, entrambe le leggi vietano di pagare interessi ai detentori.</p>
<h3 id="h3-Quadro20normativo20a20doppio20strato207468"><a name="Quadro normativo a doppio strato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quadro normativo a doppio strato</h3><p>Le normative federali e statali coesistono: i framework normativi statali devono essere “sostanzialmente equivalenti” (GENIUS) o “soddisfare o superare” (STABLE) gli standard federali, e il Tesoro ha l’autorità di porre il veto sulle certificazioni statali.</p>
<h3 id="h3-Chiarire20gli20attributi20legali836240"><a name="Chiarire gli attributi legali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Chiarire gli attributi legali</h3><p>Il disegno di legge modifica la Legge sui Titoli per chiarire che le stablecoin conformi non sono classificate come “titoli”, escludendole così dalla giurisdizione della SEC; il GENIUS Act le esclude ulteriormente dalla definizione di “merci”, evitando l’intervento della CFTC.</p>
<h2 id="h2-I20due20motori20dellegemonia20del20dollaro20e20della20digestione20del20debito20statunitense971797"><a name="I due motori dell’egemonia del dollaro e della digestione del debito statunitense" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I due motori dell’egemonia del dollaro e della digestione del debito statunitense</h2><p>La spinta degli Stati Uniti per la regolamentazione delle stablecoin non è una coincidenza. Dietro il disegno di legge ci sono due obiettivi strategici fondamentali:</p>
<h3 id="h3-Ristrutturare20legemonia20del20dollaro20digitale722580"><a name="Ristrutturare l’egemonia del dollaro digitale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ristrutturare l’egemonia del dollaro digitale</h3><p>La proporzione del dollaro statunitense nelle riserve valutarie globali è scesa al livello più basso dal 1995 (57,8% entro la fine del 2024), e molti paesi stanno cercando di bypassare i pagamenti in dollari statunitensi nel commercio bilaterale.</p>
<p>La stablecoin in dollari USA è diventata uno strumento potente per l’espansione a basso costo dell’influenza: la circolazione globale di ogni stablecoin conforme sta ampliando gli scenari d’uso del dollaro. Il Segretario al Tesoro Basent ha dichiarato candidamente: “Utilizzeremo le stablecoin per mantenere la posizione del dollaro come principale valuta di riserva mondiale.”</p>
<h3 id="h3-Assorbire20una20massiccia20emissione20di20obbligazioni20del20Tesoro20degli20Stati20Uniti948928"><a name="Assorbire una massiccia emissione di obbligazioni del Tesoro degli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Assorbire una massiccia emissione di obbligazioni del Tesoro degli Stati Uniti</h3><p>Il rapporto della Standard Chartered Bank prevede: Entro il 2028, l’emissione di stablecoin raggiungerà i 2 trilioni di dollari, portando a una domanda aggiuntiva di 1,6 trilioni di dollari per l’acquisto di titoli di Stato americani a breve termine—“sufficiente per assorbire tutta l’emissione di titoli di Stato a breve termine durante il secondo mandato di Trump.”</p>
<p>Entro il 2024, gli emittenti di stablecoin sono diventati i terzi maggiori acquirenti di obbligazioni a breve termine del Tesoro statunitense. Solo USDT detiene 98 miliardi di USD in obbligazioni statunitensi. Il senatore repubblicano Bill Hagerty prevede ulteriormente che entro il 2030, gli emittenti di stablecoin diventeranno i maggiori detentori di obbligazioni del Tesoro statunitense a livello mondiale.</p>
<h2 id="h2-Rischio20Potenziale452316"><a name="Rischio Potenziale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rischio Potenziale</h2><h3 id="h3-6620trilioni20di20deflusso20di20depositi20nellindustria20bancaria553448"><a name="$6,6 trilioni di deflusso di depositi nell’industria bancaria" class="reference-link"></a><span class="header-link octicon octicon-link"></span>$6,6 trilioni di deflusso di depositi nell’industria bancaria</h3><p>Secondo un rapporto di Bank of America Securities: le efficienti funzioni di pagamento delle stablecoin e le capacità di prestito della DeFi potrebbero portare a un deflusso di depositi di 6,6 trilioni di dollari dal sistema bancario tradizionale, con le banche di piccole e medie dimensioni che sarebbero le più colpite.</p>
<p>L’Associazione Americana dei Banchieri Comunitari Indipendenti avverte: L’uscita di fondi dalle banche comunitarie influenzerà i settori economici chiave: forniscono il 60% dei prestiti alle piccole imprese e l’80% dei prestiti agricoli a livello nazionale.</p>
<h3 id="h3-La20corsa20digitale20minaccia20la20stabilit20finanziaria780885"><a name="“La corsa digitale” minaccia la stabilità finanziaria" class="reference-link"></a><span class="header-link octicon octicon-link"></span>“La corsa digitale” minaccia la stabilità finanziaria</h3><p>La Banca dei Regolamenti Internazionali avverte: i deflussi di stablecoin potrebbero influenzare direttamente il mercato dei Treasury USA—Una vendita di Treasury da 3,5 miliardi di dollari è sufficiente a far salire i rendimenti di 6-8 punti base, innescando una reazione a catena.</p>
<p>L’evento di disaccoppiamento dell’USDC nel marzo 2023 è stato un precursore: quando Circle ha annunciato che le sue riserve di 3,3 miliardi di dollari erano detenute presso la Silicon Valley Bank, ha immediatamente scatenato un’ondata di panico da riscatto.</p>
<h3 id="h3-Ricostruzione20del20valore20del20sistema20di20pagamento141143"><a name="Ricostruzione del valore del sistema di pagamento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ricostruzione del valore del sistema di pagamento</h3><p>Il tradizionale “modello di pagamento a cinque parti” (Visa, MasterCard, ecc.) sta affrontando una disruption. I sostenitori della tecnologia blockchain affermano che i costi di transazione delle stablecoin possono essere inferiori a $0,01 per transazione, il che è quasi trascurabile rispetto al tasso di commissione di 300 punti base delle carte di credito.</p>
<h2 id="h2-Prospettive20future106919"><a name="Prospettive future" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettive future</h2><p>Poiché l’amministrazione Trump ha reso “la firma del progetto di legge sulle stablecoin prima di agosto” una priorità, Wall Street ha iniziato a riposizionarsi. Berkshire Hathaway, guidata da Buffett, ha ridotto significativamente le sue partecipazioni nelle azioni bancarie statunitensi nel primo trimestre, uscendo completamente dalla sua posizione in Citigroup.</p>
<p>Deutsche Bank prevede che la legislazione darà vita a un ecosistema di stablecoin in dollari regolamentato prima di agosto, portando le stablecoin nel mainstream delle valute. Quando gli emittenti di stablecoin detengono 2 trilioni di dollari in attivi di riserva e 6,6 trilioni di dollari in depositi bancari stanno affrontando la migrazione, la struttura di potere del sistema finanziario viene silenziosamente ristrutturata sulla blockchain.</p>
<p>La stablecoin in dollari statunitensi è sia uno strumento per gli Stati Uniti per consolidare la propria egemonia finanziaria sia una spada di Damocle che pende sulle banche tradizionali — e tutto questo setterà il tono nell’ultima partita legislativa nei prossimi mesi.</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 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 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>