RXRoZXJldW0gR2FzIGhlZWZ0IHppam4gZGllcHRlcHVudCBiZXJlaWt0LCB6YWwgZGUgbWFya3QgaGV0IGRpZXB0ZXB1bnQgYmVyZWlrZW4gZW4gc3Rpamdlbj8=

2024-05-01, 04:04
<p><img src="https://gimg2.gateimg.com/image/article/17145359501692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR572781"><a name="[TL；DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL；DR]:</h2><p>Recentelijk, de mediaan van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gas heeft een driejarig dieptepunt bereikt, met een mediane waarde van slechts 6,43 gwei op 27 april. De omloopvoorraad van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> is in de afgelopen zeven dagen met meer dan 10.000 eenheden toegenomen.</p>
<p>Ondanks aanzienlijke upgrades in Ethereum, is het probleem van hoge gasvergoedingen op het mainnet niet effectief opgelost, wat heeft geleid tot de snelle opkomst van andere concurrerende chains zoals <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>.</p>
<p>De huidige lage gasprijs zal de markt helpen om los te breken van de huidige stagnatie en kan Ethereum naar een hersteltrend drijven, maar de korte termijn zwakte moet nog worden waargenomen.</p>
<h2 id="h2-Inleiding989270"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Onlangs zijn de Ethereum gasvergoedingen aanzienlijk gedaald, waarbij de mediane gasvergoeding op het laagste niveau in drie jaar is gekomen. Veel investeerders geloven dat dit kan betekenen dat de markt een bodem heeft bereikt. Dit artikel zal dieper ingaan op dit onderwerp.</p>
<h2 id="h2-Redenen20voor20de20stijging20en20daling20van20Ethereum20Gas278779"><a name="Redenen voor de stijging en daling van Ethereum Gas" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Redenen voor de stijging en daling van Ethereum Gas</h2><p>Ondanks aanzienlijke upgrades in Ethereum is het probleem van hoge gasvergoedingen op het mainnet niet effectief opgelost, wat heeft geleid tot de snelle opkomst van andere concurrerende ketens zoals Solana.</p>
<p>Tegen de achtergrond van de recente marktdaling blijft gas op het Ethereum-netwerk dalen, zelfs onder sommige L2-niveaus, en op de datum van schrijven blijft deze waarde op acht gwei.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17145362261.png" alt=""><br>Bron: etherscan.io</p>
<p>Voordat we de relatie tussen lage gas- en marktprijstrends verkennen, moeten we de gebruiken van gas introduceren.<br>Gas, ook wel brandstof genoemd, verwijst naar de rekenwerklast die nodig is om specifieke bewerkingen uit te voeren op het Ethereum-netwerk. Omdat elke Ethereum-transactie computermiddelen vereist om uit te voeren, is het noodzakelijk om te betalen voor deze middelen om ervoor te zorgen dat Ethereum niet kwetsbaar is voor spamaanvallen en niet in een oneindige rekenlus terechtkomt.</p>
<p>Dat wil zeggen, gas is de brandstof die wordt gebruikt om bepaalde operaties uit te voeren vermenigvuldigd met de kosten per eenheid. Natuurlijk moeten brandstofkosten worden betaald, ongeacht of de transactie succesvol is of niet.</p>
<p>Op het Ethereum-mainnet moet gas worden betaald in de lokale valuta van Ethereum, ETH. Het is vermeldenswaard dat brandstof meestal geprijsd is in Gwei, een maateenheid voor Ether. Een Gwei is gelijk aan één miljardste van een Ether-munt. Gwei is een afkorting voor giga wei, wat één miljard wei betekent. Eén gwei is gelijk aan één miljard wei, vernoemd naar Wei Dai, de uitvinder van b-money (opent in een nieuw tabblad), en is de kleinste eenheid van Ether.</p>
<p>Kortom, de veiligheid van het Ethereum-netwerk profiteert van het brandstofkostenmechanisme. Elke berekening die in het netwerk wordt uitgevoerd, vereist betaling, wat het gedrag van kwaadwillende actoren die spamberichten verzenden, effectief beteugelt. Om de efficiëntie en veiligheid van de uitvoering van de code te garanderen, moet elke transactie beperkingen instellen op de stappen voor het berekenen van uitvoerbare code om onbedoelde of kwaadaardige oneindige lussen en andere verspilling van computerbronnen te voorkomen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17145362052.png" alt=""><br>Bron: tastycrypto</p>
<p>De reden waarom de brandstofkosten van Ethereum tijdens een stierenmarkt erg hoog zijn, komt voornamelijk door de toename van de werklast van on-chain interacties. Gebruikers zijn vaak bereid om hogere fooien te betalen om de kans op verwerking van transacties te verbeteren en ervoor te zorgen dat hun biedingen die van andere gebruikers kunnen overtreffen.</p>
<p>Bovendien kunnen complexe smart contracttoepassingen tal van operaties vereisen tijdens de uitvoering, wat resulteert in het verbruik van een grote hoeveelheid brandstof, wat ook een belangrijke reden is voor de stijging van de brandstofkosten.</p>
<p>Duidt de lage gasprijs van Ethereum op een marktdieptepunt?<br>Volgens de bewakingsgegevens van Santiment heeft de mediaan van de gasprijs op het Ethereum mainnet onlangs een drievoudig dieptepunt bereikt. Op 27 april bedroeg de mediaan van de gasprijs slechts 6,43 gwei en daalde de gemiddelde transactiekosten tot onder $2,6 per transactie, de zevende laagste dagelijkse mediaan van de afgelopen drie jaar.</p>
<p>Overeenkomstig is de omloopvoorraad van Ethereum in de afgelopen zeven dagen met meer dan 10.000 eenheden gestegen, waarmee het zijn hoogste niveau heeft bereikt sinds 14 maart.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17145361793.png" alt=""><br>Bron: Ultrasound Money</p>
<p>Geeft dit aan dat Ethereum op een bevriezingspunt in marktsentiment staat en op het punt staat een ommekeer en opwaartse trend te ervaren?</p>
<p>Over het algemeen dient gas op het Ethereum-netwerk vaak als een barometer van sentiment op de cryptomarkt. Wanneer het marktsentiment hoog is en investeerders over het algemeen optimistisch zijn over de opwaartse vooruitzichten van de prijzen van crypto-activa, pieken de transactiekosten vaak. Daarentegen, wanneer het marktsentiment laag is en mensen over het algemeen geloven dat de cryptomarkt in een neergang verkeert, dalen de transactiekosten vaak naar lagere niveaus.</p>
<p>De nauwe relatie tussen handelskosten en marktsentiment kan de cyclische kenmerken van de cryptomarkt onthullen. De piek van transactiekosten komt vaak overeen met het hoogtepunt van Ethereum-prijzen, terwijl de trog van transactiekosten meestal vlakbij de bodem van prijzen optreedt. Deze overeenkomst biedt ons een venster om de dynamiek van de cryptomarkt te observeren, wat ons helpt om de ups en downs van de markt beter te begrijpen.</p>
<p>Zoals te zien is in de onderstaande figuur, lag de gemiddelde kost van Ethereum on-chain transacties begin december 2022 en begin oktober 2023 slechts onder de $1.15, en de bijbehorende ETH-prijs bevond zich ook op dat moment op de tijdelijke bodempositie.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17145361634.png" alt=""><br>Bron: santiment</p>
<p>In februari van dit jaar klommen de gasvergoedingen van Ethereum naar een hoogste punt in acht maanden als gevolg van de markthype over de experimentele tokenstandaard ERC-404. Echter, naarmate de prijzen van ETH geleidelijk daalden na een hoogtepunt van bijna $4.100 op 12 maart, koelde het marktsentiment opnieuw af. De gasvergoedingen bleven afnemen en bereikten hun laagste dagelijkse niveau sinds 18 oktober.</p>
<h2 id="h2-In20de20korte20termijn20enigszins20traag20met20veel20ruimte20voor20groei20op20lange20termijn237568"><a name="In de korte termijn enigszins traag, met veel ruimte voor groei op lange termijn" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In de korte termijn enigszins traag, met veel ruimte voor groei op lange termijn</h2><p>We hebben gemerkt dat veel waarnemers geloven dat de huidige lage gasprijs de markt zal helpen losbreken uit zijn huidige stagnatie. Er wordt verwacht dat dit Ethereum naar een herstelmarkt zal drijven.</p>
<p>De huidige marktomstandigheden beïnvloeden vaak investeerders. Zoals Sentiment beschrijft, zijn investeerders in een opgewekte omgeving zeer optimistisch en geloven ze dat de prijzen naar de maan zullen gaan. Echter, wanneer de prijzen dalen, zoeken ze vaak naar grootschalige redenen voor een marktdaling.</p>
<p>Deze verandering in consensus sentiment wordt echter vaak weerspiegeld in transactiekosten. Zoals we kunnen waarnemen uit bovenstaande grafiek, zal gas blijven stijgen wanneer de markt actief welvarend is, terwijl het zal dalen tot een zeer laag niveau wanneer de markt ondergewaardeerd raakt.</p>
<p>Maar als we beter kijken, moeten we erkennen dat de daling van gas wijst op een marktdaling, maar het is moeilijk om nauwkeurige oordelen te maken over wanneer het zal omkeren en of het zal blijven dalen.</p>
<p>Als we het puur technisch bekijken, is Ethereum, zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>, heeft al zijn eerste bearish candlestick gezien na zes opeenvolgende bullish dagen, wat zeer vergelijkbaar is met verschillende historische trends, en er zijn nog steeds verwachtingen van verdere neerwaartse ontwikkelingen in de toekomst.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17145361465.png" alt=""><br>Bron: Gate.io</p>
<p>Vanuit financieel oogpunt zijn er vaak geruchten op de markt dat de Amerikaanse SEC naar verwachting in mei geen spot Ethereum ETF zal goedkeuren, wat de huidige speculatie over de voortgang van ETF’s zal temperen. Volgens Lookonchain monitoring, hoewel er veel fondsen blijven investeren in ETH, is er nog steeds een grote hoeveelheid verkoop. Op 29 april verkochten zes grote investeerders meer dan 44.000 ETH (ongeveer $1,4 miljard) nadat de markt was gedaald.</p>
<p>Over het algemeen, hoewel de langetermijnwaarde van ETH verder moet worden vrijgegeven, moet deze mogelijk nog steeds op korte termijn worden aangepast. Enerzijds is er een verwachting van losse macro liquiditeit en anderzijds moet er worden gewacht op de lancering van ecosysteeminnovatie, zoals de recente populaire LRT-herstakingsbaan.</p>
<p>Het is te voorzien dat de lage gasprijs van Ethereum niet houdbaar zal zijn en dat de huidige lage kostenomgeving gebruikers deels zal aanmoedigen om terug te keren, wat zal helpen bij het herstel van de prijzen. Op weg naar openheid en wereldwijde toegankelijkheid van Ethereum maken we ons niet alleen zorgen over de prijsschommelingen, maar blijven we ook letten op het groeipotentieel van de waarde van de smart contract markt.</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 voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards