R2xhc3Nub2RlIEluc2lnaHRzOiBORlQgVHJhZGluZyBQcm9mZXNzaW9uYWxpemVz

2023-03-01, 02:03
<p><img src="https://gimg2.gateimg.com/blog/167117004537106004920221216-135350.jpeg" alt=""></p>
<p>Terwijl Amerikaanse toezichthouders zich richten op gecentraliseerde beurzen, lijken de cryptomarkten onaangedaan en vastbesloten om hun opwaartse trend voort te zetten. Na een lichte daling gedurende het grootste deel van de week consolideerden de ETH-prijzen rond $1650 in het weekend en stegen ze boven de niveaus van vóór de ineenstorting van FTX.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677635867Group-2850.png" alt=""></p>
<p>In deze editie bekijken we de hernieuwde interesse binnen de NFT-ruimte, gedreven door de laatste ontwikkelingen rond de aankomende NFT-marktplaats en aggregator, Blur, en zijn directe uitdaging aan marktleider OpenSea. We analyseren de effecten van de Blur airdrop op de marktdominantie van OpenSea en beoordelen de duurzaamheid van de gebruikersacquisitie van Blur. We onderzoeken ook of de strategie en focus van Blur op professionele handelaren het potentieel hebben om een paradigma verschuiving te veroorzaken voor de NFT-industrie. Verder ueren we in hoeverre de hernieuwde interesse in NFT’s wordt bevorderd. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Netwerkactiviteit van ‘s werelds, en of het sterk genoeg is om adoptie te herstellen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677635899Group-2846.png" alt=""></p>
<h2 id="h2-Markten20onder20de20indruk20van20toezichthouders595470"><a name="Markten onder de indruk van toezichthouders" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markten onder de indruk van toezichthouders</h2><p>Na de neergang van FTX hebben Amerikaanse toezichthouders hun toezicht op cryptocurrency-beurzen verhoogd. Op 8 februari bereikte de in de VS gevestigde beurs Kraken een schikking met de SEC over haar staking-als-een-serviceproduct. Als gevolg hiervan heeft de beurs onmiddellijk de stakingdiensten voor Amerikaanse burgers opgeschort.</p>
<p>Kort daarna, op 13 februari, kondigde stablecoin-uitgever Paxos aan dat het de uitgifte van BUSD op 21 februari zou stopzetten vanwege regelgevende druk van het New York State Department of Financial Services. BUSD-houders reageerden snel door over te stappen naar andere stablecoins terwijl ze een duidelijke voorkeur hadden voor USDT. Sinds 8 februari is BUSD met meer dan 31,2% gedaald en zijn er meer dan $5,052 miljard aan inwisselingen geweest.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677635930BUSD.png" alt=""></p>
<p>Voorafgaand aan de aankondiging van Paxos had BUSD een marktaandeel van 11% veroverd binnen de stablecoin-markt van $136 miljard. Sindsdien, <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> heeft in relatieve toevoer dominantie gewonnen en heeft nu een marktaandeel van 54%. DAI heeft nog steeds geen merkbaar marktaandeel gewonnen, noch zichzelf succesvol kunnen promoten als de voorkeurs gedecentraliseerde en censuurbestendige alternatief, ondanks recente gebeurtenissen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677635964Group-2843.png" alt=""></p>
<h2 id="h2-Brandstofprijzen20stijgen20opnieuw121993"><a name="Brandstofprijzen stijgen opnieuw" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Brandstofprijzen stijgen opnieuw</h2><p>De mediane transactiegasprijzen zijn de afgelopen negen maanden consequent laag geweest, variërend tussen 10 en 20 Gwei. Dit komt overeen met een gemiddelde van $0.50 voor een standaardtransactie en ongeveer $2.00 voor een interactie met een slim contract, een fractie van de driecijferige getallen die we zagen tijdens de afgelopen bull-cyclus. Lage gasprijzen duiden op weinig vraag naar blokruimte en dus weinig gebruik van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> toepassingen van ‘s, wat typisch is tijdens berenmarkten.</p>
<p>Sinds het begin van dit jaar kunnen we echter een geleidelijke maar gestage stijging van de gasprijzen waarnemen. De gasprijzen staan momenteel op 38 Gwei, wat de gasprijspieken die we tijdens deze bearmarkt zagen rond gebeurtenissen zoals de FTX-collapse en de Binance-bankrun overtreft. De incrementele aard van de vraag naar gas suggereert dat er mogelijk een vroege opleving van de netwerkactiviteit aan de gang is.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677635993Group-2825.png" alt=""></p>
<h2 id="h2-Interesse20in20NFTs20wordt20opnieuw20gewekt848385"><a name="Interesse in NFT’s wordt opnieuw gewekt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Interesse in NFT’s wordt opnieuw gewekt</h2><p>Bij nadere inspectie van de grafiek van gasgebruik per transactie kunnen we vaststellen dat een belangrijke bron van deze toenemende netwerkactiviteit de NFT-markt is, die opnieuw tekenen van groei vertoont.</p>
<p>Na een sterke daling in de gebruikersactiviteit tegen het einde van 2022 is het totale gasverbruik door NFT-transacties twee opeenvolgende maanden met 97% gestegen. Dit suggereert dat de activiteit rond NFT’s weer op het niveau komt van de NFT-boom.</p>
<p>Hoewel aanvankelijk deze stijging van interesse in NFT’s wordt toegeschreven aan de lancering van nieuwe collecties door enkele van de grootste spelers in de branche, zoals Yuga Labs, Doodles en Moonbirds, toont een diepgaandere inspectie aan dat de vraag naar gas in de afgelopen twee weken voornamelijk is aangewakkerd door de ontwikkelingen rond de Blur Airdrop.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677636022Group-2835.png" alt=""></p>
<h2 id="h2-Blur20komt20na20OpenSea467288"><a name="Blur komt na OpenSea" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Blur komt na OpenSea</h2><p>Gelanceerd in oktober 2022, heeft Blur, een NFT-marktplaats en aggregator, snel terrein gewonnen en is sindsdien op de hielen gaan zitten van marktleider OpenSea. Op dit moment heeft Blur een marktaandeel van 78% van het NFT-overdrachtsvolume veroverd, nadat het OpenSea had ingehaald na de airdrop op 14 februari. Blur streeft ernaar een professioneel handelsplatform te zijn voor NFT’s, met een model zonder handelskosten en optionele royaltybetalingen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677636045NFT_marketplaces.png" alt=""></p>
<p>Hoewel de token in de afgelopen week ongeveer 13% van zijn waarde heeft verloren, heeft de airdrop nieuwe aandacht gebracht voor de opkomende concurrent. Als gevolg hiervan steeg het marktaandeel van Blur met 34%, waardoor het marktaandeel van OpenSea daalde van 36% naar 15%. In een poging om zijn opkomende concurrent tegen te gaan, heeft OpenSea een gedurfde zet gemaakt door zijn vergoedingsmodel en beleid te herstructureren, maar was nog steeds niet in staat om zijn marktaandeel te behouden:</p>
<p>De beperkte impact van de tegenzet van OpenSea kan worden toegeschreven aan de verschillen in de gebruikersbases van het platform. OpenSea heeft historisch gezien makers en verzamelaars aangetrokken, terwijl Blur zich richt op professionele handelaren. Met zijn tokenbeloningen heeft Blur met succes de marktdiepte op zijn platform verbeterd door gebruikers te stimuleren biedingen te plaatsen, met als uiteindelijk doel de frequentie van NFT-verkopen te verhogen en de NFT-handels- en liquiditeitservaring te verbeteren.</p>
<p>Vanwege de uniekheid van NFT’s kan het kwantificeren van hun liquiditeit uitsluitend op basis van handelsvolume in verhouding tot het totale aantal activa misleidend zijn. Daarom kan het onderzoeken van de dagelijkse verkoopfrequentie per unieke gebruiker een nauwkeuriger maatstaf zijn voor de omzet. Voor niet-vervangbare activa beschrijft dit uiteindelijk de snelheid waarmee individuele verkopers kopers vinden die bereid zijn om een willekeurige NFT uit de collectie te kopen, en tegen welke prijs.</p>
<p>In dat opzicht leidt Blur duidelijk de race met tussen de 4 of 5 transacties per gebruiker op dagelijkse basis, terwijl OpenSea gemiddeld twee dagelijkse transacties per gebruiker ziet. Een hogere verkoopfrequentie kan een vliegwieleffect creëren, aangezien meer NFT-verkopers zich zelfverzekerd voelen om op het platform van Blur te luisteren, waardoor een groter aanbod ontstaat, wat op zijn beurt meer kopers aantrekt.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677636074Group-2840-1-.png" alt=""></p>
<p>Hoewel de beslissing van OpenSea om de kosten en royalty’s te verlagen een reactie was op de druk van zijn concurrenten, zou dit kunnen leiden tot een paradigmaverschuiving op de NFT-markt. Nu de twee belangrijkste marktplaatsen hun focus verleggen van makers en verzamelaars naar handelaren, kan de waardecreatie voor NFT’s ook veranderen, waardoor deze verzamelobjecten mogelijk een nieuwe iteratie in de activaklasse worden.</p>
<p>Omdat NFT’s historisch gezien hun waarde hebben afgeleid van meer subjectieve criteria zoals kenmerken, zeldzaamheid en gemeenschap, is prijsontdekking moeilijk geweest en vaak beïnvloed door marktmanipulatie. Markt maken en hogere frequentie voor NFT-handel kunnen de marktefficiëntie verhogen en NFT’s dichter bij hun waargenomen waarde laten verhandelen.</p>
<p>Een blik op de verkoopomvang van beide marktplaatsen geeft aan dat de aanpak van Blur ook een winstgevendere verkoopomgeving mogelijk maakt, met verkoopgroottes variërend tussen 0,3 en 1,3 ETH. Verkopen op OpenSea daarentegen zijn constant geweest, met een gemiddelde van ongeveer 0,2 ETH gedurende vele maanden. Merk op dat bij niet-fungibele tokens de verkoopomvang niet alleen een betere winstgevendheid voor NFT-verkopers vertegenwoordigt, maar ook kan voortkomen uit over het algemeen hoger geprijsde aanbiedingen op de marktplaats van Blur. Dit spreekt opnieuw voor het succes van de marktstrategie van het platform en het doelpubliek.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677636117Group-2844.png" alt=""></p>
<h2 id="h2-Weinig20effect20op202020Ethereum280040"><a name="Weinig effect op   Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Weinig effect op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a></h2><p>De recente aandacht rond Blur heeft geleid tot een stijging in de vraag naar blokruimte, resulterend in verhoogde kosten voor validators, en meer ETH die wordt verbrand via EIP1559. Dit heeft echter nog geen merkbare impact gehad op de adoptie van het netwerk. Hoewel er een groei is geweest in totale on-chain activiteit en groei, is het aantal nieuwe adressen nog steeds 40% lager dan vorig jaar, en het maandelijkse gemiddelde 🔴 blijft onder het jaargemiddelde 🔵, wat wijst op negatieve momentum.</p>
<p>De nieuwste interesse in NFT’s lijkt voornamelijk aantrekkelijk te zijn voor bestaande gebruikers en is tot nu toe niet in staat om nieuwe gebruikers aan te trekken voor de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Dit suggereert ook dat zowel de besproken NFT-marktplaatsen als de meeste protocollen strijden om dezelfde bestaande gebruikersbasis van crypto-inwoners.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1677636140Group-2845.png" alt=""></p>
<h2 id="h2-Samenvatting20en20conclusies982484"><a name="Samenvatting en conclusies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting en conclusies</h2><p>Met Blur’s strategie voor het verkrijgen van gebruikers en de focus op het stimuleren van liquiditeit, heeft het een zekere mate van succes behaald bij het aantrekken van handelaren, verder dan de initiële airdrop-hype. De marktplaats is op weg om een serieuze speler te worden in de NFT-industrie. Met de recente aankondiging van een tweede airdrop, waarbij gebruikers worden beloond voor loyaliteit, valt nog te bezien of het in staat is om deze nieuwe gebruikersbasis te behouden.</p>
<p>De toegenomen concurrentie en verschuiving van de focus op de NFT-markt is duidelijk in het voordeel van NFT-handelaren, die profiteren van lagere kosten, verhoogde liquiditeit en een betere prijsontdekking. Ondertussen kunnen makers zich benadeeld voelen door de vermindering van de handhaving van royalty’s in de hele sector.</p>
<p>De hernieuwde interesse in NFT’s heeft echter nog geen nieuwe gebruikers aangetrokken of significante nieuwe kapitaalinstromen op gang gebracht in de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ecosysteem. Desalniettemin kan, afhankelijk van het niveau van toekomstige NFT-handelsactiviteiten, nog steeds resulteren in nettowaardecreatie voor de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk, met potentieel hogere MEV beloningen en arbitragemogelijkheden, en de opbouw van nieuwe infrastructuur voor de toekomst.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Glassnode Insights</strong><br><div>Redacteur: Gate.io Blog Team<br><div class="info-tips">*Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbevelingen.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards