Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGhhIHN1cGVyYXRvIGkgJCA0NS4wMDA7IElsIHZvbHVtZSBkaSBsaXF1aWRhemlvbmUgZGkgVFJCIMOoIHN0YXRvIGlsIHBpw7kgYWx0byBuZWxsJ2ludGVyYSByZXRlOyBIRlQsIFNVSSwgQUNBIGUgYWx0cmkgdG9rZW4gcmljZXZlcmFubm8gZ3JhbmRpIHNibG9jY2F0aSBxdWVzdGEgc2V0dGl

2024-01-02, 03:54

<p><img src="https://gimg2.gateimg.com/image/article/17041795201_3.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20BTC20supera20i204500020il20volume20in20uscita20di20TRB20si20posiziona20al20top20tra20tutte20le20reti764197"><a name="Riassunto giornaliero delle criptovalute: BTC supera i $45.000, il volume in uscita di TRB si posiziona al top tra tutte le reti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: BTC supera i $45.000, il volume in uscita di TRB si posiziona al top tra tutte le reti</h2><p>Il 2 gennaio, la giornalista di Fox Eleanor Terrett ha pubblicato sulla piattaforma X affermando che anche se il comportamento della Securities and Exchange Commission (SEC) degli Stati Uniti è imprevedibile, è improbabile che il spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Gli ETF saranno approvati il ​​giorno successivo. Dalla conversazione con l’emittente, si è appreso che la SEC deve ancora esaminare tutte le modifiche al modulo S-1 presentato lo scorso giovedì/venerdì e fornire commenti su di esso.</p>
<p>Se la SEC segue un calendario di approvazione simile a quello dei future ETH di ottobre, l’agenzia comunicherà con l’emittente dopo questa fase di revisione la data in cui desidera presentare il modulo S-1 finale e renderlo effettivo entro le prossime 24-48 ore. Lo staff della SEC è stato in vacanza dall’ultimo venerdì, quindi sembra che il tempo stia scadendo se vogliono l’approvazione martedì o mercoledì.</p>
<p>Precedentemente, fonti di BlackRock hanno dichiarato che la SEC potrebbe non essere in grado di approvare gli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot fino a questo fine settimana.</p>
<p>Il recente “Blockchain White Paper (2023)” pubblicato dalla China Academy of Information and Communications Technology mostra che a dicembre 2023, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ha circa 7500 nodi, di cui circa 3400 nodi negli Stati Uniti e circa 1800 nodi in Germania, che rappresentano quasi il 70% del totale.</p>
<p>A ottobre 2023, il numero di aziende unicorn blockchain globali (con un valore di mercato superiore a 1 miliardo di dollari) ha raggiunto 131. Le prime cinque posizioni nella classifica di valutazione sono: Biance ($45 miliardi), Upbit ($17 miliardi), Ripple ($15 miliardi), Blockchain Com ($14 miliardi) e OpenSea ($13 miliardi).</p>
<p>Secondo un rapporto sul mining di Bitcoin pubblicato da Bankless Times, la potenza di calcolo dei 28 stati membri dell’Unione Europea (UE) rappresenta un totale del 6% della potenza di calcolo della rete Bitcoin. Tra questi, l’Irlanda rappresenta il 2% della potenza di calcolo della rete Bitcoin. Gli Stati Uniti sono attualmente uno dei principali paesi per il mining di Bitcoin, con il 38% della potenza di calcolo della rete. La Cina è attualmente al secondo posto con una quota del 21%, seguita da Kazakistan (13%), Canada (7%) e Russia (5%) rispettivamente dal terzo al quinto.</p>
<p>Secondo l’analista on-chain Yu Jin, in base al monitoraggio, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> è diventato il decimo più grande detentore di BTC. Nell’ultimo giorno del Q4, <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> ha continuato a presentare richieste di BTC da Bitfinex, per un totale di 888,88 richieste di BTC (379 milioni di dollari). Al momento, Tether detiene un totale di 66465,2 BTC (2,82 miliardi di dollari), con un costo complessivo di circa 25.176 dollari e un profitto fluttuante di 1,148 miliardi di dollari (+68%).</p>
<p>Il 2 gennaio, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> La nuova criptovaluta Meme coin LFG di Gate.io ha aperto le candidature per l’airdrop destinato agli utenti Ethereum. LFG è il primo airdrop dell’ecosistema <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> rivolto agli utenti Ethereum, al fine di portare più utenti <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> all’interno di Solana.</p>
<p>L’offerta totale di token LFG è di 1 trilione, di cui il 60% sarà utilizzato per gli airdrop. I criteri di qualificazione per il primo airdrop sono che il gas costi almeno $ 4.269 per gli indirizzi Ethereum e interagisca con almeno un protocollo Ethereum comune. La stima ufficiale è che un totale di 400 miliardi di LFG saranno <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Fluire</a> in 387.000 indirizzi del portafoglio. Il portafoglio avrà un mese per raccogliere e gli LFG non reclamati saranno distrutti dopo questo periodo. Il secondo airdrop verrà distribuito ai destinatari del portafoglio airdrop LP.</p>
<p>Il 1° gennaio, secondo i dati di mercato Gate.io, TRB ha subito forti fluttuazioni nelle ultime 24 ore. Ha toccato un massimo storico di $ 315 alle 20:47 di ieri sera e poi è sceso del 25% per raggiungere $ 232 in un breve periodo di tempo. È poi salito di oltre il 200% in 7 ore e ha raggiunto un massimo storico di $ 714,55 alle 4:26 di oggi. Dopo un leggero consolidamento, ha iniziato un forte calo ed è sceso del 73% in 3 ore. Ora è quotato a $ 270.</p>
<p>Inoltre, dalla mattina presto di oggi, quando il TRB è salito a un livello elevato, ci sono stati vari gradi di premio tra le piattaforme tradizionali, così come tra le coppie di trading spot e contratti. Attualmente, la piattaforma Bybit ha ancora un premio di circa il 20% rispetto ad altre piattaforme.</p>
<p>Secondo i dati di Coinglas, a causa delle drastiche fluttuazioni nei prezzi di TRB, il suo volume di liquidazione nelle ultime 24 ore ha raggiunto i 57,78 milioni di dollari, quasi il doppio del volume di liquidazione di BTC (24,3 milioni di dollari).</p>
<p>Il mercato mostra che il prezzo del BTC ha superato i $45.000 ed è attualmente segnalato a $45.044,09, con un aumento del 6,02% nelle ultime 24 ore. Nelle ultime 12 ore, l’intero contratto di rete è stato venduto per $102 milioni, di cui gli ordini brevi sono stati venduti per $86,7213 milioni.</p>
<p>I dati di Coinglass mostrano che nelle ultime 12 ore, il mercato delle criptovalute ha visto un totale di $102 milioni di contratti di criptovaluta venduti in tutta la rete, con molteplici ordini venduti a $15.117 milioni e ordini brevi venduti a $86.7213 milioni. Il totale dell’ammontare di liquidazione BTC è di circa $51.2641 milioni, mentre l’ammontare totale della liquidazione ETH è di $13.1526 milioni.</p>
<p>Secondo i dati degli sblocchi dei token, questa settimana HFT, SUI, ACA e altri token esperimenteranno uno sblocco una tantum di grandi dimensioni, con un valore di rilascio totale di circa $43.37 milioni. Tra di essi:</p>
<p>Alle 7:00 (UTC) del 1° gennaio, Acala sbloccherà 27,43 milioni di ACA (circa 2,95 milioni di dollari), pari al 3,1% dell’offerta circolante;</p>
<p>Alle 0:00 del 2 gennaio (UTC), Sui sbloccherà 34,62 milioni di SUI (circa 26,88 milioni di dollari), corrispondenti al 3,35% dell’offerta circolante;</p>
<p>Alle 0:00 AM (UTC) del 5 gennaio, Galxe sbloccherà 3 milioni di GALs (circa 6,97 milioni di dollari), pari al 3,34% dell’offerta circolante;</p>
<p>Alle 0:00 del 7 gennaio (UTC), Hashflow sbloccherà 13,62 milioni di HFT (circa 5,14 milioni di dollari), corrispondenti al 4,81% dell’offerta circolante; Inoltre, HFT sbloccherà 316.200 token al giorno per 366 giorni a partire da quel giorno.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi811436"><a name="Tendenze principali dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali dei token di oggi</h2><h3 id="h3-BTC556375"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1704179657BTC.png" alt=""><br>La mattina si è aperta con un trend al rialzo continuo, raggiungendo la resistenza precedentemente individuata a $45.345 USD. La chiusura più alta della mattina è stata di $45.365 USD, rispettando le aspettative. Si prevede che questa settimana continui a stabilizzarsi intorno all’alta fascia di $41.500 USD. Nel breve termine, potrebbe esserci un potenziale inversione di tendenza, con un recupero dal recente calo e la successiva resistenza a $47.990 USD.</p>
<p>Se il “momentum-driven time” scatena una liquidazione nei mercati a leva, il primo trimestre di quest’anno potrebbe vedere un ritracciamento nell’intervallo di $26.000 a $28.500 USD. Se il “time-driven momentum” porta a un declino graduale, il supporto prima del secondo trimestre potrebbe essere trovato nell’intervallo di $36.000 USD a $33.085 USD.</p>
<h3 id="h3-ETH194643"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1704179682ETH.png" alt=""><br>A breve termine, il grafico delle quattro ore mostra un secondo tentativo di salire, toccando la resistenza a $2.381 USD senza riuscire a mantenere. Il consiglio a breve termine è di mantenere il supporto a $2.332 USD. Se una rottura al di sopra di $2.489 USD fallisce, potrebbe verificarsi una falsa rottura seguita da un vero declino. La prospettiva a lungo termine rimane positiva con obiettivi massimi a $8.000 USD e $12.350 USD.</p>
<h3 id="h3-LINK354404"><a name="LINK" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LINK</h3><p><img src="https://gimg2.gateimg.com/image/article/1704179768LINK.png" alt=""><br>A breve termine, il grafico delle quattro ore ha raggiunto nuovi massimi recenti. Ci si aspetta che questa settimana continui a oscillare nel range dell’alto canale ascendente, con una probabile inversione di tendenza a medio termine al top di testa e spalle, con un massimo a $17,16 USD. Nel lungo termine, il mercato rialzista vede il potenziale per superare $56,02 USD, $79,80 USD e $107,54 USD, con oltre 7 volte lo spazio attuale.</p>
<h2 id="h2-Macro20I20tre20principali20indici20azionari20registreranno20un20significativo20aumento20nel20202320e20CICC20prevede20che20la20Fed20taglier20i20tassi20di20interesse20nel20secondo20trimestre956539"><a name="Macro: I tre principali indici azionari registreranno un significativo aumento nel 2023 e CICC prevede che la Fed taglierà i tassi di interesse nel secondo trimestre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I tre principali indici azionari registreranno un significativo aumento nel 2023 e CICC prevede che la Fed taglierà i tassi di interesse nel secondo trimestre</h2><p>Venerdì scorso, l’indice del dollaro statunitense ha oscillato in modo stretto sopra il livello 101, chiudendo infine in rialzo dello 0,11% a 101,35. È sceso di oltre il 2% nel 2023, con la maggior parte della diminuzione avvenuta nel quarto trimestre; Il rendimento dei titoli di stato statunitensi ha oscillato, ponendo fine al trend positivo consecutivo di due anni. Il rendimento dei titoli di stato statunitensi a 10 anni ha chiuso infine al 3,866%, leggermente inferiore al livello di chiusura del 3,875% nel 2022; Il rendimento dei titoli di stato statunitensi a due anni, che è più sensibile ai tassi di interesse politici della Federal Reserve, ha chiuso al 4,25%, in calo di quasi 20 punti base per l’anno.</p>
<p>L’oro fisico ha registrato un secondo giorno consecutivo di declino nelle negoziazioni, scendendo al di sotto di $2.060 durante la giornata e chiudendo infine in calo dello 0,15% a $2.062,94 per oncia. Nel 2023, ha accumulato un aumento del 13%, segnando la sua migliore performance annuale dal 2020. L’argento fisico ha chiuso in calo dello 0,84% a $23,79 per oncia.</p>
<p>Nonostante le preoccupazioni per l’escalation della situazione nel Mar Rosso, il sentiment ribassista nel mercato del petrolio è comunque prso a causa della produzione record da parte dei paesi al di fuori dell’OPEC, con il petrolio greggio WTI che alla fine ha chiuso in ribasso dello 0,95% a 71,24 dollari al barile; il petrolio greggio Brent alla fine ha chiuso in ribasso dello 0,58% a 77,19 dollari al barile. Due compagnie petrolifere hanno mostrato una debole performance durante tutto l’anno, registrando un calo superiore al 10%, segnando il primo declino annuale dal 2020. I futures del gas naturale statunitense sono scesi di quasi il 44% nel 2023, segnando il più grande calo annuale dal 2006.</p>
<p>I tre principali indici azionari statunitensi hanno chiuso leggermente al ribasso, ma tutti hanno ottenuto il loro nono settimana consecutiva di guadagni. Il Nasdaq è sceso dello 0,56%, con un aumento cumulativo dello 0,12% la settimana scorsa e un aumento cumulativo di oltre il 43% per l’intero anno; l’indice S&amp;P 500 è sceso dello 0,28%, con un aumento cumulativo dello 0,32% la settimana scorsa e un aumento cumulativo di oltre il 24% per l’intero anno; il Dow Jones Industrial Average è sceso dello 0,05%, con un aumento cumulativo dello 0,81% la settimana scorsa e un aumento cumulativo di oltre il 13% per l’intero anno.</p>
<p>I sette giganti del mercato azionario statunitense hanno registrato un significativo aumento nel 2023, con Nvidia che è salita di quasi il 240% nell’anno, segnando il maggior aumento annuale dal 2001; La casa madre di Facebook, Meta, è salita oltre il 194% durante l’anno, segnando il maggior aumento annuale dalla sua quotazione; L’incremento annuale cumulativo di Tesla ha superato il 101%.</p>
<p>Di recente, la China International Capital Corporation (CICC) ha pubblicato un rapporto di ricerca affermando che, sulla base degli ultimi sviluppi, riteniamo che la Federal Reserve possa desiderare di abbassare i tassi di interesse nel secondo trimestre del 2024, un trimestre prima rispetto alle nostre aspettative. I potenziali cambiamenti nella politica monetaria degli Stati Uniti riflettono in qualche misura la nostra visione precedentemente enfatizzata secondo cui la Federal Reserve è probabile che aumenti la sua tolleranza all’inflazione per la crescita.</p>
<p>Tuttavia, va notato che i tagli ai tassi di interesse precoci possono comportare rischi di “non atterraggio” economico e “inflazione secondaria”, aggravando la volatilità del mercato.</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 venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>