RXRoZXJldW0gTmFtZSBTZXJ2aWNlIChFTlMpIHdvcnN0ZWx0IG9tIGRlIHJhbGx5IHZvbCB0ZSBob3VkZW46IEVlbiBwcmlqc2FuYWx5c2Ugdm9vciAyMDI1

2024-06-05, 07:42

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""><br>Vanaf april 2025 wordt <a href="/price/ethereum-name-service-ens" target="_blank" class="blog_inner_link">Ethereum Name Service</a> (ENS) verhandeld op $14.68, een daling van 82.86% vanaf het hoogste punt, met een marktkapitalisatie van $527.29M. De voorgestelde ENSv2-migratie naar layer-2 oplossingen heeft aanzienlijke vooruitgang geboekt, met de focus op <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> om hoge gasvergoedingen aan te pakken en transactiesnelheden te verbeteren. ENS-domeinen blijven te maken hebben met juridische uitdagingen, waaronder geschillen over het eth.link-domein en octrooigeschillen met Unstoppable Domains. Ondanks deze hindernissen behoudt <a href="/price/ethereum-name-service-ens" target="_blank" class="blog_inner_link">ENS crypto</a> zijn positie als het toonaangevende gedecentraliseerde benamingssysteem op Ethereum, waarbij het zijn mogelijkheden uitbreidt om te voldoen aan de evoluerende markteisen.
</p><h2 id="h2-Marktprestaties20in202025814961"><a name="Marktprestaties in 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktprestaties in 2025</h2><p>Vanaf april 2025 wordt de ENS-token verhandeld op $14,68, wat een aanzienlijke daling is ten opzichte van de voorspelde waarde van $78,54 voor 2025 die werd genoemd in eerdere voorspellingen. De huidige marktkapitalisatie bedraagt $527,29 miljoen, met een circulerende voorraad van 35.904.859 ENS-tokens, waardoor het de 72e grootste cryptocurrency is op basis van marktkapitalisatie. Investeerders die geïnteresseerd zijn in wat ENS is en wat ENS crypto is, volgen deze veranderingen nauwlettend.</p>
<table>
<thead>
<tr>
<th>Metrisch</th>
<th>Huidige Waarde (april 2025)</th>
<th>% Verandering vanaf het ATH</th>
</tr>
</thead>
<tbody>
<tr>
<td>Prijs</td>
<td>$14.68</td>
<td>-82.86%</td>
</tr>
<tr>
<td>24u volume</td>
<td>$337,003</td>
<td>-</td>
</tr>
<tr>
<td>Wekelijkse Verandering</td>
<td>+0.18%</td>
<td>-</td>
</tr>
<tr>
<td>Marktkapitalisatie</td>
<td>$527.29M</td>
<td>-</td>
</tr>
</tbody>
</table>
<h2 id="h2-ENSv220Implementatievoortgang83122"><a name="ENSv2 Implementatievoortgang" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ENSv2 Implementatievoortgang</h2><p>De voorgestelde migratie van ENSv2 naar layer-2 oplossingen heeft in 2025 aanzienlijke vooruitgang geboekt. ENS-directeur Khori Whittaker heeft bevestigd dat de organisatie zich blijft inzetten voor onderzoek en ontwikkeling op layer-2 netwerken, met een bijzondere focus op Optimism. Deze strategische verschuiving is bedoeld om de aanhoudende problemen van hoge gasvergoedingen en transactiesnelheden aan te pakken die de bredere adoptie van ENS-domeinen en ENS-adressen hebben beperkt.</p>
<p>Met verbeteringen gepland voor de ENS-app (vaak toegankelijk via app.ens.domain of ens.domain), zullen gebruikers het gemakkelijker vinden om zich te registreren en hun ENS-namen te beheren en deze te koppelen aan hun ENS-portemonnee. Terwijl de betekenis van ENS evolueert, blijft de bredere gemeenschap nieuwe gebruikers voorlichten over waar ENS voor staat en wat een ENS-naam is.</p>
<h2 id="h2-Lopende20Juridische20Uitdagingen401778"><a name="Lopende Juridische Uitdagingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lopende Juridische Uitdagingen</h2><p>Het ENS-ecosysteem blijft juridische strijd leveren in 2025. ENS Labs heeft goedkeuring gekregen van zijn DAO om geschillen over het eigendom van het eth.link domein te regelen, een zaak die de aandacht heeft getrokken van degenen die geïnteresseerd zijn in eth domeinen en eth naamdiensten. Daarnaast heeft de organisatie haar standpunt tegen Unstoppable Domains gehandhaafd met betrekking tot octrooigeschillen, waarbij ENS-ontwikkelaar Nick Johnson benadrukt dat octrooien die aan concurrenten zijn verleend, zijn gebaseerd op innovaties van ENS Labs.</p>
<p>Ondanks deze uitdagingen blijft de ENS zijn positie als het toonaangevende gedecentraliseerde benamingssysteem op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> versterken. Door menselijk leesbare namen te koppelen aan machineleesbare identificatoren, voorziet het systeem zowel in ENS-zoekfunctionaliteiten als eth dns-services, waardoor de voortdurende relevantie van eth ENS-oplossingen wordt gewaarborgd.</p>
<h3 id="h3-TL20DR699044"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h3><p>Na goedkeuring van spot Ethereum ETF’s door de Verenigde Staten steeg de waarde van ENS met 43%.</p>
<p>De ENS-token wordt geconfronteerd met een massaal verkoop sinds het in een overgekochte markttoestand verkeert.</p>
<p>De ENS-prijs zal waarschijnlijk blijven stijgen, aangezien het een bullish momentum vertoont.</p>
<h2 id="h2-Introductie554675"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De cryptosector heeft in 2024 verschillende belangrijke ontwikkelingen meegemaakt, waaronder de lancering van crypto spot ETFs en de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> halveringsevenement dat de markt zou moeten helpen volledig te herstellen van de effecten van de recente langste cryptocurrency winter. De Verenigde Staten <a href="https://www.gate.io/blog_detail/3707/bitcoin-etf-approval-analysts-weigh-in-on-implications" target="_blank">SEC heeft in januari spot bitcoin ETF’s goedgekeurd</a>.</p>
<p>Onlangs heeft het verschillende spot ETH ETF’s goedgekeurd, wat kan leiden tot kapitaalinstroom vanuit de traditionele financiële sector naar de cryptobranche. Dit artikel behandelt hoe <a href="/price/ethereum-name-service-ens" rel="nofollow noopener noreferrer" target="_blank">Ethereum Name Service</a>( <a href="https://www.gate.io/blog_detail/398/what-is-ens-and-did" target="_blank">ENS</a>)-tokens hebben geprofiteerd van de lancering van ETH ETF’s.</p>
<h2 id="h2-ENSs20Recent20Prijs20Prestaties20Strijd20om20voorbij20202420Hoogtepunten20te20Breken852773"><a name="ENS’s Recent Prijs Prestaties: Strijd om voorbij 2024 Hoogtepunten te Breken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ENS’s Recent Prijs Prestaties: Strijd om voorbij 2024 Hoogtepunten te Breken</h2><p>Zoals hierboven aangegeven, keurde de Verenigde Staten op 23 mei de lancering van spot Ethereum ETF’s goed, wat al invloed heeft gehad op de cryptomarkt. De markten van verschillende digitale activa zoals de <a href="https://www.gate.io/blog_detail/1503/what-is-the-ethereum-name-service-ens" target="_blank">Ethereum Name Service</a> (ENS) token reageerde positief op die ontwikkeling. Volgens de on-chain ENS-marktanalyse steeg de waarde van ENS met 43% binnen een periode van 24 uur die liep van 23 tot 24 mei.</p>
<p>We kunnen die prijsstijging niet volledig toeschrijven aan het nieuws over de lancering van de ETF’s, aangezien de bullish momentum al begon vóór de bekendmaking van de goedkeuring van spot ETH ETF’s in de VS. De speculatie over de goedkeuring van de ETF’s, de goedkeuring van ENS door Vitalik Buterin, medeoprichter van Ethereum, evenals het bredere marktsentiment zouden gezamenlijk kunnen hebben bijgedragen. <a href="https://www.gate.io/price/ethereum-name-service-ens/php" target="_blank">activeerde de ENS-prijs</a> spike.</p>
<p>Bredere positieve ontwikkeling in het Ethereum-ecosysteem: Een van de belangrijkste oorzaken van de recente piek in de Ethereum Name Service-token was het positieve sentiment binnen de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum crypto</a> bol. De <a href="https://www.gate.io/price/ethereum-name-service-ens/ves" target="_blank">ENS prijsanalyse</a> geeft aan dat het positieve sentiment sommige invloedrijke ENS-tokeninvesteerders heeft verleid om hun investering in de token te verhogen. Een van dergelijke ENS-investeerders is Brantly Millegan, de voormalige ENS Operations Director.</p>
<p>Het is zeer waarschijnlijk dat de recente investering van Millegan in de ENS-token heeft bijgedragen aan zijn optimistische vooruitzichten. Feit is dat Millegan sinds januari dit jaar 291.305 ENS heeft gestort op Coinbase, zoals blijkt uit de volgende afbeelding.<br><img src="https://gimg2.gateimg.com/image/article/17175730521.jpg" alt=""><br>Bron: x.com
</p><p>Millegan stortte ook meer dan 4,196 miljoen ENS-tokens op Coinbase tijdens de derde week van mei. Ondanks het storten van dergelijke grote hoeveelheden van de token op Coinbase Exchange, bezit Millegan nog steeds 373.000 ENS ter waarde van ongeveer $7,97M. Kortom, de strategische koop- en aanhoudactie door prominente investeerders zoals Millegan heeft geholpen om de waarde van Ethereum Name Service Token hoog te houden. Lees ook hoe je <a href="https://www.gate.io/how-to-buy/ethereum-name-service-ens" target="_blank">koop ENS op Gate.io</a>.</p>
<p>Op het moment van schrijven wordt de ENS-token verhandeld voor $25.14 na een verlies van 0.1% in de afgelopen 24 uur. Over het algemeen hebben de ENS-tokens met een marktkapitalisatie van $790.583.645 en een circulerende voorraad van 31.477.146 een bullish vooruitzicht. Dit blijkt uit de prestaties van het afgelopen jaar. De volgende grafiek toont de prijsbeweging van de ENS-token voor die periode.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/ens-v2-expanding-eth-domain-services-to-l2/3101" target="_blank">ENS V2: Uitbreiding van ETH-domeindiensten naar L2</a><img src="https://gimg2.gateimg.com/image/article/17175730992.jpg" alt=""><br>ENS Token Prijsbeweging: CoinGecko
</p><p>Zoals waargenomen op <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a>, de ENS-token was bullish sinds 31 december 2023 toen de prijs $9.89 bereikte. De goedkeuring van spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> ETF’s in de Verenigde Staten heeft mogelijk invloed gehad op de stijging van de prijs en het bereiken van $24.22 op 12 januari.</p>
<p>Goedkeuring Ethereum ETF: Natuurlijk heeft de goedkeuring van Ethereum ETF’s in de Verenigde Staten een grote impact op de waarden van tokens die op de blockchain bestaan. Op basis van cryptocurrency-trends 2024 droeg veel bij aan de prijsstijging van ENS de anticipatie op de lancering van de ETF’s. Er was veel opwinding op de cryptomarkt nadat Eric Balchunas en James Seyffart, twee gerenommeerde Bloomberg ETF-analisten, de waarschijnlijkheid van goedkeuring van ETH ETF’s verhoogden van 25% naar 75%.</p>
<p>Ook de geruchten over de ETF’s kregen meer invloed toen investeerders hoorden dat de U.S SEC de potentiële uitgevers aanmoedigde om de Ethereum ETF 19 b-4 aanvragen te versnellen, wat het potentieel voor hun goedkeuring aangaf. De verwachting van de lancering van ETF’s heeft altijd een positieve invloed gehad op de cryptomarkt. Zo zorgde de verwachting van de goedkeuring van spot bitcoin ETF’s in januari voor de Q1, 2024 crypto-rally.</p>
<p>Nu kan de lancering van de ETH ETF’s leiden tot een stijging in de vraag naar de Ethereum crypto. Het is echter belangrijk op te merken dat de ETF-uitgevers de beleggingsactiva nog niet hebben gelanceerd.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/ethereum-name-service-ens" target="_blank">ENS Prijsvoorspelling voor 2024-2030</a></p>
<p>Vitalik Buterin’s Endorsement: Het Ethereum ENS kreeg een extra boost toen Vitalik Buterin hen aanprees als een hoogwaardig crypto-product. Zelfs de medeoprichter van Ethereum uitte zijn verbazing over hoeveel crypto-investeerders zich er niet van bewust zijn dat de ENS-token een waardevolle investeringsactiva is. Zo benadrukte Buterin eenvoudigweg het nut van de ENS. De vereenvoudiging van Ethereum-adressen in leesbare tekst verhoogt de gebruikerservaring, omdat dit de risico’s op fouten bij transacties vermindert.</p>
<h2 id="h2-Analyse20van20de20impact20van20ETH20ETFS20ENS20marktwaarde20tot20gerealiseerde20waarde20MVRV20ratio231018"><a name="Analyse van de impact van ETH ETFS: ENS’ marktwaarde tot gerealiseerde waarde (MVRV) ratio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analyse van de impact van ETH ETFS: ENS’ marktwaarde tot gerealiseerde waarde (MVRV) ratio</h2><p>Één ding is zeker, de massale interesse in ENS heeft het in een overgekochte marktzone geduwd, wat blijkt uit een stijging van de Market Value to Realized Value (MVRV) ratio. Op 24 mei bijvoorbeeld bedroeg de 30-daagse MVRV van Ethereum Name Service 25,7%, wat wijst op winst die een marktverkoop kan veroorzaken. In het verleden onderging ENS een marktcorrectie wanneer de MVRV-ratio varieerde tussen 7% en 21%, wat historisch gezien als het gevarengebied werd bestempeld. De volgende grafiek toont de MVRZ-status van ENS tijdens de vierde week van mei.<br><img src="https://gimg2.gateimg.com/image/article/17175731703.jpg" alt=""><br>ENS MVRV Ratio – Santiment
</p><p>Met zo’n hoge MVRV-ratio zullen veel investeerders waarschijnlijk hun ENS-tokens verkopen, omdat ze zich in de winstzone bevinden. De stijging van actieve ENS-adressen bevestigt het vermoeden dat sommige tokenhouders hun posities kunnen verkopen.<br><img src="https://gimg2.gateimg.com/image/article/17175732074.jpg" alt=""><br>ENS Actieve stortingen - Santiment
</p><p>Zoals uit de grafiek blijkt, was er gedurende de genoemde periode een toename van actieve ENS-portefeuilleadressen, wat erop wijst dat ze klaar zijn om hun tokens te verkopen. Een massale verkoop van de token kan echter een bearish periode inluiden.</p>
<h2 id="h2-Ethereum20Name20Service2020korte20samenvatting680185"><a name="Ethereum Name Service - korte samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum Name Service - korte samenvatting</h2><p>Het Ethereum Naam Service bestaat op de blockchain, en is dus van nature gedecentraliseerd. Het stelt gebruikers in staat om hun eigen ETH domeinnamen te maken die worden opgeslagen in digitale portefeuilles en zorgen voor eigendom en beveiliging van op Ethereum blockchain gebaseerde virtuele activa. Het interessante is dat mensen de ENS kunnen verhandelen en overdragen zoals ze doen met verschillende gedecentraliseerde activa.</p>
<h2 id="h2-ENS20Prijsvoorspellingen749401"><a name="ENS Prijsvoorspellingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ENS Prijsvoorspellingen</h2><p>Op dit moment, wordt de ENS-token verhandeld voor $25.14 en heeft het een optimistisch vooruitzicht. Op basis van de huidige ENS prijsanalyse, ligt het volgende belangrijke weerstandsniveau op $26. Aan de andere kant, The Coinpriceforecast <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">prijsvoorspelling</a> toont <a href="https://coinpriceforecast.com/ens-coin" rel="nofollow noopener noreferrer" target="_blank">dat de ENS-prijs tegen medio 2024 kan stijgen tot $ 50</a> en $75 tegen het einde van het jaar. De cryptocurrency trends 2024 tonen een bullish ENS-markt aangezien de token een Greed and Fear-reading heeft van 73. Kijkend naar de toekomst, kan de ENS tegen het einde van 2025 handelen op $78,54 en $124,39 tegen 2030.</p>
<h2 id="h2-Conclusie763955"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Ondanks de recente prijsrally van ENS is het token er niet in geslaagd om het bullish momentum dat werd gegenereerd door de lancering van de spot ETH ETF’s, vol te houden. De goedkeuring van Buterin en het bredere sentiment van de cryptomarkt hebben ook geholpen om de waarde van het ENS-token omhoog te drijven. Als gevolg hiervan heeft het token een bullish momentum behouden. Desalniettemin toont de hoge MVRV-waarde een mogelijkheid van massale verkoop, wat de prijs omlaag kan dwingen.</p>
<h2 id="h2-Veelgestelde20vragen20over20Ethereum20ENS128037"><a name="Veelgestelde vragen over Ethereum ENS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Ethereum ENS</h2><h3 id="h3-Wat20is20Ethereum20Name20Services279719"><a name="Wat is Ethereum Name Services?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Ethereum Name Services?</h3><p>The Ethereum Name Services (ENS) is een systeem voor benoemen <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> digitale portemonnee adressen in een menselijk leesbare vorm zoals mavis.eth. Dergelijke namen zijn geschikt voor Ethereum-gebruikers omdat ze transactiefouten minimaliseren.</p>
<h3 id="h3-Is20Ethereum20naam20service20een20goede20investering768437"><a name="Is Ethereum naam service een goede investering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is Ethereum naam service een goede investering?</h3><p>De Ethereum Naamservices is een goede investering omdat het is gebaseerd op veilige technologie en nut biedt aan het Ethereum-netwerk. Ook is het zeer eenvoudig om ENS-tokens te verkopen en over te dragen.</p>
<h3 id="h3-Wat20is20het20doel20van20ENS45162"><a name="Wat is het doel van ENS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het doel van ENS?</h3><p>Het belangrijkste doel van ENS is om transacties gemakkelijker en veiliger te maken dan de traditionele Ethereum digitale portemonnee adressen. De gebruikers hoeven zich niet langer zorgen te maken over het veilig bewaren van hun privésleutels of zaadzinnen.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br><div></div>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle gevallen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br><p></p><br></em></div></div></div>