Application of C Language in Blockchain Technology: Underlying Implementation

Blockchain technology has become a focal point in recent years, characterized by decentralization, immutability, and transparency. While many modern programming languages (such as Python, JavaScript, etc.) are widely used in blockchain development, C language still plays a significant role in some underlying implementations due to its efficiency and direct control over hardware.

This article will introduce how to build a simple blockchain using C language, with code examples to help beginners understand its basic principles.

Basic Concepts of Blockchain

Before diving into the code, let’s first understand the basic components of a blockchain:

1. Block: Each block contains a set of transaction data and a hash value pointing to the previous block.
2. Hash Function: A method that converts data of arbitrary length into a fixed-length string, commonly used to ensure data integrity.
3. Chain: Multiple blocks connected in chronological order form an immutable data structure.

Implementing a Simple Blockchain in C

Next, we will gradually build a simple single-threaded, single-node blockchain. Our goal is to create a small program that can add new blocks and display the entire chain’s content.

1. Define Structures

First, we need to define two structures: one for representing individual transaction information and another for representing the entire block information.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef struct Transaction {
    char sender[50];
    char receiver[50];
    float amount;
} Transaction;

typedef struct Block {
    int index;
    time_t timestamp;
    Transaction transaction;
    char previousHash[64];
    char hash[64];
} Block;

typedef struct Blockchain {
    Block *blocks;
    int size;
} Blockchain;

2. Create Hash Function

Next, we need to create a hash function to generate a unique identifier for each new block. Here we use the SHA256 algorithm to compute the hash value.

#include <openssl/sha.h>

void calculateHash(Block *block) {
    char input[256];
    sprintf(input, "%d%ld%s%f%s", block->index, block->timestamp,
            block->transaction.sender, block->transaction.amount,
            block->previousHash);
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256((unsigned char*)input, strlen(input), hash);
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        sprintf(&block->hash[i*2], "%02x", hash[i]);
    }
}

3. Initialize the Genesis Block

The genesis block is a special type of block that is the first to be added to the blockchain. It has no predecessor, so it is processed differently from other ordinary blocks:

Block createGenesisBlock() {
   Block genesisBlock;
   genesisBlock.index = 0;
   genesisBlock.timestamp = time(NULL);
   strcpy(genesisBlock.transaction.sender, "Genesis");
   strcpy(genesisBlock.transaction.receiver, "FirstUser");
   genesisBlock.transaction.amount = 0.0f; // Genesis transaction amount is zero
   strcpy(genesisBlock.previousHash, "0"); // No predecessor, so set to "0"
   calculateHash(&genesisBlock);
   return genesisBlock;
}

4. Add New Transactions to the Blockchain

Now we can write a function to add new transactions to the blockchain and generate the corresponding new block:

void addTransaction(Blockchain *blockchain, Transaction transaction) {
    Block newBlock;
    newBlock.index = blockchain->size;
    newBlock.timestamp = time(NULL);
    newBlock.transaction = transaction;
    if (blockchain->size == 0) {
        strcpy(newBlock.previousHash, "0");
    } else {
        strcpy(newBlock.previousHash, blockchain->blocks[blockchain->size - 1].hash);
    }
    calculateHash(&newBlock);
    blockchain->blocks = realloc(blockchain->blocks, (sizeof(Block) * (blockchain->size + 1)));
    if (blockchain->blocks == NULL) {
        printf("Memory allocation failed\n");
        exit(1);
    }
    blockchain->blocks[blockchain->size] = newBlock;
    blockchain->size++;
}

5. Display the Entire Blockchain Content

Finally, we need to write a method to display the entire blockchain content to view all added blocks:

void displayBlockchain(Blockchain *blockchain) {
    for (int i = 0; i < blockchain->size; i++) {
        printf("Index: %d\n", blockchain->blocks[i].index);
        printf("Timestamp: %s", ctime(&blockchain->blocks[i].timestamp));
        printf("Sender: %s\n", blockchain->blocks[i].transaction.sender);
        printf("Receiver: %s\n", blockchain->blocks[i].transaction.receiver);
        printf("Amount: %.2f\n", blockchain->blocks[i].transaction.amount);
        printf("Previous Hash: %s\n", blockchain->blocks[i].previousHash);
        printf("Current Hash: %s\n\n", blockchain->blocks[i].hash);
    }
}

Complete Code Example and Main Program

Below is the complete code, including the main program part, which can be run to test the functionality:

int main() {
    Blockchain myBlockchain;
    myBlockchain.blocks = NULL;
    myBlockchain.size = 0;
    
    // Create the genesis block
    myBlockchain.blocks = (Block *)malloc(sizeof(Block));
    if (myBlockchain.blocks == NULL) {
        fprintf(stderr, "Memory allocation failed!\n");
        return EXIT_FAILURE;
    }
    myBlockchain.blocks[myBlockchain.size] = createGenesisBlock();
    myBlockchain.size++;
    
    // Add new transactions
    Transaction tx1 = {"Alice", "Bob", 10};
    addTransaction(&myBlockchain, tx1);
    
    Transaction tx2 = {"Bob", "Charlie", 20};
    addTransaction(&myBlockchain, tx2);
    
    // Display the entire blockchain
    displayBlockchain(&myBlockchain);
    free(myBlockchain.blocks);
    return EXIT_SUCCESS;
}

Conclusion

Through the above steps, we have successfully implemented a simple text-based single-node blockchain using C language. In this process, we learned how to define data structures, compute hash values, and manage dynamic memory. These are essential foundational knowledge for understanding more complex and real-world blockchain systems. I hope this article helps you get started with the integration of C language and blockchain technology.