Teoría

Los contratos inteligentes en Tezos pueden tener múltiples puntos de entrada, que pueden verse como métodos o funciones en la programación orientada a objetos. Cada uno de estos puntos de entrada puede tener sus propios parámetros y puede interactuar con el almacenamiento del contrato. En nuestro contrato de calculadora, cada operación matemática será un punto de entrada.

Es fundamental tener en cuenta que todas las modificaciones del almacenamiento se registran en la cadena de bloques. Como resultado, las operaciones que realizamos no son transitorias como lo serían en una calculadora normal. En cambio, son operaciones inmutables y auditables en la cadena de bloques de Tezos.

Además, vale la pena recordar que, dado que la cadena de bloques de Tezos está descentralizada, todos los cálculos deben ser deterministas. Esto significa que operaciones como la división pueden funcionar de manera ligeramente diferente a lo que estás acostumbrado. Por ejemplo, la división en los contratos de Tezos es una división entera, por lo que 3 dividido por 2 daría 1, no 1,5.

Práctico

A continuación se muestra el código de contrato de la calculadora. El contrato Calculator almacena el resultado de las operaciones en su almacenamiento. Cada punto de entrada toma un parámetro y realiza la operación con el resultado almacenado y el parámetro de entrada.

Python 
 importa smartpy como sp 


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

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

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

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

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

 @sp.entrypoint 
 def factorial(self, x): 
 self.data.result = 1 
 para y en el rango(1, x + 1): 
 self.data.result *= y 

 @sp.entrypoint 
 def log2(self, x) : 
 afirmar x > 0, "La entrada debe ser mayor que 0" 

 self.data.result = 0 # Inicializa el contador 

 si x < 1: # Para el intervalo 0 < x < 1 
 y = x 
 mientras y < 1: 
 self.data.result -= 1 # Disminuye el contador 
 y *= 2 # Multiplica y por 2 hasta y >= 1 
 else: # Para x >= 1 
 y = x 
 mientras y >= 2: 
 self.data.result += 1 # Incrementar el contador 
 y /= 2 # Dividir y por 2 


 si "plantillas" no están en __name__: 

 @sp.add_test(name="Calculadora") 
 def test( ): 
 c1 = main.Calculator() 
 escenario = sp.test_scenario(principal)
        escenario.h1("Calculadora")
        escenario += c1 
 c1.multiplicar(x=2, y=5) 
 c1.add(x=2, y=5) 
 c1.add(x=2, y=5) 
 c1.cuadrado(12) 
 c1.squareRoot(0) 
 c1.squareRoot(1234) 
 c1.factorial(100) 
 c1.log2(c1.data.result)
        escenario.verify(c1.data.resultado == 524)

¡Pongamos este contrato en acción!

Paso 1: pegue el código del contrato en el IDE de SmartPy.

Paso 2: haga clic en el botón Run en la esquina superior derecha para compilar y simular el contrato.

Paso 3: observe los resultados de la simulación en el lado derecho del IDE. Puede ver el estado del almacenamiento del contrato después de cada operación, como multiplicar, sumar, raíz cuadrada, etc.

Paso 4: ¡Siéntete libre de modificar los parámetros de las operaciones y observar los cambios en el almacenamiento del contrato!

¡Ahora ha creado e interactuado con un contrato inteligente que realiza operaciones básicas de calculadora! En la próxima lección, veremos conceptos más avanzados como la creación de contratos FIFO. ¡Recuerda seguir explorando y feliz codificación!