Finish bytecode verification script

Author: AgusVelez5

deployment/config/mainnet/verification-api-keys.json

@@ -0,0 +1 @@
+{}

deployment/config/verification-api-keys.sample.json

@@ -0,0 +1,7 @@
+{
+  "<wormhole-chain-id-1>": { "etherscan": "<key>", "blockscout": {"key": "<key>", "apiUrl": "https://<chain>.blockscout.com/api"}, "sourcify": ""},
+  "<wormhole-chain-id-2>": { "etherscan": "<key>", "blockscout": {"key": "<key>", "apiUrl": "https://<chain>.blockscout.com/api"}},
+  "<wormhole-chain-id-3>": { "blockscout": {"key": "<key>", "apiUrl": "https://<chain>.blockscout.com/api"}, "sourcify": ""},
+  "<wormhole-chain-id-4>": { "etherscan": "<key>", "sourcify": ""},
+  "<wormhole-chain-id-5>": { "etherscan": "<key>"}
+}

deployment/helpers/evm.ts

@@ -1,6 +1,7 @@
 import { LedgerSigner }  from "@xlabs-xyz/ledger-signer";
 import { ethers } from "ethers";
 import { ChainInfo, ecosystemChains, EvmScriptCb, getEnv } from "./index";
+import { toChain } from "@wormhole-foundation/sdk-base";
 
 export async function runOnEvms(scriptName: string, cb: EvmScriptCb) {
   const chains = evmOperatingChains();
@@ -10,7 +11,7 @@ export async function runOnEvms(scriptName: string, cb: EvmScriptCb) {
   const result = chains.map(async chain => {
     const log = (...args: any[]) => console.log(`[${chain.chainId}]`, ...args);
     const signer = await getSigner(chain);
-    log(`Starting script. Signer: ${await signer.getAddress()}`);
+    log(`Starting script. Signer: ${await signer.getAddress()}. Chain: ${toChain(chain.chainId)}`);
 
     try {
       await cb(chain, signer, log);

deployment/helpers/utils.ts

@@ -49,22 +49,37 @@ export function flattenObject(obj: Record<string, any>, parentKey = '', result:
   return result;
 }
 
-export function getVerifyCommand(
+export function getVerifyCommand({
+  chain,
+  contractName,
+  contractPath,
+  contractAddress,
+  constructorSignature,
+  constructorArgs,
+  verifier,
+  verifierUrl,
+  apiKey
+}: {  
   chain: ChainInfo,
   contractName: string,
   contractPath: string,
   contractAddress: string,
   constructorSignature: string,
   constructorArgs: any[],
   verifier: string,
+  verifierUrl?: string,
   apiKey?: string
-): string {
+}): string {
   if (chain.externalId === undefined)
     throw new Error(`Chain ${chain.chainId} does not have an external ID`);
 
+  if (verifier === "blockscout" && verifierUrl === undefined)
+    throw new Error(`Verifier URL is required for Blockscout verifier`);
+
   let command = `
     forge verify-contract ${contractAddress} ${contractPath}:${contractName} \
     --verifier ${verifier} \
+    ${ verifier === "blockscout" ? `--verifier-url ${verifierUrl}` : ''} \
     --watch --constructor-args $(cast abi-encode "${constructorSignature}" "${constructorArgs.join('" "')}") \
     --chain-id ${chain.externalId} \
     ${ apiKey === undefined || apiKey === "" ? '' : `--etherscan-api-key ${apiKey}` }

deployment/scripts/evm/TokenRouter/bytecode-verification-token-router.ts

@@ -7,48 +7,53 @@ evm.runOnEvms("bytecode-verification-token-router", async (chain, signer, log) =
   // The root path of the foundry project
   const rootPath = path.resolve('../evm/');
 
-  const verifiersData = verificationApiKeys.find((x) => x.chainId == chain.chainId);
-  const verifiers = flattenObject(verifiersData!);
-  delete verifiers.chainId;
+  const verifiers = verificationApiKeys[chain.chainId];
+  if (!verifiers) {
+    log(chalk.red(`No verifiers found for chain ${chain.chainId}`));
+    return;
+  }
 
-  for (let [name, apiKey] of Object.entries(verifiers)) {
-    name = name.split("-")[0];
+  for (let [verifier, data] of Object.entries(verifiers)) {
+    const apiKey = typeof data === 'string' ? data : data.key;
+    const verifierUrl = typeof data === 'string' ? undefined : data.apiUrl;
 
     // Implementation data
     const implementationName = "TokenRouter";
     const implementationPath = 'src/TokenRouter/TokenRouter.sol';
     const implementationAddress = getContractAddress("TokenRouterImplementation", chain.chainId);
     const implementationDeploymentArgs = getDeploymentArgs("TokenRouterImplementation", chain.chainId);
     const implementationConstructorSignature = "constructor(address,address,address,uint16,bytes32,bytes32,uint32)";
-    const verifyImplementationCommand = getVerifyCommand(
+    const verifyImplementationCommand = getVerifyCommand({
       chain,
-      implementationName, 
-      implementationPath,
-      implementationAddress, 
-      implementationConstructorSignature, 
-      implementationDeploymentArgs, 
-      name,
+      contractName: implementationName, 
+      contractPath: implementationPath,
+      contractAddress: implementationAddress, 
+      constructorSignature: implementationConstructorSignature, 
+      constructorArgs: implementationDeploymentArgs, 
+      verifier,
+      verifierUrl,
       apiKey
-    );
+    });
 
     // Proxy data
     const proxyName = "ERC1967Proxy";
     const proxyPath = 'lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol';
-    const proxyAddress = getContractAddress("MatchingEngineProxy", chain.chainId);
-    const proxyDeploymentArgs = getDeploymentArgs("MatchingEngineProxy", chain.chainId);
+    const proxyAddress = getContractAddress("TokenRouterProxy", chain.chainId);
+    const proxyDeploymentArgs = getDeploymentArgs("TokenRouterProxy", chain.chainId);
     const proxyConstructorSignature = "constructor(address,bytes)";
-    const verifyProxyCommand = getVerifyCommand(
+    const verifyProxyCommand = getVerifyCommand({
       chain,
-      proxyName,
-      proxyPath, 
-      proxyAddress, 
-      proxyConstructorSignature, 
-      proxyDeploymentArgs, 
-      name,
+      contractName: proxyName, 
+      contractPath: proxyPath,
+      contractAddress: proxyAddress, 
+      constructorSignature: proxyConstructorSignature, 
+      constructorArgs: proxyDeploymentArgs, 
+      verifier,
+      verifierUrl,
       apiKey
-    );
+    });
 
-    log(chalk.green(`Verifying bytecode on ${name}...`));
+    log(chalk.green(`Verifying bytecode on ${verifier}...`));
     log(chalk.green("Verifying implementation bytecode..."));
     execSync(verifyImplementationCommand, { stdio: "inherit", cwd: rootPath });
     console.log()