Verify Contracts

Once verified, a smart contract or token contract's source code becomes publicly available and verifiable, creating transparency and trust.

There are several ways to verify a contract, programmatically or manually on the UI.

Verify on the UI

  1. Go the the verify contract page (Other -> Verify Contract)

  2. Enter in the contract address you received during deployment. The dropdown will show you several available verification options. Select the one you would like to use and continue.

    1. Solidity (Flattended source code)

    2. Solidity (Standard JSON Input)

Solidity (Flattened Source Code)

  1. Contract Address: The 0x address supplied on contract creation (added above)

  2. Is Yul Contract: Select if the contract is coded in Yul for efficiency.

  3. Include Nightly Builds: Select if you want to show nightly builds.

  4. Compiler: derived from the first line in the contract pragma solidity X.X.X. Use the corresponding compiler version rather than the nightly build.

  5. EVM Version: Select the correct EVM version if known, otherwise use default.

  6. EVM Version: Select the correct EVM version if known, otherwise use default.

  7. Enter the Solidity Contract Code: You may need to flatten your solidity code if it utilizes a library or inherits dependencies from another contract. We recommend hardhat or the POA solidity flattener. To flatten your contract using contract, run:

yarn hardhat flatten .\contracts\<your-contract>.sol > flattened.sol
  1. Add Contract Libraries: Enter the name and 0x address for any required libraries called in the .sol file. You can add multiple contracts with the "+" button.

  2. Click the Verify and Publish button.

  3. If all goes well, you will see a checkmark next to Code in the code tab, and an additional tab called Read Contract. The contract name will now appear in BlockScout with any transactions related to your contract.

Solidity (Standard JSON Input)

  1. Include nightly builds. You can choose Yes or No depending on your compiler.

  2. Compiler. Choose the compiler version used to compile your smart contract. If you selected yes for nightly builds, use the compiler version rather than the build.

  3. Standard Input JSON. Upload your Standard Input JSON file. File should follows solidity format and all the sources must be in Literal Content format, not a URL.

Click the Verify & publish button and wait for the response.

Verify Programmatically

You can use this repo to verify your contracts programmatically along with deploying them.

Repo Link:

In this repo, use the deploy/ directory for deploying our contracts using the hardhat-deploy plugin. The deployment script deploys contracts in the contracts/ directory.

Prior to deploying the contracts, make sure to add customChain to the hardhat.config.js file. This is necessary to verify the contracts on the custom chain.

    customChains: [
        network: "unreal",
        chainId: 18231,
        urls: {
          apiURL: "",
          browserURL: "",

and add etherscan API key to the hardhat.config.js file.

  etherscan: {
    apiKey: {
      unreal: "XXXX",

Here is how a sample deploy script looks like using hardhat-deploy:

import { HardhatRuntimeEnvironment } from "hardhat/types";
import { DeployFunction } from "hardhat-deploy/types";
import { ethers, run } from "hardhat";
import {
} from "@openzeppelin/upgrades-core";

const deployBeaconAndProxies: DeployFunction = async function (
  hre: HardhatRuntimeEnvironment
) {
  const { deployments, getNamedAccounts } = hre;
  const { deploy } = deployments;
  const { deployer } = await getNamedAccounts();

  // Deploy your contract with a Transparent Proxy
  const boxDeployment = await deploy("Box", {
    contract: "Box", // Replace with your actual contract name
    from: deployer,
    args: [], // Constructor arguments for your contract (if any)
    log: true,
    proxy: {
      owner: deployer,
      proxyContract: "OpenZeppelinTransparentProxy",

  console.log(boxDeployment.address, "Box (proxy) address");

  // Wait for 10 seconds to ensure Etherscan has indexed the contract
  await new Promise((resolve) => setTimeout(resolve, 10000));

  // Retrieve implementation and admin addresses
  const proxyAddress = boxDeployment.address;
  const implementationAddress = await getImplementationAddress(
  const adminAddress = await getAdminAddress(ethers.provider, proxyAddress);

  console.log(implementationAddress, "Box (implementation) address");
  console.log(adminAddress, "Box (admin) address");

  // Verify the implementation contract
  try {
    await run("verify:verify", {
      address: implementationAddress,
      constructorArguments: [], // Add constructor arguments of your implementation contract if any
    console.log(`Verified implementation contract at ${implementationAddress}`);
  } catch (error) {
    console.error("Verification of implementation contract failed", error);

  // Additional logic for verifying other contracts can be added here if needed

export default deployBeaconAndProxies;
deployBeaconAndProxies.tags = ["Box"];

To deploy the contracts, run:

npx hardhat deploy --network <network-name>


PS C:\Users\aniru\OneDrive\Desktop\Gelato_internship\RaaS\verify-simple-proxy> npx hardhat deploy --network unreal
Nothing to compile
No need to generate any newer typings.
reusing "DefaultProxyAdmin" at 0xdDF2D006e3010e62c354508D42a2eA5910A88bD2
reusing "Box_Implementation" at 0x7b8d30c0F605fCa77F2ec04661C11c369f630753
0xe3689ABC2F6648BA8be68cE41620988C4e2708bd Box (proxy) address
0x7b8d30c0F605fCa77F2ec04661C11c369f630753 Box (implementation) address
0xdDF2D006e3010e62c354508D42a2eA5910A88bD2 Box (admin) address
The contract 0x7b8d30c0F605fCa77F2ec04661C11c369f630753 has already been verified on Etherscan.
Verified implementation contract at 0x7b8d30c0F605fCa77F2ec04661C11c369f630753