Ir para o conteúdo
Buscar

WEB3DEV

Cover image for Como atualizar os metadados do NFT Solana usando TypeScript
Fatima Lima
Fatima Lima

Posted on

Como atualizar os metadados do NFT Solana usando TypeScript

#solana #typescript #metadata

Visão Geral​

Está atualizando os traits para sua coleção de NFT? Alterando royalties/criadores para refletir sobre mudanças na sua equipe? Aprimorando a arte de sua coleção de PFP? Independentemente do motivo, a atualização de metadados para NFTs que você criou é uma ferramenta útil que qualquer desenvolvedor de NFT deve ter em sua caixa de ferramentas.

O Que Você Vai Fazer

Neste guia, você atualizará os metadados de um NFT na devnet da Solana a partir do seu terminal usando a biblioteca Solana Web3 e os SDKs Metaplex JS. Abordaremos três etapas para atualizar os metadados do seu NFT:

  1. Buscar o NFT existente
  2. Fazer upload de novos metadados
  3. Atualizar o NFT

Do que você vai precisar

  • Nodejs (versão 16.15 ou superior) instalado
  • Experiência com Typescript e a versão mais recente do ts-node instalada (você pode atualizar para a versão mais recente digitando** npm update -g typescript ts-node** no terminal)

Antes de Começar

Certifique-se de que você tenha cunhado um NFT na devnet da Solana e tenha acesso à carteira de autoridade. Você pode criar uma seguindo este procedimento Manual: Como criar um NFT no Solana usando Typescript ((Código-fonte).

🚨 Certifique-se de selecionar mutable: true na configuração do seu NFT. Somente os metadados mutáveis do NFT podem ser atualizados.

Configure Seu Projeto​

Crie um novo diretório de projeto em seu terminal com: 

mkdir update-metadata
cd update-metadata
Enter fullscreen mode Exit fullscreen mode

Crie um arquivo para seu app.ts: 

echo > app.ts
Enter fullscreen mode Exit fullscreen mode

Inicialize seu projeto com o sinalizador "yes" para usar valores padrão para seu novo pacote: 

yarn init --yes
#or
npm init --yes
Enter fullscreen mode Exit fullscreen mode

Crie tsconfig.json com a importação de .json habilitada: 

tsc -init --resolveJsonModule true
Enter fullscreen mode Exit fullscreen mode

Instale a dependência Web3 da Solana​

Para este exercício, precisaremos adicionar as bibliotecas Solana Web3 e SPL Token. Além disso, usaremos o SDK JS do Metaplex. Em seu terminal, digite:

yarn add @solana/web3.js @metaplex-foundation/js
#ou
npm install @solana/web3.js @metaplex-foundation/js
Enter fullscreen mode Exit fullscreen mode

Adicione Sua Carteira e Faça Airdrop de SOL

Para seguir este manual, você precisará da mesma carteira do Solana File System (par de chaves gravado em um arquivo guideSecret.json) que é a autoridade do seu NFT. Se você ainda não tiver uma carteira de NFT ou de autoridade de NFT, crie uma seguindo nosso Guia: Como criar um NFT na Solana usando Typescript (Código-fonte).

Certifique-se de salvar sua carteira no diretório do projeto como guideSecret.json (basta copiá-la diretamente do diretório do projeto mint-nft do Mint NFT Guide). Se precisar da devnet SOL, solicite-a inserindo o endereço de sua carteira abaixo:

🪂REQUEST DEVNET SOL (checar no texto original)

Após a configuração, seu ambiente deverá estar semelhante a este:

Image description

Configure Seu App​

Importe as dependências necessárias​

Abra o app.ts e cole as importações a seguir na linha 1:

import { Connection, Keypair, PublicKey } from "@solana/web3.js";
import { Metaplex, keypairIdentity, bundlrStorage, Nft, Sft } from "@metaplex-foundation/js";
import secret from './guideSecret.json';
Enter fullscreen mode Exit fullscreen mode

Além da carteira que criamos na etapa anterior, também estamos importando alguns métodos e classes essenciais das bibliotecas Solana Web3 e Metaplex JS.

Configure o Endpoint do seu QuickNode

Para desenvolver na Solana, você precisará de um endpoint (ponto de extremidade) de API para se conectar à rede. Você pode usar nós públicos ou implantar e gerenciar sua própria infraestrutura; no entanto, se quiser tempos de resposta 8x mais rápidos, pode deixar o trabalho pesado conosco. Veja por que mais de 50% dos projetos na Solana escolhem o QuickNode e registre-se para obter uma conta gratuita aqui. Vamos usar um nó Devnet Solana.

Copie o link do Provedor HTTP:

Image description

Dentro do app.ts, nas declarações de importação, declare seu RPC e estabeleça sua Conexão com a Solana:

const QUICKNODE_RPC = 'https://example.solana-devnet.quiknode.pro/0123456/';
const SOLANA_CONNECTION = new Connection(QUICKNODE_RPC);
Enter fullscreen mode Exit fullscreen mode

Declare as Variáveis

Você precisará declarar algumas variáveis para executar seu script:

  • Sua carteira fonte (um par de chaves derivado de sua chave secreta).
  • O endereço de cunhagem do NFT que você gostaria de atualizar.
  • Uma instância do Metaplex.
  • Seus novos metadados.

Adicione as seguintes declarações abaixo de SOLANA_CONNECTION para determinar a carteira que estaremos usando e o NFT que estaremos atualizando:

const WALLET = Keypair.fromSecretKey(new Uint8Array(secret));
const MINT_ADDRESS = '6cuiqk2VubzAgtUvFjBvosjCJUWG81EvW1F28qtX4EDn';
Enter fullscreen mode Exit fullscreen mode

Certifique-se de que o NFT que você esteja incluindo tenha a autoridade definida para a sua WALLET e que o NFT seja mutável.

Estabeleça uma nova instância do Metaplex chamando nossa SOLANA_CONNECTION em Metaplex.make(). Nossa instância usará o par de chaves que acabamos de criar e o bundlrStorage (uma opção para carregar arquivos no Arweave usando a Solana):

const METAPLEX = Metaplex.make(SOLANA_CONNECTION)
   .use(keypairIdentity(WALLET))
   .use(bundlrStorage({
       address: 'https://devnet.bundlr.network',
       providerUrl: QUICKNODE_RPC,
       timeout: 60000,
   }));
Enter fullscreen mode Exit fullscreen mode

Ao incluir nossa conexão de rede, carteira e rota de armazenamento, a API facilitará o envio de transações para a rede Solana.

Defina os Metadados do NFT

Criaremos um objeto NEW_METADATA contendo os novos metadados. Crie uma nova const, NEW_METADATA e inclua os seguintes atributos:

const NEW_METADATA = {
   imgType: 'image/png',
   imgName: 'QuickPix New MetaName',
   description: 'New description!',
   attributes: [
       {trait_type: 'Speed', value: 'Quicker'},
       {trait_type: 'Type', value: 'Pixelated'},
       {trait_type: 'Background', value: 'QuickNode Blue 2'}
   ]
};
Enter fullscreen mode Exit fullscreen mode

Sinta-se à vontade para substituir o nome, a descrição e os atributos por seus próprios valores.

NOTA: você deve incluir todos os traits aqui (mesmo que alguns não tenham sido alterados), pois todos eles serão carregados para substituir os metadados existentes (por exemplo, observe que incluímos o tipo de imagem aqui - mesmo que ele não seja alterado, temos que incluí-lo novamente em nosso upload).

Crie e Chame a Função Principal

Crie uma função async, main, que será usada para executar todos os passos do nosso código e invoque-a na linha seguinte:

async function main() {
   console.log(`Updating Metadata of NFT: ${MINT_ADDRESS}}`);
}

main();
Enter fullscreen mode Exit fullscreen mode

Isso não fará muito, mas você poderá executar o código para garantir que não haja erros nesse ponto:

ts-node app
Enter fullscreen mode Exit fullscreen mode

Você deverá ver um log no console informando que está prestes a atualizar os metadados do nosso NFT, então vamos lá! Se estiver recebendo um erro ou tiver dúvidas, envie-nos uma mensagem no Discord e teremos prazer em ajudar.

Busque o NFT​

Antes de podermos editar nosso NFT, precisamos primeiro buscá-lo. O SDK JS do Metaplex facilita isso para nós com nfts().findByMint({}). Dentro de sua função main(), adicione:

  //Passo 1 - Buscar um NFT existente
   console.log(`Step 1 - Fetching existing NFT`);
   const nft = await METAPLEX.nfts().findByMint({ mintAddress: new PublicKey(MINT_ADDRESS) });
   if (!nft || !nft.json?.image) {throw new Error("Unable to find existing nft or image uri!")}
   console.log(`   NFT Found!`)
Enter fullscreen mode Exit fullscreen mode

O método findByMint() deve retornar um objeto do tipo Nft. Se a consulta não retornar um valor ou uma imagem associada, lançaremos um erro e interromperemos o script. Caso contrário, registraremos que o NFT foi encontrado.

Faça Upload dos Metadados​

Em seguida, precisamos carregar nossos novos metadados no Arweave para obter um URI ao qual possamos associar nosso NFT. Usaremos a mesma função uploadMetadata() que criamos em nosso Guia: Como criar um Mint de NFT na Solana usando Typescript. Crie uma nova função, uploadMetadata, que aceite 5 parâmetros: imgUri, imgType, nftName, description e attributes:

async function uploadMetadata(imgUri: string, imgType: string, nftName: string, description: string, attributes: {trait_type: string, value: string}[]) {
   console.log(`Step 2 - Uploading MetaData`);

}
Enter fullscreen mode Exit fullscreen mode

Em seguida, chame nfts().uploadMetadata(). Precisaremos passar nossos parâmetros da seguinte forma:

const { uri } = await METAPLEX \
       .nfts() \
       .uploadMetadata({ \
           name: nftName, \
           description: description, \
           image: imgUri, \
           attributes: attributes, \
           properties: { \
               files: [ \
                   { \
                       type: imgType, \
                       uri: imgUri, \
                   }, \
               ] \
           } \
       }); \
   console.log('   Metadata URI:',uri); \
   return uri;
Enter fullscreen mode Exit fullscreen mode

Vamos prosseguir e chamar nossa função em main(). Depois de uploadImage, chame uploadMetadata usando nosso NEW_METADATA para alimentar os parâmetros:

//Passo 2 - Fazer Upload dos Metadados
   const newUri = await uploadMetadata(nft.json.image,NEW_METADATA.imgType,NEW_METADATA.imgName, NEW_METADATA.description, NEW_METADATA.attributes);
Enter fullscreen mode Exit fullscreen mode

Se quiser testar sua função, poderá registrar newUri e, em seguida, executar o aplicativo ts-node. Quando estiver pronto, vamos atualizar os metadados desse NFT!

Atualize os Metadados do NFT

Como em nossas funções anteriores, a API do Metaplex simplifica esse processo e nos permite cunhar nosso NFT com um único método, nfts().update(). Para executar esse método, devemos passar o objeto nft que buscamos em nossa primeira etapa, juntamente com nosso newUri.

Depois de nossa função uploadMetadata() e antes da main(), crie uma nova função async, updateNft():

async function updateNft(nft:Nft|Sft, metadataUri: string, newName: string) {
   console.log(`Step 3 - Updating NFT`);
}
Enter fullscreen mode Exit fullscreen mode

Por fim, dentro da nossa função, chame nfts().update() passando nosso metadataUri e outros parâmetros da função e registre os resultados:

   await METAPLEX
       .nfts()
       .update({
           name: newName,
           nftOrSft: nft,
           uri: metadataUri
       }, { commitment: 'finalized' });
   console.log(`   Success!🎉`);
   console.log(`   Updated NFT: https://explorer.solana.com/address/${nft.address}?cluster=devnet`);
Enter fullscreen mode Exit fullscreen mode

Essa função atualiza os metadados na cadeia do token usando o Programa Metaplex Metadata. Observe que, ao contrário do método create(), o método update() não retorna nenhum valor.

Se precisar usar o novo objeto NFT, será necessário executar const updatedNft = await metaplex.nfts().refresh(nft); (não precisaremos disso para nossos objetivos, portanto, não o usaremos agora).

Agora, tudo o que você precisa fazer é chamar essa função dentro de main(), passando os parâmetros de CONFIG:

  //Passo 3 - Atualizar o NFT

   updateNft(nft, newUri, NEW_METADATA.imgName);
Enter fullscreen mode Exit fullscreen mode

🚀Execute seu Código!

Está tudo pronto! Se quiser verificar novamente seu código em relação ao nosso, toda a nossa pasta de trabalho está disponível no GitHub aqui.

Quando estiver pronto, digite no terminal:

ts-node app
Enter fullscreen mode Exit fullscreen mode

SIM! Você está vendo algo assim?

Image description

Vá em frente e siga o link em seu console para o Explorer da Solana. Se você rolar a tela para baixo, poderá ver os metadados on-chain com o novo nome e um link para os metadados carregados:

Image description

Bom trabalho.

Próximas Etapas e Conclusão​

Agora você tem um script prático e reutilizável para atualizar os metadados do NFT diretamente do seu terminal! Gostaríamos muito de saber como você planeja usar isso e em quais projetos de NFT você está trabalhando. Entre no Discord ou no Twitter e compartilhe seus projetos!!

Nós <3 Feedback!

Se tiver algum comentário ou dúvida sobre este guia, entre em contato conosco. Gostaríamos muito de ouvir sua opinião!

Referências​

Esse artigo foi escrito por Aaron Milano e traduzido por Fátima Lima. O original pode ser lido aqui.

Top comments (0)


Leia o próximo

valterlobo profile image

Contratos inteligentes: imutabilidade e flexibilidade

Valter Lobo -

panegali profile image

O Potencial Impacto dos Tokens ERC-777 nos Protocolos DeFi

Panegali -

s4mp41xao profile image

Retrospectiva 2023: Um Ano de Conquistas na Comunidade WEB3DEV

Samuel Paixão -

isabelacnehme profile image

Do Solidity ao Cairo1: o Design de 'alexandria_bytes'

Isabela Curado Nehme -