MTYgbnVvdmkgaW5kaXJpenppIEJpdGNvaW4gKEJUQykgY29tcGFpb25vIGluIHVuIHNvbG8gZ2lvcm5vIC0gTGUgYmFsZW5lIGNyaXB0byBzaSBtdW92b25v

2023-10-31, 06:07

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>Dal marzo 2022 c’è stato un aumento del 8,12% nel numero di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> portafogli che detengono almeno 10 BTC.</p>
<p>I proprietari di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> a lungo termine possiedono il 69% dell’offerta circolante totale di bitcoin.</p>
<p>C’è alta <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> tra gli investitori di bitcoin nei paesi in via di sviluppo.</p>
<p>Parole chiave: indirizzi delle balene di Bitcoin, balene di Bitcoin, balena BTC, prezzo di Bitcoin, avviso sulle balene di Bitcoin, balena crittografica, detentori di BTC, investitori di BTC</p>
<h2 id="h2-Introduzione411154"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La performance dei prezzi delle criptovalute è stata migliore a ottobre rispetto ai mesi precedenti. Le vittorie di Ripple Labs contro la SEC e la prospettiva del <a href="https://www.gate.io/fr/blog_detail/3076/can-spot-bitcoin-etfs-become-market-catalysts-if-approved &quot;approval of bitcoin (BTC" rel="nofollow noopener noreferrer" target="_blank">approvazione degli ETF di bitcoin (BTC)</a> Gli ETF (Exchange-Traded Funds) sembrano aver dato vita al settore delle criptovalute. Ad esempio, c’è stato un aumento dell’attività delle balene del bitcoin durante il mese.</p>
<p>In questo articolo, esploreremo l’aumento recente degli indirizzi del portafoglio bitcoin in un solo giorno. Analizzeremo anche l’attuale ottimismo nei confronti del bitcoin nonostante le sfide esistenti.</p>
<h2 id="h2-Aumento20del20numero20di20indirizzi20del20portafoglio20Bitcoin610851"><a name="Aumento del numero di indirizzi del portafoglio Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aumento del numero di indirizzi del portafoglio Bitcoin</h2><p>Negli ultimi giorni c’è stato un aumento dell’attività di Bitcoin. I dati di Santiment, una società di analisi crittografica, mostrano che sono stati aggiunti 16 nuovi indirizzi del portafoglio Bitcoin entro 24 ore che si sono estese dal 13 al 14 ottobre. Quell’aumento degli indirizzi si è verificato nello stesso periodo in cui <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo di Bitcoin</a> aveva effettuato diversi tentativi di superare il livello di resistenza di $27.000.</p>
<p>Secondo Santiment, l’aumento degli indirizzi Bitcoin che coinvolgono le balene Bitcoin che detengono tra 100 e 1.000 BTC segna il livello più alto di tale attività dal 28 febbraio 2022. A causa di questi gruppi, il conteggio totale degli indirizzi del portafoglio Bitcoin è ora di 13.967. Il grafico seguente mostra le variazioni nelle detenzioni del portafoglio delle balene BTC.<br><img src="https://gimg2.gateimg.com/image/article/16987322131.png" alt=""><br>Indirizzi Bitcoin delle balene - Santiment</p>
<p>L’altra cosa degna di nota che mostrano gli indirizzi delle balene di bitcoin è la progressione dei più piccoli <a href="https://www.gate.io/learn/articles/bitcoin-wallets-which-what-why/491" target="_blank">Portafogli BTC</a> in un livello superiore. Attualmente, ci sono 140.210 portafogli che contengono tra 10 e 100 BTC.</p>
<p>Ancora più interessante, dal marzo 2022 c’è stato un aumento dell’8,12% nei portafogli che detengono almeno 10 BTC. In particolare, durante quel periodo sono state create 11.806 nuove adresse di portafoglio BTC.</p>
<p>Gli investitori possono tenere traccia delle variazioni nella quantità di bitcoin che i whale detengono utilizzando gli allarmi sui whale che pubblicano dati aggiornati sui movimenti BTC significativi.</p>
<p>L’aumento dei portafogli Bitcoin non è stata l’unica cosa notevole accaduta nel periodo tra febbraio 2022 e il presente. Il lungo termine BTC <a href="https://www.gate.io/blog_detail/1622/daily-flash-number-of-bitcoin-holders-has-been-rising-despite-bear-market-mcdonald-s-begins-to-accept-bitcoin-and-tether-in-swiss-town" target="_blank">I detentori hanno anche aumentato le loro detenzioni</a> Secondo i dati di IntoTheBlock, gli investitori che hanno tenuto il proprio bitcoin per oltre un anno possiedono circa il 69% dell’offerta circolante totale.</p>
<p>Con gran parte del bitcoin esistente nelle mani dei detentori a lungo termine (LTH), la moneta è ora più rara di prima. Secondo Charles Edwards, fondatore di un fondo di investimento in asset digitali Capriole Investments, tale sviluppo è il primo nella vita del bitcoin e indica una forte probabilità di un’impennata dei prezzi del bitcoin nel prossimo futuro.</p>
<p><a href="https://twitter.com/caprioleio/status/1714740672392229041" rel="nofollow noopener noreferrer" target="_blank">Edwards ha scritto su X</a>, “Superando il record stabilito nel 2015. Meno offerta liquida significa che le stesse persone stanno offrendo per meno monete. Fai i conti.”</p>
<p>Tuttavia, le statistiche di Edwards, raccolte da Santiment, differiscono da quelle di IntoTheBlock in quanto mostrano che gli investitori a lungo termine di BTC possiedono il 76,2% dell’attuale offerta circolante. Il grafico successivo fornisce maggiori dettagli.<br><img src="https://gimg2.gateimg.com/image/article/16987323022.png" alt=""><br>LTH come percentuale della rete – Edwards X</p>
<p>Edwards crede che ci sia un effetto a catena poiché il bitcoin disponibile per gli altri sta gradualmente diminuendo.</p>
<h2 id="h2-Lottimismo20persiste20nonostante20le20sfide20del20prezzo20del20Bitcoin140867"><a name="L’ottimismo persiste nonostante le sfide del prezzo del Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’ottimismo persiste nonostante le sfide del prezzo del Bitcoin</h2><p>La ragione prente di ottimismo tra i possessori di bitcoin è la prospettiva che la SEC possa presto approvare gli ETF di bitcoin spot. Ci sono diverse grandi società di gestione patrimoniale <a href="https://www.gate.io/de/blog_detail/3317/former-blackrock-md-sees-shift-in-sentiment-towards-spot-bitcoin-etf" target="_blank">come BlackRock</a> e Grayscale che hanno <a href="https://www.gate.io/blog_detail/3289/sec-postpones-decision-on-spot-bitcoin-etfs-from-blackrock-and-others" target="_blank">richiesto ETF su BTC</a>.</p>
<p>Una recente decisione di un giudice federale che riguarda il <a href="https://www.gate.io/de/blog_detail/3357/sec-appeal-grayscale-btc-etf" target="_blank">La SEC dovrebbe esaminare la domanda di Grayscale per un ETF bitcoin spot</a> è stato ben accolto dal mercato delle criptovalute. L’ETF di bitcoin creerà una maggiore esposizione al bitcoin rispetto al passato, poiché gli investitori finanziari tradizionali commerceranno indirettamente la criptovaluta.</p>
<p>CoinShares ha anche riportato che molti investitori istituzionali stanno mettendo i loro fondi in bitcoin poiché è la criptovaluta numero uno. Inoltre, un recente sondaggio condotto da Block, Inc. di Jack Dorsey mostra che c’è un’alta adozione di bitcoin nei paesi in via di sviluppo.</p>
<p>Secondo il sondaggio, le persone nei paesi in via di sviluppo vedono il bitcoin come qualcosa di più di un asset speculativo. Per loro, BTC è un simbolo di libertà finanziaria, una strada per eludere le istituzioni finanziarie tradizionali e uno “strumento” contro l’instabilità economica.</p>
<p>Felipe Chacon, un economista di Block, concorda con questi sentimenti. Ha detto: ‘Questo illustra davvero l’attenzione che il bitcoin sta ricevendo e la sua capacità di fungere da rete di pagamenti globale, e che l’adozione più significativa di questa rete sta cominciando a radicarsi nel Sud globale’.</p>
<p>Alcuni dei paesi che hanno partecipato al sondaggio sono Vietnam, Messico, India, Cina, Nigeria, Argentina e Brasile. Nonostante questo ottimismo, il bitcoin sta attualmente affrontando alcune sfide.</p>
<h2 id="h2-Sfide20che20Bitcoin20sta20affrontando132242"><a name="Sfide che Bitcoin sta affrontando" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sfide che Bitcoin sta affrontando</h2><p><a href="https://www.gate.io/learn/articles/what-is-bitcoin/169" target="_blank">Bitcoin</a> Like many cryptocurrencies, Bitcoin is facing some challenges. First, there is a lack of regulatory clarity in many countries which is inhibiting its adoption.</p>
<p>In secondo luogo, il suo prezzo è ancora inferiore a quello dell’era Covid-19. Ad esempio, nel novembre 2021, il bitcoin ha raggiunto i $69.000. Tuttavia, attualmente il prezzo del bitcoin oscilla tra i $30.000 e i $35.000 come mostra il grafico successivo.<br><img src="https://gimg2.gateimg.com/image/article/16987323803.png" alt=""><br>Prezzo di Bitcoin, Ottobre - CoinMarketCap</p>
<p>Come visto su <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">Il Grafico</a>, dal 24 ottobre il prezzo del bitcoin è oscillato tra $33.000 e $35.000.</p>
<h2 id="h2-Conclusione653913"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il 14 ottobre 2023, Santiment ha riferito che c’erano 16 nuovi indirizzi del portafoglio BTC che detengono tra 10 e 1.000 bitcoin. A quel tempo, i detentori di BTC a lungo termine possedevano il 69% dell’offerta circolante attuale. Fondamentalmente, c’è molta ottimismo nel mercato del bitcoin, anche se ci sono anche sfide come il prezzo depresso.</p>
<h2 id="h2-Domande20frequenti20su20Bitcoin903748"><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-Cos20un20avviso20di20balena20in20cripto767422"><a name="Cos’è un avviso di balena in cripto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è un avviso di balena in cripto?</h3><p>Un avviso balenottera è una piattaforma che raccoglie e valuta i prezzi delle criptovalute in tempo reale e pubblica i portafogli che possiedono grandi quantità di un token o di una moneta. La linea guida generale è che un portafoglio crittografico che detiene una moneta o un token del valore di $100.000 o più <a href="https://www.gate.io/learn/articles/what-are-cryptocurrency-whales/714" target="_blank">è una balena crittografica</a> Una balena può essere definita anche come un portafoglio digitale che detiene almeno l’1% dell’offerta circolante della criptovaluta.</p>
<h3 id="h3-Come20posso20tracciare20le20balene20cripto642346"><a name="Come posso tracciare le balene cripto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come posso tracciare le balene cripto?</h3><p>Puoi tracciare <a href="https://www.gate.io/de/blog_detail/2250" target="_blank">balene cripto</a> seguendo piattaforme che pubblicano dati sugli ultimi indirizzi del portafoglio delle balene. È anche possibile inserire un certo indirizzo del portafoglio in un protocollo che determina se è una balena o no.</p>
<h3 id="h3-La20criptovaluta2020controllata20dalle20balene128727"><a name="La criptovaluta è controllata dalle balene?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La criptovaluta è controllata dalle balene?</h3><p>In termini generali, le balene non controllano le criptovalute. Tuttavia, possono influenzare i prezzi delle criptovalute attraverso le loro attività di acquisto e vendita. Ad esempio, se molte balene vendono una certa criptovaluta, il suo valore potrebbe diminuire. D’altra parte, se alcune balene <a href="https://www.gate.io/buy_crypto" target="_blank">acquistare grandi quantità di una criptovaluta</a> il suo prezzo potrebbe aumentare.</p>
<h3 id="h3-Quanto20BTC2020considerato20una20balena943747"><a name="Quanto BTC è considerato una balena?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto BTC è considerato una balena?</h3><p>Una balena di bitcoin è un portafoglio che detiene almeno 100 bitcoin o BTC con un valore di $10 milioni o superiore. Tuttavia, le persone possono definire le balene di bitcoin in modo diverso.</p>
<h3 id="h3-Perch20le20balene20scaricano20bitcoin195562"><a name="Perché le balene scaricano bitcoin?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché le balene scaricano bitcoin?</h3><p>Una balena potrebbe scaricare bitcoin se ritiene che il suo prezzo sia salito a un livello che può generare molto profitto. Alcuni potrebbero vendere molti bitcoin per far scendere il suo prezzo. Altri potrebbero scaricare bitcoin per raccogliere denaro per acquistare altre criptovalute in tendenza.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>