DEV Community: Selçuk

How to deploy your token to a testnet

Selçuk — Fri, 11 Feb 2022 14:56:34 +0000

In the last tutorial, you had created and deployed your ERC20 token locally. In this tutorial, you will learn to deploy your ERC20 token on a testnet.

What is a testnet?

Ethereum, as a whole, has multiple networks. Mainnet is the actual network that Ethereum uses, but there are other networks, which are used by developers to test their contracts. In this tutorial, we will be using the Kovan testnet.

Requirements

You will need a MetaMask browser wallet.
You will need an Infura account.

Get test Ether

Each testnet has its own type of Ether. We will be using the Kovan testnet in this tutorial, so you will need some Kovan ETH. To get Kovan ETH, you will need to use a faucet. Faucet, as understandable by its name, is a source where you can earn test ETH by accomplishing simple tasks.
The faucet I personally use is the Chainlink faucet. From the following link, you can get free Kovan ETH by just typing your address that you get from MetaMask and solving an easy captcha.
Click this to go to the faucet

About environment variables

When working with projects, you might have some sensitive data which should not be published at anywhere, as an example, we can think of API keys. To not publish sensitive data, but still reach to it in your local project, you will need environment variables. Brownie has an option for environment variables and this can be very helpful in some situations.
In the base directory, create a file named .env. In this file, you are going to store your project's environment variables.
In brownie-config.yaml which we had created earlier, add these options:

dotenv: .env
wallets:
  from_key: ${PRIVATE_KEY}

This will be helpful later in the tutorial.

Get Infura Project ID

To connect to the Kovan testnet, you will need an endpoint. Infura is a service which provides simple and reliable access to Ethereum. If you have already opened your Infura account, create a new project, open the project settings and copy the PROJECT ID. Paste in into the .env file we created earlier, like this:

WEB3_INFURA_PROJECT_ID=your_project_id

Now brownie will use this project to reach to the Kovan endpoint.

Get Metamask Private Key

If you have already installed the MetaMask extension and opened an account, go to the extension window, click to the three dots at the top right, enter to 'Account Details', click 'Export Private Key', enter your password, copy your private key and paste it into the .env file like this:

PRIVATE_KEY=your_private_key

At the end, your .env file should look like this:

WEB3_INFURA_PROJECT_ID=your_project_id
PRIVATE_KEY=your_private_key

You have successfully set up the project environment variables.

Deploy the contract

As you might recall, we had used a local account at the previous tutorial. It is time to change that into our MetaMask account.
Open the scripts/deploy.py file again and change it to look like the following code.

from brownie import MyToken, accounts, config
from web3 import Web3

initial_supply = 1000000

def main():
    account = accounts.add(config["wallets"]["from_key"])
    my_token = MyToken.deploy(initial_supply, {'from': account})
    print(my_token.name())

We only changed the accounts, as we have set the private key path in our config earlier in the tutorial, we can get our account easily.
Now, let's deploy our contract. Open a command line window at the base directory, and enter this command:

> brownie run scripts/deploy.py --network kovan

If no errors occur, your contract will be deployed, and you will be given info about the transaction:

Transaction sent: 0x8175029649fc9d6bacf90b1d4fb3789cc4e626d2cfe57c670b4b787dee296726
  Gas price: 2.500000007 gwei   Gas limit: 704322   Nonce: 26
  MyToken.constructor confirmed   Block: 29779219   Gas used: 640293 (90.91%)
  MyToken deployed at: 0x5BD01Af26009232e51A012C874881051Eee6239d

Congratulations, you have successfully deployed your token to a testnet! If you want to see your token on Etherscan, copy the address after MyToken deployed at:, which is the smart contract address, paste it into Kovan Etherscan explorer, and your token is visibly there.

I hope this tutorial series was helpful for you to begin developing smart contracts. If you have any questions, or have noticed any problems, feel free to comment!

How to create your own token with Solidity and Python

Selçuk — Fri, 11 Feb 2022 12:02:11 +0000

In this tutorial, you will learn how to create a simple ERC20 token with Solidity and deploy it onto a testnet with Python.

What is an ERC20 token?

ERC20 is a token standard that resides in a smart contract. What makes it different from other standards is that it is interchangeable, which means one ERC20 token will always be equal to another of the same kind. The thing that makes ERC20 a token and not a coin is the fact that smart contracts that control ERC20 tokens live on the Ethereum and other EVM compatible blockchains such as Avalanche, meanwhile coins have their own native blockchains.

Requirements

You will need Python 3.6 or greater and pip.
You will also need npm.
We will be accomplishing things like tests and deployment using the Python package named Brownie, so you will need to install it from pip.

> pip install eth-brownie

You will also need ganache-cli, so that brownie can locally deploy/test the contracts.

> npm install ganache-cli

Project setup

Open a folder, launch a command line window inside of it and run the following command, which will initialize the basic files of your brownie project for you.

> brownie init

You will see that these files have been created.

├───build
│   ├───contracts
│   ├───deployments
│   └───interfaces
├───contracts
├───interfaces
├───reports
├───scripts
└───tests

The only folders we will focus on this tutorial are contracts and scripts. The contracts folder will hold our smart contracts and the scripts folder is going to be the one where we write our deployment scripts.

Configuration

In this tutorial, we are going to use the OpenZeppelin library. This library provides a lot of utilities and standards which can be easily imported and used in your project. To get OpenZeppelin for our project and add more settings further in the project, in the base directory we need to create a brownie-config.yaml file where we are going to configure our dependencies.
After you create the file, add these so that the library gets installed when we compile our contract.

dependencies:
  - OpenZeppelin/openzeppelin-contracts@4.2.0

compiler:
  solc:
    remappings:
      - "@openzeppelin=OpenZeppelin/openzeppelin-contracts@4.2.0"

In the dependencies section, we add the github repository of our target library and specify the version to be downloaded.
In the remappings section, we specify a remapping for the library path so that we do not have to type longer imports.

Writing the contract

A smart contract is basically code that resides on the Ethereum blockchain and is available to run functions, emit events and such. Create your smart contract code by creating a new file MyToken.sol in the contracts folder.

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

contract MyToken is ERC20 {

    constructor(uint256 initialSupply) ERC20("MyToken","TKN"){
        _mint(msg.sender, initialSupply);
    }
}

What does this code do?
The pragma keyword lets us specify which versions our code will be compatible with. This means that our code will be compatible with versions of 0.8.0, which means our contract can run in 0.8.0, 0.8.5 and such, but can not run in 0.7.0 or 0.9.0.

In the import statement, we reached to the ERC20.sol file from the OpenZeppelin library so that we can use it in our contract.

After we declared our contract, we added is ERC20, which basically inherits the functions of ERC20.sol, which technically makes our smart contract an ERC20.

The constructor allows us to initialize our smart contract. We added ERC20("MyToken", "TKN") to declare the name and symbol. The initialSupply is the amount which will be minted to the deployer of the contract.

Compiling the contract

After you have written the contract, you will have to compile the contract. To compile the contract to see if you have any errors, run the following command in the base directory.

> brownie compile

If you have no errors, now it is time to deploy it to the local ganache!

Local deployment

Create deploy.py in the scripts folder.

from brownie import MyToken, accounts
from web3 import Web3

initial_supply = 1000000

def main():
    account = accounts[0]
    my_token = MyToken.deploy(initial_supply, {'from': account})
    print(my_token.name())

The accounts that we imported from brownie are local accounts created by ganache. These make it easier for us to do operations like deployment, tests, etc.
By getting a local account and our contract MyToken from brownie, we are able to deploy the contract and use the deploy function. {'from': account} is the parameter we give to the function which allows it to be transacted by the account.
At the end, we print the use the inherited name() function to get the name we had entered in the ERC20 constructor of our contract.

After you finish coding, open your command line window in the base directory, and type the following command, which will run the script and show information about the transactions.

> brownie run scripts/deploy.py

If this runs without any problems and you get the output of the tokens name at the end, it means that you've made it!

This is the end of this part of the tutorial. If you have seen any mistakes in this tutorial, or if you have any questions, feel free to comment about it. If you want to accomplish more and deploy your token onto a testnet, follow along the series. I hope this tutorial will be your starting point to Web3!