How to create a BEP-20 token on Binance Smart Chain?

Every year, the Blockchain industry produces innovative and contemporary developments that challenge the prevailing system and bring upgrades, especially in the decentralized finance space. Binance Smart Chain is a recent development that benefits its users with a rich and growing digital asset ecosystem like never seen before in the decentralized exchange spectrum.

Using Binance Smart Chain, anyone can create and launch their digital token. Creating a BEP-20 token on Binance Smart Chain is quite a simple task. In this article, detailed information on how to create a BEP-20 token is given. Let’s jump in and walk through how that works.

• What is Binance Smart Chain?
• What is the BEP-20 token standard?
• How to create the BEP-20 token?
• How to deploy BEP-20 token?

What is Binance Smart Chain?

It is a dual chain architecture that empowers its users to create their dApps and digital assets on the blockchain and provides the advantage of fast trading.

The main highlights of BSC are:

• EVM Compatible
• Cross-chain transfer
• Proof of Stake authority
• Block time ~3 seconds

BSC runs parallel to Binance Chain and enables Smart Contracts for tokens on the Binance blockchain. An all-new staking mechanism was also introduced for BNB, one of the world’s top cryptocurrencies. BSC offers its users:

• cheap transaction fees
• cross chain defi mechanism that increases defi interoperability
• high-performance network holding the capability to produce a block every 3 seconds
• a growing ecosystem with millions of users
• a supportive Binance ecosystem that funds and bootstraps various defi projects

What is the BEP-20 token standard?

What is the BEP-20 token standard?

BSC tokens are compliant with the BEP-20 standard, which is similar to the ERC-20 Ethereum standard. Since BEP-20 and ERC-20 are almost identical, it’s compatible with both. Binance Smart Chain (BSC) is a fork of the Ethereum mainnet.

Token standards ensure basic functionalities for tokens such as returning a balance, transferring, viewing token ownership, etc. It is important to note that BSC tokens allow swapping for the regular Binance Chain that conforms to the BEP-2 standard. Transactions happening with these tokens on-chain requires a fee payment in BNB. It is like compensation for validators to secure the network.

Let’s explore how to create these tokens.

How to create the BEP-20 token?

The first step is to connect Metamask to Binance Smart Chain. Fill in all the details for your token, including ChainID, Network Name, New RPC URL, etc. Now, open remix.ethereum.org to write a BEP-20 token. Also, simultaneously go to OpenZeppelin-contracts in GitHub. Go to ERC20 in the token folder. Now, create a new file and name it bep-20 sol.

Now, begin writing the Smart Contract:

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.4;
/**
* @title SampleBEP20Token
@dev Elementary BEP20 Token example, where all tokens are pre-assigned to the creator.
Note they can later distribute these tokens as they wish using `transfer` and other
`BEP20` functions.
* USE IT ONLY FOR LEARNING PURPOSES. SHOULD BE MODIFIED FOR PRODUCTION
*/
contract SampleBEP20Token {
string public name = SampleBEP20 Token;
string public symbol = SBT;
uint256 public totalSupply = 1000000000000000000000000; // 1 million tokens
uint8 public decimals = 18;
/**
* @dev Emitted when the 'value' tokens are shifted from one account to another.
* Note that `value` may also be zero.
*/
event Transfer(address indexed _from, address indexed _to, uint256 _value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _value
);
mapping(address =; uint256) public balanceOf;
mapping(address =; mapping(address =; uint256)) public allowance;
/**
* @dev Constructor that gives msg.sender all of the existing tokens.
*/
constructor() {
balanceOf[msg.sender] = totalSupply;
}
/**
* @dev transfers `amount` tokens from the Caller's account to the recipient's.
* It returns a bool value that indicates the success of the operation.
* Emits a {Transfer} event.
*/
function transfer(address _to, uint256 _value)
public
returns (bool success)
{
require(balanceOf[msg.sender] ;= _value);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
/**
@dev Sets `amount` as the allocation of `spender` over the Caller's tokens.

function approve(address _spender, uint256 _value)
public
returns (bool success)
{
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/**
* @dev Moves the `amount` tokens from `sender` to `recipient` using the allowance mechanism. `amount` is then deducted from the Caller's allowance.

function transferFrom(
address _from,
address _to,
uint256 _value
public returns (bool success) {
require(_value ;= balanceOf[_from]);
require(_value ;= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
}