Q29tZSBjb250aW51ZXLDoCBpbCBtZXJjYXRvIGRlbCBCaXRjb2luIGRvcG8gY2hlIGdsaSBFVEYgY3JvbGxhbm8gZGVsIDE1JSBkb3BvIGwnYXR0ZXJyYWdnaW8/

2024-01-16, 09:29

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR863400"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Dopo l’approvazione del mercato statunitense <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF il 10 gennaio, il prezzo della moneta è brevemente salito e il calo massimo ha superato il 15%, con un totale di $342 milioni di fondi liquidati.</p>
<p>Il mercato specula che questa fase di declino sia dovuta al ritiro dei fondi speculativi a breve termine che hanno venduto la notizia per ottenere profitto, così come per la tecnologia ipercomprata.</p>
<p>Analogamente alla risposta dei prezzi degli ETF dell’oro e dell’argento dopo l’approvazione, il declino del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è ancora normale e aprirà un processo di scoperta del valore a lungo termine.</p>
<h2 id="h2-Introduzione320570"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Recentemente, la Securities and Exchange Commission degli Stati Uniti ha finalmente approvato 11 ETF Bitcoin il 10 gennaio. Tuttavia, poche ore dopo l’annuncio delle notizie positive, il prezzo del Bitcoin è leggermente salito a $49.000 e poi è tornato intorno a $41.000. La vendita di notizie è considerata una prova negativa per gli osservatori.</p>
<p>Tuttavia, le opinioni delle persone sull’imminente evento di dimezzamento di Bitcoin in aprile sono diverse, e questo articolo fornirà un’interpretazione approfondita di questo.</p>
<h2 id="h2-Significativa20diminuzione20del20prezzo20di20Bitcoin20guidando20una20correzione20di20mercato541163"><a name="Significativa diminuzione del prezzo di Bitcoin, guidando una correzione di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Significativa diminuzione del prezzo di Bitcoin, guidando una correzione di mercato</h2><p>L’approvazione del Bitcoin ETF spot è stata descritta dai media come una pietra miliare storica, ma la risposta del mercato cripto è stata deludente, addirittura iniziando a diminuire due giorni dopo. Questo fa sorgere la domanda se l’approvazione degli ETF Bitcoin sia positiva o negativa?</p>
<p>Secondo i dati di mercato di Gate.io, dopo l’approvazione degli ETF di Bitcoin spot, il prezzo è leggermente aumentato fino a un massimo di $49.000, per poi continuare a scendere, raggiungendo un minimo di $41.422, una diminuzione di oltre il 15%. Alla data di scrittura, il prezzo della moneta è ancora in un intervallo ristretto di fluttuazioni dopo un periodo di calo, con un prezzo temporaneo di $42.722.<img src="https://gimg2.gateimg.com/image/article/1705397508img_v3_0275_30b68186-34f9-497a-987d-a31f531dbbix.jpg" alt=""><br>Origine: Gate.io</p>
<p>Secondo i dati di CoinGlass, il giorno dopo la brusca caduta dei prezzi delle criptovalute, oltre 100.000 investitori nel mercato delle criptovalute hanno subito una vendita entro 24 ore, per un importo totale di 342 milioni di dollari.</p>
<p>Il declino di Bitcoin non ha solo causato una diminuzione dell’intero mercato crittografico, ma ha anche innescato aggiustamenti nelle azioni legate ai concetti correlati. Nel mercato azionario statunitense, le azioni legate al concetto di crittografia hanno subito un calo generale nello stesso periodo, con Marathon Digital che è sceso di oltre il 15%, Riot Platforms di oltre il 10%, MicroStrategy di oltre il 9%, Canaan Creative di quasi il 9% e Coinbase di oltre il 7%.</p>
<h2 id="h2-Il20taglio20dei20tassi20di20interesse2020ancora20poco20chiaro20e20le20notizie20positive20si20sono20trasformate20in20calo439299"><a name="Il taglio dei tassi di interesse è ancora poco chiaro e le notizie positive si sono trasformate in calo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il taglio dei tassi di interesse è ancora poco chiaro e le notizie positive si sono trasformate in calo</h2><p>Anche se l’approvazione degli ETF è una notizia positiva a lungo termine rispetto a Bitcoin, dopo che la notizia si è stabilizzata, il mercato è caduto in un breve gioco ribassista di tensione di liquidità e deflussi di capitale.</p>
<p>In termini di dati economici, l’Indice dei prezzi alla produzione (PPI) degli Stati Uniti a dicembre 2023 è aumentato del 1% su base annua, inferiore al previsto 1,3%, con un valore precedente dello 0,9%; Un inaspettato calo del 0,1% su base mensile, senza crescita per tre mesi consecutivi. Inoltre, il core PPI è aumentato del 1,8% su base annua, con un previsto 1,9% e un valore precedente del 2%.</p>
<p>Il giorno prima della pubblicazione dei dati PPI, il Dipartimento del Lavoro degli Stati Uniti ha pubblicato i dati che mostrano che l’indice dei prezzi al consumo (CPI) per dicembre 2023 è aumentato dello 0,3% su base mensile e del 3,4% su base annua, entrambi superiori alle aspettative di Wall Street e significativamente superiori all’obiettivo di inflazione del 2% della Federal Reserve.</p>
<p>Questo ha aggiunto una certa difficoltà alle aspettative della Federal Reserve di tagli dei tassi di interesse quest’anno e più a lungo dura la politica di restrizione della liquidità, più sfavorevole sarà per il mercato delle criptovalute.<br>Inoltre, dal punto di vista del contante <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> I dati, oltre ai fondi speculativi a breve termine che vendono direttamente Bitcoin per incassare, la pressione di liquidazione degli ETF Grayscale e i fallimenti di FTX sono anche un importante motore di questo periodo di declino.<img src="https://gimg2.gateimg.com/image/article/1705397533img_v3_0275_9cc1615e-3967-45c3-8c76-3990c9c398ix.jpg" alt=""><br>Fonte: Bloomberg</p>
<p>Secondo i dati, il primo giorno dell’emissione di ETF Bitcoin sul mercato spot, gli ETF Bitcoin spot di Grayscale GBTC hanno rappresentato quasi la metà del volume di scambi, con un deflusso di capitali di 579 milioni di dollari nei due giorni di quotazione.</p>
<h2 id="h2-Ci20si20aspetta20che20il20mercato20fluttui20e20si20adatti20in20futuro20si20avvicina20la20speculazione20sullhalving681916"><a name="Ci si aspetta che il mercato fluttui e si adatti in futuro, si avvicina la speculazione sull’halving" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ci si aspetta che il mercato fluttui e si adatti in futuro, si avvicina la speculazione sull’halving</h2><p>Attualmente, molte interpretazioni di questo periodo di declino sono attribuite a “Compra la voce, Vendi la notizia” che ha un certo senso.<br>Se confrontiamo lo stato attuale degli ETF di Bitcoin con il processo di approvazione degli ETF dell’oro e dell’argento passati, forse possiamo acquisire alcuni spunti.</p>
<p>I dati storici mostrano che quando il gold ETF GLD è stato approvato nel novembre 2014, i prezzi dell’oro non hanno raggiunto un nuovo picco come risultato. Ma nei successivi 8 anni, il prezzo dell’oro è più che raddoppiato, passando dagli iniziali $400 a $1,800, e il valore di mercato è aumentato da circa $2 trilioni a circa $10 trilioni, un aumento di circa $8 trilioni.</p>
<p>Secondo gli analisti di McOscillator, il momento in cui GLD è stato quotato per la prima volta non ha segnato un top definitivo per i prezzi dell’oro, ma due settimane dopo i prezzi dell’oro hanno effettivamente formato un top importante e non hanno superato per i successivi 10 mesi.<img src="https://gimg2.gateimg.com/image/article/1705397603img_v3_0275_e3d3c9a3-8270-4dca-aa15-56e024fa67ix.jpg" alt=""><br>Fonte: mcoscillator.com</p>
<p>Una situazione simile è accaduta anche nell’aprile 2006 quando il Silver ETF SLV è stato quotato per la prima volta. Il giorno in cui è stato approvato SLV non ha segnato il massimo esatto, ma è stato considerato parte della struttura al top ed è rimasto a un livello elevato per i mesi successivi.<img src="https://gimg2.gateimg.com/image/article/1705397697img_v3_0275_0a2e50fd-51f1-4f38-ade1-24fd0d93fbix.jpg" alt=""><br>Fonte: mcoscillator.com</p>
<p>Questi dati storici forniscono preziosi riferimenti per confrontare la situazione attuale degli ETF Bitcoin. Anche se l’approvazione degli ETF Bitcoin potrebbe non portare immediatamente a un nuovo picco dei prezzi, potrebbe diventare parte della struttura di mercato e avere un impatto significativo sui prezzi nei prossimi mesi.</p>
<p>In realtà, dopo che la SEC degli Stati Uniti ha approvato il Bitcoin ETF, gli investitori hanno potuto partecipare alle performance finanziarie degli asset digitali più grandi, popolari e leader, in una forma familiare e facile da usare, simile alla negoziazione di azioni tradizionali. Questa struttura riduce notevolmente l’onere tecnico della gestione dei portafogli di criptovalute, della protezione delle chiavi private e della familiarizzazione con gli scambi di criptovalute.</p>
<p>L’ETF Bitcoin ha superato gli ostacoli all’ingresso per coloro che sono interessati al mercato Bitcoin ma temono la complessità della gestione delle criptovalute. Non solo fornisce un canale di investimento più semplificato e snello, ma preserva anche il dinamismo del mercato Bitcoin e i potenziali profitti redditizi.</p>
<p>Secondo l’opinione dell’autore, l’approvazione degli ETF di Bitcoin non solo è un atterraggio favorevole, ma getta anche una base relativamente solida per prepararsi al mercato di dimezzamento di quest’anno.</p>
<p>È certo che gli ETF porteranno molti cambiamenti e impatti sul mercato delle criptovalute. Anche se potrebbe esserci ancora un po’ di volatilità dopo la presa di profitto a breve termine, che costituisce una certa prova per gli investitori a breve termine, per gli investitori a lungo termine, assisteremo alla rapida crescita degli asset criptati nel 2024 e oltre.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>