Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIHN1cGVyYXRvIGkgNDAuMDAwIGRvbGxhcmksIHRvcm5hbmRvIGFsIGRlY2ltbyBhc3NldCBwacO5IGdyYW5kZSBhbCBtb25kbyBwZXIgY2FwaXRhbGl6emF6aW9uZSBkaSBtZXJjYXRvOyBMJ2luY2lkZW50ZSBkaSBzaWN1cmV6emEgYSBub3ZlbWJyZSBoYSBjYXVzYXRvIHVuYSBwZXJkaXRhIHR

2023-12-04, 03:55

<p><img src="https://gimg2.gateimg.com/image/article/17016722631_2.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20Bitcoin20supera20i204000020dollari20e20questa20settimana20verranno20sbloccati20HFT20e20altri20token590775"><a name="Riepilogo giornaliero delle criptovalute: Bitcoin supera i 40.000 dollari e questa settimana verranno sbloccati HFT e altri token" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> supera i 40.000 dollari e questa settimana verranno sbloccati HFT e altri token</h2><p>Il Maggiore Jason Lowery della US Space Force ha proposto una prospettiva innovativa su <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a>, estendendo la sua importanza ben oltre il settore finanziario ai campi della difesa e della cybersecurity. In una dettagliata lettera al Comitato per l’Innovazione del Dipartimento della Difesa degli Stati Uniti (DoD), Lowery ritiene che Bitcoin e protocolli simili di Proof of Work (PoW) abbiano un’importanza strategica significativa e sollecita il governo a condurre ulteriori ricerche approfondite sulle loro potenziali applicazioni.</p>
<p>Lowery ritiene che Bitcoin e le sue tecnologie sottostanti possano fungere da strumenti contemporanei per le “strategie di compensazione” (strategie militari che sfruttano i progressi tecnologici per bilanciare gli avversari), potenzialmente ridefinendo il panorama della guerra cibernetica e della difesa. Il governo sta approfondendo le loro possibili applicazioni.</p>
<p>Lowery descrive il Bitcoin come un pionieristico “macro chip”, un concetto che trasforma la rete elettrica globale in un gigantesco computer ad elevato consumo di risorse. Egli ritiene che questo approccio innovativo introduce costi fisici nel campo digitale e offre un nuovo modo per proteggere grandi quantità di dati su Internet.</p>
<p>Influenzato da una vasta gamma di notizie e aspettative di mercato, l’ultimo trend di mercato mostra che il prezzo di Bitcoin ha superato i 40.000 dollari, con un aumento massimo di 40.250 dollari. Il prezzo attuale è di 40.058,85 dollari, con un aumento del 1,45% nelle ultime 24 ore. Il prezzo di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ha recentemente superato i $2.200, raggiungendo un massimo di $2.217,27. Il prezzo attuale è segnalato a $2.195,41, con un aumento del 1,45% nelle ultime 24 ore.</p>
<p>Secondo gli ultimi dati di 8marketcap, il valore di mercato del Bitcoin è aumentato del 1,57% nelle ultime 24 ore a $784,11 miliardi, superando Berkshire Hathaway di Buffett ($777,3 miliardi) e Tesla ($759,22 miliardi) per diventare il decimo più grande attivo al mondo in termini di valore di mercato.</p>
<p>I dati di Coinglass mostrano che nelle ultime 24 ore, il mercato delle criptovalute ha visto un totale di 51829 persone vendere contratti per un valore di $108 milioni sull’intera rete. Tra questi, sono stati venduti diversi ordini per un valore di $40.9338 milioni e ordini short per $66.9936 milioni. Per valuta, BTC ha una liquidazione di circa $29.2782 milioni, che costituisce la percentuale più alta. ETH ha una liquidazione di circa $13.6547 milioni, ORDI ha una liquidazione di circa $8.1314 milioni, SOL ha una liquidazione di circa $5.1901 milioni e USTC ha una liquidazione di circa $4.2576 milioni.</p>
<p>In termini di fluttuazioni dei dati, secondo il monitoraggio dell’utente di Twitter Ai Yi, un totale di quattro indirizzi hanno acquistato 7,7 milioni di BIGTIME del valore di 1,61 milioni di dollari statunitensi negli ultimi sette giorni. L’indirizzo che inizia con 0x8D7 ha già ottenuto un profitto oggi pomeriggio, con un guadagno di 380.000 dollari statunitensi; I restanti tre indirizzi non sono ancora stati venduti.</p>
<p>Il 27 novembre, il team del progetto Bigtime ha firmato indirizzi multipli e ha trasferito 20 milioni di BIGTIME ai market maker per ampliare la loro scala di market making. Attualmente, nessuno dei tre market maker ha trasferito/venduto questi token, con Amber Group che ne detiene 5 milioni, GSR Markets che ne detiene 12,5 milioni e FBG Capital che ne detiene 2,5 milioni.</p>
<p>Secondo il rapporto sulla sicurezza di novembre pubblicato da SlowMist, nel novembre 2023 si sono verificati un totale di 47 incidenti di vulnerabilità della sicurezza nel campo della blockchain, con una perdita cumulativa di circa 349 milioni di dollari USA. Le perdite totali causate dagli incidenti di Poloniex, HTX e Heco Bridge hanno raggiunto i 243 milioni di dollari USA, pari a circa il 69% delle perdite totali dovute agli incidenti di sicurezza di questo mese.</p>
<p>C’erano un totale di 24 incidenti di Rug Pull, che rappresentano il 51% del numero totale degli incidenti di sicurezza. Gli utenti dovrebbero comprendere appieno lo sfondo e il team del progetto prima di partecipare e scegliere attentamente gli investimenti. Ci sono stati due attacchi di liquidità, che hanno causato perdite di circa $54.99 milioni.</p>
<p>Inoltre, questo mese si sono verificati tre incidenti principali correlati a vulnerabilità dei servizi di terze parti, e il progetto dovrebbe collaborare con aziende di sicurezza specializzate per condurre un’audit completo di questi servizi esterni.</p>
<p>Secondo i dati di Token Unlocks, questa settimana HFT e altri token esperimenteranno uno sblocco unico e massiccio, con un valore totale di rilascio di circa $9 milioni. Tra di essi:</p>
<p>Alle 0:00 (UTC) del 5 dicembre, Liquid sblocca 637000 LQTY (circa 1,04 milioni di dollari), pari al 0,7% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 5 dicembre, Galxe sbloccherà 2,03 milioni di GALs (circa $3,12 milioni), corrispondenti al 2,26% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 7 dicembre, Hashflow sbloccherà 13,62 milioni di HFT (circa $4,4 milioni), corrispondenti al 5,57% dell’offerta circolante.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi47186"><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-BTC374783"><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/1701672306BTC.png" alt=""><br>Il trend mensile è salito per tre mesi consecutivi e ci si aspetta un volume di trading rialzista continuo. La strategia per questo periodo è attendere una rottura sopra i $37.980, con i prossimi obiettivi a $40.495 e $42.015. Si noti che il breve termine è relativamente alto; si prevede che l’obiettivo rialzista a lungo termine raggiunga $120.400 e $128.350, con un possibile ritracciamento nel primo trimestre dell’anno prossimo.</p>
<h3 id="h3-ETH120671"><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/1701672325ETH.png" alt=""><br>Questa settimana ci sono stati quattro tentativi riusciti di rompere il livello di resistenza a $2,135. Il volume consistente e i ripetuti movimenti verso l’alto indicano un forte momentum rialzista. L’attuale breakout si prevede che raggiunga l’obiettivo di $2,381 e gli obiettivi a lungo termine sono $7,840, $10,645 e $12,383.</p>
<h3 id="h3-GAL936812"><a name="GAL" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GAL</h3><p><img src="https://gimg2.gateimg.com/image/article/1701672344GAL.png" alt=""><br>Le posizioni a breve termine avviate la settimana scorsa hanno raggiunto l’obiettivo a $1.7011, con supporto a $1.5002. Se il breve termine rimane stabile, il prezzo potrebbe salire a $2.2958. Gli obiettivi a lungo termine sono $4.2755 e $7.2050. Si consiglia di mantenere a lungo termine e utilizzare il triangolo ascendente per il profitto.</p>
<h2 id="h2-Macro20Il20mercato2020completamente20quotato20e20i20tassi20di20interesse20verranno20abbassati20lanno20prossimo20Concentrati20sullarrivo20delle20attivit20non20agricole20questo20venerd253743"><a name="Macro: Il mercato è completamente quotato e i tassi di interesse verranno abbassati l’anno prossimo; Concentrati sull’arrivo delle attività non agricole questo venerdì" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il mercato è completamente quotato e i tassi di interesse verranno abbassati l’anno prossimo; Concentrati sull’arrivo delle attività non agricole questo venerdì</h2><p>La scorsa settimana, dopo che un membro falco della Federal Reserve ha fatto rare “osservazioni accomodanti”, le aspettative del mercato per il taglio dei tassi di interesse della Fed sono esplose.</p>
<p>Nonostante molti funzionari e il presidente della Federal Reserve Powell abbiano cercato di regolare le aspettative di mercato sui tagli dei tassi d’interesse della Fed, il mercato sembra avere solo due parole nei loro occhi - “tagli dei tassi d’interesse”.</p>
<p>Dopo il discorso di Powell di venerdì scorso, l’oro è salito brevemente a $ 2.070 l’oncia, stabilendo un nuovo massimo da maggio. L’indice S&amp;P 500 ha raggiunto un nuovo massimo quest’anno, con il Dow che ha toccato un nuovo massimo per l’anno e ha stabilito un record per i guadagni settimanali consecutivi più lunghi dalla fine del 2021.</p>
<p>Per quanto riguarda i prezzi del petrolio, nonostante l’OPEC+ abbia annunciato tagli alla produzione come previsto, il mercato non ci ha creduto e ha ritenuto che i cosiddetti tagli volontari alla produzione annunciati dall’OPEC+ fossero solo ‘parole vuote’, causando un significativo calo dei prezzi del petrolio.</p>
<p>Nelle ultime cinque settimane ci sono stati cambiamenti significativi nelle dinamiche di mercato. Una serie di eventi, tra cui il rapporto sui salari non agricoli negli Stati Uniti e l’indebolimento dei dati sull’IPC, nonché il cambiamento chiave da parte del direttore della Federal Reserve Waller, hanno indotto il mercato a considerare che, se l’inflazione continua a diminuire, la Federal Reserve potrebbe essere disposta a prendere in considerazione l’abbassamento dei tassi di interesse nella prima metà del 2024. innescando una “versione 2023 di Everything Rebound”.</p>
<p>Sebbene il presidente della Federal Reserve Powell abbia continuato a mantenere l’opzione di aumentare i tassi di interesse, le sottili differenze nelle sue parole sono state comunque scoperte dai trader per sostenere la loro convinzione che la Fed avesse posto fine ai suoi aumenti dei tassi di interesse. Il mercato azionario statunitense è salito, il dollaro USA è sceso e ha innescato una “corsa all’oro”.</p>
<p>La descrizione dell’attuale impostazione della politica di Powell ha subito cambiamenti sottili. Anche se in precedenza aveva affermato a ottobre che i tassi di interesse erano “non troppo stretti”, ora afferma che i tassi di interesse sono “entrati in un intervallo restrittivo”.</p>
<p>Powell ha aggiunto: “il pieno impatto della nostra politica restrittiva potrebbe non essere ancora stato avvertito.” Powell ha aggiunto che, dato il miglior equilibrio tra non fare abbastanza e il rischio di un eccessivo restrizione, il comitato ha agito “prudentemente” su questo punto.</p>
<p>Ovviamente, come pilastro della Federal Reserve, Powell doveva mantenere l’opzione di aumentare i tassi di interesse. Ha detto che se il momento è opportuno, la Federal Reserve è pronta a stringere ulteriormente la politica, ma il mercato non è molto recettivo, proprio come gli altri funzionari della Federal Reserve che si alternano questa settimana. I trader credono solo alle “osservazioni sui tagli dei tassi” del direttore di linea dura della Federal Reserve, Waller, e ignorano gli avvertimenti degli altri funzionari della Federal Reserve che potrebbero esserci ulteriori aumenti dei tassi in caso di inflazione imprevista.</p>
<p>Il Governatore della Federal Reserve Waller ha anche dichiarato pubblicamente la scorsa settimana che se l’inflazione continuerà a diminuire nei prossimi mesi, potrebbe considerare di abbassare i tassi di interesse, alimentando così le speculazioni di mercato. Le osservazioni di Waller, soprattutto considerando la sua precedente posizione falconiana, hanno attirato molto l’attenzione del mercato e aumentato le speculazioni su possibili tagli dei tassi di interesse.</p>
<p>Pertanto, il mercato ha completamente valutato che la Federal Reserve ridurrà i tassi di interesse di 25 punti base a maggio dell’anno prossimo, e ha aumentato le aspettative per il taglio dei tassi della Fed l’anno prossimo da 90 punti base a circa 115 punti base.</p>
<p>A causa dell’aumento delle scommesse sul fatto che la Federal Reserve abbasserà significativamente i tassi di interesse l’anno prossimo, il dollaro statunitense è stato recentemente influenzato. E questa settimana, poiché i funzionari della Federal Reserve entrano nel consueto “periodo di silenzio,” gli investitori potrebbero spostare la loro attenzione sui dati economici.</p>
<p>Martedì verranno annunciati gli indici PMI non manifatturieri di novembre ISM e le opportunità di lavoro JOLTS di ottobre, seguiti da mercoledì. La relazione ADP di novembre (piccolo salario agricolo non agricolo) potrebbe essere attentamente scrutinata dal mercato prima dell’evento principale della settimana: il rapporto sugli stipendi non agricoli di novembre.</p>
<p>Si prevede che la relazione che sarà pubblicata venerdì mostri un tasso di disoccupazione stabile del 3,9%, con una crescita degli occupati non agricoli da 150.000 a ottobre a 175.000 a novembre.</p>
<p>Attualmente, una leggera accelerazione del tasso di disoccupazione del 3,9% e della massa salariale non agricola non è probabile che scuota le aspettative di mercato per la Federal Reserve di tagliare i tassi di interesse diverse volte l’anno prossimo. A meno che la crescita dei salari non accelera di nuovo, il numero di massa salariale non agricola supera significativamente le aspettative.</p>
<p>Ciò potrebbe suscitare preoccupazioni tra alcuni che l’inflazione potrebbe riprendersi nei prossimi mesi, spingendo la Federal Reserve a mantenere tassi di interesse elevati per un periodo più lungo di quanto attualmente previsto.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttore:Gioia 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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>