LogoLogo
HomeExplorer
  • Overview
    • Introduction
    • Ecosystem VC Alliance
  • Research
    • Gravity Litepaper
    • Grevm 2.0 (Gravity EVM)
    • (Archived) Grevm 1.0
  • ECOSYSTEM PROGRAMS
    • Developer Grant Program
    • Community Program: Galactic G
  • Network
    • Gravity Devnet (L1)
    • Gravity Alpha Mainnet & Sepolia Testnet (L2)
    • Gravity Alpha Mainnet (L2) Node Setup
    • Gravity Testnet Sepolia (L2) Node Setup
  • Tokens on Gravity
    • G Token
    • How to Get G
    • How to Get Test Tokens
    • Token Contracts on Gravity
  • Developer Resources
    • Mainnet Contract Addresses
    • Testnet Contract Addresses
  • Verify a Smart Contract
  • Ecosystem Infrastructures
    • Wallets & Exchanges
    • Node Providers
    • Developer Utilities
    • Explorers
    • Cross-chain Interoperability
    • Onramps
    • Oracles
    • Smart Contract Wallets
    • Indexers
    • Data Analytics Platforms
    • Gravity Name Service
  • Community
    • X / Twitter
    • Discord
    • Telegram
Powered by GitBook
On this page
  • OKLink
  • 1. Explorer Interface
  • 2. Contract Verification APIs
  • 3. Verify Using Foundry
  • 4. Verify Using Hardhat
  • Blockscout

Was this helpful?

Export as PDF

Verify a Smart Contract

Verify your smart contract on Gravity Alpha Mainnet

PreviousTestnet Contract AddressesNextWallets & Exchanges

Last updated 2 days ago

Was this helpful?

There are four major ways to verify contracts on OKLink:

1. Explorer Interface

You can verify a deployed contract directly through the .

2. Contract Verification APIs

OKLink provides a set of .

3. Verify Using Foundry

Prerequisite: Get an OKLink API Key

Apply for an API key:

Run forge verify-contract

To verify a contract, you need to provide:

  • The deployed contract address

  • The contract path and name (e.g., src/MyToken.sol:MyToken)

  • The OKLink verify-url for your target chain

  • Your OKLink API key

Command format:

bashCopyEditforge verify-contract <contract_address> \
  src/MyToken.sol:MyToken \
  --verifier oklink \
  --verifier-url https://www.oklink.com/api/v5/explorer/contract/verify-source-code-plugin/gravity \
  --api-key <Your_OKLink_API_Key> \
  --watch

Check Verification Status

It is recommended to use the --watch flag to continuously poll for verification status.

If you didn’t use --watch, you can manually check the result using:

bashCopyEditforge verify-check <contract_address> --verifier oklink

4. Verify Using Hardhat

Method 1 (Recommended): Using @okxweb3/hardhat-explorer-verify Plugin

This method uses an official Hardhat plugin provided by OKX. It provides a CLI command (npx hardhat okverify) to automate contract verification.

1. Install the Plugin

bashCopyEditnpm install @okxweb3/hardhat-explorer-verify

2. Configure hardhat.config.ts

Here is a sample configuration for Gravity Chain:

tsCopyEditimport { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import "@okxweb3/hardhat-explorer-verify";

const config: HardhatUserConfig = {
  solidity: "0.8.24",
  sourcify: {
    enabled: true,
  },
  networks: {
    gravity: {
      url: "https://rpc.gravity.xyz",
      accounts: ["<Your Private Key>"],
    },
  },
  okxweb3explorer: {
    apiKey: "<Your OKLink API Key>",
    customChains: [
      {
        network: "gravity",
        chainId: 1625,
        urls: {
          apiURL:
            "https://www.oklink.com/api/v5/explorer/contract/verify-source-code-plugin/gravity",
          browserURL: "https://www.oklink.com",
        },
      },
    ],
  },
};

export default config;

3. Verify the Contract

After deployment, verify with:

bashCopyEditnpx hardhat okverify --network gravity <ContractAddress>

4. Verifying Proxy Contracts

For contracts deployed via TransparentUpgradeableProxy, use:

bashCopyEditnpx hardhat okverify --network gravity --contract contracts/MyContract.sol:MyContract --proxy <ProxyAddress>

If you're using the 897 proxy standard, omit --proxy and just run the command as normal

Method 2: Manually Configuring etherscan.customChains for OKLink

You can also verify contracts using Hardhat's native Etherscan integration by overriding the default verification endpoint.

Configuration Example:

jsCopyEditmodule.exports = {
  etherscan: {
    apiKey: "<Your OKLink API Key>",
    customChains: [
      {
        network: "gravity",
        chainId: 1625,
        urls: {
          apiURL:
            "https://www.oklink.com/api/v5/explorer/contract/verify-source-code-plugin/gravity",
          browserURL: "https://www.oklink.com",
        },
      },
    ],
  },
};

This enables Hardhat’s built-in verify task to interact with OKLink:

bashCopyEditnpx hardhat verify --network gravity <ContractAddress> <ConstructorArguments...>

⚠️ You’ll still need to ensure your contract metadata matches what OKLink expects (e.g., compiler version, optimization settings, source flattening if needed).


Blockscout uses the global blockscout verifier (so that similar contracts get automatically verified), it can sometimes be flaky. Please try again a bit later.

For contracts deployed by create2, you may ran into Fail - Unable to verify. You will have to visit the contract address page after deployment first. Then blockscout will fetch it from the RPC and see that it is a contract, then verification should work. Contract address page: https://explorer.gravity.xyz/address/***

  etherscan: {
    apiKey: {
      // ...
      // Not required. Can be any non-empty string
      gravity: "abc",
    },
    customChains: [
      // ...
      {
        network: "gravity",
        chainId: 1625,
        urls: {
          apiURL: "https://gscan.xyz/api",
          browserURL: "https://gscan.xyz",
          // For Blockscout
          // apiURL: "https://explorer.gravity.xyz/api",
          // browserURL: "https://explorer.gravity.xyz",
        },
      }
    ],
  },
  networks: {
    // ...
    gravity: {
      url: "https://rpc.gravity.xyz",
      chainId: 1625,
      accounts,
    },
  },
[etherscan]
# Gravity explorer does not require an API key, any non-empty string will do.
# gscan
gravity = { key = "abc", url="https://gscan.xyz/api", chain = 1625 }
# Blockscout
# gravity = { key = "abc", url="https://explorer.gravity.xyz/api", chain = 1625 }

Then you when you run your scripts, you can verify contracts deployed with --verify option.

forge script --chain 1625 script/YOUR_SCRIPT.s.sol:YOUR_SCRIPT --rpc-url $GRAVITY_RPC_URL --broadcast --verify -vvvv

NOTE: If contracts were deployed successfully but verification failed, DO NOT delete the broadcast/ directory. You can resume the verification process by removing the --broadcast option and providing the deployment transaction sender's key like below: (or you can configure it in cast):

forge script --chain 1625 script/YOUR_SCRIPT.s.sol:YOUR_SCRIPT --private-key $PRIVATE_KEY --rpc-url  $GRAVITY_RPC_URL --verify -vvvv

For users, you will need to change your hardhat.config.ts to something like the following example:

For users, we recommend you to use to deploy your contracts. You will need to configure the foundry.toml file as the following:

OKLink
OKLink interface
contract verification APIs
https://www.oklink.com/account/my-api
Blockscout
hardhat
foundry
scripts