L'article Créer une application Blockchain avec Plutus est apparu en premier sur Coinpedia Fintech News

Introduction

La blockchain contribue à divers secteurs grâce à ses solutions décentralisées et transparentes. Les avancées dans le domaine du développement ont eu un impact transformateur sur les développeurs et les communautés. Les avantages de la blockchain vont au-delà de la décentralisation. Elle permet de gagner du temps pour la transaction et ne nécessite aucune vérification par un tiers, ce qui réduit les risques de fraude et de cyberattaque. En tant que développeur, il est précieux de comprendre comment créer des applications blockchain, en particulier lorsque vous utilisez des outils puissants comme Plutus. Plutus est une plateforme de contrats intelligents sur la blockchain Cardano. Elle offre un cadre robuste aux développeurs pour créer des applications décentralisées (DApps) sécurisées et efficaces.

Qu'est-ce que Cardano ?

Cardano Une plateforme blockchain lancée par Charles Hoskinson (co-fondateur d'Ethereum) en 2017. Cardano est une plateforme de troisième génération, souvent considérée comme une alternative à Ethereum, une plateforme de deuxième génération. Elle utilise un mécanisme de preuve d'enjeu plus efficace que les mécanismes traditionnels. Cardano possède sa propre crypto-monnaie ADA, nommée d'après Ada Lovelace. Elle comporte deux couches distinctes, l'une qui gère les transactions et les comptes tandis que l'autre est utilisée pour gérer les contrats intelligents et les calculs. Cardano vise à créer une plateforme blockchain plus sécurisée, évolutive et adaptable que ses prédécesseurs et est utilisée dans diverses applications, notamment la gestion de la chaîne d'approvisionnement, la vérification de l'identité numérique et les services financiers sur les marchés émergents

Pluton

Plutus est un langage de programmation utilisé pour écrire des contrats intelligents basés sur Cardano. Plutus est basé sur Haskell qui est un langage fonctionnel. En tant que développeur, vous n'avez pas besoin d'écrire le noyau Plutus, tous les scripts seront générés par un plugin de compilateur Haskell. Plutus prend en charge la vérification formelle qui fournit un moyen de prouver l'exactitude d'un programme à l'aide de mathématiques. Cela améliore ainsi la sécurité et réduit la probabilité de bugs dans le contrat intelligent.

Plutus est intégré de manière native à la blockchain Cardano, ce qui permet aux développeurs d’interagir directement avec le registre et l’infrastructure de Cardano. Cela vous aide à créer et à déployer les contrats intelligents qui interagissent directement avec l’écosystème Cardano. Plutus dispose d’outils qui vous aident à simuler les contrats intelligents sans le nœud Cardano complet et à les expérimenter avant de les déployer sur le réseau principal. Plutus est particulièrement adapté aux développeurs qui cherchent à créer des applications décentralisées fiables et performantes.

Public

Cet article s'adresse aux développeurs novices en matière de développement de blockchain et possédant peu de connaissances en programmation de base. Nous vous guiderons à travers les étapes essentielles de la configuration de votre environnement, de la compréhension des concepts de blockchain et de la création d'une application blockchain simple à l'aide de Plutus.

Configuration de l'environnement de développement

Il est essentiel de disposer d'une configuration parfaite avant de démarrer le développement. La mise en place d'un environnement prenant en charge Plutus est donc la première étape de ce chapitre.

1. Installation de Plutus

Téléchargez Plutus depuis le dépôt officiel :

git clone https://github.com/input-output-hk/plutus-apps.gitcd plutus-appsnix-shell

Vérifiez l'installation en utilisant : plutus -v

2. Choisir un IDE

Lors du développement d'applications avec Plutus, il est essentiel de disposer du bon IDE. Plutus est basé sur Haskell, il est donc recommandé d'avoir un IDE prenant en charge Haskell. Deux options populaires pour le développement de Plutus sont Visual Studio Code (VS Code) et Plutus Playground. Voici un guide détaillé sur la façon de configurer et d'utiliser ces IDE pour le développement de Plutus.

Visual Studio Code : VS Code est un éditeur de code très flexible et polyvalent qui prend en charge presque tous les langages et dispose d'extensions très utiles. C'est donc l'éditeur préféré des développeurs. VSCode est open source et fournit une large gamme d'outils et de fonctionnalités pour compléter le code.

Étapes pour configurer VSCode :

  • Téléchargez VSCode depuis le site officiel (selon votre système d'exploitation)

  • Installer le logiciel

  • Plutus est construit sur Haskell, vous devez donc installer la plate-forme Haskell, qui inclut le compilateur Glasgow Haskell (GHC) et cabal (un outil de construction pour Haskell).

  • Télécharger Haskell

  • Installer les extensions Haskell dans VS Code (Haskero, Haskell Syntax Higlighting, etc.)

  • Configurer les extensions et installer des extensions supplémentaires

  • Puisque vous avez déjà installé Plutus, vous êtes prêt à partir !

Plutus Playground : Plutus Playground est un éditeur Web en ligne spécialement conçu pour les contrats intelligents Plutus. Il n'y a donc aucune installation nécessaire et est parfait pour les débutants pour gagner en confiance lors du codage.

Vous pouvez visiter le site Web de Plutus Playground et commencer !!

Les deux environnements peuvent être utilisés efficacement pour le développement de Plutus, et vous constaterez peut-être que la combinaison des deux (utilisation de VS Code pour les projets plus importants et de Plutus Playground pour les tests et le prototypage rapides) offre le meilleur des deux mondes.

3. Installation des bibliothèques requises

Utilisez cabal pour installer les bibliothèques essentielles au développement de Plutus.

Comprendre les concepts de la blockchain avec Plutus

La blockchain est une base de données distribuée et avancée qui stocke les enregistrements de transactions sous forme de blocs. Chacun des blocs doit être lié aux autres à l'aide de principes cryptographiques. Des mécanismes robustes sont utilisés pour protéger les blocs, ce qui permet de ne pas modifier les enregistrements des devises avant l'heure et sans affecter les blocs suivants.

La blockchain comporte trois composants de base :

  • Blocs : les blocs contiennent des informations sur les transactions ainsi que des métadonnées. Tous les blocs sont liés les uns aux autres par hachage qui forme une chaîne de blocs, d'où le terme blockchain.

  • Transactions : Une transaction est un transfert de données d'une entité à une autre au sein de la blockchain. Dans Plutus, les transactions sont écrites en Haskell et impliquent des UTXO (Unspent Transaction Outputs) d'entrée et de sortie.

  • Chaînes : Dans Plutus, la chaîne maintient l'ordre des transactions et garantit qu'elles sont immuables une fois confirmées.

Dans l'extrait de code suivant, nous pouvons voir la structure du bloc dans Plutus :

Chaque composant du bloc est mentionné avec son type de données

  • L'index est un entier qui indique la position d'un bloc

  • L'horodatage est l'heure à laquelle le bloc a été créé

  • Les transactions sont la chaîne ou une liste de toutes les transactions incluses dans un bloc particulier

  • Le hachage est un modèle unique et la clé principale pour identifier un bloc

  • Le hachage précédent fait référence à la continuité et est le hachage du dernier bloc

Dans cet extrait de code, nous pouvons voir la structure des transactions dans Plutus :

Décentralisation, immuabilité et mécanismes de consensus :

La base de la blockchain repose sur trois principes fondamentaux : la décentralisation, l'immuabilité et le mécanisme de consensus.

Décentralisation : La décentralisation est une propriété par laquelle aucune entité ne détient le contrôle de la base de données de la blockchain, ce qui rend l'échec du système et la partialité presque impossibles. Chaque appareil participant (nœud) conserve une copie de la blockchain, garantissant la transparence et empêchant toute défaillance ou manipulation centralisée.

Immuabilité : une fois que les données sont écrites dans une blockchain, elles ne peuvent pas être modifiées sans altérer tous les blocs suivants. Cela se fait à l'aide du hachage cryptographique. Par conséquent, toutes les modifications effectuées une fois ne peuvent pas être annulées, ce qui les rend immuables.

Mécanisme de consensus : ensemble de protocoles régissant tous les besoins de la blockchain. Tous les nœuds du réseau doivent se mettre d'accord sur les méthodes. Les mécanismes de consensus sont utilisés pour rationaliser les nœuds et garantir que tous les nœuds du réseau sont sur la même longueur d'onde.

Construire une Blockchain simple avec Plutus

Le bloc est l'unité primitive de toute blockchain. Dans cet extrait de code, nous avons défini un type de données de bloc ainsi que ses composants.

De plus, après avoir défini la classe de bloc, nous devons garantir l'intégrité de la blockchain où chaque bloc doit avoir un hachage unique. Par conséquent, avec la fonction de calcul de hachage, nous utilisons la méthode de hachage populaire SHA256 pour la même chose dans Plutus.

Une fois que vous avez terminé la définition d’un bloc, allez-y et initialisez votre blockchain à l’aide d’un bloc de genèse qui est le premier bloc de toute blockchain. Waouh !! Vous venez de créer une blockchain mais ce n’est pas tout, vous devez ajouter de nouveaux blocs et récupérer également le dernier bloc.

N'hésitez pas à vous référer au code ci-dessous au cas où vous auriez besoin d'aide !

Mise en œuvre des mécanismes de consensus dans Plutus

Cardano utilise le mécanisme PoS alors qu'au début, il avait adopté la preuve de travail. Plutus est conçu pour être compatible avec le protocole Ouroboros PoS de Cardano, offrant évolutivité, efficacité énergétique et sécurité pour les applications décentralisées (DApps).

Voici un aperçu des algorithmes de consensus qui peuvent fonctionner avec Plutus

  • Ouroboros : Ouroboros est un mécanisme de preuve d'enjeu avec lequel Plutus est hautement compatible et qui dépend de l'enjeu de l'ADA que les validateurs sont prêts à prendre pour valider un nouveau bloc. Les contrats Plutus interagissent de manière transparente avec le protocole Ouroboros, garantissant que l'exécution des contrats intelligents reste sécurisée et économe en énergie.

  • Preuve de travail : la preuve de travail est le mécanisme le plus ancien et a été largement utilisé dans toutes les anciennes crypto-monnaies. Elle peut toujours être mise en œuvre sur papier dans le cas de Plutus. Cela serait plus utile pour réfléchir à des scénarios isolés comme des objectifs éducatifs et expérimentaux.

  • Preuve de travail déléguée et tolérance aux pannes byzantines : ces mécanismes ne sont pas particulièrement compatibles avec Cardano mais peuvent néanmoins être théoriquement implémentés sur Plutus.

Dans cette section, nous allons explorer comment utiliser la preuve de travail dans Plutus.

Dans la preuve de travail, les mineurs doivent rivaliser de temps pour résoudre un casse-tête cryptographique afin de devenir validateurs de la nouvelle cryptomonnaie. Dans ce code, la fonction de preuve de travail recherche un nonce qui, lorsqu'il est combiné avec le hachage du bloc précédent, produit un hachage avec un certain nombre de zéros non significatifs. Il s'agit d'une implémentation de base de la preuve de travail, où le niveau de difficulté détermine la difficulté de trouver un nonce valide.

Une fois l’implémentation de la preuve de travail terminée, vous devez mettre à jour la blockchain pour valider la preuve qui a été extraite.

Voici l'extrait de code d'exemple :

Cette fonction garantit qu’un nouveau bloc n’est ajouté à la blockchain que si sa preuve est valide, préservant ainsi l’intégrité de la chaîne.

Créer une API Blockchain simple avec Plutus

Dans ce chapitre, vous apprendrez à créer une API simple pour interagir avec une application blockchain créée à l'aide de Plutus. Cette API vous permettra d'ajouter des blocs et de visualiser la blockchain via des requêtes HTTP.

Étapes pour créer une API :

  • Configurer l'environnement pour l'API : installer Haskel (ce qui est déjà fait), puis installer Servant à l'aide de Cabal

  • Téléchargez toutes les bibliothèques requises :

    • Serviteur : Pour créer l'API

    • Aeson pour encoder et décoder le JSON : cabal install aeson plutus-core

    • Plutus pour intégrer tout le code et la logique

Pour commencer à créer l'API, nous devons d'abord ajouter un nouveau bloc et supprimer l'état actuel de la blockchain. Ces deux étapes ont été réalisées dans les chapitres ci-dessus.

Vous pouvez maintenant continuer et définir les points de terminaison :

{-# LANGUAGE DataKinds #-}{-# LANGUAGE TypeOperators #-}module BlockchainAPI whereimport Servantimport Control.Monad.IO.Class (liftIO)— Définir le type de bloc (se reporter au chapitre 3)data Block = Block  { index        :: Int  , timestamp    :: String  , dataField    :: String  , previousHash :: String  , hash         :: String  } deriving (Show, Eq)— Blockchain est simplement une liste de blocstype Blockchain = [Block]— Définir le type d'APItype BlockchainAPI = “addBlock” :> ReqBody ‘[JSON] Block :> Post ‘[JSON] Blockchain:<|> “chain” :> Get ‘[JSON] Blockchain— Espace réservé pour la blockchain, commençant initialement par juste le bloc genesisgenesisBlock = Block 0 « 2024-09-12 00:00:00 » « Genesis Block » « 0 » « some_hash » initialBlockchain:: BlockchaininitialBlockchain = [genesisBlock]–– Gestionnaires pour les points de terminaison de l'APIaddBlockHandler :: Blockchain -> Block -> Handler BlockchainaddBlockHandler blockchain newBlock = dolet newBlockchain = blockchain ++ [newBlock]    liftIO $ putStrLn « Bloc ajouté ! »     return newBlockchain— Gestionnaire pour récupérer la chaîneviewChainHandler :: Blockchain -> Handler BlockchainviewChainHandler blockchain = return blockchain–Point d'entrée principal pour exécuter l'APIapp :: Applicationapp = serve (Proxy :: Proxy BlockchainAPI) (blockchainServer initialBlockchain)

Explication du code ci-dessus :

  • Le bloc est défini de manière similaire aux chapitres précédents

  • La bibliothèque Servant est utilisée pour définir la structure de l'API. Il existe deux méthodes pour définir les points de terminaison de l'API, GET et POST, qui signifient respectivement récupérer et ajouter la blockchain.

  • Nous avons également défini des gestionnaires (addBlockHandler) pour gérer les nouveaux blocs qui sont ajoutés et viewChainHandler) pour visualiser l'autre bloc

  • À la fin, il y a une fonction principale qui est le cœur du code, qui lie tout ensemble et qui exécute le serveur API.

Après la définition de l'API, vous disposez de deux méthodes pour ajouter les points de terminaison et récupérer les informations du point de terminaison de la blockchain.

Ouais !! Vous avez implémenté avec succès cette sous-section et vous pouvez maintenant exécuter l'API à l'aide de Cabal et vous êtes prêt à passer à la partie suivante.

Exécution et test de l'application

Après avoir créé l’API blockchain, il est temps de la tester. Nous utiliserons Postman ou curl pour interagir avec l’API et vérifier qu’elle fonctionne correctement.

Étapes pour exécuter et tester l'application :

  • Compilez le programme et exécutez-le :  cabal build   cabal run

  • Démarrer le serveur : L'API devrait être disponible à l'adresse http://localhost:8080

  • Tester et ajouter les points de terminaison du bloc

{  “index”: 1,  “timestamp”: “2024-09-12 12:30:00”,  “dataField”: “Ceci est mon nouveau bloc”,  “previousHash”: “some_hash”,  “hash”: “new_block_hash”}

Voir la Blockchain

boucle http://localhost:8080/chain

En suivant ces étapes, vous disposez désormais d'une application blockchain simple fonctionnant avec une API créée à l'aide de Plutus. L'API permet aux applications externes ou aux utilisateurs d'interagir avec votre blockchain en ajoutant de nouveaux blocs et en affichant l'état actuel de la blockchain.

Exemple concret de création d'une application blockchain avec Plutus

L'extrait de code ci-dessus est une exécution étape par étape de :

  • Étape 1 : créez le type de données Bloc avec les attributs nécessaires à l’aide de la syntaxe Plutus.

  • Étape 2 : implémentez la méthode calculate_hash.

  • Étape 3 : définissez le type de données Blockchain et initialisez-le avec un bloc de genèse.

  • Étape 4 : implémentez des méthodes pour ajouter de nouveaux blocs et récupérer le dernier bloc à l’aide de Plutus.

  • Étape 5 : ajoutez la fonctionnalité de preuve de travail au type de données Bloc et mettez à jour le type de données Blockchain.

  • Étape 6 : configurez l’environnement API pour gérer les requêtes à l’aide de Plutus.

  • Étape 7 : Testez l'application en extrayant un nouveau bloc et en vérifiant la blockchain à l'aide de Postman ou Curl

Félicitations ! Vous avez atteint la fin du module et appris toutes les bases de Plutus.

En vous lançant dans le développement de blockchain avec Plutus, vous n’écrivez pas seulement du code : vous créez l’épine dorsale de systèmes décentralisés qui pourraient redéfinir les industries. Continuez à apprendre et bon codage !!

Consultez également : Comment concevoir, développer et déployer votre propre crypto-monnaie : un guide étape par étape