Tm90aXppZSBxdW90aWRpYW5lIHwgU0FUUyBoYSBzdXBlcmF0byBPUkRJIG5lbGxhIGNhcGl0YWxpenphemlvbmUgZGkgbWVyY2F0bzsgbGEgU0VDIGFwcHJvdmEgQml0Y29pbiBTcG90IEVURiBnacOgIGEgZ2VubmFpbyBwcm9zc2ltbyBhbm5vOyBTJlAgaGEgcHViYmxpY2F0byBpbCByYXBwb3J0byBkaSB2YWx1dGF6aW9uZSBkZWxsZSB

2023-12-13, 03:52

<p><img src="https://gimg2.gateimg.com/image/article/17024477401_8.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20SATS20supera20ORDI20in20capitalizzazione20di20mercato20la20SEC20approva20gli20ETF20Bitcoin20spot20gi20a20partire20da20gennaio20prossimo952672"><a name="Riepilogo giornaliero delle criptovalute: SATS supera ORDI in capitalizzazione di mercato, la SEC approva gli ETF Bitcoin spot già a partire da gennaio prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: SATS supera ORDI in capitalizzazione di mercato, la SEC approva gli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot già a partire da gennaio prossimo</h2><p>Innanzitutto, diamo un’occhiata agli ultimi sviluppi nelle iscrizioni che hanno recentemente attirato molta attenzione sul mercato.</p>
<p>Ieri, è stata scoperta una vulnerabilità CVE-2023-50428 in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il software Core prima della versione 26.0 e Bitcoin Knots prima della versione 25.1. knots20231115 è stato ufficialmente adottato da NVD (National Vulnerability Database degli Stati Uniti). Questa vulnerabilità consente di aggirare le restrizioni sulle dimensioni dei dati mascherando i dati come codice (ad esempio, utilizzando OP-FALSE OP-IF), che è stato sfruttato da “Inion” nel 2022 e nel 2023. Il punteggio di base di CVSS (Common Vulnerability Scoring ), che è stato ufficialmente valutato da NVD per questa vulnerabilità, è 5,3, appartenente al livello di rischio medio.</p>
<p>Contrariamente a queste notizie negative, il sentimento FOMO delle persone nei confronti delle iscrizioni continua ad aumentare.</p>
<p>Il 12 dicembre, secondo i dati di mercato, il valore di mercato totale di SATS ha superato ORDI (valore di mercato totale di 1,135 miliardi di dollari), con un rapporto temporaneo di 1,137 miliardi di dollari, posizionandosi al 62° posto nella classifica del valore di mercato delle criptovalute. Al momento della pubblicazione, SATS ha riportato temporaneamente 0,00000053 dollari, con un aumento del 140,49% nelle ultime 24 ore.</p>
<p>Le ultime notizie sugli ETF, che sono stati oscurati dalla popolarità delle iscrizioni in pista e si sono raffreddati, è che il 13 dicembre l’esperto degli ETF statunitensi Nate Geraci ha dichiarato sulla sua piattaforma di social media di aver comunicato con il co-fondatore di Valkyrie Funds, Steven McClurg, che ha dichiarato di aver avuto una conversazione molto dettagliata con la SEC riguardo alla struttura degli ETF Bitcoin spot ed è “molto vicino” a raggiungere un consenso. Si prevede che gli ETF Bitcoin spot creeranno nuove quote di fondi in contanti.</p>
<p>Inoltre, Nate Geraci ha dichiarato che il lavoro di preparazione del prodotto e l’infrastruttura di backend per il lancio dell’ETF sono pronti, e la SEC potrebbe approvare gli ETF Bitcoin spot in qualsiasi momento dopo il 2 gennaio.</p>
<p>Il molto atteso Bitcoin bond in El Salvador, il “Volcano Bond”, ha ottenuto l’approvazione regolamentare.</p>
<p>L’11 dicembre, il Comitato per gli Asset Digitali di El Salvador ha approvato l’emissione di bond vulcanici, che si prevede saranno lanciati nel primo trimestre del 2024. El Salvador ha approvato una legislazione importante l’11 gennaio per fornire un quadro giuridico per i bond supportati da Bitcoin per la prima volta. I bond vulcanici mirano a ripagare il debito sovrano e finanziare la costruzione della proposta Bitcoin City nel paese. L’Ufficio Nazionale Bitcoin (ONBTC) ha annunciato che i bond saranno emessi su Bitcoin Securities, un sito web di trading di azioni e obbligazioni basato su blockchain registrato a El Salvador.</p>
<p>Inoltre, El Salvador ha recentemente lanciato un progetto di mining di Bitcoin da 1 miliardo di dollari che utilizzerà le risorse vulcaniche del paese attraverso la collaborazione con Luxor Technology.</p>
<p>Ieri, il 12 dicembre, è stato il tredicesimo anniversario dell’ultima comunicazione pubblica di Satoshi Nakamoto, creatore di Bitcoin, sul forum di Bitcoin. In questo messaggio, Satoshi Nakamoto ha menzionato che ‘c’è ancora altro lavoro da fare in termini di attacchi [denial of service] DoS.’ Questa affermazione riflette la sua preoccupazione per la sicurezza delle reti Bitcoin, specialmente nella resistenza a potenziali attacchi di negazione del servizio. Da allora, Satoshi Nakamoto non ha più parlato pubblicamente e la sua identità e dove si trova rimangono uno dei più grandi misteri nell’industria delle valute digitali.</p>
<p>Martedì, l’agenzia di rating di fama internazionale Standard&amp;Poor’s Global Ratings ha pubblicato una valutazione sulla stabilità di otto stablecoin, tra cui Dai (Dai), First Digital USD (FDUSD), <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> (USDT), <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> (Frax), <a href="/price/trueusd-tusd" rel="nofollow noopener noreferrer" target="_blank">TrueUSD</a> (TUSD), <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a> (USDC), USDP e GUSD.</p>
<p>Gli analisti si concentrano principalmente sulla qualità degli asset di stablecoin che supportano la stabilità. La qualità complessiva è misurata dal rischio di custodia, dal credito e dal valore di mercato. I risultati della valutazione mostrano che USDC, USDP e GUSD hanno ricevuto una valutazione “forte”. USDT, DAI e FDUSD hanno ricevuto una valutazione “vincolata”, mentre <a href="/price/frax-frax" target="_blank" class="blog_inner_link">FRAX</a> e TUSD hanno ricevuto una valutazione “debole”. Gli analisti hanno affermato che nella prima valutazione nessuna stablecoin ha ricevuto la valutazione più alta di “molto forte”.</p>
<h2 id="h2-I20principali20trend20dei20token20di20oggi527456"><a name="I principali trend dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I principali trend dei token di oggi</h2><h3 id="h3-BTC538662"><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/1702447781BTC.png" alt=""><br>Il volume degli scambi CME è diminuito nettamente questa settimana e il mercato continua ad aprire al ribasso stamattina. Ci si aspetta che il mercato continui a ritracciare verso il livello di supporto di $40.400 questa settimana, con ulteriore supporto a $37.980. È previsto un secondo significativo ritracciamento in seguito. Per le posizioni long, si consiglia di rimanere stabili al livello di supporto di $35.333.</p>
<h3 id="h3-ETH459443"><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/1702447802ETH.png" alt=""><br>La scorsa settimana, il prezzo obiettivo di $2,381 per ETH è stato raggiunto con un massimo di $2,386. Questa settimana si prevede un ritracciamento, con livelli di supporto a $2,135 e $2,037. È stato raggiunto il massimo a breve termine, indicando un periodo di correzione ribassista a breve termine e rialzista a lungo termine. Considera di rientrare al livello di supporto di $1,951.</p>
<h3 id="h3-BIGTIME322974"><a name="BIGTIME" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BIGTIME</h3><p><img src="https://gimg2.gateimg.com/image/article/1702447824BIGTIME.png" alt=""><br>BIGTIME, posizionato dalla metà alla fine di ottobre, è rimasto silenzioso per oltre un mese. Ha mostrato di recente un notevole rialzo, raggiungendo quasi 1 dollaro nella scorsa settimana con un aumento complessivo di oltre dieci volte. È possibile una consolidazione a breve termine a livelli elevati. Il supporto a breve termine è a $0.5712 e $0.4494, con un potenziale pullback a $0.2316 prima di continuare il trend al rialzo.</p>
<p>A lungo termine, c’è un’opportunità per BIGTIME di guidare l’intero mercato dei giochi di catena, spingendo il valore di mercato a nuove altezze e creando una situazione tripla vittoria con guadagni di spot e contratti.</p>
<h2 id="h2-Macro20Con20limprevisto20aumento20dellindice20dei20prezzi20al20consumo20potrebbero20presto20arrivare20tagli20dei20tassi20di20interesse484907"><a name="Macro: Con l’imprevisto aumento dell’indice dei prezzi al consumo, potrebbero presto arrivare tagli dei tassi di interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Con l’imprevisto aumento dell’indice dei prezzi al consumo, potrebbero presto arrivare tagli dei tassi di interesse</h2><p>Martedì, il tasso di crescita su base annua dell’indice dei prezzi al consumo (CPI) non corretto degli Stati Uniti di novembre è rallentato al 3,1% come programmato, mentre il tasso di crescita su base mensile è accelerato inaspettatamente all’0,1%; Il tasso di crescita su base annua del CPI core è stato del 4%, invariato rispetto a ottobre e accelerato dello 0,3% su base mensile, entrambi in linea con le aspettative. I trader si aspettano ora che il primo taglio dei tassi da parte della Federal Reserve avvenga nel maggio 2024.</p>
<p>A causa dell’inaspettato aumento del tasso di crescita mensile del CPI negli Stati Uniti a novembre, che ha colpito le aspettative del mercato per i tagli dei tassi di interesse, il rendimento del Tesoro statunitense è salito nel breve termine durante la giornata. Il rendimento del Tesoro statunitense a medio e lungo termine è nuovamente sceso dopo la pubblicazione dei risultati dell’asta dei Treasuries statunitensi a 30 anni e il rendimento del Tesoro statunitense a 10 anni ha chiuso al 4,202%; Il rendimento del Tesoro statunitense a due anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, ha chiuso al 4,735%. L’indice del dollaro statunitense ha raggiunto un nuovo massimo dopo la pubblicazione dei dati del CPI, ma poi ha rinunciato ai guadagni e alla fine ha chiuso in ribasso dello 0,259% a 103,82.</p>
<p>L’oro spot è salito prima e poi è sceso, scendendo brevemente al di sotto del livello di $1.980 e chiudendo infine leggermente più basso dello 0,02% a $1.980,96 per oncia, ancora in bilico su un minimo di tre settimane; l’argento spot ha chiuso in calo dello 0,1% a $22,77 per oncia.</p>
<p>Il contraccolpo nelle aspettative di tagli ai tassi di interesse da parte della Federal Reserve in qualche misura significa che c’è un maggiore rischio di un brusco arresto dell’economia, causando un primo tentativo di ripresa del petrolio greggio internazionale a perdere slancio e colpire un nuovo minimo di 5 mesi. Il petrolio greggio WTI ha registrato un lieve aumento nel calo intraday al 4%, chiudendo infine in ribasso del 3,74% a 68,8 dollari al barile; il petrolio greggio Brent ha chiuso in ribasso del 3,53% a 73,58 dollari al barile.</p>
<p>I tre principali indici azionari statunitensi sono aumentati lentamente, con il Dow Jones Industrial Average in rialzo dello 0,48%, il Nasdaq in crescita dello 0,7% e l’indice S&amp;P 500 in aumento dello 0,46%, segnando quattro giorni consecutivi di guadagni e stabilendo un nuovo massimo di chiusura da gennaio 2022.</p>
<p>Dopo la pubblicazione dei dati CPI, la segretaria al Tesoro degli Stati Uniti Yellen ha commentato i dati CPI, affermando che il rialzo dei tassi di interesse reali potrebbe influenzare la decisione della Federal Reserve sul percorso dei tassi di interesse.</p>
<p>A livello macroeconomico, ci si attendeva un taglio dei tassi di interesse nella seconda metà dell’anno prossimo, ma ora il mercato ha previsto che si anticiperà a maggio. Dopo l’anno prossimo, questa aspettativa potrebbe continuare ad anticiparsi. Quindi, l’aspettativa di tagli dei tassi di interesse si anticiperà solo e non si ritirerà, e il numero di tagli dei tassi di interesse aumenterà solo e non diminuirà. Questa è la premessa per il supporto a livello macroeconomico di un mercato rialzista che inizia l’anno prossimo.</p>
<p>Con questa premessa, l’intero mercato finanziario ribollirà di nuovo, e il mercato delle criptovalute ribolle ancora di più, quindi il prossimo anno è un anno di opportunità.</p>
<p>Secondo i dati della piattaforma di analisi Glassnode, il profitto netto realizzato bloccato dagli investitori di Bitcoin in dollari statunitensi ha raggiunto i 324 milioni di dollari al giorno, che è ancora di un ordine di grandezza inferiore rispetto al picco sperimentato nel successivo mercato rialzista del 2021, quando il picco ha superato i 3 miliardi di dollari al giorno.</p>
<p>Questo indica che le attuali performance del Bitcoin rientrano principalmente nell’ambito di un mercato rialzista precoce, piuttosto che in un mercato rialzista successivo. Quindi, tutti devono apprezzare i divari nel mercato rialzista precoce, essere ben preparati e accogliere insieme l’esplosione del mercato rialzista.</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 sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>