Tm90aXppZSBnaW9ybmFsaWVyZSB8IEJUQyBvc2NpbGxhdG8gZSBjYWR1dG8sIGlsIG1lcmNhdG8gYXR0ZW5kZSBpIGRhdGkgQ1BJIGRpIHN0YXNlcmE=

2024-09-11, 04:02

<p><img src="https://gimg2.gateimg.com/image/article/17260271959.11.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20gli20ETF20BTC20hanno20ripreso20lingresso20netto20di20fondi20il20mercato20potrebbe20toccare20il20fondo20e20riprendersi698561"><a name="Riepilogo giornaliero delle criptovalute: gli ETF BTC hanno ripreso l’ingresso netto di fondi, il mercato potrebbe toccare il fondo e riprendersi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: gli ETF BTC hanno ripreso l’ingresso netto di fondi, il mercato potrebbe toccare il fondo e riprendersi</h2><p>Secondo i dati degli investitori di Farside, gli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’entrata di ETF sul posto è stata di 117 milioni di dollari ieri. Tra questi, l’entrata netta di Fidelity FBTC è stata di 63,2 milioni di dollari e l’entrata netta di Grayscale BTC è stata di 41,1 milioni di dollari. BlackRock IBIT non ha entrata o uscita di fondi.</p>
<p>Gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot hanno registrato un afflusso netto di 11,4 milioni di dollari ieri. Tra questi, Fidelity FETH ha registrato un afflusso netto di 7,1 milioni di dollari, mentre BlackRock ETHA ha registrato un afflusso netto di 4,3 milioni di dollari.</p>
<p><strong>K33 Rapporto di Ricerca: l’Indicatore del Tasso dei Fondi Suggerisce che il Mercato toccherà il Fondo e Rimbalzerà nelle Prossime Settimane</strong></p>
<p>K33 Research ha dichiarato in un rapporto di mercato pubblicato martedì che un indicatore affidabile suggerisce un significativo rimbalzo nelle prossime settimane e mesi. Secondo il rapporto, il tasso di finanziamento medio a 30 giorni per i contratti perpetui è sceso a livelli negativi, il che è accaduto solo sei volte dal 2018.</p>
<p>Gli analisti K33 Vetle Lunde e David Zimmerman hanno scritto: ‘In passato, quando i tassi di finanziamento mensili scendevano a valori negativi, di solito significava che il mercato aveva toccato il fondo.’ Il rapporto ha dichiarato che dopo che l’indicatore si era precedentemente trasformato in negativo, il rendimento medio nei successivi 90 giorni era del 79%, mentre il rendimento mediano nei 90 giorni successivi era del 55%.</p>
<p><strong>I trader si aspettano ancora che la Federal Reserve tagli i tassi di interesse almeno due volte in futuro</strong></p>
<p>Gli operatori del mercato delle opzioni sui tassi di interesse negli Stati Uniti stanno ancora scommettendo su almeno un massiccio taglio dei tassi da parte della Federal Reserve quest’anno, ma potrebbero non agire prima delle elezioni presidenziali degli Stati Uniti del 5 novembre. La maggior parte degli economisti si aspetta che la Federal Reserve tagli i tassi di interesse di 25 punti base a settembre e tagli i tassi altre due volte quest’anno.</p>
<p>L’attività recente delle opzioni legate ai tassi di finanziamento garantiti durante la notte indica che i trader stanno sempre più posizionandosi per un taglio dei tassi di circa 150 punti base prima della decisione della Federal Reserve sulla politica il 29 gennaio. Questo è lo stesso della situazione attuale nel mercato valutario.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato2020fluttuato20mancano20punti20caldi714506"><a name="Tendenze di mercato: il mercato è fluttuato, mancano punti caldi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato è fluttuato, mancano punti caldi</h2><h3 id="h3-Mainstream20Coins295942"><a name="Mainstream Coins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Coins</h3><p>BTC è sceso sotto i 57.000 dollari e la tendenza di mercato non è molto chiara. Il mercato sta aspettando i dati sull’indice dei prezzi al consumo di questa sera.</p>
<p>ETH non è riuscito a superare la soglia di $2.400 e è tornato a circa $2.350, con una significativa riduzione dell’ampiezza;</p>
<p>La diffusa diminuzione degli Altcoins e la mancanza di punti caldi concentrati nel mercato;</p>
<p>In termini di indicatori di dati, l’indice AHR999 è oggi 0.6, non lontano dall’intervallo di acquisto in basso; l’Indice della Paura e dell’Avidità è 37, e il panico continua a persistere.</p>
<h3 id="h3-Punti20Caldi20del20Mercato574598"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p>settore DeFi: Il progetto DeFi ben consolidato <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a> è superato i $150, con un aumento cumulativo di oltre il 25% nei 3 giorni scorsi. Dal punto di vista delle notizie, il lancio di una versione Altcoin di <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> da parte del secondo figlio di Trump, unito al dibattito di oggi tra i candidati presidenziali degli Stati Uniti, ha inserito alcuni argomenti caldi nel progetto.</p>
<p>Settore RWA: OM è salito di più del 10%, e anche PENDLE ha ottenuto una piccola rottura giornaliera di 4 guadagni consecutivi. Il settore RWA è una delle nuove narrazioni in questa fase delle tendenze di mercato. Attualmente, il valore di mercato complessivo del settore è relativamente piccolo, e potrebbe essere un settore degno di monitoraggio da parte degli utenti.</p>
<h2 id="h2-Macroeconomia20Il20mercato20azionario20degli20Stati20Uniti20sta20fluttuando20la20borsa20rimane20debole20a20settembre903705"><a name="Macroeconomia: Il mercato azionario degli Stati Uniti sta fluttuando, la borsa rimane debole a settembre?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: Il mercato azionario degli Stati Uniti sta fluttuando, la borsa rimane debole a settembre?</h2><p>I tre principali indici del mercato azionario statunitense hanno oscillato, con l’indice S&amp;P 500 che è salito dello 0,45% a 5495,52 punti; Il Dow Jones Industrial Average è sceso dello 0,23% a 40736,96 punti; L’indice Nasdaq è salito dell’0,84% a 17025,88 punti. Il rendimento del titolo di Stato decennale di riferimento è del 3,65%, mentre il rendimento del titolo di Stato a 2 anni, che è il più sensibile al tasso di politica della Federal Reserve, è del 3,59%.</p>
<p>Tra le azioni popolari statunitensi, Apple è scesa dello 0,36%, Microsoft è salita del 2,09%, Nvidia è salita dell’1,53%, Amazon è salita del 2,37%, Google C è scesa dello 0,31%, Google A è scesa dello 0,03%, TSMC è scesa dello 0,18%, Tesla è salita del 4,58%, e AMD è salita del 3,40%.</p>
<p>Attualmente, il mercato azionario statunitense sta affrontando molteplici questioni chiave. L’importante indice di inflazione CPI di agosto verrà pubblicato mercoledì ora locale e la Federal Reserve terrà la sua riunione di politica monetaria di settembre la prossima settimana. Gli investitori stanno anche monitorando da vicino argomenti come la politica commerciale e la tassazione nel dibattito elettorale statunitense di oggi.</p>
<p>Il sentiment nel mercato azionario statunitense è cauto. Gli investitori stanno monitorando attentamente le preoccupazioni riguardanti una recessione negli Stati Uniti e la possibilità di un atterraggio economico morbido. Con il raffreddamento del mercato del lavoro, molti partecipanti al mercato sono preoccupati che le azioni della Federal Reserve possano essere rimaste indietro rispetto ai reali bisogni.</p>
<p>Da un punto di vista storico, settembre è stato un mese di debole performance per il mercato azionario statunitense. Gli investitori rimangono cauti sull’effetto dei fattori stagionali sul mercato azionario e sull’incertezza che circonda le imminenti elezioni presidenziali statunitensi del 5 novembre.</p>
<h3 id="h3-Conclusione859106"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h3><p>Nel complesso, <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> attualmente si trova in uno stato di attesa, con fluttuazioni di prezzo relativamente piccole per <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed Ethereum. Le altcoin in generale sono diminuite, ma alcuni settori come DeFi e RWA hanno registrato performance più significative. Dal punto di vista macroeconomico, l’imminente pubblicazione dei dati CPI di agosto degli Stati Uniti questa sera potrebbe avere un impatto significativo sul mercato, e gli investitori dovrebbero monitorarlo attentamente. Nel breve termine, il sentiment di mercato tende ad essere cauto, e gli investitori dovrebbero controllare razionalmente i rischi e evitare di inseguire ciecamente i prezzi alti.</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.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il repostaggio dell'articolo a condizione che venga citato 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>