Tm90aXppZSBxdW90aWRpYW5lIHwgQmxhY2tSb2NrIHBvdHJlYmJlIHNvc3RpdHVpcmUgR3JheXNjYWxlIEdCVEMgY29tZSBpbCAicmUgZGVsbGEgbGlxdWlkaXTDoCI7IHVuYSBiYWxlbmEgQlRDIGluYXR0aXZhIGNvbiBvbHRyZSAkMiBtaWxpYXJkaSBkaXZlbnRhIGF0dGl2YTsgVml0YWxpayBCdXRlcmluIMOoIG90dGltaXN0YSBzdWx

2024-01-18, 03:55

<p><img src="https://gimg2.gateimg.com/image/article/17055500521_15.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20BlackRock20potrebbe20sostituire20GBTC20il20volume20di20trading20di202420ore20di20dYdX20supera20Uniswap469624"><a name="Riepilogo giornaliero delle criptovalute: BlackRock potrebbe sostituire GBTC, il volume di trading di 24 ore di dYdX supera Uniswap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: BlackRock potrebbe sostituire GBTC, il volume di trading di 24 ore di <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">dYdX</a> supera Uniswap</h2><p>Innanzi tutto, diamo uno sguardo agli ultimi sviluppi in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF dopo la loro quotazione.</p>
<p>Il 16 gennaio, il volume totale degli scambi di 10 ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ha superato di più del triplo il volume totale degli scambi di tutti i 500 ETF lanciati nel 2023. L’analista ETF di Bloomberg, Eric Balchunas, ha dichiarato che, al contrario, il volume totale degli scambi di tutti i 500 ETF lanciati negli Stati Uniti lo scorso anno il 16 gennaio era solo di 450 milioni di dollari.</p>
<p>Il Bitcoin Trust di iShares di BlackRock ha attirato un afflusso netto di oltre $497 milioni negli ultimi tre giorni, diventando un chiaro leader. Negli ultimi tre giorni di negoziazione, circa $1,1 miliardi di fondi sono usciti dall’Exchange Traded Fund (ETF) di Bitcoin spot di Grayscale, e gli investitori sono desiderosi di ritirarsi dal fondo. In precedenza, il tasso di sconto del fondo si era ridotto al livello più basso degli ultimi tre anni.</p>
<p>Nonostante il fondo Grayscale Bitcoin continui a guidare in termini di volume di trading totale (oltre 5,1 miliardi di dollari), il fondo ha registrato uscite significative poiché gli investitori cercano di ridurre la loro esposizione al rischio. Balchunas ha aggiunto che i prodotti di BlackRock continueranno ad attirare il maggior afflusso di capitali, rendendolo ‘molto probabilmente il sostituto di GBTC come re della liquidità’. Rachel Aguirre, Product Manager presso BlackRock US iShares, ha dichiarato in un’intervista a Bloomberg che i fondi che affluiscono negli ETF su Bitcoin spot di BlackRock (IBITs) provengono da investitori al dettaglio e nuovi investitori.</p>
<p>Inoltre, ci sono prove che suggeriscono che gli investitori stiano passando dai prodotti ETP europei ad alto tasso a quelli statunitensi a basso tasso. Durante questo periodo (11-16 gennaio), l’uscita totale di fondi dai quattro maggiori ETP europei di Bitcoin ha raggiunto 75,2 milioni di dollari.</p>
<p>Gli analisti ritengono che la maggior parte delle uscite di capitale possano essere dovute agli investitori che si rivolgono a uno dei nuovi ETF, poiché questi addebitano commissioni inferiori rispetto a Grayscale. Tuttavia, da quando sono stati approvati gli ETF Bitcoin, il prezzo del Bitcoin è diminuito di circa il 6%. Ilan Solot, co-capo degli asset digitali presso Marex Solutions, ha dichiarato che l’approvazione degli ETF Bitcoin non è assolutamente un successo su larga scala. L’ultimo trend dei prezzi del Bitcoin indica che, per prodotti molto attesi sul mercato, gli ETF Bitcoin finora non hanno lasciato una profonda impressione.</p>
<p>È importante notare che pochi giorni dopo l’inizio del trading degli ETF Bitcoin spot, sono stati trasferiti Bitcoin dormienti per un valore di oltre 2 miliardi di dollari attraverso più indirizzi associati. Secondo i dati di monitoraggio di Arkham Intelligence, il tracker di criptovalute, questi BTC hanno subito un movimento nel 2019 e sono rimasti dormienti dal 2013. Arkham ha dichiarato: “Dal punto di vista storico, questi Bitcoin si sono tutti mossi contemporaneamente nella stessa data.”</p>
<p>È stato riferito che questi BTC sono stati fusi da 49 indirizzi a 5 indirizzi, ciascuno contenente da 8000 a 12.000 BTC, per un totale di 49.858 BTC per un valore totale di circa 2,12 miliardi di dollari.</p>
<p>Successivamente, gli ultimi progressi in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’aggiornamento di Cancun potrebbe non essere così agevole come immaginato.</p>
<p>Il developer principale di Ethereum, Tim Beiko, ha twittato che sebbene la rete di test <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Goerli abbia completato l’aggiornamento Denchun hard fork, la sua partecipazione attuale non è alta e continuano ad emergere problemi. Se il team non scoprirà ulteriori aggiornamenti del validatore, potrebbe essere condotto un test non conclusivo nelle prossime ore o giorni.</p>
<p>Il co-fondatore di Ethereum, Vitalik Buterin, ha risposto a una discussione sul tema “Ethereum L2” sulla sua piattaforma di social media, affermando che per me, per essere considerata una rete Layer 2 (L2), deve avere attributi di sicurezza più forti rispetto alle multi-firme, anche se non raggiunge garanzie complete come il roll up. I validium soddisfano questo punto. Anche gli ottimali possono raggiungere questo obiettivo, ma è necessario analizzare rigorosamente quali sono i loro esatti vantaggi in termini di sicurezza.</p>
<p>Riguardo a L2, il team di ricerca sugli asset digitali del gigante della gestione degli asset Franklin Templeton ha recentemente pubblicato un articolo in cui afferma che le soluzioni di secondo livello dell’ecosistema Bitcoin non dovrebbero essere ignorate, in quanto sono cruciali per affrontare i problemi di sicurezza economica di Bitcoin e migliorarne la praticità come conservazione del valore (SoV).</p>
<p>Inoltre, indica anche: “Emozionato per Ethereum e il suo ecosistema. Nonostante abbia recentemente attraversato una crisi di mezza età, vediamo un futuro luminoso con molte forze trainanti che spingeranno l’ecosistema Ethereum avanti.” <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, vediamo che Anatoly utilizza una singola macchina a stati atomici come un caso d’uso potente per la blockchain decentralizzata, che può ridurre l’asimmetria delle informazioni. Siamo rimasti impressionati da tutte le attività che abbiamo visto in <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> nel quarto trimestre del 2023, compresi DePIN, DeFi, token Meme, innovazione NFT e Firedance.</p>
<p>In termini di DEX, <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a> Il volume di trading delle ultime 24 ore di Gate.io ha superato <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>. I dati di CoinMarketCap mostrano che il recentemente migrato dYdX da Ethereum a Cosmos ha superato <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> nel volume di trading delle ultime 24 ore, diventando il DEX con il volume di trading giornaliero più elevato.</p>
<p>I dati mostrano che il volume di scambi di dYdX V4 basato su Cosmos ha raggiunto 757 milioni di dollari nelle ultime 24 ore, superando il volume di scambi di 608 milioni di dollari di Uniswap V3. Il volume di scambi di dYdX V3, che è ancora in funzione, è di 567 milioni di dollari, al terzo posto.</p>
<p>Secondo i dati di dYdX, il volume totale delle transazioni nel mercato V4 finora, dalla sua lancio, è di $17.8 miliardi. Il volume totale delle transazioni di dYdX v3 nel 2023 ha superato $1 trilione.</p>
<h2 id="h2-Macro20I20dati20sui20terroristi20superano20le20aspettative20tagli20dei20tassi20di20interesse20e20scommesse20si20raffreddano20rapidamente336131"><a name="Macro: “I dati sui terroristi” superano le aspettative, tagli dei tassi di interesse e scommesse si raffreddano rapidamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: “I dati sui terroristi” superano le aspettative, tagli dei tassi di interesse e scommesse si raffreddano rapidamente</h2><p>Mercoledì i dati sulle vendite al dettaglio degli Stati Uniti per dicembre hanno registrato un aumento dell’0,6% superiore alle aspettative, mentre i contratti di permuta hanno mostrato che la probabilità prevista di taglio dei tassi di interesse della Federal Reserve a marzo era scesa a circa il 50%.</p>
<p>A causa dell’impatto inatteso dei “dati terrificanti” sulle aspettative di taglio dei tassi di interesse della Federal Reserve, l’indice del dollaro statunitense si è mantenuto intorno a un nuovo massimo mensile, salendo fino a un massimo di 103,69 durante le negoziazioni. Successivamente ha rinunciato alla maggior parte dei guadagni giornalieri e ha chiuso in rialzo dello 0,04% a 103,37. Il rendimento dei titoli del Tesoro statunitense continua a salire. Il rendimento del Tesoro statunitense decennale ha superato il 4,1% e ha chiuso infine al 4,105%; Il rendimento del Tesoro statunitense biennale, che è più sensibile ai tassi di interesse della politica della Federal Reserve, è tornato sopra il 4,3% e ha chiuso al 4,360%.</p>
<p>Influenzato dal rafforzamento del dollaro statunitense e dei rendimenti dei titoli statunitensi, l’oro spot è sceso di oltre l’1% nuovamente e si è avvicinato brevemente alla soglia dei $2000 durante le contrattazioni negli Stati Uniti, con un calo di oltre $30 rispetto al suo massimo giornaliero. Alla fine ha chiuso in ribasso dell’1,1% a $2006,22 per oncia. L’argento spot ha chiuso alla fine in ribasso dell’1,58% a $22,55 per oncia.</p>
<p>Il petrolio greggio internazionale ha registrato un rimbalzo. Il petrolio greggio WTI ha iniziato a salire durante la sessione di negoziazione negli Stati Uniti, recuperando tutto il terreno perso durante la giornata e raggiungendo brevemente un massimo intraday di $72,80, per poi chiudere in rialzo dello 1,21% a $72,67 al barile; il petrolio greggio Brent è salito dello 0,37% a $78,01 al barile. I tre principali indici azionari statunitensi hanno chiuso in ribasso sotto pressione. Il Dow Jones Industrial Average ha chiuso in calo dello 0,25%, l’indice S&amp;P 500 è sceso dello 0,56% e il Nasdaq è sceso dello 0,59%.</p>
<p>Si è appreso che i trader obbligazionari hanno ridotto le loro scommesse sul taglio dei tassi della Federal Reserve a marzo e il prezzo del contratto dei tassi di swap riflette attualmente solo una probabilità del 50% di un taglio dei tassi di 25 punti base nel primo trimestre. Nel corso dell’ultimo mese, i trader hanno previsto ripetutamente un taglio dei tassi a marzo a causa di vari dati economici e Goldman Sachs e Barclays hanno adeguato i loro tagli dei tassi previsti a marzo. Parte della ragione per la scommessa su tassi d’interesse più bassi questa volta è che i dati al dettaglio degli Stati Uniti nel mese di dicembre sono stati superiori alle aspettative. I trader si aspettano comunque che la Federal Reserve passi a una politica monetaria accomodante quest’anno, stimando un totale di tagli dei tassi di circa 140 punti base, inferiore alla stima recente di quasi 175 punti base.</p>
<p>Nel frattempo, il Brown Book della Federal Reserve, pubblicato nello stesso momento, mostra che la maggior parte delle regioni ha segnalato quasi nessuna variazione dell’attività economica rispetto all’ultimo rapporto, e tutte le regioni hanno menzionato segnali di un mercato del lavoro in rallentamento, ma le imprese stanno diventando sempre più ottimiste sul futuro.</p>
<p>Il Libro Economico Marrone è stato preparato dalla Federal Reserve di Philadelphia e di solito viene pubblicato due settimane prima della riunione del FOMC. Questa collezione include informazioni aggiornate all’8 gennaio, comprensive di narrazioni e commenti sulle condizioni economiche delle 12 regioni della Federal Reserve. Gli ufficiali della Federal Reserve si affidano sempre più a queste informazioni per valutare le tendenze dell’economia e dell’inflazione. Sebbene le statistiche governative siano considerate lo standard di riferimento per i dati economici, questi numeri di solito si basano su osservazioni passate e potrebbero essere soggetti a revisione.</p>
<p>Attualmente, il mercato si aspetta che quando i responsabili delle decisioni della Federal Reserve si riuniranno per una riunione dal 30 al 31 gennaio, il FOMC manterrà invariato il suo tasso di interesse di riferimento per la quarta volta consecutiva. Dato che l’inflazione sta diminuendo più rapidamente del previsto, potrebbero anche discutere quando iniziare a abbassare i tassi di interesse.</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. Sarà consentito il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>