Tm90aXppZSBnaW9ybmFsaWVyZSB8IEdsaSBFVEYgQlRDIFNwb3QgaGFubm8gcmVnaXN0cmF0byBpbmdyZXNzaSBuZXR0aSBwZXIgMiBnaW9ybmkgY29uc2VjdXRpdmk7IEdyYXlzY2FsZSBlIENlbHNpdXMgdHJhc2ZlcmlzY29ubyBCVEMgZWQgRVRIIGEgQ0VYczsgTXVzayBoYSByaW1vc3NvIGlsIHByb2ZpbG8gZGVsbGEgaG9tZXBhZ2U

2024-01-31, 04:09

<p><img src="https://gimg2.gateimg.com/image/article/17066741521_24.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20gli20scambi20conformi20a20Hong20Kong20devono20fornire20almeno20il205020di20assicurazione20TROLL2020crollato20di20oltre20il205020in20risposta539354"><a name="Riepilogo giornaliero delle criptovalute: gli scambi conformi a Hong Kong devono fornire almeno il 50% di assicurazione, TROLL è crollato di oltre il 50% in risposta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: gli scambi conformi a Hong Kong devono fornire almeno il 50% di assicurazione, TROLL è crollato di oltre il 50% in risposta</h2><p>Innanzitutto, concentriamoci sui progressi negli aspetti normativi. Secondo Cryptoolitan, la Securities and Futures Commission (SFC) di Hong Kong ha stabilito che le borse di valori virtuali autorizzate devono fornire almeno il 50% di assicurazione sui beni dei clienti per garantire la sicurezza dei fondi degli investitori. Questa mossa mira a rafforzare il mercato degli asset virtuali e a proteggere gli utenti da possibili vulnerabilità di sicurezza o rischi di bancarotta. Secondo quanto riportato, le borse autorizzate come OSL Exchange e HashKey Exchange hanno adottato misure per fornire una copertura assicurativa oltre i requisiti, aumentando la fiducia degli investitori nel mercato delle criptovalute.</p>
<p>Il 30 gennaio, secondo Yujin Monitoring, in base all’afflusso/deflusso dei fondi ETF spot BTC del 29 gennaio, è previsto che dopo l’apertura del mercato azionario statunitense oggi, ci sarà un trasferimento di circa 14.800 BTC (circa 638,8 milioni di dollari) a vari indirizzi di custodia ETF, di cui circa 4.441 BTC <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> dall’indirizzo di custodia di Grayscale GBTC; I restanti nove indirizzi di custodia ETF si riverseranno in circa 10.359 BTC; L’ingresso netto complessivo è di circa 5.918 BTC. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot hanno registrato afflussi netti per due giorni consecutivi.</p>
<p>Il 30 gennaio, secondo i dati di Arkham, l’indirizzo di possesso di Grayscale ha trasferito 6.227 <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> a Coinbase Prime e altri due indirizzi 20 minuti fa. 4.418,63 bitcoin sono stati trasferiti a Coinbase Prime e 1.808,96 bitcoin sono stati trasferiti agli altri due indirizzi.</p>
<p>Intorno alle 7 del mattino del 31 gennaio, Celsius ha ricevuto 25266 BTC del valore di 1,1 miliardi di dollari da FalconX all’indirizzo che inizia con bc1qy. L’indirizzo di ricezione è stato etichettato come “Prestito” da Arkham. Inoltre, secondo l’analista on-chain @ai_9684xtpa il monitoraggio mostra che intorno alle 5 di stamattina, Celsius ha ricaricato 39.968 ETH del valore di 94,91 milioni di dollari all’indirizzo di Coinbase Prime; Attualmente detiene 50.219 ETH.</p>
<p>Il 31 gennaio, Musk ha cancellato i contenuti del profilo della piattaforma X precedentemente modificato “(CTO) Chief Troll Officer”. Secondo i dati di CoinGecko, TROLL ha registrato un calo del 55% in 24 ore ed è ora quotato a $0.0000001861.</p>
<p>Ultimi progressi su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Aggiornamento Denchun: Il 31 gennaio, l’aggiornamento Denchun sulla testnet di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Sepolia verrà effettuato alle 06:51 ora di Pechino del 2 febbraio e completato alle 07:10 del 2 febbraio.</p>
<p>Sepolia è il secondo dei tre testnet simulati da Denchun. All’inizio di questo mese, Denchun è stato lanciato sulla testnet di Goerli, ma inizialmente non è stato finalizzato.</p>
<p>Il 7 febbraio, Denchun sarà lanciato sul suo testnet Ethereum finale, Holesky. Successivamente, gli sviluppatori firmeranno la data di attivazione per Denchun sulla blockchain principale. Il testnet replica la blockchain principale e consente agli sviluppatori di apportare eventuali modifiche al protocollo o alle sue applicazioni decentralizzate in un ambiente a basso rischio.</p>
<p>Secondo le notizie precedenti, se tutto va secondo i piani, Denchun sarà programmato per lanciare il mainnet di Ethereum entro la fine di febbraio o l’inizio di marzo. Inizialmente ci si aspettava che Denchun si esibisse nell’ultimo trimestre del 2023, che sarà il più grande aggiornamento su Ethereum dalla Shapella upgrade dello scorso marzo. Questo aggiornamento include molteplici cambiamenti, il più notevole dei quali è l’introduzione di blocchi di dati temporanei (anche noti come “protodanksharding”) per EIP-4844, che aiuterà a ridurre i costi delle transazioni L2.</p>
<p>Per quanto riguarda gli ETF Ethereum spot, Geoffrey Kendrick, responsabile del foreign exchange presso la Standard Chartered Bank, ha recentemente affermato che la SEC potrebbe approvare gli ETF Ethereum spot il 23 maggio, che è la data limite finale per l’approvazione del primo lotto di ETF Ethereum spot.</p>
<p>La ragione principale per cui Kendrick ha espresso il giudizio sopra riportato è che la SEC non ha classificato Ethereum come una security nella sua causa legale contro le aziende cripto, e l’inclusione di ETH come contratto futures regolamentato presso il Chicago Mercantile Exchange ha aumentato questa aspettativa.</p>
<p>Kendrick ha anche dichiarato che Grayscale possiede un trust ETH e spera di convertirlo in un ETF, quindi il rifiuto della domanda di ETF potrebbe portare Grayscale a fare nuovamente ricorso.</p>
<p>Le notizie positive per l’ecosistema Ethereum si susseguono una dopo l’altra. Secondo fonti ufficiali, la rete Ethereum Layer 2 Metis ha pubblicato i risultati dei test della community sulla piattaforma X. Al 28 gennaio, il testnet conta più di 115.000 contributori, oltre 3 milioni di transazioni ed è stato sottoposto a oltre 600 rotazioni di sequenziamento. Il totale attuale dei punti del testnet ha superato i 300 milioni e la seconda stagione di testing della community inizierà il 5 febbraio.</p>
<p>Nel frattempo, le transazioni sul <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Le transazioni blockchain stanno diventando sempre più attive e, secondo i dati di The Block, il volume di transazioni sulla blockchain <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ha raggiunto un nuovo massimo annuale questo mese. Il volume di transazioni dei token SOL e SPL sulla blockchain Solana è aumentato fino a $951,9 miliardi e il throughput economico della rete è aumentato del 30% rispetto ai $735,8 miliardi di dicembre. Inoltre, la crescita dell’attività di trading sulla blockchain Solana è significativamente superiore rispetto ai livelli della maggior parte del 2023 e del 2022.</p>
<h2 id="h2-Macro20i20dati20sulle20vacanze20di20lavoro20al20di20sotto20delle20aspettative20concentrandosi20sul20debutto20del20202420della20Federal20Reserve750833"><a name="Macro: i dati sulle vacanze di lavoro al di sotto delle aspettative, concentrandosi sul “debutto del 2024” della Federal Reserve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: i dati sulle vacanze di lavoro al di sotto delle aspettative, concentrandosi sul “debutto del 2024” della Federal Reserve</h2><p>Martedì, l’indice del dollaro americano ha oscillato e ha registrato un calo. Durante la giornata, ha brevemente invertito la tendenza a causa di dati occupazionali robusti, ma poi è tornato al suo trend al ribasso e alla fine ha chiuso in calo dello 0,072% a 103,4; il rendimento dei titoli del Tesoro americano a 10 anni è aumentato temporaneamente durante il periodo di mercato americano, ma ha continuato a diminuire alla fine della giornata, rompendo il minimo intraday e chiudendo alla fine a 4,035%; il rendimento dei titoli del Tesoro americano a 2 anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, ha chiuso appena più alto a 4,339%.</p>
<p>Supportato dal deprezzamento del dollaro statunitense e dal rendimento dei titoli del Tesoro degli Stati Uniti, l’oro fisico ha brevemente raggiunto il suo livello più alto dal 16 gennaio, ma ha cancellato la maggior parte dei guadagni dopo la pubblicazione dei dati sulle offerte di lavoro, chiudendo infine in rialzo dello 0,19% a $2036,78 per oncia. L’argento fisico ha chiuso infine in ribasso dello 0,19% a $23,16 per oncia.</p>
<p>A causa dell’aggiornamento al rialzo delle prospettive di crescita economica globale di quest’anno da parte del FMI che ha stimolato le prospettive della domanda, il greggio internazionale è passato dal declino alla crescita e il mercato sta ancora aspettando come gli Stati Uniti risponderanno agli attacchi letali con droni contro il loro personale militare in Medio Oriente. Il greggio WTI è salito dell’1,04% a $77,68 al barile; il greggio Brent è salito dello 0,55% a $82,86 al barile.</p>
<p>I tre principali indici azionari statunitensi hanno guadagni e perdite misti, con il Dow Jones Industrial Average in rialzo dello 0,34%, il Nasdaq in calo dello 0,76% e l’indice S&amp;P 500 leggermente in ribasso.</p>
<p>In precedenza, i dati sulle vacanze di lavoro più recenti pubblicati per JOLT negli Stati Uniti per dicembre sono stati superiori alle aspettative, pari a 8,75 milioni, saliti a 9,026 milioni, il livello più alto degli ultimi tre mesi. Il mercato degli swap riduce la probabilità che la Federal Reserve riduca i tassi di interesse a marzo al 40% circa.</p>
<p>Attualmente, l’inflazione sembra tornare rapidamente al target del 2% della Federal Reserve, anche se gli indicatori di attività economica indicano che l’economia si sta sviluppando in modo sano, i sondaggi regionali della Fed indicano una debolezza economica. Con il rischio di un’eccessiva stretta politica che si bilancia sempre di più, e con l’uscita di dati importanti, i decisori politici potrebbero mantenere invariati i tassi di interesse nella riunione di questa settimana e spiegare gli standard per i futuri tagli dei tassi.</p>
<p>Gli economisti di Bloomberg Economics Anna Wong e Stuart Paul prevedono che la Federal Reserve inizierà a tagliare i tassi di interesse a marzo. Se questo dovesse effettivamente accadere, il presidente della Federal Reserve, Powell, potrebbe inviare un segnale durante la testimonianza di Humphrey Hawkins al Congresso alla fine di febbraio o all’inizio di marzo. A quel tempo, il FOMC dovrebbe avere abbastanza dati per prendere una decisione, e stiamo aspettando il prossimo debutto della Federal Reserve nel 2024.</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à consentita la ripubblicazione dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>