UHJvZml0dG8gc2VuemEgcHJlY2VkZW50aTogbGUgYmFsZW5lIEJpdGNvaW4gcmVhbGl6emFubyBvbHRyZSAxIG1pbGlhcmRvIGRpIGRvbGxhcmkgaW4gZHVlIHNldHRpbWFuZQ==

2024-07-02, 15:39

<p><img src="https://gimg2.gateimg.com/image/article/17199342781690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR17130"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Le balene <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> hanno venduto BTC per un valore di circa $44.000 nelle prime tre settimane di giugno.</p>
<p>Molti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> I minatori mirano a spostare la loro potenza di calcolo nel settore dell’intelligenza artificiale.</p>
<p>Il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> potrebbe scendere a $57,963 prima di riprendersi a $66,173.</p>
<h2 id="h2-Introduzione518869"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le attività dei vari partecipanti al mercato come i detentori di criptovalute influenzano i movimenti dei prezzi degli asset digitali come le criptovalute e i token non fungibili. Ad esempio, i modelli di acquisto e vendita di <a href="https://www.gate.io/learn/articles/day-trading-vs-long-term-cryptocurrency-hodling-benefits-and-drawbacks/2374" target="_blank">sia i detentori a lungo termine che quelli a breve termine di criptovalute determinano le loro performance di mercato</a> e sentiment. Questa analisi si concentra sul recente comportamento di mercato dei grandi investitori intelligenti di bitcoin, spesso indicati come BTC whales.</p>
<h2 id="h2-Comprensione20dei20partecipanti20al20mercato20delle20criptovalute20chi20sono20le20balene20del20Bitcoin393921"><a name="Comprensione dei partecipanti al mercato delle criptovalute: chi sono le balene del Bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprensione dei partecipanti al mercato delle criptovalute: chi sono le balene del Bitcoin?</h2><p>Durante la seconda e terza settimana di giugno, le balene del bitcoin erano in una vendita sfrenata poiché hanno venduto oltre 1 miliardo di dollari di BTC. Alcune di queste balene del bitcoin erano detentori a lungo termine dell’asset, tra cui investitori generali e minatori. Le vendite su larga scala hanno sollevato domande sul futuro movimento del prezzo del bitcoin.</p>
<p>Le balene Bitcoin sono detentori su larga scala dell’asset con almeno 1.000 BTC, del valore di circa $65 milioni al prezzo attuale. Nella maggior parte dei casi, queste balene cripto sono investitori istituzionali e aziende piuttosto che singoli individui che commerciano bitcoin.</p>
<h2 id="h2-Realizzazione20di20profitti20record20di20giugno20da20parte20di20vecchie20balene280255"><a name="Realizzazione di profitti record di giugno da parte di “vecchie balene”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Realizzazione di profitti record di giugno da parte di “vecchie balene”</h2><p>Solo nella prima metà di giugno, i minatori e le balene di Bitcoin hanno venduto Bitcoin per oltre 1,2 miliardi di dollari, segno che stavano prendendo profitto. Questa è stata la più grande vendita di Bitcoin da parte dei detentori su larga scala da maggio, quando il prezzo di Bitcoin è sceso al di sotto dei 70.000 dollari. Molto probabilmente questi detentori di Bitcoin a lungo termine stavano vendendo le loro posizioni in BTC a intermediari anziché a borse di criptovalute. <a href="https://cryptoquant.com/analytics/query/6671cccd93c30073780d6804" rel="nofollow noopener noreferrer" target="_blank">I dati di CryptoQuant indicano</a> che c’è stata una diminuzione delle dimensioni delle fasce di età degli UTXO di bitcoin, una situazione associata a un aumento delle vendite di bitcoin senza coinvolgere gli scambi.</p>
<p>Unspent transaction output (UTXO) si riferisce alla tecnica utilizzata per tenere traccia dei saldi di una criptovaluta come bitcoin. Mostra anche l’importo del saldo di una valuta digitale dopo una determinata transazione o una serie di transazioni. Una diminuzione nell’UTXO indica un aumento dell’attività di vendita dell’attivo. Al contrario, un aumento nell’UTXO significa che c’è stato un aumento dell’attività di acquisto.</p>
<p>L’altro segnale di un aumento delle vendite di bitcoin è la diminuzione della liquidità delle stablecoin, il che indica che gli investitori di criptovalute stanno uscendo dalle loro posizioni in bitcoin. Il fatto che gli investitori stessero convertendo i loro bitcoin in asset ancorati al fiat mostra le loro intenzioni di vendere le loro partecipazioni in criptovalute.<br><img src="https://gimg2.gateimg.com/image/article/17199344491.jpg" alt=""><br>Origine: x.com</p>
<p>Ki Young Ju, <a href="https://www.linkedin.com/posts/crypto-quant_bitcoin-at-key-levels-activity-7208933339628503041-GAVO" rel="nofollow noopener noreferrer" target="_blank">Il CEO di CryptoQuant, crede</a> che le recenti transazioni di bitcoin sono state effettuate da intermediari anziché da scambi, il che implica che l’impatto della vendita richiederà molto tempo per manifestarsi. Di solito, tali grandi vendite di criptovalute hanno il potenziale per esacerbare il momento ribassista del bitcoin.</p>
<p>I dati Onchain mostrano che mentre <a href="https://www.gate.io/blog_detail/451/btc-whale-holders-is-it-possible-to-know-who-they-are" target="_blank">balene di bitcoin</a> hanno venduto le loro partecipazioni, ma i trader non stavano aumentando le loro acquisizioni di BTC. Commentando su questo <a href="https://www.linkedin.com/posts/crypto-quant_bitcoin-at-key-levels-activity-7208933339628503041-GAVO" rel="nofollow noopener noreferrer" target="_blank">CryptoQuant ha detto</a>, “I trader non stanno ancora aumentando le loro detenzioni di Bitcoin, e la crescita della domanda dei grandi detentori (baleine) manca ancora di forza.” Le implicazioni di mercato di questo includono il calo del prezzo del bitcoin e l’accumulo di sentimenti negativi verso le criptovalute.</p>
<p>L’effetto di questo scenario non si limita solo al mercato delle criptovalute ma anche <a href="https://www.gate.io/learn/articles/how-to-stake-eric/1494" target="_blank">nell’ETF BTC spot</a> settore in cui c’erano elevate uscite di ETF di bitcoin. Fondamentalmente, il mercato degli ETF di bitcoin ha seguito la stessa tendenza registrando 460 milioni di dollari di flussi netti nello stesso periodo. Tali uscite sia nel mercato del bitcoin che nel settore degli ETF indicano un sentimento di cautela tra i grandi detentori di BTC e gli investitori istituzionali. Tuttavia, il rapporto di CryptoQuant indica che sono stati i minatori ad aver venduto la maggior parte dei bitcoin.</p>
<p>La tendenza al profitto è un’indicazione che sono stati gli ‘old-whales’ a vendere le loro posizioni poiché hanno acquisito bitcoin quando il suo prezzo di mercato era molto inferiore a quello attuale. Secondo Julio Moreno, responsabile della ricerca di CryptoQuant, il prelievo di profitti è stato senza precedenti. Ha solo confrontato l’impatto della vendita con quanto accaduto nell’aprile 2022, quando il prezzo del bitcoin era intorno ai 40.000 dollari. In un momento di quel mese, le balene del bitcoin hanno realizzato 683 milioni di dollari in un solo giorno.</p>
<p>È importante notare che la diminuzione degli Unspent transaction output (UTXO) non significa che le balene abbiano smesso di accumulare la criptovaluta. Questo significa solo che la coorte sta accumulando bitcoin a un ritmo inferiore rispetto a prima, con conseguenti movimenti delle balene meno significativi. D’altra parte, la capitalizzazione di mercato delle stablecoin continua ad aumentare, ma a un ritmo più lento rispetto a prima.</p>
<p>A proposito, WClementeIII ha detto che il bitcoin è <a href="https://www.gate.io/blog_detail/1697" target="_blank">avvicinandosi al costo a breve termine per il detentore</a> base. Pubblicazione su X, <a href="https://twitter.com/WClementeIII/status/1803070012023849333" rel="nofollow noopener noreferrer" target="_blank">ha detto</a>, “BTC si avvicina alla base di costo dei detentori a breve termine intorno a $ 63,8k, non voglio vedere giorni consecutivi chiusi al di sotto. Di solito funge da buona linea di demarcazione per le tendenze.” La base di costo dei detentori a breve termine è il prezzo medio a cui gli investitori recenti hanno acquistato bitcoin. Pertanto, se il prezzo del BTC scende al di sotto della linea di supporto più vicina a $ 63.800, i trader potrebbero panico e vendere bitcoin in grandi quantità. Tale risposta potrebbe portare a un ulteriore crollo del prezzo.</p>
<h2 id="h2-Transazione20balenottera20di20Bitcoin20spostamento20di20BTC20del20valore20di204420milioni20dopo20un20decennio588891"><a name="Transazione balenottera di Bitcoin: spostamento di BTC del valore di $44 milioni dopo un decennio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Transazione balenottera di Bitcoin: spostamento di BTC del valore di $44 milioni dopo un decennio</h2><p>Un altro pezzo di evidenza che mostra che alcuni bitcoin <a href="https://www.gate.io/how-to-buy/long-long" target="_blank">i detentori a lungo termine sono disposti a vendere le loro partecipazioni</a> è il movimento di bitcoin di una balena che era in un portafoglio inattivo da un decennio. In particolare, un portafoglio bitcoin inattivo negli ultimi 10 anni ha spostato 687,33 BTC, del valore di circa $44 milioni, per la prima volta. Quel portafoglio ha ricevuto i suddetti bitcoin il 12 gennaio 2014. Non ci sono motivi noti per quel recente movimento delle monete.</p>
<h2 id="h2-Tendenze20di20mercato20recenti20uscite20di20Bitcoin20ETF20la20performance20delle20societ20di20mining20di20Bitcoin839282"><a name="Tendenze di mercato recenti: uscite di Bitcoin ETF, la performance delle società di mining di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato recenti: uscite di Bitcoin ETF, la performance delle società di mining di Bitcoin</h2><p>Come accennato in precedenza, i trader non sono nel <a href="https://www.gate.io/how-to-buy/bitcoin-btc" target="_blank">umore per comprare bitcoin</a>. Allo stesso tempo, il tasso con cui le balene stanno acquisendo bitcoin è diminuito a causa del sentimento esistente nel mercato delle criptovalute. Alcuni analisti di mercato pensano che molti minatori di bitcoin stiano vendendo le loro posizioni per raccogliere capitali per entrare nel settore dell’intelligenza artificiale, che sembra redditizio.</p>
<p>Lucy Hu, analista senior presso il fondo criptato Metalpha, sostiene che la diminuzione delle ricompense di mining e la lenta crescita del prezzo del bitcoin stiano costringendo i minatori a spostare la loro attenzione verso il settore dell’intelligenza artificiale (AI). A riguardo, <a href="https://www.bee.com/th/13582.html" rel="nofollow noopener noreferrer" target="_blank">Bee citò Hu dicendo</a>, “Il calo delle ricompense per l’estrazione ha spinto i minatori a cercare altri canali per aumentare il loro reddito. A causa della domanda di centri dati ad alta intensità energetica da parte delle aziende di intelligenza artificiale, i minatori di Bitcoin stanno gradualmente guadagnando ricavi dalle vendite alle aziende di intelligenza artificiale.”</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/predicting-the-next-five-years-of-cryptocurrency-2024-2029-innovations-regulations-and-market-predictions/3267" target="_blank">Prevedere i prossimi cinque anni di criptovaluta 2024-2029</a></p>
<h2 id="h2-Analisi20onchain20e20previsioni20di20mercato20per20BTC684932"><a name="Analisi on-chain e previsioni di mercato per BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi on-chain e previsioni di mercato per BTC</h2><p>Nonostante, al momento della scrittura bitcoin si scambia a $60,868 il suo prezzo potrebbe riprendersi presto. Come potreste sapere, il prezzo di bitcoin è diminuito del 10% negli ultimi 30 giorni come mostra il seguente diagramma.<br><img src="https://gimg2.gateimg.com/image/article/17199346792.jpg" alt=""><br>Grafico mensile dei prezzi di Bitcoin - CoinGecko</p>
<p>Come si può vedere dal grafico mensile sopra riportato, il prezzo del bitcoin è diventato ribassista il 7 giugno fino al 24 giugno quando è entrato in una zona di domanda. Gli ultimi due bar del grafico del prezzo sono verdi, indicando un momento rialzista in aumento. La sua attuale zona di domanda di 14 bar dovrebbe rappresentare una solida base per un… <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">forte aumento del prezzo di BTC</a>. Secondo le previsioni di Coinpedia, il prezzo del bitcoin potrebbe scendere a $57,963 se il momento ribassista continua. Tuttavia, un forte rimbalzo potrebbe spingere il bitcoin al livello di prezzo di $66,173.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/bitcoin-btc" target="_blank">Previsione del prezzo di Bitcoin &amp; Prognosi per il 2024, 2025, 2030</a></p>
<h2 id="h2-Conclusion156677"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Durante le prime tre settimane di giugno, i grandi detentori di bitcoin hanno venduto BTC per un valore di $44.000. La maggior parte di questi venditori sono minatori che potrebbero voler passare la loro potenza di calcolo al settore dell’intelligenza artificiale. D’altra parte, se il momento ribassista persiste, il prezzo del bitcoin potrebbe scendere a $57.963. Tuttavia, potrebbe anche ritracciare verso il punto di prezzo di $66.173.</p>
<div class="blog-details-info"><br><div>Autore:<em> Mashell C.</em>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista 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 ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>