S29ydGUgb3BsZXZpbmc6IEV0aGVyZXVtLWtvc3RlbiBiZXJlaWtlbiAkMTAwIG5hIEJsYWNrUm9jaydzIEVUSC1pbmRpZW5pbmc=

2023-11-22, 02:56

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>BlackRock heeft een aanvraag ingediend voor een ETH ETF in de Verenigde Staten.</p>
<p>De prijs van ETH steeg naar $2.100 toen de markt hoorde over de aanvraag van BlackRock’s <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF.</p>
<p>Op 9 november stegen de ETH-gaskosten naar 270 Gwei als gevolg van een toename van de vraag naar de munt.</p>
<p>Sleutelwoorden: <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF, crypto-ETF’s, ETH-ETF, ETH-prijs, spot ETH-ETF, spot ethereum-ETF, ETH-ETF-goedkeuring, BlackRock heeft papierwerk ingediend, Securities and Exchange Commission, BlackRock dient ETH-ETF in, BlackRock ethereum-ETF-rally</p>
<h2 id="h2-Introductie378917"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Hoewel de Amerikaanse Securities and Exchange Commission (SEC) nog niet verschillende spot heeft goedgekeurd <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Na eerder dit jaar ingediende aanvragen voor exchange-traded funds heeft BlackRock nu een andere crypto-ETF aangevraagd, namelijk een spot ETH-ETF.</p>
<p>Nu kijken we in dit artikel naar de impact van de indiening van BlackRock’s spot Ethereum ETF op de prijs van ETH en de transactiekosten.</p>
<h2 id="h2-BlackRock20dient20een20ETH20ETF20in20bij20de20Verenigde20Staten765082"><a name="BlackRock dient een ETH ETF in bij de Verenigde Staten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BlackRock dient een ETH ETF in bij de Verenigde Staten</h2><p>Op 9 november, <a href="https://www.gate.io/bitwiki/detail/809" target="_blank">BlackRock</a> NASDAQ heeft namens BlackRock, de toonaangevende vermogensbeheerder met een waarde van $9 biljoen, een aanvraag ingediend voor een spot Ethereum exchange traded fund (ETF) bij de Amerikaanse Securities and Exchange Commission (SEC). In feite heeft NASDAQ het formulier 19b-4 ingediend.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/1643/blackrock-launches-blockchain-related-etf-for-european-markets." target="_blank">BlackRock lanceert Blockchain-gerelateerde ETF voor Europese markten</a></p>
<p>Het voorgestelde ETH ETF genaamd iShares Ethereum Trust geeft de ambitie van BlackRock aan om het aantal spot crypto ETF’s te verhogen, nadat ze een aanvraag hebben ingediend voor een <a href="https://www.gate.io/bitwiki/detail/731/bitcoin-etfs" target="_blank">bitcoin ETF</a> die wacht op goedkeuring van de SEC. Op dezelfde datum verwierf het bedrijf de BlackRock iShares Ethereum Trust in Delaware als een voorlopige stap naar het aanvragen van een ETH ETF.</p>
<p>In de context is iShares van BlackRock de naam van zijn ETF-divisie. In juni gebruikte het dezelfde divisie <a href="https://www.gate.io/ru/blog_detail/3434/bitcoin-etf-approval-potential-catalyst-for-historic-crypto-bull-run" target="_blank">om zijn Bitcoin ETF te registreren</a> Dergelijke ontwikkelingen tonen de toewijding van het vermogensbeheerbedrijf aan cryptocurrencies.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2841" target="_blank">De ETF-aanvraag van BlackRock zorgt voor een positief sentiment, Bitcoin Shorts verliezen $16 M</a></p>
<p>De betrokkenheid van BlackRock in de cryptowereld weegt zwaar mee, gezien het ‘s werelds grootste vermogensbeheerder is. Als het wordt goedgekeurd, zullen spot crypto ETF’s veel financiële investeringen aantrekken. Het is belangrijk op te merken dat een spot crypto ETF een beter beleggingsinstrument is. <a href="https://www.gate.io/blog_detail/3135" target="_blank">dan een op futures gebaseerde ETH</a> of <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ETF.</p>
<p>Natuurlijk is de spot Ethereum ETF een gereguleerd beleggingsinstrument dat beleggers blootstelling geeft aan Ether zonder het vast te houden. Voor de vermogensbeheerders heeft de ETH ETF een voordeel ten opzichte van de BTC ETF doordat ze de ETH die de spot ETH ETF’s ondersteunt kunnen staken.</p>
<h2 id="h2-De20prijs20van20ETH20is20gestegen20naar202100589026"><a name="De prijs van ETH is gestegen naar $2.100" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De prijs van ETH is gestegen naar $2.100</h2><p>Na het nieuws over het indienen van het BlackRock spot ETH ETF-bestand steeg de ETH-prijs naar $2.100. Dat was het gevolg van ETH-beleggers die de markt opdreven, resulterend in de prijs van de altcoin die bijna een hoogtepunt van 6 maanden bereikte. Kortom, de BlackRock Ethereum ETF-rally stelde ETH in staat om het weerstandsniveau van $2.000 te doorbreken.</p>
<p>Er is momentum aan het opbouwen in de cryptocurrency sector <a href="https://www.gate.io/blog_detail/3424/how-the-highly-anticipated-spot-bitcoin-etf-impacts-the-market" target="_blank">als gevolg van de aanvragen voor de spot bitcoin ETF</a> ingediend door verschillende vermogensbeheerders, waaronder BlackRock en Fidelity. Nu geeft de indiening van BlackRock voor een spot ETH ETF aan dat er institutionele interesse is in crypto-derivaten.</p>
<p>Volgens een vooraanstaande analist kan de activiteit van de walvis de prijsdynamiek van de altcoin verder stimuleren. <a href="https://twitter.com/ali_charts/status/1722865923399258557" rel="nofollow noopener noreferrer" target="_blank">Ali zei</a>“Ethereum heeft de drempel van $2.000 weer bereikt en interessant genoeg gebeurt dit allemaal voordat de walvissen zelfs maar zijn begonnen met het kopen van $ETH!”</p>
<p>Desalniettemin kan de prijs van ETH terugtrekken als gevolg van de activiteit van ETH-investeerders die longposities hebben ingenomen op $1.900 en hun bezittingen willen verkopen wanneer de waarde de prijs van $2.000 overschrijdt.</p>
<p>Een crypto-analist Pentoshi, met meer dan 711K volgers op X, reageerde op de recente ETH-prijsbeweging. Hij/zij zei: “Een paar gedachten over $ETH hier: Het is niet zo hoog gekomen om op zijn minst de jaarlijkse hoogtepunten te halen. Laat misschien eerst wat shorts opbouwen in dat gebied om de liquiditeit op te bouwen.”</p>
<p>De analist voegde eraan toe: ‘Als $BTC etf wordt goedgekeurd, is er een goede kans dat ETH harder stijgt.’</p>
<p>Echter heeft Santiment erop gewezen dat de recente stijging van 38% van de ETH in de afgelopen vier weken niet alleen het gevolg was van de momentum die voortkomt uit crypto ETF-aanvragen. Het was ook het gevolg van de uitbreiding van zijn netwerk. Zo heeft het onlangs meer dan 100.000 nieuwe ETH-adressen geregistreerd die meer dan 0,1 ETH bevatten.</p>
<p>Nadat BlackRock papierwerk indiende voor spot Ethereum ETF, stegen ook de prijzen van verschillende andere cryptocurrencies. Als voorbeeld bereikte bitcoin een nieuwe prijs van 18 maanden van $ 38.000, in vergelijking met $ 35.000 binnen dezelfde dag. Later op de dag zakte de prijs echter terug naar $ 36.300.</p>
<p>De recente prijsstijging van ETH heeft het in staat gesteld om een grotere marktdominantie te verwerven dan voorheen. Sterker nog, de dominantie nam toe met 1,3 procentpunten en staat nu op 17%. Ondanks de hype rond ETF’s kan het even duren voordat de goedkeuring van een ETH ETF plaatsvindt, aangezien de SEC een voorzichtige benadering hanteert ten aanzien van deze cryptoderivaten.</p>
<p>Opvallend genoeg hebben veel crypto-ETF’s nog steeds <a href="https://www.gate.io/blog_detail/3289/sec-postpones-decision-on-spot-bitcoin-etfs-from-blackrock-and-others" target="_blank">wacht op de goedkeuring van de SEC</a> Zoals we weten, heeft de SEC nog geen enkele spot crypto ETF goedgekeurd. In plaats daarvan heeft de Verenigde Staten verschillende <a href="/price/optimism-op" target="_blank" class="blog_inner_link">op crypto</a> futures gebaseerde ETF’s.</p>
<h2 id="h2-ETH20Gas20is20gestegen20tot2027020Gwei968546"><a name="ETH Gas is gestegen tot $270 Gwei" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH Gas is gestegen tot $270 Gwei</h2><p>Op donderdag 9 november, hoewel de markt de plotselinge prijsstijging van ETH vierde, vond er een ontmoedigende ontwikkeling plaats. De Ethereum-gasvergoedingen stegen naar 270 Gwei, waarmee een niveau werd bereikt dat voor het laatst werd waargenomen in juni 2022. De piek in transactiekosten was het gevolg van de hoge vraag naar ETH.</p>
<p>De sterke stijging van de ETH transactiekosten heeft invloed gehad op de kosten van het verhandelen van swaps. Specifiek moesten handelaren tussen de $60 en $100 per transactie betalen. Opmerkelijk is dat de stijging van de gasvergoedingen het gevolg was van de BlackRock ethereum ETF-rally, die leidde tot veel vraag naar de munt en daardoor een netwerkcongestie veroorzaakte.</p>
<p>Dergelijk scenario geeft aan welke uitdaging de Ethereum blockchain momenteel heeft, namelijk netwerkcongestie en schaalbaarheid. We weten echter dat het Ethereum-ontwikkelingsteam blijft zoeken naar oplossingen voor de problemen, waaronder Ethereum 2.0.</p>
<h2 id="h2-Mogelijk20bezwaar20van20de20SEC20tegen20toezicht987387"><a name="Mogelijk bezwaar van de SEC tegen toezicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mogelijk bezwaar van de SEC tegen toezicht</h2><p>BlackRock heeft één belangrijk aspect dat de SEC kan beïnvloeden om zijn crypto-ETF’s goed te keuren. Het is de surveillancedeelovereenkomst met Coinbase die zal helpen om frauduleuze activiteiten op de spotmarkt op te sporen.</p>
<p>Hiermee samenhangend, <a href="https://listingcenter.nasdaq.com/assets/rulebook/nasdaq/filings/SR-NASDAQ-2023-045.pdf" rel="nofollow noopener noreferrer" target="_blank">het indienen vermeldt</a>‘Ofwel kan CME-toezicht frauduleuze praktijken op de spotmarkt detecteren die zowel futures ETF’s als spot-beurs verhandelde producten beïnvloeden, ofwel kan dat toezicht dit niet doen voor beide soorten producten.’</p>
<p>Het voegde eraan toe: “Na goedkeuring van ETH futures ETF’s op basis van dergelijk toezicht, heeft de Commissie duidelijk bepaald dat het toezicht van CME frauduleuze praktijken op de spotmarkt kan detecteren die van invloed zouden zijn op spot ETP’s, en de Sponsor is dus van mening dat het ook spot ETH ETP’s op die basis moet goedkeuren.”</p>
<p>Die surveillanceregeling zal naar verwachting de SEC vertrouwen geven in het potentieel van BlackRock om een Ethereum ETF te beheren met weinig kans op marktmanipulatie. Dit komt omdat Coinbase een gerespecteerde en gevestigde gereguleerde cryptomarkt is.</p>
<h2 id="h2-Conclusie211693"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De ETH-prijs steeg op 9 november na het indienen van de papieren van BlackRock over spot Ethereum ETF. De Ethereum ETF-rally resulteerde in ETH die het weerstandsniveau van $2.000 doorbrak om $2.100 te bereiken. Deze prijsstijging ging echter gepaard met een tijdelijke piek van ETH-gasvergoedingen tot ongeveer 270 Gwei. Ondertussen is BlackRock van mening dat het heeft voldaan aan de basisvereisten voor goedkeuring van spot Ethereum door de SEC.</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 visie van de onderzoeker en vormt geen beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel te delen, mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen bij schending van het auteursrecht.<br></div><p></p><br></div></div></div>