Forem: Mayank Vats

Hardhat Implementation

Mayank Vats — Mon, 28 Feb 2022 17:58:30 +0000

Hardhat is a development environment to compile, deploy, test, and debug your Ethereum software.
Following document contains the minimal implementation steps to get started with hardhat:

Initialise an empty node project. npm init / yarn init
Install hardhat. npm i hardhat / yarn add hardhat
Install following dev dependencies: npm install -D @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai / yarn add -D @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai
Run this command: npx hardhat. After running this command you will get the following prompt: (choose to create an empty hardhat.config.js)

Replace the contents of hardhat.config.js with the following: hardhat.config.js
Create the following folders in the root directory, contracts/ scripts/ test/

contracts/ - Here you will store all your contracts
scripts/ - Here you will store scripts for deploying contracts to the network
test/ - Here you will store all your test scripts

The upcoming text will show you how to, compile, test and deploy a basic ERC20 contract using hardhat.
NOTE: run this command “npm i -g hardhat-shorthand”, to use “hh” with every hardhat command you run instead of ”npx hardhat”.

Contract Compilation Using Hardhat:

You can use this contract.

Make a file “Token.sol” in the contracts/ folder and copy paste the code from the above link.
Save the file and then go to the terminal and run hh compile.
After compiling two folders will be created namely artifacts/ and cache/.

artifacts/ folder will contain the contract’s ABI and bytecode.

Contract Testing Using Hardhat:

You can use this basic testing script to get started.

Make a file “TokenTest.js” in the test/ folder and copy paste the code from above link.
Save the file and then go to the terminal and run “hh test test/TokenTest.js”. Output should look something like below:

Contract Deployment Using Hardhat:

You can use this deployment script to get started.

Note: To deploy the script, replace values with your own privateKey in the hardhat’s config file.

Make a file “TokenDeploy.js” in the scripts/ folder and copy paste the code from above link.
Save the file and then go to the terminal and run “hh run scripts/TokenDeploy.js --network bscTestnet”.
You can search for the address here and verify that the contract has been deployed. Save the contract’s address somewhere.

Contract Verification Using Hardhat:

To verify contracts using hardhat we will need to install a hardhat plugin “hardhat-etherscan”. Following steps will walk you through with that.

If you use yarn, run the following command: “yarn add -D @nomiclabs/hardhat-etherscan” and if you are using npm: “npm i -D @nomiclabs/hardhat-etherscan”.
Then require the plugin in the hardhat’s config file.
Now make an account here and then go into the API keys section to create and get your API key.
Copy the API key and paste it in the hardhat’s config as shown below.

Now run this command in your terminal: hh verify --network bscTestnet "CONTRACT_ADDRESS_HERE".

This concludes the basics of getting started with the hardhat. I hope this has helped you.

Javascript: Under the hood

Mayank Vats — Sun, 27 Jun 2021 11:02:47 +0000

One day, a curious guy named Thomas, who is a Software Developer, was wondering What does the execution context means? What actually happens when the JavaScript program first runs? If JavaScript is single threaded then how does it work asynchronously?

He then shifted himself into learning mode and started searching for the answers and wrote about all his learning, which I am going to share here.

🚀 The First Run

Whenever we write the JavaScript code and execute it in our browser or in NodeJs, following things happen:

The compiler goes throw the whole source code, assigning memory to the variables, storing function definitions and creating Global Execution Context (Creation Phase).
Then, it assigns the values to the variables, makes execution context on each function call, and also pushes the function onto the call stack (Execution Phase)

Let's take an example:

var message = "Hello World!";

const send = function (message) {
  const log = `"${message}" sent to the reciever`;
  console.log(log);
};

send(message);

For the code above, firstly the compiler reads through it and decides which variables need memory and what function definitions needs to be stored, this is the Creation Phase.

Secondly, the compiler goes through the code again and this time it assigns the values to the variables and looks for the function calls to create an Execution Context.

In the image above GEC is the Global Execution Context, which is always at the base of the call stack, you may have seen something like <anonymous> in the browser's console.

Similarly, when the send function is called, the creation and execution phases are carried out and an execution context is created.

Execution Context can be thought of as an environment or a place where the current code execution is taking place.

So, whenever the JavaScript code runs, very first execution context that is the Global Execution Context is created, this Global Execution Context is the place which is responsible for storage and execution of the rest of the code, then on every function call a new execution context gets created, which may also refer to its parent execution context.

🚀 Synchronous Nature

JavaScript is a single threaded programming language, that means, JavaScript engine has only one call stack and one memory heap. Due to the presence of only single call stack it can run single instruction at a time.

Earlier, JavaScript was used for only dynamic rendering of elements in the web pages and form validation. These tasks required only single thread to run on. But, as the technology progressed and web applications became more complex, more long running tasks such as an API call, querying the database, prompting user to upload a file, became headache with this synchronous flow.

To mimic this synchronous and blocking nature, Open your browser's console and type alert() and press enter.

🚀 Asynchronous Nature

JavaScript got its asynchronous nature with the help of its runtime, which consists of a JavaScript Engine, Web APIs, callback queue and an event loop.

JavaScript Engine, consists of Call Stack and Memory Heap, which are responsible for execution of the JavaScript code.

Call Stack, keeps record of the current running function as well as the functions that needs to be executed once the current function completes its execution and is popped off the stack.

Callback Queue, is a queue which keeps record of the functions(or processes) that needs to be executed by the engine.

Event Loop, firstly checks if Call Stack is empty, monitors the Callback Queue and checks for any DOM events or processes in the queue that needs to be executed by pushing onto the stack.

Combination of these is what gives JavaScript its asynchronous capabilities. Let's go through an example:

console.log("Fetching Data");

function sayHello() {
  console.log("JS says Hello!");
}

function fetchDatabase() {
  console.log("Data Retrieved");
}

setTimeout(() => {
  fetchDatabase();
}, 3000);

sayHello();
console.log("Meanwhile doing some other task...");

If you run the above code in the browser or in the node, the output will be:

Fetching Data
JS says Hello!
Meanwhile doing some other task...
Data Retrieved

Following things happened when the above code is run:

JavaScript printed the first statement.
After that, it called the Web API that is setTimeout() and delegated the task of fetching from the database.
Then the sayHello() function gets pushed on to the Call Stack and the second statement gets printed and sayHello() is popped off the stack.
Meanwhile the Callback Queue keeps record for some other pending tasks or DOM events and Event Loop continuously checks for the tasks in the queue and pushes the task onto the Call Stack.
The third statement gets printed, and after 3 seconds the data is retrieved and Event Loop pushes it onto the Call Stack and the last statement gets printed.

Here you saw that how setTimeout() simulated a long running task of fetching from database and the asynchronous nature of the runtime made the code Non-blocking.

In this post you got an idea about:

Execution Context and the two phases
Single threaded nature of JavaScript
Call Stack and Memory Heap
JavaScript Runtime, event loop, callback queue

Keep Learning and Keep Growing 🎉

Micro-services: A micro introduction

Mayank Vats — Sat, 19 Jun 2021 12:40:27 +0000

An introduction to micro-services is incomplete without talking about monolith architecture, so before we start talking about micro-services let's first see what a monolith is, to get a good idea of what micro-services are and why they are needed.

🚀 Monolith Architecture

  In this type of architectural style, an application is developed as a single codebase and deployed as a single unit. Let's say you want to build a small role playing game(RPG) with following features:
    A. Build an avatar
    B. List available power-ups
    C. Upgrade player's power
    D. Daily bonuses

In a monolith architecture each of these features will be bundled in a single unit and then deployed, and this single unit will refer to one single database. Earlier, this kind of architecture was very common.

🚀 Micro-service Architecture

In this type of architectural style, an application is broken down based on its features, and each feature has its own codebase, known as a service, and each service refers to its own database (this model is also known as Database-per-service model).

Taking the above example of the role playing game, Build an avatar, List available power-ups, Upgrade player's power, Daily bonuses, each of these features can be a service of its own, that is, each feature can be a self-contained unit and have its own database.

The why of micro-services

Multiple teams can work independently on different features.
No single point of failure.
Even if one service fails the other one is not affected.

Microservices also provide a great way for independent feature development.

This concludes the micro introduction to the micro-services. I hope you have learnt something new today.

Keep Learning and Keep Growing. 🎉

ERC 20 and Solidity: A Starting Point (Part 1)

Mayank Vats — Tue, 12 Jan 2021 16:30:04 +0000

Things you will learn:

Intro to solidity and smart contracts

What and Why of ERC20

Remix - an online code editor

If you have been following the world of blockchain you may have come across some terms such as cypto currencies, tokens, digital assets etc. Thanks to Ethereum, since 2015, there have been a rise in number of projects over Ethereum blockchain and since May 2020, DeFi(Decentralized Finance) based projects are skyrocketing.

But on every blockchain based project you may have come across(or you will come across) you will notice that each project have their own token, a fungible asset for example COMP, BAL, LINK or Steve Woznaik's project Efforce token WOZX and many more.

Each of these tokens have one thing in common, that is, they are based on ERC20 token standards and are a fungible asset. In this series we will be diving into the know how of a Smart Contract, Solidity, ERC20 token, and also how you can build and deploy your own token, so let's get started.

What is a Smart Contract ?

It is a source code which is written in Solidity, Vyper, Go and many more languages, compiled to byte code and deployed over Ethereum blockchain and executed by Ethereum Virtual Machine(EVM).

An example (Using Solidity):

pragma solidity ^0.6.0;

contract myContract {
    uint public a = 1;

    function setA(uint _a) public returns (uint) {
        a = _a;
        return a;
    }
}

Compile and deploy smart contract

To try the code above in Remix, the online solidity's code editor, follow the given steps below:

Go here and create a new file with .sol as extension, as shown
Copy and paste the code in the example above in the file you created, and compile the code as shown (see the left side)
Now we need to deploy the compiled code to interact with it, you can deploy the code as shown in the picture (see the left side)

Interacting with the contract

After deploying the contract if you scroll down the left side you will see something like this

As you can see in the image above, Remix has generated two buttons for the corresponding functions in the contract setA() and a().
Note: Since variable 'a' is declared public the getter function for its value is automatically generated with same name as variable.

So, What is ERC20?

Now you have the idea of what smart contract is, how to write and deploy one and how you can interact with it, you are ready to understand the concept of ERC20 and its tokens.
Every token on the Ethereum blockchain is just a smart contract with some specific functions and variables and runs on Ethereum Virtual Machine(EVM) and follows a specific rules set by Ethereum Requests for Comments(ERC). These rules state that every smart contract written for the development of an ERC20 token must have the following functions defined by the ERC:-

function name() public view returns (string)
function symbol() public view returns (string)
function decimals() public view returns (uint8)
function totalSupply() public view returns (uint256)
function balanceOf(address _owner) public view returns (uint256 balance)
function transfer(address _to, uint256 _value) public returns (bool success)
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
function approve(address _spender, uint256 _value) public returns (bool success)
function allowance(address _owner, address _spender) public view returns (uint256 remaining)

But why does the smart contract must adhere to these rules? Why can't we make our own functions?

Well, we can make our own functions and there is nothing wrong in doing so. But, if every developer makes their own functions for the token's smart contract then to interact with those contracts you would first need to know about name and signature of each function, which may be an inefficient way, since the idea behind every token's smart contract is same, that is to:

keep track of and check total supply.
keep track of and check each user's balance.
transfer the tokens to other account.
allow someone else to transfer them on your behalf.

Thus, ERC20 standard makes our life easier and we don't have to know about the name and signature of particular token's smart contract functions for total supply, balance, transfer and allowing someone else to transfer those tokens.

Make your own token

You can make your own token right now, by following the steps mentioned above for compiling and deploying the contract.
The contract's code can be found here which you can copy paste into Remix.

Thank you for your valuable time. I will be writing the Part 2 of this blog in a short while, where I will explain each and every function of the ERC20 Token smart contract.