Q29uIGwnRVRIIGNoZSBzY2hpenphIGRlbCAyMCUgaW4gdW4gc29sbyBnaW9ybm8sIHF1YW5kbyBhcnJpdmVyw6AgbGEgc3RhZ2lvbmUgZGVsbGUgYWx0Y29pbiBiYXNhdGEgc3VsbCdFVEgvQlRDPw==

2024-05-21, 07:04

<p><img src="https://gimg2.gateimg.com/image/article/1716274835rdzz.jpeg" alt=""></p>
<h2 id="h2-TLDR92535"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>La scorsa settimana, il rapporto ETH/BTC ha toccato un minimo di tre anni di 0,043 e il mercato era pieno di sentimenti FUD riguardo alla debole innovazione di ETH e ai prezzi deboli.</p>
<p>La debolezza sostenuta di ETH/BTC è principalmente attribuita all’approvazione dell’ETF spot di BTC, all’espansione rapida degli ecosistemi di BTC e SOL, alla mancanza di innovazione nell’ecosistema di ETH e alla situazione attuale del trading a freddo.</p>
<p>Recentemente, il Based Rollup, ePBS, Resetting e le varie astrazioni degli account di EIP nell’ecosistema ETH sono diventati punti salienti innovativi nel processo di fermentazione, con Resetting che viene particolarmente anticipato.</p>
<h2 id="h2-Introduzione348598"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il rapporto ETH/BTC ha raggiunto un nuovo minimo di 0,043, raggiungendo il minimo degli ultimi tre anni. In mezzo al sentimento di preoccupazione del mercato nei confronti di ETH, ETH è aumentato del 20% in un solo giorno, stabilendo un record per un aumento di tre anni.</p>
<p>Con una rotazione di alti e bassi, passando da tori a orsi, questo articolo osserverà il timing di ETH e persino la stagione degli Altcoin dalle fluttuazioni dei tassi di cambio ETH/BTC.</p>
<h2 id="h2-ETHBTC20ha20raggiunto20un20minimo20di20due20anni20e20leffetto20di20trasbordo20dei20fondi20ETF20spot20non2020significativo29231"><a name="ETH/BTC ha raggiunto un minimo di due anni, e l’effetto di trasbordo dei fondi ETF spot non è significativo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH/BTC ha raggiunto un minimo di due anni, e l’effetto di trasbordo dei fondi ETF spot non è significativo</h2><p>Nel ciclo 2023-2024, possiamo osservare un significativo ampliamento della differenza di performance tra BTC e ETH. In particolare, la tendenza dei prezzi di ETH sembra essere relativamente debole, il che può essere considerato come un riflesso della debole tendenza complessiva della rotazione del capitale.</p>
<p>Specialmente rispetto ai cicli e alle svolte passate in ATH (il punto più alto della storia), le prestazioni di ETH possono essere descritte solo come passive o deboli.</p>
<p>ETH/BTC, che è sempre stato considerato un punto di riferimento per le tendenze delle Altcoin, è sceso a 0,043 la settimana scorsa, raggiungendo un nuovo minimo da aprile 2021, con la quota di mercato di ETH che è scesa al 14,6%. Questa scarsa performance riflette che la ricerca di BTC da parte dei partecipanti a lungo termine e a breve termine ha superato significativamente il loro entusiasmo per ETH, soprattutto gli investitori a breve termine mostrano un significativo ritardo nell’interesse per ETH.<br><img src="https://gimg2.gateimg.com/image/article/17162749271.jpeg" alt=""><br>Fonte: Gate.io</p>
<p>Un recente rapporto di Glassnode che esplora l’ETH più debole del BTC ha anche evidenziato questa situazione. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha registrato un aumento significativo dell’attività speculativa a breve termine prima di raggiungere un massimo storico (ATH) il 14 marzo di quest’anno. Tuttavia, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>(ETH) non è riuscito a superare il suo massimo storico del 2021, a differenza degli ETF spot statunitensi, dove un grande afflusso di nuovo capitale ha aumentato i prezzi del BTC.<br><img src="https://gimg2.gateimg.com/image/article/17162749422.jpeg" alt=""><br>Fonte: glassnode</p>
<p>Finora, ETH non è ancora riuscito a performare meglio di BTC nei due precedenti mercati rialzisti, e molti giganteschi balene che scommettono sul ribaltamento di ETH hanno subito significative perdite. Secondo l’analista on-chain @ai_9684xtpa, mentre il tasso di cambio ETH/BTC ha toccato un nuovo minimo in quasi tre anni, la gigantesca balena 0x111…dc42e, che è stata costantemente rialzista sul tasso di cambio ETH/BTC da marzo 2023, ha accumulato liquidazioni per $22.45 milioni.</p>
<p>Nel complesso, il mercato ETH segue una traiettoria dei prezzi simile a BTC, ma la maggior parte degli indicatori mostra che ETH si comporta male rispetto a BTC. Se il progresso positivo degli ETF spot di ETH il 21 maggio può rafforzarlo sarà ulteriormente osservato e considerato nel testo seguente.</p>
<h2 id="h2-XX20flip20Ethereum2020Analisi20dei20cambiamenti20strutturali20di20mercato20sottostanti400084"><a name="XX flip Ethereum - Analisi dei cambiamenti strutturali di mercato sottostanti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>XX flip <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> - Analisi dei cambiamenti strutturali di mercato sottostanti</h2><p>Finora, le prestazioni complessive di BTC hanno effettivamente superato ETH, principalmente a causa dell’approvazione dell’ETF spot di BTC e dell’espansione rapida dell’ecosistema di BTC. Naturalmente, le forti prestazioni del suo rivale della catena pubblica SOL hanno anche influenzato ETH.</p>
<p>Pertanto, con la prosperità generale e i cambiamenti strutturali del mercato delle criptovalute, il ruolo di ETH/BTC come indicatore di Altcoin nella tendenza del settore Altcoin si sta indebolendo. La catena pubblica SOL, il settore dell’IA, il settore MEME e altri hanno mostrato una tendenza relativamente resiliente o di leadership in questo mercato al rialzo, formando una chiara differenziazione dalla debolezza sostenuta di ETH.<br><img src="https://gimg2.gateimg.com/image/article/17162749623.jpeg" alt=""><br>Fonte: BLOCKCHAINCENTER.NET</p>
<p>Anche se la posizione di ETH/BTC come segnale di Altcoin non è più forte, vale comunque la pena esplorare se ETH continuerà a indebolirsi.</p>
<p>Secondo il trend settimanale in Figura 1, ETH/BTC è stato in lenta discesa nel canale discendente dal settembre 2022. La scorsa settimana è sceso brevemente al di sotto del livello chiave di supporto di 0,05. Da un punto di vista quotidiano, il tasso di cambio è finalmente rimbalzato in modo significativo sotto il supporto del canale discendente e i progressi positivi degli ETF spot. Il livello di pressione importante nella prossima fase è 0,06.</p>
<p>Se ingrandiamo ulteriormente il ciclo di osservazione, come mostrato nella figura sottostante, possiamo vedere che il tasso di cambio ETH/BTC ha mostrato un forte trend al rialzo durante i periodi più pazzi dei due mercati rialzisti nella seconda metà del 2017 e nella prima metà del 2021.<br><img src="https://gimg2.gateimg.com/image/article/17162749794.jpeg" alt=""><br>Origine: Gate.io</p>
<p>Se seguiamo questo modello storico, sembra che la crescita di ETH/BTC non sia ancora iniziata e sembra troppo presto per essere eccessivamente pessimisti su ETH.</p>
<p>Da un punto di vista fondamentale, la variabile più significativa che potrebbe influenzare il trend dell’ETH a breve è il progresso dell’approvazione da parte della SEC degli ETF spot negli Stati Uniti.</p>
<p>Sebbene l’impatto degli ETF spot nel mercato di Hong Kong sia limitato, ha aperto la strada al riconoscimento di ETH da parte delle regioni giudiziarie regolamentari globali. Al momento della stesura, a causa dell’esigenza della SEC che impone agli exchange di accelerare la presentazione di documenti regolatori sugli ETF spot di Ethereum, gli analisti di Bloomberg hanno aumentato la probabilità di approvazione degli ETF spot Ethereum dal 25% al 75%, migliorando significativamente le prospettive di approvazione per gli ETF spot ETH.<br><img src="https://gimg2.gateimg.com/image/article/17162749955.jpeg" alt=""><br>Origine: CoinDesk</p>
<p>Questa notizia ha stimolato i prezzi dell’ETH a salire del 18% in breve tempo, con aumenti significativi nei token concettuali dell’ETH come Layer 2, Infra e MEME, spazzando via il recente buio del continuo declino. Durante questo periodo, grandi investitori sulla catena si sono attivamente impegnati nel trading con leva attraverso piattaforme di prestito come <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> e ha acquistato una grande quantità di ETH. In particolare, James Fickel, come sostenitore convinto del tasso di cambio ETH/BTC, ha accumulato prestiti in WBTC per oltre $190 milioni da <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> e li ha convertiti in ETH. Inoltre, altri grandi investitori hanno preso in prestito per acquistare stETH e WBTC, alimentando ulteriormente l’entusiasmo di mercato. Questi comportamenti di trading indicano che il mercato è ottimista sul futuro sviluppo di ETH e disposto a fare grandi investimenti.</p>
<p>Inoltre, il tasso di approvazione del 75% si applica solo a 19b-4 e viene richiesta anche l’approvazione del documento S-1. L’opinione di mercato prente attuale è che la SEC possa approvare 19b-4s questa settimana e poi rallentare la velocità di esecuzione degli S-1s. Dal punto di vista legale, se l’ETF di Ethereum deve essere lanciato con successo, la SEC deve approvare contemporaneamente sia 19b-4s (cambiamenti alle regole di scambio) che S-1s (dichiarazioni di registrazione).</p>
<h2 id="h2-Quali20innovazioni20possono20far20risorgere20ETH550701"><a name="Quali innovazioni possono far risorgere ETH?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali innovazioni possono far risorgere ETH?</h2><p>L’attività della comunità Ethereum non è afflitta dai prezzi bassi, ma continua a generare molti spunti interessanti e creatività. Oltre agli ETF spot molto attesi, le recenti discussioni sull’innovazione tecnologica in Based Rollup, ePBS, Resting e varie astrazioni dei conti di EIP (Proposta di Miglioramento di Ethereum) sono state particolarmente vivaci. Questi argomenti non solo riflettono la lungimiranza degli sviluppatori di Ethereum, ma prefigurano anche il percorso di ripresa di ETH.</p>
<p>Abbiamo scritto diversi articoli per esplorare la pista Resting, che è anche la direzione narrativa in cui ETH è più probabile generare una spinta positiva in questo mercato rialzista. Dallo sblocco della liquidità di Lido allo splitting di tokenizzazioni di equità di Pendle, così come Eigenlayer e un gruppo di progetti LRT, questo tipo di liquidità staking si è sviluppato in modo più complesso ed efficiente, completamente diverso dai semplici blocchi Lego di DeFi.</p>
<p>Il posizionamento di Ethereum si sta sviluppando gradualmente verso la diversificazione e continuano a essere esplorati nuovi paradigmi. Ad esempio, il posizionamento stratificato consente agli investitori di scegliere strategie di posizionamento a diversi livelli di rischio in base alle loro preferenze di rischio; il posizionamento automatizzato migliora l’efficienza della gestione attraverso contratti intelligenti; il posizionamento collettivo (o posizionamento condiviso) offre opportunità per piccoli investitori di cooperare e aumentare il valore; e la combinazione di posizionamento e RWA conferisce nuova liquidità agli asset fisici.<br><img src="https://gimg2.gateimg.com/image/article/17162750226.jpeg" alt=""><br>Origine: Eigenlayer</p>
<p>Anche se attualmente ci sono vari modelli di staking nell’ecosistema ETH, questo è solo l’inizio. Man mano che sempre più utenti e istituzioni partecipano a DeFi, i modelli di staking diversificati diventeranno una scelta per più persone, e gli stakeholder manterranno la sicurezza della rete e otterranno rendimenti fornendo garanzie liquide. Questa economia positiva contribuirà a ridurre il rischio di manipolazione della rete e promuovere la costruzione sostenibile dell’intero ecosistema, diversamente dai puri rendimenti di staking Ponzi del passato.</p>
<p>Guardando avanti, Ethereum sta iniziando a mostrare il suo potenziale unico in settori come il riposo, e la sua attuale valutazione più bassa fornisce una solida base per il suo futuro potenziale al rialzo. Con il miglioramento graduale del sentiment di mercato, abbiamo notato che il tasso di cambio ETH/BTC ha mostrato una forte tendenza al rialzo dopo una breve diminuzione, e alcuni nuovi settori di Altcoin concettuali stanno riparando il loro valore. Suggeriamo agli investitori di rimanere pazienti e di guardare avanti a Ethereum che guida il mercato verso nuove vette con la sua solida base tecnologica e il crescente supporto della comunità.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl 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.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che Gate.io sia citato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>