Blockchain

Building a Blockchain Application with C++

2 months ago
Bitcoin Ethereum News

Introduction

Blockchain technology has fundamentally transformed finance and supply chain management by offering decentralized, transparent, and secure mechanisms that eliminate the need for intermediaries.

Why should one build a blockchain application?

Blockchain applications provide enhanced Data integrity and security and provide a trustless environment for sharing information. With blockchain, one can implement smart contracts, and create digital tokens that open up the doors to New Economic models like Decentralized Finance(DeFi) and tokenized assets, etc 

This article is a quick 10-minute tour into the world of Blockchain development through C++. 

Basics of Blockchain

Blockchain is a digital chain made up of single secure and tamper-proof units called blocks. Each block contains its metadata and the designated information of the transaction. So far, we have just created individual blocks right?! How would you try to establish a connection between each block in a meaningful way? The answer is by linking each block to its previous block with the help of unique random cryptographic functions known as hash. Each block has its own hash which is a primary key and you can link all the blocks through hashing in chronological order, forming a chain that represents the entire history of transactions within the network.

C++ in Blockchain

C++ is one of the most powerful languages used in blockchain due to its speed, flexibility, and control. It works wonders while handling complex systems, game development, and financial applications. No doubt it is the most versatile language!

C++ shines in blockchain for multiple reasons. It allows developers to build efficient blockchain systems due to its low-level memory management that provides precision control.We all know how huge and secure the Bitcoin network is. Imagine how complex its core must be, as it needs to handle countless transactions. Hence, to manage this daunting task, C++ was chosen. There are some significant applications developed using C++ like Bitcoin, Lifecoin, Ripple, Monero, and EOS.

Why C++ is an ideal language for blockchain development?

  • Faster computations
  • High-performance
  • Efficient memory management
  • Object oriented features
  • Supports Multi-threading
  • Control over system resources 

Whether you’re new to blockchain or aiming to push the limits of what’s possible, C++ is a solid choice for building long-lasting applications.

Understanding Blockchain Concepts with C++

Transactions: In blockchain, transactions are the essence, that drives the entire system. Individual blocks are like Secure vaults which hold the prestigious information of exchange and value of the transactions along with the participants. These transactions are the fundamental records that tell the story of who exchanged what, with whom, and when.

Pillars of Blockchain You Should Know

Decentralization: Decentralization is the reason why blockchain stands out in the entire tech domain. What is Decentralization? It is a property of blockchain by which no single entity holds control over the entire database. This makes the system robust to failures and inhibits any kind of biases.  Each participant device (node) maintains a copy of the blockchain, ensuring transparency and preventing centralized failure or manipulation.

Immutability: Once you write any data into blockchain you cannot alter it without changing the subsequent blocks. This is done with the help of cryptographic hashing. Hence all the changes done once can’t be undone making it immutable.

Consensus Mechanisms:  A set of protocols governing all the necessities of blockchain. All nodes in the network need to agree on the methods. Consensus mechanisms are used to streamline the nodes and ensure all the nodes in the network are on the same page.

Till now you must have understood all the basics of blockchain right? Enough of Theory! Let’s dive into the practical part now. Ready to get your hands dirty?

In this section, we will walk you through the entire process of a simple blockchain application development. Right from setting up the environment to testing and deployment.

1.Setting Up the C++ Development Environment

    Before you start development, having all the prerequisites is essential. In this chapter, we are going to look at how you can have the appropriate development environment.

    Installing C++ Compiler

    Let’s start by understanding what a compiler is.

     A compiler is a crucial tool in software development, acting as a bridge between the human-readable code you write and the machine code that your computer’s processor can understand and execute. In the context of developing blockchain applications in C++, your first step is to equip yourself with a reliable C++ compiler. This tool will translate your C++ code into executable machine code, enabling your blockchain application to run efficiently on various systems.

    Hence to start the development first install the C++ Compiler compatible with your system. Below are the popular C++ compilers you can choose from:

    GCC(GNU Compiler collection):

    Linux/MacOS:

    Open the terminal and type the commands given below respectively

    a)Ubuntu/Debian:
    sudo apt update
    sudo apt install build-essential

    b)Fedora 
    sudo dnf install gcc gcc-c++

    c)MacOS(command line tools)
    xcode-select –install

     Windows: For Windows users, the MinGW-w64 project is an excellent choice as it provides a Windows port of the GCC (GNU Compiler Collection), offering the power of GCC within a Windows environment.

    Steps to Install:

    • Download the installer by visiting the official MinGW-w64 website.
    • Run the installer after the download
    • Select the suitable architecture as per your needs
    • Follow the wizard steps for completion
    • Update the system(This is an optional step but recommended).

      Clang:

    Linux/MacOS: sudo apt install clang (also clang is already installed in MacOS)
    Fedora: sudo dnf install clang
    Windows: Clang can be installed using MinGW or via the LLVM project installer

    MSVC (Microsoft Visual C++): 

    MSVC (Microsoft Visual C++) is an integral component of Visual Studio, a robust Integrated Development Environment (IDE) developed by Microsoft. Visual Studio provides a comprehensive suite of tools for developing, testing, and deploying applications, and installing it will automatically set up MSVC on your system.

    Verify installation using the following commands in the terminal or command prompt:

    g++ –version  # For GCC
    clang –version  # For Clang
    cl  # For MSVC

    Choosing an IDE

    An Integrated Development Environment (IDE) boosts productivity by offering tools such as code completion, debugging, and project management within a unified interface. Below are some widely-used IDEs for C++ development:

    Visual Studio: Download the Visual Studio from the official website.

    And the follow the following steps as mentioned in the table below:

    CLion: Installation and setup:

    CLion is a popular IDE and is powered by JetBrains but requires a subscription however provides free trials.

    provides free trials.

    Visual Studio Code: Install and set up extensions for C++ development.

    Installing Required Libraries

    Use package managers to install essential libraries like OpenSSL for cryptographic functions. Below are the steps and various libraries for different Operating systems and their commands.

    Yay, you have successfully set up your development environment you can directly start executing the code in the IDE of your choice.

    2.Building a Simple Blockchain with C++

      Before we kickstart the journey of writing the code let’s understand the components of a block class.

      Components of Blockclass

      • An index is an integer that stores and maintains the sorted order of blocks chronologically.
      • Timestamp: The time stamp stores the instance at which the block was created in the form of a string. 
      • Transactions:  Transactions store the information of exchange between the participants and the state of the blockchain at that time.
      • Previous hash and Hash: Previous hash stores the cryptographic hash of the previous block whereas the hash is a string of cryptographic information jumbled or hashing.
      • Nonce: An integer used in the Proof of Work (PoW) consensus algorithm.Acts as a counter that is incremented to find a valid hash that meets the difficulty target. The nonce is crucial for the mining process in PoW, where miners compete to find a nonce that generates a hash with a specific number of leading zeros.

      Let’s implement all the features in code now:

      class Block {
      public:    
      int index;    
      std::string timestamp;    
      std::vector transactions;    
      std::string previousHash;    
      std::string hash;    
      int nonce; // For PoW
          
      // Constructor    
      Block(int idx, std::string time, std::vector txs, std::string prevHash) {        
      index = idx;        
      timestamp = time;        
      transactions = txs;        
      previousHash = prevHash;        
      nonce = 0;        
      hash = calculateHash(); // Hash of the current block    
      }
          // Method to calculate the hash of the block    
      std::string calculateHash() {        
      std::stringstream ss;        
      ss << index << timestamp << previousHash << nonce;        
      // Add transaction data and any additional details to the hash calculation        
      return sha256(ss.str()); // Placeholder for actual hash function    
      }
         
       // Method to mine the block    
      void mineBlock(int difficulty) {        
      std::string target(difficulty, ‘0’); // Create a string of target hash        
      while (hash.substr(0, difficulty) != target) {            
      nonce++;            
      hash = calculateHash();       
        }    
      }
      };

      Once you are done with defining the blockclass and its attributes you can further go and create the genesis block. Genesis block is the first block in blockchain that needs to be initialized and has an index of zero. After defining the genesis block you can further go on and add new blocks to your blockchain by using the addblock() method.Below you can find the code: 

      class Blockchain {
      public:    
      std::vector chain;
          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);    
      }
      };

      Create and verify the transaction. Each transaction has its own ID, a predefined constructor ,and the sender and recipient information along with the amount. After creating a transaction, you need to verify it using the method validateTransaction().

      class Transaction {public:    
      std::string sender;    
      std::string recipient;    
      double amount;    
      std::string transactionID;
          
      // Constructor    Transaction(std::string snd, std::string rcp, double amt, std::string txID) {        
      sender = snd;        
      recipient = rcp;        
      amount = amt;        
      transactionID = txID;    
      }
          // Method to validate transaction    
      bool validateTransaction() {       
       // Implementation of validation logic        
      return true; // Placeholder    
      }
      };

      3.Implementing Consensus Mechanisms in C++

         Till now, you have completed 25% of the building process. Now, you move forward and implement the consensus mechanisms for your block, which is the backbone of the entire application.

        Proof of Work

        Proof of Work (PoW) is a consensus mechanism by which members of the blockchain network/ miners, must find a solution to  difficult computational mathematical problem before they can add a new block to the chain.This is essentially a process of finding a specific number, called a nonce, which is combined with the block’s data, its hash, and other details to generate a hash value that starts with a certain number of leading zeros. This makes the process efficient and protects the network from malicious attacks.

        In C++, you can implement Proof of Work by adding a proof attribute and a proof of work method to the Block class. Here’s how you can do it:

        #include
        #include
        #include
        #include
        #include
        #include
        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);    
        stringstream ss;    
        for(int i = 0; i < SHA256_DIGEST_LENGTH; i++) {        
        ss << hex << setw(2) << setfill(‘0’) << (int)hash[i];    
        }    
        return ss.str();
        }
        class Block {
        public:    
        int index;    
        string data;    
        string previousHash;    
        string hash;    
        long proof;    
        time_t timestamp;
            
        Block(int idx, string d, string prevHash) {        
        index = idx;        
        data = d;        
        previousHash = prevHash;        
        timestamp = time(nullptr);        
        proof = 0;        
        hash = calculateHash();   
         }
            string calculateHash() const {        
        stringstream ss;        
        ss << index << timestamp << data << previousHash << proof;        
        return sha256(ss.str());    
        }
            void proofOfWork(int difficulty) {        
        string target(difficulty, ‘0’);        
        do {            
        proof++;            
        hash = calculateHash();        
        } while (hash.substr(0, difficulty) != target);    
        }
        };
        class Blockchain {
        public:    
        vector chain;    
        int difficulty;
            
        Blockchain(int diff) {        
        difficulty = diff;        
        chain.emplace_back(Block(0, “Genesis Block”, “0”));   
        }
            void addBlock(string data) {        
        Block newBlock(chain.size(), data, chain.back().hash);        
        newBlock.proofOfWork(difficulty);        
        if (isValidProof(newBlock)) {            
        chain.push_back(newBlock);        
        }    
        }
            bool isValidProof(const Block& block) const {        
        return block.hash.substr(0, difficulty) == string(difficulty,
        ‘0’);    
        }
        };

        In the above code snippet, we can see that first, we need to add a proof and a hash to the block. Then, decide the difficulty of the proof and mine it. After this, you can validate the proof.

        4.Creating a Simple Blockchain API with C++

           API- Application programming Interface is a tool that allows different software applications to interact with each other.In blockchain APIs make it easier to  interact with the predefined blockchain data hence developers can quickly build the applications without needing to know the entire underlying structure of the network. APIs help integrate blockchain with other platforms, like web or mobile applications. Hence APIs are necessary to enable efficient development and integration.

          Setting Up the API Environment

          Install and configure tools required for creating APIs with C++ as mentioned in the table below:

          Building the API

          #include
          #include
          #include “blockchain.h”

          using namespace web;
          using namespace http;
          using namespace utility;
          using namespace http::experimental::listener;

          Blockchain blockchain(4); // difficulty level 4

          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(“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) {        
          auto data = requestData[U(“data”)].as_string();
          blockchain.addBlock(data);
          request.reply(status_codes::OK, U(“Block added successfully”));
          }).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 (exception const& e) {
          cerr << e.what() << endl;
             }
          return 0;
          }

          handleGet retrieves the entire blockchain in JSON format.

          handlePost adds a new block to the blockchain using the data from the POST request.

          Running and Testing the Application

            Running the Application

            Once you are done with the core functionalities of the code according to the software development cycle you need to hop on the most crucial and inevitable step of compiling and testing the whole application. This is most important to confirm that the components in the application run as expected.

            Compile the code:
            g++ -o blockchain_api blockchain_api.cpp -lboost_system -lcrypto -lssl -lcpprest

            Run the Executable:.
            /blockchain_api

            The above code starts the API server on http://localhost:8080.

            Testing with Postman

            • Test the API endpoints using Postman or curl:
            • Add a Block:
            • Method: POST
            • URL: http://localhost:8080
            • Body: JSON format
            {  
            “data”: “This is a new block”
            }

            View Blockchain:

            • Method: GET
            • URL: http://localhost:8080

            Example of adding a block and viewing the blockchain using the API created with 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(“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) {        
            auto data = requestData[U(“data”)].as_string();
            blockchain.addBlock(data);
            request.reply(status_codes::OK, U(“Block added successfully”)) 
            }).wait();
            }

            The handlePost function processes the block addition by extracting data from the JSON body and adding a new block to the blockchain.

            The handleGet function retrieves the entire blockchain and sends it back as a JSON response.

            6.Live Example of Building a Blockchain Application with C++

               Step-by-Step Execution

              Step 1: Create the Block class with necessary attributes using C++ syntax.

              #include
              #include
              #include
              #include
              #include
              #include

              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 difficulty) {        
              string target(difficulty, ‘0’);        
              do {            
              proof++;            
              hash = calculateHash();        
              } while (hash.substr(0, difficulty) != 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;        
              for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {            
              ss << hex << setw(2) << setfill(‘0’) << (int)hash[i];        
              }        
              return ss.str();    
              }
              };

              Step 2: Implement the calculateHash method.

              #include
              #include
              #include
              #include

              class Block {
              public:    
              int index;    
              std::string data;    
              std::string previousHash;    
              std::string hash;    
              long proof;    
              time_t timestamp;
                  
              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());   
               }

              private:    
              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;        
              for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {            
              ss << std::hex << std::setw(2) << std::setfill(‘0’) << (int)hash[i];       
               }        
              return ss.str();   
                }
              };

              Step 3: Define the Blockchain class and initialize it with a genesis block.

              class Blockchain {
              public:    
              Blockchain(int difficulty)        
              : difficulty(difficulty) {        
              chain.emplace_back(Block(0, “Genesis Block”, “0”));    
              }
                  void addBlock(const string& data) {        
              Block newBlock(chain.size(), data, chain.back().hash);        
              newBlock.proofOfWork(difficulty);        
              chain.push_back(newBlock);    
              }
                  const Block& latestBlock() const {        
              return chain.back();    
              }
                  vector chain;

              private:    
              int difficulty;
              };

              Step 4: Implement the calculateHash method.

              #include
              #include
              #include
              #include

              class Block {
              public:    
              int index;    
              std::string data;    
              std::string previousHash;    
              std::string hash;    
              long proof;    time_t timestamp;
                  
              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());    
              }
              private:    
              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;        
              for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {            
              ss << std::hex << std::setw(2) << std::setfill(‘0’) <<
              (int)hash[i];        
              }        
              return ss.str();    
              }
              };

              Step 5: Define the Blockchain class and initialize it with a genesis block.

              class Blockchain {
              public:    
              Blockchain(int difficulty)        
              : difficulty(difficulty) {        
              chain.emplace_back(Block(0, “Genesis Block”, “0”));    
              }
                  
              void addBlock(const string& data) {        
              Block newBlock(chain.size(), data, chain.back().hash);        
              newBlock.proofOfWork(difficulty);        
              chain.push_back(newBlock);    
              }
                  const Block& latestBlock() const {        
              return chain.back();    }
                  
              vector chain;

              private:    
              int difficulty;};

              Step 6: Set up the API environment to handle requests using a suitable C++ library.

              #include
              #include

              using namespace web;
              using namespace web::http;
              using namespace web::http::experimental::listener;

              class 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 running…” << endl;    
              }

              Private:
              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(“Block added successfully”));
              }) . wait () ;
              }
              } ;

              Step 7: Test the application by mining a new block and verifying the blockchain using Postman or curl.

              Main:
              int main() {    
              Blockchain blockchain(4);  // Difficulty level
                  
              BlockchainAPI api(“http://localhost:8080”, blockchain);    
              api.start();
                  
              return 0;

              }

              Testing:
              curl -X POST http://localhost:8080 -H “Content-Type: application/json” -d ‘{“data”:”This is a new block”}’

              Embarking on blockchain development with C++ is more than just coding; it’s about building the foundational elements of decentralized systems that have the potential to revolutionize various industries.

              To sum up we have covered everything from the basics of C++ programming for blockchain to the deployment and testing of the application.

              As you have completed this module you can further explore the concepts of optimization like Scalability, Security practices, advanced Consensus Mechanisms, and smart contracts. 

              Stay curious, embrace continuous learning, and keep coding.May your contributions drive the future of technology!

              Source: https://coinpedia.org/blockchain-developers/building-a-blockchain-application-with-c/