Tm90aXppZSBnaW9ybmFsaWVyZSB8IElsIHRyYWRpbmcgb24tY2hhaW4gZGkgQml0Y29pbiBoYSByYWdnaXVudG8gdW4gbnVvdm8gcmVjb3JkOyBsJ2F0dGl2aXTDoCBnaW9ybmFsaWVyYSBkaSBGYXJjYXN0ZXIgaGEgcmFnZ2l1bnRvIHVuIG51b3ZvIG1hc3NpbW87IHF1ZXN0YSBzZXR0aW1hbmEgdmVycmFubm8gc2Jsb2NjYXRpIG9sdHJ

2024-02-05, 04:24

<p><img src="https://gimg2.gateimg.com/image/article/17071068761_2.png" alt=""></p>
<h2 id="h2-Riassunto20quotidiano20delle20cripto202020Bitcoin2020le20transazioni20onchain20raggiungono20nuovi20massimi20lattivit20quotidiana20di20Farcaster20raggiunge20nuovi20massimi851386"><a name="Riassunto quotidiano delle cripto:   Bitcoin  le transazioni on-chain raggiungono nuovi massimi, l’attività quotidiana di Farcaster raggiunge nuovi massimi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto quotidiano delle cripto: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> le transazioni on-chain raggiungono nuovi massimi, l’attività quotidiana di Farcaster raggiunge nuovi massimi</h2><p>Il 5 febbraio, l’ultima notizia è che la Corte Suprema delle Elezioni di El Salvador ha annunciato il conteggio preliminare dei voti per le elezioni. Il Presidente attuale Nayib Bukele è stato rieletto con successo come Presidente e sta per iniziare un altro mandato quinquennale. Nayib Bukele assumerà l’incarico il 1° giugno di quest’anno, diventando il primo Presidente di El Salvador a essere rieletto durante il periodo democratico.</p>
<p>Si dice che Nayib Bukele sia stato Presidente dal 2019. Nel 2021, El Salvador è diventato il primo Paese ad adottare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> come suo corso legale.</p>
<p>Recentemente, CoinShares ha scoperto che il 75% dei partecipanti ritiene che <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Secondo l’ultima indagine condotta sui gestori di fondi di asset digitali, le criptovalute hanno le prospettive di crescita più interessanti. La percentuale di asset digitali nel portafoglio degli investimenti è aumentata dallo 0,4% della media dei partecipanti al 1,3%, indicando un’allocazione sempre maggiore di asset digitali, e questa percentuale è la più alta dal primo trimestre del 2023.</p>
<p>Sebbene le questioni normative rimangano in cima alla lista dei rischi, la loro importanza continua a diminuire, con la combinazione di divieti governativi e regolamentazioni che è passata dal 63% sei mesi fa al 50%.</p>
<p>Secondo The Block, a gennaio 2024, Bitcoin del valore totale di $1,21 trilioni è stato trasferito sulla catena. Si tratta del volume di scambi mensile più alto dal settembre 2022 (quando il Bitcoin era quotato a circa $20.000). I dati mostrano anche che, tranne che a dicembre, il volume delle transazioni di Bitcoin in tutti gli altri mesi del 2023 non ha superato $1 trilione.</p>
<p>Il 4 febbraio, secondo i dati della società di analisi on-chain Glassnode, dopo l’approvazione degli ETF spot di Bitcoin, il numero di indirizzi di rete attivi è sceso a un minimo ciclico di 219.000 al giorno (leggermente ripreso a 221.000 questa settimana).</p>
<p>Ciò significa che sebbene il prezzo di Bitcoin sia aumentato, la crescita degli utenti di Bitcoin non ha mostrato lo stesso trend al rialzo. L’analisi suggerisce che ciò è principalmente dovuto a un aumento delle attività legate a Ordinals e iscrizioni, con molti partecipanti che riutilizzano gli indirizzi Bitcoin, riducendo così il numero di indirizzi attivi.</p>
<p>Inoltre, gli ultimi dati di Dune mostrano che il ricavo totale cumulativo dalla fusione di iscrizioni Ordinals nel protocollo Bitcoin NFT ha raggiunto 6.076,84 BTC, equivalente a circa $260 milioni. Attualmente, il numero totale di iscrizioni fuse ha superato i 59.575.506.</p>
<p>In termini di fluttuazioni di mercato, il 4 febbraio, Sun Yuchen ha pubblicato sulla piattaforma X affermando che avrebbe distrutto 20 milioni di HT del valore di 60 milioni di dollari, ottenuti attraverso lo scambio degli utenti. Si riferisce che dopo il completamento dell’operazione di distruzione, la circolazione totale di HT sarà ridotta a 134 milioni. Secondo gli ultimi dati di mercato di Gate.io, la diminuzione delle 24 ore di HT è stata del -0,4%, con una quotazione di 2,96 dollari.</p>
<p>Secondo i dati della società di analisi on-chain Glassnode, nonostante le recenti prestazioni positive degli spot ETF di Bitcoin, il mercato ha vissuto un fenomeno opposto all’intuizione, con il numero di entità attive che è sceso a un minimo ciclico di 219.000 al giorno. Ciò significa che nonostante i prezzi del Bitcoin siano aumentati, la crescita degli utenti di Bitcoin non è stata all’altezza.</p>
<p>L’analisi suggerisce che questo è principalmente dovuto a un aumento delle attività legate ai numeri ordinali e alle iscrizioni, con molti partecipanti che utilizzano ripetutamente gli indirizzi Bitcoin, riducendo così il numero di ‘entità attive’ (senza conteggio doppio).</p>
<p>Inoltre, l’attività degli utenti attivi giornalieri (DAU) del popolare protocollo sociale decentralizzato Farcaster ha recentemente raggiunto un livello storico. Il numero di reazioni uniche è 24.733, il numero di lanci unici è 19.081 e il valore medio giornaliero di tracciamento è 10.697.</p>
<p>Il 5 febbraio, i dati di sblocco dei token hanno mostrato che questa settimana, token come APT, GAL e HFT esperimenteranno uno sblocco ad alto impatto, con un valore di rilascio totale superiore a 235 milioni di dollari. Tra questi:</p>
<p>GAL (Galxe) ha sbloccato 2,03 milioni di token GAL del valore approssimativo di 3,83 milioni di dollari alle 0:00 (UTC) del 5 febbraio, pari al 2,26% dell’offerta circolante;</p>
<p>HFT (Hashflow) sblocca 13,62 milioni di token del valore di circa $4,25 milioni alle ore 8:00 del 7 febbraio, pari al 4,02% della fornitura circolante;</p>
<p>APT ( <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a>) sbloccare 24,84 milioni di token APT del valore di circa $228 milioni alle ore 20:00 del 11 febbraio, pari al 7,34% dell’offerta circolante.</p>
<h2 id="h2-Macro20Le20aspettative20di20tagli20dei20tassi20di20interesse20a20marzo20continuano20a20diminuire20concentrandosi20sul20discorso20di20Powell20luned20di20questa20settimana82518"><a name="Macro: Le aspettative di tagli dei tassi di interesse a marzo continuano a diminuire, concentrandosi sul discorso di Powell lunedì di questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Le aspettative di tagli dei tassi di interesse a marzo continuano a diminuire, concentrandosi sul discorso di Powell lunedì di questa settimana</h2><p>La settimana scorsa è stata una stagione tumultuosa per il mercato globale.</p>
<p>L’attenzione del mercato si è spostata sulla Federal Reserve e il presidente della Federal Reserve Powell ha detto qualcosa che il mercato non si aspettava, ovvero che il taglio dei tassi di marzo non è la situazione di base.</p>
<p>Nonostante una significativa diminuzione dei tassi di inflazione, Powell ha minimizzato le speculazioni secondo cui i tagli dei tassi di interesse erano imminenti, ritenendo che la Federal Reserve non credesse ancora pienamente di aver vinto la guerra. Ha sottolineato che la crescita economica stabile, la spesa flessibile dei consumatori e un mercato del lavoro stretto potrebbero mantenere i tassi di inflazione al di sopra del 2% per un certo periodo di tempo.</p>
<p>Il suo messaggio potrebbe essere che i tassi di interesse diminuiranno alla fine, ma non così velocemente come spera il mercato. Pertanto, gli operatori hanno ridotto le loro scommesse sul taglio dei tassi di interesse di marzo dal 60% a circa il 35%.</p>
<p>L’annuncio forte di venerdì ha colpito ancora più duramente le aspettative di taglio dei tassi di interesse di marzo, con il mercato dei swap che mostra una diminuzione delle scommesse sul taglio dei tassi della Federal Reserve di marzo e non prezzando più completamente il taglio dei tassi di interesse della Fed a maggio.</p>
<p>Tuttavia, il mercato non ha cambiato la sua opinione sul numero totale di tagli dei tassi quest’anno e ritiene che la Federal Reserve abbia solo rimandato il momento dei tagli dei tassi, con l’aspettativa di quasi altri sei tagli dei tassi quest’anno.</p>
<p>Guardando avanti, l’evento principale di questa settimana sarà il sondaggio ISM sui servizi non manifatturieri in programma per lunedì. Si tratta di uno dei più importanti indicatori economici principali per l’economia statunitense, con previsioni di significativa crescita a gennaio. In tal caso, il mercato potrebbe continuare a scommettere sul taglio dei tassi d’interesse della Fed, aiutando il dollaro statunitense a recuperare slancio.</p>
<p>Inoltre, Gullsby della Federal Reserve ha affermato lo scorso venerdì che ci sono ancora “settimane e mesi” di dati economici degli Stati Uniti che aiuteranno a determinare quando ridurre i tassi di interesse e la Federal Reserve riporterà l’inflazione al suo obiettivo del 2%, ma non cercherà di ripristinare i prezzi ai livelli pre-inflazione.</p>
<p>Gulsby ritiene che se la Federal Reserve vuole che i prezzi tornino ai livelli di qualche anno fa, deve davvero ridurre la crescita economica per raggiungere questo obiettivo, quindi ‘tagli dei tassi di interesse non sono nel nostro orizzonte’. Gulsby ritiene che solo aumentando i progressi, come nell’inflazione e nell’occupazione, possono sentirsi tranquilli nel raggiungimento dei loro obiettivi.</p>
<p>Questa settimana, numerosi funzionari della Federal Reserve saranno mobilitati intensivamente, prevedendo che continueranno a minare le aspettative di mercato per il primo taglio dei tassi della Fed a marzo. Inoltre, non si può escludere che possano sopprimere le puntate di mercato sulla magnitudine del taglio dei tassi della Fed.</p>
<p>Powell illuminerà la sezione “60 Minutes” della CBS lunedì mattina alle 8 ora di Pechino. Considerando che la CBS ha già rivelato che Powell discuterà il tema dei tagli dei tassi di interesse, se ancora una volta sopprime le aspettative del mercato sui tagli dei tassi di interesse della Federal Reserve, potrebbe innescare un’altra correzione dei prezzi di mercato.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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 il repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>