Building a Custom Blockchain

In this chapter, we will embark on the exciting journey of constructing our very own custom blockchain using Rust. By the end of this chapter, we will have laid the groundwork for our blockchain; in the subsequent chapter, we will finalize its implementation.

By undertaking this compact yet impactful project, we’ll gain a profound understanding of the fundamental principles underlying blockchain technology. This hands-on experience will equip us with the knowledge needed to recognize and comprehend the inner workings of other prominent blockchains such as Ethereum, Solana, NEAR, and Polkadot, all of which we’ll delve into in future chapters.

This understanding is invaluable when it comes to developing decentralized applications (dApps) on these blockchains. Armed with a solid foundation, we’ll be well-prepared to navigate the intricate world of blockchain technology and make meaningful contributions to the decentralized landscape...

Technical requirements

First, we must get our system ready with the required installations.

The most recommended operating systems to work with Rust are Ubuntu and macOS. You can also install Rust on Windows and work with it but you may run into issues in slightly more advanced and complex programs. If you’re on Windows, the most recommended way to go is using Windows Subsystem for Linux (WSL-2), which enables you to work with Ubuntu inside Windows.

Windows installation

For Windows systems, you can directly download the installer from the official Rust website (https://www.rust-lang.org/tools/install).

To set up Rust on your Windows system, you can follow the instructions provided on the Windows development environment web page (https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup).

Mac installation

For macOS users, the best way to install Rust is by using the Homebrew package manager.

Make sure you have Homebrew installed. If you don’...

Planning our first blockchain project

Before we start writing the code for our first project, we’ll practice doing this by going through a visual planning exercise to help us get a visual understanding of how we will approach the project. This helps in setting a structure for the project and not only acts as a roadmap throughout the development of the project but also enhances our understanding of the core components of the project.

Let’s discuss these core components in detail.

Structs

Our program is going to contain multiple structs (we briefly touched upon structs in Chapter 2, Rust – Necessary Concepts for Building Blockchains, in the Advantages of Rust-based languages compared to Solidity section). Structs enable us to create data types using a mixture of data types that Rust already understands. Structs also help us keep our code highly modular, readable, and reusable.

The first thing we will start with is a block – the smallest entity...

Getting started with building the blockchain

In this section, we’ll create our first blockchain project. We will use the Cargo project we created in the previous section as the starting point for our project.

Block

In the upcoming steps, we will guide you through the process of creating a block, elucidating each essential detail along the way. In the src folder, create a file called block.rs and implement the following struct in it:

pub struct Block {
    timestamp: i64,
    pre_block_hash: String,
    hash: String,
    transactions: Vec<Transaction>,
    nonce: i64,
    height: usize,
}

We will be following the plan and roadmap that we created earlier, where we did some visual planning, and extend upon this by going through the data types that we have chosen for each of the fields.

Here, Block has been represented as a struct where we have...

Creating the genesis block

The very first block in a blockchain is called the genesis block. While we haven’t written any code for the blockchain, we would like to create the first block and get things started. The genesis block doesn’t store a previous hash since no block comes before it.

In the block.rs file, we’ll begin by implementing functions specific to the Block type. To achieve this, we must create a code block, like so:

impl Block{
// Functions related to the Block type can be implemented here
...
}

The impl keyword in Rust is used to define a set of methods associated with a specific type – in this case, Block. This block acts as a container for functionality that is directly associated with the block structure, allowing us to define what operations can be performed with or on a block.

Move the new_block function that we created in the Block section, where we learned how to create a block, to inside the preceding code block and all...

Using helper functions

Helper functions simplify complex blockchain operations, enhancing code readability, reusability, and maintenance. In Rust-based blockchain development, functions such as get_transactions, get_prev_block_hash, and get_hash abstract away intricacies, enabling modular design and efficient debugging while focusing on high-level logic.

Let’s add some functions to the block.rs file that can help us work with blocks:

pub fn get_transactions(&self) -> &[Transaction] {
        self.transactions.as_slice()
    }

This function helps us to get the list of transactions, but let’s break it down and see what’s happening here.

This function is defined on a Rust struct and returns a borrowed reference to a slice of Transaction objects:

• pub indicates that this function can be called from outside the struct.
• fn is the keyword that’s used to define a function...

Summary

In this chapter, we started building our custom blockchain in Rust. First, we planned out our entire project using visuals and laid out our structs and function plans. Then, we started writing the actual code that would help us create functions for creating blocks, transactions, and the genesis block, along with structs for proof-of-work consensus and transactions.

In the next chapter, we will take things further. Following our initially laid-out roadmap, we will build the rest of the features and functions. Just like we did in this chapter, we will go through all the lines of code so that you are clear about how the blockchain works.