How to Mint an ERC-20 Token on Base with the Interchain Token Service in 5 Steps - Moralis Web3

This step-by-step guide will teach you how to mint a multichain ERC-20 token on the Base network using Axelar’s Interchain Token Service (ITS) and use the Moralis Token API to easily retrieve token balances.

Step 1: Prerequisites

You will need:

Step 2: Set up a new project and required ABIs

In this step, you will need to create a new project and set up the required ABIs to interact with ITS and mint your ERC-20 token on the Base network.

Open your terminal and navigate to any directory of your choice. Run the following commands to create and initiate a project:

mkdir mint-token && cd mint-token
 npm init -y

Install Hardhat and Moralis

Install Hardhat and Moralis with the following commands:

npm install --save-dev [email protected] [email protected] \\
 [email protected] @nomicfoundation/[email protected] moralis

Set up project ABIs

Next, set up the ABI for the Interchain Token Factory as it will be needed during deployment. Create a new file called interchainTokenFactoryABI.json and add the Interchain Token Factory ABI.

Create an `.env` file

To make sure you’re not accidentally publishing your private key, create an .env file to store it in:

touch .env

Add your private key to `.env`

Export your private key and add it to the .env file you just created:

PRIVATE_KEY= // Add your account private key here

If you will push this project on GitHub, create a .gitignore file and include .env.

Step 3: Set up the remote procedure call (RPC)

Next, you’ll need to set up the RPC. Navigate to the directory where you installed Hardhat and run the following command:

npx hardhat init

Select Create an empty hardhat.config.js with your keyboard and hit enter:

888    888                      888 888               888
 888    888                      888 888               888
 888    888                      888 888               888
 8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
 888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
 888    888 .d888888 888    888  888 888  888 .d888888 888
 888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
 888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888
 
  Welcome to Hardhat v2.18.1 ‍
 
 ? What do you want to do? …
   Create a JavaScript project
   Create a TypeScript project
   Create a TypeScript project (with Viem)
 ❯ Create an empty hardhat.config.js
   Quit

Next, update hardhat.config.js with the following code snippet:

/** @type import('hardhat/config').HardhatUserConfig */
 require("@nomicfoundation/hardhat-toolbox");
 require("dotenv").config({ path: ".env" });
 
 const PRIVATE_KEY = process.env.PRIVATE_KEY;
 
 /** @type import('hardhat/config').HardhatUserConfig */
 module.exports = {
   solidity: "0.8.19",
   networks: {
     base: {
       url: "<https://base-sepolia-rpc.publicnode.com>",
       chainId: 84532,
       accounts: [PRIVATE_KEY],
     },
   },
 };

Hardhat runs by locating the nearest hardhat.config.js from the current directory, typically found at the root of your project. Even an empty hardhat.config.js allows Hardhat to function, as your entire setup is housed in this file.

Step 4: Mint an ERC-20 token with ITS

Now that you’ve set up a Base Sepolia testnet RPC, you can mint a multichain ERC-20 token. For this tutorial, you will create a token using the following information:

Name: My New Token

Symbol: MNT

Decimals: 18

Create a new file named script.js. Import the necessary dependencies:

Ethers.js

Moralis

The contract ABI

The InterchainTokenFactory contract address

Your token information

const hre = require("hardhat");
 const crypto = require("crypto");
 const Moralis = require("moralis").default;
 const ethers = hre.ethers;
 
 const interchainTokenFactoryContractABI = require("./interchainTokenFactoryABI");
 
 const interchainTokenFactoryContractAddress =
   "0x83a93500d23Fbc3e82B410aD07A6a9F7A0670D66";
   
 // Create a new token
 const name = "My New Tokenn";
 const symbol = "MNT";
 const decimals = 18;
 
 // Intial token to be minted
 const initialSupply = ethers.utils.parseEther("1000");

Create a `mintToken()` function

Create a mintToken() function for minting a new token on the Base Sepolia testnet:

//...
 
 // Mint a new ERC-20 multichain token to the Base Sepolia testnet
 try {
     // Generate random salt
     const salt = "0x" + crypto.randomBytes(32).toString("hex");
 
     // Get a signer to sign the transaction
     const [signer] = await ethers.getSigners();
 
     // Create contract instances
     const interchainTokenFactoryContract = await new ethers.Contract(
       interchainTokenFactoryContractAddress,
       interchainTokenFactoryContractABI,
       signer
     );
 
     // Deploy the token
     const deployTxData =
       await interchainTokenFactoryContract.deployInterchainToken(
         salt,
         name,
         symbol,
         decimals,
         initialSupply,
         signer.address
       );
 
     console.log(
       `
     Transaction Hash: ${deployTxData.hash},
     salt: ${salt},
     `
     );
   } catch (e) {
     console.error(e);
 }

Add a `main()` function

Add a main() function for executing script.js. It will handle any errors that may arise:

//...
 
 async function main() {
   const functionName = process.env.FUNCTION_NAME;
   switch (functionName) {
     case "mintToken":
       await mintToken();
       break;
     default:
       console.error(`Unknown function: ${functionName}`);
       process.exitCode = 1;
       return;
   }
 }
 
 main().catch((error) => {
   console.error(error);
   process.exitCode = 1;
 });

Run `script.js` to deploy your token to the Base Sepolia testnet

Run the script in your terminal to create and mint the token, specifying the Base Sepolia testnet:

FUNCTION_NAME=mintToken npx hardhat run script.js --network base

You should see something similar to the following on your console:

Transaction Hash: 0x7695f2dd6e29240fc792d37fd6b86f402f2b5338e088e0ad4a448685e0ad565b,
 salt: 0xef36cf55326c3fb9fb47c6d3828b8a4ea12fdfab31aae4bc3634bf7bbe04eb49,

Transaction: https://sepolia.basescan.org/tx/0x7695f2dd6e29240fc792d37fd6b86f402f2b5338e088e0ad4a448685e0ad565b Token: https://sepolia.basescan.org/token/0x274e53a526fa2543ce19f9c0334286b4724aa5e0

Step 5: Check the minted token balance with the Moralis API

Now that you have successfully minted your new token, it’s time to retrieve the balance.

Add the Moralis API key to `.env`

MORALIS_API_KEY= // Add you Moralis API key here

Get your token balance

Add the following in the script.js file:

//...
 
 const MORALIS_API_KEY = process.env.MORALIS_API_KEY;
 
 // Get user balance with the Moralis API
 async function getBalance() {
   try {
     console.log("Getting balance...");
     await Moralis.start({
       apiKey: MORALIS_API_KEY,
     });
 
     const response = await Moralis.EvmApi.token.getWalletTokenBalances({
       chain: "84532", // Base Sepolia
       address: "0x510e5EA32386B7C48C4DEEAC80e86859b5e2416C", // User address
     });
 
     console.log(response.raw);
   } catch (e) {
     console.error(e);
   }
 }

Update `main()` to get the token balance

Update main() to execute getBalance() :

//...
 
 async function main() {
   const functionName = process.env.FUNCTION_NAME;
   switch (functionName) {
     //...
     case "getBalance":
       await getBalance();
       break;
     default:
     //...
   }
 }

Run the script in your terminal to retrieve your token:

FUNCTION_NAME=getBalance node script.js

You should see something similar to the following on your console:

Getting balance...
 [
   {
     token_address: '0x274e53a526fa2543ce19f9c0334286b4724aa5e0',
     symbol: 'MNT',
     name: 'My New Tokenn',
     logo: null,
     thumbnail: null,
     decimals: 18,
     balance: '1000000000000000000000',
     possible_spam: false,
     verified_contract: false,
     total_supply: '1000000000000000000000',
     total_supply_formatted: '1000',
     percentage_relative_to_total_supply: 100
   }
 ]

Summary

The tutorial provides a step-by-step guide on minting a multichain ERC-20 token on the Base Sepolia network using Axelar’s Interchain Token Service (ITS). The process involves setting up prerequisites, creating a new project and ABIs, setting up a remote procedure call (RPC), minting the ERC-20 token with ITS, and checking the minted token balance with the Moralis API.