RGFpbHkgTmV3cyB8IExhIGNvbnRyb3ZlcnNpYSBzdWxsYSBsZWdnZSBtYXJ6aWFsZSBpbiBDb3JlYSBkZWwgU3VkIGhhIHNjb252b2x0byBpIG1lcmNhdGk7IEJUQyDDqCBpbml6aWFsbWVudGUgc2Nlc28gZSBwb2kgw6ggc2FsaXRvLCBzdGFiaWxpenphbmRvc2kgaW50b3JubyBhICQ5Ni4wMDA=

2024-12-04, 03:37

<p><img src="https://gimg2.gateimg.com/image/article/173328338212.04.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20La20controversia20sulla20legge20marziale20in20Corea20del20Sud20ha20destabilizzato20i20mercati20BTC2020inizialmente20sceso20e20poi20risalito20stabilizzandosi20intorno20ai209600020dollari322863"><a name="Riassunto giornaliero: La controversia sulla legge marziale in Corea del Sud ha destabilizzato i mercati; BTC è inizialmente sceso e poi risalito, stabilizzandosi intorno ai 96.000 dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero: La controversia sulla legge marziale in Corea del Sud ha destabilizzato i mercati; BTC è inizialmente sceso e poi risalito, stabilizzandosi intorno ai 96.000 dollari</h2><p>La scorsa notte, la Corea del Sud <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ha subito una breve caduta a causa dell’annuncio della legge marziale del presidente Yoon Suk-yeol, facendo scendere il BTC a circa $63.000 e portando a significativi premi negativi in molte altcoin. Tuttavia, dopo il voto dell’Assemblea nazionale per revocare il divieto, le criptovalute hanno iniziato a riprendersi, con il BTC attualmente in aumento fino a circa $96.000 e le altcoin mostrano anche segni di ripresa.</p>
<h3 id="h3-Probabilit20del2070320che20la20Federal20Reserve20riduca20i20tassi20di20interesse20di202520punti20base20a20dicembre261810"><a name="Probabilità del 70,3% che la Federal Reserve riduca i tassi di interesse di 25 punti base a dicembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Probabilità del 70,3% che la Federal Reserve riduca i tassi di interesse di 25 punti base a dicembre</h3><p>Secondo lo strumento FedWatch del CME, la probabilità che la Federal Reserve mantenga i tassi di interesse attuali a dicembre è del 29,7%, mentre la probabilità di un taglio dei tassi di 25 punti base è del 70,3%.</p>
<h3 id="h3-Grayscale20Applica20per20Convertire20Solana20Trust20in20ETF971347"><a name="Grayscale Applica per Convertire Solana Trust in ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Grayscale Applica per Convertire <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Trust in ETF</h3><p>Grayscale e il New York Stock Exchange (NYSE) hanno presentato una richiesta 19b-4 alla SEC per convertire il Grayscale <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Trust (GSOL) in un ETF Solana. Inoltre, diverse domande di ETF Solana sono pronte ad affrontare il loro primo termine di revisione il 25 gennaio prossimo anno.</p>
<h3 id="h3-Ethereum20Foundation20annuncia20lelenco20delle20sovvenzioni20del20Q320le20sovvenzioni20totali20ammontano20a202012848820milioni193916"><a name="Ethereum Foundation annuncia l’elenco delle sovvenzioni del Q3, le sovvenzioni totali ammontano a $ 12,8488 milioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum Foundation annuncia l’elenco delle sovvenzioni del Q3, le sovvenzioni totali ammontano a $ 12,8488 milioni</h3><p>Nel terzo trimestre, il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La Fondazione ha allocato un totale di $12.8488 milioni a vari progetti, che coprono aree come l’educazione della comunità, il livello di consenso, la crittografia e le prove di conoscenza zero, l’esperienza degli sviluppatori e gli strumenti, il livello di esecuzione e il Layer 2.</p>
<h3 id="h3-South20Il20partito20al20governo20in20Corea20potrebbe20chiedere20le20dimissioni20di20Yoon20Sukyeol20propone20le20dimissioni20del20gabinetto20e20il20licenziamento20del20ministro20della20Difesa279921"><a name="South Il partito al governo in Corea potrebbe chiedere le dimissioni di Yoon Suk-yeol, propone le dimissioni del gabinetto e il licenziamento del ministro della Difesa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>South Il partito al governo in Corea potrebbe chiedere le dimissioni di Yoon Suk-yeol, propone le dimissioni del gabinetto e il licenziamento del ministro della Difesa</h3><p>Dopo la controversia sulla legge marziale, il Partito del Potere Popolare della Corea del Sud ha tenuto una riunione di emergenza il 4 dicembre per discutere le risposte alla decisione del presidente Yoon Suk-yeol di revocare la legge marziale. In precedenza, l’annuncio di Yoon della “legge marziale d’emergenza” era stato criticato dal rappresentante del partito Han Dong-hoon come un errore.</p>
<h3 id="h3-Fox20News20riferisce20Perianne20Boring20considerata20per20la20carica20di20presidente20della20CFTC905656"><a name="Fox News riferisce: Perianne Boring considerata per la carica di presidente della CFTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fox News riferisce: Perianne Boring considerata per la carica di presidente della CFTC</h3><p>Secondo quanto riferito da Fox News, Perianne Boring è stata presa in considerazione per la carica di presidente della Commodity Futures Trading Commission (CFTC) nell’amministrazione Trump.</p>
<p>Il reddito annualizzato di Curve negli ultimi 30 giorni si avvicina a $37 milioni, in aumento di quasi il 23% rispetto al mese scorso. I dati di Token Terminal mostrano che lo scambio decentralizzato Curve Finance ha raggiunto quasi $37 milioni di ricavi annuali negli ultimi 30 giorni, un aumento di quasi il 23% rispetto al mese precedente, attribuito alla crescente domanda di finanziamenti a leva e all’introduzione di nuove cassette di risparmio e del token scrvUSD.</p>
<p>Analisi di mercato: BTC ha ridotto le perdite e si è stabilizzato intorno a $96.000 con l’emergere di punti caldi di mercato localizzati.</p>
<p>Evidenziazioni di mercato:<br>-La recente controversia sulla legge marziale in Corea del Sud ha causato un breve declino in diverse criptovalute, ma questo incidente non ha significativamente appannato il sentiment ottimistico complessivo nel mercato a seguito delle elezioni negli Stati Uniti. <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ho visto una ripresa, mantenendo un ampio trend al rialzo, con settori come RWA, Layer 1, <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">Tron</a> ecosistema e iscrizioni che guidano i guadagni.</p>
<ul>
<li><a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> L’impennata di ‘ha aumentato il sentiment di mercato, portando ad un aumento dell’interesse per progetti consolidati con un alto market cap come AVAX, NEAR, <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, ONDO e HBAR, che hanno registrato un guadagno medio superiore al 30%.</li></ul>
<p>-Le speculazioni riguardanti il prossimo presidente della SEC hanno suscitato interesse per i token come RSR e DTF. La notizia che Trump ha scelto Paul Atkins come prossimo presidente della SEC - che in precedenza aveva consigliato il progetto RSR - ha inizialmente fatto aumentare il prezzo del RSR di oltre il 50%, ma il prezzo è sceso nuovamente quando è emerso che Atkins non era propenso ad accettare il ruolo. Nel frattempo, DTF, legato a RSR, è salito da $0,012 a $0,03, un aumento del 235%, prima di scendere di nuovo a $0,023. Inoltre, HBAR e <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> stanno attirando l’attenzione per i loro legami con altri candidati alla presidenza della SEC.</p>
<ul>
<li>I token meme come POPCAT, CHILLGUY, FARTCOIN e CLANKER hanno registrato guadagni significativi. Man mano che i fondi si sono spostati verso il trading di altcoin consolidate, l’impatto dei token meme sulla catena di blocco si è ridotto, con solo alcuni token meme popolari che mantengono un forte interesse.</li></ul>
<p>Tendenze di mercato:<br>-BTC ha ripreso sopra i $96.000. Dall’elezione di Trump nelle elezioni statunitensi del 5 novembre, sono stati prelevati più di 171.000 BTC dalle principali borse, con le riserve di scambio che sono scese a 2,46 milioni di BTC, il livello più basso degli ultimi anni. Di recente, l’afflusso netto di fondi negli ETF spot di BTC si è rallentato, mostrando segni di spostamento verso gli ETF spot di ETH.</p>
<p>-ETH sta vivendo una consolidazione ad alto livello, essendosi alzato sopra i $3.700 stamattina, riflettendo un aumento del 1,90% nelle ultime 24 ore. Gli afflussi netti negli ETF spot sono continuati per nove giorni lavorativi consecutivi, indicando che la crescita dell’ETH potrebbe scatenare un mercato rialzista delle altcoin.</p>
<p>-La dominanza del mercato BTC è leggermente diminuita, ma le altcoin continuano a salire, con le iscrizioni e i token dell’ecosistema <a href="/price/tron-trx" target="_blank" class="blog_inner_link">Tron</a> che mostrano le tendenze al rialzo più forti; l’aumento di TRX in 24 ore ha raggiunto il 77,98%, raggiungendo un nuovo massimo storico.</p>
<h2 id="h2-Notizie20Macro20a20seguito20della20controversia20sulla20legge20marziale20in20Corea20del20Sud20il20mercato20delle20criptovalute2020continuato20a20salire9821"><a name="Notizie Macro: a seguito della controversia sulla legge marziale in Corea del Sud, il mercato delle criptovalute è continuato a salire." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Notizie Macro: a seguito della controversia sulla legge marziale in Corea del Sud, il mercato delle criptovalute è continuato a salire.</h2><p>La scorsa notte, l’annuncio della legge marziale ha portato a un flash crash nel mercato delle criptovalute sudcoreane, con conseguenti forti sconti negativi in numerosi coppie di negoziazione. Tuttavia, con il voto dell’Assemblea nazionale per revocare il divieto, il mercato si è stabilizzato, anche se il mercato azionario coreano ha aperto con una caduta di quasi il 2% e il won ha raggiunto un nuovo minimo.</p>
<p>Le azioni statunitensi hanno chiuso in modo misto, ma il trend generale rimane una costante salita, riflettendo il sentiment di mercato guidato dalle crescenti aspettative di un taglio dei tassi a dicembre, come indicato da diversi funzionari della Federal Reserve. Attualmente, la probabilità di un taglio dei tassi di 25 punti base a dicembre è del 70,3%.</p>
<p>Inoltre, è importante notare che si prevede che Trump annuncerà oggi il prossimo presidente della SEC, anche se sembra che Paul Atkins, il candidato preferito per la posizione, potrebbe non essere disposto ad accettarla. Secondo il mercato delle previsioni Kalshi, la probabilità che Atkins diventi il prossimo presidente della SEC è aumentata. Il nuovo presidente della SEC avrà un impatto significativo sulla regolamentazione delle criptovalute e continueremo a monitorare questo sviluppo importante.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Charle Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Sally<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; la presa di decisioni oculate è essenziale.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripostare l'articolo a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>