Qml0Y29pbiBlc2NlIGRhZ2xpIHNjYW1iaTogaWwgcGnDuSBncmFuZGUgZGVmbHVzc28gZ2lvcm5hbGllcm8gdmFsdXRhdG8gMSBtaWxpYXJkbyBkaSBkb2xsYXJpIGluIDEyIG1lc2k=

2024-01-10, 07:43

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR495219"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il 29 dicembre <a href="/price/vechain-vet" rel="nofollow noopener noreferrer" target="_blank">Acquista VeChain</a> registrato il più grande deflusso giornaliero di circa 28.000.</p>
<p>Una diminuzione della quantità di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> negli scambi mostra una possibilità che il suo prezzo possa salire presto.</p>
<p>C’è stato un aumento dell’attività istituzionale di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> on-chain.</p>
<h2 id="h2-Introduzione178144"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il sentiment iniziale del mercato crittografico per il 2024 dipende dalle performance delle varie categorie di criptovalute nel 2023. Gli investitori valutano spesso la variazione del prezzo di bitcoin e delle principali altcoin come <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e <a href="https://www.gate.io/price-prediction/ethereum-eth" target="_blank">Previsione di Ether (ETH)</a> il momentum per il nuovo anno. Finora, ci sono segnali chiari che bitcoin potrebbe avere una buona performance nel 2024.</p>
<p>In questo articolo, analizziamo le recenti attività on-chain di bitcoin, compresi i flussi di ingresso e uscita dagli scambi. Il motivo è che i flussi di ingresso degli scambi indicano la possibile direzione del <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">prezzo del bitcoin prenderà nel 2024</a>. Tuttavia, ci sono diversi altri eventi chiave <a href="https://www.gate.io/blog_detail/1800/bitcoin-se-reducir%C3%A1-a-la-mitad-en-2024-tendr%C3%A1-btc-otra-carrera-alcista" target="_blank">come il dimezzamento di BTC</a> che si svolgeranno durante l’anno.</p>
<h2 id="h2-La20pi20grande20fuoriuscita20di20Bitcoin20in20un20singolo20giorno20degli20ultimi20mesi192645"><a name="La più grande fuoriuscita di Bitcoin in un singolo giorno degli ultimi mesi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La più grande fuoriuscita di Bitcoin in un singolo giorno degli ultimi mesi</h2><p>L’attività on-chain di bitcoin mostra che il mercato BTC è rialzista, il che incoraggia gli investimenti cripto. Ad esempio, di recente c’è stato un calo della quantità di bitcoin su scambi centralizzati e decentralizzati a causa di un aumento delle uscite.</p>
<p>Ad esempio, mercoledì 29 dicembre 2023 c’è stato un deflusso di oltre 28.000 BTC per un valore di circa 1 miliardo di dollari dagli scambi. Questo è stato il <a href="https://studio.glassnode.com/metrics?a=BTC&amp;category=&amp;m=transactions.TransfersVolumeExchangesNet&amp;s=1464073154&amp;u=1703721600&amp;zoom=" rel="nofollow noopener noreferrer" target="_blank">la più grande uscita singola di BTC</a> da dicembre 2022.</p>
<p>Un’ampia uscita di bitcoin dagli scambi è un’indicazione rialzista a causa della riduzione dell’offerta sul mercato. Questo indica anche che le balene di bitcoin e altri detentori di bitcoin sono disposti a tenere anziché scambiare BTC. In tal caso, potrebbero essere disposti ad adottare una strategia di detenzione a lungo termine. Sulla base dell’attuale situazione di mercato potrebbe essere il momento migliore per <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">acquista Bitcoin</a>.</p>
<p>Come da <a href="https://cryptoquant.com/asset/btc/chart/exchange-flows/exchange-netflow-total?exchange=coinbase_advanced&amp;window=DAY&amp;sma=0&amp;ema=0&amp;priceScale=log&amp;metricScale=linear&amp;chartStyle=column" rel="nofollow noopener noreferrer" target="_blank">CryptoQuant</a>, una società di analisi, Coinbase, un exchange centralizzato, che è diventato il custode dei 12 previsti exchange traded funds (ETF) di bitcoin spot negli Stati Uniti, ha registrato un deflusso di 18.000 BTC.</p>
<p>Il crescente deflusso di BTC ha aumentato le speculazioni su un potenziale aumento dell’attività istituzionale prima della data prevista per l’approvazione delle domande di ETF per bitcoin spot. A seguito di un così grande deflusso, il saldo di BTC sugli scambi è sceso a 2.327.025 BTC, il livello più basso dal aprile 2018.</p>
<p>Una diminuzione del volume di bitcoin sugli scambi indica che c’è una diminuzione della pressione venditrice che potrebbe portare all’apprezzamento del prezzo di BTC. Diversi fattori come la stagione festiva e l’aspettativa di cambiamenti nella regolamentazione potrebbero indurre una diminuzione della quantità di bitcoin sugli scambi.</p>
<p>È importante notare che Coinbase ha smentito l’affermazione di un deflusso di oltre 18.000 BTC dallo scambio. Commentando su X Brian Armstrong, il CEO di Coinbase, ha detto: ‘Questo è falso. Molto lontano dai nostri dati interni.’<br><img src="https://gimg2.gateimg.com/image/article/1704872443img_v3_026v_1d7d8ddf-83ea-4e77-8214-8b698ce51bix.jpg" alt=""><br>Fonte: x.com</p>
<h2 id="h2-Aumento20dellattivit20istituzionale20prima20della20data20prevista20per20lapprovazione20degli20ETF20di20Bitcoin20spot580376"><a name="Aumento dell’attività istituzionale prima della data prevista per l’approvazione degli ETF di Bitcoin spot" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aumento dell’attività istituzionale prima della data prevista per l’approvazione degli ETF di Bitcoin spot</h2><p>Si sta diffondendo la speculazione che molte istituzioni potrebbero acquistare molto bitcoin prima della data del <a href="https://www.gate.io/learn/articles/these-are-the-high-profile-spot-bitcoin-etf-applications-currently-in-pllay/1258" target="_blank">previsto lancio di ETF Bitcoin spot</a> Si prevede che l’approvazione degli ETF crittografici da parte della SEC avvenga durante la seconda settimana di gennaio di quest’anno.</p>
<p>MicroStrategy è un’istituzione che ha comprato bitcoin da molto tempo. Di recente, ha acquistato bitcoin del valore di $615,7 milioni, indicando che ci sono sempre più istituzioni che credono che il bitcoin sia un asset di investimento a lungo termine valido.</p>
<p>D’altra parte, diverse istituzioni hanno adottato misure pronte per investire in bitcoin e nei suoi derivati. Ad esempio, ARK Invest si è disinvestito da GBTC per investire in BITO Bitcoin futures ETF. Gli analisti vedono questo come una mossa per posizionarsi strategicamente prima di possibili cambiamenti normativi.</p>
<h2 id="h2-Bitcoin20risponde20positivamente20ai20cambiamenti20del20mercato156884"><a name="Bitcoin risponde positivamente ai cambiamenti del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin risponde positivamente ai cambiamenti del mercato</h2><p>Come la comunità cripto <a href="https://www.gate.io/learn/articles/pse-trading-the-nature-impact-and-prospects-of-bitcoin-spot-etf/1319" target="_blank">anticipa il lancio di ETF bitcoin spot, il mercato ha risposto positivamente</a>. Il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> è stato in un’ tendenza al rialzo per settimane. Ad esempio, martedì 1 gennaio il suo prezzo ha superato i 45.000 dollari. È stata la prima volta che il prezzo del bitcoin è salito oltre quella soglia da aprile 2022.</p>
<p>Inoltre, quella impennata del prezzo del bitcoin è avvenuta dopo che la Securities and Exchange Commission ha comunicato che potrebbe rendere nota la sua decisione sull’ETF bitcoin spot agli richiedenti entro martedì o mercoledì prima della scadenza del 10 gennaio.</p>
<p>Justin d’Anethan, responsabile dello sviluppo commerciale APAC di Keyrock, un market maker di criptovalute, ha commentato l’ultimo movimento del prezzo di BTC e le prospettive di approvazione degli ETF bitcoin spot.</p>
<p>Lui <a href="https://www.theblock.co/post/265684/institutional-investors-poised-for-increased-crypto-activity-in-2024-analysts-say" rel="nofollow noopener noreferrer" target="_blank">detto</a>“Non sta succedendo molto dal lato macro che porterebbe a credere che sia altro che una dinamica legata alle criptovalute. In questo caso, abbiamo avuto notizie di Blackrock, Fidelity e altri richiedenti di spot bitcoin ETF.” <a href="https://www.bloomberg.com/news/articles/2023-12-29/blackrock-names-jane-street-jpmorgan-as-bitcoin-etf-authorized-participants" rel="nofollow noopener noreferrer" target="_blank">conferma</a> nomi dei broker che supporterebbero le loro operazioni BTC.</p>
<p>Ha continuato: “La maggior parte degli investitori si aspetta una qualche forma di decisione ufficiale entro la prima metà di questo mese, quindi imminente.”</p>
<p>Un altro commentatore di criptovalute, <a href="https://x.com/ali_charts/status/1740671046582149381?s=46&amp;t=qzsvHvtDB3yjTaoaylh-2g" rel="nofollow noopener noreferrer" target="_blank">Ali Charts ha previsto</a> che il bitcoin rimarrà rialzista per un lungo periodo. Ha basato l’analisi sul periodo rialzista di 3 anni, seguito da un anno di tendenza correttiva ribassista. In questo contesto, Alichart ha presentato il seguente grafico per mostrare il possibile movimento del prezzo del bitcoin.<img src="https://gimg2.gateimg.com/image/article/1704872563img_v3_026v_12ccaf4f-d2f3-417b-b0d9-794a5a63e0ix.jpg" alt=""><br>Andamento previsto del prezzo di Bitcoin - Alicharts</p>
<p>Come hai notato, il prezzo del bitcoin è destinato a continuare a salire nel 2024.</p>
<h2 id="h2-Conclusion206723"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Bitcoin ha registrato una grande fuoriuscita giornaliera di circa 28.000, indicando la volontà delle balene Bitcoin di adottare una strategia di conservazione a lungo termine. La riduzione dei Bitcoin dagli scambi mostra una diminuzione della pressione venditrice e una forte possibilità di un rialzo dei prezzi. Tutto sommato, la comunità criptografica si aspetta che il valore di Bitcoin aumenti. <a href="https://www.gate.io/blog_detail/3646/grayscale-suggestion-_s-sec-s-re-_uation-of-bitcoin-etfs" target="_blank">se la SEC approva gli ETF di bitcoin spot</a>.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Mashell C.</strong>, Ricercatore di Gate.io<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 ripubblicare l'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>