Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIHN1cGVyYSBpIDkzLjAwMCBkb2xsYXJpLCBjb250aW51YSBhIHNlZ25hcmUgdW4gbnVvdm8gbWFzc2ltbyBzdG9yaWNvLCBQTlVUIGd1aWRhIGlsIG1lcmNhdG8gY29uIHVuIGF1bWVudG8gaW50cmFkYXkgZGVsIDQwMCU=

2024-11-14, 04:50

<p><img src="https://gimg2.gateimg.com/image/article/173155971511.14.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20ETF20ETH20ha20ripreso20grandi20afflussi20la20dimensione20di20BlackRock20IBIT20ha20superato20i204020miliardi386606"><a name="Crypto Daily Digest: ETF ETH ha ripreso grandi afflussi, la dimensione di BlackRock IBIT ha superato i $40 miliardi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: ETF ETH ha ripreso grandi afflussi, la dimensione di BlackRock IBIT ha superato i $40 miliardi</h2><p>Secondo i dati degli investitori di Farside, ieri è stato registrato un afflusso netto di spot statunitensi <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli ETF ammontavano a 514,43 milioni di dollari, di cui 235 milioni provenienti da BlackRock IBIT data, 186 milioni da Fidelity FBTC e 61,3 milioni da Grayscale Mini Trust BTC.</p>
<p>Ieri, gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot hanno registrato un afflusso di capitali di $111 milioni, ripristinando ancora una volta significativi flussi di capitali. L’afflusso di Fidelity FETH è stato di $101 milioni, quello di Bitwise ETHW di $13 milioni, mentre i dati di BlackRock ETHA non sono stati ancora aggiornati.</p>
<p><strong>Dopo la pubblicazione dell’indice dei prezzi al consumo negli Stati Uniti, la probabilità che la Fed tagli i tassi di interesse di 25 punti base a dicembre è salita al 75,7%</strong></p>
<p>Secondo i dati di “Federal Reserve Watch” di CME, la probabilità che la Federal Reserve mantenga invariati i tassi di interesse attuali fino a dicembre è del 24,3%, mentre la probabilità di un taglio dei tassi di 25 punti base cumulativi è del 75,7% (rispettivamente 37,9% e 62,1% prima della pubblicazione dei CPI).</p>
<p>La probabilità di mantenere invariato il tasso di interesse attuale fino a gennaio prossimo è del 16,5%, la probabilità di ridurre i tassi di interesse di 25 punti base in modo cumulativo è del 59,2%, e la probabilità di ridurre i tassi di interesse di 50 punti base in modo cumulativo è del 24,3%. (Prima della pubblicazione dell’IPC, erano rispettivamente del 26,5%, 54,9% e 18,6%).</p>
<p><strong>AP: La canzone ufficiale del celebrità di internet tailandese Moo Deng è stata rilasciata e disponibile in versioni tailandesi, cinesi, inglesi e giapponesi.</strong></p>
<p>Secondo l’Associated Press, lo zoo aperto di Khao Kheow a Chumphon, in Thailandia, ha ufficialmente pubblicato la canzone tema per l’ippopotamo popolare Moo Deng.</p>
<p>Si dice che la vivace canzone di 50 secondi “Moodeng Moodeng” abbia versioni in tailandese, inglese, cinese e giapponese, con testi semplici e facili da comprendere come “Moo Deng Moo Deng, boing boing boing/Mommy mommy, play with me”. Il video musicale di questa canzone è composto da brevi video di ippopotami che saltano e saltano, giocano con i loro custodi o giocano con la loro madre Jona.</p>
<p>Questo ippopotamo ha ora quattro mesi ed ha attirato un gran numero di turisti allo zoo situato a circa due ore di macchina dalla capitale Bangkok. Lo zoo stima di aver ricevuto una media di 3.000-5.000 visitatori al giorno nei mesi scorsi, e vende anche vestiti, biancheria da letto e altri prodotti basati su Moo Deng.</p>
<p><strong>L’IBIT di BlackRock ha superato i 40 miliardi di dollari in 211 giorni, stabilendo un nuovo record storico con un enorme vantaggio</strong></p>
<p>L’analista ETF di Bloomberg, Eric Balchunas, ha pubblicato sui social media che entro 211 giorni dal suo lancio, la dimensione degli asset di BlackRock IBIT ha raggiunto i 40 miliardi di dollari (solo due settimane dopo aver raggiunto i 30 miliardi di dollari), superando il precedente record di 1.253 giorni detenuto da IEMG (l’ETF dei mercati emergenti di BlackRock).</p>
<p>IBIT si posiziona nel 1% superiore di tutte le classifiche delle dimensioni degli asset ETF, e quasi 10 mesi dopo il suo lancio, la sua dimensione degli asset è più grande di tutti i 2.800 ETF lanciati nell’ultimo decennio.</p>
<h2 id="h2-Tendenze20di20mercato20PNUT20ha20guidato20il20mercato20con20un20aumento20intraday20del2040020mentre20POPCAT20continua20a20segnare20un20nuovo20massimo20storico686983"><a name="Tendenze di mercato: PNUT ha guidato il mercato con un aumento intraday del 400%, mentre POPCAT continua a segnare un nuovo massimo storico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: PNUT ha guidato il mercato con un aumento intraday del 400%, mentre POPCAT continua a segnare un nuovo massimo storico</h2><h3 id="h3-Punti20Caldi20di20Mercato817777"><a name="Punti Caldi di Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi di Mercato</h3><p>Le monete di tendenza nel settore dei meme, come PEPE, POPCAT, MOG e WIF, hanno registrato un’impennata. PEPE è stato quotato sulla borsa coreana, con una capitalizzazione di mercato che ha superato i 10 miliardi di dollari in un momento; POPCAT supera 1,85 dollari e continua a segnare un nuovo massimo storico, diventando così la moneta meme di gatto più preziosa al momento;</p>
<p>Nuove criptovalute meme di tendenza come PNUT e MOODENG hanno registrato un forte aumento, con PNUT che è salito del 400% nel corso della giornata. PNUT è stato lodato da Musk come simbolo di salvezza dell’America ed è stato menzionato ripetutamente sul suo account Twitter, facendo aumentare la sua capitalizzazione di mercato di cinque volte in un giorno fino a raggiungere i 2,5 miliardi di dollari; MOODENG è un meme di un ippopotamo celebrità di internet thailandese, con un aumento del 15% nelle ultime 24 ore e una capitalizzazione di mercato circolante attuale di 320 milioni di dollari.</p>
<h3 id="h3-Coin20principali851223"><a name="Coin principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Coin principali</h3><p>BTC supera i $93.000 e continua a raggiungere nuovi massimi storici, attualmente in fase di correzione intorno agli $89.500. Gli ETF di BTC continuano a registrare ingenti afflussi netti e il futuro del mercato di BTC è ancora promettente;</p>
<p>ETH si sta ancora consolidando intorno a $3.200 e l’ETF ETH ha iniziato a ricevere grandi flussi di denaro positivi, indicando che la diminuzione dei fondi sta per invertirsi;</p>
<p>Le monete VC in Altcoins hanno in generale subito un ritracciamento, con solo le monete di tendenza nel settore dei meme che mostrano forti guadagni e PNUT che guida il mercato con un aumento intraday del 400%.</p>
<h2 id="h2-Notizie20macroeconomiche20la20salita20e20la20caduta20del20mercato20azionario20americano20sono20miste20e20la20probabilit20di20un20taglio20dei20tassi20dinteresse20della20Fed2020salita20all825956861"><a name="Notizie macroeconomiche: la salita e la caduta del mercato azionario americano sono miste, e la probabilità di un taglio dei tassi d’interesse della Fed è salita all’82,5%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie macroeconomiche: la salita e la caduta del mercato azionario americano sono miste, e la probabilità di un taglio dei tassi d’interesse della Fed è salita all’82,5%</h2><p>I tre principali indici del mercato azionario statunitense hanno oscillato, con l’indice S&amp;P 500 che è salito dello 0,02% a 5.985,38 punti; il Dow Jones Industrial Average è salito dello 0,11% a 43.958,19 punti; l’indice Nasdaq è sceso dello 0,26% a 19.230,72 punti. Il rendimento del titolo di Stato decennale di riferimento è del 4,44%, mentre il rendimento del titolo di Stato a 2 anni, che è più sensibile al tasso di politica della Federal Reserve, è del 4,27%.</p>
<p>Secondo i dati pubblicati mercoledì dal Bureau of Labor Statistics degli Stati Uniti, l’indice dei prezzi al consumo core (CPI) al netto dei costi alimentari ed energetici è aumentato dello 0,3% per tre mesi consecutivi, con un aumento su base annua del 3,3%. I dati mostrano che il tasso CPI sui dodici mesi ha registrato il 2,6%, in linea con le attese e superiore al precedente valore del 2,4%, raggiungendo i massimi da tre mesi e ponendo fine al precedente trend di “sei cali consecutivi”; Il tasso mensile dell’IPC destagionalizzato per ottobre ha registrato lo 0,2%, in linea con le aspettative e i valori precedenti.</p>
<p>The Wall Street Journal ha sottolineato che, anche se i dati sull’inflazione si stanno stabilizzando, sembra ancora possibile che i responsabili della Federal Reserve taglino i tassi di interesse di altri 25 punti base all’ultimo incontro dell’anno il mese prossimo. Questo è principalmente perché, nonostante alti e bassi lungo il cammino, l’inflazione sembra essere in una fase di raffreddamento. Inoltre, ci sono ancora un certo grado di ‘inflazione di recupero’ nei dati.</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 suggerimenti di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo 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></div>