RGFpbHkgTmV3cyB8IEkgZm9uZGkgRVRGIEJUQyBjb250aW51YW5vIGEgcmljZXZlcmUgZ3JhbmRpIGFmZmx1c3NpLCBSRUVGIMOoIGNyb2xsYXRvIGRlbCA3MCU=

2024-10-16, 04:28

<p><img src="https://gimg2.gateimg.com/image/article/172905276310.16.png" alt=""></p>
<h2 id="h2-Digest20quotidiano20di20Crypto20gli20influssi20degli20ETF20BTC20hanno20superato20i2030020milioni20di20dollari20EIGEN20d20il20benvenuto20al20grande20sblocco20di20oggi943299"><a name="Digest quotidiano di Crypto: gli influssi degli ETF BTC hanno superato i 300 milioni di dollari, EIGEN dà il benvenuto al grande sblocco di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Digest quotidiano di Crypto: gli influssi degli ETF BTC hanno superato i 300 milioni di dollari, EIGEN dà il benvenuto al grande sblocco di oggi</h2><p>Secondo i dati di Farside Investor, lo spot degli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF hanno registrato un afflusso netto di 371,66 milioni di dollari ieri. L’afflusso di IBIT di BlackRock è stato di 289 milioni di dollari e l’afflusso di FBTC di Fidelity è stato di 35 milioni di dollari. Il mercato statunitense <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF hanno avuto un deflusso netto di 12,7 milioni di dollari ieri.</p>
<p><strong>Bitwise Chief Investment Officer: Una grande quantità di fondi sta guardando fuori dal mercato, in attesa di entrare dopo che il rischio della regolamentazione delle criptovalute negli Stati Uniti sarà eliminato</strong></p>
<p>Il direttore degli investimenti di Bitwise, Matt Hougan, ha dichiarato che le recenti osservazioni della vicepresidente degli Stati Uniti, Harris, sulle criptovalute indicano che se i regolatori daranno il via libera, gli investitori affluiranno sul mercato degli asset digitali.</p>
<p>Il lunedì, Harris ha promesso di sostenere un quadro regolamentare che protegga gli investimenti neri e la proprietà di criptovalute. Hougan ha sottolineato in un post sul blog che la proposta di Harris è coincisa con un aumento del 5% in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Prezzi in aumento lunedì, con un flusso di 555,8 milioni di dollari in ETF di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot, il maggior afflusso dal 4 giugno.</p>
<p>Ha aggiunto: “Indipendentemente da ciò che ha detto Harris, la tendenza dei prezzi del giorno mi dice che ci sono molti fondi in attesa sulle linee laterali per eliminare l’allarme ed entrare nel mercato.”</p>
<p><strong>La probabilità che la Fed tagli i tassi di interesse di 25BP a novembre è del 90,6%</strong></p>
<p>Secondo il “FedWatch” del CME, la probabilità che la Federal Reserve riduca i tassi di interesse di 25 punti base entro novembre è del 90,6%, mentre la probabilità di mantenere invariati i tassi di interesse attuali è del 9,4%. La probabilità di un taglio cumulativo dei tassi di interesse di 25 punti base entro dicembre è del 13,3%, mentre la probabilità di un taglio cumulativo dei tassi di interesse di 50 punti base è dell’86,2%.</p>
<p><strong>EIGEN dà il benvenuto all’ampio sblocco di oggi</strong></p>
<p>Il protocollo di re-staking Eigenlayer (EIGEN) ha sbloccato 11,22 milioni di token del valore di circa 41,85 milioni di dollari alle 3 del mattino di oggi, rappresentando il 6,01% della liquidità. La capitalizzazione di mercato circolante attuale di EIGEN è di circa 660 milioni di dollari, posizionandosi al 102º posto per capitalizzazione di mercato.</p>
<p>EigenLayer è un protocollo costruito sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> rete che utilizza il nuovo concetto di “re-staking” per estendere la sicurezza e la praticità della rete ad altri progetti industriali.</p>
<h2 id="h2-Tendenze20di20mercato20REEF2020sceso20del207020le20altcoin20si20sono20generalmente20adeguate543860"><a name="Tendenze di mercato: REEF è sceso del 70%, le altcoin si sono generalmente adeguate" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: REEF è sceso del 70%, le altcoin si sono generalmente adeguate</h2><h3 id="h3-Hotspot20di20mercato492283"><a name="Hotspot di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato</h3><p>Il token concetto di archiviazione STORJ è aumentato di oltre il 25%, e il token del settore di archiviazione è stato un argomento caldo nelle ultime tendenze di mercato, emergendo spesso come un mercato indipendente;</p>
<p>I nuovi progetti di catene pubbliche come SUI e SAGA hanno subito un significativo calo, con dati on-chain che mostrano che gli indirizzi che detengono 1 miliardo di SUI continuano a vendere, cosa che la comunità ritiene sia un comportamento ufficiale di vendita di monete di Sui;</p>
<p>Il progetto meme DEEP sulla catena è triplicato. DEEP è la piattaforma di trading di aggregazione di Sui Chain ed è stata ora lanciata su Gate.io.</p>
<h3 id="h3-Mainstream20Coins804858"><a name="Mainstream Coins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Coins</h3><p>Una volta che si è avvicinato ai $68.000, BTC è rapidamente sceso a $65.000, per poi ritornare sopra i $67.500. L’acquisto di BTC è stato forte e i fondi ETF hanno continuato a <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> in;</p>
<p>Le prestazioni di ETH sono indietro rispetto a BTC, ancora in fase di consolidamento intorno ai $2.600, con piccole uscite dagli ETF di ETH;</p>
<p>Le altcoin in generale sono diminuiti, con il token leader di mercato REEF che è crollato del 70% durante la giornata, la maggior parte di essi entrando nel range di correzione.</p>
<h2 id="h2-Macroeconomia20I20tre20principali20indici20azionari20statunitensi20hanno20chiuso20collettivamente20in20ribasso20e20lincertezza20dei20mercati20globali2020aumentata633916"><a name="Macroeconomia: I tre principali indici azionari statunitensi hanno chiuso collettivamente in ribasso, e l’incertezza dei mercati globali è aumentata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia: I tre principali indici azionari statunitensi hanno chiuso collettivamente in ribasso, e l’incertezza dei mercati globali è aumentata</h2><p>I tre principali indici del mercato azionario statunitense hanno chiuso collettivamente in ribasso, con l’indice S&amp;P 500 che ha registrato una diminuzione del 0,76% a 5.815,26 punti; il Dow Jones Industrial Average è sceso del 0,75% a 42.740,42 punti; l’indice Nasdaq è sceso dell’1,01% a 18.315,59 punti. Il rendimento del titolo di Stato decennale di riferimento è del 4,03%, mentre il rendimento del titolo di Stato a 2 anni, più sensibile al tasso di politica della Federal Reserve, è del 3,95%. Il mercato azionario statunitense ha chiuso al ribasso martedì (15 ottobre), principalmente a causa dell’imprevista pubblicazione del rapporto finanziario del terzo trimestre da parte del gigante olandese delle macchine per litografia ASML, che è risultato al di sotto delle aspettative.</p>
<p>Sul fronte delle notizie, la Corea del Nord ha affermato che a causa delle azioni provocatorie della Corea del Sud, più di 1,4 milioni di quadri della lega giovanile e giovani studenti in tutto il paese si sono iscritti per unirsi o rientrare nell’esercito, esacerbando l’incertezza del mercato. Inoltre, i funzionari israeliani hanno dichiarato che potrebbero colpire basi militari iraniane o edifici governativi, aumentando ulteriormente le tensioni in Medio Oriente.</p>
<p>Nel complesso, il mercato globale è diventato più incerto e gli investitori sono diventati più cauti nel detenere asset rischiosi. In questo contesto, gli asset rifugio come l’oro sono favoriti e in generale i future internazionali sui metalli preziosi chiudono al rialzo. I partecipanti al mercato monitorano attentamente lo sviluppo delle situazioni geopolitiche e le variazioni dei dati economici globali per prendere decisioni di investimento corrispondenti.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Ghiaccia</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 venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>