Tm90aXppZSBxdW90aWRpYW5lIHwgQml0Y29pbiDDqCBjcm9sbGF0byBkaSBxdWFzaSBpbCAxMCU7IGxhIFNFQyBwb3RyZWJiZSBlbWV0dGVyZSB1biBhdnZpc28gZGkgYXBwcm92YXppb25lIEVURiBnacOgIHZlbmVyZMOsOyBpbCBnb3Zlcm5vIGRlZ2xpIFN0YXRpIFVuaXRpIGRldGllbmUgYXR0dWFsbWVudGUgYWxtZW5vIDgsMyBtaWx

2024-01-04, 04:21

<p><img src="https://gimg2.gateimg.com/image/article/17043553661_5.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20Bitcoin2020improvvisamente20crollato20di20quasi20il201020la20SEC20potrebbe20emettere20un20avviso20di20approvazione20degli20ETF20gi20venerd188893"><a name="Riassunto giornaliero delle criptovalute: Bitcoin è improvvisamente crollato di quasi il 10%, la SEC potrebbe emettere un avviso di approvazione degli ETF già venerdì." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è improvvisamente crollato di quasi il 10%, la SEC potrebbe emettere un avviso di approvazione degli ETF già venerdì.</h2><p>Ieri sera, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è improvvisamente crollato, cancellando tutti i guadagni di quest’anno e andando contro la tendenza a lungo termine. È sceso del 9,2% in un momento, al di sotto dei $41.000 per moneta.</p>
<p>Il giorno prima, Bitcoin aveva superato la soglia dei 45.000$ per moneta, raggiungendo un nuovo massimo in 21 mesi. La volatilità ha colpito anche le azioni legate alle criptovalute, con il prezzo delle azioni dell’exchange di criptovalute Coinbase che è sceso del 6,7% prima del trading. “Mentre il mercato inizia a misurare il rischio di tutte le classi di asset, potremmo assistere a un’intensificazione della volatilità nel breve termine, mentre entriamo in un anno con molti punti interrogativi”, ha dichiarato mercoledì Fadi Aboualfa, responsabile della ricerca presso Copper Technologies, un depositario di criptovalute. “Ad ogni modo, abbiamo visto il mercato diminuire anche all’inizio di dicembre dello scorso anno, ma poi rimbalzare ulteriormente”.</p>
<p>Bitcoin ha appena finito di cadere qui, e Vitalik Buterin ha twittato e chiamato ENS. Il 3 gennaio, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il co-fondatore Vitalik Buterin ha pubblicato sui social media affermando che tutti i Layer 2 dovrebbero essere eseguiti su parser CCIP (non affidabili, basati su Merkel) in modo da poter registrare, aggiornare e leggere direttamente i nomi di dominio ENS su Layer 2. ENS è molto importante.</p>
<p>Secondo i dati di mercato di Gate.io, ENS ha iniziato a salire dopo il post di Vitalik, con un aumento massimo del 46,7% entro 15 minuti e un aumento del 27,04% nelle ultime 24 ore. Il prezzo attuale è di $12.9.</p>
<p>Recentemente, il mercato si sta concentrando sulle dinamiche degli ETF. La giornalista di Fox Eleanor Terrett ha pubblicato su X platform affermando che la SEC sta tenendo incontri con le principali borse (NASDAQ, CBOE, New York Stock Exchange) per confermare la revisione finale dei moduli 19b-4 presentati dagli emittenti di ETF Bitcoin spot.</p>
<p>Secondo Fox Business News, avvocati del dipartimento di trading e marketing della Securities and Exchange Commission (SEC) si sono incontrati mercoledì con funzionari delle principali borse come il New York Stock Exchange, Nasdaq e Chicago Options Exchange, dove verranno scambiati gli ETF Bitcoin spot. Secondo fonti anonime dell’azienda, questi incontri sono considerati un segnale positivo che la SEC sta per approvare alcune o tutte le domande di ETF Bitcoin spot provenienti dalle principali società di gestione del fondo e delle criptovalute.</p>
<p>La SEC richiede che l’exchange riveda e finalizzi i documenti 19b-4. Questi documenti sono presentati dall’exchange per conto dell’emittente ETF e devono essere approvati dalla SEC prima che l’ETF possa essere venduto al pubblico. Anche se la decisione finale non è ancora stata presa, gli addetti ai lavori hanno indicato che la SEC potrebbe iniziare a emettere avvisi di approvazione agli emittenti venerdì, con la negoziazione che inizia già dalla settimana prossima. Gli analisti degli ETF e gli emittenti credono ancora che la SEC prenderà una decisione favorevole il 10 gennaio o prima.</p>
<p>Secondo i dati di Polymarket, il prezzo del contratto della piattaforma per “la SEC passerà l’ETF Bitcoin prima del 15 gennaio” è di 0,89 centesimi, il che significa che i trader credono che la probabilità di approvazione sia dell’89%, rispetto al 50% dello scorso mese.</p>
<p>L’analista ETF di Bloomberg, Eric Balchunas, ha dichiarato che, sebbene lui e l’analista ETF James Seyfart credano ancora che la probabilità che gli ETF Bitcoin spot vengano approvati prima del 10 gennaio sia del 90%, non hanno alzato questa possibilità oltre quel numero.</p>
<p>Sebbene la possibilità sia piccola, il rifiuto degli ETF di Bitcoin spot questo mese è probabilmente dovuto al desiderio della SEC di avere “più tempo” anziché un rifiuto diretto. Poiché il tempo e lo sforzo investiti dalla SEC e dagli emittenti di ETF di Bitcoin significa che è improbabile che gli ETF di Bitcoin vengano completamente respinti all’ultimo minuto. Se la SEC si rifiuta, gli emittenti di fondi potrebbero seguire le orme di Grayscale e presentare cause separate contro le autorità di regolamentazione.</p>
<p>Secondo un rapporto pubblicato da Matrixport, si ritiene che tutte le attuali richieste di ETF Bitcoin non abbiano soddisfatto un requisito critico, pertanto è previsto che la SEC respinga tutte le proposte a gennaio, il che potrebbe avvenire nel secondo trimestre del 2024. Dal momento in cui i trader hanno iniziato a scommettere sull’approvazione degli ETF a settembre 2023, sono stati impiegati nel settore delle criptovalute almeno $14 miliardi in valuta fiat e leva finanziaria aggiuntivi.</p>
<p>Alcuni di questi flussi di fondi potrebbero essere correlati al rilassamento dell’ambiente macro, poiché la Federal Reserve ha adottato un approccio accomodante. Tuttavia, di questa posizione long aggiuntiva di 14 miliardi di dollari, 10 miliardi potrebbero essere correlati all’approvazione prevista degli ETF. Se la SEC rifiuta di approvare gli ETF, il mercato esperimenterà una liquidazione su larga scala, con la maggior parte delle posizioni long di 5,1 miliardi di dollari che si prevede saranno liquidate. I prezzi del Bitcoin potrebbero rapidamente diminuire del 20% e tornare nell’intervallo di 36000/38000 dollari. Tuttavia, Matrix on Target prevede che i prezzi del Bitcoin rimarranno superiori ai 42000 dollari all’inizio dell’anno entro la fine del 2024, anche nel caso in cui la SEC respinga gli ETF.</p>
<p>Adam, un ricercatore macro presso Greeks.live, ha pubblicato sulla piattaforma X, affermando: “Col passare del tempo, la probabilità che gli ETF superino questa settimana è diventata sempre più bassa e il mercato è diventato bloccato. La debolezza delle azioni minerarie di criptovaluta e la vendita di molte azioni statunitensi correlate alle criptovalute hanno anche rafforzato i dubbi di mercato. Quando il IV medio delle opzioni per la settimana è crollato al 52%, anche il IV medio delle opzioni in scadenza il 12 gennaio è sceso al di sotto del 65%, e il livello complessivo è tornato alla media di fine anno. Attualmente, le opzioni put sono relativamente economiche nel mese corrente e c’è stato un attivo acquisto di opzioni put nel trading in blocco. I dati del mercato delle opzioni mostrano che gli investitori istituzionali non sono molto ottimisti sul mercato degli ETF.”</p>
<p>Inoltre, a causa del recente rimbalzo dei prezzi del Bitcoin, il governo degli Stati Uniti attualmente detiene almeno 8,3 miliardi di dollari in Bitcoin, che valevano solo 5 miliardi di dollari meno di tre mesi fa. Tra novembre 2020 e 2022, le autorità statunitensi hanno sequestrato un totale di 207189 Bitcoin in tre azioni separate legate al mercato dark web Silk Road, all’hacker di Silk Road Jimmy Zhong e agli hacker dello scambio di criptovalute Bitfinex.</p>
<p>Nel corso degli ultimi dieci anni, il prezzo di Bitcoin è aumentato di 70 volte. Se il governo degli Stati Uniti sceglie di tenere tutti i Bitcoin sequestrati invece di venderli, deterrà ancora circa 400.000 Bitcoin (17,4 miliardi di dollari), quasi il doppio del valore attuale detenuto.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi177656"><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-BTC330974"><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/1704355653BTC.png" alt=""><br>Il mercato complessivo ha subito una forte vendita la scorsa notte e ha testato brevemente il livello di supporto di $40.750, pulendo le posizioni ad alto effetto leva. Ci si aspetta che il pullback sia guidato dal volume nel tempo. Anche se la rottura al di sotto della linea arancione di metà periodo nel breve termine segnala un trend ribassista, il fatto che sia ancora chiuso al di sopra della linea trimestrale 99MA suggerisce uno scenario di pullback e clearing sano. Si prevede un lieve rimbalzo oggi, con la struttura di medio termine che indica ancora un potenziale secondo minimo e il lato inferiore del canale ascendente. La prospettiva di lungo termine rimane bullish.</p>
<h3 id="h3-ETH675559"><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/1704355670ETH.png" alt=""><br>Dopo la significativa vendita di mercato della scorsa notte, ETH è sceso brevemente al di sotto del supporto chiave di $2.135. Oggi, si prevede una resistenza intorno al livello di $2.260. È probabile un movimento al rialzo a breve termine seguito da un altro ritracciamento. Si prevede che la struttura a medio termine continui a oscillare tra $2.135 e $2.381. Le strategie a breve termine possono prevedere di attendere una rottura per avviare posizioni long o short. La prospettiva a lungo termine rimane rialzista.</p>
<p>INJ<br><img src="https://gimg2.gateimg.com/image/article/1704355685INJ.png" alt=""><br>Dopo aver formato un modello testa-e-spalle sul grafico giornaliero, si è verificato un significativo pullback, raggiungendo precisamente il livello di ritracciamento di Fibonacci 0,382 a $29,126. L’attenzione a breve termine è sul fatto che la neckline a $34,65 tenga, mentre il panorama medio-lungo termine rimane positivo, con un obiettivo di $61,084, $97,616 e $117,48. Il trend è considerato un mercato rialzista a medio termine con un ritracciamento a breve termine, suggerendo un’attesa a lungo termine.</p>
<h2 id="h2-Macro20i20tassi20di20interesse20sono20al20loro20picco20il20Policy20Path20Chart20mostra20che20potrebbero20esserci20tre20tagli20dei20tassi20di20interesse20nel202024929376"><a name="Macro: i tassi di interesse sono al loro picco, il Policy Path Chart mostra che potrebbero esserci tre tagli dei tassi di interesse nel 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: i tassi di interesse sono al loro picco, il Policy Path Chart mostra che potrebbero esserci tre tagli dei tassi di interesse nel 2024</h2><p>Mercoledì, l’indice del dollaro statunitense è salito per il quarto giorno di contrattazione consecutivo, chiudendo infine in rialzo dello 0,227% a 102,47, raggiungendo un nuovo massimo in quasi tre settimane. Il rendimento dei titoli del Tesoro statunitense è fluttuato, con il rendimento decennale salito sopra il 4% per la prima volta dal 14 dicembre durante la sessione. Ha poi ceduto tutti i suoi guadagni durante la giornata e ha chiuso infine al 3,92%; Il rendimento dei titoli del Tesoro statunitense a due anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, ha chiuso al 4,333%.</p>
<p>Poiché le aspettative di mercato per il taglio dei tassi d’interesse della Federal Reserve non si sono rafforzate, l’oro spot è sceso per quattro giorni consecutivi, avvicinandosi al livello di 2030 durante la negoziazione e chiudendo infine in ribasso dello 0,84% a $2041,17 per oncia. L’argento spot è sceso fino al 3% durante la giornata e ha chiuso infine in ribasso del 2,69% a $22,99 per oncia.</p>
<p>A causa della completa chiusura dei campi petroliferi libici, le preoccupazioni per le carenze globali di approvvigionamento di petrolio si sono intensificate e il petrolio greggio internazionale è salito per la prima volta in cinque giorni, allontanandosi da un minimo di due settimane. Il petrolio WTI è salito del 3,64% a chiudere a $72,97 al barile; il petrolio Brent è salito del 3,2% a $78,61 al barile. I tre principali indici azionari hanno chiuso in calo, con il Dow Jones che è sceso dello 0,75%, l’indice S&amp;P 500 che è sceso dell’0,8% e il Nasdaq che è sceso dell’1,18%.</p>
<p>I verbali della riunione di politica monetaria di dicembre pubblicati dalla Federal Reserve mostrano che i funzionari della Federal Reserve ritengono che i tassi di interesse possano essere al picco di questo ciclo di restrizione della politica monetaria, ma il percorso effettivo della politica dipenderà dall’evoluzione dell’economia degli Stati Uniti nei prossimi mesi.</p>
<p>I verbali della riunione mostrano che quasi tutti gli ufficiali prevedono che, data la recente tendenza al ribasso dell’inflazione, il tasso dei fondi federali diminuirà entro la fine del 2024. Ma almeno alcuni membri hanno sottolineato che attualmente c’è un ‘grado di incertezza insolitamente alto’ e la possibilità di ulteriori aumenti dei tassi di interesse non è stata completamente esclusa.</p>
<p>Il verbale della riunione non ha fornito istruzioni specifiche riguardo il tempismo previsto per i tagli dei tassi di interesse nel 2024. Diversi membri hanno sottolineato che la situazione potrebbe evolversi fino al punto in cui l’intervallo di target per il tasso dei fondi federali deve essere mantenuto al 5,25% - 5,50% attuale per un periodo più lungo, anche più lungo di quanto attualmente prevedono.</p>
<p>Alcuni membri del Federal Open Market Committee ritengono che i dati economici mostrino che gli 11 rialzi dei tassi di interesse attuati dalla Federal Reserve dal marzo 2022 stanno avendo l’effetto atteso di rallentare la domanda dei consumatori e raffreddare il mercato del lavoro, e contribuiranno nel tempo a far tornare l’inflazione all’obiettivo del 2% della Federal Reserve.</p>
<p>Gli ufficiali della Federal Reserve hanno concordato all’unanimità nell’ultimo meeting di dicembre che il ciclo di rialzo dei tassi di interesse iniziato nel 2022 potrebbe essere terminato. È ampiamente ritenuto all’interno della Federal Reserve che l’inflazione si sia rallentata, specialmente per quanto riguarda il tasso di inflazione annualizzato a sei mesi, e che ci siano segnali che la catena di approvvigionamento stia tornando alla normalità e, con l’aumento delle persone che si uniscono al mercato del lavoro, il mercato del lavoro stia iniziando a rilassarsi.</p>
<p>I funzionari della Federal Reserve hanno dichiarato che l’aumento dei tassi di interesse oltre il 5% ha soppresso la domanda dei consumatori, riducendo così l’inflazione. Non hanno discusso su quando iniziare a ridurre i tassi di interesse. Il Grafico del Percorso della Politica mostra che la banca prevede di abbassare i tassi di interesse tre volte nel 2024.</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 riposting dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>