Theorie

Intelligente Verträge auf Tezos können mehrere Einstiegspunkte haben, die als Methoden oder Funktionen in der objektorientierten Programmierung angesehen werden können. Jeder dieser Einstiegspunkte kann seine eigenen Parameter haben und mit dem Vertragsspeicher interagieren. In unserem Rechnervertrag ist jede mathematische Operation ein Einstiegspunkt.

Es ist wichtig zu beachten, dass alle Änderungen des Speichers in der Blockchain aufgezeichnet werden. Daher sind die von uns ausgeführten Operationen nicht flüchtig, wie es bei einem normalen Taschenrechner der Fall wäre. Stattdessen handelt es sich um unveränderliche und überprüfbare Vorgänge auf der Tezos-Blockchain.

Außerdem ist zu bedenken, dass alle Berechnungen deterministisch sein sollten, da die Tezos-Blockchain dezentralisiert ist. Das bedeutet, dass Vorgänge wie Divisionen möglicherweise etwas anders funktionieren, als Sie es gewohnt sind. Beispielsweise ist die Division in Tezos-Verträgen eine ganzzahlige Division, sodass 3 dividiert durch 2 1 und nicht 1,5 ergeben würde.

Praktisch

Nachfolgend finden Sie den Vertragscode für den Rechner. Der Calculator Vertrag speichert das Ergebnis der Operationen in seinem Speicher. Jeder Einstiegspunkt übernimmt einen Parameter und führt die Operation mit dem gespeicherten Ergebnis und dem Eingabeparameter aus.

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 quadrat(selbst, x): 
 self.data.result = x * x 

 @sp.entrypoint 
 def quadratRoot(selbst, x): 
 behaupten x >= 0 
 y = x 
 während y * y > x : 
 y = (x / y + y) / 2 
 bestätige y * y <= x und x < (y + 1) * (y + 1) 
 self.data.result = y 

 @sp.entrypoint 
 def factial(self, x): 
 self.data.result = 1 
 für y in range(1, x + 1): 
 self.data.result *= y 

 @sp.entrypoint 
 def log2(self, x) : 
 behaupten x > 0, „Eingabe muss größer als 0 sein“ 

 self.data.result = 0 # Zähler initialisieren 

 wenn x < 1: # Für das Intervall 0 < x < 1 
 y = x 
 while y < 1: 
 self.data.result -= 1 # Zähler dekrementieren 
 y *= 2 # Y mit 2 multiplizieren, bis y >= 1 
 sonst: # Für x >= 1 
 y = x 
 während y >= 2: 
 self.data.result += 1 # Zähler erhöhen 
 y /= 2 # Y durch 2 dividieren 


 if „templates“ not in __name__: 

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

Lassen Sie uns diesen Vertrag in die Tat umsetzen!

Schritt 1: Fügen Sie den Vertragscode in die SmartPy-IDE ein.

Schritt 2: Klicken Sie oben rechts auf die Schaltfläche Run , um den Vertrag zu kompilieren und zu simulieren.

Schritt 3: Beobachten Sie die Simulationsergebnisse auf der rechten Seite der IDE. Sie können den Status des Vertragsspeichers nach jeder Operation sehen, z. B. Multiplikation, Addition, Quadratwurzel usw

Schritt 4: Ändern Sie gerne die Parameter für die Vorgänge und beobachten Sie die Änderungen im Vertragsspeicher!

Sie haben jetzt einen Smart Contract erstellt und mit ihm interagiert, der grundlegende Rechneroperationen ausführt! In der nächsten Lektion werden wir uns mit fortgeschritteneren Konzepten wie der Erstellung von FIFO-Verträgen befassen. Denken Sie daran, weiter zu erkunden und viel Spaß beim Programmieren!