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 destes pontos de entrada pode ter os seus próprios parâmetros e pode interagir com o armazenamento do contrato. No nosso contrato de calculadora, cada operação matemática será um ponto de entrada.

É crucial notar que todas as modificações do armazenamento são registadas na cadeia de blocos. Como resultado, as operações que realizamos não são transitórias como seriam numa calculadora normal. Em vez disso, são operações imutáveis e auditáveis na cadeia de blocos Tezos.

Além disso, vale a pena lembrar que uma vez que a cadeia de blocos Tezos é descentralizada, todos os cálculos devem ser determinísticos. Isto significa que operações como divisão podem funcionar de forma ligeiramente diferente do que está habituado. Por exemplo, a divisão nos contratos Tezos é divisão inteira, então 3 dividido por 2 daria 1, não 1,5.

Prático

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

Python
importar smartpy como sp


@sp .módulo
def principal ():
 Calculadora de classe (SP.Contract):
 def __init__(self):
 self.data.resultado = 0

 @sp .ponto de entrada
 multiplica def (self, x, y):
 self.data.resultado = x* y

 @sp .ponto de entrada
 def adicionar (self, x, y):
 self.data.resultado = x+ y

 @sp .ponto de entrada
 def quadrado (self, x):
 self.data.resultado = x * x

 @sp .ponto de entrada
 def SquareRoot (self, x):
 afirmar x > = 0
 y = x
 enquanto y* y > x:
 y = (x/ y + y)/2
 afirmar y * y < = x e x < (y+ 1) * (y + 1)
 self.data.resultado = y

 @sp .ponto de entrada
 def fatorial (self, x):
 self.data.resultado = 1
 para y no intervalo (1, x+ 1):
 self.data.resultado *= y

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

 self.data.resulte=0 # Inicializar o contador

 se x < 1: # Para o intervalo 0 < x < 1
 y = x
 enquanto aos < 10:
 self.data.resultado -= 1 # Diminuir o contador
 y *= 2 # Multiplique y por 2 até y > = 1
 caso contrário: # Para x > = 1
 y = x
 enquanto y > = 2:
 self.data.resultado += 1 # Incrementar o contador
 y /= 2 # Divida y por 2


se " os modelos " não estiverem em __name__:

 @sp .add_test (nome= Calculadora) " "
 teste def ():
         c1 = Main.Calculadora ()
 cenário = sp.test_scenario (principal)
        scenario.h1 (Calculadora) " "
        cenário += c1
 c1.multiplicar (x=2, y=5)
 c1.adicionar (x=2, y=5)
 c1.adicionar (x=2, y=5)
 c1.quadrado (12)
 c1.Raíz quadrada (0)
 c1.Raiz quadrada (1234)
 c1.fatorial (100)
 c1.log2 (c1.data.resultado)
        cenário.verify (c1.data.resultado == 524)

Vamos pôr este contrato em ação!

Passo 1: Cole o código do contrato no IDE SmartPy.

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

Passo 3: Observe os resultados da simulação no lado direito do IDE. Pode ver o estado do armazenamento do contrato após cada operação, como multiplicar, adicionar, raiz quadrada, etc

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

Agora 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 a explorar e boa codificação!