What is Bitcoin Mining?

Bitcoin mining is the process of adding new blocks to the Bitcoin blockchain by solving complex cryptographic puzzles. Miners compete to find a hash that meets the network's difficulty target. This simulation demonstrates how mining works in a simplified way.

How to Run the Simulation

To run the Bitcoin mining simulation, follow these steps:

1. Create a new file named BitcoinMiningSimulationTest.mts.
2. Copy the script below into the file.
3. Run the script using the command tsx BitcoinMiningSimulationTest.mts.

import crypto from 'crypto';

// Bitcoin block structure
class Block {
    version: number;
    previousHash: string;
    merkleRoot: string;
    timestamp: number;
    bits: number;
    nonce: number;
    hash: string;
    transactions: string[];

    constructor(version: number, previousHash: string, transactions: string[], bits: number) {
        this.version = version;
        this.previousHash = previousHash;
        this.merkleRoot = this.calculateMerkleRoot(transactions);
        this.timestamp = Math.floor(Date.now() / 1000);
        this.bits = bits;
        this.nonce = 0;
        this.transactions = transactions;
        this.hash = '';
    }

    // Calculating the root of a transaction
    private calculateMerkleRoot(transactions: string[]): string {
        if (transactions.length === 0) return crypto.createHash('sha256').update('').digest('hex');
        let hashes = transactions.map(tx => crypto.createHash('sha256').update(tx).digest('hex'));
        while (hashes.length > 1) {
            if (hashes.length % 2 !== 0) {
                hashes.push(hashes[hashes.length - 1]);
            }
            let newHashes: string[] = [];
            for (let i = 0; i < hashes.length; i += 2) {
                let combinedHash = crypto.createHash('sha256').update(hashes[i] + hashes[i + 1]).digest('hex');
                newHashes.push(combinedHash);
            }
            hashes = newHashes;
        }
        return hashes[0];
    }

    // Generating block hash
    private calculateHash(): string {
        const header = this.version + this.previousHash + this.merkleRoot + this.timestamp + this.bits + this.nonce;
        return crypto.createHash('sha256').update(header).digest('hex');
    }

    // Mining process simulation
    mineBlock(difficulty: number): void {
        console.log(`Mining block with difficulty: ${difficulty}`);
        const target = '0'.repeat(difficulty);
        do {
            this.nonce++;
            this.hash = this.calculateHash();
            if (this.nonce % 10000 === 0) {
                console.log(`Nonce: ${this.nonce}, Hash: ${this.hash}, Timestamp: ${this.timestamp}`);
            }
        } while (!this.hash.startsWith(target));
        console.log(`Block mined! Nonce: ${this.nonce}, Hash: ${this.hash}, Timestamp: ${this.timestamp}`);
    }
}

// Blockchain simulation
class Blockchain {
    chain: Block[];
    difficulty: number;

    constructor(difficulty: number) {
        this.chain = [this.createGenesisBlock()];
        this.difficulty = difficulty;
    }

    // Starting block
    private createGenesisBlock(): Block {
        return new Block(1, '0'.repeat(64), ['Genesis Block'], this.difficulty);
    }

    // Adding a new block
    addBlock(transactions: string[]): void {
        const previousBlock = this.chain[this.chain.length - 1];
        const newBlock = new Block(1, previousBlock.hash, transactions, this.difficulty);
        console.log(`Starting mining process for new block with transactions: ${JSON.stringify(transactions)}`);
        newBlock.mineBlock(this.difficulty);
        this.chain.push(newBlock);
        console.log(`Block added: ${JSON.stringify(newBlock, null, 2)}`);
    }
}

// Run the simulation
const difficulty = 5;
const blockchain = new Blockchain(difficulty);
console.log("Genesis Block created: ", JSON.stringify(blockchain.chain[0], null, 2));
blockchain.addBlock(["Alice pays Bob 1 BTC", "Charlie pays Dave 2 BTC"]);
blockchain.addBlock(["Eve pays Frank 3 BTC", "George pays Henry 4 BTC"]);
blockchain.addBlock(["Ivan pays Jack 5 BTC", "Karen pays Leo 6 BTC"]);

Example Output

Here is an example of the output generated by the script:

Genesis Block created:  {
  "version": 1,
  "previousHash": "0000000000000000000000000000000000000000000000000000000000000000",
  "merkleRoot": "89eb0ac031a63d2421cd05a2fbe41f3ea35f5c3712ca839cbf6b85c4ee07b7a3",
  "timestamp": 1742498796,
  "nonce": 0,
  "hash": "",
  "transactions": [
    "Genesis Block"
  ]
}
Starting mining process for new block with transactions: ["Alice pays Bob 1 BTC","Charlie pays Dave 2 BTC"]
Mining block with difficulty: 5
Nonce: 10000, Hash: eebabb10926865cc117d6170367e494e1d0f5f61da15779e63608b2566d02614, Timestamp: 1742498796
Nonce: 20000, Hash: 3b3a8443ab7bc8933d53579df420988fc7dbcf640e714728f1cbe70363a3bb6d, Timestamp: 1742498796
Nonce: 30000, Hash: 93140918acc0c83a6e6784db46c9afbe7fe282aeea920c78823a9b4c4b1f719f, Timestamp: 1742498796
Nonce: 40000, Hash: f1f13016e3720302cdf188304b0999309d181a9e3106211647d1a0f0f6131f77, Timestamp: 1742498796
Nonce: 50000, Hash: fd84bd1fb1295fd8a7df1c66cfcc12eb5b3998729c1fb3260f31f6a170e930dd, Timestamp: 1742498796
Nonce: 60000, Hash: 28bb30522c21bac2b49646fee7b9c4cdfa585498ebd32079c4ec873a803c0082, Timestamp: 1742498796
Nonce: 70000, Hash: bb09ab6f94ca641fe6ac29163a81ee4dae8267df8cf7c428108685348e9cf2ac, Timestamp: 1742498796
Nonce: 80000, Hash: a83172b8e4ff09108b5a071c00524fae9199cf149d95dd561da7b65c66671e6f, Timestamp: 1742498796
Nonce: 90000, Hash: 20bd6c36611191c8353528d8422a47738ab0142a8cf268eb3de219d80302e421, Timestamp: 1742498796
Nonce: 100000, Hash: 382724176ede672fe1bbf234b4d5451903303fa560b8fd5a261c086241649237, Timestamp: 1742498796
Nonce: 110000, Hash: 175c968520c1f7803c492cc04530d9a9ce70b4459e6135f4170a93a3867b4d2a, Timestamp: 1742498796
Nonce: 120000, Hash: e374696b183a5f234fa3e343b23db3598310f659756e2e90f7ae0fa19df45a9d, Timestamp: 1742498796
Nonce: 130000, Hash: 84acfd13f5268e4690120cbf966f15e03525005d0426fb4202751bd840905ddb, Timestamp: 1742498796
Nonce: 140000, Hash: b185a3656909b3dfce29645040e7abb0ae37d71f5b7fce325e9d52bdeb0b047f, Timestamp: 1742498796

Important Notes

• This is a simulation with a difficulty of 5. Do not attempt higher difficulties as they require significantly more computational resources.
• The mining process is simplified for educational purposes and does not represent real-world Bitcoin mining.
• Always ensure your system has sufficient resources before running simulations.

Why C++?

Bitcoin was originally implemented using the C++ programming language. Satoshi Nakamoto, the anonymous creator of Bitcoin, chose C++ for its efficiency, low-level memory manipulation, and strong object-oriented capabilities. These characteristics made it ideal for developing a decentralized and secure cryptocurrency system that required precise control over computational resources.

The core Bitcoin software, known as Bitcoin Core, is still primarily written in C++, although some components have been implemented in other languages such as Python for testing and scripting purposes.

Example of Early Bitcoin Code (C++)

The following is a simplified example of a basic structure from the Bitcoin Core source code written in C++:

#include <iostream>
#include <vector>
#include <sstream>
#include <ctime>
#include <openssl/sha.h>

// Function to calculate SHA-256 hash
std::string sha256(const std::string& input) {
    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 << (int)hash[i];
    }
    return ss.str();
}

// Block structure
class Block {
public:
    int index;
    std::string previousHash;
    std::string hash;
    std::string data;
    long timestamp;
    int nonce;

    Block(int idx, std::string prevHash, std::string blkData)
        : index(idx), previousHash(prevHash), data(blkData) {
        timestamp = std::time(0);
        nonce = 0;
        hash = mineBlock();
    }

    std::string calculateHash() const {
        std::stringstream ss;
        ss << index << previousHash << timestamp << data << nonce;
        return sha256(ss.str());
    }

    std::string mineBlock(int difficulty = 4) {
        std::string prefix(difficulty, '0');  // Required number of leading zeros
        do {
            nonce++;
            hash = calculateHash();
        } while (hash.substr(0, difficulty) != prefix);
        return hash;
    }
};

// Blockchain structure
class Blockchain {
public:
    std::vector<Block> chain;

    Blockchain() {
        chain.push_back(createGenesisBlock());
    }

    Block createGenesisBlock() {
        return Block(0, "0", "Genesis Block");
    }

    void addBlock(std::string data) {
        Block newBlock(chain.size(), chain.back().hash, data);
        chain.push_back(newBlock);
    }

    void printBlockchain() const {
        for (const auto& block : chain) {
            std::cout << "Block #" << block.index << "\n";
            std::cout << "Previous Hash: " << block.previousHash << "\n";
            std::cout << "Current Hash: " << block.hash << "\n";
            std::cout << "Data: " << block.data << "\n";
            std::cout << "Nonce: " << block.nonce << "\n";
            std::cout << "Timestamp: " << block.timestamp << "\n";
            std::cout << "---------------------------\n";
        }
    }
};

int main() {
    Blockchain myBlockchain;

    std::cout << "Mining Block 1...\n";
    myBlockchain.addBlock("First Transaction Data");

    std::cout << "Mining Block 2...\n";
    myBlockchain.addBlock("Second Transaction Data");

    myBlockchain.printBlockchain();

    return 0;
}

This example demonstrates a simple blockchain implementation in C++, including block creation, mining, and validation.

Evolution of Bitcoin Development

As Bitcoin evolved, various other programming languages have been used for different components of the ecosystem:

• Python: Used for testing, scripting, and data analysis.
• Go (Golang): Implemented in alternative Bitcoin clients like btcd.
• Rust: Used in some projects for its memory safety and performance benefits.
• JavaScript/TypeScript: Used in Bitcoin-related web applications and APIs.

Despite these alternatives, C++ remains the primary language for Bitcoin Core due to its performance, security, and control over system resources.

Official Resources

• Bitcoin Official Website
• Bitcoin GitHub Repository
• Learn About Mnemonics (BIP39)
• Explanation of Addresses, Transactions, Blocks, Tools, and Terms