SG9lIGJlw69udmxvZWR0IGhldCBncm9lbmUgbGljaHQgdmFuIFNwb3QgRXRoZXJldW0gRVRGJ3MgZGUgdG9la29tc3RpZ2UgbWFya3Q/

2024-05-28, 12:37

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR381804"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De Amerikaanse Securities and Exchange Commission (SEC) heeft goedgekeurd <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF-handelsplan op 23 mei, wat door de markt breed wordt geïnterpreteerd als een politieke drijvende kracht in de context van de presidentsverkiezingen van dit jaar.</p>
<p>De goedkeuring van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot ETF’s zal ongetwijfeld de waardeontdekking van Ethereum en zijn ecosysteemtokens stimuleren, en vanuit een langetermijnperspectief zal het ook de weg vrijmaken voor de adoptie van meer hoogwaardige cryptocurrencies.</p>
<p>Verwijzend naar de impact van het omzetten van GBTC naar een spot ETF op de prijs van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a>, hoewel Ethereum op korte termijn neerwaartse druk kan ondervinden, zal het op de lange termijn een positievere impact hebben.</p>
<h2 id="h2-Introductie442306"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Enkele maanden na de notering van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s heeft de cryptocurrency markt een nieuwe doorbraak gemaakt. Op 23 mei keurde de Amerikaanse Securities and Exchange Commission (SEC) het Ethereum spot ETF handelsplan goed, dat zal worden uitgevoerd door de New York Stock Exchange (NYSE), Chicago Board of Options Exchange (CBOE) en Nasdaq. De handel wordt later dit jaar verwacht, met mogelijke uitgevers zoals BlackRock, Fidelity Grayscale, VanEck en Franklin Templeton, onder anderen.</p>
<p>Het artikel zal een diepgaande interpretatie geven van de ups en downs die Ethereum’s goedkeuringsproces voor ETF heeft ervaren, van aanvankelijk sterk ondergewaardeerd tot een plotselinge verandering in de houding van de SEC, en welke impact dit zal hebben op de toekomstige markt.</p>
<h2 id="h2-Spot20ETFgoedkeuring20omarmt20groen20licht20Ethereum20stijgt20met2020123211"><a name="Spot ETF-goedkeuring omarmt ‘groen licht’, Ethereum stijgt met 20%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Spot ETF-goedkeuring omarmt ‘groen licht’, Ethereum stijgt met 20%</h2><p>Tegen de achtergrond van de wijdverspreide marktovertuiging dat de Amerikaanse Securities and Exchange Commission (SEC) naar verwachting geen Ethereum spot ETF’s zou goedkeuren, werd deze pessimistische verwachting volledig omgekeerd in de vroege uren van 20 mei.</p>
<p>Eerder heeft de controverse over de vraag of Ethereum een effect is, het goedkeuringsproces van spot-ETF’s belemmerd. Op het moment van goedkeuring werd zelfs gespeculeerd dat de intrekking van de aanvraag voor Ethereum-futures ETF door Grayscale ‘om de kans op goedkeuring van spot-ETF te vergroten’ was. Op 20 mei eiste de Amerikaanse SEC dat de effectenbeurs de 19b-4-indieningsdocumenten van de Ethereum-spot-ETF bijwerkt, wat tot positieve speculatie op de markt leidde.<br><img src="https://gimg2.gateimg.com/image/article/17168996731.jpg" alt=""><br>Bron: @EricBalchunas</p>
<p>Interessant genoeg had zelfs de eerste lichting aanvragers niet veel hoop van tevoren. Van Eck CEO Jan van Eck verklaarde vorige maand dat hij bereid is om afgewezen te worden.</p>
<p>Voor investeerders is het belangrijkste niet wanneer ze goedkeuren, maar goedkeuring. Na de bekendmaking van het positieve nieuws herstelden de Ethereum-prijzen, die oorspronkelijk in een langzame daling waren, snel met een dagelijkse stijging van 20%, waarmee het record voor de grootste dagelijkse stijging in bijna 4 jaar werd verbroken. Op een gegeven moment naderde het bijna $4000 en zorgde het voor een stijging van Layer2. De opkomst van Layer1, MEME, AI en andere sectoren heeft geleid tot een heropleving van het optimisme op de markt.<br><img src="https://gimg2.gateimg.com/image/article/17168996972.jpg" alt=""><br>Bron: Gate.io</p>
<p>Volgens CoinGlass-gegevens is op deze zeer volatiele dag het opruimbedrag van de hele gehefboomde crypto-derivatenpositie op de markt gestegen tot meer dan $360 miljoen, het hoogste niveau sinds 1 mei. Onder de geliquideerde posities zijn de meeste shortposities met een waarde van ongeveer $250 miljoen, wat aangeeft dat zeer gehefboomde handelaren zich concentreren op weddenschappen op de onmiddellijke stijging van ETF’s. ETH-handelaren werden het zwaarst getroffen, met een opruimbedrag van $132 miljoen.</p>
<p>In de vroege ochtend van 24 mei heeft de SEC eindelijk de 19b-4 formulier aanvragen voor Ethereum spot ETF’s goedgekeurd, ingediend door meerdere instellingen, waaronder BlackRock, Fidelity en Grayscale.</p>
<p>Hoewel deze formulieren zijn goedgekeurd, moeten ETF-uitgevers nog steeds wachten tot de S-1-registratieverklaring van kracht wordt voordat er gehandeld kan worden, wat enkele weken tot vijf maanden kan duren. Spot-ETF’s zijn echter al een zekerheid.</p>
<p>Volgens sommige bronnen heeft de SEC mogelijk zijn eerdere negatieve houding vanwege politieke motieven veranderd naarmate de verkiezing nadert. Voormalig president Trump heeft de afgelopen maand vaak steun betuigd aan cryptocurrencies, terwijl het campagneteam van de huidige president Biden ook MEME-managers is gaan werven. De Democratische Partij kan haar steun voor innovatieve technologieën aantonen door de goedkeuring van spot Ethereum ETF’s om cryptocurrency-kiezers voor zich te winnen.</p>
<p>Het is vermeldenswaardig dat met de stijging van het marktsentiment, Ethereum niet is blijven stijgen maar in een sterke en volatiele staat is beland, en veel giganten en instellingen zijn begonnen met het aanpassen van hun beleggingsstrategieën. Sommige instellingen en individuen die Ethereum short gaan, hebben hun Ethereum-posities verkocht, wat wijst op zorgen in de markt over de volatiliteit en onzekerheid van Ethereum-prijzen.</p>
<h2 id="h2-Achter20de20goedkeuring20de20potentile20uitdagingen20en20kansen20van20Ethereum103610"><a name="Achter de goedkeuring, de potentiële uitdagingen en kansen van Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Achter de goedkeuring, de potentiële uitdagingen en kansen van Ethereum</h2><p>De belangrijkste reden voor de goedkeuring van Ethereum-spot ETF’s wordt momenteel toegeschreven aan de politieke drive van de SEC, maar het is ook te wijten aan de gecombineerde invloed van vele praktische factoren.</p>
<p>Ten eerste biedt de succesvolle lancering van Bitcoin spot ETF’s een precedent voor de goedkeuring van Ethereum spot ETF’s, waar de SEC eerder futures ETF’s voor Bitcoin en Ethereum heeft goedgekeurd.</p>
<p>Ten tweede heeft de SEC de vorige rechtszaak tegen Grayscale verloren. Om juridische conflicten te vermijden, kan de SEC ervoor kiezen om Ethereum-spot-ETF’s te gebruiken om verdere juridische procedures te voorkomen.</p>
<p>Bovendien heeft de goedkeuring van het FIT 21-wetsvoorstel de jurisdictie van de cryptocurrency-industrie verduidelijkt, waardoor een duidelijker juridisch kader is ontstaan voor de goedkeuring van Ethereum spot ETF’s. Ondertussen is het SAB 121-beleidswetsvoorstel dat eerder door de SEC was opgesteld, ingetrokken, waardoor de strikte regulering van crypto is verminderd en gunstige omstandigheden zijn gecreëerd voor de goedkeuring van Ethereum spot ETF’s.</p>
<p>Last but not least, tijdens de Amerikaanse verkiezingen zijn beide partijen actief op zoek naar stemmen uit de cryptocurrency gemeenschap, wat ongetwijfeld de politieke druk op de SEC verhoogt om passief te reageren op de Ethereum ETF.<br><img src="https://gimg2.gateimg.com/image/article/17168997373.jpg" alt=""><br>Bron: @matthew_sigel</p>
<p>Hoe dan ook, de goedkeuring van Ethereum spot ETF’s zal ongetwijfeld de ontdekking van de waarde van Ethereum en zijn ecosysteemtokens stimuleren, en vanuit een langer termijn perspectief, zal het ook de weg effenen voor de adoptie van meer hoogwaardige cryptocurrencies in het algemeen.</p>
<p>Ten eerste zal de adoptie van Ethereum spot ETF’s de blootstelling van institutionele en particuliere beleggers aan Ethereum vergroten, zonder dat ze ETH direct hoeven te kopen en te beheren, wat de algehele vraag naar Ethereum aanzienlijk kan vergroten en zijn marktpositie verder kan versterken.</p>
<p>Ten tweede kan het handelsvolume op het Ethereum-netwerk toenemen, wat kan leiden tot hogere gasvergoedingen en netwerkcongestie. Dit zal investeerders en ontwikkelaars aanmoedigen om meer aandacht te besteden aan oplossingen zoals Layer2 en modulariteit. Dit kan nieuwe verhalen naar de Ethereum-markt brengen. Natuurlijk is er ook regelgevende druk om potentiële innovatierisico’s te beteugelen.</p>
<p>Ten slotte zal deze positieve ontwikkeling de SEC helpen om controverses zoals of Ethereum een beveiliging is opzij te zetten, de regelgevingsdruk op Ethereum-ecosysteeminnovatie te verminderen en ook bijdragen aan de actieve bevordering van andere cryptocurrencies. Bijvoorbeeld, we hebben waargenomen dat sommigen zelfs SOL hebben voorgesteld. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> het spot-ETF-concept van ‘s werelds</p>
<h2 id="h2-Is20het20mogelijk20om20in20de20toekomst20nieuwe20hoogtepunten20te20bereiken20met20de20komst20van20verkoopdruk20van20Grayscale876061"><a name="Is het mogelijk om in de toekomst nieuwe hoogtepunten te bereiken met de komst van verkoopdruk van Grayscale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is het mogelijk om in de toekomst nieuwe hoogtepunten te bereiken met de komst van verkoopdruk van Grayscale?</h2><p>Op de lange termijn zullen de lancering van Ethereum spot ETF’s meer traditionele fondsen aantrekken om de cryptocurrency-industrie binnen te gaan, waardoor de hele industrie naar een grotere schaal en hogere compliance-richting wordt gedreven en de munt natuurlijk zal stijgen in waarde.</p>
<p>Als we het vergelijken met de succesvolle ervaring van Bitcoin spot ETF’s, hebben Ethereum ETF’s ook een sterke ‘goudzuigeffect’ en wordt verwacht dat ze aanzienlijke kapitaalinstroom naar de industrie zullen brengen.</p>
<p>Er wordt algemeen aangenomen dat hoewel de marktomvang van Ethereum spot-ETF’s misschien niet te vergelijken is met die van Bitcoin spot-ETF’s, er nog steeds aanzienlijke groeimogelijkheden zijn. Er wordt voorspeld dat Ethereum spot-ETF’s misschien 10% tot 15% van de activa die door Bitcoin spot-ETF’s worden verworven, zullen ontvangen, met een bereik van $5 miljard tot $8 miljard. Volgens Geoff Kendrick, hoofd forex en digitaal vermogensonderzoek bij Standard Chartered Bank, is hij optimistischer dat na goedkeuring van de spot Ethereum ETF naar verwachting ongeveer $15 miljard tot $45 miljard aan vermogensinstroom zal opleveren binnen 12 maanden.</p>
<p>Gezien de veranderingen in ETHE vergelijkbaar met GBTC voor en na de spot Bitcoin ETF, is de premie van ETHE ten opzichte van de nettovermogenswaarde (NAV) aanzienlijk smaller geworden van -20,52% op 17 mei tot -1,27% vandaag, en de premiegraad is zelfs uitgebreid tot -26% vorige maand.<br>Vanuit dit perspectief is de markt snel begonnen Ethereum’s positieve sentiment in de prijs te verwerken.<br><img src="https://gimg2.gateimg.com/image/article/17168997774.jpg" alt=""><br>Bron: THE BLOCK</p>
<p>Nu Grayscale trustproducten omzet in ETF-producten, kan de markt te maken krijgen met enige arbitrage en verkoopdruk. Zo geloven analisten van Kaiko bijvoorbeeld dat Grayscale ETHE’s in de eerste maand na lancering als spot-ETF’s een gemiddelde dagelijkse uitstroom van $110 miljoen kunnen hebben.</p>
<p>Na de succesvolle conversie van Grayscale GBTC naar Bitcoin spot ETF, hoewel de uitstroom van gelden uit GBTC enige verkoopdruk op Bitcoin heeft gebracht en heeft geleid tot een kortetermijndaling van de muntprijzen, is dit nu verwerkt door andere Bitcoin ETF’s. Vanuit dit perspectief, hoewel er op korte termijn neerwaartse druk op Ethereum-prijzen kan zijn, is de langetermijnimpact positiever.</p>
<p>We hebben eerder verschillende artikelen geschreven waarin we suggereren dat Bitcoin en Ethereum hun eigen kernfunctionele kenmerken hebben en dat de marktherkenning en acceptatie van hen naar verwachting blijven stijgen. Vooral Ethereum, er wordt verwacht dat de prijs in de toekomst zal blijven stijgen, vooral nu institutionele investeerders geleidelijk de markt betreden en het groeimomentum nog significanter zal zijn.</p>
<p>Samengevat zal dit mijlpaal evenement ongetwijfeld een diepgaande impact hebben op de cryptocurrency markt, wat wijst op verdere ontwikkeling en volwassenheid van de cryptocurrency markt in de toekomst. Het bevordert niet alleen het nalevingsproces van de cryptografische industrie, maar trekt ook een grote hoeveelheid traditionele fondsen aan om de markt te betreden, waardoor investeerders meer diverse investeringsmogelijkheden krijgen. Tegelijkertijd biedt dit ook solide ondersteuning voor de prijsgroei van gecodeerde activa zoals Ethereum.</p>
<p>Het moet worden opgemerkt dat in het kader van gunstige beleidsmaatregelen en snelle ontwikkeling van de industrie, de korte termijn markt mogelijk oververhitting kan ervaren, met aanzienlijk verhoogde hefboomniveaus, wat in zekere mate de risicovoorkeur van sommige beleggers verhoogt. Als beleggers moeten we altijd rationaliteit en objectiviteit handhaven, de marktomgeving, beleggingsvoorkeuren en risicobeheersingsfactoren uitgebreid ueren, blindelings de trend vermijden en rationele beleggingsbeslissingen nemen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>