Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGluIGF2dmljaW5hbWVudG8gYWkgJDcwLjAwMDogU2kgYXZ2aWNpbmEgbGEgc3RhZ2lvbmUgZGVnbGkgYWx0Y29pbj8=

2024-10-21, 04:03

<p><img src="https://gimg2.gateimg.com/image/article/172948399710.21.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Continui20afflussi20significativi20negli20ETF20BTC20YGG20pronto20per20un20grande20sblocco131446"><a name="Crypto Daily Digest: Continui afflussi significativi negli ETF BTC, YGG pronto per un grande sblocco" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Continui afflussi significativi negli ETF BTC, YGG pronto per un grande sblocco</h2><p>Secondo i dati di Farside Investor, lo scorso venerdì, U.S. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF spot hanno registrato un afflusso netto di 273 milioni di dollari. L’IBIT di BlackRock ha registrato un afflusso netto di 70 milioni di dollari, mentre l’ARKB di ARK ha portato in 109 milioni di dollari. Venerdì, negli Stati Uniti. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF hanno registrato un afflusso netto di 1,9 milioni di dollari.<br>Se <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Se <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> supera i $70.000, le liquidazioni totali corte su importanti CEX potrebbero raggiungere i $349 milioni.</p>
<p>Secondo i dati di Coinglass, se Bitcoin supera i 70.000 dollari, le liquidazioni corte totali su importanti CEX potrebbero raggiungere i 349 milioni di dollari. Al contrario, se Bitcoin scende sotto i 68.000 dollari, le liquidazioni lunghe totali potrebbero raggiungere i 408 milioni di dollari.</p>
<p>Il grafico di liquidazione mostra il grado di impatto a specifici livelli di prezzo. “Barre di liquidazione” più alte indicano una reazione più intensa del mercato a causa delle impennate di liquidità a questi livelli di prezzo.</p>
<p><strong>I dati di sblocco di questa settimana: Token come ENA, YGG, EIGEN sono pronti per sblocchi significativi questa settimana</strong><br>Secondo Tokenomist.ai, token come ENA, YGG e EIGEN sono pronti per sbloccare importanti questa settimana, tra cui:</p>
<ul>
<li><p>Eigenlayer (EIGEN) sbloccherà circa 1,29 milioni di token alle 3 del mattino ora di Pechino del 23 ottobre, corrispondenti allo 0,69% del suo approvvigionamento circolante, del valore di circa 4,8 milioni di dollari.</p>
</li><li><p>Ethena (ENA) sbloccherà circa 12,86 milioni di token alle 15:00 ora di Pechino del 23 ottobre, corrispondenti al 0,47% del suo offerta circolante, del valore approssimativo di circa 5,3 milioni di dollari.</p>
</li></ul>
<p>-Yield Guild Games (YGG) sbloccherà circa 14,08 milioni di token alle 22:00 ora di Pechino del 27 ottobre, corrispondenti al 3,64% della sua offerta circolante, del valore approssimativo di $7,84 milioni.</p>
<ul>
<li><a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>(FET) e SingularityNET (AGIX) sono anche pronti per sbloccare token di dimensioni variabili questa settimana.</li></ul>
<p><strong>Capo di BlackRock ETF: l’80% degli acquirenti di ETF Bitcoin sono investitori diretti</strong><br>Nelle ultime cinque giornate di negoziazione, gli ETF Bitcoin spot hanno registrato afflussi netti superiori a 2,1 miliardi di dollari, con BlackRock che ha rappresentato la metà delle vendite. L’ETF e l’Index Chief Investment Officer di BlackRock, Samara Cohen, ha affermato che una strategia per attirare i clienti verso il loro fondo consiste nell’introdurre gli investitori in criptovalute ai benefici dei prodotti negoziati in borsa (ETP).</p>
<p>Attualmente, la maggior parte degli investitori sono nuovi al mondo delle criptovalute, e i dati mostrano che l’80% dei venditori sono investitori diretti, con il 75% di questi che non hanno mai detenuto in precedenza iShares.</p>
<h2 id="h2-Analisi20di20mercato20APE20raddoppia20in20un20giorno20DYDX20sale20del2040647514"><a name="Analisi di mercato: APE raddoppia in un giorno, DYDX sale del 40%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi di mercato: APE raddoppia in un giorno, <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">DYDX</a> sale del 40%</h2><p><strong>Evidenze di mercato:</strong><br>Il token NFT leader APE è salito alle stelle, raddoppiando il prezzo in un solo giorno. Ape ha lanciato la sua nuova catena, Apechain, insieme al suo ponte ufficiale cross-chain, permettendo il trasferimento di token da altre catene in Apechain. Inoltre, Apechain ha sviluppato una piattaforma di lancio di meme simile a PumpFun, ma la maggior parte dei token su Apechain, come CURTIS, tende a subire un rapido aumento seguito da una rapida dimezzamento del valore.</p>
<p>-Token veterano DeFi <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">DYDX</a> è aumentato di quasi il 40% in un giorno. L’aumento è stato guidato dall’annuncio di <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">Dydx</a> che stanno lanciando un contratto perpetuo per il mercato delle previsioni sulle elezioni di Trump, attirando fondi di mercato significativi.</p>
<p>I progetti di catena pubblica come ETH, SOL e INJ hanno registrato aumenti di prezzo, mentre le nuove catene pubbliche precedentemente forti come SUI, SEI e SAGA si trovano in una fase di consolidamento. Con l’andamento complessivo del mercato in crescita, i progetti di catena pubblica tendono a beneficiare per primi.</p>
<p><strong>Tendenze di mercato:</strong><br>-BTC ha mantenuto un trend al rialzo nel weekend, avvicinandosi alla soglia dei $70.000, con un sentimento positivo di mercato. La scorsa settimana, gli ETF BTC hanno registrato un afflusso di oltre $1,5 miliardi.</p>
<p>-ETH ha superato i $2.700, portando a un ritorno dei fondi ai progetti meme della catena ETH. Tuttavia, gli ETF ETH rimangono deludenti, con un ottimismo cauto per il futuro.</p>
<ul>
<li>Le altcoin hanno registrato guadagni diffusi, con DYDX, APE e DEEP in testa al mercato. Il mercato sta ancora aspettando l’emergere di un nuovo token leader.</li></ul>
<h2 id="h2-Macro20Notizie20Lo20scorso20venerd20le20azioni20statunitensi20hanno20chiuso20in20rialzo20con20le20probabilit20di20elezione20di20Trump20in20aumento111230"><a name="Macro Notizie: Lo scorso venerdì, le azioni statunitensi hanno chiuso in rialzo, con le probabilità di elezione di Trump in aumento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Notizie: Lo scorso venerdì, le azioni statunitensi hanno chiuso in rialzo, con le probabilità di elezione di Trump in aumento</h2><p>Lo scorso venerdì, tutti e tre i principali indici azionari statunitensi hanno chiuso in rialzo. Lo S&amp;P 500 è salito dello 0,40% a 5.864,67 punti; il Dow Jones è salito dello 0,09% a 43.275,91 punti; e il Nasdaq ha guadagnato lo 0,63% a 18.489,55 punti. Nella scorsa settimana, il Dow Jones è salito dello 0,96%, il Nasdaq dello 0,80% e lo S&amp;P 500 dell’0,85%.</p>
<p>Il rendimento del titolo del Tesoro statunitense decennale di riferimento si attestava al 4,08%, mentre il rendimento del titolo del Tesoro statunitense a 2 anni, che è il più sensibile ai tassi di politica della Fed, si attestava al 3,95%.</p>
<p>Il mercato sta osservando da vicino le elezioni americane, con le probabilità di vittoria di Trump che sono aumentate significativamente la scorsa settimana. I mercati delle previsioni mostrano ora Trump con il 60% di possibilità di vincere. Questa tendenza si riflette nei mercati finanziari, con circa $30 milioni che affluiscono nelle criptovalute. Man mano che si avvicinano le elezioni, potrebbe esserci un certo copertura nel mercato, portando a volatilità.</p>
<p>Tuttavia, nel medio-lungo termine, la fine delle elezioni rimuoverà un’importante incertezza politica, il che potrebbe favorire la crescita del mercato azionario. Finché i guadagni delle imprese sono solidi, c’è ancora una buona possibilità che le azioni statunitensi raggiungano nuovi massimi quest’anno.</p>
<div class="blog-details-info"><br><div>Autore: <strong>icing</strong><br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>