Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgU0VDIHBvdHJlYmJlIGFwcHJvdmFyZSBnbGkgRVRGIEJpdGNvaW4gU3BvdCBnacOgIGRhIG1hcnRlZMOsOyBaS0Jhc2Ugc3RhIHBlciBpbXBsZW1lbnRhcmUgdW5vIHNjYW1iaW8gZGkgdG9rZW4gMToxOyBUUkIsIFNJTExZIGUgT1JESSBzY2hpenphbm8gYWxsZSBzdGVsbGU=

2024-01-01, 02:09

<p><img src="https://gimg2.gateimg.com/image/article/17040832451_2.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20SEC20potrebbe20approvare20gli20ETF20Bitcoin20spot20gi20da20marted20TRB20SILLY20e20ORDI20schizzano20in20alto490259"><a name="Crypto Daily Digest: La SEC potrebbe approvare gli ETF Bitcoin spot già da martedì; TRB, SILLY e ORDI schizzano in alto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La SEC potrebbe approvare gli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot già da martedì; TRB, SILLY e ORDI schizzano in alto</h2><p>E’ il primo giorno del 2024, Buon Anno a tutti!</p>
<p>In primo luogo, l’ETF tanto atteso arriverà presto. Secondo Reuters, citando fonti a conoscenza della questione, se scelgono di approvare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF spot, potrebbero notificare l’emittente già martedì o mercoledì di questa settimana.</p>
<p>Ieri, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il fondatore Vitalik Buterin ha twittato una roadmap aggiornata per lo sviluppo di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> nel 2023. La roadmap comprende principalmente sei parti: The Merge, The Surge, The Scourge, The Verge, The Purge e The Spluge. “The Merge”, completato a settembre 2022, segna il passaggio di Ethereum dal meccanismo di consenso PoW a PoS, riducendo significativamente il consumo energetico della rete. Nel frattempo, “The Surge” ha fatto progressi significativi. Lo standard cross-rollup e l’interoperabilità sono anche aree che richiedono un miglioramento a lungo termine.</p>
<p>Inoltre, Buterin ha sottolineato che il ruolo di Single Slot Final Determinism (SSF) nel migliorare PoS dopo la fusione viene consolidato ed è il modo più semplice per affrontare molte delle attuali debolezze nel design di Ethereum PoS.</p>
<p>Per quanto riguarda la traccia ZK, secondo i rapporti ufficiali, il protocollo completo di livello 2 ZKBase (precedentemente noto come ZKSpace) basato su ZK Rollups ha completato la distruzione di 400 milioni di token (corrispondenti al 40% del totale di ZKS), riducendo l’importo non emesso di ZKS da 440 milioni a 40 milioni, con un tasso di deflazione superiore al 90%. In combinazione con il riacquisto e la distruzione in corso della piattaforma, l’importo totale di ZKS è diminuito da 1 miliardo a meno di 600 milioni, e i token rimanenti saranno utilizzati per future attività operative e incentivi alla comunità.</p>
<p>Nel 2024, il team prevede di lanciare ZKSwap (Bitcoin) per i token BRC20 e Bitcoin e di aggiornare ZKS ai token di governance dual chain Layer2 di ETH e BTC. In precedenza, il team di ZKBase ha annunciato l’aggiornamento del marchio a ZKBase, compreso lo scambio di ZKS1:1 per ZKB, che diventerà il nuovo token di governance del team di ZKBase. I detentori di token possono godere di vari vantaggi come i vantaggi di cross chain ERC20-BRC20 e il 100% delle commissioni di transazione.</p>
<p>Il team del futuro svilupperà ulteriormente l’ecosistema Layer2 di ETH e BTC e migrerà una parte dei token ZKS sulla rete BTC. I benefici ottenuti dalla migrazione saranno anche completamente utilizzati per il continuo riacquisto e la distruzione dei token e per accelerare i piani di deflazione dei token.</p>
<p>Secondo i dati di Dune, il reddito totale accumulato dalle iscrizioni ordinarie del protocollo Bitcoin NFT ha raggiunto 5238.0058 BTC, equivalenti a circa $218.359.158. Il numero totale attuale di iscrizioni eseguite raggiunge 52.651.648.</p>
<p>In termini di fluttuazioni di mercato, Teller Tributees (TRB) attualmente viene scambiato a $282.81, con un aumento del 16.66% nelle ultime 24 ore; <a href="/price/kadena-kda" rel="nofollow noopener noreferrer" target="_blank">Kadena</a>(KDA) attualmente segnala $1.37, con un aumento del 24 ore del 19.6%; Silly Dragon (SILLY) è attualmente scambiato a $0.139, in aumento dell’11% in 24 ore; ORDI (ORDI) è attualmente scambiato a $82.36, con un aumento del 24 ore del 9.4%.</p>
<p>Tuttavia, il ritiro è arrivato anche rapidamente. I dati di Coinglass mostrano che i contratti TRB hanno esaurito $59.9364 milioni nelle ultime 24 ore, con ordini multipli che hanno esaurito $19.1616 milioni e ordini short che hanno esaurito $40.7748 milioni.</p>
<p>Il mercato mostra che TRB è salito rapidamente in precedenza, superando i $600 nel breve termine, per poi subire un significativo ritracciamento. Attualmente si trova a $208.31, in calo del 20.2% nelle ultime 24 ore; SILLY è attualmente quotata a $0.132, mentre ORDI (ORDI) è quotata a $81.10.</p>
<p>Secondo The Block, il protocollo di collegamento cross-chain Orbit Chain è sospettato di essere stato hackerato, causando un flusso anomalo di criptovaluta del valore di 81,5 milioni di dollari. In cinque transazioni separate, Orbit Bridge ha inviato stablecoin per un valore di 50 milioni di dollari (30 milioni di USDT, 10 milioni di DAI e 10 milioni di USDC), 231 wBTC (circa 10 milioni di dollari) e 9500 ETH (circa 21,5 milioni di dollari).</p>
<p>L’utente X Kgjr è stato il primo a notare il comportamento di hacking, e la natura esatta dell’attacco di hacking è ancora poco chiara. Secondo il monitoraggio di PeckShield, l’attaccante ha inizialmente raccolto 10 ETH da Tornado Cash e li ha trasferiti attraverso un indirizzo intermedio che inizia con 0x704.</p>
<p>Secondo le statistiche di CertiK, gli incidenti di sicurezza nel campo della crittografia a dicembre hanno causato un totale di $33.5 milioni di perdite, tra cui circa $3.2 milioni di perdite da truffe in uscita, circa $2.4 milioni di perdite da attacchi di prestito lampo e circa $27.8 milioni di perdite da incidenti di sfruttamento.</p>
<h2 id="h2-Macro20Nella20prima20settimana20del20202420i20dati20sugli20occupati20non20agricoli20e20le20riunioni20della20Federal20Reserve20stanno20per20dare20il20via20alla20vigilia20di20Capodanno845595"><a name="Macro: Nella prima settimana del 2024, i dati sugli occupati non agricoli e le riunioni della Federal Reserve stanno per dare il via alla vigilia di Capodanno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Nella prima settimana del 2024, i dati sugli occupati non agricoli e le riunioni della Federal Reserve stanno per dare il via alla vigilia di Capodanno</h2><p>La transazione del 2023 si è conclusa così. Il prezzo dei futures dell’oro di New York è aumentato di oltre il 13% durante l’anno, segnando la maggior crescita annuale dal 2020. Le aspettative del mercato di un taglio dei tassi di interesse della Federal Reserve già a marzo dell’anno prossimo hanno spinto i prezzi dell’oro.</p>
<p>Nel 2023, i futures dell’oro di New York hanno registrato un minimo di quasi $1.800 e un massimo di un record di $2.135,40. Gli investitori si aspettano che i prezzi dell’oro raggiungano un massimo storico nel 2024, poiché il mercato si aspetta in generale un’inversione di rotta accomodante nelle politiche della Federal Reserve, rischi geopolitici in corso e acquisti di oro da parte delle banche centrali per sostenere il mercato dell’oro.</p>
<p>L’indice del dollaro statunitense è sceso di oltre il 2% nel 2023, il più grande calo annuale dal 2020. A causa del sempre maggior numero di persone che scommettono che la Federal Reserve taglierà i tassi di interesse nel 2024, il dollaro statunitense ha subito un significativo calo nel quarto trimestre, indebolendo la sua attrattiva poiché altre banche centrali potrebbero mantenere tassi di interesse più alti per un periodo più lungo. Attualmente, gli operatori di swap si aspettano che la Federal Reserve tagli i tassi di interesse di almeno 150 punti base, con tagli che inizieranno già a partire da marzo. Tuttavia, il recente calo del dollaro statunitense indica che c’è ancora spazio per un temporaneo rimbalzo.</p>
<p>La diminuzione annuale del petrolio greggio è di circa il 10%, interrompendo la tendenza al rialzo di due anni consecutivi. Questo cambiamento può essere attribuito a un anno tumultuoso, con tensioni geopolitiche, tagli alla produzione e una diminuzione dell’inflazione globale che evidenziano le difficoltà che il petrolio greggio dovrà affrontare, e ci si aspetta che si indebolisca ulteriormente nel prossimo futuro. Gli investitori devono ancora monitorare attentamente la situazione. I future sul gas naturale statunitense sono diminuiti del quasi il 44% nel 2023, segnando la più grande diminuzione annuale dal 2006.</p>
<p>Nella prima settimana del nuovo anno, il mercato accoglierà dati di grande rilevanza come il rapporto sulle retribuzioni non agricole, i verbali del meeting della Federal Reserve e l’indice PMI per le industrie manifatturiere e dei servizi in Europa e America.</p>
<p>I verbali della riunione del Federal Open Market Committee (FOMC) potrebbero rivelare la volontà della Federal Reserve di ridurre i tassi di interesse nel primo trimestre. In quella riunione, i funzionari hanno dato l’idea di mettere fine all’aumento radicale dei tassi di interesse. La Federal Reserve ha mantenuto il suo tasso di interesse di riferimento ai massimi livelli dal 2001 e non si prevede che lo aumenterà ulteriormente. Le previsioni trimestrali mostrano che i funzionari della Federal Reserve si aspettano di abbassare i tassi di interesse di 75 punti base l’anno prossimo. I prossimi verbali forniranno ulteriori dettagli sulla decisione sopra menzionata.</p>
<p>Se le aspettative di un taglio dei tassi d’interesse della Federal Reserve nel primo trimestre si consolidano, potrebbe ulteriormente sopprimere il dollaro statunitense e aumentare l’oro. È interessante notare che l’oro spesso si comporta bene nel primo mese di ogni anno. Dal 1971, il rendimento medio dell’oro a gennaio è stato del 1,79%. Durante lo stesso periodo, l’oro ha ottenuto rendimenti positivi per quasi il 60% del tempo a gennaio.</p>
<p>Nel 2000, l’oro ha ottenuto rendimenti nel 70% di gennaio. Oltre all’influenza della Federal Reserve, la domanda di oro aumenterà dopo l’ingresso del Capodanno cinese. Se il trend storico rimane invariato, è probabile che l’oro continui a riprendersi fino al primo mese del 2024. Ciò significa che potrebbe essere una buona opportunità di acquisto.</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 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>