TeQoin L2 Blockchain Documentation - Developer Guides & API Reference

🎯 Benefits of Verification
🔧 Verification Methods
✅ Verify Verification Success
🔧 Troubleshooting
📊 Verification Best Practices
📝 Verification Checklist
🎯 After Verification
💡 Pro Tips
🎯 Next Steps

Verify your smart contract source code on the TeQoin block explorer to make it publicly visible and enable users to interact with your contract directly.

Why Verify Your Contract?

✅ Users can read your contract source code
✅ Builds trust and transparency
✅ Enables direct interaction on the explorer
✅ Required for many integrations
✅ Shows you’re a legitimate project

🎯 Benefits of Verification

Transparency

Users can read your contract code and verify what it does

Trust

Verified contracts are trusted by the community

Direct Interaction

Users can call functions directly on the block explorer

Integration Support

Many services require verified contracts

🔧 Verification Methods

Hardhat (Recommended)
Foundry
Block Explorer (Manual)
Flattened Source

Verify with Hardhat

The easiest and most reliable method for Hardhat users.

Prerequisites

    # Install verification plugin
    npm install --save-dev @nomicfoundation/hardhat-verify

Step 1: Configure hardhat.config.js

hardhat.config.js

    require("@nomicfoundation/hardhat-toolbox");
    require("@nomicfoundation/hardhat-verify");
    require("dotenv").config();
    
    module.exports = {
      solidity: "0.8.20",
      networks: {
        teqoin: {
          url: "https://rpc.teqoin.io",
          chainId: 420377,
          accounts: [process.env.PRIVATE_KEY]
        }
      },
      etherscan: {
        apiKey: {
          teqoin: process.env.ETHERSCAN_API_KEY
        },
        customChains: [
          {
            network: "teqoin",
            chainId: 420377,
            urls: {
              apiURL: "https://explorer.teqoin.io/api",
              browserURL: "https://explorer.teqoin.io"
            }
          }
        ]
      }
    };

Step 2: Get API Key

Visit Block Explorer

Go to https://explorer.teqoin.io

Click “Sign In” (top-right)
Create account or sign in

Generate API Key

Go to “My Profile” → “API Keys”
Click “Add” to create new API key
Copy the API key

Add to .env

.env

        ETHERSCAN_API_KEY=your_api_key_here

Step 3: Verify Contract

    # Verify contract with no constructor arguments
    npx hardhat verify --network teqoin CONTRACT_ADDRESS
    
    # Example:
    npx hardhat verify --network teqoin 0x5E3A9432a2D6eb0c5D362A0A2F58Bc02Db45850D
    
    # Output:
    # Successfully submitted source code for contract
    # contracts/MyToken.sol:MyToken at 0x5E3A9432...
    # for verification on the block explorer. Waiting for verification result...
    # 
    # Successfully verified contract MyToken on Etherscan.
    # https://explorer.teqoin.io/address/0x5E3A9432...#code

Step 4: Verify Multi-File Contracts

If your contract imports multiple files:

    # Hardhat automatically handles multi-file verification
    npx hardhat verify --network teqoin CONTRACT_ADDRESS
    
    # It will upload all imported files automatically

✅ Contract Verified!

Verify with Foundry

Fast verification using Foundry’s built-in tools.

Prerequisites

Foundry installed (forge, cast)

Step 1: Configure foundry.toml

foundry.toml

    [profile.default]
    src = "src"
    out = "out"
    libs = ["lib"]
    
    [rpc_endpoints]
    teqoin = "https://rpc.teqoin.io"
    
    [etherscan]
    teqoin = { 
      key = "${ETHERSCAN_API_KEY}",
      url = "https://explorer.teqoin.io/api"
    }

Step 2: Set API Key

    # Export API key
    export ETHERSCAN_API_KEY=your_api_key_here
    
    # Or add to .env and load it
    echo "ETHERSCAN_API_KEY=your_key" >> .env
    source .env

Step 3: Verify Contract

    # Verify contract
    forge verify-contract \
      CONTRACT_ADDRESS \
      src/MyToken.sol:MyToken \
      --chain 420377 \
      --etherscan-api-key $ETHERSCAN_API_KEY
    
    # Example:
    forge verify-contract \
      0x5E3A9432a2D6eb0c5D362A0A2F58Bc02Db45850D \
      src/MyToken.sol:MyToken \
      --chain 420377

✅ Contract Verified!

Verify via Block Explorer UI

Manual verification through the web interface.

Step 1: Visit Your Contract

Go to https://explorer.teqoin.io/address/YOUR_CONTRACT_ADDRESS

Step 2: Start Verification

Click 'Verify and Publish'

On the contract page, click “Contract” tab, then “Verify and Publish”

Select Verification Method

Choose one:

Solidity (Single file) - For simple contracts
Solidity (Multi-part files) - For contracts with imports
Solidity (Standard JSON) - For Hardhat/Foundry projects

Step 3: Enter Contract Details

Single File Method

For simple contracts without imports:

Contract Address: (pre-filled)
Compiler Version: Select exact version (e.g., v0.8.20+commit.a1b79de6)
Open Source License: Select license (MIT, GPL-3.0, etc.)
Optimization: Select “Yes” if you used optimizer
Optimization Runs: Enter runs (usually 200)
Contract Code: Paste your entire .sol file
Constructor Arguments: Enter if your contract had constructor args

Click “Verify and Publish”

Multi-Part Files Method

For contracts with imports:

Select “Solidity (Multi-part files)”
Compiler Version: Select exact version
Optimization: Yes/No
Upload all .sol files:
- Main contract file
- All imported files (OpenZeppelin, etc.)
Constructor Arguments: If applicable

Click “Verify and Publish”

Standard JSON Method (Recommended)

For Hardhat/Foundry projects:This is the most reliable method for complex projects.Generate Standard JSON Input:

      # For Hardhat:
      npx hardhat flatten contracts/MyToken.sol > flattened.sol
      
      # Then use the flattened file in single-file method
      # OR generate standard JSON:
      npx hardhat compile --force
      # JSON is in artifacts/build-info/

For Foundry:

      # Generate standard JSON
      forge verify-contract CONTRACT_ADDRESS \
        src/MyToken.sol:MyToken \
        --show-standard-json-input > standard-input.json
      
      # Upload this JSON to the explorer

Upload the JSON file and click “Verify and Publish”

Step 4: Get Constructor Arguments

If your contract has constructor arguments, you need to encode them:

    # Encode constructor arguments
    cast abi-encode "constructor(string,string)" "MyToken" "MTK"
    
    # Output (paste this in "Constructor Arguments" field):
    # 0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000774657174696f6e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034d544b0000000000000000000000000000000000000000000000000000000000

✅ Contract Verified!

Verify with Flattened Source

Combine all contract files into one for easier verification.

Using Hardhat

    # Flatten your contract
    npx hardhat flatten contracts/MyToken.sol > MyToken_flattened.sol
    
    # This creates a single file with all imports

Using Foundry

    # Flatten with Foundry
    forge flatten src/MyToken.sol > MyToken_flattened.sol

Cleanup Flattened File

Open MyToken_flattened.sol
Remove duplicate SPDX licenses (keep only one at the top)
Remove duplicate pragma statements (keep only one)

Verify on Explorer

Go to block explorer
Select “Solidity (Single file)” method
Paste the flattened source code
Click “Verify and Publish”

✅ Contract Verified!

✅ Verify Verification Success

After submitting, check if your contract was verified:

Visit Contract Page

Go to https://explorer.teqoin.io/address/YOUR_CONTRACT_ADDRESS

Check for Green Checkmark

You should see:

✅ Green checkmark next to contract address
“Contract” tab shows source code
“Read Contract” and “Write Contract” tabs appear

Test Read Functions

Click “Read Contract” tabTry calling a view function to verify it works

🔧 Troubleshooting

'Compiler version mismatch' error

The compiler version must match exactly.Solution:

    # Check what version you used to compile
    # In Hardhat:
    cat hardhat.config.js | grep solidity
    
    # In Foundry:
    cat foundry.toml | grep solc_version
    
    # Make sure this EXACT version is selected on the explorer
    # Including the commit hash!

'Bytecode does not match' error

The compiled bytecode doesn’t match the deployed bytecode.Possible reasons:

Wrong compiler version
Optimization settings don’t match
Constructor arguments incorrect
Wrong source code

Solution:

    // Check your hardhat.config.js settings
    solidity: {
      version: "0.8.20",  // Must match exactly
      settings: {
        optimizer: {
          enabled: true,   // Must match deployment
          runs: 200        // Must match deployment
        }
      }
    }

'Invalid constructor arguments' error

Constructor arguments are not encoded correctly.Solution:

    # Use cast to encode (Foundry)
    cast abi-encode "constructor(string,string)" "MyToken" "MTK"
    
    # Or use ethers.js
    const encoded = abiCoder.encode(["string", "string"], ["MyToken", "MTK"]);
    
    # Make sure to remove the "0x" prefix when pasting!

'Too many requests' error

You’ve exceeded the API rate limit.Solution:

Wait a few minutes before trying again
If using Hardhat, it might be retrying automatically
Contact support for higher rate limits

Verification stuck on 'Pending'

The verification is queued but taking a long time.Solution:

Wait 5-10 minutes
Check the explorer’s status page
Try manual verification via UI
Contact support if stuck for > 1 hour

'Already verified' but not showing

Contract was verified but source code not visible.Solution:

Clear browser cache
Wait a few minutes for indexer to update
Try accessing in incognito mode
Contact support if persists

📊 Verification Best Practices

Verify Immediately

Verify your contract right after deployment while settings are fresh

Keep Records

Save compiler settings, constructor args, and verification commands

Test on Testnet

Practice verification on testnet before mainnet

Use Automation

Use Hardhat/Foundry auto-verification to avoid manual errors

📝 Verification Checklist

🎯 After Verification

Once your contract is verified, users can:

Read Source Code

Anyone can view and audit your contract code

Interact Directly

Users can call functions via the block explorer

Verify Security

Security researchers can audit your code

Trust Your Project

Verified contracts build user confidence

💡 Pro Tips

Automate VerificationAdd verification to your deployment script:

// Hardhat deployment script
const token = await MyToken.deploy();
await token.waitForDeployment();

// Automatically verify
await hre.run("verify:verify", {
  address: await token.getAddress(),
  constructorArguments: []
});

Keep a Verification Log

# Create a verification log
echo "MyToken: 0x5E3A... - Verified on $(date)" >> verification_log.txt

Verify All ContractsDon’t forget to verify:

Main contract
Proxy contracts (if using proxies)
Implementation contracts
Library contracts

🎯 Next Steps

Integrate with Frontend

Connect your verified contract to a dApp

Deploy Another Contract

Deploy and verify more contracts

Write Documentation

Document your contract functions for users

Get Security Audit

Consider professional audit for production contracts

Contract verified? Now integrate it with your frontend →

Deploy Smart Contracts dApp Integration Guide

Introduction

Quick Start

Developer Documentation

Bridge

Architecture

Tutorials

Resources

​🎯 Benefits of Verification

Transparency

Trust

Direct Interaction

Integration Support

​🔧 Verification Methods

​Verify with Hardhat

​Prerequisites

​Step 1: Configure hardhat.config.js

​Step 2: Get API Key

​Step 3: Verify Contract

​Step 4: Verify Multi-File Contracts

​Verify with Foundry

​Prerequisites

​Step 1: Configure foundry.toml

​Step 2: Set API Key

​Step 3: Verify Contract

​Verify via Block Explorer UI

​Step 1: Visit Your Contract

​Step 2: Start Verification

​Step 3: Enter Contract Details

​Step 4: Get Constructor Arguments

​Verify with Flattened Source

​Using Hardhat

​Using Foundry

​Cleanup Flattened File

​Verify on Explorer

​✅ Verify Verification Success

​🔧 Troubleshooting

​📊 Verification Best Practices

Verify Immediately

Keep Records

Test on Testnet

Use Automation

​📝 Verification Checklist

​🎯 After Verification

Read Source Code

Interact Directly

Verify Security

Trust Your Project

​💡 Pro Tips

​🎯 Next Steps

Integrate with Frontend

Deploy Another Contract

Write Documentation

Get Security Audit

🎯 Benefits of Verification

🔧 Verification Methods

Verify with Hardhat

Prerequisites

Step 1: Configure hardhat.config.js

Step 2: Get API Key

Step 3: Verify Contract

Step 4: Verify Multi-File Contracts

Verify with Foundry

Prerequisites

Step 1: Configure foundry.toml

Step 2: Set API Key

Step 3: Verify Contract

Verify via Block Explorer UI

Step 1: Visit Your Contract

Step 2: Start Verification

Step 3: Enter Contract Details

Step 4: Get Constructor Arguments

Verify with Flattened Source

Using Hardhat

Using Foundry

Cleanup Flattened File

Verify on Explorer

✅ Verify Verification Success

🔧 Troubleshooting

📊 Verification Best Practices

📝 Verification Checklist

🎯 After Verification

💡 Pro Tips

🎯 Next Steps