Tm90aXppZSBxdW90aWRpYW5lIHwgV0xEIGhhIGd1aWRhdG8gaWwgc2V0dG9yZSBkZWxsJ0lBIHZlcnNvIHVuIGF1bWVudG8gY29sbGV0dGl2bywgQUxHTyDDqCBhdW1lbnRhdG8gZGkgb2x0cmUgaWwgMjAwJSBuZWwgbWVzZQ==

2024-11-29, 04:53

<p><img src="https://gimg2.gateimg.com/image/article/173285586711.29.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Oltre20il209020dei20detentori20di20ETH20ottengono20profitti20la20vittoria20alle20elezioni20di20Trump20stimola20notevolmente20il20possesso20di20Bitcoin647391"><a name="Crypto Daily Digest: Oltre il 90% dei detentori di ETH ottengono profitti, la vittoria alle elezioni di Trump stimola notevolmente il possesso di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Oltre il 90% dei detentori di ETH ottengono profitti, la vittoria alle elezioni di Trump stimola notevolmente il possesso di Bitcoin</h2><p>Ieri la borsa statunitense è stata chiusa per il Ringraziamento e non c’è stato alcun flusso di fondi negli ETF spot.</p>
<p><strong>IntoTheBlock: Attualmente il 90,8% dei detentori di ETH è in profitto</strong></p>
<p>IntoTheBlock ha pubblicato che il 90,8% dei detentori di ETH è attualmente in profitto, il livello più alto da giugno.</p>
<p>Il 9,2% dei detentori di ETH si trova ancora in uno stato di perdita, con i loro token che rappresentano solo il 2,8% dell’offerta totale. Ciò indica che, mentre ETH continua a salire, la potenziale pressione venditrice da questo gruppo potrebbe avere un impatto limitato.”</p>
<p><strong>CEO di CryptoQuant: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> la dominanza improbabile di diminuire rapidamente</strong></p>
<p>Il CEO di CryptoQuant, Ki Young Ju, ha dichiarato in un post che, considerando il suo tasso di crescita, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La dominanza di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è improbabile che diminuisca rapidamente. Durante l’aumento del 37% della capitalizzazione di mercato di Bitcoin, le Altcoin di grande capitalizzazione sono aumentate del 16%, mentre le Altcoin di piccole e medie capitalizzazioni sono aumentate del 10%. L’unico momento in cui le Altcoin di piccole e medie capitalizzazioni hanno superato la crescita della capitalizzazione di mercato di Bitcoin è stato durante la stagione dei Meme in aprile.</p>
<p><strong>Dalla vittoria elettorale di Trump, l’interesse aperto nei futures Bitcoin è aumentato significativamente, superando i 60 miliardi di dollari</strong></p>
<p>Secondo The Block, dallo spoglio delle elezioni di Trump il 5 novembre, l’interesse aperto nei futures di Bitcoin è aumentato significativamente, passando da 39 miliardi di dollari il 5 novembre a 60,9 miliardi di dollari attuali, indicando un aumento dell’attività di trading e delle speculazioni di mercato. Ma gli analisti ritengono che il trading con leva non affronterà il rischio di una correzione di mercato imminente.</p>
<p>Gli analisti sostengono che l’aumento degli interessi aperti dei futures sembra essere una crescita naturale, guidata dalle aspettative di apprezzamento futuro dei prezzi. L’accumulo di leva è uno strumento comune utilizzato dai trader, comprese le istituzioni, per pianificare le tendenze dei prezzi attese.</p>
<p>Ha inoltre sottolineato che al 22 novembre il numero di futures aperti è diminuito, specialmente al livello intorno ai $94.000, con un gran numero di ordini pendenti eseguiti. E ha affermato di ritenere che non vi sia anormalità nell’accumulo recente di leva finanziaria e che il backtesting del prezzo nell’area dei $93.000 sia una correzione normale.</p>
<h2 id="h2-Tendenze20del20mercato20il20settore20dellintelligenza20artificiale2020cresciuto20collettivamente20con20la20consolidata20catena20pubblica20ALGO20che20ha20registrato20un20aumento20mensile20di20oltre20il20200822368"><a name="Tendenze del mercato: il settore dell’intelligenza artificiale è cresciuto collettivamente, con la consolidata catena pubblica ALGO che ha registrato un aumento mensile di oltre il 200%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze del mercato: il settore dell’intelligenza artificiale è cresciuto collettivamente, con la consolidata catena pubblica ALGO che ha registrato un aumento mensile di oltre il 200%</h2><h3 id="h3-Punti20Caldi20del20Mercato775360"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Il settore dell’AI ha registrato un aumento collettivo di WLD, FET, THETA e altro ancora. L’applicazione Worldcoin ha oltre 17 milioni di utenti globali di verifica dell’iride, con WLD che attualmente ha una capitalizzazione di mercato circolante di $1,8 miliardi e una capitalizzazione di mercato circolante totale di $26 miliardi. Inoltre, decine di milioni di dollari in token vengono sbloccati quotidianamente; Resta da osservare in che misura WLD possa salire con il supporto della narrazione dell’AI e dell’alta FDV a bassa circolazione;</p>
<p>La ben consolidata catena pubblica ALGO è cresciuta del 20%, con ALGO che è aumentato di oltre il 200% da inizio novembre; Il team ALGO è stato fondato nel 2017 e il token è stato emesso nel 2019, con un prezzo storico massimo di $3.44. Attualmente, il prezzo è sceso del 90% rispetto al punto massimo storico; Nel punto caldo della traccia della catena pubblica sul mercato, ALGO ha ottenuto un aumento di 20 volte nel precedente mercato rialzista, con una capitalizzazione di mercato circolante attuale di $2.85 miliardi, e il potenziale al rialzo è stimato essere limitato.</p>
<h3 id="h3-Monete20principali454777"><a name="Monete principali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Monete principali</h3><p>BTC si sta consolidando in modo stretto e sta ancora aspettando un’opportunità per superare i 96.000 dollari, poiché non c’è afflusso di capitali nell’ETF BTC durante le vacanze del Ringraziamento nel mercato azionario statunitense;</p>
<p>ETH ha subito una leggera diminuzione, mantenendosi sopra i $3.550 e ricevendo un forte supporto nella media mensile, indicando un futuro promettente per ETH;</p>
<p>Le altcoin sono generalmente aumentate, ma i punti caldi sono dispersi e il settore dell’IA rimane una delle principali narrazioni nel mercato.</p>
<h2 id="h2-Notizie20macro20mercato20azionario20statunitense20chiuso20per20il20Ringraziamento20senza20dati20o20opinioni20aggiornate20sul20mercato575647"><a name="Notizie macro: mercato azionario statunitense chiuso per il Ringraziamento, senza dati o opinioni aggiornate sul mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie macro: mercato azionario statunitense chiuso per il Ringraziamento, senza dati o opinioni aggiornate sul mercato</h2><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; è essenziale prendere decisioni prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>