Introduction à la blockchain, Tezos et SmartPy

Les bases de la blockchain

Avant de pouvoir comprendre Tezos et SmartPy, nous devons d'abord comprendre la technologie qui est à la base de tout cela : la blockchain. Une blockchain est une chaîne de blocs, chaque bloc contenant une liste de transactions. La technologie Blockchain fournit une base de données décentralisée, ou "registre numérique", des transactions que tous les participants au réseau peuvent consulter. Son architecture garantit que chaque transaction est unique et qu'une fois enregistrée dans une base de données, elle est impossible à modifier.

Introduction à Tezos

Tezos est l'une de ces plateformes de blockchain. Ce qui distingue Tezos de nombreuses autres plateformes de blockchain, telles que Bitcoin ou Ethereum, c'est l'accent mis sur l'"auto-amendement", qui permet au protocole de se mettre à niveau sans avoir besoin d'un hard fork. Il s'agit d'un avantage important, car il rend le protocole adaptable et évolutif.

Tezos propose également une plateforme pour les contrats intelligents, qui sont des contrats auto-exécutoires dont l'accord entre l'acheteur et le vendeur est directement inscrit dans des lignes de code. Cette capacité à gérer et à vérifier les accords numériques offre un large éventail d'applications potentielles, des services financiers aux chaînes d'approvisionnement en passant par les applications décentralisées (DApps). En savoir plus sur Tezos : Qu'est-ce que Tezos ? Tout ce que vous devez savoir sur XTZ

SmartPy : Langage de contrat intelligent pour Tezos

Pour créer des contrats intelligents sur Tezos, nous utilisons un langage appelé SmartPy. SmartPy est une bibliothèque Python permettant de développer des contrats intelligents pour la blockchain Tezos. Il s'agit d'un langage intuitif et efficace pour exprimer les contrats et les scénarios de test associés.

La caractéristique la plus remarquable de SmartPy est son intégration avec Python, qui est l'un des langages de programmation les plus populaires au monde et dont la croissance est la plus rapide. Si vous êtes déjà familier avec Python, vous trouverez SmartPy assez facile à prendre en main.

Démarrer avec SmartPy et votre premier contrat

Accès à l'IDE SmartPy

SmartPy comprend un environnement de développement intégré (IDE) complet, accessible depuis votre navigateur web. Allez dans l'IDE SmartPy pour commencer à écrire votre premier contrat intelligent.

Rédiger votre premier contrat

Dans l'IDE SmartPy, vous trouverez une fenêtre d'édition où vous pouvez saisir votre code de contrat. Commençons par rédiger un contrat de base. Copiez et collez le code suivant dans l'éditeur SmartPy :

Python
import smartpy as sp

# Un module SmartPy
@sp.module
def main() :
   # Une classe de contrats
 classe MyContract(sp.Contract) :
 def __init__(self, myParameter1, myParameter2) :
 self.data.myParameter1 = monParamètre1
 self.data.monParamètre2 = myParameter2

 # Un point d'entrée, c'est-à-dire un récepteur de messages
 # (les contrats réagissent aux messages)
 @sp.entrypoint
 def myEntryPoint(self, params) :
 assert self.data.myParameter1 <= 123
 self.data.myParameter1 += params

Comprendre le contrat

Ce code des contrats comporte plusieurs parties importantes :

• import smartpy as sp - Ceci importe la bibliothèque SmartPy afin que nous puissions l'utiliser pour écrire notre contrat.

• @sp.module - Ce décorateur indique à l'interpréteur SmartPy que cette fonction contiendra un contrat SmartPy.

• classe MonContrat(sp.Contrat) : - Nous définissons ici une nouvelle classe (un modèle pour la création de nouveaux objets) pour notre contrat. Il hérite de la superclasse sp.Contract, qui fournit de nombreuses fonctionnalités utiles pour gérer l'état du contrat et définir son comportement.

• self.data.myParameter1 = myParameter1 et self.data.myParameter2 = myParameter2 - Nous définissons ici l'état initial de notre contrat. Ces deux paramètres seront transmis au contrat lorsqu'il sera déployé sur la blockchain.

• @sp.entrypoint - Ce décorateur indique à l'interprète que la fonction suivante(myEntryPoint) est un point d'entrée de notre contrat. Les points d'entrée sont la manière dont nous interagissons avec notre contrat une fois qu'il a été déployé.

• self.data.myParameter1 += params - Cette ligne de code incrémente myParameter1 du montant transmis à myEntryPoint.

Test du contrat

Une partie essentielle de la rédaction des contrats consiste à les tester minutieusement. Dans SmartPy, les tests sont intégrés au processus de développement. Voici comment vous pouvez ajouter des tests au contrat :

Python
# Tests
@sp.add_test(name="Welcome")
def test() :
   # Nous définissons un scénario de test, ainsi que quelques résultats et vérifications
 # Le scénario prend le module en paramètre
 scenario = sp.test_scenario(main)
    scénario.h1("Welcome")

    # Nous définissons d'abord un contrat et l'ajoutons au scénario
 c1 = main.MyContract(12, 123)
 scenario += c1

 # Et appelons certains de ses points d'entrée
 c1.myEntryPoint(12)
 c1.myEntryPoint(13)
 c1.myEntryPoint(14)
 c1.myEntryPoint(50)
 c1.myEntryPoint(50)
 c1.myEntryPoint(50).run(valid=False)  # on s'attend à ce que cela échoue

 # Enfin, nous vérifions son stockage final
 scenario.verify(c1.data.myParameter1 == 151)

   # Nous pouvons définir un autre contrat en utilisant l'état actuel de c1
 c2 = main.MyContract(1, c1.data.myParameter1)
    scenario += c2
 scenario.verify(c2.data.myParameter2 == 151)

Exécution du contrat et des tests

Votre contrat complet devrait maintenant se présenter comme suit :

Python
import smartpy as sp

# Voici l'éditeur SmartPy.
# Vous pouvez expérimenter SmartPy en chargeant un modèle.
# (dans le menu Commandes au-dessus de cet éditeur)
#
# Un programme SmartPy typique a la forme suivante :


# Un module SmartPy
@sp.module
def main() :
   # Une classe de contrats
 classe MyContract(sp.Contract) :
 def __init__(self, myParameter1, myParameter2) :
 self.data.myParameter1 = monParamètre1
 self.data.monParamètre2 = myParameter2

 # Un point d'entrée, c'est-à-dire un récepteur de messages
 # (les contrats réagissent aux messages)
 @sp.entrypoint
 def myEntryPoint(self, params) :
 assert self.data.myParameter1 <= 123
 self.data.myParameter1 += params


# Tests
@sp.add_test(name="Welcome")
def test() :
   # Nous définissons un scénario de test, ainsi que quelques résultats et vérifications
 # Le scénario prend le module en paramètre
 scenario = sp.test_scenario(main)
    scénario.h1("Welcome")

    # Nous définissons d'abord un contrat et l'ajoutons au scénario
 c1 = main.MyContract(12, 123)
 scenario += c1

 # Et appelons certains de ses points d'entrée
 c1.myEntryPoint(12)
 c1.myEntryPoint(13)
 c1.myEntryPoint(14)
 c1.myEntryPoint(50)
 c1.myEntryPoint(50)
 c1.myEntryPoint(50).run(valid=False)  # on s'attend à ce que cela échoue

 # Enfin, nous vérifions son stockage final
 scenario.verify(c1.data.myParameter1 == 151)

   # Nous pouvons définir un autre contrat en utilisant l'état actuel de c1
 c2 = main.MyContract(1, c1.data.myParameter1)
    scenario += c2
 scenario.verify(c2.data.myParameter2 == 151)

Une fois que vous avez écrit votre contrat et vos tests, vous pouvez les exécuter directement dans l'IDE. Cliquez sur le bouton "Run" dans le coin supérieur droit de l'IDE. L'IDE compilera votre contrat, exécutera les tests et affichera les résultats avec une explication détaillée de chaque opération et changement d'état.

En conclusion, cette leçon vous a présenté la blockchain Tezos et SmartPy, le langage des contrats intelligents pour Tezos. Vous avez également écrit, compris et testé votre premier contrat SmartPy. Ce n'est que le début - il y a tellement plus à apprendre et à faire avec SmartPy et Tezos. Nous espérons que vous serez enthousiaste à l'idée de poursuivre ce voyage avec nous dans les prochaines leçons !