DEV Community: azattech

Hands-On Hardhat Part-3 (Write Your Custom Own Token)

azattech — Sun, 07 Aug 2022 10:43:00 +0000

Hands-On Hardhat Part-3

In the previous parts, we set up the project, wrote and deployed our first contract. In this part, we‘re gonna learn the ERC-20 standard and write our ERC-20 standard token.

EIP

To understand ERC, we should first understand EIP (Ethereum Improvement Proposals). As you know, Ethereum and other blockchain networks are community-based. At this point, anyone who wants to improve the network can present a proposal. For example, if Vitalik Buterin wants to do something for the Ethereum network, he presents a proposal or if you want to do something for the Ethereum network, you have to present a proposal for it. So it is like Bitcoin Improvement Proposals (BIP). Simply put, EIPs are drafts of ideas for new features or design functions put forward by any community member to be reviewed by stakeholders in the Ethereum ecosystem.

However, these proposals have fundamental standards and you must clearly state them; Abstract, Motivation, Specification, Rationale, Backwards Compatibility, Test Cases, Reference Implementation, Security Considerations.
For now, I’m not gonna detail all of them I’m just giving an example of a proposal.

And also EIPs have 3 types:

Standards Track EIP
- Core
- Networking
- Interface
- ERC
Meta EIP
Informational EIP

for furthermore details please check out this

In other words, after you have prepared tight documentation, you can present your proposal. But, not everything happens at once because the EIP has its processes.

The life cycle of an EIP involves distinct stages. An 'idea' must first be 'drafted,' allowing the proposal to be put into the EIP repository by an EIP Editor. The proposal then enters the 'review' stage, during which an author requests a date for peer review. An Editor assigns the proposal a 'last-call' status at the end of which it must be granted a 'final' state, typically after 14 days.
Any EIP can be pushed into the 'stagnant' state if left without progression for six months. A high level of technical competence is required for an EIP to be submitted, and a successful ERC is one that has not only entered a state of 'final' but is also in use by projects.

EIP Process

ERC20

ERC stands for “Ethereum Request for Comments”, it is a specialized subtype of EIP, relating to application-level changes that do not affect the Ethereum protocol itself.

It was introduced by Fabian Vogelsteller in 2015-11-19. It was an assigned GitHub issue number 20 and named “ERC20. The ERC20 is a proposal that intends to standardize how a token contract should be defined, how we interact with such a token contract, and how these contracts interact with each other.

→ ERC20 standard is for fungible tokens created using the Ethereum blockchain.
→ A fungible token is one that is interchangeable with another token.
→This standard interface allows any tokens on Ethereum to be re-used by other applications: from wallets to decentralized exchanges.

There are many ERCs such as ERC721 vs ERC1155 I’m not gonna explain all of them to see all ERCs please check out here.

As I mentioned before every proposal have fundamental standards and you must clearly state them, so according to EIP-20’s documentation ERC20 token’s Specification has to provide at least the following functions and events:

Before the coding let me explain a few things, for now I’m not gonna implement ERC20Interface. Because I don’t wanna reinvent the wheel. Probably my implementation will have some vulnerabilities and don't gas saving. So there are some implementations by various teams I mean I’m just gonna use the wheel, for today I will continue with Openzeppelin.

OpenZeppelin

OpenZeppelin is an open-source framework to build secure smart contracts it provides a complete suite of security products and audit services to build, manage, and inspect all aspects of software development and operations for decentralized applications.

Now let’s start coding;

First, we need to add openzeppelin dependency, to add this dependency open your terminal and run this command line;

npm install @openzeppelin/contracts

Second, in your project structure, open contracts package, create named MyOwnToken.sol file and then import openzeppelin ERC20 contract.

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

Lastly, write your MyOwnToken and inherit it from ERC20.

your code should follows as;

Your constructor takes a named initialSupply parameter and inherited ERC20 contract which takes 2 parameters token name and token symbol. And also in the constructor’s scope there is a _mint() function which sets how many tokens will be mint. Now maybe some of you get confused why we did like that? When you open ERC20.sol file you see it is inherited from IERC20 interface which is I mentioned above that ERC20 standard all codes that we must write come by openzeppelin. If we didn’t inherit MyOwnToken from ERC20 we would have to write functions that ERC20 has. And probably the codes that we wrote would not be efficient and safety as openzeppelin’s codes.

That’a all folks we wrote our custom token.

Next, before writing tests and deploying our smart contract there is one more thing that I want to mention it. For example you want to your token should burnable or has some access controls etc. and you’re struggling to write them, there is an openzeppelin playground, you choose options and the code of your token is written automatically just not for ERC20 also ERC721 and ERC1155 exist. To checkout playground visit here.

Now, let’s deploy and write our contract test.
First, open your terminal write compile command line;

npx hardhat compile

After compiling (I assume that you didn’t get any errors), create a named deployMyOwnToken.js file inside scripts package write your script codes for deploying;

After your script writing is done open 2 terminal one is to launch node and another is for deploying.

in first terminal write

npx hardhat node

in the another one write;

npx hardhat run ./scripts/deployMyOwnToken.js --network localhost

So far so so good until now.

Let’s write unit tests. Create a named my-own-token-test.js file inside test package and files code follows as;

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("MyOwnToken", function () {
  let totalSupply = "10000000000000000000000"; // 10000 * 1e18
  let MyOwnToken, myOwnToken, owner, address1, address2, address3;

  beforeEach(async function () {
    /**
     * A ContractFactory in ethers.js is an abstraction used to deploy new smart contracts,
     * so MyOwnToken here is a factory for instances of our token contract.
     */
    MyOwnToken = await ethers.getContractFactory("MyOwnToken");

    /** A Signer in ethers.js is an object that represents an Ethereum account.
     * It's used to send transactions to contracts and other accounts.
     * */
    [owner, address1, address2, ...address3] = await ethers.getSigners();

    myOwnToken = await MyOwnToken.deploy(totalSupply);
  });

  describe("Deployment", function () {
    it("Should assign the total supply of tokens to the owner", async function () {
      const ownerBalance = await myOwnToken.balanceOf(owner.address);
      expect(await myOwnToken.totalSupply()).to.equal(ownerBalance);
    });
  });

  describe("Transactions", function () {
    it("Should transfer tokens between accounts", async function () {
      const ownerBalance = await myOwnToken.balanceOf(owner.address);

      // Transfer 2000 tokens from owner to addr1
      await myOwnToken.transfer(address1.address, 2000);
      const address1Balance = await myOwnToken.balanceOf(address1.address);
      expect(address1Balance).to.equal(2000);

      // Transfer 2000 tokens from address1 to address2
      // We use .connect(signer) to send a transaction from another account
      await myOwnToken.connect(address1).transfer(address2.address, 2000);
      const address2Balance = await myOwnToken.balanceOf(address2.address);
      expect(address2Balance).to.equal(2000);
    });

    it("Should fail if sender doesn’t have enough tokens", async function () {
      const initialOwnerBalance = await myOwnToken.balanceOf(owner.address);

      // Try to send 1 token from address1 (0 tokens) to owner (1000000 tokens).
      // `require` will evaluate false and revert the transaction.
      await expect(
        myOwnToken.connect(address1).transfer(owner.address, 1)
      ).to.be.revertedWith("ERC20: transfer amount exceeds balance");

      // Owner balance shouldn't have changed.
      expect(await myOwnToken.balanceOf(owner.address)).to.equal(
        initialOwnerBalance
      );
    });
  });
});

specify your testfolder and run test command line;

npx hardhat test ./test/my-own-token-test.js

Well, it's done see you in the next parts.

References:
https://eips.ethereum.org/EIPS/eip-1
https://eips.ethereum.org/EIPS/eip-20
https://dev.to/yakult/a-concise-hardhat-tutorial-part-2-writing-erc20-2jpm

Connect with me on social media: Twitter && LinkedIn && Github

Hands-On Hardhat Part-2 (Writing Contract, Testing, and Deploying)

azattech — Wed, 06 Jul 2022 14:48:00 +0000

In the previous part, we mentioned how to set up our project environment with Hardhat. In this part, we will detail our project structure and write our first contract with its tests and finally, we will deploy it.

Okay, folks let’s open our VSCode.

When you look at our project's structure there is a contract that is coming as a default contract but we don’t need and don’t go over it. We’re gonna write our contract.

Let’s think about our contract, for example, we have a BookStore which lists our books and gives us information about listed books like the book’s name, author, price, and availability.

Creating Contract

And back to your VSCode, in the contract directory create a named BookStore.sol file.

Now, our BookStore.sol should be as follows;

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

contract BookStore {

    // Book's infos
    struct Book {
        string bookName;
        string bookAuthor;
        uint256 bookPrice;
        bool available;
    }

    // Books list
    Book[] public books;

    // Create a new book to add books list
    function createBook(
        string memory _name,
        string memory _author,
        uint256 _price,
        bool _available
    ) external {
        books.push(Book(_name, _author, _price, _available));
    }

    // Update book price by books list index
    function updateBookPrice(
        uint _index, 
        uint256 _newPrice
    ) external {
        books[_index].bookPrice = _newPrice;
    }

    // Update book avalibility by books list index
    function updateBookAvalibility(
        uint _index,
        bool _isAvaliable
    ) external {
        books[_index].available = _isAvaliable;
    }

    // Gell all books
    function getAllBooks() external view returns(Book[] memory) {
        return books;
    }
}

Writing the Contract tests

In the test folder create a named book-store-test.js
The project’s structure follows as;

Folks at this stage I wanna point out something, in the previous part, I added all necessary libraries or plugins automatically because we chose an advanced sample project so in this file maybe you are confused about chai or other pieces of stuff that where they are coming because they are coming as a default.

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("BookStore", function () {
  let BookStore, bookStore;

  before(async function () {
   /**
     * A ContractFactory in ethers.js is an abstraction used to deploy new smart contracts, 
     * so BookStore here is a factory for instances of our bookStore contract.
     */
    BookStore = await ethers.getContractFactory("BookStore");

    /**
     * Calling deploy() on a ContractFactory will start the deployment, 
     * and return a Promise that resolves to a Contract. 
     * This is the object that has a method for each of your smart contract functions.
     */
    bookStore = await BookStore.deploy();
    await bookStore.deployed();
  });

  it("should create a new book", async function () {
    await bookStore.createBook("1984", "George Orwell", 2, true);
    let books = await bookStore.getAllBooks();
    expect(books[0].bookName).to.equal("1984");
    expect(books[0].bookAuthor).to.equal("George Orwell");
    expect(books[0].bookPrice).to.equal(2);
    expect(books[0].available).to.equal(true);
  });

  it("should update book price", async function () {
    await bookStore.updateBookPrice(0, 4);
    let books = await bookStore.getAllBooks();
    expect(books[0].bookPrice).to.equal(4);
  });

  it("should update book availibity", async function () {
    await bookStore.updateBookAvalibility(0, false);
    let books = await bookStore.getAllBooks();
    expect(books[0].available).to.equal(false);
  });

  it("should return all books", async function () {
    await bookStore.createBook("Building a Second Brain", "Tiago Forte", 3, true );
    await bookStore.createBook("Last Summer on State Street", "Toya Wolfe", 1, true);
    await bookStore.createBook("Do Hard Things", "Steve Magness", 5, false);
    await bookStore.createBook("The Power of Discipline", "Daniel Walter", 6, true);
    await bookStore.createBook("Mindful Self-Discipline", "Giovanni Dienstmann", 2, false);
    let books = await bookStore.getAllBooks();
    expect(books.length).to.equal(6);
  });
});

after writing your test scenarios run the test task in your terminal;

npx hardhat test

At this point, don’t forget to specify your test folder. For example, our test file is inside the test folder so we have o specify it;

npx hardhat test ./test/book-store-test.js

Well, our all tests passed.

Deploying the Contract

Okay, folks so far everything is cool to deploy our contract we have to write our deployment scripts. Open your script folder and create named deployBookStore.js file.

Your script file should be as follows;

/**
 * We require the Hardhat Runtime Environment explicitly here.
 * This is optional but useful for running
 * the script in a standalone fashion through `node <script>`.
 * When running the script with `npx hardhat run <script>`
 * you'll find the Hardhat Runtime Environment's
 * members available in the global scope.
 * */
const hre = require("hardhat");

async function main() {
  /**
   * Hardhat always runs the compile task when running scripts
   * with its command line interface.
   * If this script is run directly using `node`
   * you may want to call compile
   * manually to make sure everything is compiled
   * await hre.run('compile');
   * */

  // We get the contract to deploy
  const BookStore = await hre.ethers.getContractFactory("BookStore");
  const bookStore = await BookStore.deploy();

  await bookStore.deployed();

  console.log("BookStore deployed to: ", bookStore.address);
}

/**
 * We recommend this pattern to be able to use
 * async/await everywhere and properly handle errors.
 * */
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

After your script writing is done, open your terminal and write this command line to start a local blockchain;

npx hardhat node

Then, open another terminal and run your script file;

npx hardhat run ./scripts/deployBookStore.js --network localhost

As you can see our contract deployed successfully.

So we did all things perfectly what if we want to deploy our contract to a different network like Ropsten, Rinkeby, or Goerli. To perform this scenario we have some options Alchemy and Infura. They are Blockchain API and node infrastructure.

For now, I’m gonna use Infura which provides the tools and infrastructure that allow developers to easily take their blockchain application from testing to scaled deployment.

To set up environment go to Infura and sign up and then create a new project.

And then go to project detail page choose Ropsten Network and copy endpoint;

After we got the Infura API_KEY we also need private key. Open your Metamask wallet and choose Ropsten Test Network and click three dots then click Account details

Then click Export Private Key

After got the private key, back to your VSCode open hardhat.config.js file.

Your file code follows as;

require("dotenv").config();

require("@nomiclabs/hardhat-etherscan");
require("@nomiclabs/hardhat-waffle");
require("hardhat-gas-reporter");
require("solidity-coverage");

// This is a sample Hardhat task. To learn how to create your own go to
// https://hardhat.org/guides/create-task.html
task("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
  const accounts = await hre.ethers.getSigners();

  for (const account of accounts) {
    console.log(account.address);
  }
});

// You need to export an object to set up your config
// Go to https://hardhat.org/config/ to learn more

const API_URL = "https://ropsten.infura.io/v3/API_KEY";
const PRIVATE_KEY = "";
/**
 * @type import('hardhat/config').HardhatUserConfig
 */
module.exports = {
  solidity: "0.8.4",
  networks: {
    ropsten: {
      url: API_URL,
      accounts: [`0x${PRIVATE_KEY}`],
    },
  },
};

Now, open your terminal run your deployment task;

npx hardhat run ./scripts/deployBookStore.js --network ropsten

To check your contract go to https://ropsten.etherscan.io/ search your contract adress.

That's all congratulations folks you've done writing, testing, and deploying your first contract.

To sum up, what can we do with HardHat?

Coverage (Check for Missing Tests)
Gas Reports (Check fo Optimization)
Dotenv (Secure Keys for Deployment)
Localhost (Quick Nodes for Local Testing)
Solhint Integration (Style Guide and Security)
Scripts (Compile and Deploy Running Scripts)
Typescript (Statically Typed for Bug Avoidance)
Etherscan Verification (Streamline Workflow on IDE)

Connect with me on social media: Twitter && LinkedIn && Github

Hands-On Hardhat - Part-1 (Setting up Environment)

azattech — Fri, 24 Jun 2022 21:36:00 +0000

Hi everyone I hope that you’re doing good. Today I’m gonna explain Hardhat in briefly. What is Hardhat and why we need it?

So What is It?

Firstly, according to their documentation; Hardhat is a development environment to compile, deploy, test, and debug your Ethereum software. It helps developers manage and automate the recurring tasks that are inherent to the process of building smart contracts and dApps, as well as easily introducing more functionality around this workflow. This means compiling, running and testing smart contracts at the very core. Hardhat comes built-in with Hardhat Network, a local Ethereum network designed for development. It’s functionality focuses around Solidity debugging, featuring stack traces, console.log()and explicit error messages when transactions fail. And Hardhat is written in JavaScript and Node.js.

Why we need it?
Before production we write our codes and we need to test them locally. Because we can make mistake in our own local environment and we don’t want users to see our mistakes and to prevent wrong operations, transactions or related stuffs in production. And especially if we work with Ethereum or other cryptos ecosystems we don’t wanna deploy our smart contracts straight to mainnet because these kinds of deployments are so much expensive we have to pay gas to run these transactions. So without further ado Hardhat helps us to set up a local ethereum development environment.

Okay, lads and gents let’s not beat around the bush and start to set up our environment.

Note: Before starting I assume that you’ve installed node.js

Open your terminal and create a project directory;

mkdir hands-on-hardhat

and go into it,

cd hands-on-hardhat

and then writes these command lines to init and install hardhat;

npm init --yes
npm install --save-dev hardhat

In the same directory where you installed Hardhat and run:

npx hardhat

at there, the command line ask you to choice an option and I wanna point out a few things here;

These options totally depend on your requirements.
For example an empty hardhat option is a very basic project sample if you need more libraries, plugins or you use Typescript later, you have to add them manually. Like @nomiclabs/hardhat-waffle , [ethereum-waffle](https://www.npmjs.com/package/ethereum-waffle), chai , @nomiclabs/hardhat-ethers , ethers , [@openzeppelin/contracts](https://www.npmjs.com/package/@openzeppelin/contracts)
Because, they'll allow us to interact with Ethereum and to test our contracts.

So, let me show you when you choose one of these options what will your project structure look like?

Empty

Basic

Advanced

Advanced-ts

In this tutorial I’m gonna choose an advanced sample because this tutorial will be a series so later on, I will need some libraries and I don’t want to waste my time adding other libraries.

After choosing an advanced sample my terminal is asking to me “Do you want to add a .gitignore?“

I’m gonna press enter and it will add .gitignore automatically for me.

After pressing enter look carefully at the terminal the libraries that I mentioned before all starting to download.

To make sure everything is working correctly run this command:

npx hardhat test

If you get an error like this;

write this line to the command line;

export NODE_OPTIONS=--openssl-legacy-provider

for furthermore details please check out this

well, seems everything is perfect!

The next thing that I wanted to show is the different tasks so now that we've let hardhat initialize our application and create that directory structure. If we run npx hardhat we'll see a list of different tasks or commands that we can run.

For example accounts task provides us a list of ethereum accounts that are available or compile task if we want to compile all the smart contracts in our project we use this task.
Maybe we need a local node for a local node we use node task.

To demonstrate I’m just running the accounts task for now;

So as you see It provided to us 20 ethereum test accounts.

after all installation is finished, just write this command line in the same directory;

code .

This command line will open your project automatically in VSCode.
If the command line doesn’t work like this;

Please check out this solution.

Well, congratulations you've just finished the project setup, take a breathe and wait for part 2, please.

Connect with me on social media: Twitter && LinkedIn && Github

Jetpack DataStore and How to implement it.

azattech — Sun, 13 Sep 2020 08:53:54 +0000

Jetpack DataStore is a new improved library and built on Coroutines and Flow which aims to replace the SharedPreferences. So What are the advantages over SharedPreferences; Data is stored asynchronously, consistently, and transactionally.

If we look a little deeper into our topic;

DataStore provides asynchronous API(via Flow) for storing and reading data but SharedPreferences provides async API only for reading data.
DataStore is safe to call on the UI thread because it uses Dispatchers.IO, but SharedPreferences blocks the UI thread. apply() and commit() have no mechanism of signaling errors and apply() will block the UI thread on fsync() often becoming a source of ANRs.
DataStore is safe from runtime exceptions, but SharedPreferences throws parsing errors in runtime exceptions.

And also DataStore has two different implementations:
Preferences DataStore and Proto DataStore

Preferences DataStore – stores and accesses data via key-value pairs like SharedPreferenecs, but this implementation does not provide type safety.

Proto DataStore – stores data as custom objects and requires to define a schema using protocol buffers. Also, it provides type safety.

Note: Today we're just looking at the implementation of the Preferences DataStore.

First of all, we need to add some dependencies;

    // Preferences DataStore
    implementation "androidx.datastore:datastore-preferences:1.0.0-alpha01" 

    // Lifecycle components
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0"
    implementation "androidx.lifecycle:lifecycle-extensions:2.2.0"
    implementation "androidx.lifecycle:lifecycle-common-java8:2.2.0"
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0"

Ok, Let's suppose we store a user's informations which are name and surname. Her is our UI;

Next, we're gonna create a named UserInfo class which takes a context in the constructor.

class UserInfo(context: Context) {

below, we create a dataStore and we need to give it a name.

class UserInfo(context: Context) {

    val dataStore = context.createDataStore("user_info")

}

Then we should create some keys, so to do this we're gonna create a companion object.

we create two keys which are named USER_NAME_KEY && USER_SURNAME_KEY, they're gonna be equal to preferencesKey of type String and then we need to give them the actual name USER_NAME && USER_SURNAME.

 class UserInfo(context: Context) {

    val dataStore = context.createDataStore("user_info")

    companion object {
        val USER_NAME_KEY = preferencesKey<String>("USER_NAME")
        val USER_SURNAME_KEY = preferencesKey<String>("USER_SURNAME")
    }
}

Next, we create a suspend function to save our data and it takes two arguments. We call dataStore.edit inside here we store values.

  suspend fun saveUserInfo(name: String, surname: String ) {
        dataStore.edit {
            it[USER_NAME_KEY] = name
            it[USER_SURNAME_KEY] = surname
        }
    }

So, that will take care of storing data to the key we have assigned it.

Now we create two flow which will help us to retrieve data. And we map them to our keys also we check if they're null we return an empty String ("")

val userNameFlow: Flow<String> = dataStore.data.map {
        it[USER_NAME_KEY] ?: ""
    }

val userSurnameFlow: Flow<String> = dataStore.data.map {
        it[USER_SURNAME_KEY] ?: ""
    }

Okay until now we're done with UserInfo. Now we're going to MainActivity.

First, we create a lateinit var for UserInfo and 2 variables for name and surname.

 lateinit var userInfo: UserInfo

 var name = ""
 var surname = ""

And we're going to onCreate method to instantiate userInfo and write two methods that retrieve and save data.

 override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        userInfo = UserInfo(this)

        saveData()

        observeData()
    }

After this one, we're going to saveData()
and inside here, as you know we created a suspend function in UserInfo class. So, this has to be done in CoroutineScope. We're just gonna call GlobalScope.launch and inside this block code we call saveUserInfo() method.

 private fun saveData() {
        buttonSave.setOnClickListener {
            name = etName.text.toString()
            surname = etSurname.text.toString()

            GlobalScope.launch {
                userInfo.saveUserInfo(name, surname)
            }
        }
    }

After saving data we're going to observe our LiveDatas and retrieve them to write to our TextViews.

private fun observeData() {
        userInfo.userNameFlow.asLiveData().observe(this, {
            name = it
            tvName.text = "Saved name: $it"
        })

        userInfo.userSurnameFlow.asLiveData().observe(this, {
            surname = it
            tvSurname.text = "Saved surname: $it"
        })
    }

In additionally, as I mentioned before, DataStore is safe from runtime exceptions it reads data from a file, IOExceptions are thrown when an error occurs while reading data so, we can handle these exceptions before map()

val userNameFlow: Flow<String> = dataStore.data
        .catch { exception ->
            if (exception is IOException) {
                Log.d("DataStore", exception.message.toString())
                emit(emptyPreferences())
            } else {
                throw exception
            }
        }.map {
            it[USER_NAME_KEY] ?: ""
        }

Yeah, that's all.