RU5TLXJlZ2lzdHJhdGllcyBuZW1lbiBhZjogQW5hbHlzZSB2YW4gZGUgdmVydHJhZ2luZyBpbiBkZSB2cmFhZyBuYWFyIEV0aGVyZXVtLW5hYW1zZXJ2aWNl

2024-07-17, 07:27

<p><img src="https://gimg2.gateimg.com/image/article/17212009521692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR243709"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Het aantal geregistreerde ENS is tussen april en juni 2024 met 48% gedaald.</p>
<p>Regelgevingsonzekerheden, de prestaties van de bredere cryptomarkt en het sentiment van beleggers beïnvloeden de prijs van ENS.</p>
<p>De daling van het aantal geregistreerde ENS is waarschijnlijk tijdelijk, aangezien er een grote kans is op een prijsstijging in de nabije toekomst.</p>
<h2 id="h2-Introductie460517"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De volatiele aard van cryptocurrencies maakt het moeilijk om hun toekomstige prijsbewegingen en andere marktgedrag te voorspellen. Als voorbeeld, de waarden van <a href="/price/ethereum-name-service-ens" rel="nofollow noopener noreferrer" target="_blank">Ethereum Naam Service</a> en Ether (ETH) waren gedurende enkele weken voortdurend in een dalende trend. De daling van hun waarden kan een negatieve invloed hebben op het marktsentiment en toekomstige prijsbewegingen. Deze analyse richt zich op de recente daling in de registratie van ENS ondanks een daling in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> transactiekosten.</p>
<h2 id="h2-ENSregistratie20daalt20terwijl20de20markt20instort818677"><a name="ENS-registratie daalt terwijl de markt instort" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ENS-registratie daalt terwijl de markt instort</h2><p>De registratie van het <a href="/price/ethereum-name-service-ens" target="_blank" class="blog_inner_link">Ethereum Name Service</a> (ENS), een prominente domeinnaamserviceprovider, daalde aanzienlijk in het tweede kwartaal van 2024. De daling kwam nadat het een jaarlijks hoogtepunt had bereikt in de laatste weken van april. Het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Name Service stelt mensen in staat om domeinnamen te maken en te gebruiken binnen het Ethereum-netwerk.</p>
<p>Met behulp van ENS kunnen netwerkgebruikers menselijk leesbare ETH-portemonnee-adressen maken met de vorm. eth. Dit type portemonnee-adres maakt het gemakkelijker voor mensen om digitale activa te beheren, omdat het menselijke fouten vermindert bij het uitvoeren van transacties. Bovendien stellen de primaire blockchaintoewijzingsservices gedecentraliseerde applicaties in staat om gemakkelijk verbinding te maken met digitale portefeuilles. Zo wordt het bijvoorbeeld eenvoudiger voor ENS om verbinding te maken met dApps in het Ethereum-ecosysteem.</p>
<p>Ondanks de daling van Ethereum gasprijzen was er een scherpe daling in ENS tijdens de genoemde periode. De stagnatie in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum prijs</a> leidde tot de daling van de gasvergoedingen. Een afname van de Ethereum-gasvergoedingen maakt ENS-registratie goedkoper, wat veel crypto-gebruikers zou moeten hebben verleid om hun eigen menselijk leesbare cryptocurrency-domeinen te registreren. Dat was echter niet het g. De slechte prestaties van de bredere crypto-markt zouden een negatief sentiment hebben kunnen creëren dat ETH-gebruikers ontmoedigde om hun ENS-domeinen te registreren.</p>
<p>Gegevens van Dune Analytics, een van de toonaangevende blockchain-analysebedrijven, geven een scherpe daling van domeinregistraties op de blockchain aan. Zo blijkt uit de gegevens dat er in juni slechts 20.131.eth-namen zijn geregistreerd, wat een daling van 30% op maandbasis (MoM) betekent ten opzichte van mei. Dat betekent ook een daling van 58% van ENS ten opzichte van de 47.704 registraties die in april zijn gemaakt, wat het hoogtepunt van 2024 is. De volgende grafiek geeft een samenvatting van de prestaties van ENS sinds juli 2023 weer.<br><img src="https://gimg2.gateimg.com/image/article/1721201030img_v3_02cs_7b4d2680-f6d8-4166-a420-c4ae84863eix.jpg" alt=""><br>Ethereum Name Service Maandelijkse Registraties: Dune Analytics</p>
<p>Zoals u opmerkt over <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> De registratie van ENS-namen op de ETH digitale identiteitsblockchain voor Ethereum was in juni het laagste sinds juli 2023. Dit toont de impact van het Ethereum-netwerk op de ENS-naamregistraties aan.</p>
<h2 id="h2-Hoe20de20afname20van20ENS20het20bredere20Ethereumecosysteem20benvloedt20een20kritische20analyse226763"><a name="Hoe de afname van ENS het bredere Ethereum-ecosysteem beïnvloedt: een kritische analyse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe de afname van ENS het bredere Ethereum-ecosysteem beïnvloedt: een kritische analyse</h2><p>Aangezien de Ethereum Name Service een essentieel onderdeel is van het Ethereum-ecosysteem, heeft de daling van de ENS-registratie invloed op het gedrag van investeerders, zoals handelaren. Ten eerste gebruiken investeerders het niveau van ENS-registratie als een barometer om de marktinteresse in Ether te meten. Een daling van ENS maakt investeerders voorzichtig omdat ze het zien als een marktsignaal dat de interesse van investeerders in Ethereum is afgenomen. Dit duidt op een mogelijke pessimistische outlook. Uiteindelijk leidt dit tot een afname van de ETH-vraag en een toename van de verkoopdruk. Dit hangt echter af van de bestaande cryptomarktomstandigheden.</p>
<p>De huidige ENS-markttrend toont ook toenemende regelgevende onzekerheid die leidt tot een negatief marktsentiment ten opzichte van een specifieke crypto-activa zoals ETH of ten opzichte van de hele cryptocurrency-markt. Sommige analisten geloven echter dat de huidige trend in blockchaintechnologie, die een afname van de interesse in ENS omvat, slechts tijdelijk is. Ze denken dat verbetering van regelgevende duidelijkheid waarschijnlijk zal leiden tot een opleving van de activa.</p>
<h2 id="h2-Toekomst20van20ENSregistratie20de20markt20blijft20somber648715"><a name="Toekomst van ENS-registratie: de markt blijft somber" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomst van ENS-registratie: de markt blijft somber</h2><p>Tijdens het begin van de tweede helft van 2024 blijft de toekomst van ENS registraties somber. Bijvoorbeeld, het openstaande belang in ENS-derivaten is aanzienlijk afgenomen in de eerste weken van juli. In die periode daalde het openstaande belang van ENS met meer dan 48% en toonde een afname in de vraag. Met andere woorden, openstaand belang verwijst naar het totale aantal uitstaande derivatencontracten op elk willekeurig moment.</p>
<p>Een daling van de openstaande interest toont aan dat het aantal handelaren dat hun posities verlaat hoger is dan degenen die nieuwe posities openen. Een daling van de openstaande interest weerspiegelt een afname van de vraag naar de onderliggende asset, die meestal gepaard gaat met een daling van de prijs van de asset. Aangezien de openstaande interest van ENS begin juli aanzienlijk daalde, duidt dit op een afname van de vraag naar de asset. Ook was de Relative Strength Index (RSI) van ENS begin tweede week van juli rond de 47,93, wat erop wijst dat de verkoopdruk hoger was dan het koopmomentum.</p>
<p>Ondanks de recente dip in de registraties van het blockchain domein is de toekomst van ENS helder. Zodra er een golf van ENS-aankoopactiviteiten is, zullen we waarschijnlijk een piek in hun registratie zien. Ook zal een verbetering in de bredere prestaties van de cryptomarkt waarschijnlijk leiden tot een stijging in de ENS-registraties. Over het algemeen beïnvloeden de prestaties van de bredere cryptosector, de regelgevingsomgeving en het investeerderssentiment het aantal registraties dat binnen een bepaalde periode zoals een maand plaatsvindt.</p>
<p>De rebranding oefening van het Ethereum Name Service (ENS) die begon op 8 juli, zou ook de vraag naar ENS kunnen verhogen. Zo is er bijvoorbeeld een upgrade geweest in het marketingmateriaal en de website van ENS, evenals een toename van de aanwezigheid op sociale media. Hiermee samenhangend, <a href="https://blockonomi.com/ethereum-name-service-unveils-brand-refresh-to-bridge-web2-and-web3/#:~:text=Khori%20Whittaker%2C%20utive%20Director%20of,but%20cautious%20about%20diving%20in." rel="nofollow noopener noreferrer" target="_blank">Blockonomi citeerde Khori Whittaker, utive Director van ENS Labs</a>, zoals het gezegde luidt: ‘Deze rebrand markeert een keerpunt voor ENS nu we ons inzetten om het internet te vernieuwen. We ontmoeten mensen waar ze vandaag zijn - nieuwsgierig naar <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> maar voorzichtig om erin te duiken. Door complexe technische taal af te schudden en toegankelijke taal en ontwerp te omarmen, treden we op de voorgrond als jouw vriendelijke gids naar het nieuwe internet.’</p>
<p>Het doel van deze rebranding is om de gebruikersaanname te verbeteren door het verstrekken van gemakkelijk te begrijpen informatie. Domenico Perri, hoofd van Design en UX bij ENS Labs, ging verder op dit aspect. <a href="https://blockonomi.com/ethereum-name-service-unveils-brand-refresh-to-bridge-web2-and-web3/" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>, ‘We bouwen bruggen, verbinden technologieliefhebbers met nieuwsgierige nieuwkomers om een levendige gemeenschap te creëren waar iedereen bij hoort. Ons doel is eenvoudig: een beter internet creëren voor iedereen. Deze rebranding is onze uitnodiging aan jou - ongeacht je achtergrond of expertise - om deel te nemen aan deze transformerende reis.’ Daarom kan de ENS-registratie in de nabije toekomst toenemen als deze rebranding succesvol is.</p>
<h2 id="h2-Conclusie410385"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>In juni daalde de ENS-registratie opmerkelijk als gevolg van verschillende factoren, waaronder regelgevingsonzekerheden en het negatieve sentiment in de cryptomarkt. Toch is er nog hoop. Naarmate de bredere cryptomarkt zich herstelt, zullen de prijzen van ENS waarschijnlijk weer stijgen. Een stijging van het vertrouwen van beleggers in ENS zal helpen om de prijs op te voeren.</p>
<h2 id="h2-Veelgestelde20vragen20over20het20Ethereum20Name20Service20ENS896154"><a name="Veelgestelde vragen over het Ethereum Name Service (ENS)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over het Ethereum Name Service (ENS)</h2><h3 id="h3-Wat20is20Ethereum20Name20Service867454"><a name="Wat is Ethereum Name Service?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Ethereum Name Service?</h3><p>Ethereum-naamservice is een op blockchain gebaseerde dienst die willekeurig gegenereerde digitale portefeuilleadressen omzet in menselijk leesbare domeinen die eindigen op .eth. Deze namen helpen Ethereum-gebruikers menselijke fouten te verminderen bij het doen van transacties.</p>
<h3 id="h3-Is20Ethereum20naam20service20een20goede20investering609810"><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>Op basis van de huidige marktomstandigheden levert investeren in Ethereum Name Service goede rendementen op. Zo is de waarde van de ENS in het afgelopen jaar met 160% gestegen.</p>
<h3 id="h3-Wat20is20de20toekomst20van20Ethereum20naamdienst847803"><a name="Wat is de toekomst van Ethereum naamdienst?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de toekomst van Ethereum naamdienst?</h3><p>De vraag naar ENS zal waarschijnlijk toenemen in de toekomst wanneer de markt een bullmarkt betreedt. Ook wanneer de ETH ETF’s worden gelanceerd, kan de vraag stijgen. Dit komt doordat de vraag naar ENS stijgt wanneer de prijs van Ethereum toeneemt.</p>
<h3 id="h3-Hoe20maak20je20een20ENS20aan67084"><a name="Hoe maak je een ENS aan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe maak je een ENS aan?</h3><p>Om een ENS te maken, ga je naar de ENS Manager App en verbind je je wallet. Vervolgens zoek je naar de gewenste naam en selecteer je het aantal jaren dat je de naam wilt registreren en klik je op volgende. Ten slotte moet je mogelijk je profiel bewerken voordat je op ‘Registreren’ klikt.</p>
<div class="blog-details-info"><br><div>Auteur:<em> Mashell C.</em>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>