Custom Blockchain Building on Substrate framework

Summary

The polkadot is very compatible with the multi-chain. Actually, we can’t have massively transactions around the world on one chain like the Bitcoin and Ethereum network. The polkadot depends on substrate which is opensource, module and framework to build the blockchain network. The substrate depends on the Rust programming language which is very fast and secured light. The both of substrate framework and Rust programming language are tool to incentive the polkadot blockchain ecosystem. In this article, I am going to describe how to build our own blockchain on substrate practically.

Proof of Existence Blockchain

In this article, we will build the proof of existence blockchain on the polkadot by the substrate framework,which means that we are going to run our own chain on the polkadot. For example ,imagine you are an author of some books ,then you need to proof you are actual author of the book. We will build such blockchain to implement this functionality. So you will put your name and the topic of book into the blockchain. So it should be immutable forever.I am not going to mention the blockchain use anymore here. Then let’s jump into main course.

1. Pre-requirements

We have to use substrate framework to build our own blockchain as I mentioned above already. There are two things we have to do now .We will clone the substrate-node-template and substrate-ui-template from substrate github to be very fast on our development. Also we will build the runtime pallet about our own blockchain development in the pallet folder of the substrate-node-template project.

2. Auth-Pallet Building

The auth-pallet is the modular and the logic implementation how our blockchain works on our own chain.

#![cfg_attr(not(feature = "std"), no_std)]
use frame_support::{
decl_error, decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure,
};
use frame_system::ensure_signed;
#[cfg(test)]
use sp_std::vec::Vec<u8>;  // substrate pallet standard package 
mod tests;

we can create lib.rs file inside auth-pallet folder of the pallets of substrate and copy and paste above code parts. Each pallet is the library of the runtime module to implement the state transaction function from one state to another one on chain.

decl_error: This allows the chain to be fired if the error causes while the runtime module is running.

decl_event: This allows the chain to be fired if the state change completes successfully.

decl_module: This allows external users to interact with the functionalities on the chain.

decl_storage: This allows user to save the data into the chain.

dispatch: This returns the result after the state change complete successfully on chain.

ensure: This is requirement to see the something is satisfied with some conditions. (It is similar to the require of solidity programming language).

Maybe ,you can feel boring now with these codes 🤓. So let’s jump more into next steps. Then you will become a good substrate developer.

Here are the macros which are described on substrate. important!!

decl_event!(
pub enum Event<T>
where
AccountId = <T as frame_system::Config>::AccountId,
{
  // This event emitted someone claim into chain
   
   ClaimInsert(AccountId,Vec<u8>);
}
);
decl_storage! {
trait Store for Module<T: Config> as Proof {
pub Proofs get(fn get_proof): map hasher(blake2_128_concat) T::AccountId => u8;
}
}
decl_error! {
pub enum Error for Module<T: Config> {
/// Attempted to transfer than were available
 ErrorTransfer,
}
}
decl_module! {
    pub struct Module<T:Config> for enum Call where origin:   T::Origin{
     // This will fire event in default
      
      fn deposit_event() = default
      // This function is external function to interact the users who wants to interact with our blockchain. The first parameter will be origin somehow and anytime and then add next params ...   
      fn claimInsert(origin,Vec<u8>)-> DispatchResult{
          let sender = ensure_signed(origin)?; // OR
           
           // store sender's data into chain
           <Proofs<T>>::insert(sender,Vec<8>);
        // emit event         
       Self::deposit_event(RawEvent::ClaimInsert(sender,Vec<u8>);
       
        Ok(());
      }
}
}

After we code some logic inside the auth-pallet , we run cargo build command . Then It will happen to compile wasm file to upload on our chain.

Then we will run substrate-ui-template and connect the node which built on substrate to polkadot js in local environment . That’s all . You can see your chain on it now. That’s really awesome to run your own blockchain.