Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgdGFnbGlvIGRlaSB0YXNzaSBhZ2dyZXNzaXZpIGRlbGxhIEZlZCBzY2F0ZW5hIGlsIGNyb2xsbyBkZWwgbWVyY2F0bywgbGEgc3RhZ2lvbmUgZGVnbGkgQWx0Y29pbiDDqCBhbmNvcmEgaW4gYXR0ZXNhIGRlbCBjYWxvIGRlbGxhIGRvbWluYW56YSBkZWwgQlRD

2024-12-20, 03:17

<h2 id="h2-Sommario20giornaliero20BTC20ETF20registra20un20raro20grande20deflusso20mercato20ancora20nella20zona20di20avidit330349"><a name="Sommario giornaliero: BTC ETF registra un raro grande deflusso, mercato ancora nella zona di avidità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario giornaliero: BTC ETF registra un raro grande deflusso, mercato ancora nella zona di avidità</h2><p>Secondo Farside Investors, gli Stati Uniti. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Gli ETF sullo spot hanno registrato un deflusso netto di 671 milioni di dollari ieri. Tra questi, FBTC di Fidelity ha registrato un deflusso di 208 milioni di dollari, BTC di Grayscale ha registrato un deflusso di 188 milioni di dollari e i dati di BlackRock devono ancora essere aggiornati.</p>
<h3 id="h3-TheETF20spot20statunitense20su20Ethereum20ha20registrato20un20deflusso20netto20di206020milioni20di20dollari20mentre20Bitwise20ETHW20e20Grayscale20ETHE20hanno20registrato20deflussi20rispettivamente20di206820milioni20di20dollari20e2058120milioni20di20dollari20Anche20i20dati20ETHA20di20BlackRock20sono20in20sospeso801958"><a name="The’ETF spot statunitense su Ethereum ha registrato un deflusso netto di 60 milioni di dollari, mentre Bitwise ETHW e Grayscale ETHE hanno registrato deflussi rispettivamente di 6,8 milioni di dollari e 58,1 milioni di dollari. Anche i dati ETHA di BlackRock sono in sospeso." class="reference-link"></a><span class="header-link octicon octicon-link"></span>The’ETF spot statunitense su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha registrato un deflusso netto di 60 milioni di dollari, mentre Bitwise ETHW e Grayscale ETHE hanno registrato deflussi rispettivamente di 6,8 milioni di dollari e 58,1 milioni di dollari. Anche i dati ETHA di BlackRock sono in sospeso.</h3><p>L’indice crypto fear and greed scende a 74, il mercato è ancora in preda all’avidità<br>Secondo Alternative.me, il Crypto Fear and Greed Index è sceso a 74 oggi (dai 75 di ieri), indicando che sebbene l’entusiasmo del mercato si sia leggermente raffreddato, rimane in una zona di “avidità”.</p>
<p>(Nota: L’indice di Paura e Avidità va da 0 a 100 e viene calcolato in base a diversi fattori, tra cui la volatilità (25%), il volume di mercato (25%), il sentiment sui social media (15%), i sondaggi (15%), la dominanza di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sul mercato (10%) e le tendenze di Google (10%).)</p>
<h3 id="h3-Lindice20VIX20schizza20del207420segnalando20che20Bitcoin20potrebbe20aver20toccato20un20minimo20locale640241"><a name="L’indice VIX schizza del 74%, segnalando che Bitcoin potrebbe aver toccato un minimo locale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’indice VIX schizza del 74%, segnalando che Bitcoin potrebbe aver toccato un minimo locale</h3><p>Secondo CoinDesk, l’indice di volatilità CBOE (VIX) è schizzato del 74% ieri, segnando il più grande aumento in un singolo giorno dal febbraio 2018 e il secondo più alto nella storia. Questo picco è stato causato dalla riduzione dei tassi del 25bps da parte della Fed e dai commenti falchi di Jerome Powell, scatenando il panico nei mercati. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è brevemente sceso al di sotto di $100.000, mentre le azioni statunitensi sono scese di circa il 3%.</p>
<p>Storicamente, le brusche aumenti del VIX spesso segnalano che Bitcoin ha raggiunto un minimo locale. Ad esempio, dopo che il VIX è aumentato del 116% nel febbraio 2018, Bitcoin è rimbalzato da $6,891 a oltre $11,000. Allo stesso modo, nell’agosto 2024, quando il VIX è salito del 65%, Bitcoin è rimbalzato da $54,000 a $64,000.</p>
<h3 id="h3-Top20Trader20Eugene20attualmente20concentrato20su20SOL20tra20le20principali20criptovalute634774"><a name="Top Trader Eugene: attualmente concentrato su SOL tra le principali criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Top Trader Eugene: attualmente concentrato su SOL tra le principali criptovalute</h3><p>Il top trader Eugene Ng Ah Sio ha spiegato perché attualmente si sta concentrando su SOL tra le principali criptovalute:</p>
<p>“1. Su tutti i grafici (SOLBTC, SOLETH e SOLUSD), siamo a o vicino ai livelli ‘value’ sui frame temporali più alti (HTF).</p>
<ol>
<li>La valutazione attuale sotto i 200 dollari rappresenta un buon punto di ingresso per i tori oggi.</li></ol>
<p>3.Il tasso di finanziamento è diminuito ed è ora negativo, il che indica che sta avvenendo una qualche forma di copertura di contratti perpetui, poiché l’interesse aperto (OI) è cambiato poco. Ciò suggerisce che molti partecipanti al mercato stiano utilizzando SOL per coprire posizioni corte a causa di un momento debole da quando SOL ha raggiunto il picco di $260.</p>
<p>Come ha menzionato @docXBT, questi sono livelli importanti da rispettare, specialmente su quadri temporali più alti. Come toro, sono disposto a entrare a questi livelli. Tuttavia, se questi livelli non riescono a mantenere, potremmo entrare rapidamente in una zona rischiosa.</p>
<p>In precedenza, Eugene Ng Ah Sio ha scritto che ha “ribilanciato il suo portafoglio ed è ora completamente rialzista su SOL. Ha perso circa 1 milione di dollari su meme coin e ora sta cercando un’opportunità di rimbalzo.”</p>
<h2 id="h2-Analisi20di20mercato20USUAL20in20rialzo20del205020le20altcoin20in20calo20del2020960877"><a name="Analisi di mercato: USUAL in rialzo del 50%, le altcoin in calo del 20%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi di mercato: USUAL in rialzo del 50%, le altcoin in calo del 20%</h2><p><strong>Evidenze:</strong><br>-USUAL ha sfidato la tendenza e ha registrato un aumento superiore al 50%, guidando il mercato. Usual Labs è un protocollo di stablecoin e il suo prodotto stablecoin, USD0, è una stablecoin “collateralizzata” supportata da obbligazioni di debito governativo (anche conosciute come obbligazioni sovrane). Grazie all’uso di M0 come garanzia, viene chiamata “USD0”. Dall’ultimo lancio a fine agosto, l’offerta circolante di USD0 è cresciuta fino a 1,2 miliardi di dollari. Dal 19 dicembre ad oggi, l’offerta circolante di USD0 è aumentata di oltre 200 milioni di dollari. La capitalizzazione di mercato attuale di USUAL è di 600 milioni di dollari, con una valutazione completamente diluita (FDV) di 5,5 miliardi di dollari.</p>
<p>I protocolli Layer2 MOVE e SCR sono aumentati, con MOVE che guida la giornata con un aumento del 30%. MOVE attualmente ha una capitalizzazione di mercato di $1,88 miliardi, classificandosi al 60º posto nel mercato, ancora lontano dai popolari token Layer2 come ARB e OP.</p>
<p><strong>Tendenze generali:</strong><br>Il BTC è diminuito per tre giorni consecutivi, con rari grandi deflussi dagli ETF di BTC. È probabile che il mercato si consolidi a livelli più bassi nel breve termine, ma nel medio-lungo periodo, il prezzo del BTC rimane ai minimi.</p>
<p>-ETH è sceso sotto i $3.400, cadendo per quattro giorni consecutivi, pesantemente influenzato dal ribasso del mercato in generale.</p>
<p>-Le altcoin sono generalmente in calo, con la maggior parte degli altcoin che subisce perdite superiori al 20% nel corso della giornata. La stagione degli altcoin è ancora in attesa e potremmo dover aspettare un ritracciamento della dominanza del BTC prima che possa iniziare.</p>
<h2 id="h2-Notizie20Macro20Gli20indici20azionari20statunitensi20fluttuano20mentre20il20mercato20si20adatta20alla20posizione20falco20della20Fed463341"><a name="Notizie Macro: Gli indici azionari statunitensi fluttuano mentre il mercato si adatta alla posizione falco della Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie Macro: Gli indici azionari statunitensi fluttuano mentre il mercato si adatta alla posizione falco della Fed</h2><p>Gli indici azionari statunitensi hanno avuto risultati misti: l’S&amp;P 500 è sceso dello 0,09% a 5.867,08, il Dow Jones è salito dello 0,04% a 42.342,24 e il Nasdaq è sceso dello 0,10% a 19.372,77. Il rendimento del Tesoro statunitense decennale è del 4,57% e il rendimento biennale, che è il più sensibile alla politica della Fed, è del 4,32%.</p>
<p>A seguito del tasso di taglio della Fed e delle previsioni di rallentamento della flessibilità l’anno prossimo, i titoli del Tesoro statunitense a lungo termine si sono indeboliti giovedì, e la curva dei rendimenti si è appuntita al livello più alto da circa 30 mesi. Il rendimento del Tesoro a 2 anni è sceso di 6bps al 4,295%, mentre il rendimento decennale è salito di 4bps al 4,56%, fermandosi ai livelli più alti da maggio. Il rendimento a 2 anni è ora 0,26 punti percentuali al di sotto del rendimento decennale. L’accentuazione della curva dei rendimenti è attribuita alla persistenza dell’inflazione e alla resistenza economica, che rende gli investitori riluttanti a detenere titoli a lungo termine.<br>Ian Lyngen, capo della strategia dei tassi statunitensi presso BMO Capital Markets, ha osservato che “la debolezza dei titoli a lungo termine è dovuta alla posizione della Fed e alle pressioni provenienti dall’incremento dell’offerta di titoli del Tesoro. La tendenza di una curva dei rendimenti più ripida probabilmente continuerà fino al 2024.</p>
<div class="blog-details-info"><br><div>Autore:<strong> icing</strong>, Ricercatore di Gate.io<br><div>Traduttore: Sally<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; la prudenza nella presa di decisioni è fondamentale.<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, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>