U2NhbW1lcnMgRHJlYW06IFl1Z2EgTGFicyBTZWVzIEJhY2tsYXNoIEFtaWQgTGF1bmNoIG9mIEJpdGNvaW4gTkZUcw==

2023-03-20, 00:39

<p><img src="https://gimg2.gateimg.com/image/article/1679272288热点追踪 封面.jpg" alt=""></p>
<h2 id="h2-TLDR769085"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Trefwoorden: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT’s, Yugo Labs NFT, NFT-scam, oplichters, NFT-veiling, NFT-collectie, Ordinal protocol, Taproot-update, BTC NFT’s</p>
<h2 id="h2-Inleiding783041"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>De ontwikkelingen die plaatsvinden in de blockchainsector blijven veel cryptofans en investeerders verbazen. Elk jaar ontstaan er nieuwe investeringsmogelijkheden, de creatie van speciale niet-vervangbare tokens op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain is de nieuwste ontwikkeling. Yuga Labs werd het eerste mainstream non-fungible technologieplatform dat gelanceerd werd. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT’s. Helaas ontving Yuga Labs veel kritiek op zijn veilingprocedure toen het zijn collectie van 288 verkocht. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT’s.</p>
<h2 id="h2-Verkoop20van20TwelveFold20Collection20veroorzaakt20kritiek20in20de20industrie933632"><a name="Verkoop van TwelveFold Collection veroorzaakt kritiek in de industrie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verkoop van TwelveFold Collection veroorzaakt kritiek in de industrie</h2><p>Op 6 maart lanceerde de blockchain tech gigant, Yuga Labs, zijn populaire TwelveFold, een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>-gebaseerde veiling van niet-vervangbare tokens (NFT’s). Deze Yuga Labs-collectie van generatieve kunstprojecten bestaat op het Ordinals-protocol, ontwikkeld door Casey Rodarmor. Er was veel belangstelling voor deze verkoop, die op dezelfde dag om 18.00 uur ET eindigde.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679272676Yuga Labs 1.png" alt=""><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Ordinals - <a href="https://www.cryptotimes.io/wp-content/uploads/2023/03/Bitcoin_ordinals-1.jpg" rel="nofollow noopener noreferrer" target="_blank">Cryptotijden</a></p>
<p>In totaal waren er 288 succesvolle bieders voor deze NFT’s, omdat Yuga Labs de andere 12 tokens niet te koop heeft gezet. Volgens Yuga Labs zullen sommige van de overgebleven NFT’s naar zijn bijdragers gaan, terwijl de rest willekeurig zal worden verdeeld als onderdeel van zijn filantropische programma’s.</p>
<p>Yuga Labs meldde ook dat er in totaal 3.246 bieders waren die op de dag van de veiling 735,7 BTC ter waarde van $16,5 miljoen ophaalden. Volgens het rapport werd de beste BTC NFT verkocht voor 7,1159 BTC, ter waarde van ongeveer $159.600. Daarentegen was het laagst geaccepteerde bod voor 2,2501 BTC, wat neerkomt op ongeveer $50.400 op 6 maart (NFT veilingdatum).</p>
<p>Toch is het belangrijk om op te merken dat Yuga Labs beloofde om de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT’s aan de succesvolle bieders binnen een week.</p>
<h2 id="h2-Wat20heeft20kritiek20in20de20industrie20veroorzaakt430804"><a name="Wat heeft kritiek in de industrie veroorzaakt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat heeft kritiek in de industrie veroorzaakt</h2><p>Ondanks de succesvolle lancering en verkoop van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Bij de verkoop van NFT’s was er brede veroordeling van de veilingprocedure. Allereerst moesten alle bieders hun BTC naar de portemonnee van Yuga Labs sturen en vervolgens bieden. De winnaars van de biedingen zouden de NFT’s betalen met dat bedrag. Aan de andere kant beloofde Yuga Labs de BTC terug te geven aan de personen die de biedingen verloren.<br>Er was veel ophef over dit biedproces. Sommige critici zeiden dat het proces om de BTC handmatig terug te sturen naar onsuccesvolle bieders erg lang zou duren, wat hun recht om de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zoals ze op elk moment wensten.</p>
<p>Lees ook: <a href="https://www.gate.io/uk/blog_detail/2066" target="_blank">Hoe onderscheid je ware en valse NFT?</a></p>
<p>Ten tweede hebben sommige experts Yuga Labs ervan beschuldigd een slecht branchevoorbeeld te stellen door geïnteresseerde bieders te vragen hun cryptocurrency te sturen voordat ze de biedingen winnen. Hoewel de analisten niet betwijfelen dat Yuga Labs de BTC naar de verliezende bieders zal terugsturen, geloven ze dat oplichters hetzelfde veilingmodel zullen gebruiken om argeloze gebruikers op te lichten. Daarom noemde een analist, met de Twitter-gebruikersnaam @veryordinally, het veilingmodel een droom van oplichters.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679272710Yuga Labs 2.png" alt=""><br>Droom van oplichters - <a href="https://twitter.com/veryordinally/status/1632568942374912001" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></p>
<p>Niettemin had Yuga Labs zijn redenen om dit veilingmodel te adopteren. De belangrijkste reden is dat er geen bestaande ondersteunende infrastructuur is voor de verkoop <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT’s op dezelfde manier als andere dergelijke niet-vervangbare tokens. Met andere NFT’s kunnen mensen hun biedingen plaatsen op verschillende <a href="https://www.gate.io/blog_detail/515/the-best-nft-marketplace-for-2022" target="_blank">NFT-marktplaatsen zoals OpenSea</a>. Echter, dat is niet mogelijk met <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> NFT’s omdat de marktplaats dit niet ondersteunt <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain op dit moment, een factor die Yuga Labs heeft aangezet om de veiling op zijn eigen manier te houden.</p>
<h2 id="h2-Het20begrijpen20van20de202020Bitcoin2020NFTs565512"><a name="Het begrijpen van de   Bitcoin  NFTs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het begrijpen van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFTs</h2><p>De <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT’s, ook wel NFT-ordinaals genoemd, zijn een uniek type niet-vervangbare tokens, ontwikkeld op het Ordinal-protocol. In feite schrijft het ordinaal de gegevens of inie rechtstreeks op de satoshi, de kleinste eenheid van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>. Deze BTC NFT’s zijn generatieve kunstwerken die zijn ingebed op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain op een unieke manier.</p>
<p>Als zodanig heeft Yuga Labs met de TwelveFold NFT media ingeschreven op elke afzonderlijke satoshi. Deze NFT’s combineren 3D-graphics en met de hand geschreven kenmerken die unieke kunstwerken creëren. In tegenstelling tot de andere NFT’s waarvan de gegevens worden opgeslagen in externe opslagfaciliteiten zoals IPFS en <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a>, alle gerelateerde inhoud bestaat direct op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679272735Yuga Labs 3.png" alt=""><br>3D graphics - <a href="https://d1231c29xbpffx.cloudfront.net/store/product/172643/image/89fecb54ebfe2d54c21f89512b2a84f1.png?Expires=1678641882&amp;Signature=atiCafCTAgtQ4m16ogoOg5jVQhrlHNZ~ui5aIJz8eHliw03R~Af6B24ZwTLXCT0KuSkofMy-8ku3ab2rShws21P0ggd3w47huqHWt5f7DSXKwmpeIO8SQZZI~ZzGxA7yj13zegh2HyH9IsfSbRhhFnY-G3UurnIsD2JVN~CoUwxdydX7cPaUFbIbVuMWXU-SbBVM79V8RPKbzcyQnTrsC0rR4DljCllF0PTAm1xBjIqE2FYY1ZqCpXKM3VgNlClMjUROPe7YXw~~z0ox-iuW1E4F7Cpc5JHlVkuY9ktG4lBQ6X0mrO6zoajYG27BHoxvDwrvwbARjfz9CK4cRq-mVQ__&amp;Key-Pair-Id=APKAIN6COYBF3ZQW7OQQ" rel="nofollow noopener noreferrer" target="_blank">Blendermarkt</a><br>Zoals vermeld is het nu mogelijk om gegevens rechtstreeks te genereren op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain volgend op de introductie van het Ordinal protocol, gelanceerd door Casey Rodarmor, een software engineer, in januari 2023. Aan de andere kant, de ontwikkeling van het Ordinal protocol op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain was mogelijk als gevolg van de Taproot-upgrade.</p>
<p>Al, de Ordinal NFT’s hebben geleid tot meer gebruikersactiviteiten op de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain. Bijvoorbeeld meldt Glassnode dat de Ordinals hebben geleid tot een toename in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> adressen naar een all-time-high van 44 miljoen. Een ander onderzoeksbureau, Galaxy Research, voorspelt dat het <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De NFT-markt zal in 2025 $4,5 miljard waard zijn.</p>
<h2 id="h2-Wat20is20Yuga20Labs309516"><a name="Wat is Yuga Labs?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Yuga Labs?</h2><p>Yuga Labs is een bedrijf dat blockchain-technologie ontwikkelt en niet-vervangbare tokens (NFT’s) en andere digitale activa produceert en op de markt brengt. Mensen kennen het van populaire digitale activa zoals de Bored Ape Yacht Club (BAYC), de Mutant Ape Yacht Club (MAYC) collectie en CryptoPunks.</p>
<h2 id="h2-Hoe20oplichting20te20vermijden358867"><a name="Hoe oplichting te vermijden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe oplichting te vermijden?</h2><p>Aangezien we hebben besproken hoe het NFT-veilingmodel van Yuga Labs oplichting kan bevorderen, laten we kort verkennen hoe we oplichting kunnen vermijden.</p>
<p>Het is belangrijk om <a href="https://www.gate.io/blog_detail/2148/how-to-avoid-nft-scam" target="_blank">grondig onderzoek doen naar een project</a> Voordat je erin investeert. Lees bijvoorbeeld de whitepaper en ga in gesprek met andere communityleden. Vermijd koste wat het kost om te reageren op ongevraagde berichten of hyperlinks te openen van onbekende afzenders.</p>
<p>U moet ook applicaties gebruiken van gerenommeerde organisaties. Zorg er bijvoorbeeld voor dat u de juiste websites gebruikt om digitale portefeuilles zoals MetaMask en Exodus te downloaden. Vermijd ook het nemen van investeringsbeslissingen op basis van advertenties die u op sociale mediaplatforms vindt en u beloven grote rendementen.</p>
<h2 id="h2-Conclusie162705"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Hoewel Yuga Labs met succes zijn TwelveFold-collectieveiling hield op 6 maart 2023, kreeg het veel kritiek op zijn procedure. Sommige critici zeiden dat het vragen van bieders om BTC naar zijn portemonnee te sturen vóór het biedproces een slecht precedent schept dat <a href="https://www.gate.io/blog_detail/1342/what-are-the-most-common-types-of-nft-scams" target="_blank">kan leiden tot NFT oplichting</a>.</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 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 mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>