How to Build Your First Blockchain with Plutus: A Step-by-Step Tutorial

Introduction

Blockchain technology is making waves across various sectors with its decentralized and transparent solutions. The advancements in this domain have brought transformative changes to developers and communities alike. Beyond just decentralization, blockchain offers significant benefits such as reducing transaction times and eliminating the need for third-party verification, thereby lowering the risks of fraud and cyber-attacks.

For developers, mastering blockchain application development is increasingly valuable, especially with powerful tools like Plutus.

Understanding Cardano

What is Cardano?

Cardano is a blockchain platform launched in 2017 by Charles Hoskinson, co-founder of Ethereum. As a third-generation blockchain, Cardano is often seen as a modern alternative to Ethereum, which is a second-generation platform. Cardano employs a proof-of-stake mechanism, which is more energy-efficient than traditional proof-of-work systems. Its native cryptocurrency, ADA, is named after the pioneering mathematician Ada Lovelace.

Cardano is structured with two distinct layers: one for managing transactions and accounts, and another for handling smart contracts and computations. This separation aims to enhance security, scalability, and adaptability. Cardano is utilized in various fields, including supply chain management, digital identity verification, and financial services in emerging markets.

What is Plutus?

Plutus is a programming language designed for creating smart contracts on the Cardano blockchain. Built on the functional programming language Haskell, Plutus simplifies the development process by automatically generating scripts through a Haskell compiler plugin, so developers don’t need to write Plutus Core directly.

One of Plutus’s standout features is its support for formal verification, a mathematical method for proving the correctness of programs. This capability enhances the security of smart contracts and minimizes the likelihood of bugs.

Why Choose Plutus?

Plutus is seamlessly integrated into the Cardano blockchain, enabling developers to interact directly with Cardano’s ledger and infrastructure. This integration facilitates the creation and deployment of smart contracts within the Cardano ecosystem. Plutus also includes tools for simulating smart contracts without needing a full Cardano node, allowing for experimentation before mainnet deployment. It’s an excellent choice for developers seeking to build reliable and high-performance decentralized applications.

Setting Up the Development Environment

Having a perfect setup before you kickstart the journey of development is crucial. Hence, setting up an environment that supports Plutus is the stepping stone of this chapter.

1. Installing Plutus

Download Plutus from the official repository: 

git clone https://github.com/input-output-hk/plutus-apps.git cd plutus-apps nix-shell

Verify installation using: plutus -v

2. Choosing an IDE

While developing applications with Plutus having the right IDE is crucial. Plutus is based on Haskell hence having an IDE supporting Haskell is recommended. Two popular options for Plutus development are Visual Studio Code (VS Code) and Plutus Playground. Here’s an expanded guide on how to set up and use these IDEs for Plutus development.

Visual Studio Code: VS Code is a very flexible and versatile Code editor that supports almost every language and has very helpful extensions. Hence it is the developers’ favorite editor to work on. VSCode is open source and provides wide range of tools and features to complete the code.

Steps to set up VSCode:

• Download VSCode from the official site(according to your operating system)
• Install the software
• Plutus is built on Haskell, so you need to install the Haskell Platform, which includes the Glasgow Haskell Compiler (GHC) and Cabal (a build tool for Haskell).
• Download Haskell
• Install the Haskell extensions in VS Code( Haskero, Haskell Syntax Highlighting, etc)
• Configure the extensions and set up additional extensions
• Since you have already installed Plutus you are ready to go!!
  

Plutus Playground: Plutus Playground is an online web-based editor, particularly for Plutus smart contracts. Hence there is no need for any installation and is perfect for beginners to gain some confidence while coding.

You can visit the Plutus Playground website and just get started!!

Both environments can be used effectively for Plutus development, and you may find that combining the two—using VS Code for larger projects and Plutus Playground for quick testing and prototyping—provides the best of both worlds.

3. Installing Required Libraries

Use cabal to install essential libraries for Plutus development.

Understanding Blockchain Concepts with Plutus

Blockchain is a distributed and advanced database that stores the records of transactions in the form of blocks. Each of the blocks needs to be linked with the other using cryptographic principles. Robust mechanisms are used to safeguard the blocks due to which one can’t alter any records of the currencies before time and without affecting the subsequent blocks.

Blockchain has three basic components:

• Blocks: Blocks contain information about transactions along with metadata. All blocks are linked with each other through hashing which  forms a chain of blocks, hence blockchain
• Transactions: A transaction is a transfer of data from one entity to another within the blockchain. In Plutus, transactions are written in Haskell and involve input and output UTXOs (Unspent Transaction Outputs).
• Chains: In Plutus, the chain maintains the order of transactions and ensures that they are immutable once confirmed.

In the following code snippet we can see the structure of the Block in Plutus:

Every component of the block is mentioned along with its data type

• The index is an integer that tells the position of a block
• Timestamp is the time at which the block was created
• Transactions is the string or a list of all the transactions included in a particular block
• Hash is a unique pattern and the primary key to identifying a block
• The previous hash refers to continuity and is the hash of the last block

In this code snippet we can see the structure of Transactions in Plutus:

Core Principles of Blockchain: Decentralization, Immutability, and Consensus

The foundation of blockchain relies on three core principles:  Decentralization, Immutability and consensus Mechanism

Decentralization: Decentralization ensures that no single entity controls the blockchain database. This property minimizes the risk of system failure and bias, as each participant device, or node, maintains a copy of the blockchain. This distributed approach ensures transparency and prevents centralized failures or manipulations.

Immutability: Once data is recorded on a blockchain, it cannot be altered without modifying all subsequent blocks. This is achieved through cryptographic hashing. As a result, once changes are made, they are permanent, ensuring the data’s immutability.

Consensus Mechanism: Consensus mechanisms are protocols that dictate how all nodes in the blockchain network agree on the validity of transactions and blocks. These mechanisms ensure that all nodes are synchronized and operate in unison, maintaining the integrity and consistency of the blockchain.

Building a Simple Blockchain with Plutus

A blockchain’s basic unit is the block. In this section, we define a block data type and its components.

Creating and Securing Your Blockchain

After defining the block class, it is crucial to maintain the integrity of the blockchain by ensuring that each block has a unique hash. We use the SHA256 hashing method in Plutus to accomplish this.

To start your blockchain, initialize it with a genesis block, the very first block in any blockchain. Congratulations—you’ve created your own blockchain! However, you’ll also need to add new blocks and retrieve the latest block to complete the setup.

Refer to the code snippet below for guidance:

Implementing Consensus Mechanisms in Plutus

Cardano utilizes the PoS mechanism while first, it had adopted the Proof of Work. Plutus is designed to be compatible with Cardano’s Ouroboros PoS protocol, offering scalability, energy efficiency, and security for decentralized applications (DApps). 

Here’s an overview of consensus algorithms that can work with Plutus

• Ouroboros: Ouroboros is a Proof of stake mechanism that the Plutus is highly compatible with and it depends on the stake of the ADA that the validators are willing to take up to validate a new block. Plutus contracts interact seamlessly with the Ouroboros protocol, ensuring that the execution of smart contracts remains secure and energy-efficient.
• Proof of Work: PoW is the most ancient mechanism and was widely used in all the older cryptocurrencies. It can still be implemented on paper in the case of Plutus. This would be more useful while thinking of isolated scenarios like educational purposes and experimental purposes.
• Delegated proof of work  & Byzantine fault Tolerance: These mechanisms are not particularly compatible with Cardano but still can be theoretically implemented on Plutus.

In this section, we will explore how can one use Proof of Work in Plutus.

In Proof of Work, miners need to compete in time to solve a cryptographic puzzle to become validators of the new coin. In this code, the proof of work function searches for a nonce that, when combined with the previous block’s hash, produces a hash with a certain number of leading zeros. This is a basic implementation of PoW, where the difficulty level determines how hard it is to find a valid nonce.

Once you complete the Proof of Work implementation you need to update the blockchain to validate the proof that was mined.

Here is the example code snippet:

This function ensures that a new block is only added to the blockchain if its proof is valid, maintaining the chain’s integrity.

Creating a Simple Blockchain API with Plutus

In this chapter, you will learn how to create a simple API for interacting with a blockchain application built using Plutus. This API will allow you to add blocks and view the blockchain through HTTP requests.

Steps to create an API:

• Set up the Environment for API: Install Haskel(Which is already done), nextly Install Servant using Cabal
• Download all the required libraries:
  • Servant: To create the API
  • Aeson to encode and decode the JSON: cabal install aeson plutus-core
  • Plutus to integrate all the code and logic

To start with Building the API we need to first add a new block and retire the current state of the blockchain. Both of these steps have been performed in the above chapters. 

Now you can go ahead and define the endpoints:

{-# LANGUAGE DataKinds #-} {-# LANGUAGE TypeOperators #-} module BlockchainAPI where import Servant import Control.Monad.IO.Class (liftIO) — Define the Block type (refer to Chapter 3) data Block = Block { index        :: Int , timestamp    :: String , dataField    :: String , previousHash :: String , hash         :: String } deriving (Show, Eq) — Blockchain is simply a list of Blocks type Blockchain = [Block] — Define the API type type BlockchainAPI = “addBlock” :> ReqBody ‘[JSON] Block :> Post ‘[JSON] Blockchain :<|> “chain” :> Get ‘[JSON] Blockchain — Placeholder for the blockchain, initially starting with just the genesis block genesisBlock = Block 0 “2024-09-12 00:00:00” “Genesis Block” “0” “some_hash” initialBlockchain:: Blockchain initialBlockchain = [genesisBlock] –– Handlers for the API endpoints addBlockHandler :: Blockchain -> Block -> Handler Blockchain addBlockHandler blockchain newBlock = do let newBlockchain = blockchain ++ [newBlock] liftIO $ putStrLn “Block added!” return newBlockchain — Handler for retrieving the chain viewChainHandler :: Blockchain -> Handler Blockchain viewChainHandler blockchain = return blockchain –Main entry point to run the API app :: Application app = serve (Proxy :: Proxy BlockchainAPI) (blockchainServer initialBlockchain)

Explanation of the above code:

• Block is defined similarly to the previous chapters
• Servant library is used to define the structure of the API. There are two methods to define  API endpoints,GET and POST meaning retrieve and add the blockchain respectively.
• We have also defined handlers (addBlockHandler)  to handle the new blocks that are being added andviewChainHandler) viewing the other block
• At the end, there is a main function that is the heart of the code binds everything together, and runs the API server.

After the API definition, you have two methods to add the Endpoints and retrieve the Blockchain Endpoint information.

Yay!! You have successfully implemented this subsection and now you can rum the API using cabal and you are good to go for the next part.

Running and Testing the Application

After building the blockchain API, it’s time to test it. We will use Postman or curl to interact with the API and verify that it works correctly.

Steps to Run and Test the Application:

• Compile the program and run it:  cabal build   cabal run
• Start the server : The API should be available at http://localhost:8080
• Test and add the Block endpoints

{ “index”: 1, “timestamp”: “2024-09-12 12:30:00”, “dataField”: “This is my new block”, “previousHash”: “some_hash”, “hash”: “new_block_hash”}

View the Blockchain

curl http://localhost:8080/chain

By following these steps, you now have a simple blockchain application running with an API built using Plutus. The API allows external applications or users to interact with your blockchain by adding new blocks and viewing the current blockchain state. 

Live Example of Building a Blockchain Application with Plutus

The above Code snippet is a Step-by-Step Execution of:

• Step 1: Create the Block data type with necessary attributes using Plutus syntax.
• Step 2: Implement the calculate_hash method.
• Step 3: Define the Blockchain data type and initialize it with a genesis block.
• Step 4: Implement methods to add new blocks and retrieve the latest block using Plutus.
• Step 5: Add Proof of Work functionality to the Block data type and update the Blockchain data type.
• Step 6: Set up the API environment to handle requests using Plutus.
• Step 7: Test the application by mining a new block and verifying the blockchain using Postman or Curl

Congratulations! You have reached the end of the module and learned all the basics of Plutus.

As you venture into blockchain development with Plutus, you’re not just writing code—you’re crafting the backbone of decentralized systems that could redefine industries. Keep Learning and Happy Coding !!

Also Check Out: How to Design, Develop, & Deploy Your Own Cryptocurrency: A Step-by-Step Guide