Der Beitrag „Erstellen einer Blockchain-Anwendung mit C++“ erschien zuerst auf Coinpedia Fintech News
Einführung
Die Blockchain-Technologie hat das Finanz- und Lieferkettenmanagement grundlegend verändert, indem sie dezentrale, transparente und sichere Mechanismen bietet, die den Bedarf an Vermittlern überflüssig machen.
Warum sollte man eine Blockchain-Anwendung erstellen?
Blockchain-Anwendungen sorgen für verbesserte Datenintegrität und -sicherheit und bieten eine vertrauenslose Umgebung für den Informationsaustausch. Mit Blockchain lassen sich Smart Contracts implementieren und digitale Token erstellen, die die Türen zu neuen Wirtschaftsmodellen wie Decentralized Finance (DeFi) und tokenisierten Vermögenswerten usw. öffnen.
Dieser Artikel ist eine kurze 10-minütige Tour in die Welt der Blockchain-Entwicklung mit C++.
Grundlagen der Blockchain
Blockchain ist eine digitale Kette, die aus einzelnen sicheren und manipulationssicheren Einheiten besteht, die Blöcke genannt werden. Jeder Block enthält seine Metadaten und die angegebenen Informationen der Transaktion. Bisher haben wir nur einzelne Blöcke erstellt, richtig?! Wie würden Sie versuchen, eine sinnvolle Verbindung zwischen den einzelnen Blöcken herzustellen? Die Antwort besteht darin, jeden Block mithilfe einzigartiger zufälliger kryptografischer Funktionen, die als Hash bezeichnet werden, mit dem vorherigen Block zu verknüpfen. Jeder Block hat seinen eigenen Hash, der ein Primärschlüssel ist, und Sie können alle Blöcke durch Hashing in chronologischer Reihenfolge verknüpfen und so eine Kette bilden, die den gesamten Transaktionsverlauf innerhalb des Netzwerks darstellt.
C++ in Blockchain
C++ ist aufgrund seiner Geschwindigkeit, Flexibilität und Kontrolle eine der leistungsstärksten Sprachen, die in der Blockchain verwendet werden. Es wirkt Wunder bei der Handhabung komplexer Systeme, der Spieleentwicklung und bei Finanz-Anwendungen. Zweifellos ist es die vielseitigste Sprache!
C++ glänzt in der Blockchain aus mehreren Gründen. Es ermöglicht Entwicklern, effiziente Blockchain-Systeme zu erstellen, da es eine Low-Level-Speicherverwaltung bietet, die eine präzise Steuerung ermöglicht. Wir alle wissen, wie groß und sicher das Bitcoin-Netzwerk ist. Stellen Sie sich vor, wie komplex sein Kern sein muss, da er unzählige Transaktionen verarbeiten muss. Um diese gewaltige Aufgabe zu bewältigen, wurde daher C++ gewählt. Es gibt einige bedeutende Anwendungen, die mit C++ entwickelt wurden, wie Bitcoin, Lifecoin, Ripple, Monero und EOS.
Warum ist C++ eine ideale Sprache für die Blockchain-Entwicklung?
Schnellere Berechnungen
Leistungsstark
Effiziente Speicherverwaltung
Objektorientierte Funktionen
Unterstützt Multithreading
Kontrolle über Systemressourcen
Egal, ob Sie neu in der Blockchain sind oder die Grenzen des Möglichen erweitern möchten, C++ ist eine solide Wahl für die Erstellung langlebiger Anwendungen.
Blockchain-Konzepte mit C++ verstehen
Transaktionen: In der Blockchain sind Transaktionen die Essenz, die das gesamte System antreibt. Einzelne Blöcke sind wie sichere Tresore, die die wichtigen Informationen über den Austausch und den Wert der Transaktionen sowie die Teilnehmer enthalten. Diese Transaktionen sind die grundlegenden Aufzeichnungen, die die Geschichte erzählen, wer was, mit wem und wann ausgetauscht hat.
Säulen der Blockchain, die Sie kennen sollten
Dezentralisierung: Dezentralisierung ist der Grund, warum Blockchain im gesamten Technologiebereich hervorsticht. Was ist Dezentralisierung? Es ist eine Eigenschaft von Blockchain, bei der keine einzelne Entität die Kontrolle über die gesamte Datenbank hat. Dies macht das System fehlerresistent und verhindert jegliche Art von Verzerrungen. Jedes teilnehmende Gerät (Knoten) verwaltet eine Kopie der Blockchain, was Transparenz gewährleistet und zentralisierte Fehler oder Manipulationen verhindert.
Unveränderlichkeit: Sobald Sie Daten in die Blockchain geschrieben haben, können Sie diese nicht mehr ändern, ohne die nachfolgenden Blöcke zu ändern. Dies geschieht mithilfe von kryptografischem Hashing. Daher können alle einmal vorgenommenen Änderungen nicht mehr rückgängig gemacht werden, was sie unveränderlich macht.
Konsensmechanismen: Eine Reihe von Protokollen, die alle Notwendigkeiten der Blockchain regeln. Alle Knoten im Netzwerk müssen sich auf die Methoden einigen. Konsensmechanismen werden verwendet, um die Knoten zu optimieren und sicherzustellen, dass alle Knoten im Netzwerk auf dem gleichen Stand sind.
Bis jetzt haben Sie doch sicher alle Grundlagen der Blockchain verstanden, oder? Genug der Theorie! Tauchen wir jetzt in den praktischen Teil ein. Sind Sie bereit, sich die Hände schmutzig zu machen?
In diesem Abschnitt führen wir Sie durch den gesamten Prozess der Entwicklung einer einfachen Blockchain-Anwendung. Vom Einrichten der Umgebung bis hin zum Testen und Bereitstellen.
1. Einrichten der C++-Entwicklungsumgebung
Bevor Sie mit der Entwicklung beginnen, müssen alle Voraussetzungen erfüllt sein. In diesem Kapitel erfahren Sie, wie Sie die geeignete Entwicklungsumgebung einrichten können.
Installieren des C++-Compilers
Beginnen wir damit, zu verstehen, was ein Compiler ist.
Ein Compiler ist ein wichtiges Tool in der Softwareentwicklung. Er fungiert als Brücke zwischen dem von Ihnen geschriebenen, für Menschen lesbaren Code und dem Maschinencode, den der Prozessor Ihres Computers verstehen und ausführen kann. Wenn Sie Blockchain-Anwendungen in C++ entwickeln, müssen Sie sich zunächst einen zuverlässigen C++-Compiler zulegen. Dieses Tool übersetzt Ihren C++-Code in ausführbaren Maschinencode, sodass Ihre Blockchain-Anwendung effizient auf verschiedenen Systemen ausgeführt werden kann.
Um mit der Entwicklung zu beginnen, installieren Sie daher zunächst den mit Ihrem System kompatiblen C++-Compiler. Nachfolgend finden Sie die beliebtesten C++-Compiler, aus denen Sie wählen können:
GCC (GNU-Compiler-Sammlung):
Linux/MacOS:
Öffnen Sie das Terminal und geben Sie die folgenden Befehle ein
a)Ubuntu/Debian: sudo apt updatesudo apt install build-essentialb)Fedora sudo dnf install gcc gcc-c++c)MacOS (Befehlszeilentools) xcode-select –install
Windows: Für Windows-Benutzer ist das MinGW-w64-Projekt eine ausgezeichnete Wahl, da es einen Windows-Port des GCC (GNU Compiler Collection) bereitstellt und die Leistung von GCC in einer Windows-Umgebung bietet.
Schritte zur Installation:
Laden Sie das Installationsprogramm herunter, indem Sie die offizielle MinGW-w64-Website besuchen.
Führen Sie das Installationsprogramm nach dem Download aus
Wählen Sie die geeignete Architektur entsprechend Ihren Anforderungen
Befolgen Sie zur Fertigstellung die Schritte des Assistenten
Aktualisieren Sie das System (dies ist ein optionaler, aber empfohlener Schritt).
Klang:
Linux/MacOS: sudo apt install clang (auch clang ist in MacOS bereits installiert)Fedora: sudo dnf install clangWindows: Clang kann mit MinGW oder über das LLVM-Projektinstallationsprogramm installiert werden
MSVC (Microsoft Visual C++):
MSVC (Microsoft Visual C++) ist ein integraler Bestandteil von Visual Studio, einer robusten integrierten Entwicklungsumgebung (IDE), die von Microsoft entwickelt wurde. Visual Studio bietet eine umfassende Suite von Tools zum Entwickeln, Testen und Bereitstellen von Anwendungen. Bei der Installation wird MSVC automatisch auf Ihrem System eingerichtet.
Überprüfen Sie die Installation mit den folgenden Befehlen im Terminal oder in der Eingabeaufforderung:
g++ –version # Für GCCclang –version # Für Clangcl # Für MSVC
Auswählen einer IDE
Eine integrierte Entwicklungsumgebung (IDE) steigert die Produktivität, indem sie Tools wie Codevervollständigung, Debugging und Projektmanagement innerhalb einer einheitlichen Oberfläche bietet. Im Folgenden finden Sie einige häufig verwendete IDEs für die C++-Entwicklung:
Visual Studio: Laden Sie Visual Studio von der offiziellen Website herunter.
Und befolgen Sie dann die in der folgenden Tabelle aufgeführten Schritte:
CLion: Installation und Einrichtung:
CLion ist eine beliebte IDE und wird von JetBrains betrieben, erfordert allerdings ein Abonnement, bietet jedoch kostenlose Testversionen.
bietet kostenlose Testversionen an.
Visual Studio Code: Installieren und Einrichten von Erweiterungen für die C++-Entwicklung.
Installieren der erforderlichen Bibliotheken
Verwenden Sie Paketmanager, um wichtige Bibliotheken wie OpenSSL für kryptografische Funktionen zu installieren. Nachfolgend finden Sie die Schritte und verschiedene Bibliotheken für unterschiedliche Betriebssysteme und ihre Befehle.
Juhu, Sie haben Ihre Entwicklungsumgebung erfolgreich eingerichtet und können direkt mit der Ausführung des Codes in der IDE Ihrer Wahl beginnen.
2. Erstellen einer einfachen Blockchain mit C++
Bevor wir mit dem Schreiben des Codes beginnen, wollen wir uns mit den Komponenten einer Blockklasse vertraut machen.
Komponenten von Blockclass
Ein Index ist eine Ganzzahl, die die sortierte Reihenfolge von Blöcken chronologisch speichert und verwaltet.
Zeitstempel: Der Zeitstempel speichert in Form einer Zeichenfolge den Zeitpunkt, zu dem der Block erstellt wurde.
Transaktionen: Transaktionen speichern die Austauschinformationen zwischen den Teilnehmern und den aktuellen Status der Blockchain.
Vorheriger Hash und Hash: Der vorherige Hash speichert den kryptografischen Hash des vorherigen Blocks, während der Hash eine durcheinandergewürfelte oder gehashte Zeichenfolge kryptografischer Informationen ist.
Nonce: Eine Ganzzahl, die im Proof of Work (PoW)-Konsensalgorithmus verwendet wird. Fungiert als Zähler, der hochgezählt wird, um einen gültigen Hash zu finden, der das Schwierigkeitsziel erfüllt. Der Nonce ist entscheidend für den Mining-Prozess in PoW, wo die Miner darum konkurrieren, einen Nonce zu finden, der einen Hash mit einer bestimmten Anzahl führender Nullen generiert.
Lassen Sie uns jetzt alle Funktionen im Code implementieren:
Klasse Block {public: int index; std::string timestamp; std::vector<Transaction> transactions; std::string previousHash; std::string hash; int nonce; // Für PoW // Konstruktor Block(int idx, std::string time, std::vector<Transaction> txs, std::string prevHash) { index = idx; timestamp = time; Transaktionen = txs; vorherigerHash = vorherigerHash; nonce = 0; hash = berechneHash(); // Hash des aktuellen Blocks } // Methode zum Berechnen des Hashs des Blocks std::string berechneHash() { std::string stream ss; ss << index << timestamp << previousHash << nonce; // Transaktionsdaten und weitere Details zur Hash-Berechnung hinzufügen return sha256(ss.str()); // Platzhalter für die eigentliche Hash-Funktion } // Methode zum Minen des Blocks void mineBlock(int difficulty) { std::string target(difficulty, ‘0’); // Einen String mit Ziel-Hashes erstellen while (hash.substr(0, difficulty) != target) { nonce++; hash = calculateHash(); } }};
Wenn Sie mit der Definition der Blockklasse und ihrer Attribute fertig sind, können Sie mit der Erstellung des Genesis-Blocks fortfahren. Der Genesis-Block ist der erste Block in der Blockchain, der initialisiert werden muss und einen Index von Null hat. Nachdem Sie den Genesis-Block definiert haben, können Sie mit der Methode addblock() neue Blöcke zu Ihrer Blockchain hinzufügen. Unten finden Sie den Code:
Klasse Blockchain {public: std::vector<Block> Kette; Blockchain() { chain.push_back(createGenesisBlock()); } Block createGenesisBlock() { return Block(0, „01/01/2024“, „Genesis Block“, „0“); } Block getLatestBlock() { return chain.back(); } void addBlock(Block newBlock) { newBlock.previousHash = getLatestBlock().hash; newBlock.hash = newBlock.calculateHash(); chain.push_back(newBlock); }};
Erstellen und überprüfen Sie die Transaktion. Jede Transaktion hat ihre eigene ID, einen vordefinierten Konstruktor sowie die Absender- und Empfängerinformationen und den Betrag. Nachdem Sie eine Transaktion erstellt haben, müssen Sie sie mit der Methode validateTransaction() überprüfen.
Klasse Transaction {public: std::string sender; std::string recipient; double amount; std::string transactionID; // Konstruktor Transaction(std::string snd, std::string rcp, double amt, std::string txID) { sender = snd; recipient = rcp; Betrag = amt; transactionID = txID; } // Methode zum Validieren der Transaktion bool validateTransaction() { // Implementierung der Validierungslogik return true; // Platzhalter }};
3.Implementierung von Konsensmechanismen in C++
Bis jetzt haben Sie 25 % des Erstellungsprozesses abgeschlossen. Jetzt machen Sie weiter und implementieren die Konsensmechanismen für Ihren Block, der das Rückgrat der gesamten Anwendung bildet.
Arbeitsnachweis
Proof of Work (PoW) ist ein Konsensmechanismus, bei dem Mitglieder des Blockchain-Netzwerks/Miner eine Lösung für ein schwieriges rechnerisches mathematisches Problem finden müssen, bevor sie der Kette einen neuen Block hinzufügen können. Dabei handelt es sich im Wesentlichen um einen Prozess zum Finden einer bestimmten Zahl, einem sogenannten Nonce, der mit den Daten des Blocks, seinem Hash und anderen Details kombiniert wird, um einen Hashwert zu generieren, der mit einer bestimmten Anzahl führender Nullen beginnt. Dies macht den Prozess effizient und schützt das Netzwerk vor böswilligen Angriffen.
In C++ können Sie Proof of Work implementieren, indem Sie der Block-Klasse ein Proof-Attribut und eine Proof of Work-Methode hinzufügen. So können Sie das tun:
#einschließen <iostream>#einschließen <sstream>#einschließen <ctime>#einschließen <string>#einschließen <vector>#einschließen <openssl/sha.h>using namespace 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); für (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << hex << setw(2) << setfill(‘0’) << (int)hash[i]; } return ss.str();}Klasse Block {öffentlich: int index; string data; string previousHash; string hash; langer Beweis; time_t Zeitstempel; Block(int idx, string d, string prevHash) { index = idx; Daten = d; vorherigerHash = vorherigerHash; Zeitstempel = Zeit(nullptr); Beweis = 0; Hash = Hash berechnen(); } Zeichenfolge Hash berechnen() const { stringstream ss; ss << Index << Zeitstempel << Daten << vorherigerHash << Beweis; return sha256(ss.str()); } void proofOfWork(int Schwierigkeit) { string Ziel (Schwierigkeit, „0“); do { proof++; hash = berechneHash(); während (hash.substr(0, Schwierigkeit) != Ziel); }}; Klasse Blockchain {öffentlich: Vektor<Block> Kette; int Schwierigkeit; Blockchain (int diff) { Schwierigkeit = diff; chain.emplace_back (Block (0, „Genesis Block“, „0“)); } void addBlock (Zeichenfolge Daten) { Block neuerBlock (chain.size(), Daten, chain.back().hash); newBlock.proofOfWork (Schwierigkeit); if (isValidProof(newBlock)) { chain.push_back(newBlock); } } bool isValidProof(const Block& block) const { return block.hash.substr(0, Schwierigkeit) == string(Schwierigkeit, „0“);
Im obigen Codeausschnitt können wir sehen, dass wir zuerst einen Beweis und einen Hash zum Block hinzufügen müssen. Dann legen wir den Schwierigkeitsgrad des Beweises fest und analysieren ihn. Danach können wir den Beweis validieren.
4. Erstellen einer einfachen Blockchain-API mit C++
API – Eine Anwendungsprogrammierschnittstelle ist ein Tool, mit dem verschiedene Softwareanwendungen miteinander interagieren können. In der Blockchain erleichtern APIs die Interaktion mit den vordefinierten Blockchain-Daten, sodass Entwickler die Anwendungen schnell erstellen können, ohne die gesamte zugrunde liegende Struktur des Netzwerks kennen zu müssen. APIs helfen bei der Integration der Blockchain in andere Plattformen, wie etwa Web- oder Mobilanwendungen. Daher sind APIs für eine effiziente Entwicklung und Integration erforderlich.
Einrichten der API-Umgebung
Installieren und konfigurieren Sie die zum Erstellen von APIs mit C++ erforderlichen Tools, wie in der folgenden Tabelle beschrieben:
Erstellen der API
#include <cpprest/http_listener.h>#include <cpprest/json.h>#include „blockchain.h“mit Namespace Web;mit Namespace http;mit Namespace Utility;mit Namespace http::experimental::listener;Blockchain blockchain(4); // Schwierigkeitsgrad 4void handleGet(http_request request) { json::value response = json::value::array(); int i = 0; für (auto& block : blockchain.chain) { json::value block_json; block_json[U(„index“)] = json::value::number(block.index); block_json[U(„Daten“)] = json::Wert::Zeichenfolge(block.Daten); block_json[U(„vorherigerHash“)] = json::Wert::Zeichenfolge(block.vorherigerHash); block_json[U(„Hash“)] = json::Wert::Zeichenfolge(block.hash); block_json[U(„Nachweis“)] = json::Wert::Zahl(block.Nachweis); block_json[U(„Zeitstempel“)] = json::Wert::Zahl(block.Zeitstempel); Antwort[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(„Block erfolgreich hinzugefügt“));}).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 << „Listening on http://localhost:8080“ << endl;while (true);} catch (Ausnahme const&e) {cerr << e.what() << endl; }return 0;}
handleGet ruft die gesamte Blockchain im JSON-Format ab.
handlePost fügt der Blockchain unter Verwendung der Daten aus der POST-Anfrage einen neuen Block hinzu.
Ausführen und Testen der Anwendung
Ausführen der Anwendung
Sobald Sie gemäß dem Softwareentwicklungszyklus mit den Kernfunktionen des Codes fertig sind, müssen Sie mit dem entscheidenden und unvermeidlichen Schritt fortfahren, nämlich dem Kompilieren und Testen der gesamten Anwendung. Dies ist äußerst wichtig, um sicherzustellen, dass die Komponenten in der Anwendung wie erwartet ausgeführt werden.
Kompilieren Sie den Code: g++ -o blockchain_api blockchain_api.cpp -lboost_system -lcrypto -lssl -lcpprestFühren Sie die ausführbare Datei aus: ./blockchain_api
Der obige Code startet den API-Server auf http://localhost:8080.
Testen mit Postman
Testen Sie die API-Endpunkte mit Postman oder curl:
Einen Block hinzufügen:
Methode: POST
URL: http://localhost:8080
Text: JSON-Format
{ „data“: „Dies ist ein neuer Block“}
Blockchain anzeigen:
Methode: GET
URL: http://localhost:8080
Beispiel für das Hinzufügen eines Blocks und Anzeigen der Blockchain mithilfe der mit C++ erstellten API.
void handleGet(http_request request) { json::value response = json::value::array(); int i = 0; für (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::Wert::Zeichenfolge(block.hash); block_json[U(„Nachweis“)] = json::Wert::Zahl(block.Nachweis); block_json[U(„Zeitstempel“)] = json::Wert::Zahl(block.Zeitstempel); Antwort[i++] = block_json; } Anfrage.Antwort(Statuscodes::OK, Antwort); }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(„Block erfolgreich hinzugefügt“)) }).wait();}
Die Funktion handlePost verarbeitet das Hinzufügen von Blöcken, indem sie Daten aus dem JSON-Text extrahiert und der Blockchain einen neuen Block hinzufügt.
Die Funktion handleGet ruft die gesamte Blockchain ab und sendet sie als JSON-Antwort zurück.
6.Live-Beispiel zum Erstellen einer Blockchain-Anwendung mit C++
Schrittweise Ausführung
Schritt 1: Erstellen Sie die Blockklasse mit den erforderlichen Attributen mithilfe der C++-Syntax.
#include <iostream>#include <ctime>#include <string>#include <sstream>#include <vector>#include <openssl/sha.h>using namespace std;class Block {public: int index; string data; string previousHash; string hash; long proof; time_t timestamp; Block(int idx, const string& data, const string& prevHash) : index(idx), data(data), previousHash(prevHash), proof(0), timestamp(time(nullptr)) { hash = calculateHash(); } string calculateHash() const { stringstream ss; ss << index << timestamp << data << previousHash << proof; return sha256(ss.str()); } void proofOfWork(int schwierigkeit) { string ziel(schwierigkeit, „0“); do { proof++; hash = calculateHash(); } während (hash.substr(0, schwierigkeit) != ziel); }privat: Zeichenfolge sha256 (const string & input) const { vorzeichenloser 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; für (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << hex << setw(2) << setfill(‘0’) << (int)hash[i]; } return ss.str(); }};
Schritt 2: Implementieren Sie die Methode calculateHash.
#include <iostream>#include <sstream>#include <iomanip>#include <openssl/sha.h>Klasse Block {public: int index; std::string data; std::string previousHash; std::string hash; long proof; time_t Zeitstempel; Block(int idx, const std::string& data, const std::string& prevHash) : index(idx), data(data), previousHash(prevHash), proof(0), timestamp(time(nullptr)) { hash = calculateHash(); } std::string calculateHash() const { std::stringstream ss; ss << index << timestamp << data << previousHash << proof; return sha256(ss.str()); }privat: std::string sha256(const std::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); std::stringstream ss; für (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << std::hex << std::setw(2) << std::setfill(‘0’) << (int)hash[i]; } return ss.str(); }};
Schritt 3: Definieren Sie die Blockchain-Klasse und initialisieren Sie sie mit einem Genesis-Block.
Klasse Blockchain {öffentlich: Blockchain(int Schwierigkeit) : Schwierigkeit(Schwierigkeit) { chain.emplace_back(Block(0, „Genesis Block“, „0“)); } void addBlock(const string& data) { Block newBlock(chain.size(), data, chain.back().hash); newBlock.proofOfWork(Schwierigkeit); chain.push_back(newBlock); } const Block& latestBlock() const { return chain.back(); } Vektor<Block> chain;privat: int Schwierigkeit;};
Schritt 4: Implementieren Sie die Methode calculateHash.
#include <iostream>#include <sstream>#include <iomanip>#include <openssl/sha.h>Klasse Block {public: int index; std::string data; std::string previousHash; std::string hash; long proof; time_t Zeitstempel; Block(int idx, const std::string& data, const std::string& prevHash) : index(idx), data(data), previousHash(prevHash), proof(0), timestamp(time(nullptr)) { hash = calculateHash(); } std::string calculateHash() const { std::stringstream ss; ss << index << timestamp << data << previousHash << proof; return sha256(ss.str()); }privat: std::string sha256(const std::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); std::stringstream ss; für (int i = 0; i < SHA256_DIGEST_LENGTH; i++) { ss << std::hex << std::setw(2) << std::setfill(‘0’) << (int)hash[i]; } return ss.str(); }};
Schritt 5: Definieren Sie die Blockchain-Klasse und initialisieren Sie sie mit einem Genesis-Block.
Klasse Blockchain {öffentlich: Blockchain(int Schwierigkeit) : Schwierigkeit(Schwierigkeit) { chain.emplace_back(Block(0, „Genesis Block“, „0“)); } void addBlock(const string& data) { Block newBlock(chain.size(), data, chain.back().hash); newBlock.proofOfWork(Schwierigkeit); chain.push_back(newBlock); } const Block& latestBlock() const { return chain.back(); } Vektor<Block> chain;privat: int Schwierigkeit;};
Schritt 6: Richten Sie die API-Umgebung für die Verarbeitung von Anfragen mit einer geeigneten C++-Bibliothek ein.
#include <cpprest/http_listener.h>#include <cpprest/json.h>mit Namespace Web;mit Namespace Web::http;mit Namespace Web::http::experimental::listener;Klasse 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 << „Blockchain-API läuft …“ << endl; }Privat:http_listener listener; Blockchain& blockchain;void handleGet(http_request request) {json::value response = json::value::array();int i = 0;für (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, Antwort); }void handlePost(http_request Anfrage) {request.extract_json().then([&](json::value requestData) {string data = requestData[U(„Daten“)].as_string();blockchain.addBlock(Daten);request.reply(status_codes::OK, U(„Block erfolgreich hinzugefügt“));}) . wait () ; }} ;
Schritt 7: Testen Sie die Anwendung, indem Sie einen neuen Block abbauen und die Blockchain mit Postman oder curl verifizieren.
Main:int main() { Blockchain blockchain(4); // Schwierigkeitsgrad BlockchainAPI api(„http://localhost:8080“, blockchain); api.start(); return 0;}Testing:curl -X POST http://localhost:8080 -H „Content-Type: application/json“ -d ‘{„data“:“Dies ist ein neuer Block“}’
Bei der Blockchain-Entwicklung mit C++ geht es um mehr als nur ums Programmieren. Es geht darum, die grundlegenden Elemente dezentraler Systeme aufzubauen, die das Potenzial haben, zahlreiche Branchen zu revolutionieren.
Zusammenfassend haben wir alles abgedeckt, von den Grundlagen der C++-Programmierung für Blockchain bis hin zur Bereitstellung und Prüfung der Anwendung.
Nach Abschluss dieses Moduls können Sie sich eingehender mit Optimierungskonzepten wie Skalierbarkeit, Sicherheitspraktiken, erweiterten Konsensmechanismen und Smart Contracts befassen.
Bleiben Sie neugierig, lernen Sie kontinuierlich dazu und programmieren Sie weiter. Mögen Ihre Beiträge die Zukunft der Technologie vorantreiben!