Can we add network param to run function to verify contract on specific network ??

[Rushikesh0125]

I am trying to create a task for deploying and verifying any contract from my project..
task below successfully deployed contract but it is not able to verify..

How can i tell hre.run function to run the verify task on network passed in taskArgs

Getting following error

**Error in plugin @nomicfoundation/hardhat-verify: The selected network is "hardhat", which is not supported for contract verification. Please choose a network supported by Etherscan.**

If you intended to use a different network, ensure that you provide the --network parameter when running the command.     

For example: npx hardhat verify --network <network-name>

Command i am running ->

npx hardhat deploy-and-verify --contract Informant --chain mumbai

Code for task -

import { task } from "hardhat/config";
import { ethers } from "ethers";
import { HardhatRuntimeEnvironment } from "hardhat/types";
require("dotenv").config();
import {getContractArgs} from './costructorArgs';
import { getProviderURLs } from "./getProviderURL";

task("deploy-and-verify", "Deployes and verifies a contract to any network")
    .addParam("contract", "The name of contract")
    .addParam("chain", "Network to deploy")
    .setAction(async(taskArgs, hre : HardhatRuntimeEnvironment)=>{

    const provider = new ethers.JsonRpcProvider(await getProviderURLs(taskArgs.chain));
    const signer = new ethers.Wallet(process.env.PRIVATE_KEY || "", provider);

    const { abi, bytecode } = await hre.artifacts.readArtifact(taskArgs.contract);
    const factory = new ethers.ContractFactory(abi, bytecode, signer);

    const contract = await factory.deploy(
        ...await getContractArgs(taskArgs.contract, taskArgs.chain)
    );

    await contract.deploymentTransaction();
    
    console.log(`
🚀 Successfully deployed ${taskArgs.contract} contract on ${taskArgs.chain}.
📜 Contract address: ${contract.target}`);

    console.log(`Now, let's verify the contract ${taskArgs.contract} at ${taskArgs.chain} explorer`);

    await hre.run("verify", {
        address: await contract.getAddress(),
        constructorArguments: await getContractArgs(taskArgs.contract, taskArgs.chain)
    })

})

[fvictorio]

You shouldn't need to add a chain param to your task. You should use the built-in --network param for that, and then use the ethers.provider that it's automatically created and connected to that network.

[Rushikesh0125]

Hey @fvictorio , Thank you for this answer i am actually using this. My aim was to deploy a contract on multiple chains in single command & verify subsequently.
Something like this [one of my tasks]->

task("set-interactor", "adds interactor for all pairs of deployed contract")
    .addParam("contract").setAction(async (taskArgs, hre) => {

        const chains = ["goerli", "mumbai", "bscTestnet"];

        const contractName = taskArgs.contract;

        for(let i = 0; i < 3; i++){
            const constants = await getAddreses(chains[i]);
            const chainId = constants?.chainId;
            for(let j = 0; j < 3; j++){
                if(i == j) continue;
                
                const url = await getProviderURLs(chains[j]);

                const provider =  new hre.ethers.JsonRpcProvider(getProviderURLs(chains[j]));
                const signer = new hre.ethers.Wallet(process.env.PRIVATE_KEY || "", provider);

                const address = await getDeployedAddress(chains[j], contractName);
                const interactor = await getDeployedAddress(chains[i], contractName);

                const contractInst = await hre.ethers.getContractAt(taskArgs.contract, address || "", signer);
                
                console.log(`Adding interactor ${interactor} at ${chainId} `)

                await contractInst.setInteractorByChainId(chainId, interactor);

                console.log(`Added interactor ${interactor} at ${chainId}`)
            }

            console.log("------Next Pair------------->>>>>");
        }

        console.log("done----->")

})

[fvictorio]

In that case I think it's not possible. You need to run a different Hardhat process, with a different --network, for each verification in a different network.