RXRoZXJldW0gUHJpanMgTmlldXcgTGFhZz8gV2F0IEdlYmV1cnQgRXIgQWxzIEJpdGNvaW4gT3ZlcnNjaGFrZWx0IG5hYXIgUE9TPw==

2023-10-12, 07:43

<p><img src="https://gimg2.gateimg.com/image/article/1697095974SDFX 1.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen723811"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Sinds het begin van het jaar heeft ETH een stijging van de prijs van 36% op jaarbasis gehad.</p>
<p>Op 20 september bereikte de ETH-prijs zijn laagste punt tegenover <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> binnen de laatste 14 maanden</p>
<p>Crypto-regulering, afname van concurrentie en goedkeuring van ETH ETF’s kunnen de druk opvoeren <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> omhoog</p>
<h2 id="h2-Introductie560885"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De relaties tussen de waarden van verschillende activa binnen dezelfde categorie, zoals cryptocurrencies, kunnen ons een indicatie geven van hoe de markt zich ontwikkelt en welke maatregelen we als investeerders of bedrijven kunnen nemen.</p>
<p>Vandaag kijken we naar de relatie tussen <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> en <a href="https://www.gate.io/learn/category/ethereum &quot;Ether (ETH" rel="nofollow noopener noreferrer" target="_blank">Ether (ETH)</a> We zullen ook de mogelijkheid onderzoeken van de bitcoin blockchain om over te schakelen van het proof-of-work consensusmechanisme naar het proof-of-stake mechanisme.</p>
<h2 id="h2-ETH20stijgt20met203620in20prijs20sinds20het20begin20van20het20jaar598325"><a name="ETH stijgt met 36% in prijs sinds het begin van het jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH stijgt met 36% in prijs sinds het begin van het jaar</h2><p>Voordat we kijken naar de relatie tussen de waarden van BTC en ETH, laten we de recente en huidige prijsbewegingen van ETH bespreken. ETH heeft tot nu toe in 2023 een stijging van de prijs met 36% ten opzichte van de Amerikaanse dollar ervaren.</p>
<p>In vergelijking hiermee is dit een redelijke prijsprestatie, gezien het feit dat <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ongeveer 66% lager handelt dan zijn hoogste niveau dat het bereikte in november 2022. Het hoogste niveau ooit voor de Ether-prijs is $4.870.</p>
<h2 id="h2-ETH20vs20Bitcoin20Prijsvergelijking895348"><a name="ETH vs. Bitcoin Prijsvergelijking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH vs. Bitcoin Prijsvergelijking</h2><p>We kunnen ook de prestaties van de ETH-markt meten door een analyse te maken van Ethereum vs. <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">wijzigingen in de prijs van bitcoin</a>. Op 20 september bereikte de ETH-prijs zijn laagste punt tegenover bitcoin in de afgelopen 14 maanden toen het onder het ondersteuningsniveau van 0,06 BTC viel.</p>
<p>De cryptocurrency markt is echter niet op de hoogte van de exacte oorzaken van zo’n Ethereum prijsdaling. De volgende grafiek geeft het weer. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> tegen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> analyse.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1697096098ETH  Price Low.png" alt=""><br>ETH vs. Bitcoin Prijsvergelijking - TradingView</p>
<p>Zoals de bovenstaande afbeelding laat zien, is de waarde van ETH ten opzichte van bitcoin sinds oktober 2022 gedaald. Echter, zoals we kunnen zien, heeft de situatie een kritiek punt bereikt, aangezien de waarde van ETH onlangs onder het ondersteuningsniveau van 0,060 BTC is gedaald, iets dat de cryptocurrency markt heeft gedwongen om de echte oorzaken van de huidige trend van de Ethereum-prijs in twijfel te trekken.</p>
<p>De trieste realiteit is dat de huidige daling van de ETH-prijs plaatsvindt tegen de achtergrond van verschillende infrastructuurveranderingen op de blockchain waarop de ETH-markt had verwacht dat dit zou resulteren in een rally van de munt.</p>
<p>Een van de belangrijkste ontwikkelingen op de blockchain was de overgang van Ethereum van het proof-of-work consensusmechanisme naar het proof of stake-mechanisme, die plaatsvond in september 2022.</p>
<p>In feite had de ETH-markt zich voorgesteld dat de upgrade een bullish momentum zou kunnen creëren dat zou kunnen stimuleren <a href="https://www.gate.io/futures_info_new/futures/usdt/ETH_USDT" target="_blank">Ether prijs</a> boven de $10.000. Dit komt doordat de upgrade de uitgiftegraad van ETH heeft verlaagd.</p>
<p>Halverwege september 2022 kondigde het Ethereum-ontwikkelingsteam aan dat de uitgifte van ETH was verlaagd naar 0,25 van het aanbod.</p>
<p>De andere opmerkelijke ontwikkeling van het Ethereum-netwerk was de lancering van de Shapella-upgrade op 12 april 2023, waardoor miners hun gestaakte ETH kunnen opnemen uit het native stakingprotocol.</p>
<p>De Shapella-upgrade heeft één belangrijke zorg van Ethereum-investeerders aangepakt. Voorheen maakten ETH-investeerders zich zorgen dat ze hun munten voor onbepaalde tijd moesten inzetten. Desalniettemin werd deze hindernis weggenomen toen de blockchain de Shapella-upgrade lanceerde, waardoor Ethereum-investeerders hun munten kunnen opnemen. <a href="https://www.gate.io/blog_detail/3103/analyzing-eth-price-impact-eth-staking" target="_blank">gestakede ETH</a>.</p>
<p>Na deze belangrijke mijlpaal in het netwerk, de <a href="https://www.gate.io/bitwiki/detail/102/ethereum" target="_blank">ETH-markt</a> verwachtte een voortdurende stijging van de Ethereum-prijs. Helaas gingen de dingen niet zoals verwacht, want de prijs begon te dalen. Bijvoorbeeld, de ETH-prijs daalde tot $1,850 een week na de Shapella-upgrade.</p>
<p>Er was iets opmerkelijks en onverwachts. De ETH-markt had verwacht een toename te zien in netto ETH-opnames na de upgrade. Echter, het tegenovergestelde was waar. Er was een <a href="https://www.gate.io/learn/articles/how-to-stake-eth/209" target="_blank">toename in Ethereum staken</a> wat resulteerde in een nettostroom van 3,1 miljoen ETH.</p>
<p>Nu de verwachte stijging van de Ethereum prijs is uitgebleven, willen Ethereum investeerders en de rest van de cryptocurrency markt potentiële katalysatoren identificeren om de Ethereum prijsdaling die sinds april is ervaren, om te keren.</p>
<h2 id="h2-Externe20factoren20die20mogelijk20een20Ethereumprijsopleving20kunnen20veroorzaken193452"><a name="Externe factoren die mogelijk een Ethereum-prijsopleving kunnen veroorzaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Externe factoren die mogelijk een Ethereum-prijsopleving kunnen veroorzaken</h2><p>De ETH-markt wacht op een katalysator om de Ethereum-prijs omhoog te stuwen. De eerste mogelijke katalysator is de volledige overwinning van Ripple op de Amerikaanse Securities and Exchange Commission (SEC).</p>
<p>Volgens de SEC is Ripple schuldig bevonden aan de verkoop van zijn token ( <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>) aan institutionele beleggers zonder het te registreren. In juli oordeelde rechter Analisa Torres echter dat <a href="/price/xrp-xrp" target="_blank" class="blog_inner_link">XRP</a> geen effect is wanneer het aan particuliere beleggers wordt verkocht op crypto-beurzen.</p>
<p>Feitelijk staat ETH voor een vergelijkbaar lot als Ripple, iets wat ethereum-investeerders ontmoedigd heeft. Dit komt doordat ethereum zijn munten heeft verkocht aan institutionele beleggers tijdens de pre-sale. Nu wacht de markt af om te zien of de SEC zich ook op ETH zal richten, zoals bij de Ripple-crypto (XRP) is gebeurd. Als zowel Ripple als ETH worden vrijgesproken, kan dat dienen als een katalysator voor een prijsstijging van Ethereum.</p>
<h2 id="h2-Regelgevende20zekerheid20in20de20VS662764"><a name="Regelgevende zekerheid in de VS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Regelgevende zekerheid in de VS</h2><p>Regelgevingszekerheid in de Verenigde Staten en andere toonaangevende economieën kan dienen als een katalysator voor een ETH-prijsstijging. Bijvoorbeeld, er is geen duidelijkheid over de regelgeving rond de Ether-initial coin offering (ICO).</p>
<p>Overigens heeft het Ethereum-netwerk op 20 september voor het eerst beweging ervaren die verband houdt met de ICO-fase. In feite werd 32,1 ETH die tijdens de initiële muntaanbieding (ICO) van Ethereum werd verworven, overgeboekt naar Coinbase. Desalniettemin is er geen prikkel voor vergelijkbare Ethereum-investeerders om hun op ICO gebaseerde ETH-posities te verplaatsen om de liquiditeit op de markt te vergroten.</p>
<h2 id="h2-Positief20Crypto20Gerelateerd20Nieuws738339"><a name="Positief Crypto Gerelateerd Nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Positief Crypto Gerelateerd Nieuws</h2><p>Sinds de oprichting van gedecentraliseerde valuta in 2009 heeft crypto nieuws een grote invloed gehad op de prijzen van cryptocurrencies zoals ETH en bitcoin. Waarschijnlijk is het beste stukje crypto nieuws dat de prijsstijging van ethereum kan katalyseren, gerelateerd aan crypto-derivaten. Zo kan bijvoorbeeld de goedkeuring van Ethereum exchange traded funds (ETF’s) leiden tot een opwaartse prijssprong van ETH.</p>
<p>Op dit moment wacht de ETH-markt op goedkeuring van de SEC voor ETH ETF’s. De goedkeuring van ETH ETF’s zal waarschijnlijk het risico verminderen dat gepaard gaat met institutionele concentratie in BTC.</p>
<p>Het andere nieuws dat een positieve invloed kan hebben op de Ethereum-prijs heeft betrekking op ontwikkelingen die plaatsvinden op de blockchain. Als voorbeeld kan de aankondiging van Canto, een layer-1 Cosmos-native blockchain, dat het zich uitbreidt naar de Ethereum-blockchain, van invloed zijn op de opwaartse prijsbeweging van ETH.</p>
<p>Canto, een zero-knowledge, toestemmingsloze rollup die compatibel is met de Ethereum Virtual Machine, zal traditionele financiën naar het Ethereum-netwerk brengen.</p>
<p>De goedkeuring van <a href="https://www.gate.io/blog_detail/207/why-do-people-choose-crypto-etfs-what-are-the-advantages-and-disadvantages" target="_blank">bitcoin ETF’s</a> kan ook de prijs van ETH omhoog duwen. Dit komt door het besmettingseffect van de cryptomarkt. In sommige glen, <a href="https://www.gate.io/how-to-buy/ethereum-eth" target="_blank">ETH’s prijsbeweging</a> kan vergelijkbaar zijn met die van bitcoin.</p>
<h2 id="h2-Lage20dreiging20van20concurrentienetwerken753551"><a name="Lage dreiging van concurrentienetwerken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lage dreiging van concurrentienetwerken</h2><p>Als er een afname is van bedreigingen van rivaliserende blockchains <a href="https://www.gate.io/price/ethereum-eth" target="_blank">Ethereum prijs kan stijgen</a>. Een specifiek voorbeeld is dat van <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Ketens die te maken hebben met vergelijkbare risico’s met betrekking tot ICO en effectenwetten. Omdat ze soortgelijke uitdagingen hebben, is de kans kleiner dat ze de marktdominantie van ETH uitdagen.</p>
<h2 id="h2-ETHs20Proofofstake20POS20consensusmechanisme628050"><a name="ETH’s Proof-of-stake (POS) consensusmechanisme" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH’s Proof-of-stake (POS) consensusmechanisme</h2><p>Eerder hebben we verwezen naar de overgang van de Ethereum blockchain van het proof-of-work consensusmechanisme naar de <a href="https://www.gate.io/learn/articles/what-is-proof-of-stake/60" target="_blank">bewijs van aandeel een</a> In eenvoudige bewoordingen is het proof-of-stake consensusmechanisme een gedecentraliseerd systeem dat het netwerk van investeerders, die hun tokens/munten inzetten, in staat stelt transacties op de blockchain te verifiëren. Specifiek moeten ze transacties valideren van de mensen die verkopen of <a href="/how-to-buy/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">koop Ethereum</a>.</p>
<p>Bijvoorbeeld, Ethereum-investeerders die het vereiste minimum ETH hebben gestaked, kunnen transacties op de blockchain verifiëren. Dit is anders dan het proof-of-work-consensusmechanisme dat de bitcoin-blockchain nog steeds gebruikt. In dit g moeten de miners de transacties van individuen verifiëren die verkopen of <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">koop Bitcoin</a>.</p>
<p>Bij POW gebruiken de transactie-validatoren, miners genaamd, hun rekenkracht om complexe cryptografische vergelijkingen op te lossen. Het grote nadeel van PoW, gebruikt door de bitcoin blockchain, is dat het proces veel energie verbruikt. Desondanks is het PoW-consensusmechanisme veiliger dan het <a href="https://www.gate.io/bitwiki/detail/46/proof-of-stake" target="_blank">PoS een</a>.</p>
<p>De reden waarom sommige mensen om de overgang van bitcoin vragen <a href="https://www.gate.io/blog_detail/897/%E5%B7%A5%E4%BD%9C%E8%AF%81%E6%98%8E-vs-%E6%9D%83%E7%9B%8A%E8%AF%81%E6%98%8E" target="_blank">van PoW naar PoS</a> is om het verbruik van elektriciteit te verminderen. Het overgangsproces is echter gecompliceerd omdat er consensus nodig is onder de leden van de gemeenschap.</p>
<p><strong>Gerelateerde artikelen:</strong> <a href="https://www.gate.io/learn/articles/what-is-delegated-proof-of-stake/189 &quot;What Is Delegated Proof of Stake (DPoS" rel="nofollow noopener noreferrer" target="_blank">Wat is Delegated Proof of Stake (DPoS)?</a>?“)<br><a href="https://www.gate.io/learn/articles/what-is-leased-proof-of-stake-and-how-does-it-work/374 &quot;What Is Leased Proof of Stake (LPoS" rel="nofollow noopener noreferrer" target="_blank">Wat is Leased Proof of Stake (LPoS) en hoe werkt het?</a> en hoe werkt het?</p>
<h2 id="h2-De20toekomst20van20Ethereum20en20de20bredere20cryptocurrencymarkt118744"><a name="De toekomst van Ethereum en de bredere cryptocurrencymarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De toekomst van Ethereum en de bredere cryptocurrencymarkt</h2><p>In de nabije toekomst zou het gebruik van cryptocurrencies moeten toenemen, aangezien meer mensen en instellingen ze accepteren. Veel bedrijven zullen belangrijke cryptocurrencies zoals ETH en BTC als betaalmiddel accepteren. Dit is mogelijk vanwege de recente lancering van efficiënte betaalgateways, waardoor het voor veel mensen heel eenvoudig is om transacties uit te voeren met cryptocurrencies.</p>
<p>Ook kunnen verschillende overheden belangrijke cryptocurrencies zoals bitcoin en ETH als wettig betaalmiddel aanvaarden. In het verleden hebben El Salvador en de Centraal-Afrikaanse Republiek aangewezen <a href="https://www.gate.io/blog_detail/107/feature-bitcoin-as-fiat-money-good-move-by-el-salvador" target="_blank">bitcoin als wettig betaalmiddel</a>. Veel mensen uit deze landen kunnen nu grote hoeveelheden bitcoin kopen.</p>
<p>De opkomst van gedecentraliseerde financiën ( <a href="https://www.gate.io/blog_detail/136/what-is-defi-and-how-do-you-invest-in-its-top-product" target="_blank">DeFi</a>) heeft de onbancare of onderbancare in staat gesteld om toegang te krijgen tot financiële diensten. Daarom zal de DeFi-sector naar verwachting in de toekomst blijven groeien.</p>
<p>Bijvoorbeeld, crypto leningen en leningen zullen het voor veel mensen mogelijk maken om financiering tegen een lage rente te krijgen. Dit zal veel mensen ertoe leiden om Ethereum te kopen en als onderpand te gebruiken. <a href="https://www.gate.io/blog_detail/1672/10-best-defi-protocols-to-invest-during-bear-markets" target="_blank">op verschillende DeFi-platforms.</a></p>
<p>We zullen waarschijnlijk ook meer cryptoderivaten hebben, zoals exchange traded funds. Deze kunnen de adoptie van cryptocurrencies zoals ETH en bitcoin verhogen, wat hun prijzen kan opdrijven.</p>
<h2 id="h2-Conclusie805250"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De prijs van Ethereum-munten is sinds april 2023 voortdurend gedaald. Belangrijke upgrades op de blockchain zoals Shapella zijn er niet in geslaagd de vraag naar ETH te vergroten. Toch, <a href="https://www.gate.io/blog_detail/3135/sec-approves-eth-futures" target="_blank">als de SEC ETH ETF’s goedkeurt</a> de ethereum prijs kan stijgen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>