U0VDIGtldXJ0IEV0aGVyZXVtLWZ1dHVyZXMgRVRGUyBnb2Vk

2023-08-29, 09:22

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>De Securities and Exchange Commission (SEC) van de Verenigde Staten zal naar verwachting binnen de komende drie maanden verschillende Ether ETFs goedkeuren.</p>
<p>De goedkeuring van ETH ETF’s zal waarschijnlijk toenemen <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a> van institutioneel kapitaal in <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>Er is nog steeds onzekerheid over de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s die de SEC kan goedkeuren.</p>
<p>Trefwoorden: Ethereum Futures ETF’s, Ether futures, Exchange Traded Funds, Ethereum ETF’s, futures op Ethereum kopen, ETH futures verhandelen</p>
<h2 id="h2-Introductie55288"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De cryptomarkt wacht op een katalysator om een sterke bullish momentum te veroorzaken. De prijzen van de meeste cryptocurrencies waren gedrukt gedurende de eerste helft van dit jaar, ondanks af en toe een bullish momentum te tonen. Ook de instorting van crypto-vriendelijke banken in de Verenigde Staten zoals <a href="https://www.gate.io/blog_detail/2303/svb-crash-caused-the-butterfly-effect-in-the-crypto-market-what-should-investors-do" target="_blank">Silicon Valley Bank temperde het investeerdersbelang</a> in cryptoactiva.</p>
<p>Natuurlijk heeft de Amerikaanse aanpak van de cryptosector de situatie nog nijpender gemaakt. Op dit moment geloven cryptoliefhebbers dat de goedkeuring van crypto-beurs verhandelde fondsen (ETF’s) de vereiste katalysator zou zijn om hernieuwde momentum in de sector te genereren. Dit artikel zal de waarschijnlijke effecten van de goedkeuring van bespreken. <a href="https://www.gate.io/live/video/7eec1ff7a22e0b2876bdbee473864aa3" target="_blank">Ethereum futures ETFs</a> op de cryptomarkt.</p>
<h2 id="h2-SEC20nadert20goedkeuring20van20Ethereum20futures20ETFs719166"><a name="SEC nadert goedkeuring van Ethereum futures ETFs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC nadert goedkeuring van Ethereum futures ETFs</h2><p>Naar verwachting zal de Securities and Exchange Commission (SEC) van de Verenigde Staten binnen enkele maanden goedkeuring verlenen aan ETH-beurs verhandelde fondsen (ETF’s), een ontwikkeling die mogelijk meer interesse zal creëren in de crypto-sector.</p>
<p>Volgens een rapport van Bloomberg, dat een niet nader genoemde bron aanhaalt, kunnen binnenkort een aantal vermogensbeheerders goedkeuring krijgen om dit jaar hun Ethereum ETFS te lanceren. De bron gaf aan dat de SEC naar verwachting verschillende Ether Futures ETF’s zal goedkeuren tegen oktober van dit jaar.</p>
<p>Volgens het rapport is het zeer onwaarschijnlijk dat de SEC de goedkeuring van de Ether futures ETF’s zal belemmeren. Er staat: “De toezichthouder zal naar verwachting de producten niet blokkeren, die gebaseerd zouden zijn op futures-contracten voor de op een na grootste cryptocurrency, aldus ingewijden.”</p>
<p>Ook voegde het rapport eraan toe dat er goedkeuring van regelgevende instanties in behandeling is voor ten minste 5 Ether-Futures-indieningen. Momenteel hebben meer dan een dozijn beleggingsmaatschappijen hun aanvragen ingediend voor door ETH verhandelde beursfondsen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/207/why-do-people-choose-crypto-etfs-what-are-the-advantages-and-disadvantages" target="_blank">Waarom kiezen mensen voor Crypto ETF’s? Wat zijn de voordelen en nadelen?</a></p>
<h2 id="h2-Onzekerheid20omringt20de20goedkeuring20van20Ethereum20ETFs560231"><a name="Onzekerheid omringt de goedkeuring van Ethereum ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onzekerheid omringt de goedkeuring van Ethereum ETF’s</h2><p>Zoals hierboven vermeld, hebben bijna een dozijn bedrijven zich aangemeld om hun Ether Futures ETF’s te lanceren. Desalniettemin heeft de SEC geen indicatie gegeven van de bedrijven waarvan zij de aanvragen zal goedkeuren.</p>
<p>ProShares Short Ether Strategy ETF, Bitwise Ethereum Strategy ETF, Roundhill Ether Strategy ETF, VanEck’s Ethereum Strategy ETF, Roundhill Ether Strategy ETF, en de Grayscale Ethereum Futures ETF zijn voorbeelden van Ether-futures ETF’s die wachten op goedkeuring van de SEC.</p>
<p>Zoals u opmerkt, hebben Volatility Shares, Bitwise, Valkyrie, Roundhill en ProShares zich aangemeld voor de ETH ETF’s. Desalniettemin wachten we nog steeds af welke van deze bedrijven ETH ETF’s de SEC zal goedkeuren.</p>
<p>De genoemde bronnen zeiden: ‘Het kon niet onmiddellijk worden bepaald welke fondsen groen licht zouden krijgen. Ambtenaren hebben aangegeven dat er verschillende in oktober goedgekeurd kunnen worden’.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-are-leveraged-etf-token/243" target="_blank">Wat zijn Leveraged ETF Tokens?</a></p>
<p>Over het algemeen zijn exchange traded funds beleggingsactiva die beleggers blootstelling geven aan onderliggende activa zonder ze te bezitten. Mensen kunnen ETF’s verhandelen op beurzen zoals de Chicago Mercantile Exchange (CME).</p>
<p>De goedkeuring van Ether futures ETF’s door de SEC zou betekenen dat investeerders een nieuwe manier hebben om te investeren in cryptocurrencies, wat waarschijnlijk meer institutioneel kapitaal naar de sector zal trekken.</p>
<p>De goedkeuring van ETH futures ETF’s zou ook betekenen dat particulieren en institutionele beleggers binnen enkele maanden futures op Ethereum kunnen kopen. Dit geeft hen de ruimte om ETH-futures te verhandelen, wat kan leiden tot meer acceptatie van Ethereum-producten.</p>
<h2 id="h2-Zal20de20SEC20ook20BTC20ETFs20goedkeuren475832"><a name="Zal de SEC ook BTC ETF’s goedkeuren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal de SEC ook BTC ETF’s goedkeuren?</h2><p>Het nieuws over de mogelijke goedkeuring van ETH ETF’s door de SEC komt enkele maanden nadat verschillende financiële vermogensbeheerbedrijven zoals <a href="https://www.gate.io/blog_detail/1643/blackrock-launches-blockchain-related-etf-for-european-markets." target="_blank">BlackRock heeft zich aangemeld voor bitcoin ETFs</a>. Tot nu toe is er geen indicatie dat de SEC kan goedkeuren <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETFS. In plaats daarvan lijkt de SEC reserves tegen hen te hebben.</p>
<p>Volgens de in juni vrijgegeven informatie voldeden verschillende BTC-indieningen niet aan de transparantie- en detailvereisten van de SEC. De Amerikaanse overheidsinstantie zei dat de documenten niet “duidelijk en uitgebreid” waren. Cathie Wood, CEO van Ark Invest, is echter van mening dat de SEC niet zal <a href="https://www.gate.io/learn/articles/what-is-a-bitcoin-etf/218" target="_blank">keur BTC ETF’s individueel goed</a>. Ze denkt dat als de SEC een <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF goedkeurt, het meer dan één tegelijk zal goedkeuren.</p>
<h2 id="h2-Implicaties20van20de20goedkeuring20van20SEC20van20Ether20Futures20ETFs874704"><a name="Implicaties van de goedkeuring van SEC van Ether Futures ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicaties van de goedkeuring van SEC van Ether Futures ETF’s</h2><p>Als de SEC Ethereum ETF’s goedkeurt, zal het een sleutelmijlpaal zijn voor de cryptocurrency-sector. Het zal een verschuiving van het perspectief van de SEC op digitale activa laten zien en duiden op de toenemende acceptatie van cryptocurrencies en andere digitale activa door de traditionele financiële sector.</p>
<p>De goedkeuring van ETH ETF’s zou ook helpen om de scheidslijn tussen crypto-effecten en niet-effecten te wissen. Adam Cochran, een crypto-analist, denkt dat door het goedkeuren van ETH ETF’s de SEC indirect zou hebben erkend dat ETH geen effect is. Als zodanig zou het impliceren dat Ethereum niet gereguleerd zou moeten worden als een traditionele financiële zekerheid op basis van zijn doel, gebruik en consensusmechanisme.</p>
<p>Op dezelfde manier zou deze ontwikkeling een belangrijk precedent scheppen voor de cryptosector. Het zal een referentiepunt worden in toekomstige SEC-rechtszaken tegen andere vergelijkbare cryptocurrencies die zij als effecten beschouwt. Dit betekent echter niet dat alle cryptocurrencies niet als effecten worden beschouwd.</p>
<p>De goedkeuring zou ook betekenen dat de SEC ETH accepteert als valuta of grondstof, ongeacht de eerdere zorgen met betrekking tot de initiële muntaanbieding. Het zou echter leiden tot kritiek van mensen die ETH als een effect beschouwen. Ze kunnen ook betogen dat er regelgevende vooringenomenheid is ten gunste van Ethereum.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/the-wild-west-of-the-crypto-world/670" target="_blank">Het Wilde Westen van de Crypto Wereld? Redenen achter de rechtszaken van de SEC in de VS</a></p>
<h2 id="h2-Implicaties20van20het20nieuws20over20mogelijke20goedkeuring20van20ETH20ETFS20op20de20Ethereumprijs365081"><a name="Implicaties van het nieuws over mogelijke goedkeuring van ETH ETFS op de Ethereum-prijs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicaties van het nieuws over mogelijke goedkeuring van ETH ETFS op de Ethereum-prijs</h2><p>De markt heeft het nieuws van een mogelijke goedkeuring van verschillende ETH ETF’s gunstig ontvangen, zoals blijkt uit de recente <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> Op 17 augustus meldde Bloomberg dat de prijs van ETH met 11% steeg tot $1.700 na het nieuws van de mogelijke goedkeuring van ETH Futures ETF’s door de SEC. Dit geeft ook aan dat ETH bullish kan worden als de SEC Ether ETF’s goedkeurt.</p>
<p>Zoals gewoonlijk duurt het effect van trending nieuws op de prijs van een specifieke cryptocurrency niet lang. Dit komt doordat de ETH-prijs is gedaald van $ 1.700 en nu schommelt tussen $ 1.643 en $ 1.652, zoals blijkt uit de volgende grafiek.<br><img src="https://gimg2.gateimg.com/image/article/16933009061.png" alt=""><br>ETH’s 14-daagse prijsbeweging - CoinGecko</p>
<p>Als <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> Zoals blijkt, schommelt de ETH-prijs tussen $1.600 en $1.652 sinds 17 augustus. Momenteel is de prijs zeer neutraal.</p>
<h2 id="h2-Conclusie33842"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De cryptomarkt verwacht dat de Amerikaanse Securities and Exchange Commission (SEC) de komende drie maanden verschillende ETH ETF’s zal goedkeuren. Een dergelijke goedkeuring kan betekenen dat ETH geen effect is, maar ofwel een valuta of een grondstof is. De goedkeuring van ETH ETF’s zal naar verwachting een bullish momentum op de markt creëren.</p>
<h2 id="h2-Veelgestelde20vragen20over20Ether20Futures20ETFs522729"><a name="Veelgestelde vragen over Ether Futures ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Ether Futures ETF’s</h2><h3 id="h3-Is20er20een20ETF20die20Ethereum20bevat1963"><a name="Is er een ETF die Ethereum bevat?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is er een ETF die Ethereum bevat?</h3><p>Op dit moment zijn er geen goedgekeurde Ethereum futures ETF’s op de markt. De Securities and Exchange Commission (SEC) van de Verenigde Staten zal naar verwachting ETH ETF’s goedkeuren tegen oktober 2023.</p>
<h3 id="h3-Kun20je20ETHfutures20kopen489762"><a name="Kun je ETH-futures kopen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kun je ETH-futures kopen?</h3><p>Er zijn verschillende platforms die Ethereum-futures aanbieden. U kunt Ether-futures kopen op Binance exchange, Chicago Mercantile Exchange <a href="https://www.gate.io/futures_center" target="_blank">en Gate.io</a> gecentraliseerde crypto-uitwisseling.</p>
<h3 id="h3-Waar20Ethereumfutures20verhandelen37336"><a name="Waar Ethereum-futures verhandelen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar Ethereum-futures verhandelen?</h3><p>Investeerders <a href="/price/safemoon-sfm" rel="nofollow noopener noreferrer" target="_blank">SafeMoon prijs</a> op verschillende platforms, waaronder Binance exchange, Chicago Mercantile Exchange en Gate.io gecentraliseerde crypto exchange. Ethereum futures zijn beleggingsinstrumenten die de waarde van Ether (ETH) volgen.</p>
<h3 id="h3-Wat20is20het20symbool20voor20ETH20futures297805"><a name="Wat is het symbool voor ETH futures?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het symbool voor ETH futures?</h3><p>De ticker voor Ethereum Futures is ETH. Beleggers kunnen Ether-futures verhandelen op de Gate.io-beurs, Binance-beurs en Chicago Mercantile Exchange, onder andere.</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 enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>