SWwgbWVyY2F0byBkZWkgdG9yaSByaXNvcmdlLCBhbmFsaXp6YSBsYSBzYmFsb3JkaXRpdmEgdGVuZGVuemEgYWwgcmlhbHpvIGRpIHF1ZXN0YSBmYXNl

2024-11-11, 08:12

<p><img src="https://gimg2.gateimg.com/image/article/17313123351692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR450179"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha recentemente stabilito un nuovo record storico, superando per la prima volta i $80.000.</p>
<p>Dalla volatilità del settore delle Altcoin, Meme rimane l’unico a guidare i guadagni, mentre GameFi, DeFi, AI e altri settori hanno visto aumenti significativi, diventando argomenti caldi di recente.</p>
<p>Da un punto di vista storico, in generale, dopo il <a href="/explore/bitcoin-halving-countdown" rel="nofollow noopener noreferrer" target="_blank">Bitcoin halving</a> Durante l’evento, il quarto trimestre di solito si comporta bene.</p>
<h2 id="h2-Introduzione639854"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Approfittando della vittoria di Trump nelle attuali elezioni presidenziali negli Stati Uniti, il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> recentemente ha intrapreso una nuova forte tendenza al rialzo.</p>
<p>Sullo sfondo di un aumento generale del mercato, vari settori sono saliti e hanno continuato a salire, e l’indice dell’avidità ha raggiunto un nuovo massimo, che è stato abbagliante per un certo periodo. Questo ha confermato la nostra visione rialzista nell’articolo “ <a href="https://www.gate.io/blog/4689/trump-won-the-us-election-will-crypto-market-embrace-bull-market-frenzy-again" target="_blank">Trump ha vinto le elezioni negli Stati Uniti, abbraccerà di nuovo il mercato delle criptovalute la frenesia del mercato toro?</a>” all’inizio del mese. Questo articolo riassume gli indizi recenti di un’ascesa del mercato e la logica della rotazione del settore, rivelando il recente schema di volatilità di mercato.</p>
<h2 id="h2-BTC20supera20gli208000020ETH20si20rafforza20rapidamente956070"><a name="BTC supera gli $80.000, ETH si rafforza rapidamente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC supera gli $80.000, ETH si rafforza rapidamente</h2><p>Dal momento che Trump è stato eletto come prossimo Presidente degli Stati Uniti, il <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ha sperimentato una forza senza precedenti. In mezzo alle aspettative di mercato di un potenziale allentamento delle politiche regolamentari e fiscali durante l’amministrazione Trump, i fondi sono affluiti significativamente nei mercati azionari e cripto statunitensi. Inoltre, l’incontro sui tassi di interesse dello scorso venerdì ha continuato a tagliare i tassi di interesse di 25 punti base, alimentando ulteriormente il sentiment di mercato e aprendo spazio al rialzo per il mercato cripto. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è salito oltre i 80.000 dollari per la prima volta. Questo traguardo è stato raggiunto nel fine settimana senza il supporto degli ETF spot, dimostrando il forte slancio del mercato.</p>
<p>Dal punto di vista finanziario, le commissioni di transazione sulla catena <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> continuano a diminuire e rimangono basse, ma l’afflusso netto di fondi mostra una significativa tendenza al crescita. Nel mese scorso, è arrivato al 324%, e nella settimana scorsa è arrivato al 41,96%. Questo indica senza dubbio che la fiducia del mercato nel Bitcoin sta aumentando costantemente e i fondi stanno affluendo attivamente.</p>
<p>Dal punto di vista tecnico, il canale al rialzo di Bitcoin è stato aperto e tutti i tipi di informazioni indicano notizie positive. L’implicazione di un ritorno del mercato rialzista è già molto forte. Naturalmente, possiamo considerare il trend al rialzo continuo di seguito come punto di partenza di questa ondata di crescita. Se il prezzo può tornare in questa zona di nuovo, potrebbe portare una seconda opportunità di decollo.<br><img src="https://gimg2.gateimg.com/image/article/17313124411.jpeg" alt=""><br>Sorgente: Gate.io</p>
<p>Paragonato a Bitcoin, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è finalmente diventata relativamente forte. Di recente, i fondi hanno iniziato a traboccare nel <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> il mercato, spingendo il suo tasso di cambio a continuare a salire. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha superato il valore intero di $3.000 nel fine settimana. Questa nuova fase di ripresa non solo risolve la lunga crisi di Ethereum, ma mostra anche al mercato il potenziale e il valore di Ethereum.<br><img src="https://gimg2.gateimg.com/image/article/17313125062.jpeg" alt=""><br>Sorgente: Gate.io</p>
<p>Nonostante la SEC abbia nuovamente rinviato la sua decisione su approvare o meno le opzioni ETF Ethereum spot, sembra che la notizia non abbia influenzato la fiducia di mercato in Ethereum. Al contrario, in questo contesto entusiasmante, questa decisione potrebbe ulteriormente stimolare l’entusiasmo speculativo del mercato che si prospetta, portando ad un maggiore afflusso di fondi nel mercato di Ethereum.<br><img src="https://gimg2.gateimg.com/image/article/17313125243.jpeg" alt=""><br>Origine: coinglass</p>
<h2 id="h2-I20meme20continuano20a20guidare20i20guadagni20il20revival20DeFi2020imminente110722"><a name="I meme continuano a guidare i guadagni, il revival DeFi è imminente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I meme continuano a guidare i guadagni, il revival DeFi è imminente</h2><p>Dalla volatilità del settore Altcoin, Meme resta l’unica a guidare i guadagni, che è diventata una caratteristica standard di questo mercato rialzista; Naturalmente, anche GameFi, DeFi, AI e altri settori hanno registrato aumenti significativi, in particolare DeFi, che è stato inattivo per molto tempo. Di recente c’è stata molta opinione pubblica sul suo risorgimento, ed è diventato effettivamente un argomento caldo in tempi recenti.<img src="https://gimg2.gateimg.com/image/article/17313125504.jpeg" alt=""><br>Origine: CoinGecko</p>
<p>Abbiamo scritto diversi articoli sulla sezione Meme e l’articolo della settimana scorsa, <a href="https://www.gate.io/blog/4679/with-concepts-constantly-emerging-what-are-the-trending-narratives-on-the-meme-track-recently" target="_blank">Con i concetti che emergono costantemente, quali sono le narrazioni di tendenza sulla traccia dei meme di recente?</a> Ho ordinato i meme popolari recenti.</p>
<p>Alla data di redazione, il settore dei meme è aumentato fino al 57% nell’ultima settimana, con MOODENG, LUCE e PEPE in testa al mercato con guadagni del 183%, 156% e 130%. In realtà, in tempi recenti, sia le ben consolidate DOGE, SHIB, PEPE, e le emergenti WIF, NEIRO, MEW, MOG, BOME, ecc. hanno registrato un aumento generale, e alcune nuove valute hanno addirittura stabilito nuovi massimi uno dopo l’altro. È interessante notare che l’AI+ <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> + Il Meme, rappresentato da GOAT, rimane il sottosettore Meme più persistente.</p>
<p>Il settore DeFi, rappresentato da <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">AAVE</a>, ha registrato un significativo aumento, con token concettuali come derivati on-chain, coltivazione del reddito e garanzia di liquidità che hanno ottenuto guadagni significativi. Beneficiando della quotazione favorevole su grandi exchange, DRIFT, COW e altri hanno guidato il settore DeFi con guadagni settimanali del 286% e dell’81%, rispettivamente; Inoltre, il protocollo di prestito di liquidità CETUS ha anche aggiunto la high-performance L1 public chain SUI per guidare il percorso delle public chain, diventando un punto caldo di mercato con un aumento sorprendente del 144%.<br><img src="https://gimg2.gateimg.com/image/article/17313126285.jpeg" alt=""><br>Origine: Gate.io</p>
<p>Sebbene il settore della liquidità di staking (re-) appartenga alla definizione generale di DeFi, è necessario analizzarlo separatamente a causa della sua narrazione unica e innovativa in questo mercato rialzista. Dopo aver sperimentato la gloria del primo trimestre, il percorso della liquidità di staking (re-) è caduto in un’atmosfera complessivamente lenta insieme al mercato, e le nuove narrazioni sono state abbandonate dal mercato, con Meme che occupa più attenzione. Tuttavia, con il recente forte rimbalzo di LDO, BB, REZ e altri settori, questo percorso sta gradualmente riacquistando vitalità. Naturalmente, se le prestazioni successive possono essere sostenute dipende ancora dalla capacità di Eigenlayer (EIGEN) di espandere la sua attività AVS e innovare ulteriormente la tecnologia nel contesto di un mercato rialzista.</p>
<p>Inoltre, il settore GameFi è stato popolare sul mercato a causa della sua bassa valutazione, con un aumento della capitalizzazione di mercato del 29% negli ultimi 7 giorni. Il leader di questo settore è il recentemente lanciato X Empire (X), un gioco click-to-earn basato su Telegram. È stato lanciato per la prima volta su varie piattaforme di trading alla fine di ottobre ed è recentemente salito dopo un breve aggiustamento, diventando un progetto di grande attualità diverso dal picco dei piccoli giochi TON chain come DOGS. Naturalmente, l’infrastruttura dei giochi blockchain come IMX, BEAM e ASX è naturalmente aumentata, ma i giochi a punti di TON Chain sono ancora il cuore dei giochi blockchain in questo ciclo.<img src="https://gimg2.gateimg.com/image/article/17313126636.jpeg" alt=""><br>Origine: Gate.io</p>
<h2 id="h2-Ci20sono20dei20pericoli20nascosti20nel20mercato20futuro20sotto20la20pressione814886"><a name="Ci sono dei pericoli nascosti nel mercato futuro sotto la pressione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ci sono dei pericoli nascosti nel mercato futuro sotto la pressione?</h2><p>In generale, l’alto rimbalzo di Bitcoin prima della sua svolta, combinato con le notizie favorevoli dell’elezione di Trump, ha gettato le basi per il recente miglioramento del mercato attraverso la risonanza tra gli aspetti tecnici e fondamentali.</p>
<p>Specialmente con l’elezione di Trump che ha scatenato il cosiddetto ‘Trump trade’, il mercato si aspetta in generale che lui rilassi le regolamentazioni e adotti politiche di allentamento fiscale. Inoltre, il chiaro supporto precedente di Trump per Bitcoin ha rafforzato l’effetto di collegamento tra Bitcoin e il mercato azionario degli Stati Uniti, e la performance di Bitcoin è significativamente più forte rispetto a quella del mercato azionario degli Stati Uniti.</p>
<p>Questo può essere verificato dal <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> di fondi. Lo scorso venerdì, nel giro di cinque giorni di negoziazione, il mercato azionario degli Stati Uniti ha aggiunto più di 2 trilioni di dollari di nuovi fondi, e anche l’ETF Bitcoin spot ha registrato nuovi massimi di afflussi netti giornalieri. L’afflusso di fondi ha cambiato il modello originale del mercato rialzista per i trader, e il Bitcoin ha effettivamente superato i massimi storici ed è entrato in uno stato di mercato rialzista completo.<img src="https://gimg2.gateimg.com/image/article/17313126907.jpeg" alt=""><br>Origine: coinglass</p>
<p>Da un punto di vista storico, il quarto trimestre di solito si comporta bene dopo il <a href="/explore/bitcoin-halving-countdown" rel="nofollow noopener noreferrer" target="_blank">Halving di Bitcoin</a> evento. Inoltre, la chiusura di Bitcoin a settembre ha raggiunto anche la sua migliore performance nella storia, rafforzando la fiducia degli investitori nel futuro.<img src="https://gimg2.gateimg.com/image/article/17313127058.jpeg" alt=""><br>Origine: bitbo.io</p>
<p>Sebbene il mercato sia generalmente ottimista sulle prospettive del Bitcoin, ci sono ancora alcune differenze. Secondo l’esperienza, se c’è una significativa fluttuazione di mercato nel fine settimana, spesso si riempie il gap di prezzo in futuro. Giudicando dalla pressione del BTC di raggiungere il livello doppia cifra di $80,000 e l’ETH che supera il livello di $3,000, il mercato potrebbe affrontare una breve aspettativa di correzione. Pertanto, gli investitori devono essere cauti sulle fluttuazioni di mercato ed evitare comportamenti di investimento irrazionali in un mercato surriscaldato.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle Y.</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; una decisione oculata è essenziale.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentita la ripubblicazione dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, si intraprenderanno azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>