The blockchain is a digital database based on a distributed ledger system. It works on a five-step process.
End users create transactions and broadcast them to the network.
Then, these unconfirmed transactions are stored in a mempool. The mempool is a storage location inside each
A record is created by selecting a random set of unconfirmed transactions. A candidate record verification check is done on each record made, and these records are broadcasted to the connected node.
As other nodes receive these records, they will validate it, and if it complies with its protocol rules, it is added to the
Finally, we reach a global representation of the validated set of records. This representation is called a ledger; through it, we can check transactional history.
Now we will move to a Java code implementation of the blockchain.
import java.nio.charset.StandardCharsets;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import java.time.Instant;import java.util.ArrayList;import java.util.List;class Block {private int index;private long timestamp;private String previousHash;private List<Transaction> transactions;private String hash;private int nonce;public Block(int index, long timestamp, String previousHash, List<Transaction> transactions) {this.index = index;this.timestamp = timestamp;this.previousHash = previousHash;this.transactions = transactions;this.nonce = 0;this.hash = calculateHash();}public String calculateHash() {try {MessageDigest digest = MessageDigest.getInstance("SHA-256");String data = index + timestamp + previousHash + transactions + nonce;byte[] hashBytes = digest.digest(data.getBytes());StringBuilder hexString = new StringBuilder();for (byte hashByte : hashBytes) {String hex = Integer.toHexString(0xff & hashByte);if (hex.length() == 1)hexString.append('0');hexString.append(hex);}return hexString.toString();} catch (NoSuchAlgorithmException e) {e.printStackTrace();}return null;}public String getHash() {return hash;}public String getPreviousHash() {return previousHash;}public String mineBlock(int difficulty) {String target = new String(new char[difficulty]).replace('\0', '0');while (!hash.substring(0, difficulty).equals(target)) {nonce++;hash = calculateHash();}return hash;}}
This code snippet shows the Block
class. It consists of the following:
Lines 9–14: Private member variables.
Lines 16–23: Parameterized constructor: It creates a block with the given values from its arguments.
Lines 25–42: calculateHash
function: It has a try-catch block that, if successful, creates a custom hash key for the block. If not, then it catches and returns the error.
Lines 44–50: Getters for current and previous hash.
Lines 52–59: mineBlock
function: It calculates the hash of the block while updating the nonce
.
class Transaction {private String sender;private String receiver;private double amount;public Transaction(String sender, String receiver, double amount) {this.sender = sender;this.receiver = receiver;this.amount = amount;}}
The Transaction
class above consists of the following:
Lines 2–4: Private member variables.
Lines 6–10: Parameterized constructor: It creates a transactional log with the given values from its arguments.
class Blockchain {private List<Block> chain;private List<Transaction> pendingTransactions;private int difficulty;public Blockchain() {chain = new ArrayList<>();pendingTransactions = new ArrayList<>();difficulty = 2;createGenesisBlock();}private void createGenesisBlock() {List<Transaction> transactions = new ArrayList<>();transactions.add(new Transaction("Genesis", "Alice", 100.0));Block genesisBlock = new Block(0, Instant.now().getEpochSecond(), "0", transactions);genesisBlock.mineBlock(difficulty);chain.add(genesisBlock);}public void addTransaction(Transaction transaction) {pendingTransactions.add(transaction);}public void minePendingTransactions(String minerAddress) {Block block = new Block(chain.size(), Instant.now().getEpochSecond(), chain.get(chain.size() - 1).calculateHash(), pendingTransactions);block.mineBlock(difficulty);chain.add(block);pendingTransactions = new ArrayList<>();pendingTransactions.add(new Transaction("Reward", minerAddress, 1.0));}public boolean isChainValid() {for (int i = 1; i < chain.size(); i++) {Block currentBlock = chain.get(i);Block previousBlock = chain.get(i - 1);if (!currentBlock.calculateHash().equals(currentBlock.getHash()))return false;if (!currentBlock.getPreviousHash().equals(previousBlock.getHash()))return false;}return true;}private Block getLastBlock() {return chain.get(chain.size() - 1);}}
This is the central portion of the code. The Blockchain
class consists of many functions, including:
Lines 2–4: Private member variables
Lines 6–11: Default Constructor: It initializes a chain
of blocks and pendingTransactions
. It also sets a block generation difficulty
and creates the genesis block.
Lines 13–19: createGenesisBlock
function: It creates the first block with transactions
and adds it to the chain
.
Lines 21–23: addTransaction
function: It adds a transaction to the pendingTransactions
list.
Lines 33–43: isChainValid
function: It checks if the current block has calculated its current and the previous block's hash properly. Based on its conditions, it either returns true or false.
Lines 45–47: getLastBlock
function: It returns the last block on the chain
.
public class Main {public static void main(String[] args) {Blockchain blockchain = new Blockchain();blockchain.addTransaction(new Transaction("Alice", "Bob", 0.5));blockchain.addTransaction(new Transaction("Bob", "Charlie", 0.3));blockchain.minePendingTransactions("Miner1");System.out.println("Is blockchain valid? " + blockchain.isChainValid());}}
Finally, the driver code needed to run this code is given above. It creates a new Blockchain
and adds transactions
to it. Then it mines a block, and depending on its result, it returns whether it is valid.
How are transactions verified in a blockchain network?
By a centralized authority
By a group of miners or validators
By a computer algorithm
By the sender and recipient of the transaction
This was a brief rundown of the Java implementation of blockchain. It is essential to remember that when we run this in a real-world situation, we must remain aware of many other variables like network communication and persistence, as well as consensus algorithms and node functionalities.
Free Resources