Visão geral

Stacks é uma blockchain emergente protegida por Bitcoin e com suporte nativo para contratos inteligentes. Nosso guia anterior da Stacks demonstrou como criar e implantar um contrato inteligente na blockchain Stacks. Neste guia, daremos um passo adiante e aprenderemos como criar e implantar um contrato de NFT compatível com SIP-009 para a rede de testes da Stacks. Depois de implantado, você também aprenderá como cunhar os NFTs por meio do Sandbox Stacks. Vamos começar!

O Que Você Vai Precisar

• Clarinet instalado;
• Um editor de texto ou IDE;
• Carteira Hiro;
• Tokens STX da rede de testes (você pode obter alguns nesta torneira);

O Que Você Vai Fazer

• Revisar as especificações do padrão SIP-009 NFT;
• Criar e configurar um projeto no Clarinet;
• Criar e configurar um contrato inteligente NFT;
• Testar o contrato NFT em um ambiente local;
• Implantar o contrato NFT na rede de testes da Stacks;
• Testar o NFT através da Stacks Sandbox

Padrão SIP-009 NFT

O ecossistema Stacks adotou um padrão para tokens fungíveis e não fungíveis. Esses padrões tornam mais fácil para os desenvolvedores começarem e ajudam a garantir que os contratos inteligentes que eles escrevem permaneçam combináveis. Alguns padrões populares no ecossistema Stacks atualmente são:

• SIP-010: padrão para tokens fungíveis;
• SIP-009: padrão para tokens não fungíveis.

Como estamos demonstrando o padrão SIP-009 neste guia, vamos cobrir as especificações e os métodos necessários para tornar nosso NFT compatível com o SIP-009.

• ID do último token - (get-last-token-id () (response uint uint)) - esta função não recebe argumentos e retorna o ID do último NFT gerado.
• URI do token - (get-token-uri (uint) (response (optional (string-ascii 256)) uint)) - esta função retorna um URI do token para um determinado ID de NFT.
• Proprietário - (get-owner (uint) (response (optional principal) uint)) - esta função retorna o proprietário de um determinado ID de NFT.
• Transferir - (transfer (uint principal principal) (response bool uint)) - esta função transfere o NFT para o destinatário especificado.
• Trait - Você precisará declarar um arquivo de trait que conterá os metadados de seus NFTs (em nosso exemplo, é nft-trait.clar).
• Funções de ativos nativos: nft-burn, nft-get-owner, nft-mint, nft-transfer

Agora que conhecemos o esboço da implantação de um contrato inteligente compatível com SIP-009, vamos passar à codificação!

Crie e Configure um Projeto em Clarinet

Abra uma janela de terminal e navegue até o diretório onde deseja que este projeto resida. Em seguida, execute o seguinte comando para criar um novo projeto Clarinet e navegar dentro dele.

Nota: Você deve ter o Clarinet instalado para executar o comando abaixo.

clarinet new nft-project && cd nft-project

A seguir, use o comando abaixo para criar um conjunto de arquivos de contrato inteligente:

clarinet contract new nft-trait; clarinet contract new nft-factory

O comando acima cria dois arquivos .clar (que é o formato de arquivo para Clarity), um para nossa lógica de contrato NFT (por exemplo, nft-factory.clar) e um para nossos metadados de NFTs (por exemplo, nft-trait.clar) . Ele também criará dois arquivos de teste (formato TypeScript) em um diretório de teste.

Na próxima seção, começaremos a configurar e implementar o contrato inteligente NFT.

Crie e Configure um Contrato Inteligente de NFT

Implementando o Padrão SIP-009

Antes de entrarmos no código do contrato inteligente, precisamos configurar algumas dependências para garantir que o contrato que estamos construindo seja compatível com SIP-009. Abra o Clarinet.toml e edite a seção Contracts.nft-factory (em torno das linhas 11-12) para corresponder à seguinte configuração:

[contracts.nft-factory]
path = "contracts/nft-factory.clar"
depends_on = ["nft-trait"]

A configuração acima garante que nosso contrato inteligente esteja em conformidade com as características exigidas no padrão SIP-009. Se não implementarmos as características configuradas, nossa implantação em ambientes de teste e produção falhará.

Em seguida, abra o arquivo nft-trait.clar. Copie o código a seguir e substitua-o pelo conteúdo já existente no arquivo:

(define-trait nft-trait
 (
   ;; Last token ID, limited to uint range
   (get-last-token-id () (response uint uint))

   ;; URI for metadata associated with the token
   (get-token-uri (uint) (response (optional (string-ascii 256)) uint))

    ;; Owner of a given token identifier
   (get-owner (uint) (response (optional principal) uint))

   ;; Transfer from the sender to a new principal
   (transfer (uint principal principal) (response bool uint))
 )
)

Em seguida, salve o arquivo. O código Clarity acima define as funções com as quais nosso contrato deve estar em conformidade. Essas funções devem ser familiares para você, uma vez que as discutimos na seção anterior.

Implementando a Lógica

Agora, adicionaremos a lógica do contrato inteligente de NFT ao arquivo nft-factory.clar. O contrato nos permitirá cunhar NFTs na blockchain Stacks. Abra o arquivo e substitua o conteúdo existente pelo seguinte código:

;; using the SIP009 interface (testnet)
;; trait configured and deployed from ./settings/Devnet.toml
(impl-trait 'ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.nft-trait.nft-trait)

;; declare a new NFT
(define-non-fungible-token NFT-FACTORY uint)

;; store the last issued token ID
(define-data-var last-id uint u0)

;; mint a new NFT
(define-public (claim)
 (mint tx-sender))

;; SIP009: Transfer token to a specified principal
(define-public (transfer (token-id uint) (sender principal) (recipient principal))
  (begin
     (asserts! (is-eq tx-sender sender) (err u403))
     ;; Make sure to replace NFT-FACTORY
     (nft-transfer? NFT-FACTORY token-id sender recipient)))

(define-public (transfer-memo (token-id uint) (sender principal) (recipient principal) (memo (buff 34)))
  (begin
    (try! (transfer token-id sender recipient))
    (print memo)
    (ok true)))

;; SIP009: Get the owner of the specified token ID
(define-read-only (get-owner (token-id uint))
  ;; Make sure to replace NFT-NAME
  (ok (nft-get-owner? NFT-FACTORY token-id)))

;; SIP009: Get the last token ID
(define-read-only (get-last-token-id)
  (ok (var-get last-id)))

;; SIP009: Get the token URI. You can set it to any other URI
(define-read-only (get-token-uri (token-id uint))
  (ok (some "https://token.stacks.co/{id}.json")))

;; Internal - Mint new NFT
(define-private (mint (new-owner principal))
    (let ((next-id (+ u1 (var-get last-id))))
      (var-set last-id next-id)
      ;; You can replace NFT-FACTORY with another name if you'd like
      (nft-mint? NFT-FACTORY next-id new-owner)))

Nota: você pode querer ajustar o URL na função get-token-uri, pois atualmente não aponta para nenhum metadado. Este guia não definirá nenhum metadado no NFT que cunhamos; no entanto, você pode seguir a seção "Criando URI de metadados" neste guia do NFT ERC-1155 para criar facilmente metadados usando NFT.storage e IPFS.

Na próxima seção, demonstraremos como verificar seus contratos para garantir que sejam implantáveis.

Teste o Contrato de NFT em um Ambiente Local

O Clarity é uma linguagem interpretada, o que significa que ela não compila o código para um nível inferior antes da execução; em vez disso, o código é executado no mesmo formato em tempo de execução. Isso torna o código mais lento, mas mais transparente. Para verificar se nosso código Clarity está sintaticamente correto, podemos executar o comando clarinet check no diretório nft-project.

Você poderá receber alguns avisos; entretanto, não se preocupe com isso para os fins deste guia. Falaremos sobre avisos e dados não verificados em um guia futuro.

Antes de implantar na rede de testes da Stacks, é uma boa prática verificar algumas funções para garantir que as respostas sejam as que esperamos. Podemos iniciar o console do Clarinet para fazer isso:

clarinet console

Assim que o console for iniciado, você verá o endereço do seu contrato e as funções públicas disponíveis no seu contrato. Haverá também uma lista de contas de teste associadas ao seu console local do Clarinet. Execute o comando abaixo para chamar a função claim (de reinvindicação) do nosso contrato inteligente, que criará um NFT em nosso ambiente local.

(contract-call? .nft-factory claim)

Você deverá ver uma resposta semelhante a esta:

Se tudo correr bem, passe para a próxima seção, onde implantaremos nosso contrato de NFT na rede de testes da Stacks. 👀

Implante o Contrato de NFT na Rede de Testes da Stacks

Esta seção demonstrará como implantar seu contrato de NFT na rede de testes da Stacks usando o Stacks Explorer Sandbox. Antes de começarmos, verifique se você já tem a Carteira Hiro instalada e configurada. Além disso, certifique-se de ter alguns tokens STX de teste para taxas de gás (você pode obter alguns nesta torneira).

Lembre-se de mudar a rede da sua carteira Hiro para Testnet (rede de testes). Isso pode ser feito clicando no botão de reticências ("...") e clicando em “Change Network” (alterar rede).

Assim que sua carteira estiver configurada, conecte-a ao Stacks Explorer Sandbox e navegue até a página Write & Deploy (escrever e implantar). Copie e cole o código do seu arquivo nft-factory.clar e, em seguida, preencha o nome do contrato (em nosso exemplo, é "nft-factory") se não quiser que o nome gerado aleatoriamente seja fornecido a você.

Em seguida, clique no botão “Deploy” (implantar). Você deverá receber um aviso na janela da carteira Hiro com informações sobre a transação. Verifique se a transação parece correta e clique em “Confirm” (confirmar).

A mineração (transação/processo) pode demorar alguns minutos. Você pode monitorar a transação na página de transações do Stacks Explorer ou por meio da seção de atividades da sua carteira Hiro. Depois de confirmarmos que o contrato foi minerado, podemos navegar até a página inicial do nosso contrato pesquisando o endereço do contrato ou clicando na transação em nossa carteira. A página do contrato mostrará o nome do seu contrato, o endereço do implantador, as taxas para implantar o contrato, o código-fonte e o número de bloco em que foi minerado.

Você pode estar se perguntando: onde está o NFT que você acabou de cunhar? Bem, tecnicamente, ainda não foi cunhado. Até agora, acabamos de criar e implantar o contrato de NFT. Na próxima seção, demonstraremos o processo de cunhagem onde você reivindicará seu NFT e o visualizará em sua carteira Hiro. No entanto, fique à vontade para passar um pouco mais de tempo explorando a página do explorador e passar para a próxima seção quando estiver pronto.

Cunhe o NFT por Meio do Stacks Sandbox

O momento que você estava esperando! É hora de cunhá-lo!

Para cunhar o NFT, precisaremos chamar a função claim do nosso contrato de NFT. Para esta demonstração, faremos isso no Stacks Explorer Sandbox e demonstraremos por meio do código em outro guia.

Navegue até a página Call a contract (chama um contrato) (o f na barra lateral esquerda) e, em seguida, insira o endereço do seu contrato (ou seja, ST12KGMZCKXERR1VG1TFEQQZ3VQXSMVVC3J31S604.nft-factory) e o sandbox deve detectar o endereço e o nome. Clique no botão “Get contract” (obter contrato) e deverá ver as funções que podem ser chamadas listadas na tabela da seguinte forma:

Clique na função claim e, em seguida, clique na função call (de chamada). Você receberá um aviso em sua carteira Hiro. Verifique se a função claim está sendo chamada e confirme a transação. Sua transação pode levar alguns minutos para ser confirmada. Sinta-se à vontade para fazer uma pausa rápida; a transação deve ser confirmada assim que você retornar. Se ainda demorar um pouco, você pode clicar no ícone Increase Fee* (Aumentar taxa) em sua transação na guia de atividades da sua carteira Hiro.

Depois que a transação for minerada, você poderá ver seu NFT na guia Balances (saldos) da sua carteira Hiro ou no Stacks Explorer acessando a página de endereço da sua carteira pessoal e olhando a guia Collectibles (colecionáveis).

Considerações Finais

Ótimo trabalho! Você aprendeu como criar, implantar e executar um contrato de NFT para a rede de testes da blockchain Stacks. Para continuar desenvolvendo suas novas habilidades e conhecimentos, você pode tentar adicionar metadados ao seu NFT ou tentar cunhá-los programaticamente. Você também pode verificar alguns de nossos outros guias aqui.

Quer mostrar seu novo NFT ou fazer uma pergunta? Compartilhe conosco no Discord ou entre em contato conosco pelo Twitter.

Nós <3 Feedback!

Se você tiver algum comentário ou dúvida sobre este guia, informe-nos. Adoraríamos ouvir de você!

Este artigo foi escrito por Ferhat Kochan, e traduzido por Isabela Curado Nehme. Seu original pode ser lido aqui.