C-20200127 - Blockchain Code Snippets

Problem Statement

In this task, you will develop a simple blockchain simulation using the Proof of Stake (PoS) consensus mechanism. Your system should allow for validator registration and selection based on their stake in the network. Each validator has a certain number of coins they have staked as collateral to participate in block validation. The probability of being selected to validate a block is proportional to the amount of coins staked.

Implement a basic blockchain structure that includes blocks with transactions, previous hash references, and timestamps. Additionally, create a mechanism for validators to register their stake and a function to randomly select a validator based on their stake weight. When a new transaction is added, it must be validated by the selected validator before being committed to the blockchain.

Ensure your simulation can handle concurrent transactions and maintain consistency in the blockchain state.

Concepts

Proof of Stake
Validator Selection
Blockchain Transactions

Constraints

Use JavaScript or Python for implementation
Blockchain should support at least 5 different types of transactions (e.g., transfer, registration, stake update)
Validator selection mechanism must be implemented using a weighted random algorithm

Security Notes

Ensure that all transaction validations are performed securely to prevent double spending and other attacks
Implement basic error handling for invalid transactions or stake modifications
Consider edge cases where all validators might have zero stakes

Solutions

C Solution

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

#define MAX_TRANSACTIONS 10
#define BLOCK_SIZE 5
#define TRANSACTION_TYPES 5

typedef enum {
    TRANSFER,
    REGISTRATION,
    STAKE_UPDATE,
    OTHER_TYPE_1,
    OTHER_TYPE_2
} TransactionType;

struct Validator {
    char name[30];
    int stake;
};

struct Transaction {
    TransactionType type;
    char details[100];
};

struct Block {
    struct Transaction transactions[BLOCK_SIZE];
    int transactionCount;
    unsigned long previousHash;
    time_t timestamp;
};

struct Blockchain {
    struct Block blocks[MAX_TRANSACTIONS / BLOCK_SIZE];
    int blockCount;
};

unsigned long calculateBlockHash(struct Block* block) {
    // Simple hash calculation (not secure)
    unsigned long hash = 5381;
    for (int i = 0; i < block->transactionCount; i++) {
        for (int j = 0; j < strlen(block->transactions[i].details); j++) {
            hash = ((hash << 5) + hash) + block->transactions[i].details[j];
        }
    }
    return hash;
}

void addTransaction(struct Blockchain* blockchain, struct Transaction transaction) {
    if (blockchain->blocks[blockchain->blockCount - 1].transactionCount >= BLOCK_SIZE) {
        blockchain->blockCount++;
    }
    int index = blockchain->blocks[blockchain->blockCount - 1].transactionCount++;
    blockchain->blocks[blockchain->blockCount - 1].transactions[index] = transaction;
}

struct Validator* selectValidator(struct Validator validators[], int validatorCount) {
    if (validatorCount == 0) return NULL;
    int totalStake = 0;
    for (int i = 0; i < validatorCount; i++) {
        totalStake += validators[i].stake;
    }
    int randomValue = rand() % totalStake + 1;
    for (int i = 0; i < validatorCount; i++) {
        if (randomValue <= validators[i].stake) return &validators[i];
        randomValue -= validators[i].stake;
    }
    return NULL;
}

void createBlockchain(struct Blockchain* blockchain) {
    blockchain->blockCount = 1;
    memset(blockchain->blocks, 0, sizeof(blockchain->blocks));
}

int main() {
    srand(time(NULL));
    struct Validator validators[] = {{"Validator1", 10}, {"Validator2", 50}, {"Validator3", 40}};
    int validatorCount = sizeof(validators) / sizeof(struct Validator);
    struct Blockchain blockchain;
    createBlockchain(&blockchain);

    // Adding transactions
    addTransaction(&blockchain, (struct Transaction){TRANSFER, "Transfer 100 coins"});
    addTransaction(&blockchain, (struct Transaction){REGISTRATION, "Register new user"});
    addTransaction(&blockchain, (struct Transaction){STAKE_UPDATE, "Update stake amount"});

    // Selecting validator and validating transactions
    for (int i = 0; i < blockchain.blockCount; i++) {
        struct Validator* selectedValidator = selectValidator(validators, validatorCount);
        if (selectedValidator) {
            printf("Selected Validator: %s with stake: %d\n", selectedValidator->name, selectedValidator->stake);
            for (int j = 0; j < blockchain.blocks[i].transactionCount; j++) {
                // Validate transaction
                printf("Transaction validated by %s: Type=%d, Details="%s"\n",
                       selectedValidator->name,
                       blockchain.blocks[i].transactions[j].type,
                       blockchain.blocks[i].transactions[j].details);
            }
        } else {
            printf("No validators available to validate transactions.\n");
        }
    }

    return 0;
}

This C program simulates a simple blockchain using the Proof of Stake (PoS) consensus mechanism.
The Blockchain structure contains an array of Blocks, each Block holds up to BLOCK_SIZE Transactions. Each Transaction has a type and details.
Validators are represented with a name and stake amount, determining their probability of being selected for block validation.
addTransaction adds new transactions to the blockchain, creating new blocks when necessary.
selectValidator implements a weighted random selection algorithm based on validators' stakes.
createBlockchain initializes the blockchain with an empty first block.
The main function demonstrates adding transactions to the blockchain and selecting a validator to validate each block's transactions. It prints out selected validators and validated transaction details. The program uses simple hash calculation for demonstration purposes, which is not secure in real-world applications.