Deployed 3.4.1 to all networks. Fixed up verify script.

package.json

@@ -48,8 +48,8 @@
     "sortition-sum-tree-factory": "0.1.0"
   },
   "devDependencies": {
-    "@nomiclabs/hardhat-ethers": "^2.0.1",
-    "@nomiclabs/hardhat-etherscan": "^2.1.3",
+    "@nomiclabs/hardhat-ethers": "^2.0.2",
+    "@nomiclabs/hardhat-etherscan": "^2.1.4",
     "@nomiclabs/hardhat-waffle": "^2.0.1",
     "@resolver-engine/core": "0.3.3",
     "@truffle/hdwallet-provider": "1.0.34",
@@ -60,10 +60,10 @@
     "ethers": "^5.0.0",
     "find": "^0.3.0",
     "ganache-cli": "^6.12.0",
-    "hardhat": "^2.4.0",
+    "hardhat": "^2.4.3",
     "hardhat-abi-exporter": "^2.0.8",
-    "hardhat-deploy": "^0.7.0-beta.45",
-    "hardhat-deploy-ethers": "^0.3.0-beta.7",
+    "hardhat-deploy": "^0.7.11",
+    "hardhat-deploy-ethers": "^0.3.0-beta.10",
     "minimist": "^1.2.5",
     "mocha-junit-reporter": "1.23.3",
     "shelljs": "0.8.3",

scripts/verify.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 const chalk = require('chalk')
 const util = require('util')
-const find = require('find')
-const fs = require('fs')
 const exec = util.promisify(require('child_process').exec)
 const hardhat = require('hardhat')
+const { deployments } = require("hardhat")
 
 const info = (msg) => console.log(chalk.dim(msg))
 const success = (msg) => console.log(chalk.green(msg))
@@ -16,60 +15,46 @@ const getContract = async (name) => {
   return hardhat.ethers.getContractAt(name, (await deployments.get(name)).address, signers[0])
 }
 
-const verifyAddress = async (address, name, path = "", args = "") => {
-
-  /*
-    needs to be in form:
-    hardhat verify --config <hardhat.config.<NETWORK>.js>
-      --network <network-name> <address>
-      --contract <PATH-TO-CONTRACT:CONTRACT-NAME>
-      <Constructor Args seperated by spaces>
-
-      as per https://www.npmjs.com/package/@nomiclabs/hardhat-etherscan
-  */
-
-  const network = hardhat.network.name
-  const config = getHardhatConfigFile(network)
-  let contractFlag = ""
-
-  if(path != ""){
-    contractFlag = "--contract " + path 
-  }
-
+const verifyAddress = async (address, contractName, options = "") => {
   try {
-    const cmd = `hardhat ${config} verify --network ${network} ${address} ${contractFlag} ${args}`
-    info(`running: ${cmd}`)
+    const cmd = `hardhat --show-stack-traces ${getHardhatConfigFile()} verify --network ${hardhat.network.name} ${address} ${options}`
+    info(`Verifying ${contractName}...`)
+    info(cmd)
     await exec(cmd.trim())
+    success(`Verified ${contractName}!`)
   } catch (e) {
     if (/Contract source code already verified/.test(e.message)) {
-      info(`${name} already verified`)
+      info(`${contractName} already verified`)
     } else {
       error(e.message)
       console.error(e)
     }
   }
 }
 
-const verifyProxyFactoryInstance = async (name) => {
-  const proxyFactory = await getContract(name)
-  const instanceAddress = await proxyFactory.instance()
-  info(`Verifying ${name} Instance at ${instanceAddress}...`)
-  await verifyAddress(instanceAddress, name)
-  success(`Verified ${name} Instance!`)
+const verifyAddressManually = async (address, contractName, args = "") => {
+  const artifact = await hardhat.artifacts.readArtifact(contractName)
+  const contractFlag = `--contract ${artifact.sourceName}:${contractName} ${args}`
+  await verifyAddress(address, contractName, contractFlag)
+}
+
+const proxyFactoryInstanceAddress = async (contractName) => {
+  const proxyFactory = await getContract(contractName)
+  return await proxyFactory.instance()
 }
 
 function isBinance() {
   const network = hardhat.network.name
-  return /bsc/.test(network);
+  return /bsc/.test(network) || /bscTestnet/.test(network);
 }
 
 function isPolygon() {
   const network = hardhat.network.name
-  return /polygon/.test(network) || /matic/.test(network)
+  return /polygon/.test(network) || /matic/.test(network) || /mumbai/.test(network)
 }
 
 
-function getHardhatConfigFile(network){
+function getHardhatConfigFile(){
   let config 
   if(isBinance()){
     config = '--config hardhat.config.bsc.js'
@@ -83,69 +68,28 @@ function getHardhatConfigFile(network){
   return config
 }
 
-
-async function verifyEtherscanClone(){
-  const network = hardhat.network.name
-
-  info(`verifying contracts on Etherscan Clone`)
-
-  const filePath = "./deployments/"+network+"/"
-
-  let toplevelContracts = []
-
-  // read deployment JSON files
-  fs.readdirSync(filePath).filter((fileName) => {
-    if(fileName.includes(".json")){
-
-      const contractName = (fileName.substring(0, fileName.length - 5)).trim() // strip .json
-      const contractDirPath = (find.fileSync(contractName+".sol", "./contracts"))[0]
-      if(!contractDirPath){
-        error(`There is no matching contract for ${contractName}. This is likely becuase the deployment contract name is different from the Solidity contract title.
-         Run verification manually. See verifyEtherscanClone() for details`)
-         return
-      }
-      const deployment = JSON.parse(fs.readFileSync(filePath+fileName, "utf8"))
-
-      toplevelContracts.push({
-        address: deployment.address,
-        contractPath: contractDirPath + ":" + contractName,
-        contractName,
-        constructorArgs : deployment.args
-      })
-    }
-  })
-
-  info(`Attempting to verify ${toplevelContracts.length} top level contracts`)
-
-  toplevelContracts.forEach(async (contract)=>{
-
-    let args = ""
-
-    if(contract.constructorArgs.length > 0){
-      contract.constructorArgs.forEach((arg)=>{
-        args = args.concat("\"", arg, "\" ") // format constructor args in correct form - "arg" "arg"
-      })    
-    }
-
-    await verifyAddress(contract.address, contract.contractName, contract.contractPath, args)
-  })
-}
-
-
 async function run() {
   const network = hardhat.network.name
 
   info(`Verifying top-level contracts on network: ${network}`)
 
-  if(network == "matic" || network == "bsc"){
-    await verifyEtherscanClone()
+  if(isBinance() || isPolygon()){
+    info(`verifying using hack`)
+    const contracts = await deployments.all()
+    const contractNames = Object.keys(contracts)
+    for (var i = 0; i < contractNames.length; i++) {
+      const contractName = contractNames[i]
+      const contract = contracts[contractName]
+      const args = contract.args.map(arg => arg.toString()).join(' ')
+      await verifyAddressManually(contract.address, contractName, args)
+    }
   }
-  else {  
-    info(`verifying contracts using native Hardhat verify`)
+  else { 
+    info(`verifying using Hardhat verify`)
     // using hardhat native etherscan verify -- this supports mainnet, rinkeby, kovan etc. 
-    const { stdout, stderr } = await exec(
-      `hardhat --network ${network} etherscan-verify --solc-input --api-key ${process.env.ETHERSCAN_API_KEY}`
-    )
+    const cmd = `hardhat --network ${network} etherscan-verify --solc-input --api-key ${hardhat.config.etherscan.apiKey}` 
+    info(cmd)
+    const { stdout, stderr } = await exec(cmd)
     console.log(chalk.yellow(stdout))
     console.log(chalk.red(stderr))
   }
@@ -154,13 +98,13 @@ async function run() {
 
   info(`Verifying proxy factory instances...`)
 
-  await verifyProxyFactoryInstance('CompoundPrizePoolProxyFactory')
-  await verifyProxyFactoryInstance('ControlledTokenProxyFactory')
-  await verifyProxyFactoryInstance('MultipleWinnersProxyFactory')
-  await verifyProxyFactoryInstance('StakePrizePoolProxyFactory')
-  await verifyProxyFactoryInstance('TicketProxyFactory')
-  await verifyProxyFactoryInstance('TokenFaucetProxyFactory')
-  await verifyProxyFactoryInstance('YieldSourcePrizePoolProxyFactory')
+  await verifyAddressManually(await proxyFactoryInstanceAddress('CompoundPrizePoolProxyFactory'), 'CompoundPrizePool')
+  await verifyAddressManually(await proxyFactoryInstanceAddress('ControlledTokenProxyFactory'), 'ControlledToken')
+  await verifyAddressManually(await proxyFactoryInstanceAddress('MultipleWinnersProxyFactory'), 'MultipleWinners')
+  await verifyAddressManually(await proxyFactoryInstanceAddress('StakePrizePoolProxyFactory'), 'StakePrizePool')
+  await verifyAddressManually(await proxyFactoryInstanceAddress('TicketProxyFactory'), 'Ticket')
+  await verifyAddressManually(await proxyFactoryInstanceAddress('TokenFaucetProxyFactory'), 'TokenFaucet')
+  await verifyAddressManually(await proxyFactoryInstanceAddress('YieldSourcePrizePoolProxyFactory'), 'YieldSourcePrizePool')
 
   success('Done!')
 }