Finishing Up Our Custom Blockchain

We started our journey of building a blockchain in Chapter 3, Building a Custom Blockchain, when we started outlining structs and functions. We then continued fleshing out those functions in Chapter 4, Adding More Features to Our Custom Blockchain. Now, in this chapter, we will take things forward and finish up our blockchain.

In the previous chapter, we built out some core blockchain functionality, such as writing the code to work with our blockchain with functions for adding blocks and hashes and then writing the code for the server and the node to be able to serve our created blockchain. Now, we will discuss the following topics:

• Adding memory pools
• Implementing transactions
• Utilizing unspent transaction outputs (UTXOs) and developing wallets
• Setting up configurations and utilities
• Understanding the Main.rs file
• Using your custom blockchain

Technical requirements

The code for each chapter is presented separately in different folders in the GitHub repository accompanying this book. For an uninterrupted learning journey, all the code pertaining to this chapter can be accessed in the dedicated GitHub repository. You can clone it with the following command:

git clone https://github.com/PacktPublishing/Rust-for-Blockchain-Application-Development/.

This repository contains comprehensive code snippets, projects, and resources relevant to the material discussed. To better grasp the explanations, you are encouraged to clone the repository and explore its contents as we progress through the explanations.

An important point to note

While the divided code is in different folders with the name of the specific chapter, the combined code from Chapters 3, 4, and 5 for the entire blockchain project is in a folder called complete_blockchain, so if you’d like to read the entire code and move between the functions for a...

Adding memory pools

A memory pool, often referred to as a mempool, serves as a holding area for pending cryptocurrency transactions awaiting validation and inclusion in a block on a blockchain network. It stores unconfirmed transactions, acting as a temporary repository before miners select and verify them for block inclusion. Significantly impacting blockchain efficiency, the mempool plays a pivotal role in transaction processing and network performance. Its function involves validating transactions, ensuring they comply with network rules, and prioritizing them based on associated fees or other criteria. The mempool’s role in decentralized systems, such as Bitcoin, Ethereum, and various altcoins, enhances transaction throughput and responsiveness. Applications of mempools extend beyond basic transaction storage; they influence fee estimation algorithms, network scalability solutions, and transaction acceleration services, which are vital in optimizing blockchain operations...

Implementing transactions

Transactions in a blockchain network represent the transfer of assets or information between participants. In this section, we dissect the core components of transactions – TXInput, TXOutput, and the overarching Transaction struct. These structures intricately manage inputs, outputs, and transactional data, crucial for secure asset exchanges within the blockchain ecosystem.

All the code we write in this section will be available in the transactions.rs file.

Understanding TXInput transactions

We have already seen the TXInput struct in the previous chapter; now, let’s understand the implementation functions for all TXInput transactions. It will look like the following code:

 impl TXInput {
    pub fn new(txid: &[u8], vout: usize) -> TXInput {
        TXInput {
            txid: txid.to_vec(),
   ...

Utilizing UTXOs and developing wallets

In this section, we will explore the implementation of UTXO and wallet functionalities. UTXO tracking and wallet management play pivotal roles in blockchain systems, ensuring transaction outputs’ integrity and secure asset storage and transfer.

Let us first look at the UTXOSet structure.

Implementing UTXOSet

The UTXOSet structure helps manage UTXOs within a blockchain. It facilitates functionalities such as finding spendable outputs, reindexing outputs, updating outputs after block confirmation, and counting transactions within the blockchain.

You will find the following code in the file:

pub struct UTXOSet {
    blockchain: Blockchain,
}
impl UTXOSet {
  pub fn new(blockchain: Blockchain) -> UTXOSet {
        UTXOSet { blockchain }
    }
    pub fn get_blockchain(&self) -> &Blockchain {
  ...

Setting up configurations and utilities

Setting up configurations and utilities within the code base establishes fundamental structures and utility functions pivotal for blockchain operations. These components encapsulate key configurations, cryptographic functions, and essential utilities indispensable for secure and efficient blockchain functionalities. Configurations encompass system configurations, including node addresses and mining specifics, ensuring the adaptability and customization of the blockchain environment. On the other hand, utilities house crucial cryptographic functions such as hashing algorithms, key generation, encoding, and signature verification, serving as foundational tools for secure data handling and authentication within the blockchain network. This section forms the backbone of system configurations and cryptographic operations essential for maintaining the integrity and security of blockchain-based systems.

Let us first look at the Config implementation...

Understanding the Main.rs file

The Main.rs file serves as the entry point and orchestrator of operations in this Rust blockchain application. It defines command-line interface (CLI) options using the StructOpt crate, enabling users to interact with various functionalities of the blockchain system. Each command represents a specific action, from creating a blockchain and managing wallets to sending transactions and exploring the blockchain’s state. The code structure, coupled with the utilization of modules and external crates, forms a cohesive ecosystem to execute blockchain operations efficiently. The code is organized around the Opt structure, which encapsulates different commands specified under the Command enum. These commands offer diverse functionalities such as creating a new blockchain, managing wallets, checking balances, sending transactions, examining the blockchain’s state, and initializing nodes.

Let us get into an explanation of the code in the Main.rs...

Using your custom blockchain

Before running your blockchain, ensure your environment is set up correctly. This step involves installing Rust, which is necessary for compiling and managing the project, given its development in Rust language. Here’s what you need to do:

1. Install Rust: Visit the official Rust website and follow the instructions to install Rust and Cargo on your system. Cargo is Rust’s package manager and build system.
2. Compile the project: The next step is to compile the project, which you can do as follows:
   1. Open a terminal and navigate to the Rust-Advanced-Blockchain directory within the project.
   2. Compile the project using Cargo. This will download dependencies and compile the project:

      cargo build –release

   3. The --release flag builds the project in release mode, which optimizes the binary for performance.

After running the preceding command, you will see the following result in the terminal:

blockchain_rust 0.1.0
USAGE:
  &...

Summary

In this chapter, we embarked on finalizing the essential elements of a blockchain system, emphasizing the mechanisms that facilitate secure and efficient transactions. Initially, we focused on completing the blockchain code to ensure a solid foundational structure and protocol. We then delved into memory pools, which play a pivotal role in managing transaction queues before their incorporation into the blockchain. This discussion naturally progressed to understanding UTXOs, vital for processing and validating transactions and indicative of the spendable digital currency amount for users.

Subsequently, the chapter shifted its focus to wallet development, highlighting its significance not just in storing digital currency but also in securing transactions and maintaining user identity within the blockchain through private key management. We explored how blocks are finalized in the blockchain, detailing the selection, verification, and addition of transactions from the memory...