Cardano Plutus - primeiros passos

De Onde vem Plutus?

Quer começar a desenvolver contratos inteligentes usando a blockchain da Cardano? Preparei aqui um guia com um passo-a-passo de como configurar o seu ambiente para rodar Plutus.

A Cardano escolheu Plutus como sua linguagem de programação para criação de contratos inteligentes em "baixo nível". Isso quer dizer que você precisa ter conhecimentos de programação para trabalhar com Plutus. A Cardano também oferece, principalmente para pessoas de finanças, uma alternativa para escrever contratos inteligentes, sem necessariamente precisar saber programar. Essa alternativa se chama Marlowe. Não vamos cobrir a Marlowe nesse artigo. O objetivo aqui é realmente escrever código na linguagem Haskell, que é na verdade a plataforma sobre a qual o Plutus roda.

Haskell é uma linguagem funcional. Outros exemplos de linguagem funcional são Scala, Closure, F#, Elixir, Erlang. Caso você nunca tenha programado com linguagem funcional, sugiro que estude um pouco os conceitos desse tipo de paradigma antes de prosseguir com Plutus. Quem está acostumado com linguagens como JavaScript, Python, C#, Java ou PHP entende mais o paradigma procedural ou orientado a objetos. Como a programação funcional é bem diferente, e Haskell é uma linguagem funcional, isso acaba espantando muita gente do ecossistema da Cardano. Porém, uma vez que você se acostuma e entende o funcional, acaba gostando muito e percebe muitos benefícios. Também não vamos entrar no debate do que é melhor ou pior em termos de paradigma. Apenas queria convidar você a conhecer novas formas de pensar, caso você nunca tenha programado em nenhuma linguagem funcional.

Para saber mais sobre programação funcional e Haskell, dê uma olhada curso Programação Funcional em Haskell dos professores da UFABC. Também tem o Desenvolvimento Orientado a Tipos, um pouco mais avançado, mas também super didático.

Mas se você não quiser olhar nada disso e ir direto para o Plutus, vou tentar aqui pelo menos mostrar o básico, assim já dá pra ter um gostinho de rodar um contrato inteligente na Cardano.

Instalação

1 - Nix

Para instalar o Plutus no seu computador, você vai precisar antes instalar o [nix](https://nixos.org/). O nix é uma espécie de mini sistema operacional que te ajuda a ter um ambiente fácil de configurar. Siga as instruções para instalar esse ambiente. Aqui vou listar os comandos para Mac, meu ambiente, mas no Windows e Linux não é muito diferente.

Rode:

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

Esse instalação demora um certo tempo, mas é bem tranquila. Depois disso, altere a configuração de cache para acelerar a compilação do Plutus. Para isso, edite o arquivo /etc/nix/nix.conf e inclua o seguinte conteúdo:

substituters        = https://hydra.iohk.io https://iohk.cachix.org https://cache.nixos.org/
trusted-public-keys = hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= iohk.cachix.org-1:DpRUyj7h7V830dp/i6Nti+NEO2/nhblbov/8MW7Rqoo= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=

Se tiver dificuldade para fazer isso, aqui tem uma documentação adicional.

Feche o seu terminal e abra um novo, pois depois da instalação o nix só estará disponível nos próximos shells.

2 - Plutus-apps

Vamos instalar e compilar o Plutus. Para isso clone o repositório https://github.com/input-output-hk/plutus-apps:

git clone https://github.com/input-output-hk/plutus-apps

Entramos no diretório do plutus e alteramos para um commit específico. Pode ser que o seu Plutus funcione com outro commit, mas como o Plutus está em constante desenvolvimento, não há garantia de que tudo vai funcionar como esperado, principalmente se estiver usando as versões mais recentes. Para esse tutorial, todos os testes foram feitos usando esse commit específico.

cd plutus-apps
git checkout 41149926c108c71831cfe8d244c83b0ee4bf5c8a

Agora que você está no commit certo e dentro do diretório plutus-apps, rode o nix shell:

~/dev/plutus-apps ((HEAD)$ nix-shell

Já vou logo avisando: na primeira vez que você rodar esse comando, vai demorar uma eternidade. Pra mim demorou 16 horas para baixar e compilar tudo. Então não se preocupe. Vai tirar uma soneca ou dar um rolê de bike pois essa instalação demora mesmo. Importante ter certeza que seu link de Internet não vai cair durante o processo, pois caso isso aconteça, você terá que continuar de onde parou depois.

Caso dê algum erro durante esse processo, tente rodar o comando novamente. Muitas vezes funciona na 2a. ou 3a. tentativa. Caso você esteja usando Mac ou Windows e não funcionar, minha sugestão é usar o VirtualBox e instalar o ubuntu numa máquina virtual. Pra mim isso funcionou perfeitamente.

3 - Compilando um seu primeiro contrato:

Uma vez que você conseguiu rodar o nix-shell, você está prestes a compilar seu primeiro contrato inteligente na Cardano. Para esse tutorial, vamos usar um contrato de exemplo que está no curso Plutus Pioneer Program. De dentro do nix-shell que você acabou de abrir, rode:

[$nix-shell:~/]$ git clone https://github.com/input-output-hk/plutus-pioneer-program
[$nix-shell:~/]$ cd plutus-pioneer-program/code/week01
[$nix-shell:~/plutus-pioneer-program/code/week01]$ cabal build 

Esse comando também vai demorar um certo tempo para rodar. No final você verá algo do tipo:

Installing   plutus-chain-index-core-0.1.0.0 (lib)
Completed    plutus-chain-index-core-0.1.0.0 (lib)
Starting     plutus-contract-0.1.0.0 (lib)
Building     plutus-contract-0.1.0.0 (lib)
Installing   plutus-contract-0.1.0.0 (lib)
Completed    plutus-contract-0.1.0.0 (lib)
Starting     playground-common-0.1.0.0 (lib)
Building     playground-common-0.1.0.0 (lib)
Installing   playground-common-0.1.0.0 (lib)
Completed    playground-common-0.1.0.0 (lib)
Configuring library for plutus-pioneer-program-week01-0.1.0.0..
Preprocessing library for plutus-pioneer-program-week01-0.1.0.0..
Building library for plutus-pioneer-program-week01-0.1.0.0..
[1 of 1] Compiling Week01.EnglishAuction ( src/Week01/EnglishAuction.hs, /home/danicuki/dev/plutus-pioneer-program/code/week01/dist-newstyle/build/x86_64-linux/ghc-8.10.4.20210212/plutus-pioneer-program-week01-0.1.0.0/build/Week01/EnglishAuction.o, /home/danicuki/dev/plutus-pioneer-program/code/week01/dist-newstyle/build/x86_64-linux/ghc-8.10.4.20210212/plutus-pioneer-program-week01-0.1.0.0/build/Week01/EnglishAuction.dyn_o )

src/Week01/EnglishAuction.hs:43:1: warning: [-Wunused-imports]
    The import of ‘IO’ from module ‘Playground.Contract’ is redundant
   |
43 | import           Playground.Contract  (IO, ensureKnownCurrencies, printSchemas, stage, printJson)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Isso significa que tudo funcionou. Para rodar um terminal Plutus, rode cabal repl:

[nix-shell:~/dev/plutus-pioneer-program/code/week01]$ cabal repl
Build profile: -w ghc-8.10.4.20210212 -O1
In order, the following will be built (use -v for more details):
 - plutus-pioneer-program-week01-0.1.0.0 (lib) (ephemeral targets)
Preprocessing library for plutus-pioneer-program-week01-0.1.0.0..
GHCi, version 8.10.4.20210212: https://www.haskell.org/ghc/  :? for help
Ok, one module loaded.
Prelude Week01.EnglishAuction> 

Ao longo do desenvolvimento, você vai precisar consultar a documentação do Plutus. Para compilar e disponibilizar os docs da Plutus no seu ambiente rode (de dentro do diretório plutus-apps):

[nix-shell:~/dev/plutus-apps]$ build-and-serve-docs 
Serving HTTP on 0.0.0.0 port 8002 (http://0.0.0.0:8002/) ...

Para acessar a documentação haddock, entre em http://0.0.0.0:8002/haddock:

4 - Rodando o contrato no plutus-playground

De dentro do nix-shell, entre no diretório plutus-apps/plutus-playground-client e rode:

[nix-shell:~/dev/plutus-apps/plutus-playground-client]$ plutus-playground-server 

Abra um outro terminal com nix-shell, entre no diretório plutus-playground-client/ e execute:

[nix-shell:~/dev/plutus-apps/plutus-playground-client]$ npm start

> [email protected] start /home/danicuki/dev/plutus-apps/plutus-playground-client
> plutus-playground-generate-purs && npm install && npm run install:spago && npm run build:webpack:dev

Quando o build terminar, você pode entrar no navegador no endereço 127.0.0.1:8009 e verá a interface do Plutus Playground

Na interface do Playground, apague o conteúdo do editor e substitua pelo conteúdo do arquivo plutus-pioneer-program/code/week01/src/Week01/EnglishAuction.hs. Não tente entender agora esse código todo. Nós vamos fazer isso nos próximos tutoriais.

Remova as seguintes linhas do código no editor

module Week01.EnglishAuction
    ( Auction (..)
    , StartParams (..), BidParams (..), CloseParams (..)
    , AuctionSchema
    , start, bid, close
    , endpoints
    , schemas
    , ensureKnownCurrencies
    , printJson
    , printSchemas
    , registeredKnownCurrencies
    , stage
    ) where

Pronto. Agora você pode clicar em Compile. Depois de obter a mensagem de Compilation successful, pode clicar em Simulate e começar a simular o uso do contrato.

Se você conseguiu chegar até aqui, sinta-se uma pessoa vitoriosa, uma das poucas no mundo que já conseguiram rodar um contrato inteligente em Plutus.

5 - Simulando o contrato de leilão no Plutus Playground

O contrato que você está simulando implementa uma funcionalidade de leilão. Ele possui três funções: start (para iniciar um novo leilão), bid (para fazer um lance) e close (para encerrar o leilão). Na nossa simulação vamos ter três carteiras:

• Carteira 1 - dona do NFT que vai iniciar o leilão chamando bid
• Carteira 2 - que vai fazer o primeiro lance de 10 ADA (10.000.000 lovelaces)
• Carteira 3 - que vai fazer o segundo lance de 15 ADA (15.000.000 lovelaces.

Crie essas carteiras conforme a imagem abaixo (cada uma contém um saldo inicial de 100 ADA (100.000.000 lovelaces). Além disso, a carteira 1 possui 1 unidade do token T, que representa nosso NFT:

Agora vamos criar as transações. Cada transação deve estar em um slot diferente, o que significa que elas foram feitas sequencialmente no tempo. Para fazer sentido, a transação do lance de 10 ADA deve vir antes do lance de 15 ADA. O leilão deve ter sido criado antes dos lances e a finalização do leilão deve ocorrer ao final de tudo. Preencha as Actions copiando o conteúdo da imagem abaixo:

Os parâmetros são:

• spDeadline: 1596059101999 - momento em POSIX time que o leilão acaba.
• spMinBid: Lance mínimo (10 ADA)
• unCurrencySymbol: Código hexa do Token NFT. No caso, use 66
• unTokenName: Nome do token. Colocamos T
• bpBid: valor do lance (10 ADA e depois 15 ADA)

Não se esqueça de adicionar um tempo de espera de 1 slot entre as ações e esperar até o slot 11 para fechar o leilão. Clique em Evaluate e, caso tudo esteja conforme o planejado, você acabou de rodar seu primeiro contrato inteligente na Cardano.

Confira a execução olhando para o conteúdo da blockchain em cada slot.

Slot 0

Entrada: vazia
Saída: Apenas a criação das carteiras com os devidos saldos - 100 ADAs em cada e 1 token T na carteira 1

Slot 1 - criação do leilão

Entrada: Carteira 1 com 100 ADA e 1 T
Saída:

• Carteira 1 com 100 ADA menos 10 lovelace (taxas) e 2 ADA (valor preso junto ao NFT)
• Taxas 10 lovelaces
• Contrato criado, com 1 T preso no contrato + 2 ADA

Slot 2 - lance da carteira 2

Entrada:

• Carteira 2 com 100 ADA e 0 T
• Contrato com 1 T + 2 ADA presos Saída:
• 8637 taxas
• Carteira 2 com 100 ADA menos 8637 lovelace de taxas e menos 10 ADA pelo lance
• Contrato com 1 T + 12 ADA presos

Slot 3 - lance da carteira 3

Entrada:

• Contrato com 1 T + 12 ADA presos
• Carteira 3 com 100 ADA e 0 T Saída:
• taxas 8637 lovelace
• Carteira 3 com 100 ADA menos 8637 lovelace de taxas e menos 15 ADA pelo lance
• Contrato com 1 T + 17 ADA presos
• Carteira 2 com 100 ADA de volta (já que seu lance foi devolvido)

Slot 11 - fim do leilão

Entrada:

• Contrato com 1 T + 17 ADA presos
• Carteira 1 com ~98 ADA e 0 T Saída:
• taxa 8637 lovelaces
• carteira 1 com ~98 ADA e 0 T
• carteira 1 com 15 ADA (recebendo o valor pago pelo leilão)
• carteira 3 (vencedora do leilão) com 1 T + 2 ADA (recebendo o NFT + os 2 ADAs presos junto com o mesmo)

Pronto! Parabéns! Você conseguiu! Se quiser, pode brincar com outros parâmetros no contrato, criar outras carteiras e simular outros leilões. Dê uma olhada no código em Haskell / Plutus. Não se preocupe se não entender muita coisa pela primeira vez. Navegue pelo código e tente identificar os elementos apresentados na simulação. Aos poucos começará a se familiarizar com a linguagem e conseguirá alterar esse contrato para se comportar de acordo com outras regras que você queira definir.

Por hoje é isso! Se você ainda não é membro da comunidade web3dev, aproveite para se cadastrar no nosso Discord. Lá temos um canal específico de Cardano, onde você poderá tirar suas dúvidas e mostrar o resultado do seu primeiro contrato rodando. Se você conseguiu finalizar esse tutorial, compartilhe um print do seu feito com a gente lá no canal #cardano

Até a próxima!