Como escrever contratos inteligentes para Blockchain com Python (parte 2)

Um guia passo a passo para começar

Toda linguagem de computador existente até o hoje compartilha um conjunto comum de construções lógicas. Por mais diferentes que sejam uma da outra, todas elas permitirão aos programadores criar expressões e loops condicionais para executar uma ação com base em alguma avaliação.

Esta é a segunda parte da nossa série de artigos sobre programação de contratos inteligentes de blockchain usando Python e mostrará como usar expressões e loops condicionais na linguagem SmartPy.

Vamos começar abrindo o editor online da SmartPy, apontando nosso navegador para https://smartpy.io/demo

Em seguida, copie e cole o código abaixo (do nosso último artigo) na tela do editor:

import smartpy as sp
class MyClass(sp.Contract):
    def __init__(self):
        self.init(result = 0)
        
    @sp.entry_point
    def myEntryPoint(self, params):
        self.data.result = params.op1 + params.op2        
        
@sp.add_test(name = "teste")
def myTest():
   scenario = sp.test_scenario()
   mySmartContract = MyClass()
   scenario += mySmartContract
   scenario.h3("Meu primeiro contrato inteligente")
   scenario += mySmartContract.myEntryPoint(op1 = 1, op2 = 2)

Antes de começarmos, clique no botão RUN (seta verde), para verificar se tudo está funcionando bem, caso em que você teve ter a seguinte saída na parte direita da tela:

Ótimo! Agora, vamos supor, para fins didáticos, que precisamos adicionar uma regra ao nosso script de soma. Considere que não podemos permitir que o usuário passe zero como um valor de parâmetro ao nosso Contrato Inteligente.

Teremos, portanto, de colocar uma “condição” em nosso código. Na maioria das linguagens de computador, isso seria feito adicionando uma declaração “IF”. Na SmartPy, não é diferente:

@sp.entry_point
    def myEntryPoint(self, params):
        sp.if (params.op1 == 0):
           self.data.result = -1
        sp.else:
           self.data.result = params.op1 + params.op2

O trecho de código acima acrescentou ao nosso entryPoint um teste condicional (com o bloco sp.if-sp.else), o que, simplesmente, verifica se o primeiro parâmetro passado (op1) é igual a zero. Se isso for verdade, o script coloca “-1” na variável de result do storage do contrato e não executa a operação de soma (pois está na instrução “else”).

Copie o código acima e substitua o método “myEntryPoint” no editor. Preste sempre atenção à edentação (que deve ser de 3 ou 4 caracteres ou TAB).

Depois, altere o primeiro parâmetro passado na chamada para “myEntryPoint”, colocando o valor 0. Execute o contrato clicando em RUN. Você deve obter um resultado como este:

Resultado da execução após a introdução do bloco condicional

Agora, altere novamente o parâmetro passado para 1. Execute novamente. Você verá que agora a soma foi feita, porque o código dentro da instrução “else” foi executado.

Outra maneira de checar uma condição é usar a instrução “verify”:

sp.verify(params.op1 != 0)
self.data.result = params.op1 + params.op2

Aqui, temos duas diferenças. Primeiro, observe que, agora, você verifica a condição que deseja garantir verdadeira (op1 ser diferente de zero). Segundo (e mais importante), é que essa instrução “verify” interromperá a execução do script, provocando uma “exceção” (erro).

Copie e cole o código acima no editor (substituindo o bloco sp.if-sp.else). Em seguida, altere o parâmetro op1 para 0. Execute o script. Veja o que você recebe agora:

Checando condições com a instrução “verify”

LOOPs

Em programação de computadores, os loops são repetições da execução de um bloco de código por um determinado número de vezes ou condição conhecida.

Vamos supor que queremos executar 5 vezes uma operação de soma. Precisaremos usar um loop condicional, geralmente conhecido como “for-next” ou “do-while”. Na SmartPy, é assim que fazemos:

sp.for i in sp.range(0, 5):
    self.data.result += params.op1 + params.op2

Coloque o código acima no seu editor e execute o script. Usando op1 = 1 e op2 = 2, você deverá obter “15” como resultado (somará 1 + 2 = 3 e acumulará o resultado 5 vezes = 15):

Usando loops for-next em SmartPy

Outra maneira de fazer um loop condicional é usar a construção “while”:

import smartpy as sp
class MyClass(sp.Contract):
    def __init__(self):
        self.init(result = 0, i = 0)
        
    @sp.entry_point
    def myEntryPoint(self, params):
       sp.while self.data.i <= 30:
          self.data.i += params.op1 + params.op2
    
@sp.add_test(name = "teste")
def myTest():
   scenario = sp.test_scenario()
   mySmartContract = MyClass()
   scenario += mySmartContract
   scenario.h3("Meu primeiro contrato inteligente")
   scenario += mySmartContract.myEntryPoint(op1 = 1, op2 = 2)

Isso criará um loop condicional contendo a operação de soma, até que nossa variável “i” tenha um valor maior que 30. Repare que acrescentamos a variável “i”, sendo inicializada com 0 no construtor da classe. Com isso, teremos o seguinte resultado:

Outra maneira de iterar com loop condicional

E, por hoje, é só! Experimente por si mesmo os diferentes tipos de expressões condicionais mostradas aqui. Não se esqueça de que a prática leva à perfeição.

O objetivo dessas pequenas lições é familiarizá-lo com a IDE da SmartPy e, também, com a sintaxe dos comandos, para que possamos avançar mais no futuro. Também, recomendo fortemente consultar os exemplos que acompanham o editor online, pois representam uma excelente forma de descobrir novidades.

Fique ligado pra não perder a parte 3!