V2VrZWxpamtzZSBORlQtbWFya3RhbmFseXNlKDAyMTctMDIyMyk=

2023-03-14, 07:58

<p><img src="https://gimg2.gateimg.com/image/article/1678776904image.png" alt=""></p>
<p>Deze week is er een aanzienlijke stijging geweest in het handelsvolume van NFT’s, met een toename van 191.48%, en een positieve verschuiving in de trend sinds 14 februari. Het is echter belangrijk op te merken dat handelsvolumes mogelijk niet het geheel weerspiegelen <a href="https://www.gate.io/zh/nft/?ch=GM_blog_insights_20230314&amp;utm_campaign=TR_haJPnWbH&amp;utm_content=&amp;utm_medium=ptr&amp;utm_source=CH_sApqy83F&amp;utm_term=" target="_blank">NFT</a> Handelsmarkt, aangezien verschillende factoren zoals oplichting, washandel en NFT-marketing de daadwerkelijke handelsvolumes op de markt kunnen opblazen. Het is cruciaal om de handelsvolumes grondig te analyseren om een duidelijk begrip te krijgen van de werkelijke staat van de markt. Deze week had het projectteam ‘MechMinds’ een opmerkelijke impact op het handelsvolume, met een bijdrage tot een stijging van 22% met hun NFT-marketingstrategie.</p>
<h2 id="h2-NFT20Marktwaarde20amp20Handelsvolume20Analyse20ETH960217"><a name="NFT Marktwaarde &amp; Handelsvolume Analyse (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>NFT Marktwaarde &amp; Handelsvolume Analyse (ETH)</h2><p><img src="https://gimg2.gateimg.com/image/article/1678776924image2.png" alt=""><br>NFT Market Cap &amp; Trading Volume in ETH (NFTGo.io)</p>
<p>Op basis van de marktgegevens blijkt dat de Market Cap in februari met 10,22 (1,54%) en 566,47K (290,46%) is gestegen, wat een positieve trend laat zien. Het is echter belangrijk om op te merken dat de aanzienlijke toename van het handelsvolume op 20 februari voornamelijk te wijten is aan de marketingcampagne van het NFT-projectteam “MechMinds”, dat goed is voor 125.000 ETH van het handelsvolume. Deze toename van het handelsvolume weerspiegelt niet het algemene marktsentiment en handelaren.</p>
<h2 id="h2-Traders20Verhoudingsanalyse263777"><a name="Traders Verhoudingsanalyse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Traders Verhoudingsanalyse</h2><p><img src="https://gimg2.gateimg.com/image/article/1678776943image3.png" alt=""><br>Verhouding handelaren van 2022-2023 (NFTGo.io)</p>
<p>Het totale aantal handelaren is met 13,82% gestegen ten opzichte van vorige week, met nog eens 70.637 (8,82%) kopers en 94.083 (20,19%) verkopers. Hoewel handelaren nog steeds eerder geneigd zijn om NFT’s te verkopen dan te kopen, is de algehele verhouding licht positief en vertoont tekenen van herstel. Bovendien kan het grotere aantal verkopers worden toegeschreven aan de huidige marktomstandigheden, wat aangeeft dat sommige handelaren geneigd zijn hun bezittingen te verkopen vanwege marktonzekerheid.<br>Deze marktonzekerheden zijn niet nieuw en zijn een terugkerend thema in de NFT-markt. Veel factoren zoals overheidsreguleringen, milieuzorgen en technische problemen hebben bijgedragen aan de marktonstabiliteit. Ondanks deze uitdagingen blijft de NFT-markt terrein winnen en zien we een grotere acceptatie onder reguliere gebruikers, wat de ontwikkeling van de NFT-ecoen versnelt.</p>
<h2 id="h2-Wekelijkse20handelsvolumeverdeling975083"><a name="Wekelijkse handelsvolumeverdeling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wekelijkse handelsvolumeverdeling</h2><p><img src="https://gimg2.gateimg.com/image/article/1678776971image4.png" alt=""><br>Verdeling van de wekelijkse handelsvolume (NFTGo.io)</p>
<p>In de handelsvolume van deze week van 566K ETH is de hoogste verzameling de ‘Otherdeed’-verzameling. Aangezien het werkelijke handelsvolume van ‘MechMinds’ 340 ETH is.<br>Wat betreft de marktomvangverdeling, behielden de meeste blue-chip-collecties hun gebruikelijke handelsvolumes en heeft een nieuwe collectie ‘Checks VV - Opepen Edition’ een handelsvolume van 20,42K bereikt, waarmee het op de 6e plaats staat in het hoogste handelsvolume van deze week.<br>Het is interessant op te merken dat de stijging van het handelsvolume van de ‘Otherdeed’-collectie grotendeels te danken is aan de recente aankondiging van de makers van de collectie, die hebben gehint op de release van een nieuwe serie NFT’s. Deze aankondiging heeft veel opwinding en anticipatie opgewekt onder NFT-enthousiastelingen en verzamelaars, wat heeft geleid tot een aanzienlijke toename van het handelsvolume voor de bestaande collectie.<br>Bovendien, terwijl het handelsvolume van de meeste blue-chip-collecties stabiel bleef, waren er enkele opmerkelijke uitzonderingen. Het handelsvolume van de ‘CryptoPunks’-collectie bijvoorbeeld, zag deze week een lichte daling, wat kan worden toegeschreven aan de toenemende populariteit van nieuwere en meer diverse collecties.</p>
<h2 id="h2-Top20NFTverkopen20van20de20week697772"><a name="Top NFT-verkopen van de week" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Top NFT-verkopen van de week</h2><p><img src="https://gimg2.gateimg.com/image/article/1678777003image5.png" alt=""><br>Wekelijkse top NFT-verkopen (NFTGo.io)</p>
<p>De marketingstrategie van het MechMinds-projectteam was een belangrijke factor bij de recordverkoop van de “MechMinds #7689” NFT, die deze week een verbazingwekkende prijs van 125K ETH behaalde en nu de duurste ooit verkochte NFT is. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain.</p>
<h2 id="h2-Trending20Project20Analysis20MechMinds317493"><a name="Trending Project Analysis “MechMinds”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Trending Project Analysis “MechMinds”</h2><p><img src="https://gimg2.gateimg.com/image/article/1678777025image6.png" alt=""></p>
<h2 id="h2-Achtergrondinformatie169438"><a name="Achtergrondinformatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Achtergrondinformatie</h2><p>Het MechMinds-project bestaat uit 9672 NFT’s, elk met een eigen persoonlijkheid en intelligentieniveau. Het project is ontworpen met een deflationair NFT-systeem waarmee eigenaren kunnen communiceren over elk onderwerp met hun exclusieve MechMind-begleider, aangedreven door OpenAI’s GPT-model.</p>
<h2 id="h2-Marketingstrategie20van20MechMinds781033"><a name="Marketingstrategie van MechMinds" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marketingstrategie van MechMinds</h2><p>De marketingstrategie van ‘Mechminds’ was gebaseerd op de CryptoPunk-verkoop die in 2021 plaatsvond. Dit zorgde voor veel ophef in de NFT-gemeenschap omdat het de duurste NFT tot nu toe was. Ze hebben hun ‘MechMind #7689’ verkocht met OpenSea’s transactie zonder kosten voor promotionele doeleinden. Met deze zet van het project trok het veel aandacht en werd het genoteerd als de top en trending in de OpenSea-ranking en wist het verschillende soorten handelaren aan te trekken, zoals blue-chip houders, whales en normale handelaren na de transactie van 125K.</p>
<h2 id="h2-Wat20zijn20Deflationary20NFTs178544"><a name="Wat zijn Deflationary NFTs?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn Deflationary NFTs?</h2><p><img src="https://gimg2.gateimg.com/image/article/1678777069image7.png" alt=""><br>MechMinds NFT-collectiestatus (MechMinds)</p>
<p>In de afgelopen jaren is er een aanzienlijke toename geweest in de populariteit en toepassingen van non-fungible tokens (NFT’s). Er is echter een relatief onontgonnen gebied in de NFT-ruimte genaamd ‘Deflationaire NFT’s’. Deze soorten NFT’s zijn specifiek ontworpen om geleidelijk in aantal af te nemen in de loop van de tijd met behulp van technieken zoals ‘verbranding’, ‘tokenomics’ en beperkte aanvoer, wat mogelijk kan leiden tot een verhoging van hun waarde en potentiële voordelen en nadelen.</p>
<h2 id="h2-Handelsvolumeanalyse671443"><a name="Handelsvolume-analyse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Handelsvolume-analyse</h2><p><img src="https://gimg2.gateimg.com/image/article/1678777088image8.png" alt=""><br>Handelsvolume van “UINTS” (NFTGo.io)</p>
<p>Het project werd op 13 februari gemunt met in totaal 9672 NFT’s, maar slaagde er niet in om binnen een week te minten en het minten werd voltooid op 21 februari. Dit geeft aan dat de MechMinds-collectie geen enkele aandacht trok en <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De Grafiek</a> toont aan dat het niet veel handelsactiviteit had totdat de marketingtransactie werd uitgevoerd door het projectlid. Kort na de transactie van 125.000 ETH trok het 26 walvissen, 72 blue-chip houders en ongeveer 5800 transacties aan, wat bewustwording op de markt en een record van de hoogst verkochte NFT opleverde. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ketting.</p>
<h2 id="h2-Houderstrend495504"><a name="Houderstrend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Houderstrend</h2><p><img src="https://gimg2.gateimg.com/image/article/1678777109image9.png" alt=""><br>Houders Trend van “UINTS”(NFTGo.io)</p>
<p>Momenteel met 1567 NFT-houders, wordt 28,66% van de houders niet beschouwd als flippers, terwijl 71,34% van de houders de NFT minder dan 7 dagen in bezit heeft gehad, samen met 67,70% van de houders hun NFT onmiddellijk na het minten ervan hebben verkocht. Dit is onvermijdelijk omdat de meeste houders en handelaren voornamelijk werden aangetrokken door een plotselinge toename van het handelsvolume, waarbij ze een kans zagen voor investeringen en winst. Terwijl er 2 walvissen en 90 blue-chip houders zijn, moet dit project nader worden onderzocht om te bepalen of het op de lange termijn zal voortduren.</p>
<h2 id="h2-Conclusie80167"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Samengevat heeft de NFT-markt een positieve groeitrend doorgemaakt in februari, gekenmerkt door een stijging van zowel de marktkapitalisatie als het handelsvolume. Het is echter belangrijk om de handelsvolumegegevens nauwkeurig te onderzoeken, aangezien verschillende factoren kunnen bijdragen aan de inflatie van daadwerkelijke handelsvolumes op de markt. Hoewel het percentage handelaren dat hun NFT’s vasthoudt is verbeterd, geven velen er nog steeds de voorkeur aan om te verkopen vanwege de marktonzekerheid.</p>
<p>Auteur: Korea University Blockchain Research Institute<br>Dit artikel vertegenwoordigt alleen de visie van de onderzoeker en vormt geen enkele beleggingssuggestie.<br>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 schending van het auteursrecht.</p>