Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIHN1cGVyYXRvIGdsaSAkODkuMDAwLCBzdGFiaWxlbmRvIHVuIG51b3ZvIG1hc3NpbW8gc3Rvcmljby4gQUkgTWVtZSBBQ1Qgw6ggYXVtZW50YXRvIDIwIHZvbHRlIGR1cmFudGUgbGEgZ2lvcm5hdGEu

2024-11-12, 04:39

<p><img src="https://gimg2.gateimg.com/image/article/173138618311.12.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20criptovalute20gli20ETF20ETH20hanno20raggiunto20un20flusso20netto20giornaliero20record20MicroStrategy20ha20annunciato20un20ulteriore20220miliardi20in20BTC20in20portafoglio446272"><a name="Riassunto giornaliero criptovalute: gli ETF ETH hanno raggiunto un flusso netto giornaliero record, MicroStrategy ha annunciato un ulteriore $2 miliardi in BTC in portafoglio." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero criptovalute: gli ETF ETH hanno raggiunto un flusso netto giornaliero record, MicroStrategy ha annunciato un ulteriore $2 miliardi in BTC in portafoglio.</h2><p>Secondo i dati degli investitori di Farside, l’ingresso netto di US <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli spot ETF sono stati di $1,093 miliardi ieri, di cui $736 milioni da BlackRock IBIT, $135 milioni da Fidelity FBTC e $108 milioni da Ark ARKB.</p>
<p>La scala di gestione patrimoniale di IBIT, un <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> ETF sotto il Gruppo BlackRock, supera quello di iShares IAU, uno dei più grandi ETF dell’oro. I dati di FactSet mostrano che nella scorsa settimana, IBIT ha ricevuto circa $1 miliardo di afflussi di finanziamenti, con un totale di $27 miliardi di afflussi dall’avvio a gennaio. Alla scorsa venerdì, la scala della gestione patrimoniale dell’ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> IBIT era di $34.3 miliardi, rispetto alla scala della gestione patrimoniale di IAU di leggermente meno di $33 miliardi.</p>
<p>Ieri, gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli spot ETF hanno ricevuto $194 milioni di afflussi, ottenendo un grande afflusso netto per quattro giorni consecutivi e stabilendo un record per il maggior afflusso giornaliero dalla quotazione degli ETF ETH. L’afflusso Fidelity FETH è stato di $115 milioni, l’afflusso Grayscale Mini ETH è stato di $63.3 milioni e i dati sull’afflusso BlackRock ETHA non sono ancora stati aggiornati.</p>
<p><strong>CoinShares: L’apporto netto dei prodotti di investimento in asset digitali ha raggiunto 1,98 miliardi di dollari la scorsa settimana</strong></p>
<p>Secondo l’ultimo rapporto settimanale di CoinShares, i prodotti di investimento in asset digitali hanno registrato un afflusso di fondi di 1,98 miliardi di dollari dopo le elezioni negli Stati Uniti, segnando la quinta settimana consecutiva di afflussi e portando l’afflusso totale dell’anno a una cifra record di 31,3 miliardi di dollari. Influenzata dall’aumento dei prezzi della settimana scorsa, la dimensione globale degli asset gestiti ha raggiunto anche un nuovo massimo storico di 116 miliardi di dollari. Il volume delle negoziazioni è aumentato di 20 miliardi di dollari, sebbene non sia un nuovo record, è il livello più alto da aprile di quest’anno.</p>
<p>Dal punto di vista regionale, questi flussi di capitale sono principalmente concentrati negli Stati Uniti, dove l’importo degli afflussi è stato di 1,95 miliardi di dollari, anche se gli afflussi provenienti dalla Svizzera e dalla Germania sono aumentati, raggiungendo rispettivamente 23 milioni e 20 milioni di dollari.</p>
<p><strong>MicroStrategy ha aumentato le proprie riserve di 27.200 BTC per circa $2,03 miliardi</strong></p>
<p>Il fondatore di MicroStrategy, Michael Saylor, ha pubblicato sui social media che MicroStrategy ha aumentato il suo portafoglio di 27.200 Bitcoin a un prezzo medio di circa $74.463, con un valore totale di circa $2,03 miliardi.</p>
<p>Al 10 novembre 2024, MicroStrategy detiene 279.420 Bitcoin con un costo totale di acquisto di circa 11,9 miliardi di dollari e un prezzo medio di acquisto di circa 42.692 dollari.</p>
<p><strong>Standard Chartered Bank: si prevede che SOL supererà BTC e ETH entro la fine del 2025</strong></p>
<p>Standard Chartered Bank ha dichiarato in un rapporto di ricerca che se il Partito Repubblicano vince in modo completo, il nuovo governo degli Stati Uniti sarà in grado di promuovere politiche favorevoli all’industria degli asset digitali, il che potrebbe portare alla capitalizzazione di mercato totale del <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> espandersi a $10 trilioni entro la fine del 2026.</p>
<p>Standard Chartered Bank ha dichiarato di ritenere che ci saranno una serie di fattori favorevoli al <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato cripto</a> nelle prime fasi del nuovo governo degli Stati Uniti, compresi i cambiamenti normativi e gli adeguamenti alla posizione della Securities and Exchange Commission (SEC), che potrebbero portare a una posizione più indulgente nei confronti degli asset digitali.</p>
<p>La banca ha dichiarato che questi sviluppi positivi potrebbero quadruplicare la capitalizzazione di mercato totale del mercato crittografico dagli attuali 2,5 trilioni di dollari a 10 trilioni di dollari entro la fine del 2026. Geoff Kendrick, responsabile della ricerca sugli asset digitali presso la Standard Chartered Bank, ha scritto: ‘La marea crescente dovrebbe trainare tutti gli asset digitali, con quelli più rilevanti per i casi d’uso finali che si prevede beneficino di più.’ Il rapporto suggerisce inoltre che il nuovo governo degli Stati Uniti potrebbe considerare l’istituzione di una riserva di Bitcoin, ma ciò è visto come un ‘evento a bassa probabilità ma di grande impatto’.</p>
<p>La banca ha ribadito il suo obiettivo di circa $200.000 per Bitcoin (BTC) e $10.000 per <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>(ETH) entro la fine del 2025 e ha dichiarato di aspettarsi <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> SOL supererà le due criptovalute con la più alta capitalizzazione di mercato.</p>
<h2 id="h2-Tendenze20di20mercato20ACT2020aumentato20di20oltre202020volte20nel20corso20della20giornata20e20il20settore20dellIA2020cresciuto20collettivamente148102"><a name="Tendenze di mercato: ACT è aumentato di oltre 20 volte nel corso della giornata, e il settore dell’IA è cresciuto collettivamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: ACT è aumentato di oltre 20 volte nel corso della giornata, e il settore dell’IA è cresciuto collettivamente</h2><h3 id="h3-Punti20Caldi20del20Mercato233199"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>-Le monete meme on-chain ACT e PNUT hanno registrato forti aumenti, con ACT che aumenta più di 20 volte durante la giornata. ACT è uno dei due meme AI donati da a16z, l’altro è GOAT; Il limite di mercato circolante attuale di ACT è di 400 milioni di dollari, mentre il limite di mercato circolante di GOAT è di 820 milioni di dollari. ACT ha più scambi mainstream quotati e il suo limite di mercato ha ancora margine di miglioramento. PNUT è un progetto meme scoiattolo su cui Musk è apparso frequentemente su Twitter in precedenza, con un aumento giornaliero di oltre 8 volte. È molto probabile che continui a ricevere il supporto di Musk in futuro e il limite di mercato circolante attuale di PNUT è di 390 milioni di dollari;</p>
<p>-Il ben consolidato leader dei meme DOGE continua a volare, con un aumento giornaliero di quasi il 20% e una capitalizzazione di mercato di $50 miliardi, classificandosi al 6° posto nell’intero mercato e con un distacco del 40% <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, che si posiziona al quinto posto. DOGE è il meme più noto sia all’interno che all’esterno del mercato delle criptovalute, beneficiando dell’influenza di Musk e delle elezioni americane. DOGE non è lontano dal raggiungere un massimo storico di 0,7 dollari;</p>
<p>Il settore dell’IA, compreso WLD, IO, AI, FET e altri, è salito collettivamente. Il settore dell’IA è già una delle narrazioni più importanti in questa fase delle tendenze di mercato e, unita alle prestazioni calde del meme dell’IA GOAT e ACT, le prestazioni complessive del settore dell’IA sono relativamente forti.</p>
<h3 id="h3-Mainstream20Coins515791"><a name="Mainstream Coins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Coins</h3><p>BTC ha superato gli $89.000, stabilendo un nuovo massimo storico. Le politiche macroeconomiche e di politica amichevoli hanno iniettato maggiore fiducia in BTC;</p>
<p>ETH ha superato i $3.300, con un forte afflusso di oltre $200 milioni negli ETF ETH ieri, stabilendo un record per l’afflusso giornaliero più grande dalla quotazione degli ETF ETH;</p>
<p>In generale, le altcoin sono salite e l’effetto complessivo del settore dell’IA è buono. Quando arriva la stagione delle altcoin, di solito i meme on-chain si comportano meglio.</p>
<h2 id="h2-Notizie20macro20le20azioni20statunitensi20hanno20chiuso20in20rialzo20collettivamente20la20probabilit20di20un20taglio20dei20tassi20di20interesse20a20dicembre2020diminuita606036"><a name="Notizie macro: le azioni statunitensi hanno chiuso in rialzo collettivamente, la probabilità di un taglio dei tassi di interesse a dicembre è diminuita" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie macro: le azioni statunitensi hanno chiuso in rialzo collettivamente, la probabilità di un taglio dei tassi di interesse a dicembre è diminuita</h2><p>I principali indici azionari statunitensi continuano a raggiungere nuovi massimi storici. Alla chiusura, il Dow Jones Industrial Average è salito dello 0,69% a 44.293,13 punti, l’indice S&amp;P 500 è salito dello 0,1% a 6.001,35 punti e il Nasdaq è salito dello 0,06% a 19.298,76 punti. Questa è la prima volta nella storia del Dow Jones Industrial Average che chiude sopra i 44.000 punti, e anche la prima volta nella storia dell’S&amp;P che chiude sopra i 6.000 punti. Le azioni legate al concetto di criptovalute hanno registrato un forte aumento, con Canaan Technology in aumento del 41%, MicroStrategy in aumento del 25% e Coinbase in aumento del 19%.</p>
<p>Clark Geranen, capo analista di mercato presso CalBay Investments, ha affermato che il superamento del livello di 6.000 punti dell’indice S&amp;P 500 rappresenta una ‘significativa pietra miliare psicologica’ che potrebbe attirare l’interesse di più investitori verso le azioni, considerando che vi è ancora una grande quantità di denaro in attesa nei fondi del mercato monetario e nei bond. Altri ritengono che l’incertezza sulle prospettive economiche di Trump nel suo secondo mandato e la volatilità del mercato dei bond del tesoro contino a mantenere gli investitori all’erta di ulteriori turbolenze future.</p>
<p>“La reazione iniziale del mercato post-elettorale è selezionare e scegliere quali possibilità di politica affrontare. La nostra esperienza è che tali risposte limitate non hanno mai portato a opportunità di investimento durature, e tendiamo a mettere in pausa e esaminare più attentamente le potenziali misure politiche importanti,” ha detto Paul Christopher, direttore della strategia di investimento globale presso l’Istituto di Ricerca sugli Investimenti di Wells Fargo.”</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 venga citato 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>