How to deploy a token on Polygon in 3 steps (with no-code alternative)

In this guide I will explain how to deploy a Polygon MRC-20 token using smart contracts with Solidity, and then give you a no-code alternative if you are looking for a simpler solution.

Polygon operates as an L2 solution for Ethereum, which means it provides a more scalable and cost-efficient environment while maintaining compatibility with Ethereum infrastructure.

The tokens deployed on Polygon use the ERC-20 standard (or as they call it in the niche, MRC-20), which is widely compatible and allows for easy integration of tokens with various DeFi applications, wallets and exchanges.

Since Polygon supports EVM, any smart contract or dApp you create for Ethereum can be deployed on Polygon with little or no modification.

Smart Contracts and Solidity: How to deploy MRC-20 tokens

In the Polygon ecosystem, deploying an ERC-20 token requires writing a smart contract using Solidity, the leading language for developing contracts on EVM-compatible blockchains such as Ethereum and Polygon. Here's a deeper look at the steps required to create and deploy a token on Polygon.

1. Configure your development environment

To get started, you will need to set up a development environment. There are several tools and frameworks that facilitate the development of smart contracts:

• Remix: A browser-based IDE that natively supports Solidity.
• Truffle or Hardhat: Local development frameworks that allow compiling, testing and deploying contracts, integrating with MetaMask for wallet management.

You will also need to connect to the Polygon network using a wallet such as MetaMask.

2. Writing the Smart Contract ERC-20

An ERC-20 token follows a standardized contract structure that includes several key functions and events. Below is an example of a basic ERC-20 contract written in Solidity:

pragma solidity ^0.8.0;

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

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

In this example, we use OpenZeppelin' s ERC-20 implementation to simplify the development process. The contract includes:

• Builder: Initializes the token name ("MyToken") and symbol ("MTK") and creates the initial supply for the contract creator's address.
• _mint function: Handles the creation of tokens and assigns them to a specific address (in this case, the address of the contract deployer).

Key components of the ERC-20 standard include:

• transfer: Allows token holders to send tokens to another address.
• approve: Configures an assignment for a third party to spend tokens on behalf of the holder.
• transferFrom: Allows transferring tokens from one address to another based on a previously established assignment.

3. Compiling and deploying the contract

Once you have written the contract, you will need to compile it using the Solidity compiler, either within Remix or using command line tools provided by Truffle or Hardhat.

Here is an example of how you could deploy the contract using Truffle:

truffle migrate --network polygon

The deployment process involves interacting with the Polygon network, which will require MATIC (Polygon's native token) to cover gas fees. The cost to deploy a token on Polygon is significantly lower than on Ethereum due to its L2 architecture. While deploying on Ethereum can cost hundreds of dollars, on Polygon deployment fees typically range from a few cents to a few dollars, depending on network congestion.

4. Gas and cost optimization

Smart contract developers often focus on gas optimization, especially in an L2 environment. Although gas fees are much lower on Polygon, inefficient code can generate higher transaction costs than necessary. Some common practices for optimizing gas include:

• Minimize warehousing operationsSolidity storage operations are costly. It uses variables of memory whenever possible, and avoid writing repeatedly to storage.
• Batch operations: Instead of performing multiple individual operations, group transactions together whenever possible to minimize execution steps.
• External libraries: Take advantage of libraries such as OpenZeppelin to use tested code and avoid introducing vulnerabilities or redundant code.

5. Testing and safety

Before deploying your contract on the mainnet, it is essential to test it thoroughly. Use Ganache or the local Hardhat environment to simulate deployment and interactions. Write unit tests to ensure that your token operates according to the ERC-20 standard.

Common vulnerabilities include:

• Reentrancy attacks: Occur when external calls trigger the recursive execution of functions, which may generate undesired results.
• Overflow and underflow: Although newer versions of Solidity (0.8.x and later) automatically handle this, older versions may require libraries such as SafeMath.

Once you are sure of the security of the contract, deploy first on the Polygon (Mumbai) testnet before proceeding to the mainnet.

The no-code alternative: Smithii Tools

If you don't want to get into programming or setting up environments, Smithii offers a no-code tool to deploy tokens on Polygon without the need to write smart contracts.

How to deploy a token on Polygon using Smithii in 3 steps

The first thing you should do is to enter the Polygon's Token Creator Tool Smithii's Polygon Token Creator Tool and once there follow these steps

• Enter the name of your token: there is no restriction at this point, put the one you like the most.
• Choose a symbol: With a maximum of up to 8 characters.
• Define the total supply of tokens: The most common is between 10M and 100B.

Tax

If you select this option you can add a fee per transaction of your token in percentage. If you set 5 it will be 5% of all transactions with your token. This generates a deflationary token.

Also, you can indicate a receiver wallet that is not necessarily the wallet with which you created the token. That is to say, you can address the fees directly to a wallet of fees.

Advanced options

Here we have 3 elements: the AirDrop mode, the anti-bot and the anti-whale:

• Airdrop mode: This option prevents your token from being exchanged until you specify otherwise, at no cost.
• Anti-bot: This tool applies a time limit per transaction to avoid the actions of bots sniper on your token.
• Anti-Whale: This tool limits both the time between trades and the amount that can be made for each transaction, preventing the appearance of whales in the token trading.

The cost of creating a token on Polygon using Smithii Tools is 0.01 ETH plus gas fees, one of the lowest rates on the market.

Contract verification and modification on PolygonScan

If you want to add social media links and images to your token, what you need to do is to verify ownership. If you created the token with Smithii Tools, this was done automatically when deploying.

If you didn't do it with Smithii Tools, you can follow this step-by-step guide on how to add links and logos to your ERC-20 token. This will give a very nice confidence boost to your token for investors, which will translate into more sales. It is totally worth doing.

What to do after creating the token on Polygon: Launch Liquidity Pool?

Once you have created the token, it is time to create the market and launch your liquidity pool in Uniswap. For this you can see our guide on how to create a liquidity pool in Polygon without programming.

After you have your own liquidity pool, you are ready to turn up the volume of your coin using Polygons volumebot

Is it safe to create an ERC-20 token on Smithii?

Smithii Tools has been audited by CoinFabrik under the Mantis protocol. This makes Smithii the most secure Tools Suite on the market.

Conclusion

Here we could see two ways to create an MRC-20 token, the first one through Solidity and the second one through the token creator of Smithii. The no-code alternative allows us to skip the step of verifying the ownership of the contract, making it easier to change the metadata of the token.