ūüáßūüá∑ Tutorial Marlowe 6/14

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.

Um primeiro contrato Marlowe

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.

2 Likes