Creating a Blockchain in Java

Creating a simple blockchain in Java involves defining the core components of a blockchain, such as blocks, chains, and mining (Proof of Work) mechanism. Blockchain technology is decentralized, secure, and transparent, and it forms the foundation of various applications, especially in cryptocurrencies like Bitcoin.

In this example, we will create a basic blockchain with the following components:

• Block: Represents each block in the blockchain.
• Blockchain: Manages the chain of blocks.
• Proof of Work: A consensus algorithm to secure the blockchain.
• Cryptographic Hashing: Ensures the integrity and immutability of the blocks.

Let’s break down the steps and the code to build a simple blockchain in Java.

---

Steps to Create a Blockchain in Java:

1. Define the Block class
   • Each block contains the index, timestamp, data, previous block’s hash, and its own hash.
2. Define the Blockchain class
   • The blockchain class contains the list of blocks and methods to add blocks to the chain.
3. Implement Proof of Work (Mining)
   • In this example, we’ll implement the Proof of Work mechanism to add blocks to the chain.
4. Cryptographic Hashing
   • We’ll use the SHA-256 hash function to secure the blocks.

---

1. Defining the Block Class

The Block class will represent a single block in the blockchain. Each block will store:

• Index: The position of the block in the chain.
• Timestamp: The time when the block was created.
• Data: The data (usually transaction information) stored in the block.
• Previous Hash: The hash of the previous block to ensure the chain structure.
• Hash: The unique hash of the current block, generated based on the block’s contents.
• Nonce: A value used for Proof of Work (mining).

import java.security.MessageDigest;
import java.util.Date;

public class Block {
    private int index;
    private String timestamp;
    private String data;
    private String previousHash;
    private String hash;
    private int nonce;

    // Constructor to initialize a block
    public Block(int index, String timestamp, String data, String previousHash) {
        this.index = index;
        this.timestamp = timestamp;
        this.data = data;
        this.previousHash = previousHash;
        this.hash = calculateHash();  // Generate hash initially
    }

    // Method to calculate the hash of the block
    public String calculateHash() {
        String input = index + timestamp + data + previousHash + nonce;
        return applySha256(input);  // Apply SHA-256 hashing
    }

    // SHA-256 hash function
    public static String applySha256(String input) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(input.getBytes());
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                hexString.append(String.format("%02x", b));
            }
            return hexString.toString();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // Implementing Proof of Work (Mining)
    public void mineBlock(int difficulty) {
        String target = new String(new char[difficulty]).replace('\0', '0');  // Target string (difficulty level)
        while (!hash.substring(0, difficulty).equals(target)) {
            nonce++;  // Increment nonce
            hash = calculateHash();  // Recalculate the hash with the new nonce value
        }
        System.out.println("Block mined: " + hash);  // Print the mined block hash
    }

    // Getter for block hash
    public String getHash() {
        return hash;
    }

    @Override
    public String toString() {
        return "Block #" + index + "\nTimestamp: " + timestamp + "\nData: " + data + "\nHash: " + hash + "\nPrevious Hash: " + previousHash + "\n";
    }
}

2. Defining the Blockchain Class

The Blockchain class will manage the list of blocks. It will contain methods for adding blocks to the chain and ensuring the chain’s integrity.

import java.util.ArrayList;
import java.util.List;

public class Blockchain {
    private List<Block> chain;
    private int difficulty;

    // Constructor to initialize the blockchain
    public Blockchain(int difficulty) {
        this.chain = new ArrayList<>();
        this.difficulty = difficulty;
        // Create the first (genesis) block
        this.chain.add(createGenesisBlock());
    }

    // Create the first block in the blockchain (genesis block)
    private Block createGenesisBlock() {
        return new Block(0, "01/01/2022", "Genesis Block", "0");
    }

    // Add a new block to the blockchain
    public void addBlock(Block newBlock) {
        newBlock.mineBlock(difficulty);  // Mine the block before adding
        this.chain.add(newBlock);  // Add block to the chain
    }

    // Get the block at a specific index
    public Block getBlock(int index) {
        return this.chain.get(index);
    }

    // Get the size of the blockchain
    public int getChainSize() {
        return this.chain.size();
    }

    public static void main(String[] args) {
        Blockchain blockchain = new Blockchain(3);  // Set difficulty level to 3 (easy mining)

        // Add blocks to the blockchain
        blockchain.addBlock(new Block(1, "02/01/2022", "First Block", blockchain.getBlock(blockchain.getChainSize() - 1).getHash()));
        blockchain.addBlock(new Block(2, "03/01/2022", "Second Block", blockchain.getBlock(blockchain.getChainSize() - 1).getHash()));

        // Print the entire blockchain
        for (int i = 0; i < blockchain.getChainSize(); i++) {
            System.out.println(blockchain.getBlock(i));
        }
    }
}

3. Running the Blockchain

When you run the Blockchain class, it will:

• Create the blockchain with a difficulty of 3.
• Add two blocks to the blockchain.
• Print out the details of each block, including the hash, previous hash, data, and mining process.

Example Output:

Block mined: 000a5f6d3d953b9c0f78a4d127ee24404101f7b5f5f877c593fa8da9147f2cb3
Block mined: 000db7b5e32b221a68b9f7c7bfa93dbe2a3c0b1a3f6e2c4d27c52b69c6d1e6a4
Block #0
Timestamp: 01/01/2022
Data: Genesis Block
Hash: 54e043bedc576edc9b08fe6bfa9c5b4f44b5f1d57b4f87ed898c08ee1d0bc993
Previous Hash: 0

Block #1
Timestamp: 02/01/2022
Data: First Block
Hash: 000a5f6d3d953b9c0f78a4d127ee24404101f7b5f5f877c593fa8da9147f2cb3
Previous Hash: 54e043bedc576edc9b08fe6bfa9c5b4f44b5f1d57b4f87ed898c08ee1d0bc993

Block #2
Timestamp: 03/01/2022
Data: Second Block
Hash: 000db7b5e32b221a68b9f7c7bfa93dbe2a3c0b1a3f6e2c4d27c52b69c6d1e6a4
Previous Hash: 000a5f6d3d953b9c0f78a4d127ee24404101f7b5f5f877c593fa8da9147f2cb3

In the example above:

• The genesis block is created with a fixed previous hash ("0").
• The mineBlock() method ensures that blocks are mined by solving a Proof of Work puzzle.
• Each block’s hash is calculated based on its index, timestamp, data, previous block’s hash, and nonce.

---