Théorie

Les contrats intelligents sur Tezos peuvent avoir plusieurs points d'entrée, qui peuvent être considérés comme des méthodes ou des fonctions dans la programmation orientée objet. Chacun de ces points d'entrée peut avoir ses propres paramètres et peut interagir avec le stockage du contrat. Dans notre contrat de calculatrice, chaque opération mathématique sera un point d'entrée.

Il est essentiel de noter que toutes les modifications du stockage sont enregistrées sur la blockchain. Par conséquent, les opérations que nous effectuons ne sont pas transitoires comme elles le seraient dans une calculatrice ordinaire. Il s'agit plutôt d'opérations immuables et vérifiables sur la blockchain Tezos.

Il convient également de rappeler que la blockchain Tezos étant décentralisée, tous les calculs devraient être déterministes. Cela signifie que des opérations telles que la division peuvent fonctionner légèrement différemment de ce à quoi vous êtes habitué. Par exemple, la division dans les contrats Tezos est une division entière, donc 3 divisé par 2 donnerait 1, et non 1,5.

Pratique

Vous trouverez ci-dessous le code du contrat pour le calculateur. Le contrat Calculator enregistre le résultat des opérations dans sa mémoire. Chaque point d'entrée prend un paramètre et effectue l'opération avec le résultat enregistré et le paramètre d'entrée.

Python
import smartpy as sp


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

 @sp.entrypoint
 def multiply(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
 while y * y > x :
 y = (x / y + y) / 2
 assert y * y <= x and x < (y + 1) * (y + 1)
 self.data.result = y @sp.entrypoint
 def factorial(self, x) :
 self.data.result = 1
 for y in range(1, x + 1) :
 self.data.result *= y

 @sp.entrypoint
def log2(self, x) :
 assert x > 0, "L'entrée doit être supérieure à 0"

 self.data.result = 0 # Initialiser le compteur

 if x < 1 : # Pour le 0 < x < 1 intervalle
 y = x
 while y < 1 :
 self.data.result -= 1 # Décrémenter le compteur
 y *= 2 # Multiplier y par 2 jusqu'à ce que y >= 1
 else :  # Pour x >= 1
 y = x
 while y >= 2 :
 self.data.result += 1 # Incrémente le compteur
             y /= 2 # Diviser y par 2


if "templates" not in __name__:

   @sp.add_test(name="Calculateur")
 def test() :
 c1 = main.Calculator()
 scenario = sp.test_scenario(main)
        scénario.h1("Calculateur")
        scenario += 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)
        scenario.verify(c1.data.result == 524)

Mettons ce contrat en œuvre !

Étape 1 : Collez le code du contrat dans l'IDE SmartPy.

Étape 2 : Cliquez sur le bouton Exécuter en haut à droite pour compiler et simuler le contrat.

Étape 3 : Observez les résultats de la simulation dans la partie droite de l'IDE. Vous pouvez voir l'état de la mémoire contractuelle après chaque opération, comme la multiplication, l'addition, la racine carrée, etc.

Étape 4 : N'hésitez pas à modifier les paramètres des opérations et observez les changements dans le stockage des contrats !

Vous avez maintenant construit et interagi avec un contrat intelligent qui effectue des opérations de calcul de base ! Dans la prochaine leçon, nous aborderons des concepts plus avancés tels que la création de contrats FIFO. N'oubliez pas de continuer à explorer, et bon codage !