Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIHNpIMOoIHJpdHJhdHRvIGUgY29uc29saWRhdG8sIEJJR1RJTUUgaGEgcG9ydGF0byBpbCBzZXR0b3JlIEdhbWVGaSBhIHNhbGlyZSBjb2xsZXR0aXZhbWVudGU=

2024-10-23, 04:21

<p><img src="https://gimg2.gateimg.com/image/article/172965715410.23.png" alt=""></p>
<h2 id="h2-Digest20giornaliero20delle20criptovalute20i20BTC20ETF20hanno20registrato20un20deflusso20netto20ieri20e20in20generale20il20settore20GameFi2020aumentato636053"><a name="Digest giornaliero delle criptovalute: i BTC ETF hanno registrato un deflusso netto ieri e in generale il settore GameFi è aumentato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digest giornaliero delle criptovalute: i BTC ETF hanno registrato un deflusso netto ieri e in generale il settore GameFi è aumentato</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> ETF spot hanno registrato un deflusso netto di 79,12 milioni di dollari ieri. IBIT ha avuto un afflusso netto di 42,95 milioni di dollari e ARKB ha registrato un deflusso netto di 134,74 milioni di dollari. Ieri, gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF ha avuto un deflusso netto di $20,82 milioni e gli ETF Grayscale hanno avuto un deflusso netto di $29,59 milioni.</p>
<p><strong>I token del settore GameFi sono generalmente aumentati, con BIGTIME che ha registrato un aumento giornaliero di oltre il 29%.</strong></p>
<p>Secondo le informazioni di mercato di Gate.io, il settore GameFi ha visto un aumento generale dei token oggi, con BIGTIME che ha registrato un aumento giornaliero del 29% e attualmente ha un prezzo di $0,1845, SLP ha registrato un aumento giornaliero del 19,1% e attualmente ha un prezzo di $0,003082, PIXEL ha registrato un aumento giornaliero del 18,7% e attualmente ha un prezzo di $0,1865, e MAVIA ha registrato un aumento giornaliero del 9,1% e attualmente ha un prezzo di $1,61.</p>
<p><strong>I rendimenti dei titoli del Tesoro statunitense a due anni salgono, i trader scommettono su un atterraggio morbido per l’economia statunitense</strong></p>
<p>Secondo le statistiche, dal primo taglio dei tassi d’interesse della Federal Reserve il 18 settembre 2020, il rendimento dei titoli di stato a due anni degli Stati Uniti è aumentato di 34 punti base.</p>
<p>Nella storia, sotto la guida di Greenspan, la Federal Reserve ha raffreddato con successo l’economia nel 1995, ma non ha causato una recessione, e aumenti simili nei rendimenti si sono verificati in quel periodo. Nel ciclo di taglio dei tassi d’interesse prima del 1989, il rendimento del Tesoro a due anni è sceso in media di 15 punti base un mese dopo che la Federal Reserve ha iniziato a tagliare i tassi d’interesse.</p>
<p>Steven Zeng, stratega dei tassi di interesse presso Deutsche Bank, ha affermato che l’aumento dei rendimenti “si riflette in una ridotta probabilità di rischio di recessione economica.” I dati sono piuttosto solidi. La Federal Reserve potrebbe rallentare il ritmo dei tagli dei tassi di interesse. Inoltre, il recente rimbalzo dei rendimenti indica che la resilienza dell’economia statunitense e la prosperità dei mercati finanziari hanno limitato la scelta del presidente della Federal Reserve, Powell, di tagliare attivamente i tassi di interesse. Le transazioni di swap dei tassi di interesse mostrano che i trader si aspettano che la Federal Reserve riduca i tassi di interesse di 128 punti base prima di settembre 2025, rispetto a 195 punti base di un mese fa.</p>
<p><strong>Analista: L’elenco di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Le opzioni ETF possono aumentare la volatilità di mercato</strong></p>
<p>Secondo The Block, la Securities and Exchange Commission (SEC) degli Stati Uniti ha precedentemente approvato il trading di opzioni e l’elenco di più spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Molti analisti prevedono che questa misura aumenterà la volatilità di mercato di Bitcoin.</p>
<p>Il CEO di Kbit, Ed Tolson, ha affermato che gli investitori al dettaglio negli Stati Uniti possono utilizzare le opzioni IBIT per ottenere strutture di rendimento asimmetriche. Ha sottolineato che i market maker istituzionali potrebbero dover comprare quando i prezzi salgono e vendere quando i prezzi scendono, il che potrebbe amplificare la volatilità.</p>
<p>Michael Harvey, il responsabile del trading presso Galaxy Digital, prevede che la volatilità aumenterà nel breve termine, ma a lungo termine, l’adozione di strategie di generazione di reddito da parte degli investitori istituzionali potrebbe ridurre la volatilità complessiva. La SEC ha stabilito un limite di 25000 contratti per le posizioni di opzioni, il che Harvey ritiene possa spingere alcune istituzioni a passare al trading di azioni correlate alle criptovalute come Coinbase o MicroStrategy.</p>
<h2 id="h2-Tendenze20di20mercato20GOAT2020salito20del2020020il20320mentre20le20prestazioni20di20SCR20del20progetto20Layer220sono20state20al20di20sotto20delle20aspettative583371"><a name="Tendenze di mercato: GOAT è salito del 200% il 3, mentre le prestazioni di SCR del progetto Layer2 sono state al di sotto delle aspettative" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: GOAT è salito del 200% il 3, mentre le prestazioni di SCR del progetto Layer2 sono state al di sotto delle aspettative</h2><h3 id="h3-Punti20caldi20di20mercato522713"><a name="Punti caldi di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi di mercato</h3><p>Il token GOAT, leader dei meme AI, è aumentato in modo significativo, registrando un aumento del 200% il giorno 3. Nonostante ci siano ancora dubbi su come l’AI e la criptovaluta possano essere combinate, i token meme AI stanno attirando l’attenzione del mercato grazie alle loro forti performance di prezzo. Il valore di mercato attuale di GOAT è vicino ai 500 milioni di dollari, che è già il tetto per molti meme coin non quotati su scambi principali.</p>
<p>Il token Scroll SCR del progetto Layer2 è stato lanciato, ma le sue prestazioni di prezzo non hanno soddisfatto le aspettative. Nel contesto delle prestazioni in declino di ETH, il settore Layer2 ha avuto in generale una scarsa performance nelle ultime fasi del mercato, con il rilascio di token e un aumento del valore di mercato circolante, ma i prezzi sono continuati a diminuire.</p>
<p>Il settore dei token GameFi ha visto un aumento diffuso, con PIXEL, BIGTIME, YGG e altri che hanno registrato guadagni significativi. Dopo la metà dell’anno, di solito c’è un’azione di richiamo per i token di tipo gioco “play-to-earn” per soddisfare le esigenze di spedizione degli utenti e delle istituzioni che partecipano al progetto durante il ciclo. In generale, il mercato non è sostenibile.</p>
<h3 id="h3-Monete20principali353761"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>Il BTC si è consolidato intorno ai $67.000 e non c’è stato un calo significativo della liquidità, indicando fondi circolanti sufficienti sul mercato;</p>
<p>ETH ha mostrato un lieve calo, diminuendo per due giorni consecutivi, e le performance dell’ETF di ETH rimangono deludenti;</p>
<p>Le altcoin stanno generalmente diminuendo, e i progetti meme on-chain come GOAT stanno performando bene. Il mercato sta ancora aspettando l’emergere dei token leader.</p>
<h2 id="h2-Macroeconomia20il20mercato20azionario20statunitense20ha20sperimentato20lievi20fluttuazioni20con20unalta20probabilit20che20la20Fed20taglier20i20tassi20di20interesse20di202520punti20base20a20novembre241631"><a name="Macroeconomia: il mercato azionario statunitense ha sperimentato lievi fluttuazioni, con un’alta probabilità che la Fed taglierà i tassi di interesse di 25 punti base a novembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: il mercato azionario statunitense ha sperimentato lievi fluttuazioni, con un’alta probabilità che la Fed taglierà i tassi di interesse di 25 punti base a novembre</h2><p>I tre principali indici del mercato azionario statunitense hanno oscillato, con l’indice S&amp;P 500 che è sceso dello 0,05% a 5.851,20 punti; Il Dow Jones Industrial Average è sceso dello 0,02% a 42.924,89 punti; L’indice Nasdaq è salito dello 0,18% a 18.573,13 punti. Il rendimento del titolo di Stato decennale di riferimento è del 4,20%, mentre il rendimento del titolo di Stato a 2 anni, il più sensibile al tasso di politica della Federal Reserve, è del 4,03%.</p>
<p>Secondo il “FedWatch” della CME, la probabilità che la Federal Reserve riduca i tassi di interesse di 25 punti base entro novembre è del 91,1%, la probabilità di mantenere i tassi di interesse attuali invariati è dell’8,9% e la probabilità di riduzione dei tassi di interesse di 50 punti base è dello 0%. La probabilità di mantenere invariato il tasso di interesse attuale fino a dicembre è del 2,2%, la probabilità di riduzione cumulative dei tassi di interesse di 25 punti base è del 29,5%, la probabilità di riduzione cumulative dei tassi di interesse di 50 punti base è del 68,3% e la probabilità di riduzione cumulative dei tassi di interesse di 75 punti base è dello 0%.</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; è essenziale prendere decisioni prudenti.<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 per violazione del copyright.<br></div><p></p><br></div></div></div></div>