Einführung in Blockchain, Tezos und SmartPy

Blockchain-Grundlagen

Bevor wir Tezos und SmartPy vollständig verstehen können, müssen wir zunächst die Technologie verstehen, die dem Ganzen zugrunde liegt: die Blockchain. Eine Blockchain ist eine Kette von Blöcken, wobei jeder Block eine Liste von Transaktionen enthält. Die Blockchain-Technologie stellt eine dezentrale Datenbank oder ein „digitales Hauptbuch“ von Transaktionen bereit, die alle Netzwerkteilnehmer sehen können. Seine Architektur garantiert, dass jede Transaktion einzigartig ist, und sobald sie in einer Datenbank aufgezeichnet ist, ist eine Änderung nicht mehr möglich.

Einführung in Tezos

Tezos ist eine solche Blockchain-Plattform. Was Tezos von vielen anderen Blockchain-Plattformen wie Bitcoin oder Ethereum unterscheidet, ist die Betonung der „Selbstanpassung“, die es dem Protokoll ermöglicht, sich selbst zu aktualisieren, ohne dass ein Hard Fork erforderlich ist. Dies ist ein erheblicher Vorteil, da es das Protokoll anpassungsfähig und zukunftssicher macht.

Tezos bietet auch eine Plattform für Smart Contracts, bei denen es sich um selbstausführende Verträge handelt, bei denen die Vereinbarung zwischen Käufer und Verkäufer direkt in Codezeilen geschrieben wird. Diese Fähigkeit, digitale Vereinbarungen zu verwalten und zu überprüfen, bietet ein breites Spektrum potenzieller Anwendungen, von Finanzdienstleistungen über Lieferketten bis hin zu dezentralen Anwendungen (DApps). Lesen Sie mehr über Tezos: Was ist Tezos? Alles, was Sie über XTZ wissen müssen

SmartPy: Intelligente Vertragssprache für Tezos

Um Smart Contracts auf Tezos zu erstellen, verwenden wir eine Sprache namens SmartPy. SmartPy ist eine Python-Bibliothek zur Entwicklung intelligenter Verträge für die Tezos-Blockchain. Es handelt sich um eine intuitive und effektive Sprache zum Ausdrücken von Verträgen und den damit verbundenen Testszenarien.

Das bemerkenswerteste Merkmal von SmartPy ist die Integration mit Python, einer der weltweit beliebtesten und am schnellsten wachsenden Programmiersprachen. Wenn Sie bereits mit Python vertraut sind, werden Sie SmartPy recht leicht erlernen können.

Erste Schritte mit SmartPy und Ihrem ersten Vertrag

Zugriff auf die SmartPy-IDE

SmartPy umfasst eine voll funktionsfähige integrierte Entwicklungsumgebung (IDE), auf die Sie über Ihren Webbrowser zugreifen können. Gehen Sie zur SmartPy-IDE , um mit dem Schreiben Ihres ersten Smart-Vertrags zu beginnen.

Schreiben Sie Ihren ersten Vertrag

In der SmartPy-IDE finden Sie ein Bearbeitungsfenster, in dem Sie Ihren Vertragscode eingeben können. Beginnen wir mit dem Verfassen eines Rahmenvertrages. Kopieren Sie den folgenden Code und fügen Sie ihn in den SmartPy-Editor ein:

Python 
 import smartpy as sp 

 # Ein SmartPy-Modul 
 @sp.module 
 def main(): 
 # Eine Klasse von Verträgen 
 class MyContract(sp.Contract): 
 def __init__(self, myParameter1, myParameter2): 
 self.data.myParameter1 = myParameter1 
 self.data.myParameter2 = myParameter2 

 # Ein Einstiegspunkt, also ein Nachrichtenempfänger 
 # (Verträge reagieren auf Nachrichten) 
 @sp.entrypoint 
 def myEntryPoint(self, params): 
 Assert self.data.myParameter1 <= 123 
 self.data.myParameter1 += Parameter

Den Vertrag verstehen

Dieser Vertragskodex besteht aus mehreren wichtigen Teilen:

• import smartpy as sp – Dies importiert die SmartPy-Bibliothek, damit wir sie zum Schreiben unseres Vertrags verwenden können.

• @sp.module – Dieser Dekorator teilt dem SmartPy-Interpreter mit, dass diese Funktion einen SmartPy-Vertrag enthalten wird.

• class MyContract(sp.Contract): – Hier definieren wir eine neue Klasse (eine Blaupause zum Erstellen neuer Objekte) für unseren Vertrag. Sie erbt von der Superklasse sp.Contract , die viele nützliche Funktionen für die Handhabung des Vertragsstatus und die Definition seines Verhaltens bereitstellt.

• self.data.myParameter1 = myParameter1 und self.data.myParameter2 = myParameter2 – Hier definieren wir den Anfangszustand unseres Vertrags. Diese beiden Parameter werden an den Vertrag übergeben, wenn er in der Blockchain bereitgestellt wird.

• @sp.entrypoint – Dieser Dekorator teilt dem Interpreter mit, dass die folgende Funktion (myEntryPoint) ein Einstiegspunkt unseres Vertrags ist. Einstiegspunkte sind die Art und Weise, wie wir mit unserem Vertrag interagieren, sobald er bereitgestellt wurde.

• self.data.myParameter1 += params – Diese Codezeile erhöht myParameter1 um den an myEntryPoint übergebenen Betrag.

Testen des Vertrags

Ein wichtiger Teil der Vertragsgestaltung besteht darin, sie gründlich zu testen. Das Testen in SmartPy ist in den Entwicklungsprozess integriert. So können Sie dem Vertrag Tests hinzufügen:

Python 
 # Tests 
 @sp.add_test(name="Welcome") 
 def test(): 
 # Wir definieren ein Testszenario zusammen mit einigen Ausgaben und Prüfungen 
 # Das Szenario verwendet das Modul als Parameter 
 Szenario = sp .test_scenario(main)
    Szenario.h1("Willkommen")

    # Wir definieren zunächst einen Vertrag und fügen ihn dem Szenario hinzu 
 c1 = main.MyContract(12, 123) 
 Szenario += c1 

 # Und rufen einige seiner Einstiegspunkte auf 
 c1.myEntryPoint(12) 
 c1.myEntryPoint(13) 
 c1.myEntryPoint(14) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50).run(valid=False)  # Es wird erwartet, dass dies fehlschlägt 

 # Schließlich überprüfen wir den endgültigen Speicher 
 Szenario.verify(c1.data.myParameter1 == 151) 

 # Wir können einen anderen Vertrag mit dem aktuellen Status von c1 
 definieren c2 = main.MyContract(1, c1.data.myParameter1)
    Szenario += c2 
 Szenario.verify(c2.data.myParameter2 == 151)

Ausführen des Vertrags und der Tests

Ihr vollständiger Vertrag sollte jetzt wie folgt aussehen:

Python 
 Smartpy als SP 

 importieren # Dies ist der SmartPy-Editor.
# Sie können mit SmartPy experimentieren, indem Sie eine Vorlage laden.
# (im Befehlsmenü über diesem Editor) 
 # 
 # Ein typisches SmartPy-Programm hat die folgende Form: 


 # Ein SmartPy-Modul 
 @sp.module 
 def main(): 
 # Eine Klasse von Verträgen 
 class MyContract(sp .Contract): 
 def __init__(self, myParameter1, myParameter2): 
 self.data.myParameter1 = myParameter1 
 self.data.myParameter2 = myParameter2 

 # Ein Einstiegspunkt, also ein Nachrichtenempfänger 
 # (Verträge reagieren auf Nachrichten) 
 @sp.entrypoint 
 def myEntryPoint(self, params): 
 Assert self.data.myParameter1 <= 123 
 self.data.myParameter1 += params 


 # Tests 
 @sp.add_test(name="Welcome") 
 def test(): 
 # Wir definieren ein Testszenario zusammen mit einigen Ausgaben und Prüfungen 
 # Das Szenario verwendet das Modul als Parameter- 
 Szenario = sp.test_scenario(main)
    Szenario.h1("Willkommen")

    # Wir definieren zunächst einen Vertrag und fügen ihn dem Szenario hinzu 
 c1 = main.MyContract(12, 123) 
 Szenario += c1 

 # Und rufen einige seiner Einstiegspunkte auf 
 c1.myEntryPoint(12) 
 c1.myEntryPoint(13) 
 c1.myEntryPoint(14) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50).run(valid=False)  # Es wird erwartet, dass dies fehlschlägt 

 # Schließlich überprüfen wir den endgültigen Speicher 
 Szenario.verify(c1.data.myParameter1 == 151) 

 # Wir können einen anderen Vertrag definieren, indem wir den aktuellen Status von c1 
 c2 = main.MyContract(1, c1.data.myParameter1) 
 verwenden
    Szenario += c2 
 Szenario.verify(c2.data.myParameter2 == 151)

Sobald Sie Ihren Vertrag und Ihre Tests geschrieben haben, können Sie diese direkt in der IDE ausführen. Klicken Sie auf die Schaltfläche „Ausführen“ in der oberen rechten Ecke der IDE. Die IDE kompiliert Ihren Vertrag, führt die Tests durch und zeigt die Ausgabe zusammen mit einer detaillierten Erläuterung jedes Vorgangs und jeder Statusänderung an.

Abschließend hat Ihnen diese Lektion die Tezos-Blockchain und SmartPy, die intelligente Vertragssprache für Tezos, vorgestellt. Sie haben auch Ihren ersten SmartPy-Vertrag geschrieben, verstanden und getestet. Das ist erst der Anfang – mit SmartPy und Tezos gibt es noch viel mehr zu lernen und zu tun. Wir hoffen, dass Sie sich darauf freuen, diese Reise in den kommenden Lektionen mit uns fortzusetzen!