Qml0Y29pbiBlIEV0aGVyIGhhbm5vIHByZXNvIHN0cmFkZSBkaXZlcnNlIC0gcXVlc3RvIHN0YSBkaXZlbnRhbmRvIHVuJ29wcG9ydHVuaXTDoCBwZXIgZ2xpIGludmVzdGl0b3JpIGNyaXB0byBuZWwgMjAyMw==

2023-03-08, 08:44

<p><img src="https://gimg2.gateimg.com/image/article/1678264742industry analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR964375"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’evento dell’halving previsto nel 2024 potrebbe essere alla base dell’aumento del prezzo del BTC.</p>
<p>Il coefficiente di correlazione tra BTC ed ETH è diminuito dell’18% nel gennaio 2023.</p>
<p>L’offerta di ETH sull’exchange è aumentata a gennaio mentre quella di BTC è diminuita.</p>
<h2 id="h2-Introduzione668097"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dal 2023 in poi, il sentimento di mercato è diventato più positivo rispetto al 2022 a causa dei cambiamenti delle variabili macroeconomiche, tra cui l’inflazione e i tassi di interesse. La possibilità che la Federal Reserve riduca i tassi di interesse, così come la leggera diminuzione del tasso di inflazione negli Stati Uniti, ha creato una speranza per un anno migliore per le criptovalute - il 2023.</p>
<p>Già abbiamo assistito ad un’impennata delle principali criptovalute, in particolare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e Ether a gennaio. Tuttavia, le due posizioni nette più grandi nelle criptovalute sugli scambi si sono allontanate l’una dall’altra. Questo perché c’è stato un calo della correlazione tra le due, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e ETH. Questo articolo copre il cambiamento nelle posizioni nette di BTC e ETH e le ragioni per cui la loro correlazione sta diminuendo.</p>
<h2 id="h2-Performance20of202020Bitcoin2020e20ETH20nel202023927561"><a name="Performance of   Bitcoin  e ETH nel 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Performance of <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e ETH nel 2023</h2><p>Per comprendere meglio la dinamica attuale del mercato, analizziamo le performance di BTC e ETH nei primi due mesi del 2023. Al 11 febbraio 2023, il prezzo di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> era <a href="https://www.gate.io/blog_detail/2047/5-things-you-need-to-know-about-the-crypto-market-this-week" target="_blank">leggermente sopra i $21.000</a>, anche se ha scambiato sopra i $23.000 nelle due settimane precedenti. Infatti, ha superato il livello di $23.000 il 21 gennaio.</p>
<p>Alcuni analisti ritengono che l’attuale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> l’andamento al rialzo potrebbe essere il risultato del prossimo evento di dimezzamento che <a href="https://www.gate.io/article/28944/gate.io-blog-btc-will-surpass-100k-after-the-2024-btc-halving-event" target="_blank">si verificherà nel 2024</a>. Di solito, BTC inizia a salire di valore circa un anno prima dell’evento di dimezzamento e più di un anno dopo quell’evento.</p>
<p>L’altro possibile motivo per l’attuale rally è la leggera diminuzione del tasso di inflazione negli Stati Uniti che potrebbe contribuire a fermare i rialzi dei tassi di interesse. Questi fattori creano un ambiente favorevole agli investimenti in criptovalute.</p>
<p>L’altro fattore contributivo è l’accumulo di BTC <a href="https://www.gate.io/blog_detail/1340/What-are-crypto-whales-and-how-do-you-track-them" target="_blank">dalle balene del bitcoin</a>. Secondo Santiment, l’aggregatore on-chain, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Le balene hanno recentemente acquistato e detenuto grandi quantità di BTC, il che è un segno di un potenziale recupero.</p>
<p>Simile a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, ETH ha sperimentato una forte pressione d’acquisto dall’inizio dell’anno. Tuttavia, non è stato così rialzista come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, in quanto ha guadagnato con un margine inferiore. Ciò potrebbe spiegare la differenza delle loro posizioni nette sugli scambi.</p>
<h2 id="h2-Qual2020la20posizione20dellattivo20netto20sulla20borsa20valori155617"><a name="Qual è la posizione dell’attivo netto sulla borsa valori?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la posizione dell’attivo netto sulla borsa valori?</h2><p>La posizione netta dell’attivo di un titolo è la differenza tra il costo iniziale di creazione di una posizione e il suo valore di negoziazione attuale. Ad esempio, se sono state acquistate 1.000 opzioni al prezzo di $2,00 ciascuna e sono negoziate a $10,00 ciascuna, la posizione netta è di $10.000 meno $2.000, che è uguale a $8.000.</p>
<h2 id="h2-Bitcoin2020cambiamento20nella20posizione20netta20vs20ETH967111"><a name="Bitcoin  cambiamento nella posizione netta vs. ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> cambiamento nella posizione netta vs. ETH</h2><p>In termini di criptovaluta, la posizione netta dell’attivo è la differenza tra il valore dei prelievi e dei depositi. Pertanto, i cambiamenti della posizione netta della criptovaluta riflettono le fluttuazioni dell’afflusso e deflusso dell’attivo sugli scambi. Ad esempio, un aumento dell’afflusso di un’attività sugli scambi indica un aumento della pressione di vendita. Il diagramma seguente mostra la diminuzione degli afflussi di BTC dal 24 gennaio al 5 febbraio.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826489610851678264645_.pic.jpg" alt=""><br>Diminuzione dell’afflusso di BTC- Chainanalysis</p>
<p>Questa diminuzione dell’afflusso di BTC indica che c’è una diminuzione della pressione venditrice. Il grafico successivo ci aiuta a avere un’immagine più chiara del sentiment di mercato di BTC.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826492410861678264659_.pic.jpg" alt=""><br>Diminuzione dell’importo di BTC sugli scambi - Chainanalysis</p>
<p>Come osservato nel diagramma sopra, c’è stato un calo di BTC sugli scambi. Ciò significa che c’è una diminuzione del numero di partecipanti che vogliono venderlo. La situazione è diversa da quella dell’ETH. Il grafico successivo mostra un aumento della quantità di ETH sugli scambi alla fine di gennaio 2023.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826494910871678264667_.pic.jpg" alt=""><br>Aumento dell’importo di ETH sugli scambi - Chainanalysis</p>
<p>Come mostrato nel diagramma, tra il 14 gennaio e il 30 gennaio il volume di ETH sugli scambi è stato inferiore a quello tra il 31 gennaio e il 5 febbraio. Questo mostra la separazione di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e Ether in termini delle loro quantità sugli scambi. In altre parole, c’è una divergenza del mercato crittografico.</p>
<h2 id="h2-Bitcoin2020cambiamenti20nella20posizione20di20vs20Ether20net693564"><a name="Bitcoin  cambiamenti nella posizione di vs Ether net" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> cambiamenti nella posizione di vs Ether net</h2><p>I cambiamenti delle posizioni nette di BTC ed ETH sulle borse sono stati separati dall’inizio del 2023. Ciò è dovuto alla diminuzione dell’offerta di BTC sulla borsa mentre quella <a href="https://www.gate.io/es/blog_detail/2073/daily-news-crypto-market-begins-to-descend-further-as-stock-market-follows-suit-vitalik-buterin-divulges-the-final-challenge-for-ethereum" target="_blank">di ETH sta aumentando</a>. Il diagramma seguente mostra le variazioni della posizione netta di BTC sugli scambi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826499410881678264675_.pic.jpg" alt=""><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> posizione netta di ‘s - Coindesk</p>
<p>Il diagramma mostra chiaramente una diminuzione della posizione netta di BTC. La situazione è diversa da quella di ETH come indicato nel diagramma successivo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/167826501510891678264683_.pic.jpg" alt=""><br>La posizione netta di ETH sugli scambi - Coindesk</p>
<p>Nel diagramma puoi osservare un aumento dell’offerta di ETH mostrato dalle barre verdi alla fine <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">Il Grafico</a>. Questo <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e la differenziazione di Ether potrebbe derivare dalla percezione del mercato. Più specificamente, gli utenti di criptovaluta potrebbero essere in fase di visualizzazione <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e ETH come sostituti, dove la maggior parte di loro preferisce BTC a ETH.</p>
<h2 id="h2-Bitcoin2020vs20Eth20il20calo20della20correlazione561706"><a name="Bitcoin  vs. Eth: il calo della correlazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> vs. Eth: il calo della correlazione</h2><p>Un’altra spiegazione per i percorsi separati <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e Ether potrebbero subire una caduta nella loro correlazione. <a href="https://www.gate.io/article/28405" target="_blank">coefficiente di correlazione per Bitcoin ed ETH</a> è diminuito del 18% dal 23 gennaio. Come spiegato in precedenza, la data imminente dell’evento di dimezzamento potrebbe essere una delle ragioni. Il vantaggio del primo arrivato potrebbe influenzare anche la dinamica attuale del mercato di BTC e ETH.</p>
<h2 id="h2-Conclusion499547"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>In breve, entrambi <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e ETH hanno sperimentato un momento rialzista dall’inizio del 2023. Tuttavia, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha guadagnato un margine superiore rispetto a ETH. D’altra parte, l’offerta di ETH è aumentata durante gli ultimi giorni di gennaio mentre quella di BTC è diminuita. Questo è un motivo che indica che le tendenze del mercato delle criptovalute potrebbero cambiare nel 2023. Inoltre, la direzione opposta di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e l’Ether è evidente nella caduta del loro coefficiente di correlazione.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore 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à consentita la ripubblicazione dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno adottate azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>