R2xhc3Nub2RlIEluc2lnaHRzOiBCbG9jY2F0byBuZWwgTWV6em8=

2023-07-11, 10:14
<p><img src="https://gimg2.gateimg.com/image/article/1689069864SDFX.jpeg" alt=""></p>
<h2 id="h2-Sommario20Esecutivo192276"><a name="Sommario Esecutivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario Esecutivo</h2><p>I prezzi del <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> si stanno consolidando intorno al punto medio di $30k del ciclo 2021-23, con le performance dei prezzi YTD che rimangono storicamente forti.</p>
<p>Le iscrizioni si sono raffreddate notevolmente e <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> la congestione di rete sta iniziando a diminuire. Tuttavia i volumi di trasferimento monetario stanno aumentando, ora in aumento del +75% rispetto ai minimi di novembre.</p>
<p>L’equilibrio tra l’offerta detenuta in profitto e in perdita ha raggiunto un punto di equilibrio sinonimo del “periodo di riaccumulo” di diversi mesi osservato nei cicli passati.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168906989200_cover-4.png" alt=""></p>
<h2 id="h2-Tenendo20su20OK798506"><a name="Tenendo su OK" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tenendo su OK</h2><p>Il mercato Bitcoin ha mantenuto la maggior parte dei guadagni del 2023 finora, risalendo sopra i $31k nelle ultime settimane. Con il mercato che si sta consolidando vicino ai massimi annuali, possiamo confrontare questa performance di prezzo con i cicli precedenti, sia dal punto di vista del mercato toro che orso.</p>
<p>Se assumiamo che i minimi di novembre 2022 siano effettivamente il piano di ciclo, possiamo confrontare la profondità delle ‘correzioni di mercato toro’ finora. Possiamo vedere che il massimo ribasso nel 2023 è stato solo del -18%, il che è notevolmente superficiale rispetto a tutti i cicli precedenti. Ciò suggerisce forse un grado relativamente forte di domanda sottostante l’asset.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168906992501_pricebull.png" alt=""></p>
<p>Se invece mettiamo gli occhiali da mercato orso, possiamo valutare le prestazioni del 2023 indicizzate dall’ATH del ciclo. Da questo punto di vista, il potente recupero dai minimi di novembre è del 91%, e presenta una notevole somiglianza con le riprese di recupero dei cicli precedenti.</p>
<p>Ad eccezione del 2019, tutti i cicli precedenti che hanno sperimentato un movimento simile dalla parte inferiore, sono stati infatti il punto di origine di un nuovo trend ciclico al rialzo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168906993502_pricebear.png" alt=""></p>
<h2 id="h2-Le20iscrizioni20lasciano20spazio20agli20investitori838664"><a name="Le iscrizioni lasciano spazio agli investitori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le iscrizioni lasciano spazio agli investitori</h2><p>Uno degli eventi più sorprendenti del 2023 è stato l’emergere di ordinali e iscrizioni su Bitcoin. Questo fenomeno ha avuto due fasi distinte <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a> di attività:</p>
<p>Onda 1: Iscrizioni principalmente basate sull’immagine, che portano all’emergere di beni NFT su Bitcoin. Finora sono state iscritte un totale di 1,08 milioni di immagini.</p>
<p>Onda 2: principalmente iscrizioni testuali a pagamento di commissioni elevate associate ai token ‘BRC-20’. In generale, Bitcoin ora ospita 14,8 milioni di iscrizioni testuali.</p>
<p>Per numero di iscrizioni, la Wave 2 è stata un ordine di grandezza superiore, tuttavia l’attività è in costante declino dal mese di maggio. C’è stato un breve aumento delle iscrizioni di testo questa settimana, tuttavia le transazioni non confermate attraverso i mempool di Bitcoin stanno iniziando a risolversi nel complesso.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907068503_Count.png" alt=""></p>
<p>Le iscrizioni hanno anche forzato uno sviluppo molto intrigante nel nostro quadro di interpretazione delle metriche dell’attività on-chain. In generale, i picchi nelle metriche dell’attività on-chain di Bitcoin sono un segnale di una crescente adozione e di una rete sana (ovvero l’incremento è solitamente una buona cosa da vedere).</p>
<p>Tuttavia, a causa del significativo riutilizzo degli indirizzi (WoC 20) e dei volumi di trasferimento molto ridotti (~10k sats) associati alle iscrizioni, i periodi di alta domanda richiedono ora un’interpretazione leggermente più sfumata, riassunta nella seguente tabella.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1689070030activity_table-3.png" alt=""></p>
<p>Tenendo presente ciò, possiamo vedere che mentre le iscrizioni si raffreddano, il momentum degli indirizzi attivi ha ricominciato a salire.</p>
<p>L’interpretazione tradizionale avrebbe visto gli ultimi 2-3 mesi come una diminuzione implicita dell’attività di rete di Bitcoin. Tuttavia, l’interpretazione corretta è che è stato semplicemente un prodotto di un significativo riutilizzo degli indirizzi da parte degli operatori di iscrizione, e l’attività di rete era effettivamente in crescita, con i blocchi che venivano riempiti completamente.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907005805_newaddrmomentum.png" alt=""></p>
<p>Anche il conteggio delle transazioni ha raggiunto un picco precedentemente irraggiungibile, con le iscrizioni che approfittavano dello sconto dati di SegWit. Ciò significava che i minatori potevano inserire più dati di transazione in ogni blocco, con alcuni blocchi che si avvicinavano persino al limite teorico di 4 MB.</p>
<p>Anche il numero di transazioni giornaliere si è ridotto significativamente nelle ultime settimane, in linea con il rallentamento dell’attività di iscrizione.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907006706_txcountmom.png" alt=""></p>
<p>Dopo diversi mesi di congestione della rete, i mempool si stanno lentamente ma sicuramente svuotando, e le commissioni di transazione on-chain si stanno abbassando. Le commissioni di transazione denominate in USD su Bitcoin sono diminuite di oltre il 96% rispetto all’apice della febbre del BRC-20 a maggio, con la commissione media pagata ora di $1,33, con commissioni medie scese a $0,16.</p>
<p>Le metriche delle commissioni, sopra tutte le altre, suggeriscono che attualmente è in corso un rallentamento aggregato dell’attività on-chain.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907009604_feespaid.png" alt=""></p>
<p>Mentre l’attività si sta raffreddando, i volumi di BTC che vengono trasferiti stanno iniziando a aumentare in modo significativo. Il BTC che cambia di mano ha recuperato il 75% dai minimi di FTX, raggiungendo ora $4.2 miliardi al giorno in totale regolamento.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907015107b_entadjvol.png" alt=""></p>
<p>Se isoliamo solo gli afflussi e deflussi degli scambi, vediamo che la rete Bitcoin sta entrando in un periodo di momentum positivo. La media mensile dei flussi degli scambi è ora saldamente al di sopra di quella annuale, segno che storicamente ha suggerito una crescente adozione dal punto di vista degli asset monetari.</p>
<p>Mentre diverse altre metriche di attività on-chain si stanno raffreddando, questa suggerisce un ritorno verso una predominanza dei trasferimenti monetari BTC.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907017407_exchvolmom.png" alt=""></p>
<p>Dall’attività correlata a questo scambio, possiamo sviluppare un modello di prezzo NVT. originariamente sviluppato da Will Woo. Questo modello cerca di implicare un ‘valore equo’ per una data quantità di transazioni on-chain.</p>
<p>Su base a breve termine di 28 giorni, questo modello implica un ‘valore equo’ di $35.9k, che è superiore ai prezzi spot per la prima volta da novembre 2022. Anche il modello più lento di 90 giorni sta salendo rapidamente, e sta recuperando da un livello di $24.7k.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907019508_nvtprice.png" alt=""></p>
<h2 id="h2-Fondamenta20solide365536"><a name="Fondamenta solide" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fondamenta solide</h2><p>Finora abbiamo stabilito che il recupero del mercato del Bitcoin nel 2023 è stato notevolmente robusto, sia dal punto di vista delle prestazioni dei prezzi, ma anche dal punto di vista dell’utilizzo della rete. Il grafico qui sotto aiuta a mettere tutto in prospettiva, dimostrando la solida base di offerta che è stata acquisita a prezzi inferiori a $30k.</p>
<p>Possiamo vedere che il cluster di offerta tra $15k e $30k è piuttosto significativo, dimostrando che un grande volume di monete è passato di mano negli ultimi 12 mesi. Al contrario, solo il 25% dell’offerta è stato acquisito a prezzi superiori a $30k, detenuto dai compratori del ciclo 2021-22.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907023909_urpd.png" alt=""></p>
<p>Possiamo inserire l’euristica a lungo e breve termine nel nostro grafico URPD, facendo le seguenti osservazioni:</p>
<p>🔵 Un volume consistente di fornitura LTH è stato acquisito tra $15k e $25k (quindi in profitto) e rimane non speso nonostante i prezzi abbiano raggiunto i $31k.</p>
<p>🔵 Quasi tutte le monete con un prezzo di acquisto superiore a $30k sono detenute da LTHs. Questi investitori sono i sopravvissuti dell’orso 2021-22 e sono sia HODLers induriti dalla battaglia, sia inclini a creare resistenza nel caso in cui il mercato si riprenda.</p>
<p>🔴L’intervallo di prezzo tra $20k e $30k ha visto un’espansione dell’accumulo dal mese di febbraio, nonostante l’attacco della pressione regolamentare negli Stati Uniti.</p>
<p>Nel complesso, questa distribuzione dell’offerta è piuttosto ‘pesante verso il basso’, suggerendo che esiste una base relativamente solida di detenzioni degli investitori al di sotto dei $30.000.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907027011_urpd_lthsth.png" alt=""></p>
<p>Possiamo anche vedere l’entità dell’offerta acquisita durante la recente correzione a $25k nel grafico sottostante. Il volume dell’offerta che è passato da ‘in-loss’ a ‘in-profit’ è stato di circa 2,47M BTC, equivalente al 12,7% dell’offerta totale.</p>
<p>Al contrario, la fornitura detenuta ‘in perdita’ è diminuita a soli 4,79M BTC, raggiungendo livelli simili a quelli osservati nel luglio 2021 ($30k), luglio 2020 ($9.2k), aprile 2016 ($6.5k) e marzo 2016 ($425).</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907027913_supplyprofitloss.png" alt=""></p>
<h2 id="h2-Bloccato20nel20mezzo383448"><a name="Bloccato nel mezzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bloccato nel mezzo</h2><p>I dati di Bitcoin mostrano spesso modelli stranamente ripetitivi ciclo dopo ciclo. Nel ciclo 2021-22, il livello di prezzo di $ 30k ha formato una sorta di “punto intermedio” ed è stato testato più volte sia dall’alto che dal basso.</p>
<p>Un livello molto simile è stato osservato nel 2013-16 intorno al livello di $ 425 e di nuovo nel 2018-19 a circa $ 6,5k. Si noti inoltre che questi livelli sono stati menzionati in precedenza, come punti in cui un volume simile di offerta è stato ritenuto “in perdita”.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1689070316image-8.png" alt=""></p>
<p>Con il mercato che si sta consolidando al di sotto di questo ‘punto medio’ di $30k, possiamo vedere che circa il 75% dell’offerta totale è in profitto e il 25% è detenuto in perdita. Questo è, stranamente, lo stesso equilibrio raggiunto quando il prezzo ha raggiunto i punti intermedi sia nel 2016 che nel 2019.</p>
<p>In realtà, questo equilibrio del 75:25 della fornitura detenuta in profitto:perdita è il punto di equilibrio per Bitcoin. Il 50% di tutti i giorni di trading ha visto un saldo profitto-perdita più alto e il 50% un saldo più basso.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907033612_pctsupplyprofit-1.png" alt=""></p>
<p>Questo punto di equilibrio ha storicamente richiesto tempo al mercato per essere digerito e riconsolidato. Molti analisti di Bitcoin si riferiscono a questo come il ‘periodo di riaccumulo’, che tende a straddle l’evento di dimezzamento.</p>
<p>Possiamo visualizzare ciò guardando la proporzione della capitalizzazione di mercato detenuta in una perdita non realizzata. Durante il principale periodo di ribasso, il mercato viene trascinato in profondità nel rosso, con gli investitori che gradualmente si arrendono. Man mano che il mercato si forma e poi si riprende dai minimi, la redditività mostra un forte recupero, raggiungendo livelli simili a quelli attuali.</p>
<p>I precedenti ‘periodi di riaccumulo’ sono caratterizzati da una mancanza di direzione del mercato macro, tendendo a scambiare lateralmente (e in modo volatile) per diversi mesi. Con il mercato di nuovo a questo punto di equilibrio, resta da vedere se è necessario un processo simile, lungo e accidentato, per superarlo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/168907036514_relunrealizedloss.png" alt=""></p>
<h2 id="h2-Sommario20e20Conclusioni604406"><a name="Sommario e Conclusioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario e Conclusioni</h2><p>Bitcoin si sta attualmente consolidando al di sotto del punto medio del ciclo 2021-22 di $30k, con diverse metriche che raggiungono un livello di equilibrio ed equilibrio. Questo è sinonimo del “periodo di riaccumulazione” osservato nei cicli passati, caratterizzato da diversi mesi con poca direzione macro.</p>
<p>La performance del prezzo YTD è stata comunque relativamente forte, con un massimo drawdown di soli -18% finora. L’attività on-chain per Bitcoin si sta raffreddando un po’, principalmente a causa di una diminuzione dell’attività di iscrizione. Tuttavia, i volumi di trasferimento monetario stanno iniziando a aumentare, mostrando un momentum positivo spesso associato a una maggiore liquidità e adozione.</p>
<p><strong>Avviso: Questo rapporto non fornisce alcun consiglio di investimento. Tutti i dati sono forniti solo a scopo informativo ed educativo. Nessuna decisione di investimento dovrebbe essere basata sulle informazioni fornite qui e tu sei l’unico responsabile delle tue decisioni di investimento.</strong></p>
<div class="blog-details-info"><br><div>Autore: Glassnode Insights<br><div>Editor: Squadra del Blog di Gate.io<br><div class="info-tips">*Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards