Understanding Blockchain by building one

Why Blockchain?

• Decentralized: Transactions happen on a network of computers.

• Immutability: If a transaction is created, it can not be modified

• Open: All the transactions are visible to all the nodes.

• Security: Due to the encryption feature, Blockchain is almost always secure

Prerequisites

• Working knowledge of classes and other ES6 features in Typescript.

• NodeJS installed on the machine.

Getting Started with the Block

• Data to record on the blockchain, e.g., transaction data.

• A block hash - which is the ID of the block generated using cryptographic techniques.

• The previous block’s hash in the chain. It is recorded in every block to link it to the chain and improve its security.

• A timestamp of when the block was created and added to the blockchain.

• Proof of Work (PoW), which is the amount of effort taken to derive the current block’s hash (we will be using this consensus since Proof of Stake (PoS) is beyond this article).

Defining the Block Class having the above properties

import { createHash } from 'crypto';

export type Transaction = {
    from: string;
    to: string;
    amount: number;
    comment?: string;
};

export type Blockdata = {
    transactions: Transaction[];
};

export class Block {
    data: Blockdata;
    hash: string;
    previousHash: string;
    timestamp: Date;
    pow: number;

    constructor(data: Blockdata, previousHash: string) {
        this.data = data;
        this.hash = '0';
        this.previousHash = previousHash;
        this.timestamp = new Date();
        this.pow = 0;
    }
}

Calculating the hash of the Block

static calculateHash(block: Block): string {
    const blockData = JSON.stringify(block.data);
    const hashInput = blockData + block.previousHash + block.timestamp.toISOString() + block.pow.toString();

    return createHash('sha256').update(hashInput).digest('hex');
}

• Converted the block’s data to JSON format so that we can concat it with other information as a string.

• Concatenated the block’s previous hash, data, timestamp, and proof of work (PoW).

• Generating the hash for the earlier concatenation with the SHA256 algorithm.

• Returned the hashing result in base 16, with lowercase letters for A-F.

Mining new Blocks

public mine(difficulty: number): void {
    // create a regex with template literal string to dynamically reflect the difficulty
    const regex = new RegExp(`^(0){${difficulty}}.*`);

    // recalculate the hash as long as the hash not matches the regex
    while (!this.hash.match(regex)) {
        this.pow++;
        this.hash = Block.calculateHash(this);
    }
}

Define the Blockchain class

import { Block, Blockdata } from './Block';

export class Blockchain {
    public genesisBlock: Block;
    public chain: Block[];
    public difficulty: number;
    public blockTime: number;

    constructor(genesisBlock: Block, chain: Block[], difficulty: number, blockTime: number) {
        this.genesisBlock = genesisBlock;
        this.chain = chain;
        this.difficulty = difficulty;
        this.blockTime = blockTime;
    }

    static create(difficulty: number, blockTime: number): Blockchain {
        const genesisBlockData: Blockdata = {
            transactions: [{ from: '', to: '', amount: 0 }]
        };
        const genesisBlock = new Block(genesisBlockData, '');

        return new Blockchain(genesisBlock, [genesisBlock], difficulty, blockTime);
    }
}

Adding new blocks to the blockchain

public addBlock(data: Blockdata): void {
    const blockData = data;
    const lastBlock = this.chain[this.chain.length - 1];
    const newBlock = new Block(blockData, lastBlock.hash);

    // mine the newly created block and add to chain
    newBlock.mine(this.difficulty);
    this.chain.push(newBlock);

    // adjust difficulty according to mining speed
    this.difficulty += Date.now() - newBlock.timestamp.getTime() > this.blockTime ? -1 : 1;
}

• Collects the details of a transaction (sender, receiver, and transfer amount) from the parameter.

• Creates a new block with the transaction details.

• Mines the new block with the mine method of the Block class.

• Push the newly created block to the chain property of the blockchain.

Validating the Blockchain

public isValid(): Boolean {
    if (this.chain.length === 1) return true;
    for (let index = 1; index < this.chain.length; index++) {
        const currentBlock = this.chain[index];
        const previousBlock = this.chain[index - 1];
        if (
            currentBlock.hash !== Block.calculateHash(currentBlock) ||
            previousBlock.hash !== currentBlock.previousHash
        )
            return false;
    }
    return true;
}

Testing the Blockchain

import { Blockdata } from './Block';
import { Blockchain } from './Blockchain';

// create a new blockchain
const blockchain = Blockchain.create(3 /* difficulty */, 10000 /* blockTime in ms */);

// add transactions for first block data
const firstBlockdata: Blockdata = {
    transactions: [
        { from: 'Alice', to: 'Bob', amount: 10 },
        { from: 'Bob', to: 'Alice', amount: 5 }
    ]
};

// add transactions for second block data
const secondBlockdata: Blockdata = {
    transactions: [{ from: 'John', to: 'Jane', amount: 100 }]
};

// add blocks to the chain
blockchain.addBlock(firstBlockdata);
blockchain.addBlock(secondBlockdata);

// log out current state of the blockchain
console.log('Blockchain state after adding two blocks:');
console.dir(blockchain, { depth: null });

// check if blockchain is valid
console.log(`Blockchain valid: ${blockchain.isValid()}`); // true - since we haven't tampered with it

// tampering with the chain, i.e. the evil hacker would do this to get rich
blockchain.chain[1].data.transactions[0] = {
    from: 'Alice',
    to: 'Bob',
    amount: 100,
    comment: 'evil hacker tampered the original tx'
};
blockchain.chain[2].data.transactions.push({
    from: 'Alice',
    to: 'Hacker',
    amount: 100,
    comment: 'evil hacker injected this tx'
});

// log out state of the blockchain after tampering with it
console.log('Blockchain state after tampering:');
console.dir(blockchain, { depth: null });

// check if blockchain is still valid after tampering with it
console.log(`Blockchain valid: ${blockchain.isValid()}`); // false - tampered with the blockchain

Bonus: Block time and difficulty adjustment

new difficulty = old difficulty * (2016 blocks * 10 minutes) / mining time of the previous 2016 blocks

Conclusion