Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIEVURiBPdXRmbG93cyBwZXIgdHJlIGdpb3JuaSBjb25zZWN1dGl2aSwgbGEgRmVkIHBvdHJlYmJlIHRhZ2xpYXJlIGkgdGFzc2kgZGkgaW50ZXJlc3NlIGRpIDUwIHB1bnRpIGJhc2UgYSBzZXR0ZW1icmU=

2024-08-30, 04:21

<p><img src="https://gimg2.gateimg.com/image/article/172499158130.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20il20trading20di20ETF20ETH2020lento20fuoriuscite20di20ETF20BTC20per20tre20giorni20consecutivi289741"><a name="Riepilogo giornaliero delle criptovalute: il trading di ETF ETH è lento, fuoriuscite di ETF BTC per tre giorni consecutivi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: il trading di ETF ETH è lento, fuoriuscite di ETF BTC per tre giorni consecutivi</h2><p>Secondo i dati degli investitori di Farside, lo spot statunitense <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF hanno registrato un deflusso netto di $72 milioni ieri, segnando tre giorni consecutivi di deflussi netti. Tra questi, il deflusso di IBIT di BlackRock è stato di circa $14 milioni, il che rappresenta il secondo giorno di deflusso sui 160 giorni di negoziazione dall’uscita degli ETF IBIT.</p>
<p>Ieri c’è stato un deflusso netto di 1,7 milioni di dollari dallo spot statunitense <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF, compreso un deflusso netto di 5,3 milioni di dollari da Grayscale ETHE e un afflusso netto di 3,6 milioni di dollari da Grayscale BTC.</p>
<p><strong>Cboe presenta una domanda rivista per la quotazione di opzioni ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ed Ethereum</strong></p>
<p>Secondo documenti ufficiali, il Chicago Board Options Exchange (Cboe Exchange) ha presentato una domanda rivista ai regolatori il 28 agosto, sperando di elencare opzioni ETF per Bitcoin ed Ethereum. La modifica proposta alle regole classificherà gli ETF crittografici spot come “titoli ritenuti adatti per il trading di opzioni” insieme agli ETF basati su materie prime come l’ETF fisico dell’oro di Goldman Sachs e l’iShare Silver Trust.</p>
<p><strong>Grayscale ETHE ha venduto finora il 31% di ETH</strong></p>
<p>L’analista rinomato Trader T ha pubblicato un’analisi dei dati sui social media, affermando che l’importo di ETH gestito da Grayscale ETHE è diminuito del 31% in 28 giorni di negoziazione, con un uscita netta di $5,35 milioni da ETHE ieri. Si prevede che il 50% di ETHE lo farà. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> esaurito entro 108 giorni (20 novembre), ma attualmente il mercato non è attivo e il volume di scambio è estremamente basso.</p>
<p><strong>Analisi: il grafico arcobaleno e cinque indicatori, tra cui l’indice di forza relativa, indicano che Bitcoin non ha ancora raggiunto il suo picco</strong></p>
<p>Secondo l’articolo di Lookonchain su X, cinque indicatori possono essere utilizzati per osservare se Bitcoin ha raggiunto il suo apice:</p>
<p>Il grafico arcobaleno è uno strumento di valutazione a lungo termine che utilizza curve di crescita logaritmiche per prevedere la direzione potenziale del prezzo di BTC in futuro. Il nuovo grafico arcobaleno Bitcoin2023 mostra che BTC è ancora molto economico;</p>
<p>Grafico dell’Indice di Forza Relativa (RSI) ≥ 70: BTC è ipercomprato e potrebbe presto diminuire. 30: BTC è ipervenduto e potrebbe presto salire. L’RSI attuale è 61,87 e rispetto ai dati precedenti, BTC sembra non aver ancora raggiunto il suo picco;</p>
<p>La mappa termica della media mobile a 200 settimane mostra il punto di prezzo attuale in blu, indicando che non è ancora stato raggiunto il picco del prezzo e che è un’opportunità per mantenere e acquistare;</p>
<p>Giorni accumulati di bruciatura del valore valutario (CVDD), quando <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo BTC</a> raggiunge la linea verde, il prezzo del BTC è sottovalutato, indicando un’ottima opportunità di acquisto al momento. Attualmente il CVDD mostra che il top del BTC sembra non essere ancora stato raggiunto;</p>
<p>Il moltiplicatore della media mobile annuale mostra che il prezzo del BTC si trova tra le linee rossa e verde. La linea rossa non è stata ancora raggiunta e il mercato non ha ancora raggiunto il picco.</p>
<h2 id="h2-Tendenze20di20mercato20Il20mercato2020debole20e20volatile20adatto20agli20investitori20a20lungo20termine184152"><a name="Tendenze di mercato: Il mercato è debole e volatile, adatto agli investitori a lungo termine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: Il mercato è debole e volatile, adatto agli investitori a lungo termine</h2><h3 id="h3-Criptovalute20principali500854"><a name="Criptovalute principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Criptovalute principali</h3><p>La recente tendenza di BTC è stata volatile. Ieri, il prezzo di BTC è salito brevemente a $61.000, ma poi è sceso a circa $59.000, indicando la debole volatilità del mercato. Inoltre, gli ETF BTC hanno registrato deflussi di fondi per tre giorni consecutivi, riflettendo il sentiment degli investitori cauto.</p>
<p>Il prezzo di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> continua a oscillare intorno ai $2.500. Sebbene l’ETF di ETH fosse molto atteso prima del suo lancio, il volume effettivo delle negoziazioni è stato molto al di sotto delle aspettative, e di recente si è verificato un deflusso netto di $5 milioni. Questo indica che il mercato rimane cauto sulle prospettive a breve termine di ETH.</p>
<p>Il mercato delle altcoin sta generalmente diminuendo e attualmente appartiene a un periodo di noia di mercato, senza nuove narrazioni o argomenti caldi emergenti, con conseguente mancanza di direzione nel mercato.</p>
<p>Oggi, l’indice AHR999 è 0,65, il che indica che il prezzo attuale è ancora adatto agli investimenti a lungo termine in BTC. Il basso livello di questo indicatore viene di solito considerato una buona opportunità per gli acquisti a lungo termine.</p>
<p>L’attuale indice di paura e avidità è 34, indicando che il sentiment di mercato rimane in uno stato di “paura”. Gli investitori sono cauti riguardo alle tendenze future e il sentiment di mercato è relativamente pessimistico.</p>
<h3 id="h3-Hotspot20di20mercato696901"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p>Ecosistema Ton: Nonostante la cauzione del fondatore di Telegram Durov, le prestazioni di prezzo di TON sono ancora relativamente deboli e il futuro del mercato non è ottimista. Vale la pena notare che Hamster Kombat, il più grande gioco di “clicca-per-guadagnare” sulla catena Ton, ha annunciato che emetterà token il 26 settembre, il che potrebbe attirare un po’ di attenzione all’ecosistema, ma l’impatto complessivo è limitato.</p>
<p>Settore Polifi: Nel settore Polifi, token come MAGA e POEPLE hanno ottenuto buoni risultati e sono diventati uno dei pochi punti salienti del mercato. Si prevede che il governo degli Stati Uniti tenga un’audizione sulle criptovalute a settembre e ci sarà anche un dibattito televisivo tra Trump e Harris il 10 settembre. Questi eventi politici potrebbero portare l’attenzione del mercato sul concetto politico correlato di Meme coin e scommesse in anticipo.</p>
<h2 id="h2-Macroeconomia20Il20trend20del20mercato20azionario20statunitense2020in20fluttuazione20e20la20Federal20Reserve20potrebbe20tagliare20i20tassi20di20interesse20di205020punti20base20a20settembre363628"><a name="Macroeconomia: Il trend del mercato azionario statunitense è in fluttuazione, e la Federal Reserve potrebbe tagliare i tassi di interesse di 50 punti base a settembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: Il trend del mercato azionario statunitense è in fluttuazione, e la Federal Reserve potrebbe tagliare i tassi di interesse di 50 punti base a settembre</h2><p>I tre principali indici del mercato azionario statunitense hanno oscillato, con l’indice S&amp;P 500 in calo dello 0,00% a 5.591,96 punti; il Dow Jones Industrial Average è salito dello 0,59% a 41.335,05 punti; l’indice Nasdaq è sceso dello 0,23% a 17.516,43 punti. Inoltre, il rendimento del decennale di riferimento è del 3,87%, mentre il rendimento del biennale, che è più sensibile al tasso di politica della Fed, è del 3,87%.</p>
<p>Tra le azioni statunitensi popolari, Apple è salita dell’1,46%, Microsoft dell’0,61%, Nvidia è scesa del 6,39%, Google C è scesa dello 0,67%, Google A è scesa dello 0,66%, Amazon è salita dello 0,77%, Meta è salita dello 0,28%, TSMC è salita dello 0,08%, Tesla è salita dello 0,26%, e AMD è scesa dello 0,59%.</p>
<p>Gurpreet Garewal, stratega macro per soluzioni di reddito fisso e liquidità presso Goldman Sachs, ha dichiarato in un rapporto che ci si aspetta che la Federal Reserve riduca i tassi di interesse di 25 punti base tre volte di seguito a settembre, novembre e dicembre. Ma ha detto che se il rapporto sull’occupazione di agosto, che sarà pubblicato la prossima settimana, mostra ulteriori segni di un mercato del lavoro debole, potrebbe spingere la Federal Reserve a iniziare a tagliare i tassi di interesse di oltre 50 punti base.</p>
<h3 id="h3-Conclusione459967"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h3><p>Complessivamente, il mercato è ancora in uno stato di volatilità e di attesa. La tendenza di BTC e ETH mostra un atteggiamento cauto degli investitori, mentre la mancanza di nuovi punti di riferimento nel mercato delle Altcoin ha portato a una diminuzione complessiva. Nonostante l’indice AHR999 e l’indice Fear &amp; Greed forniscono alcuni segnali di investimento a lungo termine, il mercato affronta ancora una significativa incertezza nel breve termine.</p>
<p>In termini di hotspots di mercato, anche se ci sono stati alcuni punti salienti nell’ecosistema Ton e nel settore Polifi, l’impatto complessivo è relativamente limitato. Gli investitori dovrebbero continuare a concentrarsi sugli eventi di mercato imminenti e sui cambiamenti dei dati, operare con cautela e allocare gli asset in modo ragionevole.</p>
<p>Nell’attuale ambiente di mercato, si consiglia agli investitori di mantenere la pazienza, monitorare le opportunità di investimento a lungo termine e monitorare da vicino i punti caldi del mercato e i cambiamenti di politica al fine di adeguare tempestivamente le proprie strategie di investimento.</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 ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>