Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgcHJlc3Npb25lIGRpIHZlbmRpdGEgZGkgR3JheXNjYWxlIHNpIMOoIHJhbGxlbnRhdGE7IEdsaSBFVEYgQml0Y29pbiBTcG90IGhhbm5vIHJlZ2lzdHJhdG8gdW4gZGVmbHVzc28gbmV0dG8gZGkgJDEwNiBtaWxpb25pOyBJbCBmYXR0dXJhdG8gYW5udW8gZGVpIG1pbmF0b3JpIGRpIEJpdGNvaW4

2024-01-25, 07:34

<p><img src="https://gimg2.gateimg.com/image/article/17061680261_20.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20la20SEC20ha20rinviato20la20sua20decisione20sullETF20spot20Ethereum20la20pressione20delle20vendite20di20Grayscale20si2020rallentata646513"><a name="Riepilogo giornaliero delle criptovalute: la SEC ha rinviato la sua decisione sull’ETF spot Ethereum, la pressione delle vendite di Grayscale si è rallentata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: la SEC ha rinviato la sua decisione sull’ETF spot Ethereum, la pressione delle vendite di Grayscale si è rallentata</h2><p>Ieri, Gary Gensler, presidente della SEC degli Stati Uniti, ha dichiarato in un’intervista mercoledì che sebbene alcune persone si aspettassero l’approvazione successiva per il trading spot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF, l’approvazione dell’agenzia di diversi spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> le piattaforme di trading all’inizio di questo mese erano limitate a questo tipo di criptovaluta.</p>
<p>Durante un briefing con i media, Gensler ha sottolineato quando gli è stato chiesto del suo punto di vista sugli ETF Ethereum: come ho già detto due settimane fa, ciò che facciamo con i prodotti di trading sulla piattaforma di trading <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è limitato a questa merce non titoli e non dovrebbe essere interpretato come qualcosa al di là di questo ambito.</p>
<p>Recenti documenti pubblici mostrano che la SEC degli Stati Uniti ha rinviato la sua decisione sull’applicazione di BlackRock per l’iShares <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Trust. Nei prossimi mesi, la SEC continuerà a prendere decisioni sugli spot Ethereum ETF di altri emittenti, con la prossima data importante che sarà il 23 maggio. Più lunga è la data, migliore è l’aspettativa di hype su Ethereum, perché finché non ci sarà l’approvazione, questa aspettativa di hype continuerà ad esistere.</p>
<p>Secondo gli ultimi dati, tutti gli ETF Bitcoin spot negli Stati Uniti hanno registrato un deflusso netto di 106 milioni di dollari nell’ottavo giorno di negoziazione. L’afflusso totale di fondi in questi 8 giorni è stato di 982,8 milioni di dollari.</p>
<p>Secondo i dati condivisi, nell’ottava giornata di negoziazione, il GBTC di Grayscale ha avuto un afflusso netto di circa $515,3 milioni, l’IBIT di BlackRock ha avuto un afflusso netto di $160,1 milioni, il FBTC di Fidelity ha avuto un afflusso netto di $157,7 milioni, il BITBC di Bitwise ha avuto un afflusso netto di $26,3 milioni, Ark 21Shares ha avuto un afflusso netto di $61,8 milioni, l’EZBC di Franklin ha avuto un afflusso netto di $1,1 milioni, l’HODL di VanEck ha avuto un afflusso netto di $2,2 milioni, mentre BTCO di Invesco, BRRR di Valkyrie e BTCW di WisdomTree hanno avuto cambiamenti relativamente piccoli. Non inclusi.</p>
<p>Inoltre, secondo i calcoli di Bitcoin, l’afflusso totale di tutti gli ETF entro 8 giorni è di 21.362,5 BTC e l’efflusso totale di GBTC entro 8 giorni è di 98.296 BTC.</p>
<p>Il monitoraggio di Lookonchain mostra che Grayscale ha depositato 14.487 bitcoin (circa 579 milioni di dollari) in Coinbase Prime ieri e trasferito 4.750 bitcoin (circa 189,8 milioni di dollari) in un nuovo portafoglio. Dall’approvazione dell’ETF, Grayscale ha depositato un totale di 93.700 bitcoin (circa 3,85 miliardi di dollari) in Coinbase Prime.</p>
<p>Si riporta che Grayscale detenga attualmente un totale di 519.399 bitcoin, e gli ETF Grayscale Bitcoin Trust detengono ancora un valore patrimoniale netto di $20,05 miliardi. Il valore patrimoniale netto totale degli ETF spot Bitcoin è di $25,17 miliardi.</p>
<p>L’analista di Bloomberg Eric Balchunas ha twittato ieri che il volume di trading di GBTC è nuovamente diminuito oggi, il che potrebbe essere un segno che il trend di vendita si sta esaurendo. Ha aggiunto: “L’uscita di oggi di GBTC è solo 425 milioni di dollari, il che rappresenta la più bassa uscita da quando è stata convertita in Bitcoin spot ETF il primo giorno e sembra essere in un trend al ribasso. In altre parole, si tratta comunque di un numero considerevole.”</p>
<p>Un nuovo rapporto pubblicato da Cornerstone Research mostra che la SEC ha attuato un totale di 46 azioni di contrasto legate alle criptovalute nel 2023, un aumento di oltre il 50% rispetto alle 30 del 2022, stabilendo un nuovo massimo storico. Il 61% delle cause accusa le entità criptovalute di violazione delle leggi sui titoli, e il 57% delle cause accusa tali entità di commettere frodi in violazione delle leggi sui titoli o delle leggi sugli scambi. Alla fine del 2023, la SEC ha imposto multe per un totale di 2,89 miliardi di dollari ai partecipanti al mercato delle criptovalute, con un ammontare di accordo superiore a 281 milioni di dollari. Dal 2013, l’agenzia ha attuato un totale di 173 azioni di contrasto contro le entità criptovalute.</p>
<p>Il 24 gennaio c’è stato un nuovo progresso nell’aggiornamento di Ethereum Cancun. Il client Ethereum Geth ha rilasciato ufficialmente la versione v1.13.11, preparandosi all’aggiornamento di Cancun in Sepolia e Holesky. Questa versione corregge alcuni errori e abilita gli aggiornamenti di Cancun per le reti Sepolia e Holesky. Inoltre, supporta anche transazioni EIP-4844 nei metodi API. Si dice che Sepolia verrà aggiornata il 31 gennaio e Holesky il 7 febbraio.</p>
<p>Secondo quanto riportato dai media, la quota di mercato di Geth tra i client di esecuzione della rete Ethereum è passata dall’84% del giorno precedente al 78,8%, una diminuzione del 5,2%. Geth è fondamentale per l’elaborazione delle transazioni e l’esecuzione dei contratti intelligenti su Ethereum, ma la sua preferenza tra i validatori di Ethereum porta a un disequilibrio nella diversità dei client di esecuzione su Ethereum, determinando problemi di centralizzazione. Secondo il mercato di Gate.io, Ethereum viene attualmente quotato a $2.219,12, con un aumento del 0,14% nelle ultime 24 ore.</p>
<p>Riguardo ai minatori, Yassine Elmandjra, responsabile degli asset digitali presso ARK Invest, ha recentemente pubblicato sulla piattaforma X affermando che il reddito cumulativo dei minatori di Bitcoin si è avvicinato a $60 miliardi e la crescita e la scala di Bitcoin non possono essere sottovalutate.</p>
<p>Yassine Elmandjra ha anche affermato che dieci anni fa, il mining di Bitcoin era solo un’attività per gli appassionati di business, ma ora il reddito annuo dei minatori ha superato quello di diverse società a livello globale, come Spotify, eBay, Hermes, Chipotle, Hertz, Hilton e così via.</p>
<h2 id="h2-Macro20Forti20dati20PMI20sopprimono20le20aspettative20di20tagli20dei20tassi20di20interesse487002"><a name="Macro: Forti dati PMI sopprimono le aspettative di tagli dei tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Forti dati PMI sopprimono le aspettative di tagli dei tassi di interesse</h2><p>Mercoledì, l’indice del dollaro USA ha registrato un leggero ritiro, rompendo al di sotto del livello di 103 e scendendo ad un minimo intraday di 102,77. Tuttavia, ha rapidamente recuperato questo livello e alla fine ha chiuso in ribasso dello 0,27% a 103,24; Il rendimento del Tesoro USA a 10 anni si è stabilizzato al livello del 4,1% e ha chiuso a 4,180%; Il rendimento del Tesoro USA a 2 anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, ha chiuso a 4,384%.</p>
<p>L’oro spot è crollato bruscamente durante il mercato statunitense, scendendo sotto i livelli 2030 e 2020 uno dopo l’altro, per poi sfiorare il livello 2010 e chiudere in calo dello 0,76% a $2,013.91 per oncia. L’argento spot e l’oro hanno mostrato tendenze discordanti, avvicinandosi al livello di $23 durante la sessione statunitense e chiudendo infine in rialzo dell’1,01% a $22.67 per oncia.</p>
<p>Con la possibilità di una diminuzione imprevista delle scorte di petrolio greggio negli Stati Uniti e una diminuzione della produzione di petrolio greggio negli Stati Uniti, il petrolio greggio internazionale è risalito significativamente. La stazione del petrolio greggio WTI è salita di $75, con una chiusura finale del 1,17%, a $75,31 al barile; il petrolio greggio Brent è tornato sopra la soglia dei $80 e alla fine ha chiuso in rialzo dello 0,75% a $80,23 al barile.</p>
<p>Microsoft (MSFT.O) è salito dello 0,9%, non riuscendo a stabilizzare il suo valore di mercato di 3 trilioni di dollari, mentre NVDA.O ha raggiunto un nuovo massimo storico del 2,5%, con un valore di mercato superiore a 1,5 trilioni di dollari.</p>
<p>Mercoledì gli Stati Uniti hanno pubblicato i dati PMI del settore manifatturiero per gennaio, con un valore iniziale di 50,3, un nuovo massimo di quindici mesi; L’indice di produzione manifatturiera ha registrato 48,7, un massimo di due mesi; Il valore iniziale dell’indice PMI del settore dei servizi ha registrato 52,9, un nuovo massimo di 7 mesi; Il valore iniziale del PMI complessivo ha registrato 52,3, un nuovo massimo di 7 mesi.</p>
<p>La forte performance dell’economia statunitense e la soppressione dei tagli dei tassi di interesse da parte dei responsabili politici stanno spingendo alcuni investitori a rivalutare le loro aspettative sulla velocità dei tagli dei tassi di interesse della Federal Reserve quest’anno. Questo cambiamento di concetto sta producendo un effetto a catena sul mercato dei titoli del tesoro e sul mercato dei cambi, anche se il mercato azionario è ancora vicino al picco storico.</p>
<p>I dati PMI di gennaio sorprendentemente forti dagli Stati Uniti dimostrano ancora una volta la vitalità dell’economia. Il valore iniziale del PMI manifatturiero registrato è 50,3, un nuovo massimo in 15 mesi; Il valore iniziale del PMI del settore dei servizi registrato è 52,9, un nuovo massimo in 7 mesi; Il valore iniziale del PMI complessivo registrato è 52,3, un nuovo massimo in 7 mesi. Tutti e tre gli indicatori hanno superato le aspettative del mercato.</p>
<p>Chris Williamson, Chief Business Economist di S&amp;P Global Market Intelligence, ha affermato che in base ai dati PMI, l’avvio dell’economia statunitense quest’anno è incoraggiante, con una significativa accelerazione della crescita aziendale e una forte diminuzione della pressione inflazionistica.</p>
<p>Williamson ha sottolineato che la produzione di beni e servizi a gennaio ha raggiunto il tasso di crescita più veloce da giugno dello scorso anno e il miglioramento della domanda ha ulteriormente stimolato il momento di crescita. L’afflusso di nuovi ordini è aumentato per tre mesi consecutivi, contribuendo a rafforzare la fiducia delle imprese per l’anno in corso, raggiungendo il livello più ottimistico da maggio 2022. A causa dell’aumento dei prezzi più lento dalla chiusura per COVID-19 all’inizio del 2020, il tasso di inflazione dei prezzi di vendita è attualmente inferiore alla media pre-pandemia. L’indagine mostra che i ritardi nella fornitura si stanno intensificando, mentre il mercato del lavoro rimane stretto e le pressioni sui costi devono essere monitorate attentamente nei prossimi mesi.</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 relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>