Polygon: Bridging ERC-20 from Ethereum to Polygon

• Deploy an ERC-20 smart contract on the Ethereum Goerli testnet.
• Deploy a compatible smart contract on the Polygon Mumbai testnet.
• Map the Ethereum smart contract to the Polygon smart contract.

​

Prerequisites

• Chainstack account to deploy an Ethereum node and a Polygon node.
• Truffle Suite to create and deploy contracts.
• OpenZeppelin Contracts to use the audited ERC-20 libraries to create your ERC-20 contract.

​

Overview

1. With Chainstack, create a public chain project.
2. With Chainstack, join the Ethereum Goerli testnet.
3. In the same project, join the Polygon Mumbai testnet.
4. With Chainstack, access your Ethereum node and Polygon node endpoints.
5. With OpenZeppelin, create an ERC-20 contract.
6. With Truffle, compile and deploy the contract through your Ethereum node.
7. With Truffle, compile and deploy a Polygon contract through your Polygon node.
8. Submit a mapping request to bridge the deployed Ethereum contract to the deployed Polygon contract.

​

Step-by-step

​

Create a public chain project

​

Join the Ethereum Goerli testnet and the Polygon Mumbai testnet

​

Get your Ethereum node and Polygon node access and credentials

​

Install OpenZeppelin Contracts

​

Install Truffle Suite

​

Create the root Ethereum ERC-20 contract

1. On your machine, in the contract directory, initialize Truffle:
   Copy

   truffle init
   

   This will generate the Truffle boilerplate structure:
   Copy

   .
   ├── contracts
   │   └── .gitkeep
   ├── migrations
   │   └── .gitkeep
   ├── test
   │   └── .gitkeep
   └── truffle-config.js
   

2. Go to the contracts directory. In the directory, create your ERC-20 contract: myL2token.sol.
   Copy

   //SPDX-License-Identifier: MIT
   pragma solidity ^0.8.0;
   
   import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
   
   contract myL2token is ERC20 {
     constructor(uint256 initialSupply) ERC20("myL2token", "ML2T") {
       _mint(msg.sender, initialSupply);
     }
   }
   

   This is a standard OpenZeppelin ERC-20 preset contract.
3. Create 2_deploy_contracts.js in the migrations directory.
   Copy

   var myL2token = artifacts.require("./myL2token.sol");
   
   module.exports = function(deployer) {
     deployer.deploy(myL2token, 100);
   };
   

   This will create the instructions for Truffle to deploy the contract with the supply of 100 ML2T tokens.

​

Compile and deploy the root Ethereum ERC-20 contract

1. Install HDWalletProvider. HDWalletProvider is Truffle’s separate npm package used to sign transactions. Run:
   Copy

   npm install @truffle/hdwallet-provider
   

2. Edit truffle-config.js to add:
   • HDWalletProvider
   • Your Ethereum node access and credentials
   • Your Ethereum account that you will use to deploy the contract
   Copy

   const HDWalletProvider = require("@truffle/hdwallet-provider");
   const private_key = 'PRIVATE_KEY';
   
   module.exports = {
    networks: {
       goerli: {
           provider: () => new HDWalletProvider(private_key, "YOUR_CHAINSTACK_ENDPOINT"),
           network_id: 5
       }
      },
   
    compilers: {
       solc: {
       version: "0.8.1",
       }
     }
   };
   

   where
   • goerli — any network name that you will pass to the truffle migrate --network command.
   • HDWalletProvider — Truffle’s custom provider to sign transactions.
   • PRIVATE_KEY — the private key of your Ethereum account that will deploy the contract.
   • YOUR_CHAINSTACK_ENDPOINT — your Chainstack node endpoint. See also View node access and credentials and Ethereum tooling.
   • network_id — the network ID of the Ethereum Goerli testnet: 5.
   • solc — the Solidity compiler version that Truffle must use.
3. Run:
   Copy

   truffle migrate --network goerli
   

   This will engage 2_deploy_contracts.js and deploy the contract to the Ethereum Goerli testnet as specified in truffle-config.js.

​

Verify your root Ethereum ERC-20 contract on Etherscan

1. Flatten your contract code Since your ERC-20 contract uses imported OpenZeppelin libraries, you must put all the imports into one .sol file to make Etherscan be able to verify it. Install Truffle Flattener. In the contracts directory, run:
   Copy

   npx truffle-flattener myL2token.sol > flatmyL2token.sol
   

2. Clean up the licensing information. The flattened contract will have the same licensing note imported from each of the files. Multiple licensing notes in one file break the Etherscan verification, so you have to leave one licensing note for the entirety of the flattened contract. The easiest way to clean up is to search for the SPDX mentions in the file and remove all of them except for the very first one.
3. Verify the deployed contract on Etherscan. At this point, you have your flattened and cleaned-up contract ready for the Etherscan verification.
4. Go to Etherscan.
5. Find your deployed contract. The address of your contract should have been printed by Truffle at the end of the deployment in the contract address field.
6. On the contract page on Etherscan, click Contract > Verify and Publish.
7. In Compiler Type, select Solidity (Single file).
8. In Compiler Version, select v0.8.1. This is the version this tutorial used to compile the contract.
9. In Open Source License Type, select MIT License (MIT).
10. Click Continue.
11. Keep the Optimization option set to No as Truffle does not use optimization by default.
12. Paste the entirety of your flattened .sol contract in the Enter the Solidity Contract Code below field.
13. Click Verify and Publish. Etherscan will take a few seconds to compile your contract, verify, and publish it.

​

Create the child Polygon ERC-20 contract

1. Go to the contracts directory. In the directory, put the default child ERC-20 contract provided by Polygon.
2. Create 2_deploy_contracts.js in the migrations directory.
   Copy

   var ChildERC20 = artifacts.require("./ChildERC20.sol");
   
   module.exports = function(deployer) {
     deployer.deploy(ChildERC20, 'myL2tokenChild', 'ML2T', 18, '0x2e5e27d50EFa501D90Ad3638ff8441a0C0C0d75e');
   };
   

   where
   • myL2tokenChild — the name of your ERC-20 token
   • ML2T — the symbol of your ERC-20 token
   • 18 — the default decimals number as used by the OpenZeppelin ERC-20 preset contract
   • 0x2e5e27d50EFa501D90Ad3638ff8441a0C0C0d75e — the ChildChainmanager address on the Polygon Mumbai testnet. For the ChildChainManager contract addresses, look online for the addresses provided by Polygon:
     • Mainnet addresses

​

Compile and deploy the child Polygon ERC-20 contract

1. Edit truffle-config.js to change to:
   • Your Polygon node access and credentials
   • Your Polygon account that you will use to deploy the contract.
   • The Solidity compiler version used by the default child ERC-20 contract template provided by Polygon.
     JavaScript

     Copy

     const HDWalletProvider = require("@truffle/hdwallet-provider");
     const private_key = 'PRIVATE_KEY';
     
     module.exports = {
      networks: {
         mumbai: {
             provider: () => new HDWalletProvider(private_key, "YOUR_CHAINSTACK_ENDPOINT"),
             network_id: 80001
         }
        },
     
      compilers: {
         solc: {
         version: "0.6.6",
         }
       }
     };
     

   where
   • mumbai — any network name that you will pass to the truffle migrate --network command.
   • HDWalletProvider — Truffle’s custom provider to sign transactions.
   • PRIVATE_KEY — the private key of your Polygon account that will deploy the contract.
   • YOUR_CHAINSTACK_ENDPOINT — your Chainstack node endpoint. See also View node access and credentials and Polygon tooling.
   • network_id — the network ID of the Polygon network: testnet is 80001, mainnet is 137.
   • solc — the Solidity compiler version that Truffle must use. OpenZeppelin contracts have a higher version Solidity compiler requirement than the default Truffle installation, hence you must provide a specific compiler version.
2. Run:
   Shell

   Copy

   truffle migrate --network Mumbai
   

​

Verify your child Polygon ERC-20 contract on the Polygon explorer

1. Go to the Polygon Mumbai explorer.
2. Find your deployed contract. The address of your contract should have been printed by Truffle at the end of the deployment in the contract address field.
3. On the contract page on the explorer, click Contract > Verify and Publish.
4. In Compiler Type, select Solidity (Single file).
5. In Compiler Version, select v0.6.6. This is the compiler version the default child contract uses as provided by Polygon.
6. In Open Source License Type, select MIT License (MIT).
7. Click Continue.
8. Keep the Optimization option set to No as Truffle does not use optimization by default.
9. Paste the entirety of your ChildERC20.sol contract in the Enter the Solidity Contract Code below field.
10. Click Verify and Publish.

​

Map your Ethereum ERC-20 contract to the Polygon contract

1. Go to the token mapper.
2. Select ERC20 and Goerli Testnet - Mumbai Testnet.
3. Provide the address of your contract on the Ethereum Goerli testnet and on the Polygon Mumbai testnet.
4. Provide an email address to be notified of when the mapping is done.
5. Click Submit.

​

Bridge the mapped tokens

​

Conclusion

​

About the author

Ake

Director of Developer Experience @ Chainstack Talk to me all things Web320 years in technology | 8+ years in Web3 full time years experienceTrusted advisor helping developers navigate the complexities of blockchain infrastructure