Q29zJ8OoIGlsIG1ldGFkYXRvIE5GVCBlIGNvbWUgZnVuemlvbmE=

<p><img src="https://gimg2.gateimg.com/image/article/16740321051.18.jpeg" alt=""><br>I metadati NFT contengono informazioni sull’immagine, proprietà, caratteristiche, nome, offerta totale e storia di un NFT.</p>
<p>I creatori di token non fungibili possono memorizzare i metadati NFT sul blockchain e fuori dalla catena.</p>
<p>Il File System InterPlanetario è un sistema peer-to-peer popolare per la memorizzazione dei file.</p>
<p>Gli utenti NFT possono accedere ai dati sui token non fungibili utilizzando gli esploratori blockchain come Etherscan e BSCscan.</p>
<p>Parole chiave: metadati NFT, File System InterPlanetary, IPFS, Etherscan, BSCscan, come ERC-72, ERC-115, BEP-721, BEP-115, creatori di NFT</p>
<h2 id="h2-Introduzione601666"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I token non fungibili (NFT) sono uno dei più importanti asset digitali presenti sul mercato in quanto svolgono varie funzioni, come la prova di proprietà di asset fisici. Le informazioni importanti che consentono alle persone di tracciare la proprietà di asset digitali e fisici fanno parte dei metadati NFT. Questo articolo spiega come funzionano i metadati NFT, gli standard dei metadati e dove vengono archiviati.</p>
<h2 id="h2-Comprensione20dei20metadati20NFT455346"><a name="Comprensione dei metadati NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprensione dei metadati NFT</h2><p>I metadati NFT si riferiscono alle informazioni sul contenuto che rappresenta un determinato token non fungibile. Come già sappiamo, un token non fungibile è un asset digitale che rappresenta un oggetto digitale o fisico ed esiste in diversi formati tra cui GIF, JPEG e MP4.</p>
<p>Detto ciò, i dati sull’NFT come la sua descrizione, l’immagine, le proprietà, le caratteristiche, il nome, l’offerta totale e la storia sono contenuti nei metadati. Inoltre, i metadati contengono una <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> che le persone usano per <a href="https://www.gate.io/learn/articles/what-are-nfts/4" target="_blank">vedere l’NFT</a>. Di solito, i metadati NFT esistono nel formato JavaScript Object Notation (JSON).</p>
<p>È interessante notare che, anche se l’NFT esiste sulla blockchain, il file che lo supporta viene conservato fuori dalla catena. Ecco perché i metadati contengono il <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> del file di supporto. In senso reale, i metadati consentono al server di memorizzare in modo efficiente i dati correlati e rendono molto facile per le persone comprendere e accedere all’NFT.</p>
<p>È fondamentale per gli investitori sapere come accedere ai metadati NFT in modo da sapere esattamente cosa stanno acquistando e detenendo. Ciò perché un NFT funge da gateway per accedere all’attività digitale o fisica sottostante come musica, video o pezzo d’arte.<br><img src="https://gimg2.gateimg.com/image/article/167643199611.png" alt=""><br>Metadati NFT- Creabili</p>
<h2 id="h2-Standard20di20metadati20NFT745651"><a name="Standard di metadati NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Standard di metadati NFT</h2><p>Esistono diversi standard per coniare i token non fungibili. Poiché il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain è stata la prima rete a sviluppare token non fungibili, alcuni degli standard sono nella forma del formato di token ERC-20 come ERC-721 e ERC-115. È lo standard che rende il token un NFT e unico. Di conseguenza, ogni NFT ha un identificatore univoco o un ID token unico.</p>
<p>Lo standard ERC-115 è leggermente diverso rispetto all’ERC-721 in quanto consente a un contratto intelligente di contenere un componente fungibile e uno non fungibile, rendendo possibile per vari protocolli di gioco creare valute e oggetti in-game. Tuttavia, altre blockchain come Binance Chain hanno versioni simili di questi due come BEP-721 e BEP-115.</p>
<h2 id="h2-Due20modi20di20memorizzazione20dei20metadati20NFT169814"><a name="Due modi di memorizzazione dei metadati NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Due modi di memorizzazione dei metadati NFT</h2><p>I metadati NFT possono essere archiviati sia on-chain che off-chain. Fattori come il costo determinano dove vengono archiviati i metadati.</p>
<h3 id="h3-Archiviazione20dei20metadati20onchain282438"><a name="Archiviazione dei metadati on-chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Archiviazione dei metadati on-chain</h3><p>I creatori digitali possono scegliere di mantenere i metadati NFT e le immagini sul blockchain. Questo metodo rende molto facile per gli utenti accedere e verificare le informazioni sull’NFT. Tuttavia, molti progetti evitano di memorizzare i loro NFT sul blockchain perché le immagini che esistono sotto forma di file JPEG contengono molte informazioni e memorizzarle sul blockchain diventa costoso. Questo è il motivo per cui <a href="https://www.gate.io/nft/explore" target="_blank">la maggior parte dei creatori di NFT conservano</a> le informazioni sui metadati NFT sono off-chain.</p>
<h3 id="h3-Archiviazione20dei20metadati20offchain648124"><a name="Archiviazione dei metadati off-chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Archiviazione dei metadati off-chain</h3><p>I creatori di NFT che archiviano i metadati NFT off-chain di solito utilizzano server come Google Drive o Amazon Web Services (AWS). Altri progetti utilizzano una rete di condivisione file decentralizzata chiamata InterPlanetary File System (IPFS). Con questo sistema, i file caricati che includono immagini vengono condivisi tra molti nodi, rendendo lo storage molto sicuro.</p>
<h2 id="h2-Il20sistema20di20archiviazione20dati20IPFS911219"><a name="Il sistema di archiviazione dati IPFS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il sistema di archiviazione dati IPFS</h2><p>Come accennato, alcuni progetti NFT scelgono di archiviare i loro metadati sul sistema di archiviazione dati IPFS. Fondamentalmente, il File System Interplanetario (IPFS) è il sistema di archiviazione file peer-to-peer più affidabile sul mercato. Archivia diversi tipi di file, inclusi quelli creati utilizzando gli standard ERC-721 o ERC-1155.<br><img src="https://gimg2.gateimg.com/image/article/167643204122.png" alt=""><br>IPFS per l’archiviazione dei dati- Flairtraining</p>
<p>Quando un progetto carica un file sul sistema IPFS, genera un codice unico o un ID di contenuto per esso. Il file viene quindi archiviato in nodi separati che compongono il sistema peer-to-peer. Per aggiungere maggiore sicurezza ai file, alcuni creatori di NFT li archiviano anche su <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> attraverso NFT.Storage. Questi dati vengono quindi inviati al contratto intelligente NFT dove l’URL dei dati è <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> associato all’ID del NFT.</p>
<p>In termini semplici, l’IPFS ha un sistema per identificare ogni pezzo di dati utilizzando una stringa di caratteri nota come Content ID (CID) che appare come segue: Baccyeigvgzoolc4drupyhlefdp9urscrbcsqfpycc3zxiw1wctk2xjpjtx</p>
<p>Inoltre, un <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> verrà creato un collegamento tra la blockchain e l’IPFS simile a ipfs:// Baccyeigvgzoolc4drupyhlefdp9urscrbcsqfpycc3zxiw1wctk2xjpjtx.</p>
<h2 id="h2-Come20trovare20i20metadati20di20un20NFT936525"><a name="Come trovare i metadati di un NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come trovare i metadati di un NFT?</h2><p>Puoi ottenere i metadati NFT attraverso diversi modi a seconda del suo standard. Ad esempio <a href="/price/amp-amp" rel="nofollow noopener noreferrer" target="_blank">Amp</a> Invece, puoi utilizzare gli esploratori blockchain come Etherscan e BSCscan per visualizzare i metadati NFT on-chain. Per il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> basato su standard di metadati NFT come ERC-115, si utilizza Etherscan per visualizzare i metadati.</p>
<p>Inoltre, le persone possono utilizzare Etherscan per identificare tutti gli NFT che sono in <a href="https://www.gate.io/bitwiki/detail/211/erc-20" target="_blank">la loro ERC-20</a> portafogli conformi. Possono anche verificare qualsiasi transazione <a href="https://www.gate.io/blog_detail/2036/the-different-types-of-nfts" target="_blank">relativo ai loro NFT</a>. Le persone che utilizzano Binance Smart Chain possono utilizzare BSCscan in modo simile a Etherscan.<br><img src="https://gimg2.gateimg.com/image/article/167643207533.png" alt=""><br>Utilizzare Etherscan per trovare i metadati NFT- Cointelegraph</p>
<p>Gli utenti possono anche estrarre i metadati NFT usando il <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> fornito nella sezione dettagli del contratto intelligente. Ciò che è importante per l’individuo è avere l’ID NFT. Possono anche utilizzare gli URI del token, o Uniform Resource Identifiers per accedere alle informazioni su NFT specifici.</p>
<p>Cliccando sul valore dell’immagine nell’output dei metadati JSON, gli utenti possono scaricare i file che contengono i dati sui NFT, <a href="https://www.gate.io/blog_detail/1584/what-is-the-interplanetary-file-ipfs" target="_blank">incluso l’IPFS</a> Metadati NFT, sui loro computer.</p>
<p>Come è stato osservato, è possibile utilizzare servizi di monitoraggio e verifica NFT per tracciare la storia degli NFT, i suoi metadati e la cronologia delle transazioni. Questi possono aiutarti a prendere decisioni informate quando acquisti o vendi token non fungibili.</p>
<h2 id="h2-Conclusione722443"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>I metadati NFT contengono le informazioni di base su un token non fungibile. I creatori di NFT possono memorizzare i metadati NFT on-chain o off-chain a seconda delle loro competenze e risorse finanziarie. Etherscan e BSCscan forniscono molti dettagli sugli NFT, consentendo agli utenti di tracciare le loro cronologie di transazione.</p>
<h2 id="h2-Domande20frequenti20sui20metadati20NFT82534"><a name="Domande frequenti sui metadati NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sui metadati NFT</h2><h3 id="h3-Come20posso20ottenere20i20metadati20del20mio20NFT830644"><a name="Come posso ottenere i metadati del mio NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come posso ottenere i metadati del mio NFT?</h3><p>Puoi utilizzare un esploratore di blockchain come Etherscan o BSCscan per individuare i metadati NFT. Per l’NFT basato su ERC-721 e ERC-1155, puoi utilizzare Ethercan. D’altro canto, puoi utilizzare BSCscan per gli NFT che utilizzano gli standard BEP-721 e BEP-1155.</p>
<h3 id="h3-Dove20vengono20archiviati20i20metadati20NFT488789"><a name="Dove vengono archiviati i metadati NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dove vengono archiviati i metadati NFT?</h3><p>I metadati NFT sono memorizzati sulla blockchain o fuori catena a seconda delle preferenze del creatore. Tuttavia, è molto costoso memorizzare gli NFT sulla blockchain perché i file JPEG contengono molti dati. Quando si memorizzano gli NFT fuori catena, l’intero NFT o parte di esso esiste al di fuori della blockchain. In questo caso, il creatore può memorizzare i dati su server centralizzati o su server decentralizzati come il Sistema di File InterPlanetario (IPFS).</p>
<h3 id="h3-Che20cos20il20metadata20ERC721154511"><a name="Che cos’è il metadata ERC-721?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Che cos’è il metadata ERC-721?</h3><p>I metadati ERC-721 sono per l’NFT che utilizza lo standard ERC-721 e esiste sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La norma ERC-721 ha diverse estensioni opzionali ed è divisa tra contratti intelligenti. Puoi monitorare i metadati per gli NFT tramite il tokenURI, o Uniform Resource Identifier</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 ripostaggio dell'articolo a condizione che venga fatto 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>