QnV0ZXJpbiBwbGFhZ3QgbWV0IGVlbiBiYWFuYnJla2VuZGUgdXBncmFkZSBkaWUgZWVuIHZlcnNjaHVpdmluZyB2YW4gMTAwWCB6b3Uga3VubmVuIHppam4=

2023-08-03, 08:56

<p><img src="https://gimg2.gateimg.com/image/article/1691051921SDFX.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen203294"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain zal binnenkort rollups lanceren die de capaciteit ervan zullen vergroten.</p>
<p>Larry Fink, de legendarische chief utive van BlackRock, heeft voorspeld dat cryptocurrencies beter zullen presteren dan traditionele valuta’s.</p>
<p>Account abstractie op de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain zal gebruikers in staat stellen om hun externe wallet adressen te veranderen naar op smart contract gebaseerde adressen.</p>
<p>ETH is er niet in geslaagd om boven $2.000 uit te breken omdat het vastzit in een kanaal dat onder dat prijsniveau ligt.</p>
<h2 id="h2-Introductie341228"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Al lange tijd hebben Ethereum-schaaluitdagingen invloed op veel investeerders en gebruikers. Als zodanig is het een belangrijk onderwerp gebleven in de blockchainsector, gezien het feit dat Ethereum op dit moment een van de grootste netwerken is.</p>
<p>Onlangs heeft medeoprichter van Ethereum, Vitalik Buterin, laten doorschemeren hoe ze van plan zijn het schaalprobleem van ETH op te lossen. In deze post leggen we uit wat er moet gebeuren om Ethereum met 100X te schalen.<br>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/758/vitalik-buterin-explains-why-you-should-keep-holding-your-bitcoins" target="_blank">Vitalik Buterin legt uit waarom u uw bitcoins moet blijven vasthouden</a></p>
<h2 id="h2-Belangrijke20cryptocurrencies20registreren20hoge20prijzen843714"><a name="Belangrijke cryptocurrencies registreren hoge prijzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijke cryptocurrencies registreren hoge prijzen</h2><p>De historische <a href="https://www.gate.io/blog_detail/2960" target="_blank">SEC vs Ripple uitspraak dat XRP geen cryptosecurity is</a> toen verhandeld op crypto-beurzen, zorgde dit voor prijsstijgingen van grote cryptocurrencies met dubbele cijfers, wat laat zien hoe veerkrachtig de crypto-markt is.</p>
<p>Bijvoorbeeld, op 15 juli de <a href="https://www.gate.io/fr/blog_detail/2927/ripple-price-after-victory" target="_blank">prijs van XRP is met 98% gestegen</a> om te handelen op $0,93 terwijl die van Ethereum coin met 8% steeg. Ook steeg de waarde van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> boven $31.000. Verder stegen de waarden van <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (SOL), <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> (ADA) en Binance Chain munt ( <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>) is ook scherp gestegen.</p>
<p>Lees ook: <a href="https://www.gate.io/fr/blog_detail/2961/290m-in-liquidation-as-altcoins-rally-crushes-short-positions" target="_blank">$290M aan liquidatie als Altcoins Rally verplettert short posities</a></p>
<p>Ook recentelijk, <a href="https://www.gate.io/uk/bitwiki/detail/809" target="_blank">BlackRock</a> veroorzaakte een prijsstijging van verschillende cryptocurrencies, waaronder ETH en Bitcoin, toen Larry Fink, de legendarische CEO van BlackRock, toegaf dat hij verwacht dat cryptocurrencies fiatvaluta’s zoals de Amerikaanse dollar zullen ‘overstijgen’.</p>
<p>Lees ook: <a href="https://www.gate.io/fr/blog_detail/2904/tether-usdt-poised-to-outpace-blackrocks-profits-in-2023-say-analysts &quot;Tether (USDT" rel="nofollow noopener noreferrer" target="_blank">Tether (USDT) zal naar verwachting in 2023 de winst van BlackRock overtreffen, aldus analisten.</a> Volgens analisten zal het naar verwachting de winst van BlackRock in 2023 overtreffen.</p>
<p>In feite zei hij in een interview met CNBC: “Belangrijk is dat vanwege de internationale aard [van crypto] het elke valuta in valutawaardering zal overstijgen.”</p>
<p>Hij voegde eraan toe: ‘Meer en meer van onze wereldwijde investeerders vragen ons naar crypto.’ Hij zei dit terwijl hij de stap van BlackRock uitlegde om zich aan te melden voor de Amerikaanse spotmarkt. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> beursgenoteerd fonds (ETF) bij de Securities and Exchange Commission (SEC).</p>
<p>Fink benadrukte verder dat BlackRock er alles aan zal doen om de investering in andere activaklassen te democratiseren door middel van ETF’s. Hij voegde eraan toe: ‘We werken samen met onze regelgevers, want als BlackRock’s naam erop staat, zorgen we ervoor dat het veilig en beschermd is, zoals in elke nieuwe markt.’</p>
<p>Ondertussen blijven baanbrekende ontwikkelingen plaatsvinden binnen de crypto-ruimte. Zo sprak Buterin onlangs bijvoorbeeld over een game-changing upgrade die kan resulteren in 100X schaalvergroting voor de blockchain en zijn account abstractie functie.</p>
<p>Lees ook: <a href="https://www.gate.io/fr/blog_detail/2962/ethereum-surges-to-2-000-marking-its-first-return-to-this-level-since-may-driven-by-the-xrp-ruling" target="_blank">Ethereum stijgt tot $2.000, wat de eerste keer is sinds mei dat het dit niveau bereikt, gedreven door de XRP-uitspraak.</a></p>
<h2 id="h2-Buterin20van20plan20om20Account20Abstractie20te20introduceren3333"><a name="Buterin van plan om Account Abstractie te introduceren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Buterin van plan om Account Abstractie te introduceren</h2><p>Tijdens de Ethereum Community Conference in Parijs in 2022 sprak Buterin over het introduceren van account abstractie. Het beste aan deze functie is dat er geen verandering zal zijn in het onderliggende protocol.</p>
<p>Met account abstractie kunnen gebruikers hun externe portefeuilles omzetten in op slimme contracten gebaseerde portefeuilles, waardoor ze hun herstelzin gemakkelijk kunnen herstellen. Sterker nog, deze functie stelt elke portefeuille in staat om als een slim contract te fungeren dat de gebruiker kan beheren.</p>
<p>Account abstractie zal met verschillende voordelen komen, zoals lagere transactiekosten, verbeterd door transacties zonder handtekening. Buterin legde uit hoe dit zal werken. Hij zei: “Het idee hier is als er technieken zijn die het vormen van veel handtekeningen van willekeurige transacties mogelijk maken en deze combineren tot één object dat veel kleiner is en veel sneller kan worden geverifieerd dan het individueel en afzonderlijk verifiëren van alle account abstractie transacties.”</p>
<p>Met deze functie kunnen gebruikers andere cryptocurrencies ontvangen die ze kunnen gebruiken om transactiekosten te betalen zonder ze om te zetten naar ETH.</p>
<h2 id="h2-X10020Ethereum20Blockchain20Schaalbaarheid83876"><a name="X100 Ethereum Blockchain Schaalbaarheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>X100 Ethereum Blockchain Schaalbaarheid</h2><p>Op de Tim Ferris Podcast sprak Buterin over de mogelijkheid om de blockchain met meer dan 100 keer te schalen door gebruik te maken van rollups en shards. Het langetermijndoel van Ethereum is om rollups en sharding te combineren om een ​​synergetisch effect te creëren dat de capaciteit van het Ethereum-netwerk zal vergroten.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/77" target="_blank">Ethereum Laag 2: Een Upgrade van Schaalbaarheid</a></p>
<p>Volgens Buterin zal Ethereum echter eerst rollups introduceren. De rollups zijn secundaire schaaloplossingen waarbij transactiegegevens worden verwerkt en opgeslagen op side-chains voordat ze worden gebundeld en doorgestuurd naar het Ethereum-mainnet. De rollups zijn in staat om de transactiecapaciteit van het netwerk met 100 keer te verhogen.</p>
<p>Buterin gelooft ook dat het Ethereum-netwerk de capaciteit heeft om tussen de 1.000 en 4.000 transacties per seconde te verwerken, afhankelijk van hun aard en omvang. Hij gaf ook een hint dat <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> zal binnen ongeveer een maand haar rollups introduceren.</p>
<p>Verder zei Buterin dat sharding, wat inhoudt dat grote hoeveelheden gegevens in kleinere eenheden worden opgesplitst, later zal komen en de transactionele prestaties van Ethereum verder zal verbeteren. Hiermee zou het verwachte schaalmechanisme van Ethereum de transactiecapaciteit van de Ethereum blockchain met 1000X moeten verhogen.</p>
<p>Lees ook: <a href="https://www.gate.io/fr/blog_detail/2905/a-comprehensive-guide-on-verifying-ethereum-transactions" target="_blank">Een uitgebreide gids over het verifiëren van Ethereum-transacties</a></p>
<h2 id="h2-ETH20slaagt20er20niet20in20om20boven20de20200020uit20te20komen339895"><a name="ETH slaagt er niet in om boven de $2.000 uit te komen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH slaagt er niet in om boven de $2.000 uit te komen</h2><p>Ondanks de besproken ontwikkelingen handelt ETH nog steeds onder de $2.000. Momenteel zit Ethereum vast in het bereik tussen $1.800 en $2.000. Echter, de ETH-prijs is nu al een maand lang niet in staat geweest om boven de $2.000 uit te breken. Gedurende het grootste deel van juli schommelt ETH tussen $1.850 en $1.950.<br>Als ETH boven het ondersteuningsniveau van $1.950 uitbreekt, is het waarschijnlijk dat het boven $2.000 zal stijgen. Op basis van de huidige verkoopdruk en de activiteiten van bull-whales is het zeer onwaarschijnlijk dat de <a href="https://www.gate.io/price/ethereum-eth" target="_blank">Ethereumprijs</a> zal in de nabije toekomst onder de $ 1.800 dalen, tenzij daar een sterke katalysator voor is.</p>
<p>Ook had ETH in deze periode een laagtepunt van $1.842 en een hoogtepunt van $1.904. Op het moment van schrijven, op 30 juli, werd ETH verhandeld tegen $1.876,13, met een winst van 0,1% in de afgelopen 7 dagen.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/ethereum-eth" target="_blank">ETH Prijsvoorspelling &amp; Prognose voor 2023, 2025, 2030</a></p>
<h2 id="h2-Conclusie959848"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Vitalik Buterin, de mede-oprichter van Ethereum, gaf aan dat de blockchain een game-changing ETH-upgrade zal krijgen die de transactiecapaciteit met ongeveer 100X zal verhogen. Enkele verwachte ontwikkelingen zijn onder meer de introductie van rollups en shards. Desalniettemin is ETH, net als de rest van de belangrijkste cryptocurrencies, gebonden binnen een prijskanaal en is het er niet in geslaagd om boven de $2.000 uit te breken.</p>
<h2 id="h2-Veelgestelde20vragen20over20Ethereum968729"><a name="Veelgestelde vragen over Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Ethereum</h2><p>Hoeveel kost één ETH?</p>
<p>De prijs van Ethereum schommelt momenteel tussen $ 1.800 en $ 2.000. Het heeft echter het potentieel om tegen het einde van 2023 de $ 2.000 te overschrijden.</p>
<p><strong>Hoeveel Ethereum is er over?</strong></p>
<p>Ethereum heeft momenteel een circulerende voorraad van 120.181.083 munten. De voorraad ETH neemt echter toe met ongeveer 5 munten per 14 tot 15 seconden.</p>
<p><strong>Wat was de prijs van ETH bij de lancering?</strong></p>
<p>Toen ETH in 2015 werd gelanceerd, had het een waarde van $0.311. Desalniettemin wordt het momenteel verhandeld tussen $1.800 en $2.000.</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 standpunten van de onderzoeker en vormt geen beleggingsadviezen.<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 zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>