Basic blockchain implementation in the C programming language

 

Here's an example of a basic blockchain implementation in the C programming language:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <openssl/sha.h>

#define BLOCK_DATA_SIZE 255

#define BLOCK_HASH_SIZE 65

#define BLOCK_NONCE_RANGE 1000000

typedef struct {

    int index;

    time_t timestamp;

    char data[BLOCK_DATA_SIZE];

    char previous_hash[BLOCK_HASH_SIZE];

    char hash[BLOCK_HASH_SIZE];

    int nonce;

} Block;

char* calculate_hash(const Block* block) {

    char input_string[BLOCK_DATA_SIZE + BLOCK_HASH_SIZE + BLOCK_HASH_SIZE + sizeof(int)];

    sprintf(input_string, "%d%ld%s%s%d", block->index, block->timestamp, block->data, block->previous_hash, block->nonce);

    unsigned char hash[SHA256_DIGEST_LENGTH];

    SHA256((unsigned char*)input_string, strlen(input_string), hash);

    char* output_hash = malloc(BLOCK_HASH_SIZE * sizeof(char));

    for (int i = 0; i < SHA256_DIGEST_LENGTH; ++i) {

        sprintf(output_hash + 2 * i, "%02x", hash[i]);

    }

    output_hash[BLOCK_HASH_SIZE - 1] = '\0';

    return output_hash;

}

void mine_block(Block* block, int difficulty) {

    char prefix[difficulty + 1];

    for (int i = 0; i < difficulty; ++i) {

        prefix[i] = '0';

    }

    prefix[difficulty] = '\0';

    while (strncmp(block->hash, prefix, difficulty) != 0) {

        block->nonce++;

        free(block->hash);

        block->hash = calculate_hash(block);

    }

    printf("Block mined: %s\n", block->hash);

}

Block* create_block(int index, const char* data, const char* previous_hash) {

    Block* block = malloc(sizeof(Block));

    block->index = index;

    block->timestamp = time(NULL);

    strncpy(block->data, data, BLOCK_DATA_SIZE);

    strncpy(block->previous_hash, previous_hash, BLOCK_HASH_SIZE);

    block->hash = calculate_hash(block);

    block->nonce = rand() % BLOCK_NONCE_RANGE;

    return block;

}

int main() {

    srand(time(NULL));

    Block* genesis_block = create_block(0, "Genesis Block", "");

    mine_block(genesis_block, 2);

    Block* block1 = create_block(1, "Data 1", genesis_block->hash);

    mine_block(block1, 2);

    Block* block2 = create_block(2, "Data 2", block1->hash);

    mine_block(block2, 2);

    free(genesis_block->hash);

    free(genesis_block);

    free(block1->hash);

    free(block1);

    free(block2->hash);

    free(block2);

    return 0;

}

In this example, we use the OpenSSL library for the SHA-256 hashing function. Each block in the blockchain has an index, timestamp, data, previous hash, current hash, and a nonce value. The calculate_hash function calculates the SHA-256 hash for a given block, and the mine_block function performs the proof-of-work process by finding a hash with a specified number of leading zeros (difficulty level).

The create_block function is used to create new blocks with the provided data and previous hash. The main function demonstrates the creation and mining of blocks.

Please note that this is a simplified implementation for educational purposes and does not include advanced features like dynamic block storage