Q3J5cHRvUHVuayBORlQgU2FsZSBbRmFrZV06IEVlbiBGbGFzaC1sZW5pbmcgRmFjYWRlIFRlIE1pZGRlbiBWYW4gTkZULW1hcmt0IERhbGluZw==

2024-10-16, 02:51

<p><img src="https://gimg2.gateimg.com/image/article/17290465081692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR854357"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De aankoop van CryptoPunk 1563 op 1 oktober blijkt een marketingstunt te zijn geweest.</p>
<p>Een analist gelooft dat de verkoop van CryptoPunk 1563 voor 24.000 ETH was ter voorbereiding op de lancering van Kamala Harris Punk NFT.</p>
<p>Marktmanipulatie in de NFT-sector kan het vertrouwen en de trust van investeerders in de activa verminderen.</p>
<h2 id="h2-Introductie150656"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Hoewel niet-vervangbare tokens <a href="https://www.gate.io/learn/articles/breakthrough-of-nft-bringing-fungible-tokens-and-nfts-together/1997 &quot;(NFTs" rel="nofollow noopener noreferrer" target="_blank">(NFTs) zijn niet zo populair als cryptocurrencies</a> Hoewel NFT’s niet zo populair zijn als cryptocurrencies, kopen mensen ze vaak tegen hoge prijzen. Helaas zijn er momenten waarop verkopers hun toevlucht nemen tot marktmanipulatie om meer te profiteren. Bijvoorbeeld, soms kopen investeerders nep-NFT’s zonder waarde op de markt. In deze analyse richten we ons op een recent g van marktmanipulatie waarbij een zogenaamde investeerder een NFT kocht voor een whopping $53,6 miljoen.</p>
<h2 id="h2-Een20g20van20nepverkoop20CryptoPunk20NFT20verkocht20voor2053600807665"><a name="Een g van nepverkoop: CryptoPunk NFT verkocht voor $53.600" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een g van nepverkoop: CryptoPunk NFT verkocht voor $53.600</h2><p>De cryptosector is geschokt door de recente verkoop van CryptoPunk 1563 voor 24.000 ETH, met een waarde van ongeveer $56,3 miljoen op het moment van de transactie. Als gevolg van de onverwachte verkoopprijs hebben veel mensen de echtheid van de transactie in twijfel getrokken. Na een grondige blockchain-analyse hebben sommige analisten geconcludeerd dat de verkoop van de <a href="https://www.gate.io/learn/articles/what-is-crypto-punk-nft/4288" target="_blank">CryptoPunk non-fungible token (NFT)</a> was gewoon een marketing NFT-stunt. De NFT werd in feite op 3 oktober verkocht met behulp van een flash-lening.</p>
<p>On-chain data toont aan dat de koper een flash-lening heeft gebruikt van <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a> Protocol - een geautomatiseerde market maker (AMM) - om de NFT te kopen. Nadat de NFT verkooptransactie was voltooid, keerde de verkopersportemonnee de 24.000 ETH terug naar <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a>. In werkelijkheid blijkt dit dat de verkoop niet echt was. Het was gewoon een kwestie van de NFT die van het ene naar het andere portefeuilleadres verhuisde. De koper gebruikte slechts $54, wat de gasvergoeding was voor crypto-transacties op dat moment. Sinds <a href="https://www.gate.io/nft/collection/19626/Crypto---Punk" target="_blank">CryptoPunk 1563</a> werd in september gekocht voor $69,000, er is geen reden waarom de waarde ervan met 81,000% zou zijn gestegen binnen een paar weken. En alsof dat nog niet genoeg was, heeft de NFT geen zeldzame eigenschappen die zo’n hoge prijsstijging binnen een korte periode rechtvaardigen.<br><img src="https://gimg2.gateimg.com/image/article/17290466441.jpeg" alt=""><br>CryptoPunk 1563 Verkocht voor 24.000 ETH - x.com/Cryptopunksbot</p>
<p>24.000 ETH is het hoogste bedrag dat ooit is betaald voor een CryptoPunk NFT, zelfs tijdens de NFT-gekte in februari 2022. CryptoPunk 1563 was echter niet de eerste NFT die werd gekocht met behulp van flash-leningen. Zo gebruikte iemand in oktober 2021 een flash-lening om een andere CryptoPunk 9998 te verwerven, die destijds werd gewaardeerd op $532 miljoen. Veel mensen beschouwden die transactie echter als nep. Zelfs Larva Labs, de maker van CryptoPunk, zei dat het de verkoop niet zou bijhouden omdat deze illegitiem was.</p>
<p>Commentaar op de transactie, <a href="https://x.com/cryptopunksnfts/status/1453903818308083720" rel="nofollow noopener noreferrer" target="_blank">Larva Labs zei</a>, “Deze transactie (en een aantal andere) is geen bug of exploit, ze worden uitgevoerd met ‘Flash Loans’. Kort gezegd heeft iemand deze punk van zichzelf gekocht met geleend geld en de lening in dezelfde transactie terugbetaald.” Etherscan heeft echter die transactie geregistreerd, iets dat veel mensen in verwarring zou brengen.<br><img src="https://gimg2.gateimg.com/image/article/17290467032.jpeg" alt=""><br>Etherscan heeft de transactie van Punk 9998 bevestigd - x.com/Cryptopunksbot</p>
<h2 id="h2-Het20echte20motief20achter20de20CryptoPunk20156320NFTstunt20een20marketingstunt170634"><a name="Het echte motief achter de CryptoPunk 1563 NFT-stunt: een marketingstunt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het echte motief achter de CryptoPunk 1563 NFT-stunt: een marketingstunt</h2><p>Er is geen duidelijke reden gegeven voor de recente verkoop van CryptoPunk 1563 met behulp van een flash-lening. Verschillende analisten hebben echter gesuggereerd dat dit een marketingtruc zou kunnen zijn geweest. Sommigen beweren dat de NFT-stunt is uitgevoerd ter voorbereiding op een aankomende meme-munt genaamd Kamala Harris Punk. Daarom kan de verkoop van de NFT een middel zijn geweest om steun te zoeken voor de marketing van de meme-munt. Pseudonieme speurder 0XQuit heeft hierop gereageerd. <a href="https://x.com/0xQuit/status/1841945533453369807" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a> Deze keer lijkt het een poging te zijn om een Kamala Harris Punks mememunt te marketen. Contract B is in dit g een nieuw geïmplementeerde ERC20-token genaamd Kamala Harris Punk, dat een open voortverkoop heeft voor ~1 week.</p>
<p>Echter zei 0XQuit dat de betreffende NFT na een voorgesprek van één week aan de hoogste bieder zal worden verkocht. Het resultaat van de verkoop kan beide kanten op gaan - een winst of verlies.<br><img src="https://gimg2.gateimg.com/image/article/17290467893.jpeg" alt=""><br>De weg voorwaarts na de NFT-stunt - x.com/Quit</p>
<h2 id="h2-Analyseren20van20de20NFTmarkt2020Legitieme20NFTs20met20hoge20waarde340181"><a name="Analyseren van de NFT-markt - Legitieme NFT’s met hoge waarde" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analyseren van de NFT-markt - Legitieme NFT’s met hoge waarde</h2><p>Er zijn <a href="https://www.gate.io/learn/articles/what-are-the-main-nft-collections/934" target="_blank">Op dit moment zijn er veel NFT’s op de markt</a>. Echter hebben sommige van hen helemaal geen waarde meer. CryptoPunks behoren tot de zeer waardevolle en legitieme NFT’s op de markt. Bijvoorbeeld, CryptoPunk #2386, die werd aangeschaft voor 10 ETH, is nu ongeveer 600 ETH waard (ongeveer $1,5 miljoen). Echter, het werd lange tijd genegeerd en vergeten. In de laatste anderhalve maand zijn CryptoPunks met een totale waarde van $16,7 miljoen verkocht.</p>
<p>Liberty Cats, gehost op <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, zijn ook legitiem. Als gevolg hiervan hadden de Liberty Cats in de afgelopen drie maanden een handelsvolume van meer dan $157,86 miljoen. De NFT-collectie is nog steeds in trek na het opnemen van 3.010 transacties sinds de lancering tijdens Q3, 2024. The Bored Ape Yacht Club <a href="https://www.gate.io/learn/articles/what-is-bored-ape-yacht-club/143" target="_blank">(BAYC)</a>. Gedurende de afgelopen drie maanden zijn meer dan 10.000 profielfoto-NFT’s gemaakt op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Ze hadden een totaal NFT handelsvolume van 15.1K ETH. De BAYC-collectie wordt ook zeer gewaardeerd in de NFT-sector. Hun baanbrekende rol in profielfoto (PFP) NFT resulteerde in hun hoge vraag.</p>
<p>En inderdaad, <a href="https://www.gate.io/learn/articles/all-you-need-to-know-about-pudgy-penguins/1756" target="_blank">Pudgy Penguins, met 8.888 generatieve pinguïnavatars</a>, ontwikkeld door NFT studio Igloo op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, zijn ook een verzameling waardevolle NFT’s. Ze hadden in het afgelopen kwartaal een handelsvolume van 14.67K ETH.</p>
<p>Lees ook: <a href="https://www.gate.io/blog/1524/rarest-pudgy-penguin-fetches-400-eth" target="_blank">Zeldzaamste Pudgy Penguin haalt 400 ETH op</a></p>
<h2 id="h2-Risicos20en20gevolgen20van20manipulatie20op20de20NFTmarkt673103"><a name="Risico’s en gevolgen van manipulatie op de NFT-markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Risico’s en gevolgen van manipulatie op de NFT-markt</h2><p>Marktmanipulatie vindt plaats wanneer sommige investeerders misleidende middelen gebruiken om de waarden van activa op te blazen voordat ze ze verkopen. In sommige glen kunnen handelaren frauduleuze methoden gebruiken om de waarden van activa zoals NFT’s te laten dalen voordat ze deze verwerven. Er zijn verschillende tactieken die frauduleuze handelaren kunnen gebruiken, zoals spoofing, front running, wash trading, insider trading en pump &amp; dump-schema’s. Een populaire manier om de markt te manipuleren is door betaalde beroemdheden te gebruiken om een NFT te promoten. Zodra de waarde van de NFT tot een bepaald niveau is gestegen, neemt de handelaar alle winst en dumpen ze het activum.</p>
<p>Ongetwijfeld heeft marktmanipulatie een negatieve invloed op de NFT-markt. Het kan de legitimiteit van NFT’s aanzienlijk beïnvloeden. Sommige van de NFT’s waarvan de prijs mogelijk is gemanipuleerd, kunnen voorgoed waarde verliezen. Bovendien kunnen prijsschommelingen die gepaard gaan met marktmanipulatie sommige investeerders ontmoedigen om te investeren in NFT’s en andere digitale activa. In het algemeen kan marktmanipulatie in de digitale sector leiden tot verlies van vertrouwen en vertrouwen van investeerders in virtuele activa.</p>
<p>Lees ook: <a href="https://www.gate.io/web3/nft" target="_blank">Ontdek de volgende grootste NFT’s in Web3</a></p>
<h2 id="h2-De20huidige20stand20van20de20NFTmarkt81905"><a name="De huidige stand van de NFT-markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De huidige stand van de NFT-markt</h2><p>Voor het grootste deel van 2024 is de NFT-markt in een achtbaanrit geweest, tot het vierde kwartaal waar er tekenen zijn van marktherstel. Het handelsvolume van NFT’s van kwartaal tot kwartaal daalde met ongeveer 50% tijdens Q3 tot $1,1 miljard. In feite begon het jaar met het totale handelsvolume van de NFT-markt van $4,1 miljard. Van daaruit daalde het naar $2,25 miljard in Q2 voordat het verder gleed naar het huidige niveau. Echter, de nieuwste gegevens van <a href="https://www.cryptoslam.io/nftglobal?timeFrame=year&amp;headerPeriod=7d" rel="nofollow noopener noreferrer" target="_blank">CryptoSlam</a> laat zien dat de daling van de NFT-markt doorgaat. Zo bedroegen de totale NFT-verkopen in de afgelopen 30 dagen ongeveer $333 miljoen. De volgende grafiek geeft een overzicht van de belangrijkste handelstrends.<br><img src="https://gimg2.gateimg.com/image/article/17290470184.jpeg" alt=""><br>NFT Jaarlijkse Verkopen - CryptoSlam</p>
<p>Als <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">de grafiek</a> toont aan dat er het afgelopen jaar een toename was in unieke kopers. Er is echter een afname geweest in totale verkoop en unieke verkopers. Al met al heeft de NFT-markt veerkracht getoond in het licht van verschillende uitdagingen, waaronder de huidige mondiale economische omstandigheden en woedende oorlogen in Oekraïne en het Midden-Oosten.</p>
<h2 id="h2-De20toekomst20van20NFTs20en20blockchaintransparantie851983"><a name="De toekomst van NFT’s en blockchaintransparantie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De toekomst van NFT’s en blockchaintransparantie</h2><p>De toekomst van NFT’s is verstrikt in onzekerheden als gevolg van verschillende factoren, waaronder veranderingen in regelgeving. Op dit moment is de oorspronkelijke hype rond NFT’s verdwenen en blijven alleen NFT-enthousiastelingen gefocust. Naast de economische uitdagingen waarmee de meeste landen worden geconfronteerd, heeft de toename van oplichting en andere illegale activiteiten geleid tot het niveau van <a href="https://www.gate.io/blog/1250/nfts-market-value-reduces-by-over-90-after-crypto-crash" target="_blank">interesse in NFT’s daalt</a>. In de Verenigde Staten neemt de SEC stappen om de NFT-sector te reguleren, aangezien het heeft verklaard dat NFT’s effecten zijn.</p>
<p>Gerelateerd artikel: <a href="https://www.gate.io/blog/1275/why-many-crypto-assets-are-falling" target="_blank">Waarom vallen veel crypto-activa</a></p>
<p>Ondanks de huidige staat van de NFT-markt kunnen nieuwe ontwikkelingen ze opnieuw positioneren voor groei. Een voorbeeld is de opkomst van nieuwe toepassingen die duurzame interesse in de tokens kunnen aanwakkeren. NFT’s kunnen een rol spelen in verschillende sectoren van de economie, waaronder onderwijs, onroerend goed en gaming. Wat waarschijnlijk ook de adoptie van NFT’s zal vergroten, is interoperabiliteit. Met andere woorden, de NFT’s die bruikbaar zijn op verschillende platforms zullen meer nut hebben dan die welke op een platform gebaseerd zijn.</p>
<p>Het vergroten van de transparantie van blockchain kan ook helpen bij het creëren van vertrouwen in de NFT-markt. Bijvoorbeeld, de blockchain-protocollen die te maken hebben met NFT’s moeten ervoor zorgen dat er geen ruimte is voor valse activa. Ze moeten er ook voor zorgen dat er geen frauduleuze activiteiten zijn op hun platforms. Een ander essentieel aspect dat de adoptie van NFT kan bevorderen, is eerlijke compensatie voor de makers. Als voorbeeld moet er een duidelijke manier zijn … <a href="https://www.gate.io/learn/articles/how-nft-royalties-work-designs-challenges-and-new-ideas/3624" target="_blank">van het bijhouden van royalty’s voor NFT’s</a>.</p>
<h2 id="h2-Conclusie280860"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Op 1 oktober gebruikte een NFT-investeerder een flash-lening om CryptoPunk 1563 te kopen voor 24.000 ETH. De hoge aankoopprijs zorgde echter voor twijfel binnen de NFT-gemeenschap, aangezien de token in september gewaardeerd werd op $69.000. Uiteindelijk werd vastgesteld dat de verkoop niet legitiem was. Ondertussen is er sinds het begin van 2024 een sterke daling geweest in de waarde van NFT’s. Een manier waarop de interesse in NFT’s kan worden hersteld, is de introductie van nieuwe gebruiksmogelijkheden.</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 visie van de onderzoeker en vormt geen enkele beleggingssuggestie. Alle beleggingen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het herpubliceren van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>