Before we get into building the blockchain, there are two crucial concepts that we need to familiarize ourselves with. These important concepts are as follows:

• The JavaScript constructor function
• The prototype object

Becoming familiar with the constructor function is important as we'll be using it to build our blockchain data structure. By now, you must be wondering what a constructor function is and what it actually does.

A constructor function is simply a function that creates an object class and allows you to easily create multiple instances of that particular class. What this actually means is that the constructor function allows you...

Let's get started with building our blockchain data structure. We'll start by opening all of the files that we have in our blockchain directory by using the Sublime editor. If you are comfortable using any other editor, you can use that too. Open our entire blockchain directory in whichever editor you prefer.

We'll be building our entire blockchain data structure in the dev/blockchain.js file that we created in Chapter 1, Setting up the Project. Let's build this blockchain data structure by using a constructor function that we learned about in the previous section. So, let's begin:

For the constructor by type the following:

function Blockchain () {
}

For now, the Blockchain () function is not going to take any parameters.

Next, inside of our constructor function, we are going to add the following terms:

function Blockchain...

Let's continue with building our blockchain data structure. After defining our constructor function in the previous section, the next thing that we want to do with our constructor function is to place a method in our Blockchain function. This method that we are going to create will be called createNewBlock. As its name suggests, this method will create a new block for us. Let's follow the below mentioned steps to build the method:

1. The createNewBlock method will be defined as follows:

Blockchain.prototype.createNewBlock = function () { 

}

2. Now we've got this createNewBlock method on our blockchain prototype object. This method will take the three parameters, as highlighted in the following line of code:

Blockchain.prototype.createNewBlock = function (nonce, previousBlockHash, hash) { 

}

We'll learn in depth about these...

Now, the next method that we are going to add to our Blockchain constructor function will be the getLastBlock. This method will simply return the last block in our blockchain to us. Follow the below mentioned steps to build the method:

1. Go to our dev/blockchain.js file, and after our createNewBlock method, add the following:

Blockchain.prototype.getLastBlock = function () { 

}

2. Inside of this getLastBlock method, we will type the following highlighted line of code:

Blockchain.prototype.getLastBlock = function () { 
    return this.chain[this.chain.length - 1];

}

The [this.chain.length - 1]; in this preceding code defines the position of the block in the chain, which, in our case, is the previous block, therefore negated by 1. This method is simple and straightforward, and we'll use it in later chapters.

The next method that we are going to add to our blockchain constructor function is called createNewTransaction. This method will create a new transaction for us. Let's follow the below mentioned steps to create the method:

1. Start building up this method by adding the following line of code after our getLastBlock method:

Blockchain.prototype.createNewTransaction = function () {

}

2. The function () will take three parameters, such as the following:

Blockchain.prototype.createNewTransaction = function (amount, sender, recipient) {

}

What these three parameters will do is as follows:

• amount: This parameter will take in the amount of the transaction or how much is being sent in this transaction.
• sender: This will take in the sender's address.
• recipient: This will take in the recipient's address.

3. The next thing that we want...

The next method that we are going to look at and add into our blockchain data structure is called hashBlock. What this hashBlock method will do is take in a block from our blockchain and hash its data into a fixed length string. This hashed data will appear randomly.

In essence, what we're going to do is pass some blocks of data into this hash method, and in return we'll get a fixed-length string, which will simply be a hash data that is generated from the data that we passed in or from the block that we passed.

To add the hashBlock method to our blockchain data structure, type the following line of code after our createNewTransaction method:

Blockchain.prototype.hashBlock = function(blockdata) {

}

In our hashBlock method, blockdata will be the input data of our block from which we want to generate the hash.

So, how can we take a block or blocks...

The next method that we are going to add to our blockchain data structure is the proofOfWork method. This method is very important and essential to the blockchain technology. It is because of this method that Bitcoin and many other blockchains are so secure.

Now, you must be getting curious about what a Proof of Work (PoW) actually is. Well, if we take a look at our blockchain, every blockchain is pretty much a list of blocks. Every single block has to be created and added to the chain. However, we don't just want any block to be created and added to the chain. We want to make sure that every block that is added to the chain is legitimate, has the correct transactions, and has the correct data inside of it. This is because if it doesn't have the correct transactions or the correct data, then people could fake how much Bitcoin they have and essentially...

One more thing that we would have to add to our blockchain data structure is the genesis block. But what is a genesis block? Well, a genesis block is simply the first block in any blockchain.

To create our genesis block, we are going to use the createNewBlock method inside of the Blockchain() constructor function. Go to the dev/blockchain.js file, and inside of the blockchain constructor function type in the following highlighted lines of code:

function Blockchain () {
    this.chain = [];
    this.pendingTransactions =[];
    this.createNewBlock();         
}

As we observed in the previous section, the createNewBlock method takes in the value of a nonce, a previousBlockHash, and a hash as parameters. Since we're using the createNewBlock method over here to create the genesis block, we are not going to have any of those mentioned parameters. Instead...

In this chapter, we began by building the constructor function and then moved on to create some amazing methods such as createNewBlock, creatNewTransaction, getLastBlock, and so on. We then learned about the hashing method, SHA256 hashing, and created a method to generate a hash for our block data. We also learned what a proof of work is and how this works. In this chapter, you also got to learn how to test the various methods that we created and check whether they are working as expected. The methods that we have learned about in this chapter will be very useful for us in further chapters when we interact more with the blockchain.

If you want to get more familiar with the blockchain data structure, it is recommended that you open up the test.js file, test all of the methods, try to play around with those, observe how they work together, and have fun with it.

In the next...