R3Jvb3RzdGUgTkZULWR1bXAgaW4gZGUgZ2VzY2hpZWRlbmlzIHZhbiBORlQncw==

2023-03-20, 00:04
<p><img src="https://gimg2.gateimg.com/image/article/1679269908深度分析 封面.jpeg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen305087"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Jeffrey Huang werd populair toen hij 1.010 NFT’s verkocht binnen 48 uur en daarna 191 NFT’s kocht.</p>
<p>De belangrijkste reden voor Huang om een groot volume van NFT’s te verhandelen was om een groot individueel aandeel van de BLUR-tokens te krijgen.</p>
<p>The Merge, de eerste 5.000 dagen, The Clock NFT, HUMANE ONE en verschillende cryptopunks zijn de duurste NFT’s.</p>
<p>Naast de Blur NFT-marktplaats kunt u ook NFT kopen bij Gate.io’s Magic Box.</p>
<h2 id="h2-Inleiding104123"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Ondanks de huidige depressieve cryptomarkt zijn er veel activiteiten op de NFT-markt, wat aantoont hoe populair niet-fungibele tokens zijn. Beroemdheden behoren tot de topinvesteerders in de virtuele wereldsector. Dit artikel zal behandelen hoe Jeffrey Huang, een wereldberoemde muzikant, 1.010 NFT’s verkocht in 48 uur. We zullen ook bespreken… <a href="https://www.gate.io/learn/articles/top-10-most-expensive-nfts-ever-sold/285" target="_blank">enkele van de grootste NFT-verkopen aller tijden</a>.</p>
<h2 id="h2-Belangrijke20verkoop20gevolgd20door20een20snelle20terugkoop12512"><a name="Belangrijke verkoop gevolgd door een snelle terugkoop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijke verkoop gevolgd door een snelle terugkoop</h2><p>Nansen, een blockchain-onderzoeksbureau, meldt dat Jeffrey Huang, ook bekend als Machi Big Brother, 1.010 NFT’s heeft verkocht voor een totaal van 11.680 ETH ter waarde van $18,6 miljoen op de datum van de verkoop. De lijst van de door hem verkochte NFT’s omvat 90 <a href="https://www.gate.io/learn/articles/what-is-bored-ape-yacht-club/143" target="_blank">Bored Ape Yacht Club (BAYC)</a> NFT’s, 191 Mutant Ape Yacht Club (MAYC) NFT’s en 308 <a href="https://www.gate.io/blog_detail/2159/otherside-nft-explained" target="_blank">Andere eigendomsbewijzen NFTs</a>.</p>
<p>Het interessante is dat Machi Big Brother later 191 NFT’s heeft gekocht, een stap die volgens sommige analisten zoals Andrew Thurman een vorm van marktmanipulatie zou kunnen zijn of een manier om een grote airdrop te krijgen. <a href="https://www.gate.io/uk/blog_detail/2168/tides-shift-in-nft-market-blur-token-activity-rises-on-gate.io" target="_blank">van Blur marktplaats</a>, de nummer 1 NFT-marktplaats.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679270422Jeffrey hwang1.png" alt=""><br>Machi Big Brother (Jeffrey Huang) - <a href="https://assets.pandaily.com/uploads/2022/08/Untitled-design-3-11-1536x799.jpg" rel="nofollow noopener noreferrer" target="_blank">Pandaily</a></p>
<p>Het is niet verrassend dat Machi Big Brother’s NFT-dump en de daaropvolgende aankoop van andere NFT’s bedoeld waren om zijn betrokkenheid op de Blur NFT-marktplaats te vergroten. Dit komt omdat het aandeel van de airdrop dat een NFT-handelaar krijgt, wordt bepaald door zijn/haar niveau van deelname op de Blur-marktplaats. In februari kondigde Blur Marketplace een nieuwe ronde van airdrop aan die binnenkort wordt verwacht.</p>
<p>Opmerkelijk genoeg kreeg Machi Big Brother de grootste individuele deel van de gedistribueerde BLUR-token tijdens de recente Blur airdrop. Sterker nog, Arkham Intel, een blockchain-analysebedrijf, meldt dat Machi Big Brother 1,8 miljoen BLUR-tokens ontving die hij inwisselde voor $1,3 miljoen.</p>
<p>Lees ook over <a href="https://www.gate.io/learn/articles/the-trend-of-nft-marketplaces/379" target="_blank">de trend van NFT-marktplaatsen</a></p>
<h2 id="h2-Wie20is20Machi20Grote20Broer931696"><a name="Wie is Machi Grote Broer?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie is Machi Grote Broer?</h2><p>Machi Big Brother wiens echte naam Jeff Huang is, is een bekende Taiwanese muzikant en technologie-ondernemer. Hij was lid van het muzikale trio L.A. Boyz tussen 1991 en 1997. Later richtte hij zijn eigen hiphopmuziekgroep op genaamd Machi in 2003. Met zoveel ervaring en passie voor muziek, richtten Huang en zijn partners een muziekopnamebedrijf op genaamd MACHI Entertainment.</p>
<p>In 2017 werd Huang populair in de blockchainsector toen hij Mithril oprichtte, een gedecentraliseerd sociaal mediaplatform dat contentmakers beloont voor hun bijdrage. Machi Big Brother begon in 2021 zwaar te investeren in NFT’s toen hij een van de best gerangschikte NFT-walvissen werd. In feite is hij geïnteresseerd geweest in Bored Ape Yacht Club (BAYC) NFT’s.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2250" target="_blank">Wat zijn cryptowalvissen en waarom zijn ze belangrijk</a></p>
<h2 id="h2-Welke20relatie20heeft20Machi20Big20Brother20met20BAYC744581"><a name="Welke relatie heeft Machi Big Brother met BAYC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke relatie heeft Machi Big Brother met BAYC?</h2><p>Volgens de gegevens van cryptoslam.io is Machi Big Brother de beste BAYC NFT-handelaar aller tijden. Hij lijkt veel winst te hebben behaald door deze NFT’s te verhandelen sinds 2021. Als voorbeeld verdiende Machi Big Brother in 2021 $ 5,85 miljoen door de handel in 34 Bored Apes NFT’s. Op dezelfde manier heeft hij meer dan 1.300 Otherside NFT’s verhandeld, waarbij hij in enkele maanden meer dan $ 1,4 miljoen aan verkopen heeft gegenereerd. Over het algemeen heeft hij echter <a href="https://opensea.io/MachiBigBrother/activity" rel="nofollow noopener noreferrer" target="_blank">handel</a> activiteiten bestaan uit inkomende en uitgaande transacties, iets wat al lange tijd aan de gang is.</p>
<h2 id="h2-Andere20grootste20NFTverkopen20in20de20geschiedenis556575"><a name="Andere grootste NFT-verkopen in de geschiedenis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere grootste NFT-verkopen in de geschiedenis</h2><p>Sinds 2021 zijn er verschillende dure NFT’s op de markt gekomen. Enkele van de bekende NFT-verkopen zijn Everydays: The Merge, The First 5000 Days, Clock, HUMAN ONE, TPunk #3442 en verschillende cryptopunks.</p>
<h2 id="h2-De20fusie509064"><a name="De fusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De fusie</h2><p>The Merge is de duurste NFT-verkoop in de hele geschiedenis van niet-vervangbare tokens geweest. Gemaakt door Pak, de digitale kunstenaar, werd de Merge verkocht voor $91,8 miljoen in december 2021. In totaal grepen 28.983 individuen 312.000 aandelen van de Merge, waardoor Pak de duurste levende kunstenaar werd.</p>
<h2 id="h2-Everyday20De20eerste20500020dagen904850"><a name="Everyday: De eerste 5.000 dagen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Everyday: De eerste 5.000 dagen</h2><p>“Everyday”, gemaakt door Mike “Beeple” Winkelmann, is de op één na duurste NFT omdat het in maart 2021 $69,3 miljoen opleverde. Vignesh Sundaresan, ook bekend als MetaKovan, de oprichter van het Metapurse NFT-project, kocht ‘The First 5000 Days’ (Everyday) op de veiling van Christie’s.</p>
<h2 id="h2-De20Klok20NFT100232"><a name="De Klok NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Klok NFT</h2><p>De anonieme kunstenaar Pak en Julian Assange, de maker van WikiLeaks, werkten samen om de “Gecensureerde NFT-collectie” te creëren, die de Clock NFT bevat. De Clock NFT, verkocht voor $52,7 miljoen, is een dynamische NFT die het aantal dagen laat zien dat Assange in de gevangenis heeft doorgebracht.</p>
<p>De AssangeDAO kocht de Clock NFT in februari 2022 als een fondsenwervingsactiviteit voor de verdediging van Assange tegen zijn uitlevering aan de Verenigde Staten.</p>
<p>Neem een kijkje <a href="https://www.gate.io/price/view/nft" target="_blank">Top NFT-munten &amp; -tokens op basis van marktkapitalisatie</a></p>
<h3 id="h3-HUMANE20EEN908666"><a name="HUMANE EEN" class="reference-link"></a><span class="header-link octicon octicon-link"></span>HUMANE EEN</h3><p>HUMANE ONE, het kunstwerk van Beeple met een astronaut die permanent door veranderende landschappen wandelt, werd verkocht voor $28,9 miljoen in november 2021. Deze NFT is bijzonder omdat er een smart contract in is gecodeerd waarmee Beeple het op afstand kan besturen om te controleren wat erin wordt weergegeven.</p>
<h3 id="h3-Larva20Labs20cryptopunks468619"><a name="Larva Labs’ cryptopunks" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Larva Labs’ cryptopunks</h3><p>Verschillende crypto-punks van Larva Labs zijn enkele bekende NFT-verkopen waar je aan kunt denken. Deze omvatten CryptoPunk #5822, verkocht voor $23,7 miljoen aan ETH, CryptoPunk #5822, verkocht voor $23,7 miljoen, CryptoPunk #7523 ($11,8 miljoen), CryptoPunk #4156 ($10,26 miljoen), CryptoPunk #5577 ($7,7 miljoen), CryptoPunk #7804 ($7,56 miljoen) en CryptoPunk #3100 ($7,51 miljoen).</p>
<h2 id="h2-Hoe20goede20NFTs20te20kopen20op20Gateio784525"><a name="Hoe goede NFT’s te kopen op Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe goede NFT’s te kopen op Gate.io</h2><p>In de Gate.io NFT-marktplaats genaamd <a href="https://www.gate.io/nft" target="_blank">Magische Doos</a> je kunt verschillende niet-vervangbare tokens kopen via het vaste prijs- of veilsysteem. Magic Box is in feite geïntegreerd met primaire NFT-marktplaatsen zoals OpenSea, Sorare en Rarible.</p>
<p>De eerste stap wanneer u NFT’s wilt kopen, is het aanmaken van uw account bij Gate.io en het laten verifiëren. Zodra uw account geverifieerd is, moet u uw portemonnee van geld voorzien. Vervolgens bezoekt u <a href="https://www.gate.io/nft" target="_blank">de marktplaats</a> en verken de verschillende NFT’s die daar worden weergegeven.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679270540Jeffrey hwang2.png" alt=""><br>NFT’s op Gate.io NFT Marketplace- Gate.io</p>
<p>Zodra u de NFT heeft geïdentificeerd die u wilt kopen, klikt u erop om een nieuw venster te openen en klikt u vervolgens op ‘Bestelling verzamelen’, zoals hieronder aangegeven.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679270595Jeffrey hwang3.png" alt=""></p>
<p>Zodra u op ‘Bestelling verzamelen’ klikt, wordt er een nieuw venster geopend waarin u ruimte krijgt om uw bod te plaatsen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679270612Jeffrey hwang4.png" alt=""></p>
<p>Daarom voert u het aanbod in door het bedrag aan te geven dat u bereid bent te betalen voor de NFT. Zodra u dat doet, wacht u tot de veilingperiode eindigt.</p>
<h2 id="h2-Conclusie858338"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Kortom, Jeffrey Huang verraste de cryptogemeenschap toen hij binnen 48 uur 1.010 NFT’s verkocht. Verrassend genoeg kocht hij kort na de verkoop nog eens 191 NFT’s. Analisten geloven dat Huang’s motief hiervoor was om zijn betrokkenheid bij de Blur NFT-marktplaats te vergroten om een ​​goed aandeel van de airdrop te krijgen. Hoewel Huang <a href="https://www.gate.io/learn/articles/how-to-trade-nft/48" target="_blank">heeft de NFT verhandeld</a> op de Blur NFT-marktplaats kun je ze ook kopen bij Gate.io crypto exchange.</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 opvattingen van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards