Para acompanhar essa série de conteúdos fique de olho no blog Educação Cardano
Conteúdo original no site https://alpha.marlowe.iohkdev.io/tutorial/
6. Marlowe e Blockly
Até agora, nesses tutoriais, nos concentramos na criação de contratos na versão textual do Marlowe, incorporada em Haskell. Os contratos da Marlowe também podem ser construídos usando o ambiente de programação visual Blockly, conforme descrito nesta série de vídeos.
Introdução ao Playground Marlowe
Transcrição:
Olá, eu sou Simon Thompson, o líder do time Marlowe na IOHK. O que eu quero fazer é aqui mostrar vocês através do Playground Marlowe, que é a ferramenta baseada em browser para construir e interagir com os contratos Marlowe. Ao abrir o Playground, você vai encontrar um de três painéis.
Você pode abrir o painel de simulação, e é aqui que você pode, uma vez escrito um contrato, interagir com ele, percorrer através dele interativamente, seja executando etapas, desfazendo-as, tomando outras escolhas, de forma que você consiga explorar como o contrato se comporta. Através desse painel também é possível realizar análises, de forma que simbolicamente possamos percorrer todas as possíveis entradas para o contrato e verificar que possui certas propriedades. Nós queremos ter a certeza, por exemplo, que o contrato nunca falha em realizar um pagamento, quando deveria. Sendo assim, o painel de simulação é o ambiente onde podemos explorar os contratos, uma vez que os tenhamos escrito. Mas ainda duas maneiras que fornecemos, ou três maneiras, sendo assim duas maneiras extras de escrever um contrato. No próprio painel de simulação você pode escrever um contrato Marlowe. E esse é o contrato que vamos simular.
Se você clicar no segundo painel, o editor de tarefas, o que é possível fazer é construir um contrato, utilizando as ferramentas de Haskell, na aba superior há uma seleção de contratos exemplo. E o que fizemos aqui foi construir um contrato a partir do tipo Haskell Contract, e isso é uma maneira mais legível de escrever um contrato. Dessa forma é possível realizar essa tarefa com Haskell, e em seguida apertar o botão de compilar, que irá transformar o código em Marlowe e será possível enviar o resultado dessa compilação para o simulador. Assim, podemos construir os contratos usando Haskell e depois simulá-los.
Eu vou falar de mais detalhes do simulador quando construirmos alguns exemplos, mas para falar sobre mais coisas que existem nesse painel. Mas uma vez temos exemplos que podem ser carregados, é o possível no canto superior direito transformar o contrato em seu formato visual em Blockly. Podemos salvar o contrato no GitHub, no lado direito é possível criar inputs para as transações e ver os resultados da execução de etapas dessa simulação.
Uma coisa importante a se ressaltar é que no canto inferior esquerdo há links para o tutorial. Esse tutorial dá uma visão geral do Marlowe em grande detalhe.
A terceira forma de criar contratos é através do Playground. É possível ver um exemplo de um contrato já escrito que foi transformado em um formato visual. Em seguida vamos ver como é possível construir um contrato dessa maneira do zero sem ter que pensar em programar. É isso que vamos fazer em seguida.
Transcrição:
Nesse vídeo eu gostaria de mostrar a vocês como construir contratos, dentro do editor Blockly. Vamos começar, vocês podem ver que estamos na aba Blockly e esse é o lugar onde colocamos os contratos. No aba do lado esquerdo é possível ver uma lista dos vários componentes dos contratos. Ao clicar em contratos é possível ver modelos para os vários tipos de contratos. Se clicarmos em um deles e arrastarmos para a área de trabalho é possível ver que estamos trabalhando com um tipo de contrato de pagamento. É possível encaixar esse modelo para o contrato.
Agora, o que devemos fazer para completar essa tarefa é preencher os espaços, quais sejam: quem será pago, o quanto será pago, em que moeda e a partir de quem será pago (a partir de um número de conta).
Vamos ver como preencher esses espaços. O primeiro espaço requer uma parte de contrato então vamos preenche-lo com uma parte. Primeiro encaixando um bloco de recebedor do pagamento e dentro desse bloco encaixando um bloco de papel, e a pessoa a cumprir esse papel será Bob. Vamos pagar Bob com um valor de constante 1. Devemos também informar que moeda será usada para o pagamento de Bob, é possível utilizar uma moeda customizada, mas nesse caso vamos apenas usar ADA.
Conta 1, com a dona Alice, vai ser uma parte do contrato, e nessa parte vamos preencher com Alice. Nesse momento temos um contrato que vai pagar 1 ADA a Bob a partir da conta de Alice, temos que dizer então o que o contrato deve fazer em seguida.
Para escolher o que fazer em seguida devemos escolher outro contrato, vamos dar uma olhada nos contratos que temos disponíveis. Temos os contratos de escolha; contratos condicionais, onde podemos esperar alguém tomar uma ação; o mais simples a se fazer é utilizar um contrato de Close para encerrar. Então vamos fazer isso. Ao fechar isso temos um contrato completo que realiza um único pagamento.
Agora podemos clicar no canto superior esquerdo e converter esse contrato pra código, dessa forma podemos ver que o contrato é refatorado em Marlowe na aba de simulação. O que temos aqui é o contrato mais simples possível que é o de um pagamento, de fato esse contrato não esperar por nenhum compositor de entradas, ao simplesmente clicar em aplicar o contrato o pagamento será efetuado.
Ao fazer isso nós recebemos um alerta que o contrato deveria fazer um pagamento mas não conseguiu concluí-lo. Então vamos desfazer essa ação. Podemos também ver na barra inferior na aba de análise estática como é possível analisar esse contrato, e assim verificar que temos um alerta mesmo sem executar o contrato. Em outros casos é possível analisar e percorrer o caminho do contrato.
Para sintetizar o que fizemos aqui: construímos um simples contrato utilizando Blockly, convertemos em código e simulamos suas ações, além de analisar o seu comportamento. Vamos parar por aqui e o que faremos em seguida é pegar nosso contrato simples estendê-lo com outros construtores.
Aprimorando o contrato de pagamentos
Transcrição:
Vamos continuar de onde paramos, construímos um simples contrato que realiza um pagamento. O que gostaríamos de fazer agora é aprimorar esse contrato de algumas maneiras. Vamos aprimorá-lo para ter certeza que há dinheiro no contrato para realizar o pagamento. Vamos ver os tipos de coisas que podemos fazer editando no Blockly. Vamos pegar esse contrato e fazer com que ele não seja mais o contrato principal.
Vamos adicionar um outro construtor de alto nível, vamos utilizar um construtor do tipo When (quando). Com o construtor do tipo When temos que pensar em uma ação, pela qual vamos aguardar, nesse caso vamos esperar pela ação de depósito. E que tipo de depósito queremos? Nesse caso queremos um depósito feito por Alice. Isso é uma coisa interessante que podemos fazer no Playground, podemos simplesmente copiar e colar qualquer um desses itens e reutilizá-los em outros lugares no nosso contrato. Podemos copiar Alice, podemos copiar a quantidade, a moeda.
Vamos dizer que queremos que Alice deposite 2 ada e ela vai depositar esse valor na sua conta 1, vamos mudar isso. E o dono da conta, copiando e colando, podemos usar Alice. Ou seja, o que queremos aqui é um depósito feito por Alice e a partir daí continuamos o nosso contrato. O contrato espera por um depósito, e uma vez que o depósito é realizado o contrato continua para executar um pagamento, e por fim continua em Close.
Mas o que acontece se Alice não realiza o depósito? Precisamos pensar em incluir um timeout no contrato. Vamos dizer que depois do slot 10, vamos seguir um contrato alternativo. Novamente copiando e colando vamos utilizar o contrato Close para encerrar. Lendo do topo mais uma vez nós esperamos por um depósito, depois fazemos um pagamento e fechamos, no caso do depósito não ser feito após 10 slots o contrato se encerra.
Refatorando isso para código podemos ver que a versão em texto aparece na janela do browser e podemos então simular esse contrato. Olhando no lado direito da tela, podemos ver o compositor de entradas. Nessa situação a única entrada viável é para que Alice deposite 2 unidades de ada. Vamos fazer isso. Podemos ter múltiplas entradas em uma transação, mas vamos aplicar essa entrada. Você verá então que todo o contrato foi executado e o pagamento de Alice para Bob foi feito. Podemos desfazer isso e voltar para o início.
Nesse caso não temos alternativas então vamos deixar as coisas como estão. Nesse vídeo utilizamos outros construtores como o When e o Pay. Temos vários outros construtores que podemos usar como ações, partes (pessoas envolvidas no contrato) e token (por padrão usamos ada, mas outros tokens podem ser utilizados).
No último vídeo vamos dar uma olhada no nosso contrato final.
Um terceiro contrato: adicionando escolhas e observações
Transcrição:
No vídeo final dessa série vamos dar uma olhada mais atenta nas observações e nas escolhas. O que vamos fazer é modificar o contrato que trabalhamos até agora para fazer mais uma coisa. No momento o contrato aguarda por um depósito e em seguida faz um pagamento. Ao invés disso vamos realizar uma escolha e baseado nessa escolha iremos ou realizar um pagamento a Bob ou a Alice. Após duplicar o bloco temos na parte de cima um pagamento de Alice para Bob e na parte de baixo um pagamento de Alice para Alice.
O que vamos é colocar ambos os blocos no If (Se). Além de esperar por um depósito vamos esperar por uma segunda ação e essa ação vai ser uma escolha “a ou b”, e o dono dessa escolha será Carol. E os limites da escolha serão entre 1 e 2. Nesse caso o contrato se transforma em uma sequência de primeiro fazer um depósito em seguida fazer uma escolha que se desenvolve em duas diferentes ações.
Temos que decidir a observação. Podemos dizer que a observação se baseia no valor da escolha. Também determinamos que se uma escolha não for feita teremos o valor padrão de 0. Dessa forma, se a escolha de “a ou b” for maior ou igual a 2 Bob é pago, caso contrário Alice é paga. A última coisa que falta é o período limite para realizar a escolha, podemos limitar até o slot 20. Finalmente iremos refatorar em código e simular esse contrato.
Você verá que ao aplicar o depósito de Alice o contrato na janela principal irá mudar para refletir essa ação. E agora aplicamos a escolha, uma escolha de 1 significa que pagamento será feito de volta a Alice. Se desfizermos essa ação e fizermos uma escolha de 2 veremos que o dinheiro irá para Bob.
Vamos voltar ao Blockly para concluir. Nesse exemplo utilizamos o When, utilizamos o If. Observações são coisas que são determinadas a partir de valores, que podem ser saldos de contas, constantes, escolhas (como visto no exemplo), podem ser o intervalo de slots que nos encontramos.
Actions (ações) são impactos no contrato a partir no mundo externo. Payees e Partes se combinam, partes podem ser representados por uma chave pública ou um papel mais abstrato. Tokens podem ser ada ou outras moedas customizadas providas por Plutus. E Bounds (limites) podem limitar um número finito de escolhas que podem ser feitas.
Essa série de vídeos cobriu a maioria dos construtores utilizados em Marlowe. Podemos colapsar ou expandir, podemos deletar todo o conteúdo, ou ainda copiar e colar. Essa ferramenta nos dá uma forma intuitiva de desenhar contratos Marlowe que depois podem ser simuladas.