July 18, 2024

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

Table of Contents

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.

References

Now that you know how to mint a multichain token, check out the following:

Token API
Supercharge your dapp with our leading-edge Token API! Real-time token prices, balances, transfers & much more.
Token API
Related Articles
November 16, 2022

Exploring AWS Lambda and What it is Used For

November 22, 2023

Best NFT Data Analytics for 2024 – Real-Time NFT Transfers, Tracking & Discovery

December 3, 2022

Exploring the Palm Network – What is Palm NFT Studio?

January 21, 2023

How to Create a Twitter Bot for Crypto

December 14, 2022

Ethers.js Tutorial – How to Get Started Using a Simple Ethers.js Example

October 4, 2023

Polygon Node Guide: How to Run a Polygon RPC Node

September 15, 2023

NFT Image API – How to Get Images from NFT Collections

May 7, 2024

Build Dapps on Moonbeam Network with Moonbeam APIs

January 17, 2024

How to Index Blockchain Data & Build a Blockchain Indexer

🔥 LIMITED-TIME OFFER - Get early access to an Enhanced Token Page & boost your token project’s exposure! GET EARLY ACCESS 🔥