U0VDLWNvbW1pc3NhcmlzIGJlc3ByZWVrdCBoZXQgdm9vcnVpdHppY2h0IHZhbiBnb2Vka2V1cmluZyB2YW4gZWVuIEV0aGVyZXVtIEVURg==

2024-02-08, 16:00
<p><img src="https://gimg2.gateimg.com/image/article/1707407263SDFXnew.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen35566"><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 SEC zal in mei 2024 een beslissing nemen over de ETH ETF van BlackRock.</p>
<p>Hester Peirce, de commissaris van de SEC, heeft laten doorschemeren dat de toezichthouder op een gegeven moment spot ETH ETF’s zou kunnen goedkeuren.</p>
<p>De goedkeuring van ETH ETF’s kan ETH legitimeren als een waardevol beleggingsmiddel.</p>
<h2 id="h2-Inleiding902660"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Er is veel hoop in de cryptocurrency sector dat de Amerikaanse SEC binnenkort goedkeuring zal geven <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> exchange traded funds ( <a href="https://www.gate.io/blog_detail/538/what-are-etfs-etps-etns" target="_blank">ETFs</a>). De markt verwacht dat de goedkeuring binnen de komende 45 dagen zal komen nadat de SEC de definitieve besluitdatum heeft verlengd. De goedkeuring van spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s hebben een sterke precedent geschapen voor ETH ETF’s.</p>
<p>Deze post onderzoekt de opvattingen van één SEC-commissaris over de mogelijkheid van goedkeuring van ETH ETF’s tijdens 2024. We zullen ook kijken naar de redenen voor de vertraging van de SEC bij het nemen van haar definitieve beslissing over <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF-aanvragen.</p>
<h2 id="h2-SEC20nadert20goedkeuring20van20Ethereum20ETF725856"><a name="SEC nadert goedkeuring van Ethereum ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC nadert goedkeuring van Ethereum ETF</h2><p>Op basis van de recente opmerkingen van Hester Peirce, een commissaris van de SEC, zou de Securities and Exchange Commission (SEC) Ethereum ETF’s in de nabije toekomst kunnen goedkeuren. Haar standpunten geven aan dat de positie van de SEC ten aanzien van crypto exchange traded funds (ETF’s) zou kunnen zijn veranderd.</p>
<p>Opmerking van Peirce gaf een <a href="https://youtu.be/b-LmqVMF8I0" rel="nofollow noopener noreferrer" target="_blank">hint op een mogelijke verschuiving in SEC-regelgeving</a> met betrekking tot cryptocurrencies zoals <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> en ETH. Hester Peirce, populair bekend als ‘Crypto Mom’, blijft haar steun uitspreken voor cryptocurrencies. Ze sprak over de correlatie tussen crypto futures en spotmarkten in cryptocurrencies, een perceptie die wijst op de mogelijkheid van goedkeuring van een ETH ETF.</p>
<p>Volgens Peirce zou de benadering van de regelgevende autoriteit ten aanzien van cryptocurrency ETF’s niet afhankelijk moeten zijn van de vraag of een activum al dan niet een effect of een grondstof is. Wat belangrijk is, is het handhaven van een consistente benadering ten aanzien van verhandelde fondsen. Haar standpunt geeft aan dat de SEC een bredere en inclusievere positie zou moeten innemen ten aanzien van ETF’s.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/these-are-the-high-profile-spot-bitcoin-etf-applications-currently-in-pllay/1258" target="_blank">Dit zijn de aanvragen voor high-profile Spot Bitcoin ETF</a></p>
<p>Peirce <a href="https://youtu.be/b-LmqVMF8I0" rel="nofollow noopener noreferrer" target="_blank">zei</a>, ‘We zouden geen rechtbank nodig moeten hebben om ons te vertellen dat onze aanpak willekeurig en grillig is om het goed te doen. Ik hoop zeker dat dat niet het g zal zijn. Mensen zullen naar precedent kijken bij het maken van argumenten voor andere producten en wij zullen, kijkend naar de feiten en omstandigheden, naar verluidt dat precedent toepassen.’</p>
<p>Pierce gelooft dat er geen noodzaak is voor iemand om naar de rechtbank te gaan om de SEC te dwingen ETH ETF’s goed te keuren. Dit komt doordat de rechtbank waarschijnlijk voorrang zal geven aan de zaak, na <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/218" target="_blank">bitcoin ETF</a> goedkeuringen.</p>
<p>Vaak heeft Peirce haar SEC-collega’s bekritiseerd vanwege hun standpunt over cryptogeldkwesties. Coindesk <a href="https://au.finance.yahoo.com/news/eth-etfs-inevitable-195202296.html" rel="nofollow noopener noreferrer" target="_blank">recentelijk gemeld</a> dat de commissaris onlangs kritiek leverde op Gary Gensler, de voorzitter van de SEC, omdat hij ‘een decennium aan kansen heeft verspild om ons werk te doen’ in een ‘onnodige, maar ingrijpende saga’ die in trek zijnde producten bij investeerders heeft weggehouden en ‘retailbeleggers heeft gedreven naar minder efficiënte manieren om Bitcoin te verkrijgen.’</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/learn/articles/crypto-market-investment-outlook-2024/1690" target="_blank">Crypto-marktinvesteringsperspectief voor 2024</a></p>
<p>Ze voegde eraan toe: ‘Het Congres heeft ons niet gemachtigd om mensen te vertellen of een bepaalde investering geschikt voor hen is, maar we hebben administratieve procedures misbruikt om investeringen die we niet leuk vinden achter te houden voor het publiek.’</p>
<h2 id="h2-SEC20vertraagt20beslissing20over20verschillende20EthereumETFaanvragen792340"><a name="SEC vertraagt beslissing over verschillende Ethereum-ETF-aanvragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC vertraagt beslissing over verschillende Ethereum-ETF-aanvragen</h2><p>De SEC heeft zijn definitieve beslissing over de aanvraag van BlackRock’s spot ETH ETF uitgesteld, waardoor de uitspraakdatum met 45 dagen is verschoven. Juridisch gezien was de deadline om een regelwijziging voor die specifieke ETH ETF-aanvraag voor te stellen 25 januari.</p>
<p>In een reactie op de vertraging zei de SEC dat ze nog steeds wachten op publieke feedback over de voorgestelde regelwijziging met betrekking tot de Blackrock ETH ETF. <a href="https://www.sec.gov/files/rules/sro/nasdaq/2024/34-99419.pdf" rel="nofollow noopener noreferrer" target="_blank">zei dat</a>, “De Commissie vindt het passend om een langere periode aan te wijzen waarbinnen actie kan worden ondernomen met betrekking tot de voorgestelde wijziging van de regels, zodat zij voldoende tijd heeft om de voorgestelde wijziging van de regels en de daarin opgeworpen kwesties te overwegen.”</p>
<p>Het voegde eraan toe: ‘Dienovereenkomstig wijst de Commissie krachtens artikel 19(b)(2) van de wet 5 maart 10, 2024 aan als de datum waarop de Commissie de voorgestelde regelwijziging goedkeurt, afkeurt, of een procedure instelt om te bepalen of de voorgestelde regelwijziging afgekeurd moet worden.’</p>
<p>Het uitstel van de goedkeurings- of afkeuringsdatum van de ETF van BlackRock komt een week nadat het hetzelfde deed voor de spot Ethereum ETF van Fidelity Investments, die werd uitgesteld tot 5 maart.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/eths-path-to-10k---the-ethereum-2024-roadmap/1696" target="_blank">ETH’s weg naar $10k - De Ethereum 2024 Routekaart</a></p>
<p>Hoe dan ook, BlackRock is gewend geraakt aan de vertragende tactieken van de SEC bij het goedkeuren van exchange traded funds en andere beleggingsinstrumenten. In het g van zijn bitcoin ETF, duurde het meer dan 6 maanden voordat de SEC het goedkeurde.</p>
<p>Volgens <a href="https://twitter.com/ItsBitcoinWorld/status/1751982211291836772" rel="nofollow noopener noreferrer" target="_blank">Bitcoinworld Media, Investeringsbank TD Cowen</a> gelooft dat de SEC pas in 2025 of 2026 ETH ETF’s zal goedkeuren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707407992ETHapproval1.png" alt=""><br>Bron: <a href="https://twitter.com/ItsBitcoinWorld/status/1751982211291836772" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>In het verleden heeft de SEC de goedkeuring van verschillende ETH ETF-aanvragen uitgesteld. Zo heeft het de aanvragen voor Grayscale Investments en VanEck’s Ethereum ETF’s uitgesteld. Naast BlackRock hebben ook Distributed Capital en Hashdex zich aangemeld om spot Ethereum ETF’s te lanceren.</p>
<p>Een reden voor deze vertragingen is de vereisten van de SEC voor aanvullende openbaarmakingen. De SEC heeft lange tijd bezwaar gemaakt tegen spot crypto ETF’s uit angst voor marktmanipulatie en prijsvolatiliteit die investeringen in Ethereum ETF’s in gevaar zou kunnen brengen.</p>
<p>Volgens Wu Blockchain, de bekende crypto-ETF-analist, Eric Balchunas, denkt dat spot ETH ETF’s een kans van 70% hebben op goedkeuring.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1707408004ETHapproval2.png" alt=""><br>Bron: <a href="https://twitter.com/WuBlockchain/status/1745312885298041012" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>De hele crypto community wacht tot mei om te zien of de SEC goedkeurt of afkeurt <a href="https://www.gate.io/blog_detail/3499/etf%E7%94%B3%E8%BE%BC-%E5%85%AC%E5%BC%8F" target="_blank">BlackRock’s crypto ETF</a> De goedkeuring van een ETH ETF in de Verenigde Staten kan leiden tot een grotere adoptie van ETH dan voorheen. We wachten ook af hoeveel investeerders bereid zijn om crypto-ETF’s te kopen.</p>
<h2 id="h2-Conclusie843789"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Peirce, de commissaris van de SEC, heeft gesuggereerd dat de toezichthoudende autoriteit Ethereum ETF’s zou kunnen goedkeuren, hoewel ze geen specifieke tijdsperiode heeft aangegeven. Ondertussen heeft de instantie de beslissingsdatum van het ETH ETF van BlackRock verplaatst naar mei van dit jaar. De goedkeuring van een ETH ETF in de Verenigde Staten kan leiden tot een grotere adoptie van dit crypto-activum.</p>
<h2 id="h2-Veelgestelde20vragen20over20Spot20ETH20ETFs493584"><a name="Veelgestelde vragen over Spot ETH ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Spot ETH ETF’s</h2><h3 id="h3-Zal20er20een20ETF20voor20Ethereum20zijn861817"><a name="Zal er een ETF voor Ethereum zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal er een ETF voor Ethereum zijn?</h3><p>Er zijn ETH Futures ETF’s die onder andere Global X Ethereum ETP, WisdomTree Physical Ethereum, DDA Physical Ethereum ETP en VanEck Ethereum ETN omvatten. De cryptomarkt verwacht echter dat de Amerikaanse SEC tussen 2024 en 2026 verschillende spot ETH ETF’s zal goedkeuren.</p>
<h3 id="h3-Wat20is20de20beste20ETF20voor20Ethereum264725"><a name="Wat is de beste ETF voor Ethereum?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de beste ETF voor Ethereum?</h3><p>Populaire ETH futures ETF’s zijn onder meer Global X Ethereum ETP, WisdomTree Physical Ethereum, DDA Physical Ethereum ETP en VanEck Ethereum ETN. Op basis van marktkapitalisatie is de Grayscale Ethereum Trust (ETHE) de grootste ETH ETF op de markt.</p>
<h3 id="h3-Heeft20ETH20een20ETF15805"><a name="Heeft ETH een ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Heeft ETH een ETF?</h3><p>ETH heeft verschillende toekomstige ETF’s, waaronder Grayscale Ethereum Trust (ETHE), XBT Provider Ethereum Tracker One (COINETH), CI Galaxy Ethereum ETF (ETHX.B) en 21Shares Ethereum Staking ETP (AETH). De meeste van deze ETF’s zijn gevestigd in Europa en de Verenigde Staten.</p>
<h3 id="h3-Hoe20te20investeren20in20ETH20ETF772832"><a name="Hoe te investeren in ETH ETF?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe te investeren in ETH ETF?</h3><p>Aangezien ETH ETF’s worden verhandeld op traditionele effectenbeurzen, moet een belegger een rekening openen bij een makelaar. Zodra hij/zij zijn/haar makelaarsrekening heeft gefinancierd, kan hij/zij ETH ETF’s naar keuze kopen.</p>
<h3 id="h3-Zal20Ethereum20in20202420weer20stijgen464396"><a name="Zal Ethereum in 2024 weer stijgen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal Ethereum in 2024 weer stijgen?</h3><p>Er is een grote kans dat de prijs van ETH zal stijgen in 2024. Wat op dit moment niet zeker is, is met welke marge het zal 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 mening van de onderzoeker en vormt geen beleggingsaanbevelingen.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards