RHVtcCBzdHJhdGVnaWNvOiBpIG1pbmF0b3JpIGRpIEJpdGNvaW4gc2NhcmljYW5vIG1hZ2lzdHJhbG1lbnRlIGxhIGxvcm8gc2NvcnRhIHByb3ByaW8gcHJpbWEgZGVsIGdyYW5kZSBwYXJ0eSBkZWxsJ0hhbHZpbmc=

2024-02-08, 16:23

<p><img src="https://gimg2.gateimg.com/image/article/1707408700SDFXnew.jpeg" alt=""></p>
<h2 id="h2-TL20DR229970"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Da gennaio 2024 <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> I minatori hanno venduto grandi quantità di BTC mentre ci avviciniamo all’evento di halving, previsto ad aprile.</p>
<p>Le riserve di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> miner sono molto basse al momento.</p>
<p>Attualmente, il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> sta oscillando intorno ai $43.000.</p>
<h2 id="h2-Introduzione501713"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Con l’attesa imminente dell’evento di dimezzamento di Bitcoin, diversi minatori di Bitcoin hanno scaricato le loro detenzioni di BTC, il che ha depresso il suo prezzo dal medio gennaio. Gli analisti ritengono che <a href="https://www.gate.io/blog_detail/1866/btc-halved-for-the-fourth-time-how-does-it-affect-the-supply-of-btc" target="_blank">l’evento di halving avverrà in aprile di quest’anno</a> e ridurrà la ricompensa per il mining da 6,25 a 3,125 BTC per blocco.</p>
<p>Oggi, ci concentriamo sulle principali ragioni per cui i minatori di bitcoin scaricano la criptovaluta numero uno sul mercato durante gennaio. Analizzeremo anche gli effetti della grande vendita di bitcoin sul suo valore.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/3286/bitcoin-halving-85-done-long-term-holders-supply-inches-toward-record-highs" target="_blank">Bitcoin Halving: 85% Fatto</a></p>
<h2 id="h2-I20miner20di20Bitcoin20scaricano20grandi20quantit20di20BTC20sul20mercato135573"><a name="I miner di Bitcoin scaricano grandi quantità di BTC sul mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I miner di Bitcoin scaricano grandi quantità di BTC sul mercato</h2><p>I minatori di bitcoin hanno scaricato molte BTC sul mercato, aumentando la pressione delle vendite. Questa è una delle ragioni per cui il prezzo del bitcoin è sceso dall’inizio di gennaio.</p>
<p>Ad esempio, solo il 17 gennaio i minatori di bitcoin hanno venduto oltre 10.000 BTC, causando il più grande calo giornaliero delle riserve minerarie nel periodo di un anno. Secondo <a href="https://cryptoquant.com/asset/btc/chart/miner-flows/miner-reserve?miner=all_miner&amp;window=DAY&amp;sma=0&amp;ema=0&amp;priceScale=log&amp;metricScale=linear&amp;chartStyle=line" rel="nofollow noopener noreferrer" target="_blank">CryptoQuant</a>, un provider di analisi on-chain, il 17 gennaio i minatori hanno venduto 10.233 BTC, equivalenti a circa 450 milioni di dollari al prezzo prente in quel momento.</p>
<p>Sulla base del trend precedente, c’è una forte probabilità che i minatori intelligenti di bitcoin continueranno a vendere bitcoin nei prossimi mesi fino alla data del dimezzamento. Di fatto, alcuni minatori vendono bitcoin come mossa strategica man mano che ci avviciniamo <a href="https://www.gate.io/blog_detail/1067/bitcoin-halving-what-it-is." target="_blank">all’evento di dimezzamento</a>.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707409268btcMINERS1.png" alt=""><br>Sorgente: <a href="https://twitter.com/cryptoquant_com/status/1750654514263114197" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>In risposta al post sopra, un altro utente X ha spiegato perché i minatori potrebbero vendere le loro partecipazioni in grandi quantità. Natnah el ha detto: “Come minatore, è una mossa molto intelligente proteggersi dall’incertezza del prezzo/valore perché è certo che le ricompense diventeranno minori ma non c’è certezza su dove sarà il prezzo al momento dell’evento di dimezzamento.”</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707409289btcMINERS2.png" alt=""><br>Source: <a href="https://twitter.com/effo_suave/status/1750657685836485081" rel="nofollow noopener noreferrer" target="_blank">X.com</a></p>
<p>Di conseguenza, i minatori stanno guadagnando profitto prima dell’evento di dimezzamento per coprire i costi operativi e prepararsi <a href="https://www.gate.io/learn/articles/bitcoin-mining-a-path-to-electrifying-the-world/1367" target="_blank">per altri sviluppi legati al mining di bitcoin</a> Ad esempio, alcuni minatori devono acquistare attrezzature più efficienti per il mining di bitcoin in previsione di un aumento della difficoltà di mining dopo l’evento di halving.</p>
<p>Poiché il premio per il mining di bitcoin diminuirà della metà, il reddito dei minatori probabilmente diminuirà a meno che il prezzo di BTC aumenti durante il periodo successivo alla riduzione a metà.</p>
<p>Ancora, come si può notare dalla spiegazione di Natnah, i minatori potrebbero vendere le loro posizioni in bitcoin per paura di una forte volatilità dei prezzi dopo l’evento di dimezzamento. In un’altra notizia correlata, CryptoQuant ha accertato che l’afflusso di bitcoin dai minatori alle borse è aumentato di oltre tre volte, indicando una forte pressione venditrice.</p>
<p>L’effetto dell’aumento della pressione venditrice di bitcoin era evidente <a href="https://www.gate.io/blog_detail/3698/spot-bitcoin-etfs-approval-becomes-a-milestone-how-the-crypto-price-will-move-in-the-future" target="_blank">alcuni giorni dopo l’approvazione dell’ETF della SEC</a>. Oltre ai minatori che hanno venduto molti bitcoin, anche alcune balene hanno venduto le loro posizioni in BTC.</p>
<p>Ciò che ha anche aggravato la situazione <a href="https://www.gate.io/blog_detail/158/the-1st-cryptocurrency-investments-grayscale-what-is-gbtc" target="_blank">è stata la vendita di Grayscale Bitcoin Trust</a> di circa 106.575 BTC a seguito delle approvazioni degli ETF bitcoin a pronti. In modo significativo, il 12 gennaio bitcoin ha riconquistato i 40.000 dollari dopo essere sceso al di sotto di quel livello nei giorni precedenti.</p>
<p>Inoltre, l’afflusso di bitcoin agli scambi ha comportato una diminuzione delle riserve di BTC mining. Attualmente, le riserve di mining di bitcoin ammontano a circa 1,83 milioni, per un valore di circa 73,4 miliardi di dollari.</p>
<p>Nonostante le riserve minerarie fossero stabili dal 2021, sono diminuite di 22.800 BTC durante gli ultimi 12 mesi. Tuttavia, il 15 gennaio <a href="https://cryptoquant.com/asset/btc/chart/flow-indicator/miners-position-index-mpi?window=DAY&amp;sma=0&amp;ema=0&amp;priceScale=log&amp;metricScale=linear&amp;chartStyle=line &quot;Bitcoin Miners’ Position Index (MPI" rel="nofollow noopener noreferrer" target="_blank">Indice di posizione dei minatori di Bitcoin (MPI)</a>“), ha iniziato a indicare che era il momento per i minatori di vendere i loro BTC.</p>
<h2 id="h2-Il20mining20di20Bitcoin20avviene20a20cicli892607"><a name="Il mining di Bitcoin avviene a cicli" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il mining di Bitcoin avviene a cicli</h2><p>L’attuale azione dei minatori di bitcoin non è sorprendente considerando che attraversano diverse fasi o cicli. Secondo Bitfinex <a href="https://blog.bitfinex.com/wp-content/uploads/2023/08/Bitfinex-Alpha-67-1.pdf" rel="nofollow noopener noreferrer" target="_blank">rapporto 2023</a> i minatori di bitcoin avevano accumulato la moneta a partire dalla metà del 2023, quando il suo prezzo era depresso. Man mano che il valore del bitcoin aumenta, i minatori continuano a vendere le loro monete. Hanno iniziato a vendere gran parte delle loro posizioni nel dicembre 2023.</p>
<p>Tuttavia, il momento della vendita è aumentato a gennaio quando il prezzo del bitcoin oscillava tra i $42.000 e i $49.000, come indica il diagramma successivo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707409355btcMINERS3.png" alt=""><br>Prezzo del Bitcoin, gennaio e febbraio 2024 - <a href="https://www.coingecko.com/en/coins/bitcoin" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a></p>
<p>Come mostra l’immagine sopra, il prezzo del bitcoin è oscillato tra i $40.000 e i $47.000 per la maggior parte del periodo menzionato. Al momento della stesura, il bitcoin viene scambiato a $43.083, il che implica che la maggior parte degli investitori in criptovalute che hanno acquisito BTC durante il 2023 potrebbero generare un profitto se lo vendessero ora. Per i minatori, il periodo in cui possono incassare un profitto dopo aver disposto delle loro posizioni viene definito fase di vendita.</p>
<h2 id="h2-Attuale20volatilit20del20prezzo20del20Bitcoin190980"><a name="Attuale volatilità del prezzo del Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Attuale volatilità del prezzo del Bitcoin</h2><p>A gennaio il bitcoin ha subito una forte correzione di prezzo da circa $49.000 sull’11. Nel suo calo di prezzo ha superato i livelli di supporto di $45.000, $43.500 e $40.000 per stabilizzarsi intorno a $38.572. Da quel momento, il prezzo ha iniziato a riprendersi verso il suo attuale livello di trading, $43.083.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707409371btcMINERS4.png" alt=""><br>Grafico giornaliero del prezzo del Bitcoin - <a href="https://www.tradingview.com/symbols/BTCUSD/" rel="nofollow noopener noreferrer" target="_blank">TradingView.com</a></p>
<p>Come puoi vedere in <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> Come sopra, il Bitcoin si sta riprendendo dal recente calo. Fondamentalmente, il suo valore è salito sopra la media mobile semplice a 50 giorni. Inoltre, si è formato un pattern di candele a testa e spalle inverse, indicando che il suo prezzo potrebbe salire ancora più in alto nei prossimi giorni.</p>
<p>Se il BTC riesce a chiudere sopra i $43.500, potrebbe dirigersi verso il livello di prezzo di $44.850 e probabilmente superare $45.000, $46.500 e $47.000. Una volta raggiunto questo livello di prezzo, potrebbe puntare al livello di $48.750 prima di ritestare i $50.000.</p>
<h2 id="h2-Conclusion895003"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>I minatori di Bitcoin hanno <a href="https://www.gate.io/blog_detail/451/btc-whale-holders-is-it-possible-to-know-who-they-are" target="_blank">stato vendendo le loro posizioni BTC</a> durante il tempo il suo prezzo è stato oscillante tra $42,000 e $49,000. Con un tale intervallo di prezzi potrebbero trarre profitto dalle loro vendite. A seguito delle grandi vendite di bitcoin le riserve dei minatori sono diminuite a livelli molto bassi.</p>
<h2 id="h2-Domande20frequenti20sul20mining20di20Bitcoin979141"><a name="Domande frequenti sul mining di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sul mining di Bitcoin</h2><h3 id="h3-Come20lapprovazione20degli20ETF20ha20influenzato20il20settore20del20mining20di20bitcoin263666"><a name="Come l’approvazione degli ETF ha influenzato il settore del mining di bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come l’approvazione degli ETF ha influenzato il settore del mining di bitcoin?</h3><p>L’approvazione degli ETF di spot bitcoin aumenterà la domanda della moneta, il che potrebbe portare ad aumenti di prezzo sostenuti. L’aumento del prezzo del bitcoin significa che i minatori di BTC ottengono margini più alti quando vendono la criptovaluta. Ad esempio, dopo l’approvazione degli ETF di bitcoin il 10 gennaio c’è stato un aumento delle vendite di BTC da parte dei minatori.</p>
<h3 id="h3-Cos20il20dimezzamento20del20bitcoin20nel202024170959"><a name="Cos’è il dimezzamento del bitcoin nel 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è il dimezzamento del bitcoin nel 2024?</h3><p>L’halving di Bitcoin è un processo in cui la ricompensa per il mining di un blocco di bitcoin diminuisce della metà. L’halving di Bitcoin del 2024, previsto per aprile, ridurrà la ricompensa di mining da 6,25 a 3,125 BTC.</p>
<h3 id="h3-Qual2020un20fattore20per20il20successo20del20mining20di20bitcoin628481"><a name="Qual è un fattore per il successo del mining di bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è un fattore per il successo del mining di bitcoin?</h3><p>Ci sono diversi fattori che influenzano il successo del mining di bitcoin, tra cui la difficoltà di mining, il costo dell’elettricità e l’efficienza dell’attrezzatura da mining. Ad esempio, i minatori di bitcoin situati in luoghi dove il prezzo dell’elettricità è basso generano più profitto rispetto a quelli nelle regioni in cui il costo dell’energia è più alto.</p>
<h3 id="h3-Qual2020il20vantaggio20dellETF20del20bitcoin178480"><a name="Qual è il vantaggio dell’ETF del bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il vantaggio dell’ETF del bitcoin?</h3><p>Gli ETF di bitcoin sul mercato spot sono strumenti di investimento regolamentati il cui valore correla con quello del bitcoin. Inoltre, quelli <a href="https://www.gate.io/ar/blog_detail/3728/what-does-bitcoin-etf-introduction-mean-for-investors" target="_blank">chi investe in ETF di BTC non affronta le sfide</a> associati all’acquisto e all’archiviazione di bitcoin.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips">Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br><div>*Gate.io si riserva tutti i diritti su questo articolo. Il repostaggio dell'articolo sarà consentito a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>