V2ViMyBSaWNlcmNhIFNldHRpbWFuYWxlIHwgUXVlc3RhIHNldHRpbWFuYSwgaWwgbWVyY2F0byDDqCBkaW1pbnVpdG8gY29tcGxlc3NpdmFtZW50ZSBhIGNhdXNhIGRlbCB0YWdsaW8gZGVpIHRhc3NpIGRpIGludGVyZXNzZSBkZWxsYSBGZWRlcmFsIFJlc2VydmU7IGxhIGRvbWluYW56YSBkaSBFdGhlcmV1bSBzdWwgbWVyY2F0byDDqCB

2024-12-20, 09:09

<p><img src="https://gimg2.gateimg.com/image/article/17346857181692587604touyanzhoubao.jpeg" alt=""></p>
<h2 id="h2-Panoramica20Settimanale688261"><a name="Panoramica Settimanale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica Settimanale</h2><p>Questa settimana, la <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> complessivamente ha registrato un calo, entrando in una fase di correzione di mercato. La maggior parte delle principali criptovalute è stata influenzata da fattori esterni, con prezzi in aumento all’inizio della settimana, solo per sperimentare un brusco calo a metà settimana. Finora non c’è stata alcuna segnalazione di ripresa. La volatilità di mercato ha portato a evidenti cali nella capitalizzazione di mercato, e il sentiment è significativamente diminuito.</p>
<p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>(BTC) ha subito un calo continuo, scendendo a circa $96.500 da un picco di circa $108.000. Nel complesso, le principali criptovalute sono in una tendenza al ribasso e sembra probabile che il mercato subirà ulteriori cali nel breve termine. L’indice di sentiment di mercato è sceso a 69 e potrebbe continuare a diminuire nel fine settimana. La capitalizzazione di mercato totale del <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ha registrato un significativo calo rispetto allo stesso periodo della settimana scorsa, ora intorno a $3,32 trilioni, in calo del 5,8% nelle ultime 24 ore.<br>Rispetto alla settimana scorsa, questa settimana <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ha mostrato un ulteriore declino, con le principali criptovalute che hanno sperimentato un forte calo a breve termine, trascinando il mercato nel complesso verso il basso. BTC è tornato al suo recente range di prezzo inferiore di circa $95,000, mentre ETH è sceso nel range $3,300-$3,400.</p>
<p>Il calo complessivo del mercato è principalmente dovuto a fattori esterni, specialmente dopo che la Federal Reserve ha abbassato il tasso di interesse chiave di politica di 25 punti base e ha lasciato intendere che i futuri tagli dei tassi potrebbero rallentare. Questo ha causato un crollo dei prezzi delle principali criptovalute come BTC ed ETH, provocando un calo complessivo del mercato. Di conseguenza, la maggior parte delle criptovalute più performanti di questa settimana ha registrato guadagni relativamente modesti, con solo la memecoin PENGU che ha registrato un aumento superiore al 400%.</p>
<p>Questo fine settimana, c’è una probabilità più alta che il mercato continui la sua correzione al ribasso, anche se potremmo vedere piccole fluttuazioni con poche possibilità di un forte recupero nel breve termine.</p>
<h2 id="h2-Mercato20delle20criptovalute95531"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥 Nel 2024 <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> mercato toro, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> non ha tenuto il passo con il momentum di Bitcoin. La dominanza di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> è salita dal 50% al 61% ma è poi scesa al 54%, mentre la dominanza di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è diminuita nettamente dal 18% al 12%.</p>
<p>🔥 Il 16 dicembre, Vana, una rete decentralizzata di liquidità dati AI, ha ufficialmente lanciato la sua mainnet e introdotto la funzione di staking VANA.</p>
<p>🔥 Secondo i dati di GameFiHub del 14 dicembre, i primi tre <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> I progetti di gioco basati sono:<br>GMT ( <a href="/price/stepn-gmt" rel="nofollow noopener noreferrer" target="_blank">STEPN</a>): Capitalizzazione di mercato di $591.27 mila<br>Metaplex (MPLX): Capitalizzazione di mercato di $233.24 mila<br>Crown (di ThirdTimeGames): Capitalizzazione di mercato di $103.19 mila</p>
<p>🔥 MarkLongo (@Squirrel_Dad12), il proprietario del popolare meme scoiattolo Peanut, ha inviato una lettera di cessazione e desistenza a Binance tramite il suo studio legale.</p>
<p>🔥 Il vicepresidente di Galaxy Research, Christine Kim, ha riassunto il 147° <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Chiamata Consenso Sviluppatore Core (ACDC).</p>
<p>🔥Secondo i dati di Infinite Market Cap, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il prezzo di mercato di ‘è salito sopra i $4.000 questa settimana, con la sua capitalizzazione di mercato che ha raggiunto i $482,64 miliardi e un aumento del 3,86% nelle ultime 24 ore. Tuttavia, è rapidamente sceso dopo.</p>
<p>🔥 L’analista on-chain @ai_9684xtpa riferisce che l’indirizzo WorldLiberty associato a Trump ha acquistato asset non stabili, inclusi <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a>, ENA e ONDO. La metà di questi asset appartiene alle principali applicazioni DeFi, mentre l’altra metà sono token di asset nel mondo reale (RWA).</p>
<p>🔥 Secondo CoinDesk, dopo che la piattaforma di trading NFT OpenSea ha registrato un’entità nelle Isole Cayman, hanno cominciato a circolare voci che potrebbe essere in preparazione per un token airdrop.</p>
<p>🔥 IntoTheBlock ha riportato che <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>(ETH) è tornato sopra i $4.000 questa settimana, con l’acquisto di 7,2 milioni di ETH appena al di sotto dell’intervallo di prezzo di $4.000, indicando una forte domanda di mercato.</p>
<p>🔥 The Block ha riportato che <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Valanga</a> ha lanciato l’aggiornamento Avalanche9000, che riduce significativamente il costo di distribuzione delle subnet blockchain e l’esecuzione di smart contract, ottimizzando il modello di convalida. La tariffa di base per la C-chain è stata ridotta da 25 nAVAX a 1 nAVAX.</p>
<p>🔥 Il 17 dicembre, Monad ha annunciato la fondazione di Monad Foundation, che si concentrerà sulla promozione della governance basata sui validatori, delle proposte di miglioramento della comunità, della documentazione degli sviluppatori e dello sviluppo dell’ecosistema.</p>
<p>🔥 Il 18 dicembre hanno circolato voci secondo cui MicroStrategy (MSTR) potrebbe entrare in un periodo di blocco nel gennaio 2025, durante il quale sospenderebbe l’emissione di azioni e obbligazioni convertibili tramite offerte “at-the-market” (ATM) per raccogliere fondi per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> acquisti.<br>🔥 Secondo le pagine pertinenti, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> i membri della comunità hanno respinto una proposta preliminare (pre-PIP) inizialmente avanzata da <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Il fornitore di rischi AllezLabs, in collaborazione con i protocolli DeFi Morpho e Yearn, per sfruttare circa $1.3 miliardi in riserve DAI, USDC e USDT sul ponte PoSChain per la generazione di rendimento.</p>
<p>🔥 I dati di Lookonchain rivelano che BlackRock ha <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’ETF, iShares Ethereum Trust ETF, detiene attualmente oltre 1 milione di ETH, pari a 1.025.378 ETH (circa 4,04 miliardi di dollari).</p>
<p>🔥 Secondo Cryptoslate, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> Il fondatore Charles Hoskinson ha pubblicato sui social media X il 18 dicembre, chiedendo il <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> La Fondazione si trasferirà in una giurisdizione che consente agli utenti di eleggere i membri del consiglio. Ha anche incoraggiato il <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> comunità per informarsi sulla struttura del consiglio direttivo della fondazione e sul processo decisionale.</p>
<p>🔥 Il 18 dicembre, il rapporto del lunedì di Galaxy Research ha indicato che il mercato NFT sta mostrando segni di ripresa.</p>
<p>🔥 Il titolo di MicroStrategy (MSTR) è salito del 546% quest’anno, con un valore di mercato di $99,4 miliardi. La principale ragione di questa impennata è la detenzione da parte dell’azienda di 439.000 BTC.</p>
<p>🔥 Secondo Cointelegraph, il 10% dei validatori di Ethereum ha espresso il proprio sostegno all’aumento del limite di gas in un singolo blocco di Ethereum a 30 milioni. Il core developer di Ethereum, Eric Connor, ha menzionato che questo potrebbe ridurre le commissioni di transazione del 15% al 33%.</p>
<p>🔥 <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.com ha riportato che l’ultima ricerca serale NFT mostra che dopo <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Quando il prezzo di ’s ha superato i $100.000, sono stati creati 14.211 nuovi milionari e 4 nuovi miliardari.</p>
<p>🔥 Sonic Labs ha annunciato il X che “Sonic Gateway sarà lanciato nei prossimi giorni, permettendo agli utenti di collegare USDC, EURC e WETH da Ethereum a Sonic.”</p>
<p>Il co-fondatore e presidente di MicroStrategy, Michael Saylor, in un’intervista, ha affermato che una volta esaurito il piano di raccolta fondi attuale, l’azienda passerà dall’esposizione a Bitcoin con leva finanziaria a concentrarsi maggiormente su titoli a reddito fisso per raccogliere fondi per l’acquisto di criptovalute.</p>
<p>🔥 Secondo i dati di Artemis, il 17 dicembre, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ha gestito 66,9 milioni di transazioni, superando il numero totale di transazioni su altre blockchain principali. In termini di partecipazione degli utenti, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ha rappresentato più della metà degli indirizzi attivi giornalieri tra le principali piattaforme blockchain durante lo stesso periodo.</p>
<p>🔥 10x Research ha pubblicato un rapporto affermando che sebbene il tono del presidente della Federal Reserve Jerome Powell si prevede che sia leggermente falco, la previsione aggiornata del tasso di interesse mediano della Fed ha sconvolto il mercato. La previsione suggerisce aumenti dei tassi di interesse non solo nel 2025 ma anche nel 2026 e nel 2027.</p>
<p>🔥 Secondo un recente rapporto di Glassnode, il mercato rialzista in corso di Bitcoin segna un importante spostamento di ricchezza dai detentori a lungo termine ai nuovi investitori, segnalando la maturità del mercato.</p>
<h2 id="h2-Regolamentazione20e20politica20macroeconomica45622"><a name="Regolamentazione e politica macroeconomica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regolamentazione e politica macroeconomica</h2><p>🔥 Il 17 dicembre, Phoenix News ha riportato che le 21Shares <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Trust Fund ha completato la sua registrazione nel Delaware, USA. Il nome registrato è “21Shares”. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>“Fiducia”, e l’agente registrato è CSC Delaware Trust Company.</p>
<p>🔥 Il 17 dicembre, FTX ha annunciato che il suo piano di riorganizzazione ai sensi del capitolo 11 approvato dal tribunale entrerà in vigore il 3 gennaio 2025, con la prima data di allocazione fissata per quel giorno. La prima distribuzione è prevista entro 60 giorni dalla data di efficacia e si applicherà alle richieste approvate nella classe di comodità.</p>
<p>🔥 Nate Geraci, Presidente di The ETF Store, ha pubblicato su X, affermando che Invesco (il quarto più grande emittente di ETF) oggi ha presentato molteplici domande di struttura di classe azionaria presso la SEC degli Stati Uniti. Quasi 40 società di fondi stanno cercando questa iterazione di struttura. Si prevede che diventerà la narrazione degli ETF più calda del 2025, insieme ad altri ETF di criptovalute spot.</p>
<p>🔥 L’analista degli ETF di Bloomberg, James Seyffart, ha dichiarato che l’approvazione della SEC <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> ETFs è stato ritardato e sarà rivalutato una volta che la nuova gestione della SEC prenderà ufficio. Le questioni legali devono essere risolte prima dell’approvazione.</p>
<h2 id="h2-Crypto20Market20Highlights547642"><a name="Crypto Market Highlights:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Market Highlights:</h2><p>⭐️ Nella scorsa settimana, <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ha registrato un calo significativo, entrando in una fase ribassista più definita. Questo declino è stato in gran parte determinato da fattori esterni, in particolare dalla decisione della Federal Reserve di abbassare i tassi di interesse, il che ha portato a cambiamenti nel sentiment di mercato. Mentre il fine settimana si avvicina, il mercato rimane in uno stato di declino oscillante, con ulteriori movimenti al ribasso previsti. C’è poco probabilità di un rimbalzo nel breve termine e il mercato continua a mostrare segni di ulteriori correzioni.</p>
<p>⭐️ A causa del generale calo del mercato di questa settimana, la crescita delle principali criptovalute è stata relativamente limitata. Rispetto alle settimane precedenti, gli aumenti di prezzo delle migliori monete sono stati più modesti. Tuttavia, la memecoin PENGU si è distinta come il maggior guadagno della settimana, con un’impennata del 471,68%. Questo picco è stato principalmente determinato dal lancio recente della moneta e da un rally di breve termine. PENGU ha raggiunto un massimo settimanale di $0,05063, ma è poi corretta a circa $0,026.<br><img src="https://gimg2.gateimg.com/image/article/17346904281.png" alt=""></p>
<h2 id="h2-Prestazioni20settimanali20di20Bitcoin20ed20Ethereum748603"><a name="Prestazioni settimanali di Bitcoin ed Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestazioni settimanali di Bitcoin ed Ethereum</h2><h3 id="h3-Bitcoin20BTC463780"><a name="Bitcoin (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/17346904092.png" alt=""><br>(fonte: TradingView)</p>
<p>Questa settimana, Bitcoin (BTC) ha subito una significativa diminuzione del prezzo, largamente influenzata da fattori esterni. A metà settimana, BTC ha visto una continua correzione al ribasso dopo aver raggiunto un picco vicino a $110.000. Il prezzo è poi bruscamente sceso, toccando un minimo inferiore a $96.000. Attualmente, BTC sta scambiando all’interno di un nuovo range di $96.000-$98.000. La causa principale di questa inversione di tendenza è stata l’impatto dei fattori di mercato esterni, in particolare il taglio dei tassi di interesse della Federal Reserve, che ha influenzato il sentiment del mercato più ampio. Ciò, unito a una serie di liquidazioni di posizioni lunghe, ha scatenato ulteriore pressione al ribasso sui prezzi di BTC.</p>
<p>Gli analisti ritengono che il movimento dei prezzi di BTC questa settimana sia stato principalmente determinato dalla reazione complessiva del mercato alla politica dei tassi di interesse della Fed. Le liquidazioni all’interno del mercato BTC hanno anche portato a perdite significative e hanno contribuito a una brusca diminuzione del prezzo. Nonostante la significativa caduta, BTC si mantiene ancora all’interno di un range di prezzo relativamente stabile, indicando una certa resilienza. Attualmente, il mercato sembra lottare per una ripresa, con BTC che mostra pochi segnali di una forte spinta al rialzo nel breve termine.</p>
<h3 id="h3-Ethereum20ETH758803"><a name="Ethereum (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum (ETH)</h3><p><img src="https://gimg2.gateimg.com/image/article/17346903943.png" alt=""><br>(Fonte: TradingView)</p>
<p>Ethereum (ETH) ha seguito una tendenza simile al prezzo di Bitcoin (BTC) questa settimana, anche se l’aggiustamento del prezzo per ETH è stato relativamente più piccolo. Rispetto alla settimana precedente, ETH ha brevemente raggiunto oltre i $4000, ma con la tendenza al ribasso del mercato più ampio a metà settimana, ETH ha subito un costante declino, compresa una serie di correzioni a breve termine. Il punto più basso per ETH questa settimana è sceso a $3300 e attualmente il prezzo si mantiene intorno a $3430. ETH ha registrato un calo settimanale di circa l’11,65%. Al momento, ETH si trova in una fase di continue fluttuazioni minori, con l’aspettativa di ulteriori movimenti di prezzo nel weekend. Tuttavia, la probabilità di un significativo rimbalzo nel breve termine appare bassa, date le attuali condizioni di mercato.</p>
<h2 id="h2-Tendenze20del20progetto20Web3946800"><a name="Tendenze del progetto Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze del progetto Web3</h2><p>Questa settimana, la maggior parte <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> I progetti hanno subito notevoli cali di valore di mercato, in linea con la tendenza del mercato generale. Man mano che ci avviciniamo al fine settimana, c’è una maggiore probabilità di ulteriori movimenti al ribasso, con poche possibilità di un importante rimbalzo dei prezzi.<br><img src="https://gimg2.gateimg.com/image/article/173469116720241220-182826.jpeg" alt=""></p>
<div class="blog-details-info"><br><div>Autore:<strong> icing</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; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ri-pubblicare dell'articolo a condizione che venga citato 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>