TWV0IEVUSCBkYXQgbWV0IDIwJSBzdGlqZ3QgaW4gw6nDqW4gZGFnLCB3YW5uZWVyIHphbCBoZXQgYWx0Y29pbi1zZWl6b2VuIGFycml2ZXJlbiBvcCBiYXNpcyB2YW4gRVRIL0JUQz8=

2024-05-21, 07:04

<p><img src="https://gimg2.gateimg.com/image/article/1716274835rdzz.jpeg" alt=""></p>
<h2 id="h2-TLDR55038"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p>Vorige week bereikte de ETH/BTC-verhouding een driejarig dieptepunt van 0,043, en de markt was gevuld met FUD-sentiment van zwakke ETH-innovatie en zwakke prijzen.</p>
<p>De aanhoudende zwakte van ETH/BTC wordt voornamelijk toegeschreven aan de goedkeuring van BTC’s spot ETF, de snelle uitbreiding van BTC en SOL ecoen, het gebrek aan innovatie in het ETH-ecosysteem en de huidige situatie van koude handel.</p>
<p>Onlangs zijn de Based Rollup, ePBS, Resetting en diverse account abstracties van EIP in het ETH-ecosysteem innovatieve hoogtepunten geworden in het brouwproces, waarbij met name Resetting bijzonder wordt verwacht.</p>
<h2 id="h2-Inleiding796161"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De ETH/BTC-verhouding bereikte een nieuw dieptepunt van 0,043, waarmee het een dieptepunt van drie jaar bereikte. Te midden van het FUD-sentiment van de markt jegens ETH, steeg ETH met 20% op één dag, waarmee een record voor een stijging van drie jaar werd gevestigd.</p>
<p>Met een rotatie van ups en downs, die zich richt op stieren en beren, zal dit artikel de timing van ETH en zelfs het Altcoin-seizoen observeren vanuit de schommeling van de ETH/BTC-wisselkoersen.</p>
<h2 id="h2-ETHBTC20heeft20een20tweejarig20dieptepunt20bereikt20en20het20overloopeffect20van20spot20ETFfondsen20is20niet20significant48735"><a name="ETH/BTC heeft een tweejarig dieptepunt bereikt, en het overloopeffect van spot ETF-fondsen is niet significant" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH/BTC heeft een tweejarig dieptepunt bereikt, en het overloopeffect van spot ETF-fondsen is niet significant</h2><p>In de cyclus van 2023 tot 2024 kunnen we een significante verbreding van het prestatieverschil tussen BTC en ETH waarnemen. Specifiek lijkt de prijstrend van ETH relatief zwak te zijn, wat gezien kan worden als een weerspiegeling van de zwakke algehele trend van kapitaalrotatie.</p>
<p>Vooral in vergelijking met eerdere cycli en doorbraken in ATH (het hoogste punt in de geschiedenis), kan de prestatie van ETH alleen worden omschreven als passief of zwak.</p>
<p>ETH/BTC, dat altijd beschouwd is als een benchmark voor Altcoin trends, daalde vorige week naar 0,043, waarmee het een nieuw dieptepunt bereikte sinds april 2021, met een ETH-marktaandeel dat daalde naar 14,6%. Deze zwakke prestatie weerspiegelt dat de achtervolging van BTC door langetermijn- en kortetermijndeelnemers aanzienlijk groter is dan hun enthousiasme voor ETH, vooral kortetermijninvesteerders tonen een aanzienlijke achterstand in interesse in ETH.<br><img src="https://gimg2.gateimg.com/image/article/17162749271.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Een recent rapport van Glassnode, waarin wordt onderzocht dat ETH zwakker is dan BTC, wees ook op deze situatie. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zag een aanzienlijke toename van kortetermijnspeculatie voordat het op 14 maart van dit jaar een historisch hoogtepunt (ATH) bereikte. Echter, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> (ETH) slaagde er niet in om zijn 2021 ATH te doorbreken, in tegenstelling tot Amerikaanse spot-ETF’s, waar een grote instroom van nieuw kapitaal de BTC-prijzen stimuleerde.<br><img src="https://gimg2.gateimg.com/image/article/17162749422.jpeg" alt=""><br>Bron: glassnode</p>
<p>Tot op heden heeft ETH nog niet beter gepresteerd dan BTC in de vorige twee bullmarkten, en veel grote walvissen die wedden op een ommekeer van ETH hebben ook aanzienlijke verliezen geleden. Volgens on-chain analist @ai_9684xtpa monitoring, naarmate de ETH/BTC-wisselkoers een nieuw dieptepunt bereikte in bijna drie jaar, heeft de grote walvis 0x111…dc42e, die sinds maart 2023 voortdurend optimistisch is geweest over de ETH/BTC-wisselkoers, $22,45 miljoen aan liquidatie opgebouwd.</p>
<p>Over het algemeen volgt de ETH-markt een prijsverloop dat vergelijkbaar is met BTC, maar de meeste indicatoren tonen aan dat ETH slecht presteert in vergelijking met BTC. Of de positieve vooruitgang van ETH-spot-ETF’s op 21 mei het kan versterken, zal verder worden waargenomen en overwogen in de volgende tekst.</p>
<h2 id="h2-XX20flip20Ethereum2020Analyseer20de20onderliggende20marktstructurele20veranderingen203613"><a name="XX flip Ethereum - Analyseer de onderliggende marktstructurele veranderingen" 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> - Analyseer de onderliggende marktstructurele veranderingen</h2><p>Tot nu toe heeft BTC’s algehele prestatie inderdaad ETH overtroffen, voornamelijk vanwege de goedkeuring van BTC’s spot ETF en de snelle uitbreiding van het BTC-ecosysteem. Natuurlijk heeft de sterke prestatie van zijn publieke ketenrivaal SOL ook invloed gehad op ETH.</p>
<p>Daarom is met de algehele welvaart en structurele veranderingen op de cryptomarkt de rol van ETH/BTC als een altcoin-indicator in de trend van de altcoinsector aan het verzwakken. De SOL-publicchain, AI-sector, MEME-sector en andere sectoren hebben een relatief veerkrachtige of leidende trend laten zien in deze bullmarkt, wat een duidelijk onderscheid vormt ten opzichte van de aanhoudende zwakte van ETH.<br><img src="https://gimg2.gateimg.com/image/article/17162749623.jpeg" alt=""><br>Bron: BLOCKCHAINCENTER.NET</p>
<p>Hoewel de positie van ETH/BTC als een altcoinsignaal niet langer sterk is, is het nog steeds de moeite waard om te onderzoeken of ETH zal blijven verzwakken.</p>
<p>Volgens de wekelijkse trend in figuur 1 daalt ETH/BTC langzaam in het neerwaartse kanaal sinds september 2022. Vorige week daalde het kortstondig onder het belangrijke ondersteuningsniveau van 0.05. Vanuit een dagelijks perspectief is de wisselkoers eindelijk aanzienlijk hersteld ondersteund door het neerwaartse kanaal en de positieve vooruitgang van spot ETF’s. Het belangrijke drukniveau in de volgende fase is 0.06.</p>
<p>Als we de observatiecyclus verder vergroten, zoals weergegeven in de onderstaande figuur, kunnen we zien dat de wisselkoers ETH/BTC een sterke stijgende trend vertoonde tijdens de gekste periodes van de twee bullmarkten in de tweede helft van 2017 en de eerste helft van 2021.<br><img src="https://gimg2.gateimg.com/image/article/17162749794.jpeg" alt=""><br>Bron: Gate.io</p>
<p>Als we dit historische patroon volgen, lijkt de stijging van ETH/BTC nog niet begonnen te zijn, en lijkt het te vroeg om al te pessimistisch te zijn over ETH.</p>
<p>Vanuit een fundamenteel perspectief is de meest significante variabele die op korte termijn de trend van ETH kan beïnvloeden, de voortgang van de goedkeuring van zijn spot ETF’s door de Amerikaanse SEC.</p>
<p>Hoewel de impact van spot-ETF’s op de Hong Kong-markt beperkt is, heeft het de erkenning van ETH door mondiale gerechtelijke regelgevingsgebieden pionier gemaakt. Op de dag van schrijven, als gevolg van de eis van de SEC aan beurzen om regelgevende documenten over Ethereum spot-ETF’s te versnellen, verhoogden Bloomberg-analisten de kans op goedkeuring voor spot Ethereum ETF’s van 25% tot 75%, wat de vooruitzichten voor goedkeuring van ETH spot-ETF’s aanzienlijk verbeterde.<br><img src="https://gimg2.gateimg.com/image/article/17162749955.jpeg" alt=""><br>Bron: CoinDesk</p>
<p>Dit nieuws heeft de ETH-prijzen gestimuleerd om in korte tijd met 18% te stijgen, met opvallende stijgingen in ETH-concepttokens zoals Layer 2, Infra en MEME, waardoor de recente somberheid van voortdurende daling werd weggevaagd. Gedurende deze periode hebben grote investeerders op de keten actief deelgenomen aan hefboomhandel via uitleenplatforms zoals <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> en heeft een grote hoeveelheid ETH gekocht. Het is met name opmerkelijk dat James Fickel, als een fervent voorstander van de ETH/BTC wisselkoers, meer dan $190 miljoen aan WBTC-leningen van <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> heeft opgebouwd en deze heeft omgezet in ETH. Bovendien hebben andere grote investeerders geleend om stETH en WBTC te kopen, waardoor de marktenthousiasme verder is toegenomen. Deze handelsgedragingen geven aan dat de markt optimistisch is over de toekomstige ontwikkeling van ETH en bereid is om grote investeringen te doen.</p>
<p>Ter aanvulling, de goedkeuringsgraad van 75% is alleen van toepassing op 19b-4, en goedkeuring van het S-1 document is ook vereist. De huidige heersende marktvisie is dat de SEC deze week 19b-4’s kan goedkeuren en vervolgens de uitvoeringssnelheid van S-1’s kan vertragen. Juridisch gezien moet de SEC beide 19b-4’s (veranderingen in de beursregels) en S-1’s (registratieverklaringen) tegelijk goedkeuren als Ethereum’s ETF succesvol gelanceerd moet worden.</p>
<h2 id="h2-Welke20innovaties20kunnen20ervoor20zorgen20dat20ETH20weer20stijgt160476"><a name="Welke innovaties kunnen ervoor zorgen dat ETH weer stijgt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke innovaties kunnen ervoor zorgen dat ETH weer stijgt?</h2><p>De activiteit van de Ethereum-gemeenschap wordt niet geplaagd door lage prijzen, maar blijft vele prikkelende inzichten en creativiteit genereren. Naast de zeer verwachte spot ETF’s, zijn recente discussies over technologische innovatie in Based Rollup, ePBS, Resting en verschillende account abstracties van EIP (Ethereum Improvement Proposal) bijzonder levendig geweest. Deze onderwerpen weerspiegelen niet alleen het vooruitziende blik van Ethereum-ontwikkelaars, maar voorspellen ook de herstelreis van ETH.</p>
<p>We hebben verschillende artikelen geschreven om het Rustende spoor te verkennen, wat ook de narratieve richting is waarin ETH waarschijnlijk een positieve vliegwiel zal genereren in deze stierenmarkt. Van Lido dat liquiditeitsstaking ontgrendelt tot Pendle die getokeniseerde aandelen splitst, evenals Eigenlayer en een reeks LRT-projecten, is dit type liquiditeitsstaking ontwikkeld tot iets complexer en efficiënter, volledig anders dan eenvoudige DeFi Lego-blokken.</p>
<p>Ethereum staking ontwikkelt zich geleidelijk naar diversificatie en er worden voortdurend nieuwe paradigma’s verkend. Zo maakt Layered staking het mogelijk voor investeerders om staking strategieën op verschillende risiconiveaus te kiezen op basis van hun risicovoorkeuren; geautomatiseerde staking verbetert de efficiëntie van het beheer via slimme contracten; collectieve staking (of gedeelde staking) biedt mogelijkheden voor kleine investeerders om samen te werken en waarde te verhogen; en de combinatie van staking en RWA geeft fysieke activa nieuwe liquiditeit.<br><img src="https://gimg2.gateimg.com/image/article/17162750226.jpeg" alt=""><br>Bron: Eigenlayer</p>
<p>Hoewel er momenteel verschillende stakingmodellen zijn in het ETH-ecosysteem, is dit pas het begin. Naarmate meer gebruikers en instellingen deelnemen aan DeFi, zullen gediversifieerde stakingmodellen een keuze worden voor meer mensen, en stakers zullen netwerkbeveiliging behouden en rendement behalen door liquide onderpand te verstrekken. Deze positieve economie zal helpen het risico van netwerkmanipulatie te verminderen en de duurzame opbouw van het hele ecosysteem te bevorderen, wat verschilt van vroegere pure Ponzi-stakingrendementen.</p>
<p>Vooruitkijkend begint Ethereum zijn unieke potentieel te tonen op gebieden zoals rusten, en zijn huidige lagere waardering biedt een solide basis voor zijn toekomstige opwaartse potentieel. Naarmate het marktsentiment geleidelijk verbetert, hebben we gemerkt dat de ETH/BTC-wisselkoers een sterke opwaartse trend vertoont na een korte daling, en sommige nieuwe concepten in de Altcoin-sectoren herstellen ook hun waarde. We raden investeerders aan geduldig te blijven en uit te kijken naar Ethereum die de markt naar nieuwe hoogten leidt met zijn solide technologische basis en groeiende gemeenschapsondersteuning.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>