How to Deploy a token on Polygon in 3 Steps (With a No-Code Alternative)

In this guide, I’ll walk you through how to deploy an MRC-20 token on Polygon using Solidity smart contracts, then show you a no-code alternative if you want a simpler path.

Polygon works as an L2 solution for Ethereum, which means it gives you a more scalable and cost-efficient environment while staying compatible with Ethereum infrastructure.

Tokens deployed on Polygon use the ERC-20 standard (also called MRC-20 in this niche), which gives them broad compatibility and makes it easy to integrate tokens with DeFi apps, wallets, and exchanges.

Because Polygon is EVM-compatible, any smart contract or dApp you create for Ethereum can be deployed on Polygon with little to no modification.

Smart Contracts and Solidity: How to Deploy token MRC-20

In the Polygon ecosystem, deploying an ERC-20 token means writing a smart contract in Solidity, the main language for building contracts on EVM-compatible blockchains like Ethereum and Polygon. Below is a closer look at the steps required to create and deploy a token on Polygon.

1. Set Up Your Development Environment

To get started, you’ll need to set up a development environment. Several tools and frameworks make smart contract development easier:

• Remix: A browser-based IDE with native Solidity support.
• Truffle or Hardhat: Local development frameworks that let you compile, test, and deploy contracts, with MetaMask integration for wallet management.

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

2. Writing the ERC-20 Smart Contract

An ERC-20 token follows a standardized contract structure with several key functions and events. Here 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 keep development simpler. The contract includes:

• Constructor: Sets the token name (“MyToken”) and symbol (“MTK”), then mints the initial supply to the contract creator’s address.
• _mint function: Handles token creation and assigns the tokens to a specific address (in this case, the contract deployer’s address).

The key components of the ERC-20 standard include:

• transfer: Lets token holders send tokens to another address.
• approve: Sets an allowance so a third party can spend tokens on the holder’s behalf.
• transferFrom: Lets tokens move from one address to another based on an allowance that was already approved.

3. Compiling and deploying the contract

Once the contract is written, you’ll need to compile it with the Solidity compiler, either inside Remix or through command-line tools provided by Truffle or Hardhat.

Here’s an example of how you could deploy the contract with Truffle:

truffle migrate --network polygon

The deployment process involves interacting with the Polygon network, which requires MATIC (Polygon’s native token) to cover gas fees. The cost of deploying a token on Polygon is significantly lower than on Ethereum thanks to its L2 architecture. While deploying on Ethereum can cost hundreds of dollars, deployment fees on Polygon usually 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. While gas fees are much lower on Polygon, inefficient code can still push transaction costs higher than they need to be. Common gas optimization practices include:

• Minimize storage operations: Storage operations in Solidity are expensive. Use memory variables whenever possible, and avoid repeated writes to storage.
• Batch operations: Instead of running multiple individual operations, group transactions whenever possible to reduce execution steps.
• External libraries: Use libraries like OpenZeppelin to rely on battle-tested code and avoid introducing vulnerabilities or redundant logic.

5. Testing and security

Before deploying your contract to mainnet, thorough testing is essential. Use Ganache or the local Hardhat environment to simulate deployment and interactions. Write unit tests to make sure your token follows the ERC-20 standard.

Common vulnerabilities include:

• Reentrancy attacks: These happen when external calls trigger recursive function execution, which can lead to unintended outcomes.
• Overflow and underflow: Newer Solidity versions (0.8.x and later) handle this automatically, but older versions may require libraries like SafeMath.

Once you are confident the contract is secure, deploy it first on the Polygon testnet (Mumbai) before moving to mainnet.

The no-code alternative: Smithii Tools

If you do not want to deal with programming or environment setup, Smithii offers a no-code tool to deploy tokens on Polygon without writing smart contracts.

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

First, go to the Token Creator Tool by Polygon from Smithii, then follow these steps:

• Enter your token name: there are no restrictions here, so choose the one you like best.
• Choose a symbol: Up to 8 characters max.
• Set the total supply of tokens: The usual range is between 10M and 100B.

Tax

If you select this option, you can add a transaction fee for your token as a percentage. If you enter 5, that means 5% of every transaction with your token. This creates a deflationary token.

You can also set a receiver wallet that does not have to be the same wallet you used to create the token. In other words, you can route the fees directly to a dedicated fee wallet.

Advanced Options

Here you have 3 options: AirDrop mode, anti-bot, and anti-whale:

• Airdrop mode: This option prevents your token from being traded until you decide otherwise, and it costs nothing.
• Anti-bot: This tool adds a time limit between transactions to block sniper bots from acting on your token.
• Anti-Whale: This tool limits both the time between trades and the amount allowed per transaction, helping keep whales out of your token trading.

Creating a token on Polygon with Smithii Tools costs 0.01 ETH plus gas fees, one of the lowest fees on the market.

Verify and update the contract on PolygonScan

If you want to add social media links and images to your token, you need to verify ownership. If you created the token with Smithii Tools, this was done automatically during deploy.

If you did not use Smithii Tools, you can follow this step-by-step guide where we explain how to add links and logos to your token ERC-20. This gives investors a much stronger trust signal for your token, which can translate into more sales. It is absolutely worth doing.

What to do after creating your token on Polygon: launch Liquidity Pool?

Once you’ve created your token, the next step is to create the market and launch your liquidity pool on Uniswap. For the full walkthrough, see our guide on how to create a liquidity pool on Polygon without coding.

Once you have your own liquidity pool, you’ll be ready to increase your coin’s volume using the Polygon volume bot.

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

Smithii Tools has been audited by CoinFabrik under the Mantis protocol. That makes Smithii the safest Tools Suite on the market.

Conclusion

Here we covered two ways to create an MRC-20 token: the first with Solidity, and the second with the token creator from Smithii. The no-code option lets us skip the contract ownership verification step, making it easier to update the token metadata.