RW50aG91c2lhc21lIHZvb3IgRXRoZXJldW0ncyBFVEYgdmVyZGFtcHQ6IEVlbiBuYWRlcmUgYmxpayBvcCBkZSBzdGFnbmF0aWUgb25kZXIgZGUgJDRL

2024-06-05, 07:23

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR133373"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De Securities and Exchange Commission van de Verenigde Staten heeft op 23 mei <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s goedgekeurd.</p>
<p>Het kan weken of maanden duren voordat de ETF-uitgevers ETH ETF’s lanceren.</p>
<p>ETH ETF’s zullen de liquiditeit op de Ethereum-markt verhogen.</p>
<h2 id="h2-Introductie207751"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De goedkeuring van crypto exchange traded funds (ETF’s) door de Amerikaanse SEC heeft een nieuw tijdperk ingeluid in de cryptogeldindustrie, omdat het veel institutionele investeringen heeft aangetrokken. Terwijl de lancering van spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s hebben het begin van de algemene acceptatie van cryptocurrency aangegeven, de goedkeuring van spot Ethereum ETF’s heeft de uitbreiding van de rol van digitale activa in de financiële wereld ingeluid.</p>
<p>Vandaag bespreken we de reis van Ethereum naar de goedkeuring van ETF’s in de Verenigde Staten. We zullen ook de huidige stand van zaken binnen de ETH ETF-markt ueren.</p>
<h2 id="h2-Ethereum20ETFgoedkeuringen20Een20korte20viering949948"><a name="Ethereum ETF-goedkeuringen: Een korte viering" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum ETF-goedkeuringen: Een korte viering</h2><p>Naar aanleiding van de Amerikaanse SEC’s <a href="https://www.gate.io/blog_detail/4168" target="_blank">goedkeuring van spot Ethereum ETF’s op 23 mei</a> De cryptogemeenschap reageerde positief, wat resulteerde in een korte periode van stijging van Ether (ETH). Verschillende vermogensbeheerders, waaronder Fidelity, Bitwise, VanEck, Franklin, ARK Invest en Grayscale, kregen toestemming om spot ETH ETF’s te lanceren na het voltooien van de vereiste papieren.</p>
<p>De <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> Analyse toont aan dat na de goedkeuring van de ETF de prijs van ETH steeg tot boven de $3.900, maar binnen een korte periode terugzakte naar $3.720. De onderstaande grafiek toont de prijsbeweging van ETH na de goedkeuring van de ETF’s.<br><img src="https://gimg2.gateimg.com/image/article/17175719741.jpg" alt=""><br>Ethereum Prijsbeweging na goedkeuring van ETH ETF’s door de Amerikaanse SEC - CoinGecko</p>
<p>Zoals de diagram laat zien, bereikte de Ethereum prijs $3.946 na de goedkeuring van de ETF’s. Hoewel de prijs terugliep, is hij sindsdien redelijk hoog gebleven en schommelt hij boven de $3.600. Wat ook opmerkelijk is in de diagram, is de ETH prijsstijging die plaatsvond op 20 mei, een week voor de goedkeuringsdatum van de ETF’s. De verwachting van de goedkeuring van spot ETH ETF’s in de VS was de reden achter die sterke prijsbeweging.</p>
<h2 id="h2-Pizzino20Waarom20de20prijs20van20Ethereum20niet20steeg20tot20boven20de20400020en20de20lauwe20rally20van20het20ETHBTCpaar890626"><a name="Pizzino: Waarom de prijs van Ethereum niet steeg tot boven de $4.000 en de lauwe rally van het ETH/BTC-paar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pizzino: Waarom de prijs van Ethereum niet steeg tot boven de $4.000 en de lauwe rally van het ETH/BTC-paar</h2><p>Ongetwijfeld verwachtte de cryptomarkt dat de ETH-prijs het weerstandsniveau van $4.000 zou overwinnen na de goedkeuring van de ETF’s. Maar dat gebeurde niet. Wat zou daar de verklaring voor kunnen zijn?</p>
<p>Ondanks een veelbelovende prijsactie op 23 mei, wat resulteerde in een stijging van 0,65% in zijn marktkapitalisatie, slaagde ETH er niet in om het weerstandsniveau van $4.000 te doorbreken. Jason Pizzino, een crypto-analist, denkt dat de voorzichtige aanpak van investeerders de potentiële prijsstijging van ETH heeft gestopt.</p>
<p>Volgens een <a href="https://beincrypto.com/ethereum-etf-approval-price-below-4000/" rel="nofollow noopener noreferrer" target="_blank">BeInCrypto publicatie</a> Pizzino zei: “De Ethereum ETF is goedgekeurd. Maar dat was niet genoeg om de prijs boven de $4.000 te krijgen. Het ETH/BTC-paar zag ook een zwakkere dan verwachte rally.” Sommige crypto-analisten geloven echter dat de ETH-prijs waarschijnlijk tegen het einde van 2024 $8.000 zal bereiken als gevolg van de kapitaalinstroom van de ETF’s.</p>
<p>De markt heeft mogelijk niet zo sterk gereageerd als mensen hadden verwacht, omdat de ETF’s nog niet zijn gelanceerd. Als gevolg hiervan is er nog steeds beperkte stroom van investeringen in cryptocurrency naar de Ethereum-markt. De reden hiervoor is dat de ETF-uitgevers toestemming van de SEC nodig zullen hebben voordat ze de ETF’s lanceren. Daarom kan het weken of maanden duren voordat de ETF’s op de beurzen worden verhandeld. De situatie verschilde van wat er gebeurde met spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ETF’s die binnen 24 uur na goedkeuring van de SEC op de beurzen werden gelanceerd.</p>
<h2 id="h2-De20korte20triomf20en20neergang20van20Pepe20Gedetailleerde20reactie20van20de20meme20coin20op20het20nieuws20over20de20ETF639944"><a name="De korte triomf en neergang van Pepe: Gedetailleerde reactie van de meme coin op het nieuws over de ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De korte triomf en neergang van Pepe: Gedetailleerde reactie van de meme coin op het nieuws over de ETF</h2><p>Afgezien van de lauwe reactie van ETH op het nieuws van de goedkeuring van de Amerikaanse ETH ETF <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Netwerkgebaseerde tokens reageerden op gemengde wijze. De markttrends van Ethereum tonen aan dat PEPE positief reageerde op het nieuws, aangezien de prijs aanzienlijk steeg tot een nieuw all-time high van $0.00001576. De bullish momentum duurde echter niet lang, aangezien het daarna met 8% terugliep.</p>
<p>Hoewel de Arbitrum-prijs aanvankelijk steeg, daalde hij ook met 3% binnen een korte periode. De prijs van <a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a>(LDO) steeg ook voordat het weer daalde, in navolging van de trends van PEPE, ARB en ETH. Dezelfde trend die bitcoin doormaakte, werd waargenomen onder deze op Ethereum blockchain gebaseerde tokens. Sterker nog, na de goedkeuring van bitcoin spot ETF’s daalde de BTC-prijs aanvankelijk voordat deze met een grote marge steeg. Uiteindelijk duurde de bullish momentum van bitcoin maanden na de lancering van de ETF’s.</p>
<h2 id="h2-Verschillen20tussen20de20goedkeuring20van20Ethereum20en20Bitcoins20ETF733214"><a name="Verschillen tussen de goedkeuring van Ethereum en Bitcoin’s ETF" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verschillen tussen de goedkeuring van Ethereum en Bitcoin’s ETF</h2><p>Zoals gezegd, markeerde de goedkeuring van spot Ethereum ETF’s de consolidatie van de cryptomarkt. Nu is er veel vertrouwen dat cryptocurrencies hier zullen blijven en een betekenisvolle bijdrage zullen leveren aan de financiële sector. Wat belangrijk is, is dat de goedkeuring van zowel ETH ETF’s als <a href="https://www.gate.io/blog_detail/379/what-are-bitcoin-etfs-bitcoin-etfs-explained" target="_blank">Bitcoin ETFs</a> bracht veel blijdschap in de crypto sector. Het proces van goedkeuring van bitcoin ETF’s was echter anders dan dat van ETH ETF’s.</p>
<p>In principe, <a href="https://www.gate.io/learn/articles/what-the-official-approval-of-bitcoin-spot-etfs-means-for-the-crypto-industry/2055" target="_blank">de goedkeuring van Bitcoin ETF’s was historisch</a> Sinds de eerste cryptocurrency ETF’s in de Verenigde Staten werden gelanceerd. Deze ETF’s openden de eerste deuren voor institutionele geldinstroom in de cryptocurrency-sector. Zelfs de particuliere beleggers begonnen te profiteren van bitcoin, omdat ze nu indirect konden investeren in BTC zonder de noodzaak om digitale portefeuilles te beheren. Ook beschouwde de cryptomarkt de goedkeuring van bitcoin ETF’s als de legitimisering van niet alleen bitcoin, maar van alle digitale valuta.</p>
<p>Bij de goedkeuring van bitcoin ETF’s was de SEC meer bezorgd over de mogelijkheid van marktmanipulatie na de lancering ervan. Daarom richtte het zich op het waarborgen dat de ETF-markt de nodige maatregelen had genomen om de consumenten te beschermen. Nu lijkt de situatie na de lancering van bitcoin ETF’s de SEC ervan te hebben overtuigd dat de ETF-markt geschikte maatregelen heeft genomen om marktmanipulatie te voorkomen en aan te pakken.</p>
<p>De weg naar de goedkeuring van bitcoin ETF’s had minder hindernissen dan de weg naar Ethereum ETF’s. Ten eerste kwam de goedkeuring van ETH ETF’s na veel debat over wetgeving die nodig was om cryptocurrencies te reguleren. Zo werken de Verenigde Staten en de Europese Unie aan het introduceren van crypto-regelgeving. Er is ook veel discussie geweest over de vraag of ETH moet worden geclassificeerd als crypto-grondstof of als beveiliging. De goedkeuring van ETH ETF’s kwam dus tijdens een periode van grotere regelgevingsonzekerheid dan tijdens de lancering van BTC ETF’s.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/bitcoin-efts-have-been-trading-around-the-world-for-years/2801" target="_blank">Bitcoin ETF’s worden al jaren over de hele wereld verhandeld</a></p>
<h2 id="h2-Parallellen20tussen20Ethereum20en20het20verleden20van20Bitcoins20goedkeuring20van20ETFs20en20marktgedrag113961"><a name="Parallellen tussen Ethereum en het verleden van Bitcoin’s goedkeuring van ETF’s en marktgedrag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Parallellen tussen Ethereum en het verleden van Bitcoin’s goedkeuring van ETF’s en marktgedrag</h2><p>De cryptomarkt reageerde anders op de lancering van bitcoin ETF’s en Ethereum ETF’s in de Verenigde Staten. Er waren echter één of twee overeenkomsten.</p>
<p>Marktimpact en reacties: De goedkeuring van zowel bitcoin als ETH ETF’s heeft interesse gewekt in de activa. Zowel institutionele als particuliere beleggers hebben de bereidheid getoond om te investeren in deze twee cryptocurrencies via de gereguleerde financiële activa (ETF’s). Degenen die niet bereid zijn om rechtstreeks ETH of bitcoin te kopen, kunnen nu investeren in hun derivaten, met name de exchange traded funds.</p>
<p>Handelsvolumes en prijsbewegingen: Na de goedkeuring van bitcoin ETF’s steeg de BTC-prijs, vergezeld van hoge handelsvolumes. Op dezelfde manier leidde de goedkeuring van de SEC Ethereum tot een vergelijkbare trend. Zowel de handelsvolumes als de prijs van Ethereum stegen tijdens een periode van 24 uur na de goedkeuring van de ETF’s.</p>
<p>Het opmerkelijke verschil tussen de bitcoin en <a href="https://www.gate.io/price-prediction/ethereum-eth" target="_blank">ETH prijsbewegingen</a> Na de goedkeuring van de respectieve ETF’s was de lengte van hun post-ETF-goedkeuringsperiodes optimistisch. De ETH-prijs steeg gedurende een korte periode van ongeveer 24 uur terwijl de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> steeg meer dan drie maanden tijdens de fase na goedkeuring van ETF’s.</p>
<p>Bitcoin vs. Ethereum Correlatie: Hoewel bitcoin en ETH vroeger een correlatie hadden, zal de goedkeuring van Ethereum ETF’s waarschijnlijk die positieve relatie versterken. Dit komt omdat de goedkeuring van de SEC <a href="https://www.gate.io/blog_detail/207/why-do-people-choose-crypto-etfs-what-are-the-advantages-and-disadvantages" target="_blank">van crypto-ETF’s</a> heeft gehandeld als de erkenning van de Verenigde Staten van de twee activa als de moeite waard beleggingsinstrumenten. Dientengevolge zijn zowel institutionele als particuliere beleggers waarschijnlijk <a href="https://www.gate.io/how-to-buy/ethereum-eth" target="_blank">Ethereum kopen</a> en bitcoin in meer proportionele hoeveelheden dan voorheen. Ook kunnen investeerders hun fondsen in het ETH/BTC-paar storten.</p>
<h2 id="h2-De20veranderende20houding20van20de20SEC20ten20opzichte20van20cryptocurrency20ETFs387282"><a name="De veranderende houding van de SEC ten opzichte van cryptocurrency ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De veranderende houding van de SEC ten opzichte van cryptocurrency ETF’s</h2><p>Het is niet verrassend dat de SEC zijn standpunt ten opzichte van crypto-ETF’s heeft veranderd. Ten eerste leek het voor de SEC riskant om Ethereum ETF’s af te keuren vanwege het precedent van bitcoin. Als de SEC ETH ETF-aanvragen zou hebben afgekeurd, hadden de aanvragers de toezichthoudende instantie kunnen aanklagen op juridische gronden dat zowel ETH als BTC cryptocurrencies zijn, waardoor er geen ruimte is voor discriminatie.</p>
<p>Ten tweede is er gedurende de korte periode dat spot bitcoin ETF’s bestaan geen sprake geweest van marktmanipulatie of enige andere bedreiging voor crypto ETF-beleggers. Dit scenario zou vertrouwen kunnen hebben gecreëerd bij de regelgevende instantie dat dezelfde coöperatieve situatie zal blijven bestaan na de goedkeuring van ETH ETF’s.</p>
<p>Eindelijk is er veel politieke druk geweest voor de regering-Biden om pro-crypto beleid aan te nemen. Zo heeft tijdens zijn verkiezingscampagne Donald Trump de regering-Biden en de SEC-voorzitter, Gensler, aanglen omdat ze de vooruitgang in de cryptocurrency-sector zouden tegenhouden. Dergelijke politieke druk kan de harde houding van de SEC tegen crypto-activa hebben versoepeld.</p>
<h2 id="h2-De20rol20van20ETFs20voor20cryptoinvesteringen450583"><a name="De rol van ETF’s voor crypto-investeringen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De rol van ETF’s voor crypto-investeringen</h2><p>Crypto ETF’s, die derivaten zijn, vereenvoudigen het investeringsproces in cryptocurrency. Ten eerste hoeven de investeerders geen cryptocurrencies zoals bitcoin en ETH te kopen en vast te houden. Ze profiteren gewoon van de prijsbewegingen door te investeren in ETF’s. Als gevolg hiervan wordt het proces van investeren in cryptocurrencies handiger en minder riskant. Dit komt doordat er geen kans is dat de crypto-activa van de investeerders kunnen worden gestolen door hacking of andere middelen.</p>
<p>Aangezien ETF’s traditionele beleggingsactiva zijn, kunnen ook veel traditionele beleggers erin handelen. Het feit dat dit gereguleerde financiële instrumenten zijn, schept vertrouwen onder conservatieve investeerders. Al met al trekken crypto ETF’s veel investeringen aan in de sector, wat de liquiditeit op de markt vergroot en de handel in digitale activa bevordert.</p>
<h2 id="h2-Conclusie664379"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Nadat de Securities and Exchange Commission van de Verenigde Staten op 27 mei de Ethereum ETF’s heeft goedgekeurd, steeg de ETH-prijs met 22%, maar daalde later weer. De goedkeuring van zowel ETH ETF’s als Bitcoin ETF’s heeft veel institutionele investeringen in de sector aangetrokken. Een ander goed ding aan crypto ETF’s is dat ze de investering in cryptocurrencies vereenvoudigen. Na de lancering van bitcoin ETF’s was er veel kapitaalinstroom in de BTC-markt. De cryptomarkt verwacht dat er na de lancering van ETH ETF’s meer institutionele investeringen in de altcoin zullen zijn dan voorheen.</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 alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen 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>