Tm90aXppZSBnaW9ybmFsaWVyZSB8IENlbHNpdXMgaGEgaW52aWF0byBvbHRyZSA0NUsgRVRIIGEgcGnDuSBDRVhzOyBVbmEgYmFsZW5hIEVUSCBoYSB2aW50byAkNTAwSyBkaSBwcm9maXR0aSBhIGJyZXZlIHRlcm1pbmU7IEwnYWdnaW9ybmFtZW50byBkaSBFdGhlcmV1bSBEZW5jaHVuIHNhcsOgIGxhbmNpYXRvIGdpw6AgYWxsYSBmaW5

2024-01-26, 03:29

<p><img src="https://gimg2.gateimg.com/image/article/17062396991_21.png" alt=""></p>
<h2 id="h2-Digest20giornaliero20sulle20criptovalute20Celsius20ha20trasferito20oltre204500020ETH20laggiornamento20Denchun20potrebbe20essere20lanciato20gi20entro20la20fine20di20febbraio404295"><a name="Digest giornaliero sulle criptovalute: Celsius ha trasferito oltre 45.000 ETH, l’aggiornamento Denchun potrebbe essere lanciato già entro la fine di febbraio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digest giornaliero sulle criptovalute: Celsius ha trasferito oltre 45.000 ETH, l’aggiornamento Denchun potrebbe essere lanciato già entro la fine di febbraio</h2><p>Nel nono giorno di negoziazione del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Per quanto riguarda gli spot ETF, c’è stato un deflusso netto di 158 milioni di dollari. Tra questi, il deflusso di GBTC è stato di 429,3 milioni di dollari, l’afflusso di IBIT (BlackRock) è stato di 66,2 milioni di dollari e l’afflusso di FBTC (Fidelity) è stato di 125,7 milioni di dollari. Inoltre, secondo il monitoraggio di Lookonchain, il 24 gennaio Grayscale GBTC ha ridotto le sue riserve di 13.179 BTC (del valore approssimativo di 529,2 milioni di dollari). Gli altri 8 <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF hanno aumentato le loro riserve di 8.251 BTC (del valore approssimativo di 331,3 milioni di dollari), di cui Fidelity ha aumentato le sue riserve di 4.023 BTC (del valore approssimativo di 161,5 milioni di dollari).</p>
<p>Il 25 gennaio, i dati ufficiali di BlackRock hanno mostrato che al 24 gennaio 2024, il suo ETF Bitcoin IBIT aveva 45.668,08260 BTC, con un valore di mercato di circa 1.833.605.029,01 dollari, un aumento di circa 1.663 BTC rispetto ai 44.004,5231 BTC del 23 gennaio.</p>
<p>Ieri, il governo degli Stati Uniti ha rilasciato un avviso in cui annunciava i piani per vendere 2875 Bitcoin sequestrati al trafficante di droga della Silk Road sul dark web, Ryan Farace, e all’ex <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Segreto</a> Agente di servizio Shaun Bridges. Questi Bitcoin valgono attualmente circa 133 milioni di dollari. Ryan Farace è stato condannato a 54 mesi di carcere nel Maryland l’anno scorso per cospirazione per riciclare denaro. Shaun Bridges era un membro della Silk Road Task Force ed è stato condannato a sei anni di carcere nel 2015 per il suo coinvolgimento nelle indagini del governo degli Stati Uniti sulla Via della Seta. Il governo degli Stati Uniti ha dichiarato che prevede di disporre dei beni confiscati in conformità con le istruzioni del Procuratore Generale degli Stati Uniti.</p>
<p>Ulteriori progressi su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>: Il 26 gennaio, secondo il monitoraggio di Spot on Chain, sono stati inviati 45956 ETH (del valore di 1,02 miliardi di dollari) a indirizzi CEX multipli nelle ultime 8 ore presso l’indirizzo di Celsius. Tra questi, sono stati inviati 305254 ETH (circa 674 milioni di dollari) a Coinbase Prime; 146.507 ETH (circa 324 milioni di dollari) inviati a Paxos; 7.800 ETH (circa 17,02 milioni di dollari) inviati a FalconX.</p>
<p>A partire dal 13 novembre 2023, <a href="/price/celsius-network-cel" rel="nofollow noopener noreferrer" target="_blank">Celsius Network</a> ha trasferito un totale di 757.626 ETH (circa 1,69 miliardi di dollari) a FalconX, Coinbase, OKX e Paxos. Attualmente, Celsius detiene ancora 62.469 ETH (circa 138 milioni di dollari) all’indirizzo 0xdb3.</p>
<p>Secondo il monitoraggio di ai_9684xtpa, la balena vincente, che in precedenza era prentemente rialzista, ha preso in prestito 6.600 ETH da Maker 7 ore fa e li ha venduti tutti a un prezzo medio di $2.230, per un valore di $14,72 milioni. In seguito, quando l’ETH è sceso, ha ricomprato tutti i token a un prezzo medio di $2.208 e ha ripagato il prestito, guadagnando alla fine un profitto di $497.000.</p>
<p>Notizie di BlockBeats: il 25 gennaio gli sviluppatori di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> hanno stabilito un programma definitivo per l’aggiornamento di “Denchun”. Se tutto va bene nelle reti di test di Sepolia e Holesky il 30 gennaio e il 7 febbraio, gli sviluppatori stabiliranno la data di accesso di “Denchun” alla rete principale di Ethereum. L’obiettivo attuale è di concludere entro febbraio o all’inizio di marzo.</p>
<p>È di nuovo il giorno di scadenza mensile delle opzioni. Secondo i dati di Deribit, le opzioni BTC con un valore nominale di $3.74 miliardi scadranno e verranno consegnate domani, con un rapporto Put Call di 0.52 e un punto massimo di dolore di $41,000. Le opzioni ETH con un valore nominale di $2.05 miliardi scadranno e verranno consegnate domani, con un rapporto Put Call di 0.31 e un punto massimo di dolore di $2,300.</p>
<p>Inoltre, vale la pena prestare attenzione anche a un sondaggio di opinione pubblica. Ieri, secondo un sondaggio dei media sugli utenti europei di criptovalute in Francia, Spagna, Italia e Svezia, il 73% dei rispondenti si è mostrato ottimista sul futuro delle criptovalute. Questo sondaggio approfondisce le preferenze e i comportamenti delle comunità cripto europee. Il 55% dei partecipanti utilizza pienamente gli asset digitali, il che indica che questi strumenti finanziari occupano una posizione significativa tra la popolazione sondata.</p>
<p>Il sondaggio ha anche rivelato alcune tendenze chiave: il 55% dei partecipanti utilizza gli asset digitali negli acquisti quotidiani e il 10% utilizza le criptovalute per acquistare beni ogni settimana. In termini di utilizzo, il 34% degli intervistati lo utilizza per transazioni a lungo termine, il 26% per risparmi, il 13% per transazioni quotidiane e il 9% per acquisti giornalieri.</p>
<p>I principali driver dell’adozione della cripto valuta includono un alto potenziale di rendimento (20% dei rispondenti), decentralizzazione e autonomia finanziaria (18% dei rispondenti), e interesse per l’innovazione e la tecnologia (17% dei rispondenti). L’82% dei rispondenti è stato coinvolto nel mercato della cripto valuta per almeno un anno, con il 73% che ha partecipato per 1-5 anni. Per quanto riguarda le preferenze di conservazione, il 65% dei rispondenti tende ad utilizzare portafogli di exchange centralizzati, seguiti da portafogli hardware (18%).</p>
<h2 id="h2-Macro20La20crescita20del20PIL20supera20le20aspettative20con20scommesse20di20tagli20dei20tassi20di20interesse20su20salti20orizzontali20ripetuti20522"><a name="Macro: La crescita del PIL supera le aspettative, con scommesse di tagli dei tassi di interesse su “salti orizzontali ripetuti”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La crescita del PIL supera le aspettative, con scommesse di tagli dei tassi di interesse su “salti orizzontali ripetuti”</h2><p>Giovedì, trainato dalla crescita della spesa personale, il PIL del quarto trimestre degli Stati Uniti è cresciuto del 3,3% in più rispetto alle previsioni. Il numero di richieste di sussidio di disoccupazione iniziali negli Stati Uniti per la settimana conclusasi il 20 gennaio è stato di 214.000, un nuovo massimo dalla settimana conclusasi il 23 dicembre 2023. Dopo la pubblicazione dei dati, gli operatori hanno aumentato le scommesse sul taglio dei tassi d’interesse della Fed, il che potrebbe suggerire che la Fed sia meno desiderosa di tagliare i tassi.</p>
<p>Influenzato da questi dati, l’indice del dollaro statunitense è salito notevolmente durante la sessione di trading negli Stati Uniti, raggiungendo un massimo intraday di 103,68 in un momento e chiudendo infine in rialzo dello 0,23% a 103,48; Il rendimento del Tesoro americano a 10 anni ha temporaneamente raggiunto il livello del 4,2% durante il trading, ma poi si è invertito e ha chiuso a 4,120%; Il rendimento del Tesoro americano a 2 anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, ha chiuso a 4,299%.</p>
<p>L’oro spot ha subito un’altalena, scendendo al di sotto del livello del 2010 prima del mercato statunitense e raggiungendo un minimo intraday di 2009,60. Successivamente ha riguadagnato tutto il terreno perduto e ha fluttuato avanti e indietro intorno al livello del 2020, chiudendo infine in rialzo dello 0,35% a $2,020,86 l’oncia. L’argento spot è salito di oltre l’1% e ha chiuso infine in rialzo del 1,07% a $22,91 l’oncia.</p>
<p>A causa della continua interruzione del commercio globale causata dalla situazione tesa nel Mar Rosso, i prezzi internazionali del petrolio greggio potrebbero aumentare di oltre il 2%. Il petrolio greggio WTI è salito significativamente nella giornata, chiudendo infine in rialzo del 2,3% a $77,04 al barile; il petrolio greggio Brent si è stabilizzato sulla soglia dei 80 dollari e ha chiuso infine in rialzo del 2,43% a $82,18 al barile. L’indice azionario statunitense è salito dello 0,64%, l’indice S&amp;P 500 è salito dello 0,53% e il Nasdaq è salito dello 0,18%.</p>
<p>Ora, l’economia degli Stati Uniti è cresciuta più velocemente del previsto nel quarto trimestre, mettendo una perfetta conclusione a un anno che molti avevano previsto che sarebbe finito con una recessione economica.</p>
<p>Secondo i dati della United States Bureau of Economic Analysis, il tasso di crescita trimestrale annualizzato del PIL reale per il quarto trimestre degli Stati Uniti ha registrato il 3,3%, superando le aspettative del 2% e rallentando rispetto al precedente 4,9%, raggiungendo un nuovo minimo dal secondo trimestre del 2023. Ciò ha portato ad una crescita del 2,5% dell’economia statunitense nel 2023, in aumento rispetto all’1,9% del 2022. Il tasso di spesa personale effettiva trimestrale nel quarto trimestre degli Stati Uniti ha registrato il 2,8%, superiore al previsto 2,5%, che è un nuovo minimo dal secondo trimestre del 2023, con un valore precedente del 3,1%.</p>
<p>Nel frattempo, il mercato del lavoro mostra segni di raffreddamento, con il numero di richieste di sussidio di disoccupazione negli Stati Uniti che ha raggiunto quota 214.000 per la settimana terminata il 20 gennaio, un nuovo massimo dal 23 dicembre 2023, superando le aspettative di 200.000. Il valore precedente è stato aumentato da 187.000 a 189.000.</p>
<p>Dopo la pubblicazione dei dati, i future sui tassi di interesse a breve termine negli Stati Uniti sono aumentati poiché i trader hanno aumentato le loro scommesse sul taglio dei tassi della Fed.</p>
<p>Secondo l’osservazione della Federal Reserve del CME, la probabilità che la Federal Reserve mantenga i tassi d’interesse nell’intervallo del 5,25% al 5,50% a febbraio è del 97,4%, mentre la probabilità di un taglio dei tassi di 25 punti base è del 2,6%. La probabilità di mantenere i tassi d’interesse invariati entro marzo è del 48,7%, la probabilità di un taglio cumulativo di 25 punti base è del 50,0%, e la probabilità di un taglio cumulativo di 50 punti base è dell’1,3%.</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 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 fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>