U29nbm8gZGVnbGkgU2NhbW1lcjogWXVnYSBMYWJzIFN1YmlzY2UgdW5hIFJlYXppb25lIENvbnRyYXJpYSBpbiBDb25jb21pdGFuemEgY29uIGlsIExhbmNpbyBkZWxsZSBORlQgZGkgQml0Y29pbg==

2023-03-20, 00:39

<p><img src="https://gimg2.gateimg.com/image/article/1679272288热点追踪 封面.jpg" alt=""></p>
<h2 id="h2-TLDR862731"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>Parole chiave: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT, Yugo Labs NFT, truffa NFT, truffatori, asta NFT, collezione NFT, protocollo Ordinal, aggiornamento Taproot, NFT BTC</p>
<h2 id="h2-Introduzione561823"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli sviluppi che avvengono nel settore della blockchain non smettono di stupire molti appassionati di criptovalute e investitori. Ogni anno emergono nuove opportunità di investimento, la creazione di speciali token non fungibili sul <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain essendo l’ultima novità. Yuga Labs è diventata la prima piattaforma tecnologica non fungibile mainstream a lanciare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Purtroppo, Yuga Labs ha ricevuto molte critiche per la sua procedura d’asta quando ha venduto la sua collezione di 288 NFT. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFTs.</p>
<h2 id="h2-La20vendita20della20collezione20TwelveFold20suscita20critiche20nellindustria724370"><a name="La vendita della collezione TwelveFold suscita critiche nell’industria" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La vendita della collezione TwelveFold suscita critiche nell’industria</h2><p>Il 6 marzo il gigante della tecnologia blockchain, Yuga Labs, ha lanciato il suo popolare TwelveFold, un <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Asta di collezione di token non fungibili (NFT) basata sulla raccolta. Questa collezione di progetti d’arte generativa Yuga Labs esiste sul protocollo Ordinals, sviluppato da Casey Rodarmor. C’è stato molto interesse per questa vendita che si è chiusa alle 18:00 ET lo stesso giorno.</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> Ordinali - <a href="https://www.cryptotimes.io/wp-content/uploads/2023/03/Bitcoin_ordinals-1.jpg" rel="nofollow noopener noreferrer" target="_blank">Cryptotimes</a></p>
<p>In tutto, ci sono stati 288 offerenti di successo per questi NFT poiché Yuga Labs non ha messo in vendita gli altri 12 token. Secondo Yuga Labs, alcuni dei rimanenti NFT andranno ai suoi contributori mentre distribuirà casualmente il resto come parte dei suoi programmi filantropici.</p>
<p>Yuga Labs ha anche riferito che c’erano un totale di 3.246 offerenti che hanno raccolto 735,7 BTC per un valore di $16,5 milioni il giorno dell’asta. Secondo il rapporto, il miglior BTC NFT è stato venduto per 7,1159 BTC, equivalente a circa $159.600. Al contrario, l’offerta accettata più bassa è stata di 2,2501 BTC, equivalente a circa $50.400 il 6 marzo (data dell’asta NFT).</p>
<p>Tuttavia, è importante notare che Yuga Labs ha promesso di inviare il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT saranno consegnati ai migliori offerenti entro una settimana.</p>
<h2 id="h2-Cosa20ha20causato20le20critiche20dellindustria61088"><a name="Cosa ha causato le critiche dell’industria" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa ha causato le critiche dell’industria</h2><p>Nonostante il lancio e la vendita di successo del <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFT, c’è stata una diffusa condanna della procedura di asta. Innanzitutto, a tutti i partecipanti è stato richiesto di inviare i propri BTC al portafoglio di Yuga Labs e poi effettuare l’offerta. I vincitori delle offerte avrebbero pagato gli NFT utilizzando quella quantità. D’altra parte, Yuga Labs ha promesso di restituire i BTC alle persone che hanno perso le offerte.<br>C’è stato un clamore riguardo a questo processo di offerta. Alcuni critici hanno affermato che il processo di invio manuale dei BTC agli offerenti non riusciti richiederebbe molto tempo, il che violerebbe il loro diritto di utilizzo della <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> come desideravano in qualsiasi momento.</p>
<p>Leggi anche: <a href="https://www.gate.io/uk/blog_detail/2066" target="_blank">Come distinguere il vero e il falso NFT?</a></p>
<p>In secondo luogo, alcuni esperti hanno accusato Yuga Labs di creare un cattivo precedente nel settore chiedendo agli offerenti interessati di inviare la propria criptovaluta prima di vincere le offerte. Sebbene gli analisti non dubitino che Yuga Labs restituirà i BTC agli offerenti perdenti, ritengono che gli scammer utilizzeranno lo stesso modello d’asta per frodare gli utenti ignari. Questo è il motivo per cui un analista, con lo username di Twitter @veryordinally, ha definito il modello d’asta come il sogno degli scammer.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1679272710Yuga Labs 2.png" alt=""><br>Sogno dello scammer - <a href="https://twitter.com/veryordinally/status/1632568942374912001" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></p>
<p>Tuttavia, Yuga Labs aveva le sue ragioni per adottare questo modello d’asta. La ragione principale è che non esiste un’infrastruttura di supporto esistente per la vendita <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli NFT allo stesso modo di altri token non fungibili. Con altri NFT, le persone possono fare offerte su diversi <a href="https://www.gate.io/blog_detail/515/the-best-nft-marketplace-for-2022" target="_blank">Mercati NFT come OpenSea</a>. Tuttavia, ciò non è possibile con <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> NFT poiché il marketplace non supporta il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> al momento il settore blockchain, un fattore che ha spinto Yuga Labs a tenere l’asta a modo suo.</p>
<h2 id="h2-Comprensione20della202020Bitcoin2020NFTs917766"><a name="Comprensione della   Bitcoin  NFTs" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprensione della <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> NFTs</h2><p>Il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Gli NFT, anche chiamati Ordinali NFT, sono un tipo unico di token non fungibili, sviluppati sul protocollo Ordinal. In pratica, l’ordinale scrive i dati o l’iscrizione direttamente sul satoshi, l’unità più piccola di valuta. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a>. Questi BTC NFT sono opere d’arte generative che sono incorporate nel <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain in un modo unico.</p>
<p>Pertanto, con il TwelveFold NFT, Yuga Labs ha inciso i media su ogni singolo satoshi. Questi NFT combinano grafica 3D e caratteristiche disegnate a mano che creano opere d’arte uniche. A differenza degli altri NFT il cui dati sono memorizzati su strutture di archiviazione esterne come IPFS e <a href="/price/arweave-ar" rel="nofollow noopener noreferrer" target="_blank">Arweave</a>, tutto il contenuto correlato esiste direttamente sul <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>Grafica 3D - <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">Blendermarket</a><br>Come menzionato, ora è possibile generare dati direttamente sulla <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> seguendo l’introduzione del protocollo Ordinal, lanciato da Casey Rodarmor, un ingegnere software, nel gennaio 2023. D’altra parte, lo sviluppo del protocollo Ordinal sul <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La blockchain è stata resa possibile grazie all’aggiornamento di Taproot.</p>
<p>Già, gli NFT ordinali hanno portato a un aumento delle attività degli utenti sul <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> blockchain. Ad esempio, Glassnode riporta che gli Ordinals hanno portato ad un aumento in <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> indirizzi a un massimo storico di 44 milioni. Un’altra società di ricerca, Galaxy Research, prevede che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il mercato NFT varrà 4,5 miliardi di dollari nel 2025.</p>
<h2 id="h2-Cos20Yuga20Labs84596"><a name="Cos’è Yuga Labs?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Yuga Labs?</h2><p>Yuga Labs è una società di sviluppo di tecnologia blockchain che produce e commercializza token non fungibili (NFT) e altri asset digitali. Le persone lo conoscono per i suoi popolari asset digitali come il Bored Ape Yacht Club (BAYC), la collezione Mutant Ape Yacht Club (MAYC) e CryptoPunks.</p>
<h2 id="h2-Come20evitare20di20essere20truffati929991"><a name="Come evitare di essere truffati?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come evitare di essere truffati?</h2><p>Dato che abbiamo discusso di come il modello di asta NFT di Yuga Labs possa promuovere la truffa, esploriamo brevemente come evitare di essere truffati.</p>
<p>È importante <a href="https://www.gate.io/blog_detail/2148/how-to-avoid-nft-scam" target="_blank">ricerca approfonditamente su un progetto</a> prima di investire in essa. Ad esempio, leggi il suo whitepaper e interagisci con altri membri della comunità. Ad ogni costo, evita di rispondere a messaggi non richiesti o di aprire collegamenti ipertestuali da mittenti sconosciuti.</p>
<p>Dovresti anche utilizzare applicazioni da organizzazioni affidabili. Ad esempio, assicurati di utilizzare i siti web corretti per scaricare portafogli digitali come MetaMask ed Exodus. Inoltre, evita di prendere decisioni di investimento basate su annunci che trovi su piattaforme di social media che ti promettono rendimenti elevati.</p>
<h2 id="h2-Conclusione733891"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Anche se Yuga Labs ha tenuto con successo la sua asta della collezione TwelveFold il 6 marzo 2023, ha ricevuto molte critiche per la sua procedura. Alcuni critici hanno detto che chiedere agli offerenti di inviare BTC al suo portafoglio prima del processo di offerta stabilisce un cattivo precedente che <a href="https://www.gate.io/blog_detail/1342/what-are-the-most-common-types-of-nft-scams" target="_blank">potrebbe portare a truffe NFT</a>.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il re-post dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>