L'article Créer une application Blockchain avec C++ est apparu en premier sur Coinpedia Fintech News
Introduction
La technologie Blockchain a fondamentalement transformé la gestion de la finance et de la chaîne d’approvisionnement en offrant des mécanismes décentralisés, transparents et sécurisés qui éliminent le besoin d’intermédiaires.
Pourquoi construire une application blockchain ?
Les applications de blockchain offrent une intégrité et une sécurité des données améliorées et fournissent un environnement sans confiance pour le partage d'informations. Avec la blockchain, on peut mettre en œuvre des contrats intelligents et créer des jetons numériques qui ouvrent les portes à de nouveaux modèles économiques comme la finance décentralisée (DeFi) et les actifs tokenisés, etc.
Cet article est une visite rapide de 10 minutes dans le monde du développement Blockchain via C++.
Les bases de la blockchain
La blockchain est une chaîne numérique composée d'unités uniques, sécurisées et inviolables, appelées blocs. Chaque bloc contient ses métadonnées et les informations désignées de la transaction. Jusqu'à présent, nous avons simplement créé des blocs individuels, n'est-ce pas ? Comment essayer d'établir une connexion entre chaque bloc de manière significative ? La réponse est de relier chaque bloc à son bloc précédent à l'aide de fonctions cryptographiques aléatoires uniques appelées hachage. Chaque bloc a son propre hachage qui est une clé primaire et vous pouvez relier tous les blocs par hachage dans l'ordre chronologique, formant ainsi une chaîne qui représente l'historique complet des transactions au sein du réseau.
C++ dans la blockchain
Le C++ est l'un des langages les plus puissants utilisés dans la blockchain en raison de sa vitesse, de sa flexibilité et de son contrôle. Il fait des merveilles dans la gestion de systèmes complexes, le développement de jeux et les applications financières. C'est sans aucun doute le langage le plus polyvalent !
Le C++ est un atout majeur dans le domaine de la blockchain pour plusieurs raisons. Il permet aux développeurs de créer des systèmes de blockchain efficaces grâce à sa gestion de la mémoire de bas niveau qui permet un contrôle précis. Nous savons tous à quel point le réseau Bitcoin est vaste et sécurisé. Imaginez à quel point son cœur doit être complexe, car il doit gérer d'innombrables transactions. Par conséquent, pour gérer cette tâche ardue, le C++ a été choisi. Certaines applications importantes ont été développées à l'aide de C++, comme Bitcoin, Lifecoin, Ripple, Monero et EOS.
Pourquoi C++ est un langage idéal pour le développement blockchain ?
Des calculs plus rapides
Haute performance
Gestion efficace de la mémoire
Fonctionnalités orientées objet
Prend en charge le multithreading
Contrôle des ressources système
Que vous soyez novice en matière de blockchain ou que vous souhaitiez repousser les limites du possible, C++ est un choix solide pour créer des applications durables.
Comprendre les concepts de la blockchain avec C++
Transactions : Dans la blockchain, les transactions sont l'essence même du système. Les blocs individuels sont comme des coffres-forts sécurisés qui contiennent les informations prestigieuses sur l'échange et la valeur des transactions ainsi que sur les participants. Ces transactions sont les enregistrements fondamentaux qui racontent l'histoire de qui a échangé quoi, avec qui et quand.
Les piliers de la blockchain que vous devez connaître
Décentralisation : La décentralisation est la raison pour laquelle la blockchain se démarque dans l'ensemble du domaine technologique. Qu'est-ce que la décentralisation ? Il s'agit d'une propriété de la blockchain par laquelle aucune entité unique ne détient le contrôle de l'ensemble de la base de données. Cela rend le système robuste aux pannes et inhibe tout type de biais. Chaque appareil participant (nœud) conserve une copie de la blockchain, garantissant la transparence et empêchant toute panne ou manipulation centralisée.
Immuabilité : une fois que vous avez écrit des données dans la blockchain, vous ne pouvez plus les modifier sans modifier 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écanismes 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.
Jusqu’à présent, vous devez avoir compris toutes les bases de la blockchain, n’est-ce pas ? Assez de théorie ! Plongeons-nous maintenant dans la partie pratique. Prêt à vous salir les mains ?
Dans cette section, nous vous guiderons tout au long du processus de développement d'une application blockchain simple, depuis la configuration de l'environnement jusqu'aux tests et au déploiement.
1. Configuration de l'environnement de développement C++
Avant de commencer le développement, il est essentiel de disposer de tous les prérequis. Dans ce chapitre, nous allons voir comment vous pouvez disposer de l'environnement de développement approprié.
Installation du compilateur C++
Commençons par comprendre ce qu’est un compilateur.
Un compilateur est un outil essentiel dans le développement de logiciels, agissant comme un pont entre le code lisible par l'homme que vous écrivez et le code machine que le processeur de votre ordinateur peut comprendre et exécuter. Dans le contexte du développement d'applications blockchain en C++, votre première étape consiste à vous équiper d'un compilateur C++ fiable. Cet outil traduira votre code C++ en code machine exécutable, permettant à votre application blockchain de fonctionner efficacement sur différents systèmes.
Pour commencer le développement, installez d'abord le compilateur C++ compatible avec votre système. Vous trouverez ci-dessous les compilateurs C++ les plus populaires parmi lesquels vous pouvez choisir :
GCC (collection de compilateurs GNU) :
Linux/MacOS :
Ouvrez le terminal et tapez les commandes ci-dessous respectivement
a)Ubuntu/Debian : sudo apt updatesudo apt install build-essentialb)Fedora sudo dnf install gcc gcc-c++c)MacOS (outils de ligne de commande)xcode-select –install
Windows : pour les utilisateurs Windows, le projet MinGW-w64 est un excellent choix car il fournit un portage Windows du GCC (GNU Compiler Collection), offrant la puissance de GCC dans un environnement Windows.
Étapes d'installation :
Téléchargez le programme d'installation en visitant le site Web officiel de MinGW-w64.
Exécutez le programme d'installation après le téléchargement
Sélectionnez l'architecture adaptée à vos besoins
Suivez les étapes de l'assistant pour terminer
Mettre à jour le système (il s’agit d’une étape facultative mais recommandée).
Bruit métallique :
Linux/MacOS : sudo apt install clang (clang est également déjà installé sous MacOS)Fedora : sudo dnf install clangWindows : Clang peut être installé à l'aide de MinGW ou via l'installateur du projet LLVM
MSVC (Microsoft Visual C++) :
MSVC (Microsoft Visual C++) est un composant intégré de Visual Studio, un environnement de développement intégré (IDE) robuste développé par Microsoft. Visual Studio fournit une suite complète d'outils pour le développement, le test et le déploiement d'applications. Son installation configurera automatiquement MSVC sur votre système.
Vérifiez l’installation à l’aide des commandes suivantes dans le terminal ou l’invite de commande :
g++ –version # Pour GCCclang –version # Pour Clangcl # Pour MSVC
Choisir un IDE
Un environnement de développement intégré (IDE) améliore la productivité en offrant des outils tels que la saisie semi-automatique du code, le débogage et la gestion de projet au sein d'une interface unifiée. Vous trouverez ci-dessous quelques IDE largement utilisés pour le développement C++ :
Visual Studio : Téléchargez Visual Studio depuis le site officiel.
Et suivez les étapes suivantes comme mentionné dans le tableau ci-dessous :
CLion : Installation et configuration :
CLion est un IDE populaire et est alimenté par JetBrains mais nécessite un abonnement mais propose des essais gratuits.
propose des essais gratuits.
Visual Studio Code : installer et configurer des extensions pour le développement C++.
Installation des bibliothèques requises
Utilisez les gestionnaires de paquets pour installer des bibliothèques essentielles comme OpenSSL pour les fonctions cryptographiques. Vous trouverez ci-dessous les étapes et les différentes bibliothèques pour différents systèmes d'exploitation et leurs commandes.
Ouais, vous avez configuré avec succès votre environnement de développement, vous pouvez directement commencer à exécuter le code dans l'IDE de votre choix.
2.Construire une blockchain simple avec C++
Avant de commencer le voyage d’écriture du code, comprenons les composants d’une classe de bloc.
Composants de Blockclass
Un index est un entier qui stocke et maintient l'ordre trié des blocs de manière chronologique.
Horodatage : l'horodatage stocke l'instance à laquelle le bloc a été créé sous la forme d'une chaîne.
Transactions : Les transactions stockent les informations d’échange entre les participants et l’état de la blockchain à ce moment-là.
Hachage précédent et Hash : Le hachage précédent stocke le hachage cryptographique du bloc précédent tandis que le hachage est une chaîne d'informations cryptographiques mélangées ou hachées.
Nonce : un entier utilisé dans l'algorithme de consensus Proof of Work (PoW). Il agit comme un compteur qui est incrémenté pour trouver un hachage valide qui répond à la cible de difficulté. Le nonce est crucial pour le processus d'extraction dans PoW, où les mineurs rivalisent pour trouver un nonce qui génère un hachage avec un nombre spécifique de zéros non significatifs.
Implémentons maintenant toutes les fonctionnalités dans le code :
classe Block {public : int index ; std::string horodatage ; std::vector<Transaction> transactions ; std::string previousHash ; std::string hachage ; int nonce ; // Pour PoW // Constructeur Block(int idx, std::string heure, std::vector<Transaction> txs, std::string prevHash) { index = idx ; horodatage = heure ; transactions = txs ; previousHash = prevHash nonce = 0 ; hash = calculateHash(); // Hachage du bloc actuel } // Méthode de calcul du hachage du bloc std::string calculateHash() { std::stringstream ss; ss << index << timestamp << previousHash << nonce; // Ajouter les données de transaction et tous les détails supplémentaires au calcul du hachage return sha256(ss.str()); // Espace réservé pour la fonction de hachage réelle } // Méthode d'extraction du bloc void mineBlock(int difficulty) { std::string target(difficulty, ‘0’); // Créer une chaîne de hachage cible while (hash.substr(0, difficulty) != target) { nonce++; hash = calculateHash(); } }};
Une fois que vous avez terminé de définir la classe de blocs et ses attributs, vous pouvez continuer et créer le bloc Genesis. Le bloc Genesis est le premier bloc de la blockchain qui doit être initialisé et a un index de zéro. Après avoir défini le bloc Genesis, vous pouvez continuer et ajouter de nouveaux blocs à votre blockchain en utilisant la méthode addblock(). Vous trouverez ci-dessous le code :
classe Blockchain {public: std::vector<Block> chaîne; Blockchain() { chaîne.push_back(createGenesisBlock()); } Bloc createGenesisBlock() { return Block(0, « 01/01/2024 », « Genesis Block », « 0 »); } Bloc getLatestBlock() { return chain.back(); } void addBlock(Block newBlock) { newBlock.previousHash = getLatestBlock().hash; newBlock.hash = newBlock.calculateHash(); chain.push_back(newBlock); }};
Créez et vérifiez la transaction. Chaque transaction possède son propre identifiant, un constructeur prédéfini et les informations sur l'expéditeur et le destinataire ainsi que le montant. Après avoir créé une transaction, vous devez la vérifier à l'aide de la méthode validateTransaction().
classe Transaction {public: std::string sender; std::string recipient; double amount; std::string transactionID; // Constructeur Transaction(std::string snd, std::string rcp, double amt, std::string txID) { sender = snd; recipient = rcp; amount = amt; transactionID = txID; } // Méthode de validation de la transaction bool validateTransaction() { // Implémentation de la logique de validation return true; // Espace réservé }};
3. Implémentation de mécanismes de consensus en C++
Jusqu'à présent, vous avez réalisé 25 % du processus de création. Vous pouvez maintenant avancer et mettre en œuvre les mécanismes de consensus pour votre bloc, qui constitue l'épine dorsale de l'ensemble de l'application.
Preuve de travail
La preuve de travail (PoW) est un mécanisme de consensus par lequel les membres du réseau blockchain/mineurs doivent trouver une solution à un problème mathématique informatique difficile avant de pouvoir ajouter un nouveau bloc à la chaîne. Il s'agit essentiellement d'un processus de recherche d'un nombre spécifique, appelé nonce, qui est combiné aux données du bloc, à son hachage et à d'autres détails pour générer une valeur de hachage qui commence par un certain nombre de zéros non significatifs. Cela rend le processus efficace et protège le réseau contre les attaques malveillantes.
En C++, vous pouvez implémenter la preuve de travail en ajoutant un attribut de preuve et une méthode de preuve de travail à la classe Block. Voici comment procéder :
#include <iostream>#include <sstream>#include <ctime>#include <string>#include <vector>#include <openssl/sha.h>utilisation de l'espace de noms std;string sha256(const string str) { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, str.c_str(), str.length()); SHA256_Final(hash, &sha256); stringstream ss; for(int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << hex << setw(2) << setfill(‘0’) << (int)hash[i]; } retour ss.str();}classe Bloc {public: int index; chaîne données; chaîne Hash précédent; chaîne hachage; long preuve; heure_t horodatage; Bloc(int idx, chaîne d, chaîne Hash précédent) { index = idx; données = d; précédent Hash = Hash précédent; horodatage = heure(nullptr); preuve = 0 ; hachage = calculateHash(); } chaîne calculerHash() const { chaînestream ss ; ss << index << horodatage << données << previousHash << preuve ; return sha256(ss.str()); } void proofOfWork(int difficulté) { chaîne cible(difficulté, ‘0’); do { preuve++ ; hachage = calculateHash(); } while (hash.substr(0, difficulté) != cible); }};classe Blockchain {public: vector<Block> chaîne ; int difficulté ; Blockchain(int diff) { difficulté = diff ; chaîne. emplace_back(Bloc(0, « Bloc Genesis », « 0 »)); } void addBlock(chaîne données) { Bloc newBlock(chaîne.size(), données, chaîne.back().hash); newBlock.proofOfWork(difficulté); if (isValidProof(newBlock)) { chaîne.push_back(newBlock); } } bool isValidProof(const Block& block) const { retourner bloc.hash.substr(0, difficulté) == string(difficulté, ‘0’); }};
Dans l'extrait de code ci-dessus, nous pouvons voir que nous devons d'abord ajouter une preuve et un hachage au bloc. Ensuite, décidez de la difficulté de la preuve et exploitez-la. Après cela, vous pouvez valider la preuve.
4.Création d'une API Blockchain simple avec C++
L'API (Application Programming Interface) est un outil qui permet à différentes applications logicielles d'interagir entre elles. Dans la blockchain, les API facilitent l'interaction avec les données de blockchain prédéfinies, ce qui permet aux développeurs de créer rapidement des applications sans avoir besoin de connaître toute la structure sous-jacente du réseau. Les API aident à intégrer la blockchain à d'autres plateformes, comme les applications Web ou mobiles. Les API sont donc nécessaires pour permettre un développement et une intégration efficaces.
Configuration de l'environnement API
Installez et configurez les outils requis pour créer des API avec C++ comme mentionné dans le tableau ci-dessous :
Création de l'API
#include <cpprest/http_listener.h>#include <cpprest/json.h>#include “blockchain.h”utilisation de l'espace de noms web;utilisation de l'espace de noms http;utilisation de l'espace de noms utilitaire;utilisation de l'espace de noms http::experimental::listener;Blockchain blockchain(4); // niveau de difficulté 4void handleGet(http_request request) { json::value response = json::value::array(); int i = 0; for (auto& block : blockchain.chain) { json::value block_json; block_json[U(“index”)] = json::value::number(block.index); block_json[U(“data”)] = json::value::string(block.data); block_json[U(“previousHash”)] = json::value::string(block.previousHash); block_json[U(“hash”)] = json::value::string(block.hash); block_json[U(“preuve”)] = json::value::number(block.preuve); block_json[U(“horodatage”)] = json::value::number(block.horodatage); response[i++] = block_json; } request.reply(status_codes::OK, response);}void handlePost(http_request request) { request.extract_json().then([&](json::value requestData) { auto data = requestData[U(“data”)].as_string();blockchain.addBlock(data);request.reply(status_codes::OK, U(“Bloc ajouté avec succès”));}).wait();}int main() {http_listener listener(U(“http://localhost:8080”));listener.support(methods::GET, handleGet);listener.support(methods::POST, handlePost);try {listener.open().wait();cout << “Écoute sur http://localhost:8080” << endl;while (true);} catch (exception const& e) {cerr << e.what() << endl; }retour 0;}
handleGet récupère l'intégralité de la blockchain au format JSON.
handlePost ajoute un nouveau bloc à la blockchain en utilisant les données de la requête POST.
Exécution et test de l'application
Exécution de l'application
Une fois que vous avez terminé avec les fonctionnalités de base du code selon le cycle de développement logiciel, vous devez passer à l'étape la plus cruciale et inévitable de la compilation et du test de l'ensemble de l'application. Il est très important de confirmer que les composants de l'application fonctionnent comme prévu.
Compilez le code :g++ -o blockchain_api blockchain_api.cpp -lboost_system -lcrypto -lssl -lcpprestExécutez l'exécutable :./blockchain_api
Le code ci-dessus démarre le serveur API sur http://localhost:8080.
Test avec Postman
Testez les points de terminaison de l'API à l'aide de Postman ou curl :
Ajouter un bloc :
Méthode : POST
URL : http://localhost:8080
Corps : format JSON
{ « données » : « Ceci est un nouveau bloc »}
Voir la Blockchain :
Méthode : GET
URL : http://localhost:8080
Exemple d'ajout d'un bloc et de visualisation de la blockchain à l'aide de l'API créée avec C++.
void handleGet(http_request request) { json::value response = json::value::array(); int i = 0; for (auto& block : blockchain.chain) { json::value block_json; block_json[U(“index”)] = json::value::number(block.index); block_json[U(“data”)] = json::value::string(block.data); block_json[U(“previousHash”)] = json::value::string(block.previousHash); block_json[U(“hash”)] = json::value::string(block.hash); block_json[U(“preuve”)] = json::valeur::numéro(bloc.preuve); block_json[U(“horodatage”)] = json::valeur::numéro(bloc.horodatage); réponse[i++] = block_json; } requête.réponse(codes_d'état::OK, réponse); }void handlePost(http_request request) { requête.extract_json().then([&](json::valeur requestData) { auto data = requestData[U(“données”)].as_string();blockchain.addBlock(données);requête.réponse(codes_d'état::OK, U(“Bloc ajouté avec succès”)) }).wait();}
La fonction handlePost traite l'ajout de bloc en extrayant les données du corps JSON et en ajoutant un nouveau bloc à la blockchain.
La fonction handleGet récupère l'intégralité de la blockchain et la renvoie sous forme de réponse JSON.
6.Exemple concret de création d'une application blockchain avec C++
Exécution étape par étape
Étape 1 : créez la classe Block avec les attributs nécessaires à l’aide de la syntaxe C++.
#include <iostream>#include <ctime>#include <string>#include <sstream>#include <vector>#include <openssl/sha.h>utilisation de l'espace de noms std;class Block {public: int index; chaîne données; chaîne previousHash; chaîne hachage; long preuve; heure_t horodatage; Block(int idx, const chaîne& données, const chaîne& prevHash) : index(idx), données(données), previousHash(prevHash), preuve(0), horodatage(time(nullptr)) { hash = calculateHash(); } chaîne calculateHash() const { stringstream ss; ss << index << horodatage << données << previousHash << preuve ; return sha256(ss.str()); } void proofOfWork(int difficulty) { string target(difficulté, ‘0’); do { proof++; hash = calculateHash(); } while (hash.substr(0, difficulté) != target); }private: string sha256(const string& input) const { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, input.c_str(), input.size()); SHA256_Final(hash, &sha256); stringstream ss; pour (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << hex << setw(2) << setfill(‘0’) << (int)hash[i]; } retour ss.str(); }};
Étape 2 : implémentez la méthode calculateHash.
#include <iostream>#include <sstream>#include <iomanip>#include <openssl/sha.h>class Block {public: int index; std::string données; std::string Hash précédent; std::string hachage; long preuve; heure_t horodatage; Block(int idx, const std::string& données, const std::string& prevHash) : index(idx), données(données), Hash précédent(Hash précédent), preuve(0), horodatage(heure(nullptr)) { hash = calculateHash(); } std::string calculateHash() const { std::stringstream ss; ss << index << horodatage << données << previousHash << preuve ; retour sha256(ss.str()); }privé : std::string sha256(const std::string& entrée) const { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, input.c_str(), input.size()); SHA256_Final(hash, &sha256); std::stringstream ss; pour (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << std::hex << std::setw(2) << std::setfill(‘0’) << (int)hash[i]; } retourner ss.str(); }};
Étape 3 : définissez la classe Blockchain et initialisez-la avec un bloc de genèse.
classe Blockchain {public: Blockchain(int difficulty) : difficulty(difficulté) { chain.emplace_back(Block(0, “Genesis Block”, “0”)); } void addBlock(const string& data) { Block newBlock(chain.size(), data, chain.back().hash); newBlock.proofOfWork(difficulté); chain.push_back(newBlock); } const Block& latestBlock() const { return chain.back(); } vecteur<Block> chaîne;private: int difficulty;};
Étape 4 : implémentez la méthode calculateHash.
#include <iostream>#include <sstream>#include <iomanip>#include <openssl/sha.h>class Block {public: int index; std::string données; std::string Hash précédent; std::string hachage; long preuve; heure_t horodatage; Block(int idx, const std::string& données, const std::string& prevHash) : index(idx), données(données), Hash précédent(Hash précédent), preuve(0), horodatage(heure(nullptr)) { hash = calculateHash(); } std::string calculateHash() const { std::stringstream ss; ss << index << horodatage << données << previousHash << preuve ; retour sha256(ss.str()); }privé : std::string sha256(const std::string& entrée) const { unsigned char hash[SHA256_DIGEST_LENGTH]; SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, input.c_str(), input.size()); SHA256_Final(hash, &sha256); std::stringstream ss; pour (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << std::hex << std::setw(2) << std::setfill(‘0’) << (int)hash[i]; } retourner ss.str(); }};
Étape 5 : définissez la classe Blockchain et initialisez-la avec un bloc de genèse.
classe Blockchain {public: Blockchain(int difficulty) : difficulty(difficulté) { chain.emplace_back(Block(0, “Genesis Block”, “0”)); } void addBlock(const string& data) { Block newBlock(chain.size(), data, chain.back().hash); newBlock.proofOfWork(difficulté); chain.push_back(newBlock); } const Block& latestBlock() const { return chain.back(); } vecteur<Block> chaîne;private: int difficulty;};
Étape 6 : configurez l’environnement API pour gérer les requêtes à l’aide d’une bibliothèque C++ appropriée.
#include <cpprest/http_listener.h>#include <cpprest/json.h>utilisation de l'espace de noms web;utilisation de l'espace de noms web::http;utilisation de l'espace de noms web::http::experimental::listener;classe BlockchainAPI {public: BlockchainAPI(const string& address, Blockchain& blockchain) : listener(http_listener(U(address))), blockchain(blockchain) { listener.support(methods::GET, std::bind(&BlockchainAPI::handleGet, this, std::placeholders::_1));listener.support(methods::POST, std::bind(&BlockchainAPI::handlePost, this, std::placeholders::_1));void start() {listener.open().wait(); cout << « API Blockchain en cours d'exécution… » << endl ; }Privé : http_listener listener Blockchain& blockchain;void handleGet(http_request request) {json::value response = json::value::array();int i = 0;for (const auto& block : blockchain.chain) {json::value block_json;block_json[U(“index”)] = json::value::number(block.index);block_json[U(“data”)] = json::value::string(block.data);block_json[U(“previousHash”)] = json::value::string(block.previousHash);block_json[U(“hash”)] = json::value::string(block.hash);block_json[U(“proof”)] = json::value::number(block.proof);block_json[U(“timestamp”)] = json::value::number(block.timestamp);response[i++] = block_json; } request.reply(status_codes::OK, response); }void handlePost(http_request request) {request.extract_json().then([&](json::value requestData) {string data = requestData[U(“data”)].as_string();blockchain.addBlock(data);request.reply(status_codes::OK, U(“Bloc ajouté avec succès”));}) . wait () ; }} ;
Étape 7 : Testez l’application en extrayant un nouveau bloc et en vérifiant la blockchain à l’aide de Postman ou de curl.
Main:int main() { Blockchain blockchain(4); // Niveau de difficulté BlockchainAPI api(“http://localhost:8080”, blockchain); api.start(); return 0;}Test:curl -X POST http://localhost:8080 -H “Content-Type: application/json” -d ‘{“data”:”Ceci est un nouveau bloc”}’
Se lancer dans le développement de blockchain avec C++, c’est bien plus que du codage ; il s’agit de construire les éléments fondamentaux de systèmes décentralisés qui ont le potentiel de révolutionner divers secteurs.
Pour résumer, nous avons tout couvert, depuis les bases de la programmation C++ pour la blockchain jusqu'au déploiement et aux tests de l'application.
Une fois ce module terminé, vous pouvez explorer davantage les concepts d'optimisation tels que l'évolutivité, les pratiques de sécurité, les mécanismes de consensus avancés et les contrats intelligents.
Restez curieux, adoptez l’apprentissage continu et continuez à coder. Que vos contributions déterminent l’avenir de la technologie !