SSBtaW5hdG9yaSBkaSBCVEMgYXVtZW50YW5vIGxhIHByZXNzaW9uZSBkZWxsZSB2ZW5kaXRlOiB2ZW5kaXRhIGRpICQ0MSBN

2023-08-29, 09:40

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>Un aumento in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> la vendita durante gli ultimi due mesi ha depresso il suo valore di mercato.</p>
<p>L’aumento della difficoltà del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> potrebbe aver costretto molti minatori a vendere molti BTC.</p>
<p>A causa dell’alta pressione delle vendite <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> è inferiore a $27.000.</p>
<p>Parole chiave: mining di bitcoin, mining di BTC, minatori di BTC, minare BTC, comprare BTC, prezzo del bitcoin</p>
<h2 id="h2-Introduzione877028"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’attività dei minatori di Bitcoin ha influenzato <a href="https://www.gate.io/price" target="_blank">il prezzo della criptovaluta</a>. Spesso quando i minatori scaricano le loro monete sul mercato ciò può portare a una caduta del loro prezzo. Recentemente, gli investitori di Bitcoin hanno sollevato preoccupazione per l’aumento della quantità di BTC che i minatori stanno scaricando sul mercato. Questo articolo analizza l’impatto dell’ultima vendita di massa da parte dei minatori di bitcoin.</p>
<h2 id="h2-I20minatori20di20Bitcoin20aumentano20la20quantit20di20BTC20sul20mercato56131"><a name="I minatori di Bitcoin aumentano la quantità di BTC sul mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I minatori di Bitcoin aumentano la quantità di BTC sul mercato</h2><p>Il <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">prezzo del bitcoin</a> è aumentato dall’inizio dell’anno nonostante le sfide come la repressione delle criptovalute negli Stati Uniti. Tuttavia, il prezzo del bitcoin non è riuscito a salire sopra i $32.500 a causa di diversi fattori, tra cui lo smaltimento di massa dei BTC miner sul mercato.</p>
<p>Da giugno molti minatori di Bitcoin hanno aumentato le quantità di BTC che hanno scaricato sugli scambi, causando una maggiore pressione venditrice rispetto al passato. Secondo Glassnode, l’azienda di analisi dei dati on-chain, molte aziende di mining di bitcoin hanno inviato grandi quantità di BTC agli scambi.</p>
<p>Inoltre, i dati su Glassnode indicano che la quantità totale di bitcoin che i minatori hanno portato agli scambi ha raggiunto un massimo di tre anni il 3 giugno, un livello che è stato raggiunto per l’ultima volta durante il mercato rialzista del 2021.</p>
<p>Queste informazioni sono coerenti con i dati di Coin Metrics che indicano un netto calo della metrica dell’approvvigionamento a un salto dei minatori, che tiene traccia della quantità di bitcoin conservati in portafogli digitali che ricevono BTC da vari pool di mining. La metrica mostra un aumento del possesso di bitcoin da parte dei minatori da maggio di quest’anno. Tuttavia, dalla seconda settimana di giugno il numero di bitcoin nei portafogli dei minatori ha iniziato a diminuire.</p>
<p>Ad esempio, i minatori di bitcoin hanno scaricato più di 14.000 BTC, del valore di circa 41,2 milioni di dollari, sugli scambi durante un periodo di 24 ore che si è esteso dal 12 al 13 luglio. L’aumento della pressione venditrice di BTC è stato accompagnato da una bassa volatilità negli ultimi 40 giorni. Durante la maggior parte di quel periodo, il prezzo del bitcoin si aggirava intorno ai 30.000 dollari.<br><img src="https://gimg2.gateimg.com/image/article/16933018561.png" alt=""><br>Pressione di vendita di Bitcoin - CryptoQuant</p>
<p>Come indica il diagramma sopra, c’erano più venditori di BTC che acquirenti.</p>
<p>In quel momento Maartun ha commentato: “Il volume di vendita dei taker continua a superare significativamente gli acquirenti taker. Ecco perché il prezzo è ancora soppresso al di sotto dei 30.000 dollari.” Tuttavia, se il prezzo del BTC supera i 32.000 dollari, i minatori potrebbero smettere di vendere i loro bitcoin, il che potrebbe far salire il prezzo.</p>
<h2 id="h2-Effetti20dellottimismo20BTC20ERFs20sul20prezzo20del20Bitcoin688976"><a name="Effetti dell’ottimismo BTC ERFs sul prezzo del Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Effetti dell’ottimismo BTC ERFs sul prezzo del Bitcoin</h2><p>Nonostante la recente grande vendita di BTC, Glassnode rivela che ci sono molti investitori di bitcoin che detengono ancora grandi quantità della criptovaluta. Infatti, ha indicato che i detentori di bitcoin a lungo termine hanno raggiunto un nuovo record di 14,59 milioni di monete, che corrisponde a circa il 75% dell’offerta circolante di bitcoin. Ciò dimostra la loro volontà di detenere BTC nonostante il mercato depresso a breve termine. Il grafico successivo mostra la variazione della quantità di BTC accumulata dagli investitori a lungo termine quest’anno.<br><img src="https://gimg2.gateimg.com/image/article/16933018682.png" alt=""><br>Bitcoin Holding - Glassnode</p>
<p>Come mostrato dal grafico a linea blu nel diagramma sopra, c’è stato un aumento della quantità di bitcoin che gli investitori a lungo termine detengono.</p>
<p>Alcuni analisti, tuttavia, ritengono che un forte catalizzatore come il <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/218" target="_blank">approvazione degli ETF BTC</a> potrebbe spingere il suo prezzo al di sopra della zona compresa tra $30.000 e $32.000. Nel mese scorso, il prezzo del bitcoin spesso si è ritirato a $29.000 anche se aveva registrato un picco per un breve periodo.</p>
<p>Secondo gli analisti, la maggior parte di questi detentori di Bitcoin a lungo termine prevede che la Securities and Exchange Commission (SEC) degli Stati Uniti possa approvare gli ETF di bitcoin. Recentemente, la SEC ha ricevuto molti <a href="https://www.gate.io/blog_detail/379/what-are-bitcoin-etfs-bitcoin-etfs-explained" target="_blank">applicazioni per ETF BTC</a> da varie istituzioni finanziarie tradizionali di buona reputazione <a href="https://www.gate.io/blog_detail/1643/blackrock-launches-blockchain-related-etf-for-european-markets." target="_blank">come BlackRock</a>.</p>
<p>Tuttavia, la SEC non ha commentato sugli ETF BTC. Invece, ha aperto una finestra di 21 giorni per ottenere le opinioni del pubblico su di essi. Alcuni importanti operatori del settore come Ark Invest Cathie Wood e Galaxy Digital Mike Novogratz, tuttavia, hanno dichiarato di aspettarsi che la SEC li approvi in qualsiasi momento.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/207/why-do-people-choose-crypto-etfs-what-are-the-advantages-and-disadvantages" target="_blank">Perché le persone scelgono gli ETF criptati? Quali sono i vantaggi e gli svantaggi?</a></p>
<h2 id="h2-Motivi20per20lalto20selloff20dei20minatori20BTC895442"><a name="Motivi per l’alto sell-off dei minatori BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Motivi per l’alto sell-off dei minatori BTC</h2><p>Ci sono diverse ragioni progettate per cui le migliori aziende che estraggono BTC vendono le loro riserve in grandi quantità. I minatori di Bitcoin potrebbero aver venduto le monete per ottenere profitto.</p>
<p>Il <a href="https://www.gate.io/learn/articles/what-is-btc-mining/287" target="_blank">mining di BTC</a> Le aziende potrebbero aver venduto le loro partecipazioni per coprire i crescenti costi operativi derivanti dai mercati ribassisti prolungati iniziati nel 2022. Anche se il mercato crittografico sta cercando di scrollarsi di dosso il periodo ribassista, i prezzi della maggior parte delle criptovalute, compreso il BTC, rimangono depressi. Sono ben lontani dai massimi storici, per lo più registrati nel 2021.</p>
<p>I minatori potrebbero vendere le loro partecipazioni a causa dell’aumento della difficoltà del bitcoin, una metrica che misura il livello di difficoltà che i minatori incontrano per trovare nuovi blocchi. Un aumento della difficoltà del bitcoin porta a una riduzione dei guadagni dei minatori che potrebbe ridurre i loro profitti o addirittura aumentare le loro perdite. La diminuzione dei ricavi potrebbe costringerli a vendere più bitcoin di prima per coprire le spese operative.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/359/understanding-cryptocurrency-mining" target="_blank">Comprensione del mining di criptovaluta</a></p>
<p>La diminuzione dell’attività degli ordinali Bitcoin potrebbe aver costretto i minatori a vendere più BTC. Per gran parte del primo semestre dell’anno il fatturato dei minatori proveniva dall’attività degli ordinali BTC. La sua diminuzione a maggio potrebbe aver costretto le aziende che estraggono Bitcoin a vendere parte dei loro averi.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/250/gate.io-observation-how-to-use-cloud-mining-to-mine-bitcoin-in-just-one-click" target="_blank">Come utilizzare il cloud mining per estrarre Bitcoin in un solo clic?</a></p>
<h2 id="h2-Cosa20succederebbe20se20i20minatori20di20Bitcoin20smettessero20di20vendere20in20modo20massiccio20BTC751474"><a name="Cosa succederebbe se i minatori di Bitcoin smettessero di vendere in modo massiccio BTC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa succederebbe se i minatori di Bitcoin smettessero di vendere in modo massiccio BTC?</h2><p>Durante gli ultimi mesi il prezzo del bitcoin è stato fluttuante all’interno di un piccolo canale, $27,000 a $31,500. Tuttavia, attualmente il prezzo del bitcoin è al di sotto di questo intervallo poiché è in negoziazione a $26,095.</p>
<p>Se i minatori di BTC riducono la quantità di bitcoin, potrebbe verificarsi una carenza sul mercato che potrebbe spingere il prezzo sopra i $32.000. Tuttavia, non c’è garanzia che il suo prezzo aumenterà nel prossimo futuro. Pertanto, gli investitori dovrebbero fare la loro ricerca indipendente e investire solo la quantità che possono permettersi di perdere.</p>
<p>È anche importante notare che <a href="https://www.gate.io/how-to-buy/bitcoin-btc" target="_blank">molti investitori comprano BTC</a> quando il suo prezzo è basso per generare profitti più alti quando il suo valore aumenta.</p>
<p>Leggi anche su <a href="https://www.gate.io/learn/articles/best-mining-software-in-2023/523" target="_blank">Miglior software di mining nel 2023</a></p>
<h2 id="h2-Conclusion695822"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>I minatori di Bitcoin hanno venduto molti bitcoin da giugno, portando ad una forte pressione venditrice. Di conseguenza, il suo prezzo è rimasto relativamente basso, oscillando tra i $27.000 e i $31.500. Attualmente, però, il prezzo del Bitcoin è inferiore ai $27.000, essendo scambiato a $26.095.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1671/bitcoin-mining-profit-squeezed-in-face-of-surging-hash-rate-and-mining-difficulty" target="_blank">Il profitto del mining di Bitcoin viene compresso di fronte all’aumento della hash rate e della difficoltà di mining</a></p>
<h2 id="h2-Domande20frequenti20su20Bitcoin967610"><a name="Domande frequenti su Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Bitcoin</h2><h3 id="h3-Lottimismo20sugli20ETF20pu20innescare20una20rottura20del20BTC704651"><a name="L’ottimismo sugli ETF può innescare una rottura del BTC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ottimismo sugli ETF può innescare una rottura del BTC?</h3><p>È probabile che l’approvazione degli ETF su bitcoin da parte della SEC inneschi un forte aumento del prezzo di BTC. Tuttavia, la misura in cui il prezzo di BTC potrebbe aumentare dipende da altre variabili di mercato come i tassi di interesse, il livello di inflazione e l’attuale contesto normativo.</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. La ripubblicazione dell'articolo sarà consentita a condizione che sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>