Create your own Blockchain ERC20 Token | Python, Brownie, Solidity

This helpful video course will assist you in creating an ERC20 token on the Ethereum blockchain. ERC-20 is the standard for fungible tokens on the Ethereum blockchain. This can be an advanced concept for a beginner, but with the right guidelines, even a beginner can easily develop their own Blockchain ERC20 Token. You will learn how to create a Blockchain ERC20 Token with the help of Python, Brownie, and Solidity. This tutorial covers all the fundamental concepts of Ethereum-based tokens and offers developers a hands-on development experience.

ERC20 – An Overview

ERC20 is a widely used and accepted Ethereum blockchain token standard. Within ERC20, a set of rules and functionalities help interact with other tokens and the system. For developers, ERC20 is especially important because it can help create tokens that are widely accepted and compatible with many wallets, exchanges, and dApps.

To create the ERC20 token, you will mainly use Python, Brownie, and Solidity. Here is how these languages are helpful:

Python

It is a beginner-friendly programming language that will work as the primary development language.

Brownie

A development framework is especially used for developing Ethereum smart contracts.

Solidity

This is another programming language that is used to design smart contracts on the Ethereum platform.

What Will You Learn in this Free Course?

In this tutorial, the students will learn about fundamental topics like starting a Brownie repository, developing token contracts, launching these tokens on the local blockchain, and developing seamless connections between various networks.

Moreover, you will learn about token customization and adjusting token behavior, such as adding token dependencies and adjusting the initial supply, as well as other functionalities. Finally, this guide will help you understand the workings of ERC20 tokens, their deployment, and customization.

By the end of this tutorial, you will be able to create your token and adjust it based on your needs and requirements.

How to Develop an ERC20 Token?

ERC20 token is considered a standard in the Ethereum blockchain. However, there is a lot of room for customization.

Here is a step-by-step process for creating an ERC20 Token:

Create a New Brownie Repository

To kick-start the process, you need a Brownie Repository. You can install Brownie by simply using the following command prompt and add it to the terminal:

pip install eth-brownie

Now that you have installed Brownie, you need to make a new directory for your project. Here is a code that can help you create a new directory and navigate to it:

mkdir my-erc20-token && cd my-erc20-token

Start a fresh Brownie project with the following code prompt:

brownie init

Place Token Contracts with Contracts Folder

For this project, you need to go to the contract folder within the project directory. Here is a quick prompt that you can use for that:

cd contracts

Now, it is time to make a fresh file and simply name it Token.sol. After making the file, use any code editor of your choice to open it.

After opening the Token.sol file, copy the following Solidity code and paste it:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract Token {

   // Token implementation

}

Deploy this in the Local Blockchain

Go to the project directory and then to the scripts folder. Here is a prompt to help you navigate to the scripts:

cd scripts

Now, make a new file and name it deploy_token.py. You can use any code editor of your choice to open this file.

Within your deploy_token.py file, just copy and paste the following Python code:

from brownie import accounts, Token

def main():

   deployer=accounts[0]

   token=Token.deploy({'from': deployer})

   print(f'Token deployed at address: {token.address}')

Now that you have pasted the code, you can save this file and exit it. Finally, you can use the following command and paste it into your terminal. This will help you run the token to your local blockchain: brownie run deploy_token

Install it with npm or yarn

Now, start a new npm or yarn project within your project directory. Here is a prompt that will facilitate the process:

npm init -y

Here is another code that you can use for installing the essential dependencies:

npm install @openzeppelin/contracts

Deploy Supply Token

Now, it’s time to deploy the supply token. To do this, you have to navigate to the contracts folder and open Token.sol file. Now, copy the code below and paste it under the contract token line:

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

contract Token is ERC20 {

   constructor(uint256 initialSupply) ERC20("MyToken", "MTK") {

       _mint(msg.sender, initialSupply);

   }

}

Provide an Initial Supply

To give an initial supply, you have to get to the scripts folder and then navigate to deploy_token.py file.

Now, you can customize the main function. Here is an example of customizing the main function:

def main():

   deployer=accounts[0]

   initial_supply=1000000 # Set the initial supply as desired

token=Token.deploy(initial_supply, {'from': deployer})

   print(f'Token deployed at address: {token.address}')

Add Dependencies

1. Go to the project directory and get to the brownie-config.yaml file.
2. You can use OpenZeppelin contracts for customizing the dependencies section:

dependencies:

 - OpenZeppelin/openzeppelin-contracts@4.0.0

Generate a New Script

1. Navigate to the scripts folder and make a new file. Now, you can name this file custom_tokens.py.
2. Open this file in any code editor and copy the following Python code.
3. You need to paste this code into the custom_tokens.py file, and you will be able to create a new script.

from brownie import accounts, Token

def main():

   deployer=accounts[0]

token1=Token.deploy(1000000, {'from': deployer})

token2=Token.deploy(2000000, {'from': deployer})

token3=Token.deploy(3000000, {'from': deployer})

   print(f'Token 1 deployed at address: {token1.address}')

   print(f'Token 2 deployed at address: {token2.address}')

   print(f'Token 3 deployed at address: {token3.address}')

Link this to Blockchain

1. Within the project directory, you will find brownie-config.yaml file.
2. Open this file and customize the networks section.

This will help you add a local development network, and you will be able to connect it to the Blockchain.

networks:

 development:

   host: localhost

   chainid: 1337 # Choose a suitable chain ID

   gas_limit: 10000000 # Adjust the gas limit as needed

   gas_price: 20000000000 # Adjust the gas price as needed

Create a Wallet Section

To specify the mnemonic phrase of your Ethereum account, you need to navigate to the project directory. Now open the brownie-config.yaml file and change the wallet section.

Here is a quick example of modifying the wallet section

wallets:

from_key: ${YOUR_MNEMONIC_PHRASE}

Replace ${YOUR_MNEMONIC_PHRASE} with your actual mnemonic phrase.

Covenant Testnet Deployment

Now, you can deploy the custom token that you just created to covenant testnet. To deploy these tokens, you need to go to the terminal, copy the following command, and paste it into the terminal:

brownie run custom_tokens --network covenant

Customize Your Tokens

Now that you have created tokens, you can easily customize and add functionalities that you need. To customize the token, go to the contract folder and open the Token.sol file.

Now, you can add the functionalities of your choice to the token contract. This will help you customize the token based on the project requirement. You can add a minting function, access control system or even implement token burning as well.

Congrats! You just created your own ERC20 token with Python, Brownie, and Solidity. Take your time and experiment with the customization of token behavior. There are so many different ways you can control different functionalities, deploy them on different networks, and even integrate them into other apps.