Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgdGFnbGlvIGRlaSB0YXNzaSBkJ2ludGVyZXNzZSBkZWxsYSBGZWQgbGEgcHJvc3NpbWEgc2V0dGltYW5hIMOoIHF1YXNpIGNlcnRvOyBsJ2F0dGl2aXTDoCBEZUZpIMOoIHJpcHJlc2EsIHN0aW1vbGFuZG8gbCdhdW1lbnRvIGRpIEVUSCBlIEFBVkU=

2024-12-13, 03:31

<p><img src="https://gimg2.gateimg.com/image/article/173406058612.13.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20gli20ETF20spot20BTC20ed20ETH20hanno20entrambi20registrato20ingenti20afflussi20e20la20Fed20probabilmente20taglier20i20tassi20di20interesse20la20prossima20settimana850448"><a name="Crypto Daily Digest: gli ETF spot BTC ed ETH hanno entrambi registrato ingenti afflussi, e la Fed probabilmente taglierà i tassi di interesse la prossima settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: gli ETF spot BTC ed ETH hanno entrambi registrato ingenti afflussi, e la Fed probabilmente taglierà i tassi di interesse la prossima settimana</h2><p>Secondo i dati di Farside Investor, gli Stati Uniti <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Gli spot ETF hanno avuto un afflusso netto di 604 milioni di dollari ieri. L’afflusso di ETHA di BlackRock è stato di 430 milioni di dollari, e l’afflusso netto di FBTC di Fidelity è stato di 30,5 milioni di dollari.</p>
<p>Gli Stati Uniti <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’ETF spot ha registrato un afflusso netto di $277 milioni ieri. L’afflusso di ETHA di BlackRock è stato di $202 milioni, mentre l’afflusso netto di ETH di Grayscale è stato di $73,2 milioni.</p>
<p><strong>La probabilità che la Fed tagli i tassi di interesse di 25 punti base a dicembre è del 96,7%</strong></p>
<p>Secondo il “FedWatch” del CME, la probabilità che la Fed mantenga invariati i tassi di interesse attuali fino a dicembre è del 3,3%, mentre la probabilità di un taglio dei tassi di 25 punti base è del 96,7%.</p>
<p><strong>CryptoQuant: Il prezzo medio di rivendita di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è aumentato vertiginosamente e potrebbe superare i $5.000</strong></p>
<p>Secondo TheBlock, gli analisti di CryptoQuant hanno affermato che in base agli indicatori di valutazione, se la situazione attuale di offerta e domanda continua, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> potrebbe superare i 5.000 dollari.</p>
<p>Gli analisti di CryptoQuant sottolineano che la fascia di prezzo realizzato di Ethereum è un indicatore chiave che valutano. Il prezzo implementato rappresenta il prezzo medio di rivendita di Ethereum. Il limite superiore attuale della fascia di prezzo è di $5,200. Man mano che i nuovi acquirenti acquistano Ethereum a prezzi più alti, questo limite di prezzo continuerà a salire, indicando il potenziale per ulteriori aumenti nel ciclo di mercato attuale.</p>
<p><strong><a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a> è salito sopra i $380, con l’ultima impennata dei tassi di interesse sui depositi e il TVL che raggiunge nuovi massimi</strong></p>
<p>Secondo le informazioni di mercato di Gate.io, il protocollo di prestito <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> Il token <a href="/price/aave-aave" target="_blank" class="blog_inner_link">AAVE</a> ha superato i 380 dollari durante il giorno, toccando quota 388,52 dollari, e ora è quotato a 368 dollari, con un aumento del 19,9% nelle ultime 24 ore.</p>
<p>In precedenza, diversi indicatori del protocollo Aave hanno raggiunto nuovi massimi, ma il prezzo attuale della moneta è solo circa il 60% del prezzo del periodo ATH. Rispetto al 2021, l’offerta totale di stablecoin è significativamente più alta, il che fornisce anche slancio per DeFi e <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">prezzo AAVE</a> si prevede che cresca ulteriormente. Secondo i dati di DeFiLlama, il TVL di Aave ha raggiunto un nuovo massimo storico di 38,6 miliardi di dollari, superando il precedente periodo di mercato rialzista nel mese di ottobre 2021. Il fatturato annuo stimato per questo protocollo è di 117 milioni di dollari.</p>
<h2 id="h2-Tendenze20di20mercato20AVA2020aumentato20di20oltre20il2035020durante20la20giornata20mentre20il20TVL20di20AAVE20ha20raggiunto20un20massimo20storico306323"><a name="Tendenze di mercato: AVA è aumentato di oltre il 350% durante la giornata, mentre il TVL di AAVE ha raggiunto un massimo storico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: AVA è aumentato di oltre il 350% durante la giornata, mentre il TVL di AAVE ha raggiunto un massimo storico</h2><h3 id="h3-Hotspot20di20mercato567699"><a name="Hotspot di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato</h3><p>AVA è salito di oltre il 350% nel giro di un giorno, ma l’attuale aumento è leggermente diminuito, mantenendo comunque un tasso di crescita di circa il 250%; AVA è il token di utilità di Travala, una piattaforma di viaggi che supporta metodi di pagamento in criptovalute. Si riferisce che il fatturato annuo della piattaforma ha superato i 100 milioni di dollari. Ieri, CZ ha annunciato di aver già investito nella piattaforma, stimolando l’aumento del token AVA; La capitalizzazione di mercato circolante attuale di AVA è di 137 milioni di dollari, posizionandosi al 424º posto nell’intero mercato, e c’è ancora ampio spazio per la speculazione;</p>
<p>AAVE è salito di oltre il 30% nel corso della giornata e il mercato è rimbalzato, stimolando l’attività DeFi; In qualità di protocollo di prestito DeFi leader, il TVL di Aave ha raggiunto un massimo storico di 38,6 miliardi di dollari, superando il precedente periodo di bull market nell’ottobre 2021. Il fatturato annuo stimato per questo protocollo è di 117 milioni di dollari.</p>
<h3 id="h3-Mainstream20Coins405159"><a name="Mainstream Coins" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Coins</h3><p>BTC si è ripreso e ha superato i $102.500 prima di ritracciarsi leggermente. Potrebbe trovarsi in un periodo di aggiustamento volatile nel breve termine, ma resta comunque ottimista nel medio-lungo periodo;</p>
<p>ETH ha mostrato una performance relativamente forte, con l’aumento dei token DeFi e la crescita delle attività DeFi che stimolano la domanda di ETH;</p>
<p>Le altcoin in generale hanno subito un ritracciamento, e attualmente non c’è un settore concentrato nel mercato. A novembre, la maggior parte degli altcoin è salita diverse volte, e aggiustamenti a breve termine sono inevitabili.</p>
<h2 id="h2-Macro20notizie20le20azioni20statunitensi20chiudono20in20calo20collettivo20i20trader20si20aspettano20che20i20tagli20dei20tassi20di20interesse20rallentino20lanno20prossimo9980"><a name="Macro notizie: le azioni statunitensi chiudono in calo collettivo, i trader si aspettano che i tagli dei tassi di interesse rallentino l’anno prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro notizie: le azioni statunitensi chiudono in calo collettivo, i trader si aspettano che i tagli dei tassi di interesse rallentino l’anno prossimo</h2><p>I tre principali indici del mercato azionario statunitense hanno chiuso in calo, con l’indice S&amp;P 500 che ha registrato una diminuzione dello 0,54% a 6.051,25 punti; il Dow Jones Industrial Average è sceso dello 0,53% a 43.914,12 punti; l’indice Nasdaq è sceso dello 0,66% a 19.902,84 punti. Il rendimento del titolo di Stato di riferimento decennale è del 4,32%, mentre il rendimento del titolo di Stato a 2 anni, che è più sensibile al tasso di politica della Federal Reserve, è del 4,18%.</p>
<p>Secondo un rapporto pubblicato giovedì dall’Ufficio di Statistica del Lavoro degli Stati Uniti, l’Indice dei prezzi alla produzione (PPI), che misura la domanda finale, è aumentato dello 0,4% su base mensile rispetto al mese precedente, segnando il più grande incremento da giugno. Il mercato si aspetta una crescita dello 0,2% su base mensile. Il PPI è aumentato significativamente del 3% su base annua, che è il più grande incremento da marzo 2023 e superiore alle aspettative del mercato pari al 2,6%.</p>
<p>Dopo la pubblicazione dei dati economici, i trader dei futures sui tassi di interesse si aspettano generalmente che la Federal Reserve riduca il tasso di interesse di riferimento di 25 punti base la prossima settimana. Gli analisti prevedono generalmente che dopo tre tagli consecutivi dei tassi di interesse, il ritmo dei tagli dei tassi di interesse l’anno prossimo rallenterà significativamente.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Icing</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; Un processo decisionale prudente è essenziale.<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, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>