Hardhat Contract Verification

The Tenderly-Hardhat plugin is an NPM library that allows you to automate the process of verifying smart contracts deployed with Hardhat. The plugin supports on public networks (mainnets and testnets) as well as Tenderly’s development infrastructure - Virtual TestNets. Rely on seamless automatic verification, or use manual mode to explicitly verify contracts in deployment scripts.

Versions and compatibility

Depending on the Ethers version you’re using with Hardhat, you need to download the corresponding version of the Tenderly-Hardhat plugin.

Verification methods

The Tenderly-Hardhat plugin supports three methods for contract verification.

• Automatic verification (recommended): Simply import and set up the plugin. This method is ideal for verification during deployment because the process is fully automated. Automatic verification works with plain hardhat deployment setup, as well as using hardhat-ignition. Control automatic verification by using the TENDERLY_AUTOMATIC_VERIFICATION environment variable.

• Manual verification (low-code): Offers an explicit verification step within your code, which is useful for scenarios like post-deployment verification, conditional verification (e.g. only after a failing test), or verifying factory contracts’ instances.

• Verbose manual verification (high-code): Provides detailed control over the verification process, specifying library addresses, source codes, and compiler configurations. This is necessary for verifying multiple contracts with varying compiler versions or settings.

Examples

The best way to explore the automatic verification process is to go through an example that you can in our GitHub repo.

All the examples use your sample Greeter contract.

Tenderly-Hardhat plugin setup

Follow the steps below to install and initialize the Tenderly-Hardhat plugin.

yarn add -D @tenderly/hardhat-tenderly@^2.2.2

curl https://raw.githubusercontent.com/Tenderly/tenderly-cli/master/scripts/install-macos.sh | sudo sh

tenderly whoami

tenderly login

tdly.setup({automaticVerifications: !!process.env.TENDERLY_AUTOMATIC_VERIFICATION});

import {HardhatUserConfig} from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
 
import * as tdly from "@tenderly/hardhat-tenderly";
 
const config: HardhatUserConfig = {
solidity: "0.8.19",
};
 
export default config;

import {HardhatUserConfig} from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
 
import * as tdly from "@tenderly/hardhat-tenderly";
 
const config: HardhatUserConfig = {
solidity: "0.8.19",
tenderly: {
username: "Your account slug" ?? "error",
project: "Your project slug",
 
// Contract visible only in Tenderly.
// Omitting or setting to `false` makes it visible to the whole world.
// Alternatively, configure verification visibility using
// an environment variable `TENDERLY_PUBLIC_VERIFICATION`.
privateVerification: process.env.TENDERLY_PUBLIC_VERIFICATION !== 'true',
},
};
 
export default config;

import {HardhatUserConfig} from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import * as tdly from "@tenderly/hardhat-tenderly";
 
const config: HardhatUserConfig = {
solidity: "0.8.19",
networks: {
mainnet_base: {
url: "https://base.gateway.tenderly.co",
chainId: 8453
},
tenderly_base_testnet: {
// your Tenderly TestNet RPC
url: "https://virtual.base.rpc.tenderly.co/872ac073-1de1-4422-b01d-8d057781d77d",
chainId: 888
}
},
tenderly: {
username: "Your account slug",
project: "Your project slug",
 
// Mainnet contract verification visible only in Tenderly.
// Omitting or setting to `false` makes it visible to the whole world.
// Alternatively, configure verification visibility using
// an environment variable `TENDERLY_PUBLIC_VERIFICATION`.
privateVerification: process.env.TENDERLY_PUBLIC_VERIFICATION !== 'true',
},
etherscan:{
apiKey: "YOUR_API_KEY",
customChains: [
{
network: "tenderly_base_testnet",
chainId: 888,
urls:{
apiURL: `https://virtual.base.rpc.tenderly.co/872ac073-1de1-4422-b01d-8d057781d77d/verify/etherscan`,
browserURL: "https://virtual.base.rpc.tenderly.co/872ac073-1de1-4422-b01d-8d057781d77d"
}
}
]
},
};
 
export default config;

In the following sections, you’ll learn how to verify contracts using the different verification methods.

Automatic verification

Automatic verification occurs seamlessly when you deploy a contract using Ethers.js. The automatic verification approach will perform the verification automatically after collecting the compiler settings, the deployed contract’s address, and the source code.

To enable or disable automatic verification, use the TENDERLY_AUTOMATIC_VERIFICATION environment variable recognized by the plugin.

The Tenderly-Hardhat plugin will verify contracts when it detects that the contract has been deployed, and Ethers has received the receipt of the deployment transaction.

To enable this, you need to await for deployment when you deploy contracts using Ethers’ helper methods ethers.deployContract() and ethers.getContractFactory(), by calling waitForDeployment() or deployed() on the contract instance, respectively.

import {ethers} from "hardhat";
 
export async function main() {
console.log("🖖🏽[ethers] Deploying and Verifying Greeter in Tenderly");
 
-   const greeter = await ethers.deployContract("Greeter", ["Hello, Hardhat!"]);
+   let greeter = await ethers.deployContract("Greeter", ["Hello, Hardhat!"]);
 
-   await greeter.waitForDeployment();
+   greeter = await greeter.waitForDeployment();
 
const greeterAddress = await greeter.getAddress();
console.log("{Greeter} deployed to", greeterAddress);
}
 
main().catch((error) => {
console.error(error);
process.exitCode = 1;
});

const greeter = await (
await ethers.deployContract("Greeter", ["Hello, Hardhat!"])
).waitForDeployment();

TENDERLY_AUTOMATIC_VERIFICATION=true \
npx hardhat ignition deploy ./ignition/modules/Lock.ts --network virtual_base --deployment-id
deploy-to-virtual-base

Verifying proxy contracts

Automatic verification of proxy contracts deployed and upgraded with hardhat-upgrades is possible with the following versions of @tenderly/hardhat-tenderly package:

• >= 1.10.0
• >= 2.1.0

For versions 1.x.x < 1.10.0 and 2.x.x < 2.1.0 follow the proxy verification guide.

Manual verification

Low-code verification through tenderly.verify() allows you to be explicit about the exact point of verification within a deployment script or a Hardhat test.

This method is particularly beneficial for:

• Verifying previously deployed contracts through custom scripts.
• Verifying instances created by factory contracts.
• Enhancing test runs by selectively verifying contracts at the end of a failing suite (after), which speeds up execution.

To manually control the verification, disable automatic verification by changing the TENDERLY_AUTOMATIC_VERIFICATION to false when running scripts.

The verify function

The verify() function takes an object where you must provide the:

• name of the contract
• address where the contract is deployed
• libraries (optional) used by the contract

The Tenderly-Hardhat plugin will pick up the existing compiler configuration and contract source code to perform the verification of the contracts you’ve specified.

let greeter = await ethers.deployContract("Greeter", ["Hello, Hardhat!"]);
greeter = await greeter.waitForDeployment();
 
await tenderly.verify({
  name: 'Greeter',
  address: await greeter.getAddress(),
  libraries: {
    AwsomeLib: "0x...",
  }
});

If you’re verifying multiple contracts, the function has variadic arguments:

let greeter = await ethers.deployContract("Greeter", ["Hello, Hardhat!"]);
greeter = await greeter.waitForDeployment();
 
const counter = (await ethers.deployContract("Counter", [42])).waitForDeployment();
 
await tenderly.verify(
  {
    name: 'Greeter',
    address: await greeter.getAddress(),
  },
  {
    name: 'Counter',
    address: await counter.getAddress(),
    libraries: {
        KickAssLib: "0x...",
    }
  },
);

import {HardhatUserConfig} from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
 
import * as tdly from "@tenderly/hardhat-tenderly";
- tdly.setup();
+ tdly.setup({automaticVerirication: false});
 
const config: HardhatUserConfig = {

    import { ethers } from "hardhat";
    + import { tenderly } from "hardhat";
 
    async function main() {
    console.log("🖖🏽[ethers] Deploying and Verifying Greeter in Tenderly");
 
    -   const greeter = await ethers.deployContract("Greeter", ["Hello, Manual Hardhat!",]);
    +   let greeter = await ethers.deployContract("Greeter", ["Hello, Manual Hardhat!",]);
 
    -   await greeter.waitForDeployment();
    +   greeter = await greeter.waitForDeployment();
 
    const address = await greeter.getAddress();
    console.log("Manual Simple: {Greeter} deployed to:", address);
 
    +    await tenderly.verify({
    +        address,
    +        name: "Greeter",
    +    });
  }
 
    main().catch((error) => {
    console.error(error);
    process.exitCode = 1;
  });

    TENDERLY_AUTOMATIC_VERIFICATION=false \
    npx hardhat run scripts/deploy.ts --network virtual_base

Verbose manual verification

The method verifyMultiCompilerAPI() gives you full control over the verification process, allowing you to specify every detail of the verification process.

This is rarely recommended but can be useful if you’re verifying contracts compiled with different compiler versions or configurations.

The fully controlled verification method allows you to explicitly:

• Specify the source code of the contracts (sources)
• Set compilation arguments (compiler)
• Set linked libraries (libraries)

The following example demonstrates how to perform a fully controlled verification.

await tenderly.verifyMultiCompilerAPI({
  contracts: [
    {
      contractToVerify: 'Greeter',
      sources: {
        'contracts/Greeter.sol': {
          name: 'Greeter',
          code: readFileSync('contracts/Greeter.sol', 'utf-8').toString(),
        },
        'hardhat/console.sol': {
          name: 'console',
          code: readFileSync('node_modules/hardhat/console.sol', 'utf-8').toString(),
        },
      },
      // solidity format compiler with a little modification at libraries param
      compiler: {
        version: '0.8.17',
        settings: {
          optimizer: {
            enabled: true,
            runs: 200,
          },
        },
        libraries: {
          'path/to/lib.sol': {
            addresses: {
              LibName1: '0x...',
              LibName2: '0x...',
            },
          },
        },
      },
      networks: {
        [NETWORK_ID]: {
          address: greeterAddress,
        },
      },
    },
  ],
});

Verification arguments

The verifyMultiCompilerAPI() method takes one argument — an array of contract objects. Each contract object consists of the following:

    sources: {
    'contracts/Greeter.sol': {
    name: 'Greeter',
    code: readFileSync('contracts/Greeter.sol', 'utf-8').toString(),
  },
    'hardhat/console.sol': {
    name: 'console',
    code: readFileSync('node_modules/hardhat/console.sol', 'utf-8').toString(),
  },
  },

  {
    networks: {
    [NETWORK_ID]: {
    address: greeterAddress,
  },
  },
  }

compiler.settings.libraries = {
"path/to/lib.sol": {
addresses: {
"LibName1": "0x...",
"LibName2": "0x..."
}
}
}