Tm90aXppZSBxdW90aWRpYW5lIHwgTGUgaXN0aXR1emlvbmkgcHJldmVkb25vIDYgZ3JhbmRpIHRlbmRlbnplIG5lbCBjcmlwdG8gbmVsIDIwMjQ7IEJUQyBzYWxpcsOgIGEgJDE2MC4wMDA/IFNPTCBoYSBzdXBlcmF0byBYUlAgZGl2ZW50YW5kbyBsYSBxdWludGEgY3JpcHRvIHBpw7kgZ3JhbmRlIHBlciBjYXBpdGFsaXp6YXppb25lIGR

2023-12-21, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/17031393911_15.png" alt=""><a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">criptovaluta Bitcoin Cash</a><br>Mercoledì, secondo The Block, la Corte d’Appello degli Stati Uniti ha definitivamente autorizzato il sequestro formale di 69370 <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e altre criptovalute correlate al mercato dark web di Silk Road. La sentenza è stata emessa per la prima volta ad agosto, ma secondo un documento della Corte d’Appello degli Stati Uniti per il Nono Circuito, entrerà ora in vigore. I documenti presentati mercoledì elencavano Ross Ulbricht, il fondatore di Silk Road, come imputato, e due ricorrenti e il governo degli Stati Uniti come querelanti.</p>
<p>Paul Veradettakit, partner di Pantera Capital, ha pubblicato sei previsioni importanti per l’industria delle criptovalute nel 2024, tra cui:</p>
<p>1.Il revival di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e DeFi Summer 2.0;<br>2.Esperienze sociali basate su token per nuovi casi d’uso consumer;<br>3.Aumento dei ponti TradFi DeFi come stablecoin e asset mirror;<br>4.L’integrazione di blockchain modulare e zero-knowledge proof;<br>5.Vengono lanciate applicazioni più intensive in termini di calcolo, come AI e DePIN, sulla catena;<br>6.L’integrazione dell’ecosistema di catene pubbliche e il modello di “radiazione centrale” della catena di applicazioni.</p>
<p>I dati mostrano che <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ha sostituito <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> come la quinta criptovaluta per valore di mercato, con un valore di mercato di $35,1 miliardi, raggiungendo un nuovo massimo di 20 mesi. Questa settimana, trainata dall’aumento dei prezzi degli asset e dai continui afflussi di protocolli DeFi, la Total Value Locked (TVL) di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ha superato per la prima volta il miliardo di dollari dall’incidente di FTX lo scorso novembre.</p>
<p>Il volume degli scambi di DEX su Solana è aumentato. Il 15 dicembre, il volume delle transazioni di Orca ha raggiunto 746 milioni di dollari, superando i 100 milioni solo prima di novembre. La maggior parte dell’aumento delle attività può essere attribuita ai token MEME come Bonk, che attualmente hanno un valore di mercato superiore a 1,2 miliardi di dollari. Il prezzo di negoziazione attuale di SOL è di 83,58 dollari, con un aumento del 12,14% nelle ultime 24 ore.</p>
<p>Precedentemente, è stato segnalato che il volume di trading giornaliero del DEX ecologico di Solana ha superato 1,2 miliardi di dollari, segnando la seconda volta nella storia in cui ha superato <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>; In seguito, è stato riferito che il volume di trading di SOL su Upbit è stato superiore al volume di trading di ETH per 55 giorni consecutivi.</p>
<p>Nelle ultime settimane, il 95% delle attività di trading sulla catena EVM è stato generato attraverso iscrizioni.</p>
<p>Etherscan ha twittato che dal novembre, sono state create frequentemente iscrizioni sulla catena EVM, portando a un significativo aumento del volume di trading giornaliero, a tariffe di gas in aumento e a tempi di elaborazione delle transazioni più lunghi. In certo senso, il fenomeno delle iscrizioni può essere visto come un buon test di stress per i fornitori di blockchain e infrastrutture per valutare le loro limitazioni.</p>
<p>Man mano che il mercato migliora gradualmente, anche le istituzioni corrono per predire il mercato. Matrixport ha rilasciato l’ultimo rapporto affermando che il tasso di inflazione degli Stati Uniti dovrebbe scendere al 2% entro il 2024. Si prevede che l’economia macro supporti il prezzo di Bitcoin raggiungendo un livello più alto nel 2024. I minatori di Bitcoin spesso limitano l’offerta di nuovi Bitcoin prima e dopo il ciclo di halving, e Bitcoin raggiungerà un nuovo massimo storico sei mesi dopo l’halving (previsto per essere dimezzato nell’aprile dell’anno prossimo).</p>
<p>Il tasso di interesse di finanziamento di Bitcoin rimane elevato, il che indica che i trader si aspettano che i prezzi aumentino, e anche se la volatilità di SP500 è scesa ai minimi degli ultimi anni, la volatilità implicita rimane alta. Pertanto, è previsto che i tassi di finanziamento diminuiranno durante le vacanze di Natale, ma la volatilità potrebbe comunque aumentare poiché i trader si proteggono dalle potenziali approvazioni degli ETF Bitcoin spot.</p>
<p>Secondo l’analisi del rapporto, dal 8 dicembre, il Bitcoin si trova in un intervallo di consolidamento laterale. Tuttavia, a causa dell’approvazione prevista degli ETF spot di Bitcoin all’inizio di gennaio 2024, ci si aspetta che il livello di supporto inferiore in questo intervallo ($40.000) rimanga invariato. Allo stesso tempo, il rapporto rimane cauto su se il Bitcoin possa superare i livelli più alti durante il Natale.</p>
<p>Da un punto di vista storico, Bitcoin è salito del 3% dal 24 dicembre al 31 dicembre, ma il tasso di rendimento è stato influenzato dai forti rendimenti di Bitcoin nei suoi primi anni, mentre il prezzo di Bitcoin è stato più basso per quattro anni negli ultimi cinque anni. Ciò significa che potremmo aver già visto il punto più alto di quest’anno e i prezzi potrebbero continuare a consolidarsi fino alla fine dell’anno.</p>
<p>Il valore di mercato del Bitcoin è aumentato da $320 miliardi a $827 miliardi, e la ricchezza dei detentori di Bitcoin è aumentata di circa $500 miliardi. Il 31 ottobre 2017, quando il CME Group ha annunciato il lancio dei future Bitcoin del quarto trimestre, i future Bitcoin del CBOE sono stati quotati il 10 dicembre e il CME il 17 dicembre. Dal suo annuncio al lancio, il Bitcoin è salito del +212%. Quando gli ETF Bitcoin spot saranno approvati, potrebbero verificarsi situazioni simili. Le date di approvazione più probabili sono l’8, il 9 e il 10 gennaio.</p>
<p>Considerando gli incontri frequenti tra la SEC, in particolare BlackRock, le aspettative di approvazione degli ETF di Bitcoin sul mercato spot a gennaio sono aumentate. Casualmente, dal 8 dicembre, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> La velocità di coniazione della stablecoin di ’ si è ridotta - indicando che i fondi istituzionali che passano dalla valuta legale alla criptovaluta potrebbero essere in attesa di una nuova domanda all’inizio di gennaio.</p>
<p>Nel report si legge anche che il TVL, che all’inizio del 2023 era di 38 miliardi di dollari, ora è salito a 51 miliardi di dollari, il livello più alto prima del crollo di FTX. Con le promesse che diventano una proposta di valore chiave per Ethereum, il TVL di Lido è aumentato in modo significativo. Il TVL di Lido è passato da 6 miliardi di dollari a 20 miliardi di dollari. Tuttavia, nel complesso, la performance della DeFi nel 2023 è stata deludente. La transazione annuale di quest’anno deve essere Grayscale Bitcoin Trust (GBTC), poiché il suo sconto è stato ridotto dal -47% a solo -8%. Sebbene i prezzi di Bitcoin siano aumentati del +154%, GBTC è aumentato del +326%.</p>
<p>Il 21 dicembre, gli analisti di CryptoQuant hanno anche dichiarato in un rapporto che la prevista domanda di Bitcoin da parte di diversi ETF statunitensi, l’imminente halving e la crescita del mercato azionario più ampio in un contesto di tagli dei tassi di interesse potrebbero spingere Bitcoin a un massimo di $160.000. Nel frattempo, gli analisti dicono che un mercato rialzista potrebbe iniziare nel 2024.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi511855"><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-BTC414194"><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/1703139637BTC.png" alt=""><br>Il grafico 4-ore ha toccato il livello di supporto a $40.280 e si è stabilizzato, mostrando un trend rialzista. A breve termine, si sta formando un modello a forma di W, che tenta di sfondare la resistenza. Prestare attenzione alla convergenza della struttura a medio termine ai livelli più alti. Utilizza il canale rialzista generale sia per le posizioni lunghe che corte. Livelli di resistenza da tenere d’occhio: $ 45.345 e $ 47.990; Livelli di supporto da mantenere: $ 40.280 e $ 38.399.</p>
<h3 id="h3-ETH26240"><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/1703139670ETH.png" alt=""><br>Questa settimana, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> continua a oscillare sopra i $2.135. I tentativi di rompere la linea di tendenza non hanno avuto successo, portando a continui test al di sotto. Nel breve termine, è consigliabile mantenere la stabilità sopra i $2.135. I livelli di supporto al di sotto sono a $2.037 e $1.974. Tenere d’occhio la rottura della resistenza a $2.381; una rottura riuscita potrebbe portare a $2.489. Nel medio termine, osservare la tendenza discendente indicata dalla linea arancione.</p>
<h3 id="h3-TRB684004"><a name="TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB</h3><p><img src="https://gimg2.gateimg.com/image/article/1703139702TRB.png" alt=""><br>La strategia di manipolazione del mercato è evidente, con movimenti rapidi entro cinque minuti. TRB non è consigliato per il trading nel mercato dei futures a causa di frequenti cali che vanno dal 33% al 35%. Dopo un movimento a breve termine, chiudendo a $185, si consiglia di mantenere le posizioni e prevedere un ritracciamento al di sopra della linea di tendenza. Il supporto è a $108,77, e le tendenze a lungo termine rimangono rialziste con obiettivi a $231,25 e $245.</p>
<h2 id="h2-Macro20Il20mercato20azionario20statunitense20ha20interrotto20le20sue20nove20consecutive20salite20e20Huck20della20Fed20ha20dichiarato20che20la20Fed20ha20intenzione20di20ridurre20i20tassi20di20interesse20ma20non20cos20rapidamente470543"><a name="Macro: Il mercato azionario statunitense ha interrotto le sue nove consecutive salite e Huck della Fed ha dichiarato che la Fed ha intenzione di ridurre i tassi di interesse, ma non così rapidamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il mercato azionario statunitense ha interrotto le sue nove consecutive salite e Huck della Fed ha dichiarato che la Fed ha intenzione di ridurre i tassi di interesse, ma non così rapidamente</h2><p>Mercoledì, l’indice del dollaro statunitense è rimasto forte sopra il livello 102, salendo ad un massimo intraday di 102,54 e chiudendo infine in rialzo dello 0,3% a 102,44. Il rendimento dei titoli del Tesoro statunitense è diminuito, con il rendimento decennale che scende sotto il livello del 3,9% e chiude infine al 3,853%; Il rendimento dei titoli del Tesoro statunitense a due anni, che è più sensibile ai tassi di interesse politici della Federal Reserve, si è chiuso al 4,340%.</p>
<p>L’oro spot non è riuscito a stabilizzarsi sopra il livello di $2.040 ed è brevemente sceso sotto il livello di $2.030 durante il mercato statunitense, chiudendo infine in ribasso dello 0,44% a $2.031,24 per oncia; l’argento spot ha mostrato un trend altalenante, con un significativo aumento durante il mercato statunitense, seguito da un ritracciamento della maggior parte dei guadagni, chiudendo infine in rialzo dello 0,4% a $24,15 per oncia.</p>
<p>A causa di un’improvvisa aumento delle scorte di petrolio grezzo degli Stati Uniti della scorsa settimana, un aumento maggiore del previsto delle scorte di combustibile e una produzione di petrolio record, il petrolio greggio internazionale ha subito un ritracciamento. Il petrolio greggio WTI ha ripreso tutti i suoi guadagni durante la sessione degli Stati Uniti ed è sceso, chiudendo alla fine in ribasso dello 0,53% a $73,74 al barile; il petrolio greggio Brent ha brevemente toccato i $80 nella sessione di trading, ma non è riuscito a stabilizzarsi e ha chiuso infine in ribasso dello 0,24% a $79,11 al barile.</p>
<p>I tre principali indici azionari statunitensi hanno continuato a diminuire negli scambi tardi, con il Dow Jones Industrial Average che ha chiuso in ribasso dello 1,27% e il Nasdaq che ha chiuso in ribasso dell’1,5%. Tutti e nove i giorni consecutivi di guadagni sono stati interrotti, e l’indice S&amp;P 500 ha chiuso in ribasso dell’1,47%, segnando il più grande calo giornaliero da quasi tre mesi.</p>
<p>Funzionari della Fed hanno nuovamente rilasciato dichiarazioni. Mercoledì, il presidente della Fed di Philadelphia, Huck, ha affermato che la Fed dovrebbe iniziare a tagliare i tassi di interesse, ma non immediatamente. Alcuni dei suoi colleghi hanno recentemente lanciato una campagna di ‘taglio dei tassi di interesse per estinguere il fuoco’, contrastando vigorosamente il taglio dei tassi di interesse ampiamente atteso dal mercato all’inizio del 2024. In contrasto, la posizione di Huck è più moderata.</p>
<p>“È importante per noi iniziare a abbassare i tassi di interesse. Non abbiamo bisogno di agire troppo rapidamente, né prenderemo provvedimenti immediati”, ha detto Huck in un’intervista radiofonica locale mercoledì.</p>
<p>Ha detto: “Manterremo i tassi di interesse al livello attuale prima di iniziare a abbassarli.”</p>
<p>I commenti di Huck sono più favorevoli al prossimo aggiustamento di politica della Fed che sarà un taglio dei tassi, piuttosto che il tipo di confutazione dei suoi colleghi nei giorni scorsi. Ha detto che sebbene i dati governativi guardino indietro, l’economia sembra rallentare più velocemente di quanto i dati mostrino.</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 riposting dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>