Your Go-to Guide to Develop Cryptocurrency Blockchain in Node.Js

Making your hands dirty by learning how to create blockchain will assist you in appreciating the technology and how it works,” says Elliot Minns, a coding and cryptocurrency guru.

In this article, you will learn how to build an easy cryptocurrency blockchain using Node.Js, a popular JavaScript backend runtime engine that is highly scalable, cost-effective, multi-utility, and very business-friendly.  

So get started, Node.Js developers, and enter into the crazy blockchain software development space by simply creating a cryptocurrency.

What you’ll need?

• Node.Js installed on your computer.
• A basic Node.Js understanding.
• A basic understanding of blockchain technology. 
• A code editor.

Let’s begin:

The blockchain boom is real, but why? 

First of all, blockchain is beyond cryptocurrency and bitcoin. Though in its infancy, the blockchain has spread out in various industries like finance, healthcare, government, DeFi, security, NFTs, and more, not just cryptocurrencies.

Block and chain: the block holds a highly encrypted series of data entries while the information is distributed among that particular community in the form of millions of copies via a chain. This is what we call a blockchain.

Blockchain tenets: Encryption, decentralization, provenance, and a multitude of stakeholders and exclusive control are the major fail-proof tenets of blockchain. In addition, blockchain technology solutions are built on trust protocol against penetrators and hackers. 

Cryptocurrency: Now, let’s finally talk about cryptocurrencies. These are digitally protected virtual currencies developed through cryptographic methods. Cryptography ensures the currency’s security and integrity. 

Creating a Block

As mentioned, a blockchain consists of multiple blocks. Basically, storage houses of information are connected through a public database, i.e., a chain. Cryptographic hashes are important to maintain the ledger’s validity.

Blockchain class hints at the preceding class and blocks data. For example, in Node.Js, each block of the blockchain consists of the following prime elements: 

const crypto = require("crypto"); // Import Node Js Crypto Module
class Block {
// Our Block Class
constructor(data, prevHash = "") {
this.timestamp = Date.now(); // Get the current timestamp
this.data = data; // Store whatever data is relevant
this.prevHash = prevHash; // Store the previous block's hash
this.hash = this.computeHash(); // Compute this block's hash
}
computeHash() {
// Compute this Block's hash
let strBlock = this.prevHash + this.timestamp + JSON.stringify(this.data); // Stringify the block's data
return crypto.createHash("sha256").update(strBlock).digest("hex"); // Hash said string with SHA256 encryption
}
}

Let’s break the above code for you:

• Timestamp — Is the timestamp of every block created or transaction made.  
• Data — Information stored inside the block. In the case of cryptocurrency, this data includes transaction status and stakeholders involved. However, a block can store much more than just transactions. 
• PreviousHash — Hash that represents the previous block.
• Hash — It is the encrypted block hash. If we add/edit/remove any data inside this block, the entire hash will change.

Wait, what is a previous block? It is the key element of Blockchain. In fact, every chained block must contain a data record of the previous block. Therefore, for every change in the block, you’ll have to revise the logic of existing and future hashes, which is a tedious process. This way, blockchain technology delivers the promise of immutability.

Also, in the above code snippet, the SHA256 module, imported from the crypto-js JavaScript library, is used to calculate and validate the hash per block. This is the most used cryptographic hash function in blockchains because of its effortless calculation, which is irreversible. 

Go to the terminal and run the following command using npm for convenient crypto-js library installation to your project: 

npm install --save crypto-js

Now, how do we create a blockchain? EZPZ, lemon squeezy ;)

Creating a Blockchain

Firstly, let’s set the most crucial function of our blockchain, i.e., to process each block’s hash.

As discussed previousHash, timestamp, data, and hash are four important parameters of a blockchain. Setting a hash function is imperative to maintain foolproof security against potential hackers that can penetrate the block data and even validate it. To fight the concern, we will set barricades that prevent hash from getting changed and validated. 

class BlockChain {
// Our Blockchain Object
constructor() {
this.blockchain = [this.startGenesisBlock()]; // Initialize a new array of blocks, starting with a genesis block
}
startGenesisBlock() {
return new Block([]); // Create an empty block to start
}
obtainLatestBlock() {
return this.blockchain[this.blockchain.length - 1]; // Get last block on the chain
}
addNewBlock(newBlock) {
// Add a new block
newBlock.prevHash = this.obtainLatestBlock().hash; // Set its previous hash to the correct value
newBlock.hash = newBlock.computeHash(); // Recalculate its hash with this new prevHash value
this.blockchain.push(newBlock); // Add the block to our chain
}
}

What does the above code snippet say? Let’s analyze:

initGenesisBlock() — It is the first block in our blockchain software development. The first in the chain, this block cannot keep any of the preceding hash content. It is basically at index 0.

latestBlock — As the name indicates, it is used for identifying the last block in the chain. It allows you to easily ensure the current block’s hash and connect it with the previous block’s hash to meet the needed chain integrity. 

addNewBlock — You can add a new block to the chain using this command. After every block addition, the preceding hash is cross-matched with the current block’s hash to ensure a tamper-proof chain function. 

Awesome! Your blockchain is ready to function. But it’s not over yet. Next, we create a command to verify blockchain validity to monitor, detect, and decline attempts of tampering. 

Now Test Your Blockchain 

Let’s create two scenarios here: 

1. An intruder tampers with the block data, and the existing hash value is no longer the accurate hash value.
2. An intruder tampers with the preceding block’s content, and the previousHash stored value eventually becomes inaccurate.

Now it’s time to execute a function that validates the entire blockchain after a new block is added: 

function validateChain(chain) {
function tce(chain, index) {
if (index === 0) return true;
const { hash, ...currentBlockWithoutHash } = chain[index];
const currentBlock = chain[index];
const previousBlock = chain[index - 1];
const isValidHash = hash === calculateHash(currentBlockWithoutHash);
const isPreviousHashValid =
currentBlock.previousHash === previousBlock.hash;
const isValidChain = isValidHash && isPreviousHashValid;
if (lisValidChain) return false;
else return tce(chain, index - 1);
}
return tce(chain, chain.length - 1);
}

Don’t worry; let me explain it to you: 

• First, a new function is created that considers the entire chain as its argument.
• We then create another function, tce (tail call elimination), where chain and block index are considered its argument.
• Considering the Genesis Block, we’ll take it as true.
• In another case, you’ll need to check other conditions, e.g., if the currentBlock’s hash is correct or if the previousBlock’s hash is correct for obvious reasons — to check the chain's validity.  

In simple words, If the blockchain integrity is compromised, it returns as false; otherwise, if no ambiguity occurs, it returns as true.

This one’s a really powerful yet easy process!

Kudos! You have your own blockchain in Node.Js now. But if you are eager to become more blockchain savvy, play around with this newly developed code and figure out what actually disrupts the chain validity.