Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIEVURiBoYSB2aXN0byBmb3J0aSBhZmZsdXNzaSBkaSBmb25kaSwgU1VTSEkgw6ggYXVtZW50YXRvIGRlbCAzMDAlIGluIHVuIHNvbG8gbWVzZQ==

2024-12-09, 04:39

<p><img src="https://gimg2.gateimg.com/image/article/173371903012.09.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20scorsa20settimana20gli20afflussi20di20fondi20ETF20BTC20sono20stati20forti20e20APT20verr20sbloccato20in20grandi20quantit20questa20settimana146192"><a name="Crypto Daily Digest: La scorsa settimana, gli afflussi di fondi ETF BTC sono stati forti e APT verrà sbloccato in grandi quantità questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La scorsa settimana, gli afflussi di fondi ETF BTC sono stati forti e APT verrà sbloccato in grandi quantità questa settimana</h2><p>Secondo i dati degli investitori di Farside, l’ultimo flusso netto di venerdì dagli ETF BTC spot statunitensi è stato di 376 milioni di dollari. L’afflusso IBIT di BlackRock è stato di 257 milioni di dollari, mentre l’afflusso netto di FBTC di Fidelity è stato di 120 milioni di dollari.</p>
<p>Lo scorso venerdì, gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’ingresso dell’ETF spot è stato di $83,8 milioni. L’ingresso dell’ETHA di BlackRock è stato di $34,6 milioni, l’ingresso netto dell’FETH di Fidelity è stato di $47,9 milioni e l’uscita dell’ETHE di Grayscale è stata di $29,6 milioni.</p>
<h2 id="h2-Il20sentimento20di20acquisto20degli20ETF20Bitcoin20spot20rimane20forte20con20un20flusso20netto20complessivo20di20277520miliardi20di20dollari20la20scorsa20settimana227544"><a name="Il sentimento di acquisto degli ETF Bitcoin spot rimane forte, con un flusso netto complessivo di 2,775 miliardi di dollari la scorsa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il sentimento di acquisto degli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot rimane forte, con un flusso netto complessivo di 2,775 miliardi di dollari la scorsa settimana</h2><p>Secondo i dati degli investitori di Farside, il sentimento di acquisto di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> La scorsa settimana gli ETF spot sono rimasti forti, con un afflusso netto complessivo di 2,775 miliardi di dollari e un aumento delle partecipazioni di 28.606,26 BTC. Giovedì, i prezzi di BTC hanno superato con successo i 100.000$. BlackRock continua a guidare l’aumento delle partecipazioni, assorbendo 26.880,87 Bitcoin in una sola settimana, pari all’81,7% dell’aumento totale delle partecipazioni. Al contrario, Grayscale ha continuato a ridurre le sue partecipazioni a 3.113,12 BTC, mentre altre istituzioni hanno mantenuto uno stato di afflusso netto.</p>
<h2 id="h2-Lista20dei20dati20di20sblocco20di20questa20settimana20APT20ENA20ADA20e20altri20token20riceveranno20grandi20quantit20di20sblocco124115"><a name="Lista dei dati di sblocco di questa settimana: APT, ENA, ADA e altri token riceveranno grandi quantità di sblocco" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lista dei dati di sblocco di questa settimana: APT, ENA, ADA e altri token riceveranno grandi quantità di sblocco</h2><p>Secondo i dati di Token Unlocks, APT, ENA, ADA e altri token riceveranno sblocco di grandi quantità questa settimana, tra cui:</p>
<p><a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a>(APT) sbloccherà circa 11,31 milioni di token a mezzanotte ora di Pechino il 12 dicembre, con un rapporto del 2,11% rispetto alla circolazione attuale e un valore di circa $160 milioni;</p>
<p><a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> (ADA) sbloccherà circa 18,53 milioni di token alle 8:00 am ora di Pechino il 11 dicembre, con un rapporto dello 0,05% rispetto all’attuale <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> e un valore di circa $22,24 milioni;</p>
<p>Ethena (ENA) sbloccherà circa 12,86 milioni di token alle ore 15:00 ora di Pechino del 11 dicembre, con un rapporto dello 0,44% rispetto al valore corrente. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> e un valore di circa $12.88 milioni.</p>
<h2 id="h2-Punto20di20vista20La20criptovaluta20ha20vissuto20una20tendenza20di20mercato20indipendente20con20una20limitata20influenza20dal20mercato20macro20Occhi20puntati20sui20flussi20di20capitali20dagli20ETF20e20dalle20azioni20statunitensi20legate20alle20criptovalute112952"><a name="Punto di vista: La criptovaluta ha vissuto una tendenza di mercato indipendente, con una limitata influenza dal mercato macro; Occhi puntati sui flussi di capitali dagli ETF e dalle azioni statunitensi legate alle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punto di vista: La criptovaluta ha vissuto una tendenza di mercato indipendente, con una limitata influenza dal mercato macro; Occhi puntati sui flussi di capitali dagli ETF e dalle azioni statunitensi legate alle criptovalute</h2><p>Adam, un ricercatore di Greeks.live, ha pubblicato sui social media che <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> sta crescendo, con gli ETF che mantengono la loro tendenza al flusso di denaro e BTC ed ETH che superano le soglie intere di $100.000 e $4.000. Questa settimana ci sono dati importanti sull’IPC e sui tassi di interesse della Banca Centrale Europea, ma recentemente la criptovaluta sta vivendo trend indipendenti e l’impatto sul mercato macroeconomico è limitato. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> dei fondi ETF e azionari statunitensi correlati alle criptovalute merita maggiore attenzione.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha superato con successo i $100.000, e le Altcoin hanno sperimentato una rotazione completa dei guadagni, con diverse monete principali che sono apparse diverse volte più grandi. Gli afflussi di capitale di mercato sono forti, e i tori sono molto forti nel mercato spot dei tori.</p>
<p>Il mercato delle opzioni è relativamente stabile, e il trading in blocco e i tassi di interesse di mercato sono degni di attenzione. L’IV a lungo termine è basso, e l’IV a breve termine è significativamente diminuito. L’attuale mercato rialzista è forte, una buona opportunità per acquistare opzioni.</p>
<h2 id="h2-Tendenze20di20mercato20SUSHI2020aumentato20del203520nel20corso20della20giornata20e20il20settore20DEX2020cresciuto20collettivamente544116"><a name="Tendenze di mercato: SUSHI è aumentato del 35% nel corso della giornata e il settore DEX è cresciuto collettivamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: <a href="/price/sushi-sushi" target="_blank" class="blog_inner_link">SUSHI</a> è aumentato del 35% nel corso della giornata e il settore DEX è cresciuto collettivamente</h2><h3 id="h3-Hotspot20di20mercato356361"><a name="Hotspot di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato</h3><p>token DEX <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">SUSHI</a> è aumentato del 35%, con una capitalizzazione di mercato circolante attuale di $690 milioni, classificandosi al 144º posto nell’intero mercato e ottenendo un aumento cumulativo di oltre il 300% da novembre; Altri token DEX in DeFi, come <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a>, <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">DYDX</a>, PERP, ecc., sono aumentati anche in modo parallelo; Questi DEX non hanno lanciato altri prodotti e l’aumento è solo dovuto all’abbondanza di sentimenti di mercato e al livello generale di bassa capitalizzazione di mercato in cui si trovano attualmente;</p>
<p>PEPE è salito del 10% durante la giornata, raggiungendo un nuovo massimo storico. Attualmente ha una capitalizzazione di mercato circolante di $11.3 miliardi, diventando la terza criptovaluta meme con una capitalizzazione di mercato superiore a $10 miliardi dopo DOGE e SHIB. Attualmente si posiziona al 20° posto nell’intero mercato. Se DOGE e SHIB non raggiungono nuovi record di prezzo, il potenziale rialzista di PEPE potrebbe non essere molto grande.</p>
<h3 id="h3-Monete20principali327140"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC sta ancora scambiando intorno a $99.500, con un afflusso di BTC ETF superiore a $2,7 miliardi la scorsa settimana. Attualmente, il sentiment di mercato rimane generalmente ottimista;</p>
<p>ETH ha subito una leggera diminuzione dopo aver superato i $4.000 ed è attualmente in una fase di consolidamento stretta, in attesa della direzione del mercato;</p>
<p>Le altcoin in generale hanno subito un ritracciamento, con monete in tendenza come GOAT e MOODENG che entrano nella zona di correzione nelle prime fasi.</p>
<h2 id="h2-Macro20News20Lascesa20e20la20caduta20del20mercato20azionario20statunitense20sono20miste20ed2020quasi20certo20che20la20Fed20taglier20i20tassi20dinteresse20a20dicembre63056"><a name="Macro News: L’ascesa e la caduta del mercato azionario statunitense sono miste, ed è quasi certo che la Fed taglierà i tassi d’interesse a dicembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro News: L’ascesa e la caduta del mercato azionario statunitense sono miste, ed è quasi certo che la Fed taglierà i tassi d’interesse a dicembre</h2><p>Venerdì scorso, i tre principali indici azionari statunitensi hanno registrato fluttuazioni, con l’indice S&amp;P 500 in aumento dello 0,25% a 6.090,27 punti; il Dow Jones Industrial Average è diminuito dello 0,28% a 44.642,52 punti; l’indice Nasdaq è salito dello 0,81% a 19.859,77 punti. Il rendimento del titolo di stato decennale di riferimento è del 4,15%, mentre il rendimento del titolo di stato biennale, più sensibile ai tassi di interesse della Federal Reserve, è del 4,10%.</p>
<p>Lo scorso venerdì, dopo che il rapporto mensile sull’occupazione ha mostrato che il mercato del lavoro si stava raffreddando a sufficienza per consentire alla Federal Reserve di abbassare nuovamente i tassi di interesse alla fine del suo incontro del 18 dicembre, il Tesoro degli Stati Uniti ha proseguito il suo recente rimbalzo. I dati sugli stipendi non agricoli sono considerati l’ultimo indicatore chiave del mercato del lavoro prima di questo. Questa settimana, gli Stati Uniti rilasceranno anche i dati CPI e PPI, e il mercato si aspetta che questi rapporti mostrino una leggera aumento della pressione inflazionistica.</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 oculate.<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 per violazione del copyright.<br></div><p></p><br></div></div></div></div>