Teoria

Os contratos inteligentes no Tezos podem ter vários pontos de entrada, que podem ser vistos como métodos ou funções na programação orientada a objetos. Cada um desses pontos de entrada pode ter parâmetros próprios e interagir com o armazenamento do contrato. No nosso contrato de calculadora, cada operação matemática será um ponto de entrada.

É fundamental observar que todas as modificações do armazenamento são registradas no blockchain. Como resultado, as operações que realizamos não são transitórias como seriam em uma calculadora normal. Em vez disso, são operações imutáveis e auditáveis na blockchain Tezos.

Além disso, vale lembrar que como o blockchain Tezos é descentralizado, todos os cálculos devem ser determinísticos. Isso significa que operações como divisão podem funcionar de maneira um pouco diferente do que você está acostumado. Por exemplo, a divisão nos contratos Tezos é uma divisão inteira, então 3 dividido por 2 daria 1, não 1,5.

Prático

Abaixo está o código do contrato da calculadora. O contrato Calculator armazena o resultado das operações em seu armazenamento. Cada ponto de entrada recebe um parâmetro e executa a operação com o resultado armazenado e o parâmetro de entrada.

Python 
 importar smartpy como sp 


 @sp.module 
 def main(): 
 class Calculadora(sp.Contract): 
 def __init__(self): 
 self.data.result = 0 

 @sp.entrypoint 
 def multiplicar(self, x, y): 
 self.data.result = x * y 

 @sp.entrypoint 
 def add(self, x, y): 
 self.data.result = x + y 

 @sp.entrypoint 
 def square(self, x): 
 self.data.result = x * x 

 @sp.entrypoint 
 def squareRoot(self, x): 
 assert x >= 0 
 y = x 
 enquanto y * y > x : 
 y = (x / y + y) / 2 
 assert y * y <= x e x < (y + 1) * (y + 1) 
 self.data.result = y 

 @sp.entrypoint 
 def fatorial(self, x): 
 self.data.result = 1 
 para y no intervalo(1, x + 1): 
 self.data.result *= y 

 @sp.entrypoint 
 def log2(self, x) : 
 assert x > 0, "A entrada deve ser maior que 0" 

 self.data.result = 0 # Inicialize o contador 

 se x < 1: # Para o intervalo 0 < x < 1 
 y = x 
 enquanto y < 1: 
 self.data.result -= 1 # Diminua o contador 
 y *= 2 # Multiplique y por 2 até y >= 1 
 else: # Para x >= 1 
 y = x 
 enquanto y >= 2: 
 self.data.result += 1 # Incrementa o contador 
 y /= 2 # Divida y por 2 


 se "modelos" não estiverem em __name__: 

 @sp.add_test(name="Calculator") 
 def test( ): 
 c1 = main.Calculator() 
 cenário = sp.test_scenario(main)
        cenário.h1("Calculadora")
        cenário += c1 
 c1.multiply(x=2, y=5) 
 c1.add(x=2, y=5) 
 c1.add(x=2, y=5) 
 c1.square(12) 
 c1.squareRoot(0) 
 c1.squareRoot(1234) 
 c1.factorial(100) 
 c1.log2(c1.data.result)
        cenário.verify(c1.data.result == 524)

Vamos colocar esse contrato em ação!

Etapa 1: cole o código do contrato no IDE SmartPy.

Passo 2: Clique no botão Run no canto superior direito para compilar e simular o contrato.

Etapa 3: observe os resultados da simulação no lado direito do IDE. Você pode ver o estado do armazenamento do contrato após cada operação, como multiplicação, adição, raiz quadrada, etc.

Passo 4: Fique à vontade para modificar os parâmetros das operações e observar as alterações no armazenamento do contrato!

Agora você construiu e interagiu com um contrato inteligente que executa operações básicas de calculadora! Na próxima lição, veremos conceitos mais avançados, como a criação de contratos FIFO. Lembre-se de continuar explorando e boa codificação!