Fazendo NFTs com Plutus

Recentemente, o projeto de criptomoeda Cardano lançou sua versão Alonzo com suporte para contratos inteligentes. Cardano é construída principalmente em Haskell e seu sistema de contrato inteligente, Plutus, também.

Cardano é um grande projeto de criptomoeda, atualmente o terceiro maior (no momento da tradução deste artigo, Cardano se encontra na oitava posição) por capitalização de mercado depois de Bitcoin e Ethereum. Além da capitalização de mercado, o projeto é possivelmente o projeto Haskell mais desenvolvido ativamente. Ele foi projetado para competir com as habilidades de contrato inteligente da Ethereum, mas como Cardano usa Proof of Stake, em vez de Proof of Work, é mais eficiente em termos de energia e requer taxas drasticamente mais baixas.

É comum que as transações de contrato inteligente da Ethereum custem mais de US $ 60 em taxas. No entanto, isso não impediu a adoção da Ethereum, que aumentou este ano à medida que os NFTs se tornaram mais populares.

Cardano promete fazer todas as coisas que a Ethereum pode fazer, mas melhor e mais barato, e usa Haskell. Ethereum usa Solidity, não conheço Solidity, mas com 12 anos de Haskell pensei em dar uma olhada.

Conforme rapidamente descoberto, havia pouco escrito sobre como implantar um contrato inteligente Plutus do início ao fim. Espero que esta postagem no blog ajude a preencher essa lacuna.

Compre Ada

Para realmente implantar e interagir com um contrato inteligente Plutus, você precisa criar uma transação na blockchain Cardano. Isso exigirá o gasto da moeda nativa Ada. Você não precisa de muito para brincar com o Plutus (na verdade você não precisa de nenhum para usar a testnet... mas como isso é agradável?). Alguns dólares em Ada serão suficientes.

A maneira mais fácil de comprar Ada é com a Coinbase. Se você ainda não possui uma conta na Coinbase, convém instalar o aplicativo e configurar uma. Divirta-se.

Instalar o Nix

A primeira coisa que você vai querer fazer é instalar o sistema gerenciador de pacotes Nix.

Você pode fazer isso com este comando:

sh <(curl -L https://nixos.org/nix/install) --daemon

Se você já tiver o Nix instalado, verá instruções sobre como desinstalá-lo.

Estou em um Mac e, portanto, precisei de algumas etapas extras para desinstalar que não foram listadas, infelizmente.

Primeiro, tive que usar o Utilitário de Disco para remover minha partição Nix. Então eu precisava excluir a linha /nix do arquivo/etc/exports.

Depois de reiniciar meu computador, consegui instalar o Nix…

MUITO IMPORTANTE

Você deve configurar os caches nix do IOHK, caso contrário, você acabará compilando o GHC a partir da fonte. Siga as instruções aqui: https://github.com/input-output-hk/plutus#iohk-binary-cache

Instalar o Daedalus

Daedalus é o sistema de carteira Cardano GUI. Você provavelmente poderia usar o nó cardano em vez disso, mas eu tenho coisas para trabalhar com o Daedalus, então ... essa é a direção que seguiremos.

Baixe aqui: https://daedaluswallet.io/en/download/.

Após a instalação, inicie-o e deixe-o sincronizar. Isso levará meio dia.

Construa o cardano-cli

Vamos precisar do cardano-cli para interagir com a Blockchain Cardano. Essas instruções são baseadas na documentação aqui: https://docs.cardano.org/plutus/Plutus-transactions.

Clone o repositório e construa o cardano-cli

git clone https://github.com/input-output-hk/cardano-node
cd cardano-node
git fetch --all --recurse-submodules --tags
git checkout tags/1.29.0

Crie um arquivo plutux-tutorial.nix com o seguinte conteúdo:

{ version ? "mainnet", pkgs ? import <nixpkgs> { }}:
let
  cardano-node-repo = import ./. { };

in pkgs.mkShell {
  buildInputs = with pkgs; [
    libsodium
    cabal-install
    zlib
    haskell.compiler.ghc8107
    haskellPackages.haskell-language-server

    cardano-node-repo.scripts."${version}".node
    cardano-node-repo.cardano-cli
  ];

  CARDANO_NODE_SOCKET_PATH = "${builtins.toString ./.}/state-node-${version}/node.socket";

}

Chamada

nix-shell plutus-tutorial.nix

Espere dez minutos.

Uma vez que tudo tenha terminado de ser construído, é hora de criar um endereço de carteira.

Execute o seguinte no shell nix atualmente ativo.

cardano-cli address key-gen --verification-key-file ~/plutus_test.vkey --signing-key-file ~/plutus_test.skey
cardano-cli address build --payment-verification-key-file ~/plutus_test.vkey --out-file ~/plutus_test.addr

Agora transfira 2 Ada para este endereço.

Criando um NFT

NFTs são uma maneira de criar ativos digitais exclusivos. Cardano teve a capacidade de criar uma forma limitada de NFTs antes da bifurcação Alonzo, mas com Plutus, Cardano pode fazer NFTs que rivalizam com os NFTs baseados em Ethereum.

Extraí o código de criação do NFT do repositório do Lobster Challenge. O código NFT está localizado aqui: https://github.com/jfischoff/plutus-nft.

O contrato inteligente NFT impõe exclusividade exigindo que a entrada da transação seja um UTxO específico na blockchain. UTxO's são nós de blockchain que podem ser usados ​​como entradas para novas transações. No entanto, uma vez que são usados ​​em uma transação, eles não podem ser usados ​​novamente (isso permitiria “gastos duplos”).

O que isso significa é que o contrato inteligente deve ser recompilado para cada NFT. Só pode ser usado uma vez.

Para compilar o contrato inteligente, devemos primeiro obter a ID do UTxO onde nosso Ada está armazenado.

Primeiro, certifique-se de que o Daedalus esteja em execução e sincronizado com a rede. Em seguida, defina:

export CARDANO_NODE_SOCKET_PATH="/Users/YOUR_USER_NAME/Library/Application Support/Daedalus Mainnet/cardano-node.socket"

Agora podemos obter o UTxO associado ao nosso endereço de carteira.

cardano-cli query utxo --address $(cat ~/plutus_test.addr) --mainnet

                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
ea2fe8519d45c33c21de2fc95664075c1dfd42af232f3a51809ed0ffad223164     0        4200000 lovelace + TxOutDatumHashNone

Neste exemplo, a id que precisamos é

ea2fe8519d45c33c21de2fc95664075c1dfd42af232f3a51809ed0ffad223164#0

.

Podemos passar isso junto com o “nome do token” do nosso NFT:

cabal run create-nft-script -- ea2fe8519d45c33c21de2fc95664075c1dfd42af232f3a51809ed0ffad223164#0 AwesomeNFT

Isso gravará o nft-mint-policy.plutusno diretório scripts.

Agora podemos criar nossa transação de cunhagem de NFT.

scripts/mint_nft.sh ea2fe8519d45c33c21de2fc95664075c1dfd42af232f3a51809ed0ffad223164#0 $(cat ~/plutus_test.addr) ~/plutus_test.skey AwesomeNFT

Após cerca de 30 segundos, consulte o UTxO no endereço da sua carteira

Amount
--------------------------------------------------------------------------------------
8579dd0a31cd1b54e5b91320ff90806e1bdd65ebe3278a93e638429b262ecd8b     0        2070331 lovelace + TxOutDatumHashNone
8579dd0a31cd1b54e5b91320ff90806e1bdd65ebe3278a93e638429b262ecd8b     1        1724100 lovelace + 1 369e5bad71475274d99a1c3c8272df1b159e677b49b86d220961e3c4.AwesomeNFT + TxOutDatumHash ScriptDataInAlonzoEra "45b0cfc220ceec5b7c1c62c4d4193d38e4eba48e8815729ce75f9c0ab0e4c1c0"

Que deve mostrar seu NFT.

Parabéns!

Considerações finais

Criamos um NFT, mas não é tão útil. Os NFTs na Ethereum também armazenam metadados, como urls para IPFS, que precisamos fazer também se quisermos fazer algo mais útil. Acredito que isso exigiria um script de validação para preservar os metadados, além do script de política de cunhagem.

No entanto, é um começo. Estou muito ocupado construindo minha terceira tentativa em um aplicativo social de consumidor (apenas mais 10 tentativas antes que uma delas funcione), mas posso tentar estender a funcionalidade NFT. As solicitações de puxar (pull request) são bem-vindas.

Artigo escrito por Jonathan Fischoff e traduzido por Marcelo Panegali. A versão original pode ser encontrada aqui.