Tm90aXppZSBxdW90aWRpYW5lIHwgU3RhZ2lvbmUgZGkgQWx0Y29pbiBpbiBwaWVubyBzdm9sZ2ltZW50bywgSGlwcG8gTU9PREVORyBhdW1lbnRhIGRpIG9sdHJlIGlsIDEwMCUgbmVsbCdpbnRyYWRheQ==

2024-12-03, 07:16

<h2 id="h2-Crypto20Daily20Digest20Ingresso20di20350M20in20BTC20ETF20Altcoin20in20Aumento20Diffuso212981"><a name="Crypto Daily Digest: Ingresso di $350M in BTC ETF, Altcoin in Aumento Diffuso." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Ingresso di $350M in BTC ETF, Altcoin in Aumento Diffuso.</h2><p>Secondo i dati di Farside Investor, gli ETF BTC spot negli Stati Uniti hanno registrato un afflusso netto di $353M ieri. Tra questi, IBIT di BlackRock è stato il leader con $338M, mentre FBTC di Fidelity ha registrato un afflusso di $25.1M.</p>
<p>Domenica, U.S. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot hanno registrato un afflusso di $24,2M. ETHA di BlackRock ha guadagnato $5,59M, FETH di Fidelity ha guadagnato $1,99M, mentre ETHE di Grayscale ha registrato un deflusso di $4,44M.</p>
<h3 id="h3-Limpennata20recente20di20LTC20mette20in20profitto20quasi20l8020dei20detentori503933"><a name="L’impennata recente di LTC mette in profitto quasi l’80% dei detentori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’impennata recente di LTC mette in profitto quasi l’80% dei detentori</h3><p>Secondo i dati di mercato di Gate.io, LTC è salito oltre il 27% nella scorsa settimana, aumentando significativamente il numero di indirizzi redditizi.</p>
<p>I dati di IntoTheBlock mostrano che a metà novembre circa il 60% dei detentori di LTC aveva un profitto. Entro il 2 dicembre questa percentuale era salita al quasi 80%, con oltre 6,37 milioni di indirizzi LTC (circa il 79,37%) attualmente in profitto, come mostrano le metriche di ingresso/uscita.</p>
<h3 id="h3-Prospettiva20Volume20di20mercato20delle20criptovalute20in20Corea20in20forte20aumento20Attenzione20agli20altcoin821561"><a name="Prospettiva: Volume di mercato delle criptovalute in Corea in forte aumento; Attenzione agli altcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prospettiva: Volume di mercato delle criptovalute in Corea in forte aumento; Attenzione agli altcoin</h3><p>Secondo l’ultimo rapporto di 10X Research, dalla elezione di Trump sono avvenuti cambiamenti significativi nell’attività di trading. Sebbene la sua inaugurazione sia ancora a sette settimane di distanza, le prime nomine indicano un significativo spostamento verso politiche amichevoli alle criptovalute nel governo degli Stati Uniti. Ci si aspetta che questa tendenza continui, espandendo potenzialmente le opportunità di trading.</p>
<p>Anche i governi di altri paesi, in particolare la Corea del Sud, stanno adottando posizioni più amichevoli nei confronti delle criptovalute. Poiché gli Stati Uniti sono in testa nel definire le tendenze normative delle criptovalute (o nel facilitare le regolamentazioni), ci si aspetta che seguirà una ondata globale di politiche amichevoli verso le criptovalute. I token cripto più piccoli, inclusi i token alpha, potrebbero continuare a crescere.</p>
<p>Nelle ultime 24 ore, il volume di trading al dettaglio in Corea del Sud <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> è salito a $ 18 miliardi, segnando il secondo volume di trading più alto di quest’anno, superando il volume di trading di $ 14 miliardi del mercato azionario locale. Ripple ( <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>) guidato da un volume di $6,3 miliardi, seguito da DOGE ($1,6 miliardi), XLM ($1,3 miliardi), ENS ($900 milioni), HBAR ($800 milioni) e SHIB ($600 milioni). Queste criptovalute ad alta volatilità sono principalmente guidate dai trader al dettaglio, sfruttando e rafforzando le tendenze basate sul momentum.</p>
<p>I tassi di finanziamento BTC rimangono relativamente miti, annualizzati al 15%, mentre il volume di trading al dettaglio in Corea del Sud è aumentato a 18 miliardi di dollari - una differenza storica. Chiaramente, l’attuale focus del mercato è sugli altcoin.</p>
<h3 id="h3-Fed20Hawk20Waller20Inclinato20a20sostenere20un20taglio20dei20tassi20a20dicembre53154"><a name="Fed Hawk Waller: Inclinato a sostenere un taglio dei tassi a dicembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fed Hawk Waller: Inclinato a sostenere un taglio dei tassi a dicembre</h3><p>Il governatore della Federal Reserve, Christopher Waller, ha dichiarato di essere inclinato a sostenere un taglio dei tassi nel meeting della Fed previsto per questo mese. Tuttavia, ha anche osservato che rimane aperto a mantenere i tassi.</p>
<p>In un discorso preparato per la conferenza di Washington di lunedì, Waller ha dichiarato: “La politica rimane sufficientemente restrittiva. Un ulteriore taglio dei tassi alla prossima riunione non cambierà significativamente l’orientamento della politica monetaria e lascia ampio margine per rallentare il ritmo dei tagli, se necessario, per rimanere sul percorso verso l’obiettivo dell’inflazione.”<br>Waller ha espresso preoccupazione per il fatto che i dati sull’inflazione siano leggermente più alti del previsto nei due mesi scorsi. Si è paragonato a un artista marziale misto che “soffoca l’inflazione, aspettando che si arrenda, ma scivola sempre via all’ultimo momento.” Ha sottolineato che la Fed non permetterà all’inflazione di accelerare nuovamente. “La resa è inevitabile; l’inflazione non è ancora scappata dall’ottagono,” ha detto. Nonostante la recente ostinazione dell’inflazione, i dati economici e le previsioni indicano che l’inflazione tornerà all’obiettivo del 2% della Fed.</p>
<h2 id="h2-Analisi20di20mercato20MOODENG20Voler20Oltre20il2010020Intraday20Il20Leader20Oracle20LINK20Sale20del2040151854"><a name="Analisi di mercato: MOODENG Volerà Oltre il 100% Intraday; Il Leader Oracle LINK Sale del 40%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi di mercato: MOODENG Volerà Oltre il 100% Intraday; Il Leader Oracle <a href="/price/link-ln" target="_blank" class="blog_inner_link">LINK</a> Sale del 40%</h2><h3 id="h3-Punti20salienti20di20mercato309304"><a name="Punti salienti di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti salienti di mercato:</h3><p>-MOODENG, un token meme, è schizzato oltre il 100% intraday, salendo da $0.295 a $0.68 la scorsa notte. MOODENG, ispirato al meme dell’ippopotamo della Thailandia, ha attualmente una capitalizzazione di mercato circolante di $620M, classificandosi al 211º posto a livello globale, con un significativo potenziale di crescita.</p>
<ul>
<li><a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> Il protocollo oracle leader, , ha registrato un aumento superiore al 40%, superando la soglia dei $15 miliardi di capitalizzazione di mercato e posizionandosi al 24º posto a livello globale. Come protocollo indispensabile per i progetti DeFi, il recupero del prezzo di LINK in questo rally potrebbe segnalare una potenziale ripresa nel settore DeFi.<h3 id="h3-Tendenze20generali20del20mercato961892"><a name="Tendenze generali del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze generali del mercato:</h3>-BTC: È sceso brevemente al di sotto dei $94.500 questa mattina, ma si è ripreso sopra i $96.000. BTCD continua a diminuire e BTC potrebbe consolidarsi per un po’ di tempo.</li></ul>
<p>-ETH: ha seguito BTC con lievi ribassi, ma l’ecosistema ETH e i progetti DeFi sono in rialzo.</p>
<p>-Altcoins: In generale in aumento come fondi <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> entrando nel settore, con i token meme e i progetti DeFi in testa.</p>
<h2 id="h2-Notizie20Macro20Performance20mista20del20mercato20azionario20statunitense20Opinioni20divise20sulla20politica20dei20tassi20della20Fed342875"><a name="Notizie Macro: Performance mista del mercato azionario statunitense; Opinioni divise sulla politica dei tassi della Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie Macro: Performance mista del mercato azionario statunitense; Opinioni divise sulla politica dei tassi della Fed</h2><p>Il mercato azionario statunitense ha mostrato una performance mista:</p>
<p>-S&amp;P 500 è salito dello 0,24% a 6047,15 punti.</p>
<p>-Il Dow è sceso dello 0,29% a 44782,00 punti.</p>
<p>-Nasdaq ha guadagnato lo 0,97% a 19403,95 punti.</p>
<p>Il rendimento del titolo del Tesoro decennale di riferimento era al 4,19%, mentre il rendimento del titolo a 2 anni, che è più sensibile ai tassi di politica della Fed, si attestava al 4,17%.</p>
<p>Il taglio dei tassi della Fed di 25 punti base a novembre ha portato il tasso di riferimento al 4,5%-4,75%. Tuttavia, i verbali dell’ultima riunione hanno attenuato il sentimento di mercato, suggerendo che il percorso di taglio dei tassi potrebbe presto fermarsi.</p>
<p>Questo secondo taglio dei tassi dell’anno pari a 75 punti base, riportando il tasso di riferimento al suo livello di febbraio 2023. C’è una significativa disaccordo di mercato su se la Fed continuerà a tagliare i tassi a dicembre.</p>
<p>Nick Timiraos, il “Fed Whisperer”, ha osservato che i funzionari hanno discusso delle opzioni per rallentare o sospendere i tagli ai tassi. Il rappresentante falco Kashkari ha sostenuto che un taglio di 25 punti base a dicembre sarebbe ragionevole ma ha sottolineato le preoccupazioni sull’inflazione. Il rappresentante colomba Goolsbee si aspetta che la Fed continui a tagliare i tassi a meno che non emergano prove di surriscaldamento dell’economia.</p>
<div class="blog-details-info"><br><div>Autore:<strong> icing </strong>, Ricercatore di Gate.io<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, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>