Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGhhIHN1cGVyYXRvIGlsIHN1byBtYXNzaW1vIHN0b3JpY28sIGkgcmlzdWx0YXRpIGRlbGxlIGVsZXppb25pIHByZXNpZGVuemlhbGkgZGVnbGkgU3RhdGkgVW5pdGkgc2FyYW5ubyByZXNpIG5vdGkgb2dnaSBhIG1lenpvZ2lvcm5v

2024-11-06, 04:52

<p><img src="https://gimg2.gateimg.com/image/article/173086857911.06.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20gli20ETF20di20BTC20hanno20registrato20un20altro20deflusso20di20oltre2010020milioni20i20risultati20delle20elezioni20presidenziali20degli20Stati20Uniti20saranno20annunciati20oggi20a20mezzogiorno676375"><a name="Riepilogo giornaliero delle criptovalute: gli ETF di BTC hanno registrato un altro deflusso di oltre $100 milioni, i risultati delle elezioni presidenziali degli Stati Uniti saranno annunciati oggi a mezzogiorno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: gli ETF di BTC hanno registrato un altro deflusso di oltre $100 milioni, i risultati delle elezioni presidenziali degli Stati Uniti saranno annunciati oggi a mezzogiorno</h2><p>Secondo i dati degli investitori di Farside, il punto degli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Gli ETF hanno registrato un deflusso netto di 117,27 milioni di dollari ieri, segnando due giorni consecutivi di deflussi netti. Il deflusso di IBIT di BlackRock è stato di 44 milioni di dollari e il deflusso di FBTC di Fidelity è stato di 68 milioni di dollari.</p>
<p>Ieri, gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF sullo spot hanno registrato un deflusso di 74 milioni di dollari, di cui 31,5 milioni da Fidelity FETH e 31,9 milioni da Grayscale ETHE.</p>
<p><strong>Citigroup: La scommessa sul fatto che la Fed eviti tagli ai tassi di interesse a dicembre è attraente</strong></p>
<p>L’analista di Citigroup, Jabaz Matai, ha affermato che in base alle attuali probabilità di mercato, è interessante scommettere che la Federal Reserve non abbasserà nuovamente i tassi di interesse a dicembre.</p>
<p>Il mercato generalmente si aspetta che la Federal Reserve tagli i tassi di interesse di 25 punti base questa settimana, ma dato i recenti dati economici positivi, questo potrebbe essere l’ultimo taglio dei tassi della Fed dell’anno. Il suo ultimo rapporto suggerisce di effettuare una transazione di swap, in cui i trader accettano di pagare un tasso di interesse annuale fisso del 4,404% e ricevere interessi che fluttuano con il tasso target della Federal Reserve. Se la Federal Reserve non taglia i tassi di interesse a dicembre e li mantiene tra il 4,5% e il 4,75% entro la fine dell’anno, questa transazione genererà rendimenti.</p>
<p><strong>La moneta Meme è salita nel contesto delle elezioni negli Stati Uniti, DMAGA è aumentato di oltre il 163% in 24 ore.</strong></p>
<p>Secondo il monitoraggio di GMGN, il concetto di Meme coin nelle elezioni presidenziali statunitensi è aumentato, tra cui:</p>
<p>TRUMP è salito del 16% in 24 ore, temporaneamente a $4,06;</p>
<p>PAC è salito oltre il 113% in 24 ore, temporaneamente a $0.004;</p>
<p>MAGA è aumentato di oltre il 19% in 24 ore, temporaneamente a $0.0001952;</p>
<p>DOGE è salito di oltre il 11% in 24 ore, temporaneamente a $0.18065;</p>
<p>PEOPLE è aumentato dell’14% in 24 ore, temporaneamente a $0.06831;</p>
<p>DMAGA è aumentato di oltre il 163% in 24 ore, temporaneamente a $0.01872;</p>
<p>KAMA è sceso leggermente del 6,7% in 24 ore, temporaneamente a $0,01068.</p>
<p><strong>Se <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> supera un nuovo massimo, la forza di liquidazione vuota accumulata del CEX mainstream raggiungerà i 215 milioni</strong></p>
<p>Secondo i dati di Coinglass, se <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> supera un massimo storico, la forza di liquidazione cumulativa degli ordini brevi di mainstream CEX raggiungerà i 215 milioni. Al contrario, se Bitcoin scende al di sotto di $68,000, la forza di liquidazione cumulativa degli ordini mainstream CEX raggiungerà i 484 milioni.</p>
<p>Il grafico di liquidazione mostra in che misura il prezzo target sarà influenzato quando raggiunge una determinata posizione. Una colonna di liquidazione più alta indica che il prezzo avrà una reazione più forte a causa dell’onda di liquidità una volta arrivata.</p>
<h2 id="h2-Tendenze20di20mercato20GOAT2020salito20bruscamente20avvicinandosi20ai20massimi20precedenti20DOGE20ha20guidato20la20crescita20generale20delle20monete20meme622144"><a name="Tendenze di mercato: GOAT è salito bruscamente, avvicinandosi ai massimi precedenti, DOGE ha guidato la crescita generale delle monete meme" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: GOAT è salito bruscamente, avvicinandosi ai massimi precedenti, DOGE ha guidato la crescita generale delle monete meme</h2><h3 id="h3-Punti20Caldi20di20Mercato310869"><a name="Punti Caldi di Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi di Mercato</h3><p>GOAT ha registrato un aumento del 40% in 24 ore, ora quotato a $0.68, con un valore di mercato circolante di $600 milioni. GOAT ha iniziato a riprendersi dopo aver subito un declino all’inizio del mese. Come token leader nel concetto di AI+meme, il futuro mercato di GOAT è degno di essere atteso con interesse;</p>
<p>I concetti di DOGE, PEOPLE, MASK e altri concetti del concetto di Musk sono aumentati rapidamente, e i fondi di mercato stanno puntando in anticipo sulle elezioni di Trump. Come uno dei più grandi sostenitori di Trump, Musk ha annunciato che lancerà il D.O.G.E (Dipartimento per l’Efficienza del Governo) dopo le elezioni di Trump, e i token concettuali correlati stanno venendo esaltati;</p>
<p>DOGE, come leader veterano degli animali meme, ha una capitalizzazione di mercato di oltre 26 miliardi di dollari e attualmente si posiziona all’ottavo posto per valore di mercato; BILLY, PEPE, WIF, MICHI e altri settori nel settore Meme sono generalmente in crescita. Il settore Meme è completamente circolato con una bassa capitalizzazione di mercato e, rispetto alle monete VC a bassa circolazione e alta capitalizzazione di mercato, le monete Meme sono più favorite dai fondi di mercato.</p>
<h3 id="h3-Mainstream20Coins612113"><a name="Mainstream Coins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Coins</h3><p>Il BTC ha superato un massimo storico e ha toccato brevemente i $75.000. L’ETF BTC non ha ripreso gli afflussi di capitale positivi e l’attuale aumento potrebbe essere solo dovuto alla scommessa anticipata del mercato sull’elezione di Trump. Una situazione di mercato più chiara deve ancora attendere la decisione sui tassi d’interesse della Federal Reserve di venerdì;</p>
<p>ETH è salito leggermente ma non ha ricevuto un supporto finanziario significativo e la pressione venditrice da Grayscale ETHE impiegherà diversi mesi per essere assorbita;</p>
<p>Le altcoin stanno generalmente salendo, con il settore dei meme che mostra una forza complessiva, e il settore dell’IA mostra anche un trend collettivo al rialzo.</p>
<h2 id="h2-Notizie20macro20le20azioni20statunitensi20sono20aumentate20collettivamente20lappetito20per20il20rischio2020aumentato20il20giorno20delle20elezioni20negli20Stati20Uniti82150"><a name="Notizie macro: le azioni statunitensi sono aumentate collettivamente, l’appetito per il rischio è aumentato il giorno delle elezioni negli Stati Uniti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie macro: le azioni statunitensi sono aumentate collettivamente, l’appetito per il rischio è aumentato il giorno delle elezioni negli Stati Uniti</h2><p>I tre principali indici azionari statunitensi sono saliti complessivamente di oltre l’1%, con le azioni tecnologiche, tra cui Nvidia e Tesla, che hanno registrato guadagni significativi. Il rendimento del titolo di Stato decennale di riferimento è del 4,43%, mentre il rendimento del titolo di Stato a 2 anni, che è il più sensibile al tasso di politica della Federal Reserve, è del 4,24%.</p>
<p>Gli strategisti di Goldman Sachs ritengono che la probabilità di un mercato ribassista nel mercato azionario statunitense nei prossimi 12 mesi sia bassa, poiché un’economia solida continuerà a sostenere il mercato azionario. Stimano che, anche considerando i rischi legati alle elezioni, la probabilità che il mercato azionario statunitense scenda di oltre il 20% (ossia entri in un mercato ribassista tecnico) sia solo dell’18%. Il rapporto di Goldman Sachs sottolinea che finché la crescita economica è robusta, il mercato azionario dovrebbe essere in grado di assorbire l’aumento dei rendimenti obbligazionari. Tuttavia, Goldman Sachs avverte che potrebbe esserci volatilità di mercato dopo le elezioni.</p>
<p>Secondo i sondaggi d’opinione pubblica, Trump e Harris sono alla pari nelle elezioni presidenziali degli Stati Uniti, e c’è un’alta possibilità di un esito controverso. L’incertezza delle elezioni ha scatenato la domanda di rifugi sicuri e, unita alle aspettative di un taglio dei tassi d’interesse della Federal Reserve, si prevede un miglioramento dei prezzi dell’oro. Il prezzo dell’oro spot è aumentato di quasi lo 0,5% sul mercato e ha superato i 2.750 dollari.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Glassa</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. Tutti gli investimenti comportano rischi intrinseci; la decisione oculata è essenziale.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'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>