UGVyY2jDqSBsXCdvcm8gc3RhIGF1bWVudGFuZG8gbWVudHJlIGlsIEJpdGNvaW4gbm9uIHNlZ3VlPw==

2025-06-05, 11:23

<p><img src="https://gimg2.gateimg.com/image/btc202506051920056074257330.png" alt="">
</p><p>All’inizio di giugno 2025, i prezzi internazionali dell’oro sono aumentati a un massimo storico di $3430 all’oncia, con un incremento dell’anno fino ad oggi di oltre il 30%. Nel frattempo, il Bitcoin, noto come “oro digitale”, ha mostrato fluttuazioni al ribasso, evidenziando una performance debole. Questa divergenza riflette una nuova teoria dei giochi del capitale globale nel contesto del ciclo di riduzione dei tassi d’interesse della Federal Reserve e delle incertezze geopolitiche.</p>
<h2 id="h2-La20logica20macroeconomica20dellaumento20dei20prezzi20delloro356593"><a name="La logica macroeconomica dell’aumento dei prezzi dell’oro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La logica macroeconomica dell’aumento dei prezzi dell’oro</h2><ol>
<li>Aumento degli acquisti di oro da parte delle banche centrali e de-dollarizzazione del dollaro: le banche centrali di tutto il mondo stanno aumentando le loro riserve auree a un ritmo senza precedenti, con le banche centrali di Cina, India e Russia che mediamente acquistano oltre 1.000 tonnellate all’anno negli ultimi tre anni. Questo riflette preoccupazioni sistemiche sulla credibilità del dollaro: azioni come il congelamento delle riserve di cambio estero della Russia da parte degli Stati Uniti hanno spinto i paesi a ridurre la quota di riserve in dollari dal 60% nel 2022 al 57% attuale. L’oro è diventato la “politica” definitiva quando il credito sovrano collassa.</li><li>Riduzioni dei tassi della Federal Reserve e debolezza del dollaro: lo strumento CME FedWatch mostra che la probabilità di un taglio dei tassi a settembre ha raggiunto il 100%. Il calo dei tassi di interesse indebolisce direttamente l’attrattiva del dollaro, mentre l’oro quotato in dollari guadagna slancio di apprezzamento naturale. I dati storici indicano una significativa correlazione negativa tra oro e tassi di interesse: in un ambiente di tassi di interesse bassi, i rendimenti obbligazionari diminuiscono e i fondi sono più inclini a <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> in oro, che non rende ma preserva il valore.</li><li>Arbitraggio tecnico attivato da aspettative tariffarie: Dopo la vittoria di Trump, le preoccupazioni sui dazi all’importazione sui metalli preziosi sono aumentate nel mercato. I trader statunitensi si sono precipitati a “fare scorta” di oro spot, causando una differenza temporanea superiore a $70/oncia tra i futures sull’oro COMEX e il prezzo dell’oro di Londra. Gli arbitraggisti di mercato incrociato sono accorsi: acquistando oro fisico a Londra per spedirlo a New York mentre accorciavano i futures per bloccare i profitti. Nel giro di tre mesi, le scorte d’oro COMEX sono aumentate del 101% e i prezzi dei futures sono stati continuamente spinti verso l’alto.</li></ol>
<h2 id="h2-La20differenziazione20tra20attivit20rifugio20e20attivit20a20rischio482885"><a name="La differenziazione tra attività rifugio e attività a rischio." class="reference-link"></a><span class="header-link octicon octicon-link"></span>La differenziazione tra attività rifugio e attività a rischio.</h2><ul>
<li>Il vantaggio delle “due attribuzioni” dell’oro: a differenza delle criptovalute, l’oro ha sia proprietà di investimento che di consumo: la domanda di gioielli in oro rappresenta il 48% della domanda annuale globale, mentre le applicazioni tecnologiche rappresentano il 7%. Questa struttura di domanda diversificata fornisce supporto durante le turbolenze economiche, causando spesso un aumento in direzione opposta quando le azioni statunitensi scendono.</li><li>L’etichetta “attivo a rischio” di Bitcoin: La correlazione a 30 giorni tra <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e l’indice Nasdaq è alto fino a 0,82. Quando i desk di trading istituzionali affrontano fluttuazioni nel mercato azionario statunitense, spesso vendono <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> per soddisfare i requisiti di margine. Nel marzo 2025, mentre l’oro è aumentato del 16%, il Bitcoin è sceso del 6%, evidenziando la divergenza logica tra i due.</li></ul>
<h2 id="h2-Le20sfide20e20le20opportunit20delloro20digitale71808"><a name="Le sfide e le opportunità dell’”oro digitale”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le sfide e le opportunità dell’”oro digitale”</h2><p>Sebbene Bitcoin dimostri le sue proprietà di rifugio sicuro in alcuni scenari (come il trasferimento di beni da parte dei residenti turchi attraverso Bitcoin durante il conflitto Russia-Ucraina), i suoi principali collo di bottiglia risiedono in due punti:</p>
<ol>
<li>La volatilità schiaccia l’oro: la volatilità settimanale di Bitcoin è 4,5 volte superiore a quella dell’oro, con una diminuzione media di &gt;2,5% che si verifica una volta ogni quattro settimane, mentre il Value at Risk (VaR) è fino a 5 volte superiore a quello dell’oro. Questo mina la sua credibilità come “riserva di valore” per i fondi conservatori.</li><li>La narrazione si basa sui dividendi politici: L’aumento del Bitcoin all’inizio di quest’anno è stato principalmente dovuto all’approvazione dell’ETF sul Bitcoin negli Stati Uniti, che ha portato centinaia di miliardi di dollari in fondi incrementali. Tuttavia, dopo che il “Trump trade” (che prometteva di porre fine alla repressione delle criptovalute) è stato completamente scontato dal mercato, è mancato un slancio sostenuto. Al contrario, l’aumento dell’oro è sostenuto da una domanda strutturale come gli acquisti delle banche centrali (che rappresentano il 23%).</li></ol>
<h2 id="h2-Allocazione20Diversificata20Strategie20di20Copertura20per20Investitori20Web397284"><a name="Allocazione Diversificata: Strategie di Copertura per Investitori Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Allocazione Diversificata: Strategie di Copertura per Investitori Web3</h2><p>Per gli investitori in criptovalute, l’aumento dell’oro non è un segnale competitivo, ma un avviso di rischio:</p>
<ul>
<li>Opportunità di arbitraggio per i token d’oro on-chain: il token d’oro PAXG aumenta insieme ai prezzi dell’oro spot, mentre la differenza di prezzo con Bitcoin si amplia, offrendo opportunità di copertura tra asset. Il 2 giugno, quando l’oro è aumentato dell’1,2%, PAXG/USD è aumentato dell’1,5%, mentre BTC è diminuito dello 0,5%.</li><li>Indicatori principali delle tendenze dei fondi sovrani: se gli Stati Uniti vendono il 17% delle loro riserve auree (circa 171,8 miliardi di dollari), potrebbero spostarsi verso l’allocazione di Bitcoin. Trump ha firmato l’”Ordine Esecutivo per la Riserva Strategica di Bitcoin”, che, se attuato, cambierà il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> paesaggio.</li></ul>
<h2 id="h2-Conclusione20Complementare20piuttosto20che20sostitutivo25819"><a name="Conclusione: Complementare piuttosto che sostitutivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione: Complementare piuttosto che sostitutivo</h2><p>L’oro supera i massimi precedenti mentre il Bitcoin ristagna, il che riflette essenzialmente la divergenza tra “copertura del credito” e “giochi di liquidità”. Quando il debito degli Stati Uniti supera i 35 trilioni di dollari (aumentando di 1 trilione ogni cento giorni), entrambi riflettono il mettere in discussione il sistema delle valute fiat ma svolgono ruoli diversi: l’oro funge da zavorra di fronte al crollo del credito, mentre il Bitcoin agisce come ricevitore dell’eccesso di liquidità.</p>
<p>a <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Gli investitori dovrebbero aumentare le loro partecipazioni in PAXG e in altri asset sostenuti dall’oro + investire in media nel costo degli ETF Bitcoin per formare un portafoglio controciclico. La vera narrazione dell’”oro digitale” è appena all’inizio mentre il divario tra il valore di mercato dell’oro (22,7 trilioni di USD) e il valore di mercato di Bitcoin (2,1 trilioni di USD) si riduce.</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 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>