Blockchain Java

Blockchain is a budding technology that has tremendous scope in the coming years. In this tutorial, we will briefly cover the basic concepts of Blockchain. We'll also create a basic Blockchain program in Java to understand how it works in the programming world.

What is Blockchain?

Blockchain is a continuously growing list of records, known as blocks, which are linked and secured using cryptography.

Blockchain is the modern technology that stores data in the form of block data connected through cryptography and cryptocurrencies such as Bitcoin. It was introduced by Stuart Haber and W. Scott Tornetta in 1991. It is a linked list where the nodes are the blocks in the Blockchain, and the references are hashes of the previous block in the chain. References are cryptographic hashes when dealing with link lists. The references are just basically objects. So every single node will store another node variable, and it will be the reference to the next node. In this case, the references are cryptographic hashes.

Blockchain uses hash pointers to reference the previous node in a long list. We assign a hash to every single node because this is how we can identify them.

To generate a hash, the SHA256 algorithm is used. One of the most important advantages of this algorithm is that it is generic, so it is a generic cryptographic hash function wherein the input can be anything.

Deterministic: It means that if we apply the same hash-function (SHA256) on the same input, the output must be the same.
One-way: It is easy to generate the hash with the given hashing algorithm, but on the other hand, it is tough (time-consuming) to restore the original input. It is like a trap-door function.
Collision-free: There are no collisions in SHA256 (ok, there are but with extremely low probability). It means that no two different inputs share the same output hash, and this is good. We want to make these hashes unique, this is how we identify a block in the Blockchain.
Avalanche effect: A slight change in the input results in a completely different output hash. Otherwise, a cryptanalyst can make predictions about the input based on the output exclusively.

Blockchain Block Diagram

Let's understand the Blockchain concept with the help of a diagram

Genesis Block: The first block in the blockchain is called the Genesis block. The software constructed it. So, for example, when dealing with Bitcoin cryptocurrency, bitcoin itself created the first block. There is no data associated with this block. The previous hash value is all zeros. And, of course, it has a hash value. For example: Hash = 056FH.
Block 1: The next block in the blockchain will have some data. For example, it could contain the transactions data. The previous hash incorporates the hash value of the Genesis Block. Therefore the Previous Hash = 056FH
Every node has a hash. So, in this case, the hash of the first block = HJI66
Block 2: The next block is also going to have some data of other transactions. The previous hash value is going to be the hash of Block 1. So this is why we have been discussing that references are cryptographic hashes. Therefore the Previous Hash = HJI66
The second block will contain its own hash value. Therefore Hash = ZU77F.
Block 3: It will also contain the data of transactions. The previous hash is going to be the hash of the previous block. Therefore the Previous Hash = ZU77F.
The second block will contain its own hash value. Therefore Hash = ZU77F.

So basically, this is the underlying data structure. We have various blocks that store data, such as transactions when dealing with cryptocurrencies. Every single block has two hashes, i.e., the hash of the previous node and the hash value of the actual block. And these hash values are going to be the references of the previous blocks.

Implementing Blockchain in Java

Though we are implementing the Blockchain in Java, you can create the code in your preferred OOPs (Object Oriented Programming) language.

Step 1: Defining the constants

First of all, let's take a look at the Constants. In this program, we will create a private constructor to prevent this class from being instantiated as we will store public, static and final variables such as difficulty, minor reward and the previous hash value of the first block, which is called the Genesis block.

Refer to the given below program to create the constants in Java:

Costant.java

package com.balazsholczer.blockchain;

public class Constants_Program {

	private Constants() {
		
	}
//difficult in mining is defined by the leading zeros
//here, the difficulty is set to 1 so, it will have 1 zero
	public static final int DIFFICULTY = 1;

	public static final double MINER_REWARD = 10;

// previous hash value is going to contain all zeros because 
//the Genesis block is the first block of the block chain. 
//Therefor it has no previous block and we will manually assign it
	public static final String GENESIS_PREV_HASH = "0000000000000000000000000000000000000000000000000000000000000000";

}

STEP 2: Generating Hashes:

In this step, we will implement the SHA256Helper. It is pretty convenient to implement this procedure in Java because we rely on the built methods and built-in classes of Java security.

Firstly we will import the MessageDigest, and further will generate the hash for our Blockchain.

Question: How many SHA256 hashes are there?

Answer: One hash takes up 256 bits in memory with binary values 0 and 1. Therefore, we can conclude that the total number of hashes is 2256. If you are dealing with hexadecimal values, there are 64 hexadecimal characters; therefore, it yields 1664 hash values.

Refer to the given below program to generate the Blockchain hashes in Java:

SHA256Helper.java

package com.balazsholczer.blockchain;
import java.security.MessageDigest;

public class SHA256Helper {

    public static String generateHash(String data) {
        try {
	// we will get the instance of SHA256
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
	//by using  digest() function, we will get has as one dimensional byte array
            byte[] hash = digest.digest(data.getBytes("UTF-8"));
            //we wanna use hexadecimal values not bytes in our program
            // will covert byte into hexadecimal
            StringBuffer hexadecimalString = new StringBuffer();
            for (int i = 0; i < hash.length; i++) { 
                String hexadecimal = Integer.toHexString(0xff & hash[i]);
                if (hexadecimal.length() == 1) hexadecimalString.append('0');
                hexadecimalString.append(hexadecimal);
		    }
		return hexadecimalString.toString();
	    } 
        catch (Exception e) {
        throw new RuntimeException(e);
        }
    }

}

STEP 3: Creating Blocks

The block is the fundamental building block of the Blockchain. These blocks are cryptographically linked together based on the hash values. For creating a block, a Block class is implemented, and further in that class, several variables are defined, such as the id of the block, the timestamp, the hash of the block, the previous hash in the Blockchain, the transactions, and the nonce.

Refer to the given below program to create the block in Java:

Block.java

package com.balazsholczer.blockchain;
import java.util.Date;

public class Block {
private int id;
private int nonce;
// the below variable is used to store the timestamp of the block in milliseconds.
private long timeStamp;
//the variable hash will contain the hash of the block
private String hash;
//The previousHash variable contains the hash of the previous block
private String previousHash;
private String transaction;

public Block(int id, String transaction, String previousHash) {

	this.id = id;

	this.transaction = transaction;

	this.previousHash = previousHash;

	this.timeStamp = new Date().getTime();

	generateHash();

}

public void generateHash() {

	String dataToHash = Integer.toString(id) + previousHash + Long.toString(timeStamp) + Integer.toString(nonce) + transaction.toString();

	String hashValue = SHA256Helper.generateHash(dataToHash);

	this.hash = hashValue;

}

public String getHash() {

	return this.hash;

}
	
public void setHash(String hash) {

	this.hash = hash;

}

public String getPreviousHash() {

	return this.previousHash;

}

public void setPreviousHash(String previousHash) {

	this.previousHash = previousHash;
}

public void incrementNonce() {

	this.nonce++;
}

@Override

public String toString() {

	return this.id+"-"+this.transaction+"-"+this.hash+"-"+this.previousHash+"-";

}

}

Step 4: Implementing Blockchain

In this program, we will store the generated blocks in an ArrayList.

BlockChain.java

package com.balazsholczer.blockchain;

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

public class BlockChain {
	//instantiating the list of blocks
	private List<Block> blockChain;

	public BlockChain() {
		//further, instantiating the list as an ArrayList
		this.blockChain = new ArrayList<>();
	}

	public void addBlock(Block block) {
		this.blockChain.add(block);
	}
	public List<Block> getBlockChain() {
		return this.blockChain;
	}
	public int size() {
		return this.blockChain.size();
	}	

	@Override
	public String toString() {
		String blockChain = "";
		for(Block block : this.blockChain)
			blockChain+=block.toString()+"\n";
		return blockChain;
	}

}

Step 5: Miner Program

Mining is the most important concept in Blockchain as well as in cryptocurrencies (such as Bitcoin). Mining means finding the right hash to avail you for the given block. But there are some constraints as far as difficulty is concerned. Nevertheless, every miner is going to get a reward because they are validating the given transactions.

In the Constant class, we have already defined the difficulty as '5', which means there have to be five leading zeros at the beginning of every hash. So miners will generate hash values until they find the right hash.

Question: In a decentralized system, who will handle the transactions?

Answer: In a decentralized system, Miners will handle all the transactions.

Getting rewards is not the only aim of mining; it is just the by-product.
Mining is the mechanism that allows the Blockchain to be a decentralized security.
It is about finding the right hash values for the blocks and adding these blocks to the Blockchain.
Miner is also responsible for appending or adding the block to the Blockchain.

Refer to the given below program to initiate the mining code in Java:

Miner.java

package com.balazsholczer.blockchain;

public class Miner {

	private double reward;	

	public void mine(Block block, BlockChain blockChain) {

		while(notGoldenHash(block)) {
			//generating the block hash
			block.generateHash();
			block.incrementNonce();
		}

		System.out.println(block+" has just mined...");
		System.out.println("Hash is: "+block.getHash());		
		//appending the block to the blockchain
blockChain.addBlock(block);
		//calculating the reward
		reward+=Constants.MINER_REWARD;

	}
	
	// So miners will generate hash values until they find the right hash.
	//that matches with DIFFICULTY variable declared in class Constant 
	public boolean notGoldenHash(Block block) {

		String leadingZeros = new String(new char[Constants.DIFFICULTY]).replace('\0', '0');

		return !block.getHash().substring (0, Constants.DIFFICULTY).equals (leadingZeros);
	}
	public double getReward() {
		return this.reward;
	}

}

Step 6: Main Program

Refer to the given below program to run the main Blockchain program in Java:

MainProgram.java

package com.balazsholczer.blockchain;

public class MainProgram{

	public static void main(String[] args) {
		// First of all we instantiate the BlockChain class itself.
		BlockChain blockChain = new BlockChain();
		// we will instantiate the Miner class to fetch the minor object.
		Miner miner = new Miner();
  		
//we have created the genesis or block 0 
		// we will pass the id, the transaction string and previous hash
		//as this is the first block so we have to manually provide the previous hash	
Block block0 = new Block(0,"transaction1",Constants.GENESIS_PREV_HASH);

		//miner will take the transaction and will mine the block
 		//to find the hash value and miner will append the block to Blockchain
		miner.mine(block0, blockChain);
		
		//we will create the next block 
		//we pass id, traction and this time the previous hash will contain
		// the hash value of Genesis block
Block block1 = new Block(1,"transaction2",blockChain.getBlockChain().get(blockChain.size()-1).getHash());

		miner.mine(block1, blockChain);

		Block block2 = new Block (2,"transaction3",blockChain.getBlockChain().get(blockChain.size()-1).getHash());
	miner.mine(block2, blockChain);
	System.out.println("\n"+ "BLOCKCHAIN:\n"+blockChain);
	System.out.println("Miner's reward: " + miner.getReward());
	}

}

Output

Run the main program to get the following output with hashes and reward values.