Tm90aXppZSBxdW90aWRpYW5lIHwgT1JESSBoYSB2aXNzdXRvIHVuYSBkb3BwaWEgZXNwbG9zaW9uZSBkaSBsaXF1aWRhemlvbmUgbHVuZ2EgZSBjb3J0YTsgU2VndWkgbGUgdGVuZGVuemUgY3JpcHRvIGRlZ25lIGRpIG5vdGEgbmVsIDIwMjQ7IEkgZm9uZGkgc29ubyByYXBpZGFtZW50ZSBhZmZsdWl0aSBuZWkgZnV0dXJlIHN1IEV0aGV

2023-12-07, 04:05

<p><img src="https://gimg2.gateimg.com/image/article/17019301781_5.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20ORDI20ha20vissuto20una20doppia20esplosione20di20liquidazione20di20posizioni20lunghe20e20corte20Segui20le20tendenze20cripto20degne20di20nota20nel20202491706"><a name="Riassunto giornaliero delle criptovalute: ORDI ha vissuto una doppia esplosione di liquidazione di posizioni lunghe e corte; Segui le tendenze cripto degne di nota nel 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: ORDI ha vissuto una doppia esplosione di liquidazione di posizioni lunghe e corte; Segui le tendenze cripto degne di nota nel 2024</h2><p>Innanzitutto, diamo un’occhiata alla discussione molto attesa dell’incidente della “Vulnerabilità dell’iscrizione” di ieri.</p>
<p>Ieri, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Lo sviluppatore principale Luke Dashjr ha pubblicato sulla piattaforma X affermando che Inion sta sfruttando una vulnerabilità nel client principale di Bitcoin, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Core, per inviare messaggi di spam alla blockchain. Ha riconosciuto che ci sono ancora falle nel Bitcoin Core nella prossima versione V26 e si aspetta che vengano finalmente risolte prima della versione V27 dell’anno prossimo.</p>
<p>Luke Dashjr ha confermato nella risposta al commento di X che se la vulnerabilità di Bitcoin Core precedentemente divulgata viene risolta, significa che Ordinals e BRC-20 non esisteranno più e ha affermato che la “Inion Chain” potrebbe essere una soluzione fattibile.</p>
<p>Influenzato da questa notizia, il 6 dicembre ORDI ha continuato a scendere sotto i $42, con una diminuzione del 34% nelle ultime 8 ore e una diminuzione del 15,4% nelle ultime 24 ore. Secondo i dati di Coinglass, nelle ultime 12 ore, ORDI ha venduto $14,9409 milioni, seconda solo a BTC ( <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> esaurito $13.77 milioni), con ordini multipli che si sono esauriti per circa $9.286 milioni e ordini brevi che si sono esauriti per circa $5.655 milioni.</p>
<p>Secondo il monitoraggio di Lookonchain, una gigantesca balena potrebbe aver visto un tweet dello sviluppatore di Bitcoin Core, Luke Dashjr, e venduto tutti i 59.000 ORDIs (circa 3,54 milioni di dollari) prima del calo degli ORDI, guadagnando oltre 2,3 milioni di dollari. Questa persona ha ritirato 65.263 ORDIs (circa 1,3 milioni di dollari) da Binance il 22 novembre, al prezzo di 20 dollari al momento.</p>
<p>Dopo 12 ore di fermentazione dell’incidente di vulnerabilità, Luke Dashjr ha risposto a diverse domande da scettici sulla piattaforma X. Uno degli interroganti ha chiesto: “È possibile che finché un minatore non sceglie di uscire, quel minatore può ancora gestire le transazioni di iscrizione sulla blockchain? O devono i minatori raggiungere un consenso maggioritario su se scegliere di unirsi/uscire?”</p>
<p>Luke Dashjr ha risposto affermando che non è necessario eliminare tutte le iscrizioni per fornire valore a Bitcoin.</p>
<p>Le osservazioni di Luke Dashjr potrebbero riconoscere l’iscrizione per “ammorbidire” la comunità, e ORDI è aumentato brevemente di circa il 20%, con una quotazione attuale di $ 52,6. Al momento della scrittura, ORDI è rimbalzato sopra i 55 dollari ed è ora quotato a 55,28 dollari, con un ulteriore aumento di oltre il 30% nell’ultima ora.</p>
<p>Il 6 dicembre, il noto venture capitalist crypto a16z crypto ha pubblicato sulla piattaforma X condividendo tendenze degne di nota nell’industria crittografica nel 2024, tra cui l’ingresso in una nuova era di decentralizzazione; Resettare l’esperienza utente futura; La crescita dello stack tecnologico modulare; La combinazione di intelligenza artificiale e blockchain; P2E (Play to earn) diventa P+E (Play and earn); Quando l’intelligenza artificiale diventa un creatore di giochi, la crittografia fornisce garanzie; La verifica formale è diventata più concisa; NFT è diventato un asset di marca onnipresente; SNARK (argomentazione di conoscenza concisa non interattiva) è diventato mainstream.</p>
<p>Mentre il mercato si riprende, anche l’aeronautica nel mercato azionario delle criptovalute subisce pesanti perdite.</p>
<p>Secondo Decrypt, l’ultimo rapporto della società di dati finanziari S3 Partners mostra che da quando Bitcoin ha toccato un minimo di tre mesi ($25.152) l’11 settembre, il suo prezzo è aumentato del 75% fino agli attuali $43.924. Questo slancio ha portato a perdite di oltre $2,6 miliardi per i trader di criptovalute a breve termine in meno di tre mesi. Le azioni criptovalutarie, rappresentate da Coinbase e MicroStrategy, sono salite di pari passo con Bitcoin, cogliendo di sorpresa i venditori a breve.</p>
<p>Sotto il forte rimbalzo dei prezzi del Bitcoin, il prezzo delle azioni di Coinbase è aumentato del 51% nell’ultimo mese, raggiungendo $143.63; Il prezzo delle azioni di MicroStrategy, che detiene circa $6.6 miliardi in Bitcoin, è aumentato dell’82% da ottobre a $568.88.</p>
<p>Queste enormi fluttuazioni dei prezzi delle azioni hanno causato perdite per 2,656 miliardi di dollari ai trader a breve termine delle criptovalute negli ultimi tre mesi, con oltre il 50% delle perdite provenienti dalla vendita allo scoperto delle azioni di Coinbase e un altro 25% proveniente dalla vendita allo scoperto delle azioni di MicroStrategy.</p>
<p>In termini di fluttuazioni dei dati, BTC è aumentato di oltre il 60% questo trimestre, mentre ETH è aumentato solo del 35%. In un periodo più lungo, il divario di performance tra i due è ancora maggiore.</p>
<p>Alcuni analisti ritengono che ora i fondi siano <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> a un ritmo più veloce rispetto ai futures di Bitcoin, questo divario potrebbe ridursi.</p>
<p>Secondo Velo Data, nei cinque giorni scorsi, il valore in USD delle posizioni aperte del contratto futures su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> liquidato in contanti della CME è aumentato del 30%, raggiungendo i 711 milioni di dollari, superando l’aumento del 19% delle posizioni aperte del contratto futures su Bitcoin (4,9 miliardi di dollari).</p>
<p>Inoltre, secondo i dati di Reflexity Research, all’inizio di questa settimana, il tasso di premio dei futures su Ethereum rispetto ai prezzi dell’indice spot (oltre il 20%) era del 5% superiore a Bitcoin. Dopo l’ascesa iniziale di Bitcoin, le posizioni aperte nei contratti futures su Ethereum al CME hanno iniziato a aumentare. Allo stesso tempo, l’indicatore delle opzioni su Deribit mostra anche una maggiore preferenza rialzista tra gli investitori verso Ethereum.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi176346"><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-BTC310084"><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/1701930224BTC.png" alt=""><br>Questa settimana, Bitcoin (BTC) continua a stabilizzarsi intorno ai $44.000. Il volume di trading a breve termine diminuisce gradualmente questa mattina. Gli obiettivi a breve termine rimangono a $45.345 e $47.990. Gli obiettivi rialzisti a lungo termine sono fissati a $120.400 e $128.350. Si prevede un’alta volatilità questo mese, con un possibile ritracciamento nel primo trimestre dell’anno prossimo.</p>
<h3 id="h3-ETH69390"><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/1701930248ETH.png" alt=""><br>Ethereum (ETH) ha rotto con successo il livello di resistenza a $2.135 quattro volte questa settimana, ma ha subito un ritracciamento supportato dal volume a $2.230 stamattina. L’obiettivo al rialzo è fissato a $2.381, con supporto a breve termine a $2.194 e supporto a medio termine a $2.135. La prospettiva rialzista a lungo termine include obiettivi a $8.000 e $12.300.</p>
<h3 id="h3-ARKM326530"><a name="ARKM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARKM</h3><p><img src="https://gimg2.gateimg.com/image/article/1701930268ARKM.png" alt=""><br>ARKM ha sperimentato cinque candele settimanali rialziste consecutive, completando un ritracciamento medio settimanale. Il grafico giornaliero forma una grande struttura a tazza e manico, indicando un trend rialzista. Gli obiettivi a breve termine sono $0.5916 e il precedente massimo di $0.8900. Gli obiettivi a lungo termine includono $0.89, $1.25, $1.85 e $2.45, con un potenziale aumento del prezzo del 845% nell’impostazione a lungo termine.</p>
<h2 id="h2-Macro20I20dati20sulloccupazione20ADP20non20sono20come20previsto20e20latmosfera20di20mercato20per20i20tagli20dei20tassi20di20interesse2020forte538377"><a name="Macro: I dati sull’occupazione ADP non sono come previsto, e l’atmosfera di mercato per i tagli dei tassi di interesse è forte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I dati sull’occupazione ADP non sono come previsto, e l’atmosfera di mercato per i tagli dei tassi di interesse è forte</h2><p>I dati sull’occupazione ADP di novembre negli Stati Uniti hanno registrato 103.000 persone, mentre il mercato si aspettava 130.000 persone, mancando le aspettative per il quarto mese consecutivo; Gli stipendi dei lavoratori sono aumentati del 5,6%, il tasso di crescita salariale più basso da settembre 2021.</p>
<p>Influenzati dal rapporto ADP che è stato inferiore alle aspettative e che ha confermato nuovamente il indebolimento del mercato del lavoro, i rendimenti del Tesoro degli Stati Uniti continuano a diminuire, con i rendimenti del Tesoro degli Stati Uniti a 10 anni che si avvicinano al livello del 4,1%, il livello più basso dal 1° settembre, chiudendo a 4,167%; Il rendimento del Tesoro degli Stati Uniti a due anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, ha perso tutti i guadagni intraday durante il trading e alla fine ha chiuso leggermente più alto a 4,597%.</p>
<p>Poiché il mercato ha completamente considerato la prospettiva del taglio dei tassi d’interesse della Federal Reserve mentre le aspettative per le altre banche centrali continuavano ad approfondirsi, l’indice del dollaro USA si è attestato a 104 e alla fine ha chiuso in rialzo dello 0,309% a 103,95. I tre principali indici azionari statunitensi hanno aperto in rialzo e chiuso in ribasso, con il Dow Jones Industrial Average in calo dello 0,19%, l’indice S&amp;P 500 in calo dello 0,39% e il Nasdaq in calo dello 0,59%.</p>
<p>Dati i deboli rendimenti dei bond statunitensi e la stabilizzazione dell’oro spot, ha raggiunto un massimo di $2.035,71 l’oncia nel giorno e alla fine ha chiuso a +0,34% a $2.026,19 l’oncia; l’argento spot è sceso di $24 l’oncia e alla fine ha chiuso in ribasso del 0,92% a $23,9 l’oncia.</p>
<p>Il forte aumento delle scorte di benzina negli Stati Uniti ha sollevato preoccupazioni sulla domanda, con gli investitori che si chiedono se i tagli alla produzione dell’OPEC+ possano compensare l’impatto dell’eccesso di offerta da altri paesi produttori di petrolio e dalla debole domanda globale di petrolio. Il greggio internazionale è sceso per il quinto giorno di negoziazione consecutivo. Il greggio WTI è sceso sotto la soglia dei 70 dollari per la prima volta da inizio luglio, chiudendo infine in ribasso del 4% a 69,36 dollari al barile; il greggio Brent ha chiuso in ribasso del 3,5% a 74,55 dollari al barile, segnando la prima volta dall’inizio di giugno di quest’anno che è sceso al di sotto dei 75 dollari al barile.</p>
<p>Dopo che la Federal Reserve ha aumentato significativamente i tassi di interesse, il mercato del lavoro degli Stati Uniti si sta gradualmente raffreddando.</p>
<p>Tuttavia, gli economisti si aspettano generalmente che il rapporto sul non-agricolo mostri un aumento dell’occupazione a novembre, poiché circa 33000 membri in sciopero della Federazione dei Lavoratori dell’Automobile tornano al lavoro.</p>
<p>Bill Adams, Chief Economist della Commercial Bank of America a Dallas, ha dichiarato che il recente indebolimento dei dati del mercato del lavoro ha ridotto il rischio di ripresa delle pressioni inflazionistiche a causa dei problemi dei prezzi dei salari, rendendo più facile per la Federal Reserve passare a tagli dei tassi di interesse nel 2024. Aspetteremo e vedremo.</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>