Comment créer une application Blockchain avec Python

En tant que développeur de blockchain, vous en saurez beaucoup plus que les gens moyens sur la façon dont les choses fonctionnent sous le capot. Vous serez familiarisé avec les blocs, les hachages, les nœuds, les transactions, divers types de données et bien d’autres. Cependant, si vous avez une idée de la façon de mettre en œuvre la blockchain dans un environnement spécifique avec des utilisateurs occasionnels, vous ne partagerez pas toute votre sagesse avec eux, encore moins les forcer à apprendre comment chaque opération est effectuée. Les utilisateurs contemporains sont gâtés avec des interfaces faciles et avec des interfaces utilisateur exceptionnelles qui garantissent une excellente expérience utilisateur. Si vous voulez rendre votre projet blockchain plus attrayant que vous devriez au moins le rendre facile à utiliser. C’est là que les applications décentralisées ou dApps entrent en jeu.

Les applications décentralisées sont une nouvelle tendance dans le développement de logiciels. Ils sont devenus populaires après l’engouement pour les ICO qui a débuté en 2017. La principale particularité des dApps est qu’ils dépendent entièrement de la blockchain et ne peuvent donc pas être contrôlés ou arrêtés par un tiers. En outre, les dApps peuvent également utiliser des contrats intelligents, dont nous avons discuté précédemment, pour effectuer diverses opérations de manière sécurisée et autonome. Sinon, les dApp ressemblent à des applications centralisées et pourraient être n’importe quoi, des échanges aux jeux. Vous pouvez consulter certains d’entre eux dans notre liste de 10 dApps ici.

Bien qu’il existe des langages de programmation dédiés pour la programmation de contrats intelligents et dApp, tels que Solidity, Vyper et Simplicity, d’autres langages peuvent également être utilisés à cette fin. Pour les besoins de ce didacticiel, nous avons choisi Python car c’est l’un des langages les plus complets et les plus polyvalents du marché. Aujourd’hui, nous allons vous montrer une application simple créée avec Python, la lancer et expliquer son fonctionnement. Ne tardons plus et mettons-nous au travail!

Structure et propriétés d’une dApp

Tout d’abord, décrivons à quoi doit ressembler une dApp et passons en revue ses éléments. Il y a deux parties principales d’une dApp:

  • L’extrémité avant

  • Back end

Le frontal contient tout ce qui est montré à un utilisateur. Par exemple, lorsque vous faites défiler votre profil Facebook, vous interagissez avec le front-end de Facebook. Il est généralement rédigé en HTML, CSS et JavaScript, mais il existe d’autres moyens de le faire. L’arrière-plan est comme le moteur d’une voiture. Personne, sauf les mécaniciens, ne le regarde, mais ça fait marcher les choses. Alors que les applications centralisées utilisent des services d’hébergement et divers frameworks comme Django et NodeJS, les applications décentralisées utilisent à la place des blockchains. Dans les deux cas, la communication entre le frontend & le backend se produit via des messages au format JSON.

Nous devons également noter que puisque les tâches de backend se produisent sur la blockchain où tout est immuable, un ingénieur qui crée une dApp doit effectuer plusieurs vérifications approfondies de son projet pour s’assurer qu’il n’y a pas de vulnérabilités dans le code. Cela fait en sorte que la création de dApps ressemble plus à la création de matériel, plutôt que de logiciel, qui peut être modifié à la volée. Du bon côté, si un dApp est parfaitement écrit, il est pratiquement impossible à pirater car il n’y a pas de point central de défaillance. Deuxièmement, le code pour les dApps est généralement publié en open-source. Sinon, la communauté aura des problèmes de confiance et évitera d’utiliser certaines applications.

Créer un backend

Maintenant que nous savons qu’une dApp repose sur la blockchain, créons-en une avec Python localement. C’est une approche plus sûre pour apprendre et tester des choses, car nous ne voulons pas encombrer un vrai réseau avec du code inutile. De plus, cette démonstration est plus encline à vous montrer les principes du fonctionnement des choses – les dApps du monde réel sont beaucoup plus complexes..

Comme tout se passera sur votre ordinateur, la blockchain sera physiquement située sur votre disque dur, ce qui en fera essentiellement un nœud. Pour cela, créez un dossier quelque part que vous aimez et appelez-le «Projet». Dans le dossier, créons-en un autre, appelons-le «blockchain» et codons en dur un premier bloc là-bas. Créez un fichier texte et ouvrez-le dans l’éditeur de code de votre choix. Nous utiliserons Atom.

Initialisation du bloc de genèse

Dans le premier bloc, nous préciserons qu’un payeur a payé mille pièces à un bénéficiaire. Comme vous vous en souvenez probablement dans notre article sur la puissance de hachage, chaque tête de bloc est hachée et le hachage de chaque bloc est inclus dans le suivant pour garantir que le réseau n’a pas été falsifié. Un bloc de genèse n’a pas de bloc devant lui, il y aura donc un hachage vide.

Bloc GenesisImage par U.Today

Ensuite, dans notre dossier avec la blockchain, créons un fichier avec le script. Commencez par importer la bibliothèque JSON car nous utiliserons ce formatage. Continuez avec le «if __name__ == "__principale__": »Pour permettre de vérifier si le script sera lancé ou non depuis la console. Cette étape vous aidera lors de l’importation. Pour que notre blockchain locale fonctionne, nous devons écrire une fonction qui crée de nouveaux blocs. De plus, il devrait y avoir une fonction pour vérifier si la blockchain a été modifiée ou non.

Ecrire de nouveaux blocs

Codons la fonction pour créer les blocs suivants dans la chaîne. Pour ce faire, nous devons spécifier tous les types de données que nous avons écrits dans le bloc genesis. Ensuite, nous créons une instruction «avec» avec une fonction pour créer un nouveau fichier pour rendre le code dans les nouveaux blocs plus adapté à la lecture, spécifiez l’indentation. Une fois cela fait, nous pouvons exécuter le script et obtenir un fichier avec notre bloc de test.

Nouveau bloc de test & amp; ScénarioImage par U.Today

La fonction de test fonctionne! Nous pouvons maintenant l’étendre pour recevoir des données et les écrire dans les blocs suivants. Pour ce faire, nous allons placer les arguments du bénéficiaire, du montant, du payeur et p_hash (hachage du bloc précédent) dans la fonction. Ensuite, nous devons faire en sorte que la fonction écrive les blocs dans le dossier respectif. À cette fin, importez le système d’exploitation pour travailler avec le système de fichiers de l’ordinateur. Ensuite, dans la fonction définissons le répertoire que nous avons créé pour nos blocs via «os.curdir». Ensuite, spécifiez cette déclaration dans l’instruction qui écrit un nouveau fichier.

Pour aller plus loin, nous ne pouvons pas laisser le fichier de test étiqueté tel quel, nous voulons que chaque nouveau bloc soit nommé de manière consécutive. Comme notre bloc de genèse est «0», le bloc suivant doit être 1 et ainsi de suite. Celui-ci est assez simple, notre fonction devrait être capable d’analyser le répertoire de base de la blockchain. Trouvez le dernier numéro du bloc le plus récent, incrémentez ce numéro de un et nommez le bloc suivant. Pour obtenir tous les blocs, nous utiliserons «listdir» du système d’exploitation et lui fournirons notre variable de répertoire blockchain. Gardez à l’esprit que «listdir» ne trie pas les blocs par leur nom, donc le dernier fichier, dans ce cas, n’est peut-être pas ce dont nous avons besoin. Par conséquent, nous devons utiliser la compréhension de liste pour renvoyer des entiers pour tous les noms de fichiers et les trier via la fonction «triée». Enfin, apprenons à notre blockchain à étiqueter les blocs en renvoyant le nom du dernier bloc et en l’incrémentant de un. Assurez-vous de reconvertir l’étiquette en chaîne et d’ajouter un nom de bloc à la fonction «avec».

Fonction pour obtenir des blocsImage par U.Today

Hashing

Désormais, chaque fois que vous exécuterez le script, vous obtiendrez un nouveau bloc. Cependant, ce n’est toujours pas une blockchain, car les nœuds devraient également pouvoir vérifier l’intégrité et donc la sécurité des données. Chacun des blocs aura un hachage d’un précédent. Commençons par le hachage des données dans des blocs. Premièrement, nous allons importer le module «hashlib». Ensuite, nous allons créer une fonction qui lira le contenu d’un bloc, l’exécutera via l’algorithme de hachage SHA-256 et retournera un hachage. Veuillez noter que vous devez spécifier ici l’emplacement du dossier «blockchain», sinon la fonction ne trouvera pas de blocs. Dans la fonction qui crée des blocs, définissez une variable pour un hachage précédent qui lancera notre fonction de hachage pour le bloc précédent. Au fur et à mesure que nous le testons, nous pouvons voir que le nouveau bloc contient le hachage du précédent. Vous pouvez facilement vérifier le hachage en copiant le contenu du bloc numéro 1 sur un générateur SHA256 en ligne et comparer les résultats.

Fonction de hachageImage par U.Today

Vérification de bloc

Jusqu’à présent, nous avons la fonction de création de bloc et la fonction de hachage. Il est temps d’introduire un algorithme de vérification pour notre nœud. La fonction que nous allons créer pourra obtenir la liste de tous les fichiers de la blockchain, lire les hachages du bloc précédent à partir du deuxième bloc, générer à nouveau un hachage de chaque bloc précédent, les comparer et renvoyer le résultat.

Nous commencerons par déclarer une variable qui récupère tous les fichiers du répertoire «blockchain», une variable qui renvoie la liste des fichiers et une qui trie les blocs par ordre croissant. La prochaine chose que nous devrions faire est de rendre la fonction capable de parcourir les blocs et de lire les hachages des blocs précédents. Cela peut être fait via une boucle «for» qui charge toutes les données d’un bloc et ne renvoie que ce qui correspond au «hachage». Passons maintenant à la création du hachage pour le vérifier par rapport à ce qu’une fonction reçoit. Dans la boucle «for», nous laisserons une variable «true_h» qui lancera la fonction de hachage pour le bloc précédent. La dernière étape consiste à comparer les hachages en utilisant une instruction «if / else». Les résultats seront écrits dans un tableau que nous avons défini pour eux et tout sera affiché dans la console.

Vérification de blocImage par U.Today

Après avoir nettoyé certaines redondances, nous avons une blockchain locale codée en Python.

Construire un frontend

Même si nous avons réussi à mettre toutes les fonctions nécessaires en moins de 60 lignes de code, pour un utilisateur moyen, cela ressemblerait toujours à un tas de charabia. Par conséquent, nous devons le rendre facile à comprendre et à utiliser avec une interface frontale. Dans ce didacticiel, nous utiliserons le framework Flask avec HTML, CSS et JavaScript.

Mise en place de l’environnement

Dans le répertoire principal du projet, créez un dossier pour l’environnement virtuel qui servira de backend. Si vous ne l’avez pas déjà fait, veuillez télécharger Python depuis la page officielle ou via une ligne de commande dans votre OS (nous utilisons homebrew sous OSX) et installez-le. Pour aller plus loin, installez Virtualenv & Pip via les commandes de ligne de commande appropriées. Après cela, lancez un environnement virtuel à partir de la ligne de commande dans le dossier «UI», vous obtiendrez un nouveau dossier si tout a été fait correctement. Il est temps de l’activer et d’installer le flacon via Pip.

Création et activation de venvImage par U.Today

Mettons notre back-end à côté du frontend. Coupez le dossier «blockchain» et le script et collez-les dans le dossier «app» du répertoire principal. Dans le dossier backend, nous devons créer le fichier de script principal.

Créer la structure

Dans notre script principal, nous devons d’abord importer Flask et placer un lien vers le nom du fichier pour permettre à Flask de comprendre les chemins. Nous devons également mettre une instruction standard qui vérifie si le script est lancé depuis la console et exécute notre application. Assurez-vous d’ajouter “debug” pour permettre le rechargement de Flask chaque fois que vous modifiez quelque chose dans le code.

Application videImage par U.Today

Si vous lancez le script à ce stade, vous pouvez voir que localhost: 5000 est actif, mais affiche l’erreur 404. C’est normal, car l’application est toujours vide. Commençons par le remplir en créant une fonction qui permettra à notre nœud de traiter les requêtes des utilisateurs. En son sein (en plaçant «@» avant la fonction), nous mettrons une fonction d’indexation. Cela créera une structure d’URL locales et des fonctions correspondantes. La fonction “index” affichera les utilisateurs index.html via le module “render_template”.

Application avec fonction d'affichageImage par U.Today

Nous pouvons maintenant procéder à la création de notre structure HTML. Il y aura deux fichiers, un pour les informations générales et un autre pour l’interface utilisateur de la première page. Dans base.html, nous importerons la bibliothèque Bootstrap pour créer une mise en page via CSS. Créons une colonne centrée et y plaçons un bloc de contenu dans un format pouvant être interprété par la Jinja de Flask..

Première page en htmlImage par U.Today

Composition de l’interface utilisateur

Notre application sera un simple système de paiement. Il y aura un payeur, un bénéficiaire et une somme d’argent transférée. Tout se fera via la blockchain, mais pour un utilisateur, cela ressemblera à une application classique. Lorsque vous transférez de l’argent sur Internet, vous remplissez généralement un formulaire et le soumettez. Bootstrap a différentes formes pour nous aider avec certains préréglages. Vous pouvez copier celui que nous avons choisi ici et copiez le code dans votre index.html. Il n’y aura que deux champs dans le formulaire pré-écrit et une case à cocher, nous supprimerons la case à cocher et ajouterons un champ. Ensuite, nous ajusterons les étiquettes, les identifiants, les types et les espaces réservés appropriés. Enfin, nous attribuerons notre fonction d’index au formulaire. Lorsqu’un utilisateur saisit son nom, son montant et un agent de comptage, toutes les informations doivent être sauvegardées quelque part puis incluses dans un bloc. Pour cela, modifions nos champs de saisie en ajoutant “nom” et “valeur”. La valeur utilisera la méthode «get» pour extraire tout ce qu’un utilisateur met dans le champ «Payer». N’oubliez pas de spécifier une chaîne vide au cas où un utilisateur n’entrerait rien.

FormeImage par U.Today

Revenons à notre script principal. Le script doit être capable de comprendre si la requête envoyée par un utilisateur est POST ou non. Pour l’activer, nous allons importer le module de requête à partir du flacon et spécifier les méthodes dans notre application. Dans l’application, nous déclarerons les variables qui demanderont les données respectives du formulaire.

Application mise à jourImage par U.Today

Pour aller plus loin, nous devrons transmettre toutes les données collectées à un nouveau bloc. Cela nous oblige à connecter le script principal à celui qui écrit les blocs. Pour ce faire dans l’instruction ‘if’ qui vérifie le type d’une requête, nous allons mettre une fonction ‘write’ avec des arguments correspondant à ce que nous avons dans nos blocs.

Lier l'interface utilisateur au backendImage par U.Today

Maintenant, si nous retournons à notre navigateur et soumettons une transaction, nous obtiendrons un nouveau bloc dans notre dossier blockchain qui contiendra les informations que nous avons communiquées. Cependant, vous pouvez voir que les champs ne se sont pas actualisés. Pour cela, nous devons rediriger un utilisateur vers une nouvelle instance de index.html. N’oubliez pas d’importer les modules que nous utilisons depuis Flask. Voila, tout se rafraîchit après avoir soumis.

RedirectionImage par U.Today

La touche finale à notre interface utilisateur sera un bouton Cela permet à notre nœud de vérifier toute faille de sécurité dans notre blockchain. Pour ce faire, nous allons créer un autre routage pour la vérification avec une fonction à l’intérieur. Revenons ensuite à notre base.html et spécifions deux autres conteneurs pour un bouton et les résultats de la vérification avec les marges supérieures définies comme 5. Placez un bloc dans un conteneur et dans l’index.html également.

Bloquer pour vérificationImage par U.Today

Pour l’étape suivante, nous choisirons un bouton dans la bibliothèque Bootstrap et le placerons dans base.html dans un formulaire. Dans le formulaire, mettez notre fonction «vérifier» comme action et attachez-la à la fonction «vérifier» dans le script principal. Une fois cela fait, revenez au script principal et placez la fonction de vérification du script pour créer des blocs dans la fonction de vérification. Allez dans le fichier base.html, ici nous voulons faire une boucle «for» pour chaque variable dans le tableau «results». Dans la boucle «for», nous créerons un div qui affichera les résultats de la vérification.

Vérification de la boucleImage par U.Today

Tester le dApp

Alors là vous l’avez. Revenez à votre navigateur et actualisez la page. À partir de maintenant, notre dApp peut enregistrer les transactions sur la blockchain et vérifier si l’un des blocs a été piraté. Pour vous assurer que tout fonctionne, soumettez une transaction avec les données de votre choix et accédez au dossier blockchain. Vous devriez y avoir un nouveau fichier texte avec le payeur, le montant et le bénéficiaire que vous avez spécifiés et le hachage du bloc précédent.

Interface dAppImage par U.TodayNouveau blocImage par U.Today

Revenez au navigateur, créez d’autres blocs et lancez le processus de vérification. Vous verrez qu’à ce stade, tous les blocs sont authentiques. Il est temps de pirater notre nœud! Accédez au dossier blockchain et modifiez l’un des blocs que vous avez créés avant le dernier. Revenez maintenant au navigateur et vérifiez à nouveau notre chaîne. Comme vous pouvez le voir, notre nœud signale qu’un bloc est corrompu et nous ne devons pas faire confiance aux données de cette blockchain.

Faux blocsImage par U.Today

Résumé

Pour résumer, nous vous avons présenté aujourd’hui une application décentralisée simple sur une blockchain opérée localement. La création d’applications de manière décentralisée a ses caractéristiques, mais elle est également similaire à la création d’applications classiques. Après tout, les applications sont destinées à l’utilisateur final, donc à première vue, on ne trouverait probablement pas beaucoup de différence.

Si vous envisagez de coder des dApps, vous devez connaître les principes de la technologie blockchain et comprendre comment écrire pour le frontend et le backend. Avec un niveau de connaissances aussi avancé requis, vous feriez mieux de choisir un langage de programmation rapide et simple comme Python. Avec Python, vous pourrez à la fois créer un code compact et exécuter un serveur local sans tracas. Ce dernier est très important, car vous souhaitez effectuer toutes les vérifications de sécurité nécessaires avant la publication car la blockchain est immuable.

Nous espérons que ce tutoriel vous a beaucoup aidé à vous familiariser avec les dApps. Prendre plaisir!