QXR0ZW56aW9uZSBhbGxlIHRydWZmZSBORlQgLSBDb21lIGRpc3Rpbmd1ZXJlIGlsIHZlcm8gTkZUIGRhbCBmYWxzbz8=

2023-01-19, 08:21

<p><img src="https://gimg2.gateimg.com/blog/165042832718348369crypto101_web.jpg" alt=""></p>
<p><strong>[TL; DR]</strong><br>🔹 Le vendite totali di NFT nel 2022 hanno raggiunto i 55,5 miliardi di dollari, con un aumento del 175% rispetto ai 20,2 miliardi di dollari del 2021.</p>
<p>🔹 Fai attenzione ai truffatori che copiano le opere d’arte NFT e poi iniziano a venderle dopo il conio, affermando falsamente di essere vendute ufficialmente.</p>
<p>🔹 Ci sono 7 modi per dire la verità sugli NFT per tenerti lontano dalle truffe sugli NFT.</p>
<h2 id="h2-Introduzione583114"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Secondo statistiche incomplete, nel corso dell’intero anno 2022 si sono verificati 44 incidenti di sicurezza nell’ambito degli NFT, con perdite che superano i 42,56 milioni di dollari. Nel 2022, le vendite totali di NFT hanno raggiunto i 55,5 miliardi di dollari, di cui il 46% è derivato dal wash trading.</p>
<p>Gli NFT sono sempre stati una tendenza popolare nelle transazioni di cripto-attività. Come possiamo identificare gli NFT falsi nell’attuale era delle frodi?</p>
<h2 id="h2-Sono20comuni20le20truffe20NFT90478"><a name="Sono comuni le truffe NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sono comuni le truffe NFT?</h2><p>Il 2022 è stato un anno turbolento per le criptovalute. Il mercato rialzista delle criptovalute è terminato dopo diversi eventi importanti. Tale impatto di mercato influisce anche sul NFT. Nel 2022 le vendite e il numero totale di utenti NFT sono diminuiti. Tuttavia, le vendite totali di NFT nel 2022 hanno raggiunto i 55,5 miliardi di dollari, in aumento del 175% rispetto ai 20,2 miliardi di dollari del 2021.<br><img src="https://gimg2.gateimg.com/image/article/1674115864111.png" alt=""></p>
<p>La fonte di dati delle vendite NFT e degli utenti totali nel 2022: Footprint Analytics</p>
<p>Pertanto, anche nel contesto del mercato ribassista, gli investitori hanno ancora un forte interesse per il mercato NFT. Nel 2021 le collezioni NFT sono state circa 145.000, ma alla fine del 2022 i dati rilevanti erano aumentati notevolmente. Ogni giorno nascono nuove collezioni e progetti in NFT, che creano molte opportunità di investimento. Tuttavia, le opportunità e la domanda del mercato vanno di pari passo, così come le frodi.</p>
<p><a href="https://www.gate.io/blog_detail/544/NFTs--a-new-window-of-opportunity-for-digital-scammers--learn-How-to-Avoid-NFT-Scams" target="_blank">Gli scam NFT sono diffusi</a>, che vanno da centinaia di migliaia di dollari a milioni di dollari. Ad esempio, la recente copia di Mutant Ape Yacht Club (MAYC) e lo sviluppatore NFT Aurelien Michel della serie Mutant Ape Planet sono stati arrestati e accusati di frode per presunta frode di 2,9 milioni di dollari.</p>
<p>Nel febbraio 2022, OpenSea nel mercato NFT è stato soggetto <a href="https://www.gate.io/ru/blog_detail/770/the-implications-of-opensea-phishing-scam?lang=en" target="_blank">per frode di phishing contro gli utenti</a>, e NFT per un valore di oltre 2,7 milioni di dollari sono trapelati illegalmente. I suoi truffatori hanno inviato e-mail false camuffate da OpenSea per indurre gli utenti a rintracciare <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> dannosi e spingerli a firmare contratti fraudolenti.</p>
<p>Attualmente, NFT “Bored Ape Yacht Club (BAYC)”, che è relativamente in tendenza e ha un alto prezzo di transazione, ha anche la possibilità di subire frodi di phishing. Il CEO dello sviluppatore del progetto, Yuga Labs, ha dichiarato di aver ricevuto un messaggio che qualcuno stava <a href="https://www.gate.io/blog_detail/1032/The-Official-Bored-Ape-Yacht-Club-Instagram-account-hacked-with-over--13.7-Million-worth-of-BAYC-NFTs-stolen" target="_blank">Cercando di attaccare</a> il loro progetto.</p>
<p>Ci <a href="https://www.gate.io/blog_detail/1342/What-are-the-most-common-types-of-NFT-scams" target="_blank">sono innumerevoli truffe NFT</a> di dimensioni simili e l’importo è illimitato. Anche la collezione NFT delle celebrità è stata rivelata essere stata rubata. Ad esempio, Jay Chou, un famoso cantante, ha dichiarato in un articolo del 1° aprile che il suo numero 3738, l’NFT Bored Ape, è stato rubato tramite phishing, per un valore di 330.000$.<br><img src="https://gimg2.gateimg.com/image/article/1674115934222.png" alt=""></p>
<p>Bored Ape Yacht Club NFTs. Fonte: opensea</p>
<h2 id="h2-Qual2020la20differenza20tra20token20non20fungibili20e20immagini20non20fungibili97334"><a name="Qual è la differenza tra token non fungibili e immagini non fungibili?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la differenza tra token non fungibili e immagini non fungibili?</h2><p>NFT sta per token non fungibile. La sua essenza risiede nel certificato patrimoniale digitale unico e affidabile nella rete blockchain, che è un’attivo digitale unico e un’importante infrastruttura per l’attuale metaverso popolare.</p>
<p>Le sue caratteristiche includono unicità e indivisibilità. Ogni opera NFT ha una unica “carta di identità digitale”, che è il numero impostato dal creatore. Questo consente anche alle opere NFT di essere completamente registrate dalla blockchain in ogni <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> di circolazione e di trading.</p>
<p>Tuttavia, ci sono molti tipi di NFT, tra cui immagini, dipinti e altre opere d’arte, giochi, carte dei giocatori, film, musica, avatar, assicurazioni e gif. L’immagine non fungibile è solo uno di questi, ed è anche un dipinto NFT popolare al momento.<br><img src="https://gimg2.gateimg.com/image/article/1674116062333.png" alt=""></p>
<p>MAYC. Fonte: Gate.io</p>
<h2 id="h2-Metodi20importanti20per20verificare20lautenticit20di20un20NFT103252"><a name="Metodi importanti per verificare l’autenticità di un NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Metodi importanti per verificare l’autenticità di un NFT</h2><p>Anche se le opere NFT sono uniche, è comunque necessario prestare attenzione all’autenticità delle opere NFT in cui si investe durante il trading o la raccolta. L’autenticità di <a href="https://www.gate.io/blog_detail/902/Minting--Purchasing-and-Trading-NFT-Art" target="_blank">Opere d’arte NFT</a> può essere verificato per riferimento attraverso i seguenti aspetti.</p>
<h3 id="h3-Verifica20lidentit20dellartista20o20del20venditore969308"><a name="Verifica l’identità dell’artista o del venditore" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verifica l’identità dell’artista o del venditore</h3><p>I venditori legali di NFT avranno un marchio di autenticazione blu accanto al loro nome utente su <a href="https://www.gate.io/nft/explore" target="_blank">Piattaforma di mercato NFT</a>, e gli attributi della collezione saranno chiaramente elencati. Puoi anche trovare gli artisti giusti e le loro opere sui canali dei social media o tramite i siti web degli artisti. Il modo più diretto è chiedere all’artista se l’opera d’arte che desideri acquistare gli appartiene e se ha un profilo utente corretto.<br><img src="https://gimg2.gateimg.com/image/article/1674116111444.png" alt=""></p>
<p>Origine: Gate.io</p>
<h3 id="h3-Verifica20la20dimensione20e20lattivit20del20sito20web20ufficiale20e20della20comunit61099"><a name="Verifica la dimensione e l’attività del sito web ufficiale e della comunità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verifica la dimensione e l’attività del sito web ufficiale e della comunità</h3><p>Visita sempre direttamente siti web verificati per transazioni NFT, come Gate NFT. Sfogliando la piattaforma di mercato, puoi osservare l’attività della piattaforma e i dati di vendita delle opere d’arte correlate agli NFT, visualizzare la cronologia delle transazioni degli acquirenti o dei venditori e la partecipazione dei creatori. Presta particolare attenzione e resisti alla tentazione delle cosiddette offerte speciali NFT, che potrebbero essere uno dei modi per attirare gli investitori all’acquisto.</p>
<h3 id="h3-Verifica20indirizzo20del20contratto528874"><a name="Verifica indirizzo del contratto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verifica indirizzo del contratto</h3><p>Ogni pagina di trading di opere d’arte NFT ha dettagli sull’indirizzo del contratto, che possono essere interrogati e ti aiutano a capire la situazione di trading del venditore. Verifica se i creatori del progetto sono onesti e trasparenti sulla loro identità.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674116159555.png" alt=""></p>
<p>Sorgente: Gate NFT</p>
<h3 id="h3-Attenzione20alle20False20Promozioni20di20NFT532338"><a name="Attenzione alle False Promozioni di NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Attenzione alle False Promozioni di NFT</h3><p>Al fine di attirare gli investitori a fare trading, i truffatori offriranno dei benefici: gli investitori otterranno un NFT gratuito registrandosi sul sito attraverso le loro informazioni promozionali. Tuttavia, dopo che l’investitore si registra, il sistema ti chiederà di <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> le tue credenziali del portafoglio per ricevere i tuoi ‘giveaway’. Una volta che i truffatori hanno inserito le credenziali fornite dagli investitori, possono liberamente accedere ai loro account e rubare gli asset.</p>
<h3 id="h3-Ricerca20Google20per20immagini20NFT964494"><a name="Ricerca Google per immagini NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ricerca Google per immagini NFT</h3><p>Cerca il numero corrispondente su Google per l’opera d’arte NFT in cui desideri investire, oppure cerca direttamente le immagini.</p>
<h3 id="h3-Visualizza20il20volume20delle20vendite20e20il20prezzo20di20NFT435885"><a name="Visualizza il volume delle vendite e il prezzo di NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Visualizza il volume delle vendite e il prezzo di NFT</h3><p>Prima <a href="https://www.gate.io/price/view/nft" target="_blank">acquistare opere d’arte NFT</a>, puoi controllare i prezzi corrispondenti sulla piattaforma di trading ufficiale. Se il prezzo sembra essere inferiore rispetto al prezzo indicato sul sito di trading legittimo, ti preghiamo di fare attenzione all’acquisto dell’investimento. Potrebbe trattarsi di una truffa. Se il volume delle vendite delle opere NFT è superiore al volume normale di trading, potrebbe trattarsi di manipolazione dei dati, come il wash trading.</p>
<h3 id="h3-Ricerca20inversa20delle20immagini20utilizzando20NFT841738"><a name="Ricerca inversa delle immagini utilizzando NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ricerca inversa delle immagini utilizzando NFT</h3><p>Se non sei sicuro se questo NFT è contraffatto, puoi utilizzare una ricerca inversa dell’immagine come Tiny Eye per vedere se il venditore possiede l’immagine.</p>
<h2 id="h2-Come20acquistare20vere20opere20darte20NFT20e20assicurarsi20che20non20siano20rubate330331"><a name="Come acquistare vere opere d’arte NFT e assicurarsi che non siano rubate" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come acquistare vere opere d’arte NFT e assicurarsi che non siano rubate</h2><p>Oltre ai passaggi sopra menzionati per confermare l’autenticità di NFT, c’è anche un modo importante per scegliere una piattaforma di trading NFT affidabile. Oltre a garantire la <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> dei fondi e della trasparenza delle transazioni, la piattaforma ha anche la fiducia selezionata da migliaia di utenti e l’aggiornamento delle opere NFT per evitare di diventare vittima di siti web e progetti falsi.</p>
<p>Un noto mercato di scambio di NFT è OpenSea, che è anche il mercato più grande e popolare nel campo degli NFT al momento. La gamma di opere NFT negoziabili fornite è ampia, ed è il luogo in cui sono situate la maggior parte delle collezioni d’arte generate. Tuttavia, i creatori e i venditori devono versare una tassa di inizializzazione una tantum per l’apertura dell’account, che va da $20 a $250. È inoltre necessario versare il 2,5% del prezzo di transazione alla piattaforma dopo il completamento della negoziazione.</p>
<p>Gli utenti possono anche scegliere di navigare e fare trading sul<br><strong>Gate <a href="https://www.gate.io/nft" target="_blank">Piattaforma di trading NFT</a></strong>. Gate NFT è creato sulla base dello scambio di criptovalute Gate.io, che è in funzione da 9 anni. L’exchange ha fornito un margine di terze parti per le transazioni di criptovalute degli utenti per garantire la sicurezza dei fondi degli utenti. The<br><strong>Piattaforma Gate NFT</strong> Insieme agli artisti, alle IP in tendenza e ai creatori ben noti, è una piattaforma di distribuzione di mercato di primo livello per il lancio di opere NFT di alta qualità. Le opere coprono tutte le categorie di asset digitali NFT come arte, collezioni, metaverso, musica, film, giochi, e così via. Gli artisti o creatori vendono opere NFT attraverso la piattaforma di distribuzione Gate NFT, che ha i vantaggi naturali di basso costo, alto rendimento, elevata liquidità e supporto della comunità.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1674116241666.png" alt=""></p>
<p>Fonte: Gate NFT</p>
<p>Dopo aver selezionato una piattaforma affidabile di mercato NFT, dovresti anche prestare attenzione ad altre modalità con cui gli truffatori possono ottenere le tue informazioni private, come le truffe di phishing tramite messaggi/e-mail con link che richiedono un “aggiornamento dell’indirizzo ufficiale”, così come siti web falsi, rischi di vendita di NFT all’asta. <a href="https://www.gate.io/pt/learn/articles/what-is-a-crypto-airdrop/24" target="_blank">falso NFT airdrop</a>, e impersonando il servizio clienti ufficiale.</p>
<p>La frode è ovunque nel campo NFT. Gli investitori devono essere vigili durante la navigazione e il trading, prestare attenzione alla verifica e all’indagine, ed evitare di diventare vittime innocenti.</p>
<h2 id="h2-Domande20frequenti20sugli20scam20NFT362227"><a name="Domande frequenti sugli scam NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sugli scam NFT</h2><h3 id="h3-Possono20essere20forgiati20gli20NFT944587"><a name="Possono essere forgiati gli NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Possono essere forgiati gli NFT?</h3><p>In generale, un NFT è unico. Ogni opera d’arte è incorporata con informazioni di codice uniche per la successiva circolazione e commercio. Tuttavia, ci saranno ancora alcuni truffatori che copiano le opere d’arte e poi iniziano a venderle dopo averle coniate in un NFT, affermando falsamente di essere state vendute ufficialmente.</p>
<h3 id="h3-Come20faccio20a20sapere20se20lNFT2020vero890373"><a name="Come faccio a sapere se l’NFT è vero?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come faccio a sapere se l’NFT è vero?</h3><p>L’NFT può essere verificato tramite strumenti come il browser blockchain, il certificato digitale di autenticità e la ricerca inversa dell’immagine. I metodi di conferma sono menzionati nel contenuto sopra.</p>
<h3 id="h3-Qualcuno20pu20falsificare20la20propriet20degli20NFT156291"><a name="Qualcuno può falsificare la proprietà degli NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qualcuno può falsificare la proprietà degli NFT?</h3><p>Anche se il truffatore può copiare o falsificare l’NFT, non può copiare e falsificare la proprietà dei metadati correlati all’opera. Le uniche informazioni di codifica generate dai creatori di NFT per le loro opere d’arte sono registrate nella blockchain e gli utenti possono facilmente verificare la loro proprietà.</p>
<h3 id="h3-Alcune20vendite20NFT20sono20false779791"><a name="Alcune vendite NFT sono false?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Alcune vendite NFT sono false?</h3><p>Questa possibilità è dovuta all’esistenza di wash trading nelle transazioni di mercato NFT. Il wash trading NFT significa che il compratore e il venditore nella transazione sono la stessa persona o due persone che colludono. Questa è una forma di manipolazione di mercato. Gli investitori comprano e vendono contemporaneamente gli stessi prodotti per creare attività umane fuorvianti sul mercato.</p>
<h3 id="h3-Sono20legali20gli20NFT20falsi987355"><a name="Sono legali gli NFT falsi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sono legali gli NFT falsi?</h3><p>La proprietà virtuale normale è un’attività personale legale protetta dalla legge. I falsi prodotti NFT non sono inclusi.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Rena W. </strong>, Ricercatore 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. Il riposting dell'articolo sarà consentito a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>