It is also good to know that ERC20 tokens are considered smart contracts. For this reason, these tokens based on the Ethereum blockchain work in a decentralized manner in the blockchain.

This will increase the security of these tokens.

Solidity (Smart contract programming language)

Solidity is one of the programming languages ​​for smart contracts, which is used to build Ethereum-based tokens. Investors familiar with JavaScript or C-like programming languages ​​can easily learn solidity as well. Before we get into that, let’s take a look at ERC20 tokens.

What is an ERC-20 token?

The ERC-20 standard defines a set of short and basic functions that all ERC-20 tokens must be executed to interact with other contracts, markets, or wallets.

1. function totalSupply() public view returns (uint256)
2. function balanceOf(address tokenOwner) public view returns (uint);
3. function allowance(address tokenOwner, address spender)
4. public view returns (uint);
5. function transfer(address to, uint tokens) public returns (bool);
6. function approve(address spender, uint tokens)  public returns (bool);
7. function transferFrom(address from, address to, uint tokens) public returns (bool);

These functions allow external users, such as users of wallet applications, to find their account balances and transfer funds to other users’ accounts. Only two events are defined by smart contracts.

1. event Approval(address indexed tokenOwner, address indexed spender,
2. uint tokens);
3. event Transfer(address indexed from, address indexed to,
4. uint tokens);

When a user can transfer tokens from one account to another and this happens, these events are called or eventually published. Many ERC20 tokens have additional sections, such as:

1. string public constant name;
2. string public constant symbol;
3. uint8 public constant decimals;

How does the ERC-20 token work?

If you are not yet familiar with the ERC20 token, we suggest you pay attention to this section. ERC stands for Ethereum Request for Comments, and the number 20 indicates a valid ID. This name makes the ERC20 token different from other tokens and anyone can easily recognize it.

It should also be noted that this token is created in the Ethereum blockchain and for this reason, it must comply with some rules and standards related to this blockchain. Proper use of these rules will make their purchase and sale in this program easy and successful.

ERC-20 token coding using solidity

As mentioned earlier, you can easily encode ERC20 tokens using the solidity programming language. Of course, this position requires specialized knowledge in this field. In addition, by knowing this, you can create an ERC20 token with the best features. In the following, we will explain the most important steps required to make an ERC20 token.

1. Find mapping objects

Given the concept of Solidity for a key/value or associative array, you need to find two mapping objects:

1. mapping(address => uint256) balances;
2. mapping(address => mapping (address => uint256)) allowed;

· Mapping (address => unit 256) – It defines an associative array that contains address keys (a number used to indicate the account address) and values ​​of uint256 (a 256-bit integer used to store token balance).

· Balance – This is the first mapping object to hold each owner’s account balance.

· Allowed – It is the second mapping object that includes all the accounts that have been approved to withdraw tokens from a given account, as well as the withdrawal sum that has been approved for each account.

The above-mentioned mappings will be stored in the Ethereum blockchain along with the contract sections. They are then used to show changes in all sections of the user. You should always try to keep your blockchain storage to a minimum. This is because the cost of storage space in the blockchain seems relatively high, and it is the responsibility of smart contract users to pay for these costs.

In this section, we’ll discuss how to write apt functions with ERC20 logic.

2. Choose the number of ICO tokens

If you want to know how to make a token on the Ethereum blockchain platform, you must first determine the number of your ICO tokens. There are several methods you can use to maximize your ICO tokens.

In this article, we have tried to use the simplest way to do this. With this method, we determined the total amount of tokens at the time of creating the smart contract and then assigned all of them to the account holder in which we created the contract.

1. uint256 totalSupply_;
2. constructor(uint256 total) public {
3. totalSupply_ = total;
4. balances[msg.sender] = _totalSupply;
5. }

• Constructor: An Ethereum function used to determine the number of tokens using investor account parameters
• Msg: A global variable declared by Ethereum Blockchain itself that contains all the important data for contract execution.
• sender: The part of the Ethereum account that executes the current contract

3. Get the total token supply

1. function totalSupply() public view returns (uint256) {
2. return totalSupply_;
3. }

In this part of the tutorial on making an ERC20 token on the Ethereum platform, we encounter the received token. This part of the smart contract is responsible for returning all marks specific to this contract regardless of its owner.

To do this, you must obtain the owner’s balance

1. function balanceOf(address tokenOwner) public view returns (uint) {
2. return balances[tokenOwner];
3. }

Do this using the balanceOf option, which is responsible for restoring the account balance.

After doing this, you will need to transfer the tokens to another account.

1. function transfer(address receiver,
2. uint numTokens) public returns (bool) {
3. require(numTokens <= balances[msg.sender]);
4. balances[msg.sender] = balances[msg.sender] — numTokens;
5. balances[receiver] = balances[receiver] + numTokens;
6. emit Transfer(msg.sender, receiver, numTokens);
7. return true;
8. }

You can do this using the transfer and msg.sender options. With the transfer option, you can transfer tokens from the owner’s account to the receiver. Note that people use the msg.sender option to transfer digital currencies. Of course, do not forget that only the owner of the tokens can transfer the tokens.

In addition, it is good to be familiar with the require. People commonly use the term to prove a proposition in solidity coding. If you do not have enough balance to transfer and this event fails, it will be refunded without any change to the blockchain.

4. Confirm your Delegates to Withdraw Tokens

People use this option mostly in the marketplaces of tokens and cryptocurrencies.

1. function approve(address delegate,
2. uint numTokens) public returns (bool) {
3. allowed[msg.sender][delegate] = numTokens;
4. emit Approval(msg.sender, delegate, numTokens);
5. return true;
6. }

In this step, you will have to face the approve option. This option allows msg.sender to verify a delegate’s account for withdrawing and transferring tokens to other accounts.

People generally use this function in scenarios where token owners offer their tokens for sale on a marketplace since it allows the marketplace to finalize the transaction without requiring prior approval from the owner.

5.  How to Get the Number of Approved Tokens

People mostly use this option in tokens and cryptocurrency marketplaces.

1. function allowance(address owner,
2. address delegate) public view returns (uint) {
3. return allowed[owner][delegate];
4. }

This function returns the number of commonly approved tokens by an owner to a specific delegate.

transferFrom – In this function, the delegate who approved the withdrawal can transfer funds from the owner’s account to a third-party account.

1. function transferFrom(address owner, address buyer,
2. uint numTokens) public returns (bool) {
3. require(numTokens <= balances[owner]);
4. require(numTokens <= allowed[owner][msg.sender]);
5. balances[owner] = balances[owner] — numTokens;
6. allowed[owner][msg.sender] =
7. allowed[from][msg.sender] — numTokens;
8. balances[buyer] = balances[buyer] + numTokens;
9. Transfer(owner, buyer, numTokens);
10. return true;
11. }

By making a token on the Ethereum blockchain platform, we see that we need to fill in two confirmations at the beginning. This confirms whether the transactions are legal or not. If the account holder does not have enough balance to transfer the tokens, they will also need these confirmations.

6. Add the SafeMath Solidity Library

SafeMath is a solidity library that is designed to stop one-way hackers from breaking contracts using integer overflow attacks.

By passing parameters that will take relevant integers past their maximum value, the hacker is forcing the contract to use incorrect numeric values.

With SafeMath, you can protect your smart contract from attacks by any hacker. Before doing so, you must perform the necessary tests. This can greatly reduce the risk of hackers. In addition, in the ERC-20 digital currency build tutorial, we see that the SafeMath library is very small in size. For this reason, there is no penalty or cost for storage. You can add this library to your contract with the following code:

library SafeMath { // Only relevant functions
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a); return a — b; } function add(uint256 a, uint256 b) internal pure returns (uint256)   { uint256 c = a + b; assert(c >= a);
return c;
}
}

1. balances[msg.sender] = balances[msg.sender].sub(numTokens);
2. balances[receiver] = balances[receiver].add(numTokens);
3. balances[buyer] = balances[buyer].add(numTokens);
4. balances[owner] = balances[owner].sub(numTokens);

Deployment of Ethereum Contract

Ethereum developers and investors often use different tools such as Truffle or Remix. To use them, you must install the Meta Mask plugin on your browser. In the meantime, you should have a Rinkeby account, which is an experimental Ethereum network.

Once you have executed these contracts, you can move to all parts of the network. For this reason, if you make any changes to your contract, you also transfer them to participating departments. After installing all the necessary items, you should go to the Remix program and put your code in the SafeMath library.

Then, in the tutorial for creating digital currency on the ERC-20 platform, we see that after you have added your code in the online Remix editor, go to the second option and click on the Deploy option. You have successfully executed an ERC-20 token when you selected the option to verify transactions. At this point, you will be ready to buy, pay and transfer across the blockchain.

Conclusion

Learning how to create an ERC20 token on the Ethereum platform is one of the most important things you should be aware of. In this article, we have explained how to make tokens on the Ethereum blockchain platform for you. Using the above tips, you can create ERC20 tokens with the best features for yourself. Then you can buy and sell them and put them on the marketplace.

The post What is an ERC-20 token and how to create one ? appeared first on Bizznerd.