Refactor base fn and add disable script

Author: AgusVelez5

deployment/config/config-types.ts

@@ -1,34 +1,19 @@
 import { ChainId } from "@wormhole-foundation/sdk-base";
-import { BytesLike } from "ethers";
-
-export type RouterEndpointConfig = {
-  wormholeChainId: ChainId;
-  endpoint: {
-    router: BytesLike;
-    mintRecipient: BytesLike;
-  },
-  circleDomain: number;
-}
 
 export type TokenRouterConfiguration = {
   // Wormhole Chain ID of the token router configuration
   chainId: ChainId;
 
-  // Immutable values
-  matchingEngineMintRecipient: string;
-  matchingEngineChain: ChainId; // Wormhole Chain ID
-  matchingEngineDomain: string;
-  
   // Mutable values
   ownerAssistant: string;
-  routerEndpoints: RouterEndpointConfig[];
   fastTransferParameters: {
     enabled: boolean;
     maxAmount: number;
     baseFee: number;
     initAuctionFee: number;
   };
   cctpAllowance: number;
+  disableRouterEndpoints?: ChainId[];
 };
 
 export type MatchingEngineConfiguration = {
@@ -45,6 +30,5 @@ export type MatchingEngineConfiguration = {
   // Mutable values
   ownerAssistant: string;
   feeRecipient: string;
-  routerEndpoints: RouterEndpointConfig[];
   cctpAllowance: number;
 };

deployment/helpers/evm.ts

@@ -45,7 +45,7 @@ export async function runOnEvmsSequentially(scriptName: string, cb: EvmScriptCb)
 }
 
 export function evmOperatingChains() {
-  const { operatingChains } = ecosystemChains.evm;
+  const { operatingChains } = ecosystemChains;
   if (Array.isArray(operatingChains) && operatingChains.length >= 1) {
     return ecosystemChains.evm.networks.filter((x) => {
       return operatingChains.includes(x.chainId);

deployment/helpers/interfaces.ts

@@ -1,6 +1,6 @@
 import { ChainId } from "@wormhole-foundation/sdk-base";
 import { SolanaLedgerSigner } from "@xlabs-xyz/ledger-signer-solana";
-import { ethers } from "ethers";
+import { BytesLike, ethers } from "ethers";
 
 export type EvmScriptCb = (chain: ChainInfo, signer: ethers.Signer, logFn: LoggerFn) => Promise<void>;
 export type SolanaScriptCb = (chain: ChainInfo, signer: SolanaLedgerSigner, logFn: LoggerFn) => Promise<void>;
@@ -21,9 +21,8 @@ export type Deployment = {
 };
 
 export type Ecosystem = {
-  guardianSetIndex: number;
+  operatingChains?: number[];
   evm: {
-    operatingChains?: number[];
     networks: ChainInfo[];
   },
   solana: {
@@ -46,4 +45,22 @@ export interface Dependencies extends ChainConfig {
 export interface ValueDiff {
   onChain: any;
   offChain: any;
+}
+
+export interface VerificationApiKeys extends ChainConfig {
+  etherscan: string;
+  blockscout?: {
+    mainnet: string;
+    testnet: string;
+  };
+  sourcify?: string;
+} 
+
+export type RouterEndpoint = {
+  wormholeChainId: ChainId;
+  endpoint: {
+    router: BytesLike;
+    mintRecipient: BytesLike;
+  },
+  circleDomain: number;
 }

deployment/helpers/utils.ts

@@ -1,8 +1,5 @@
 import chalk from 'chalk';
-import { LoggerFn, ValueDiff, getEnv } from '.';
-import { ChainId } from "@wormhole-foundation/sdk-base";
-import { RouterEndpointConfig } from '../config/config-types';
-import { UniversalAddress } from '@wormhole-foundation/sdk-definitions';
+import { ChainInfo, LoggerFn, ValueDiff } from '.';
 
 export const someoneIsDifferent = (values: ValueDiff[]) => values.some((value) => value.onChain.toString() !== value.offChain.toString() && Number(value.onChain) !== Number(value.offChain));
 
@@ -13,124 +10,66 @@ export function logComparision(name: string, diffValues: any, log: LoggerFn) {
     return;
 
   // If the on chain value is not present or it is zero value, log it as an addition
-  if (!diffValues.onChain || Number(diffValues.onChain) === 0) {
+  if (!diffValues.onChain || Number(diffValues.onChain) === 0)
     log(chalk.green(`+ ${name}: ${diffValues.offChain}`));
-  }
 
   // If the off chain value is not present or it is zero value, log it as a removal
-  else if (!diffValues.offChain || Number(diffValues.offChain) === 0) {
+  else if (!diffValues.offChain || Number(diffValues.offChain) === 0)
     log(chalk.red(`- ${name}: ${diffValues.onChain}`));
-  }
 
   // If both values are present and they are different, log it as a change
-  else {
+  else 
     log(chalk.yellow(`~ ${name}: `) + chalk.red(`${diffValues.onChain}`) + ' -> ' + chalk.green(`${diffValues.offChain}`));
-  }
 }
 
 // Assuming that we'll only have two types of addresses: Ethereum and Solana
 export function getAddressType(address: string): 'hex' | 'base58' {
   const ETHEREUM_ADDRESS_LENGTH = 40;
   const addressLength = address.length - (address.startsWith("0x") ? 2 : 0);
 
-  // TODO: check lenght of solana addresses
   if (address.length < ETHEREUM_ADDRESS_LENGTH)
     throw new Error(`Invalid address length: ${address}`);
 
   return addressLength === ETHEREUM_ADDRESS_LENGTH ? 'hex' : 'base58';
 }
 
-// Router endpoint helpers
-
-export function getRouterEndpointDifferences(onChainRouterEndpoints: RouterEndpointConfig[], offChainRouterEndpoints: RouterEndpointConfig[]) {
-  const routerEndpointsDifferences = [];
-  let onChainIndex = 0;
-  let offChainIndex = 0; 
-  
-  onChainRouterEndpoints = onChainRouterEndpoints.sort((a, b) => a.wormholeChainId - b.wormholeChainId);
-  offChainRouterEndpoints = offChainRouterEndpoints.sort((a, b) => a.wormholeChainId - b.wormholeChainId);
-  
-  while (true) {
-    const onChainEndpoint = onChainRouterEndpoints[onChainIndex];
-    const offChainEndpoint = offChainRouterEndpoints[offChainIndex];
-
-    // If we've reached the end of both arrays, we're done
-    if (!onChainEndpoint && !offChainEndpoint) {
-      break;
-    }
-
-    // If we've reached the end of offChainEndpoints, add the remaining onChainEndpoints
-    // or if the onChainEndpoint is less than the offChainEndpoint, add the onChainEndpoint
-    if (!offChainEndpoint || onChainEndpoint?.wormholeChainId < offChainEndpoint?.wormholeChainId) {
-      routerEndpointsDifferences.push(
-        routerEndpointConfig(onChainEndpoint.wormholeChainId, onChainEndpoint, {})
-      );
-      onChainIndex++;
-      continue;
-    } 
-
-    // If we've reached the end of onChainEndpoints, add the remaining offChainEndpoints
-    // or if the offChainEndpoint is less than the onChainEndpoint, add the offChainEndpoint
-    if (!onChainEndpoint || onChainEndpoint?.wormholeChainId > offChainEndpoint?.wormholeChainId) {
-      routerEndpointsDifferences.push(
-        routerEndpointConfig(offChainEndpoint.wormholeChainId, {}, offChainEndpoint)
-      );
-      offChainIndex++;
-      continue;
-    } 
-
-    routerEndpointsDifferences.push(
-      routerEndpointConfig(onChainEndpoint.wormholeChainId, onChainEndpoint, offChainEndpoint)
-    );
-
-    onChainIndex++;
-    offChainIndex++;
+export function flattenObject(obj: Record<string, any>, parentKey = '', result: Record<string, any> = {}) {
+  for (let key in obj) {
+      if (obj.hasOwnProperty(key)) {
+          let newKey = parentKey ? `${parentKey}-${key}` : key;
+
+          if (typeof obj[key] === 'object' && obj[key] !== null && !Array.isArray(obj[key])) {
+              flattenObject(obj[key], newKey, result);
+          } else {
+              result[newKey] = obj[key];
+          }
+      }
   }
-
-  return routerEndpointsDifferences;
-}
-
-const routerEndpointConfig = (wormholeChainId: ChainId,  onChain: Partial<RouterEndpointConfig>, offChain: Partial<RouterEndpointConfig>) => ({
-  wormholeChainId,
-  router: {
-    onChain: onChain?.endpoint?.router,
-    offChain: offChain?.endpoint?.router
-  },
-  mintRecipient: {
-    onChain: onChain?.endpoint?.mintRecipient,
-    offChain: offChain?.endpoint?.mintRecipient 
-  },
-  circleDomain: {
-    onChain: onChain?.circleDomain,
-    offChain: offChain?.circleDomain
-  }
-});
-
-export function getFormattedEndpoint(router: string, mintRecipient: string) {
-  const routerAddresType = getAddressType(router);
-  const mintRecipientAddressType = getAddressType(mintRecipient);
-
-  return {
-    router: (new UniversalAddress(router, routerAddresType)).toString(),
-    mintRecipient: (new UniversalAddress(mintRecipient, mintRecipientAddressType)).toString()
-  };
+  return result;
 }
 
 /// Verify bytecode helper
 
 export function getVerifyCommand(
+  chain: ChainInfo,
   contractName: string,
   contractPath: string,
   contractAddress: string,
   constructorSignature: string,
   constructorArgs: any[],
-  EvmChainId: number
+  verifier: string,
+  apiKey?: string
 ): string {
-  const ETHERSCAN_API_KEY = getEnv("ETHERSCAN_API_KEY");
-  return `
+  if (chain.externalId === undefined)
+    throw new Error(`Chain ${chain.chainId} does not have an external ID`);
+
+  let command = `
     forge verify-contract ${contractAddress} ${contractPath}:${contractName} \
+    --verifier ${verifier} \
     --watch --constructor-args $(cast abi-encode "${constructorSignature}" "${constructorArgs.join('" "')}") \
-    --chain-id ${EvmChainId} \
-    --etherscan-api-key ${ETHERSCAN_API_KEY} \
+    --chain-id ${chain.externalId} \
+    ${ apiKey === undefined || apiKey === "" ? '' : `--etherscan-api-key ${apiKey}` }
   `;
+
+  return command;
 }

deployment/scripts/evm/MatchingEngine/config-matching-engine.ts

@@ -1,5 +1,5 @@
 import { MatchingEngine } from "../../../contract-bindings";
-import { runOnEvmsSequentially, ChainInfo, LoggerFn, getContractInstance, getContractAddress, getFormattedEndpoint } from "../../../helpers";
+import { runOnEvmsSequentially, ChainInfo, LoggerFn, getContractInstance, getContractAddress } from "../../../helpers";
 import { ethers } from "ethers";
 import { getConfigurationDifferences, logDiff } from "./utils";
 import confirm from '@inquirer/confirm';

deployment/scripts/evm/MatchingEngine/utils.ts

@@ -1,7 +1,7 @@
 import { ethers } from "ethers";
 import { MatchingEngineConfiguration } from "../../../config/config-types";
 import { MatchingEngine, MatchingEngine__factory } from "../../../contract-bindings";
-import { ChainInfo, getChainConfig, LoggerFn, getDependencyAddress, writeDeployedContract, getContractAddress, getContractInstance, getRouterEndpointDifferences, logComparision, someoneIsDifferent } from "../../../helpers";
+import { ChainInfo, getChainConfig, LoggerFn, getDependencyAddress, writeDeployedContract, getContractAddress, getContractInstance,  logComparision, someoneIsDifferent } from "../../../helpers";
 import { ERC20 } from "../../../contract-bindings/out/ERC20";
 
 export function getMachingEngineConfiguration(chain: ChainInfo): Promise<MatchingEngineConfiguration> {
@@ -75,25 +75,11 @@ export async function getOnChainMachingEngineConfiguration(chain: ChainInfo) {
   const feeRecipient = await matchingEngine.feeRecipient();
   const ownerAssistant = await matchingEngine.getOwnerAssistant();
 
-  const routerEndpoints = await Promise.all(config
-    .routerEndpoints
-    .map(async ({ wormholeChainId }) => {
-      const { router, mintRecipient } = await matchingEngine.getRouterEndpoint(wormholeChainId);
-      return { 
-        wormholeChainId, 
-        endpoint: {
-          router,
-          mintRecipient
-        },
-        circleDomain: await matchingEngine.getDomain(wormholeChainId)
-      }
-    }));
 
   return {
     cctpAllowance,
     feeRecipient,
-    ownerAssistant,
-    routerEndpoints
+    ownerAssistant
   };
 } 
 
@@ -120,43 +106,11 @@ export async function getConfigurationDifferences(chain: ChainInfo) {
     };
   }
 
-  differences.routerEndpoints = getRouterEndpointDifferences(onChainConfig.routerEndpoints, offChainConfig.routerEndpoints);
-
   return differences;
 }
 
 export function logDiff(differences: Record<string, any>, log: LoggerFn, valuesToShow?: Array<"new" | "update" | "delete">) {
   logComparision('feeRecipient', differences.feeRecipient, log);
   logComparision('cctpAllowance', differences.cctpAllowance, log);
 
-  logRoutersDiff(differences, log, valuesToShow);
-}
-
-export function logRoutersDiff(differences: Record<string, any>, log: LoggerFn, valuesToShow?: Array<"new" | "update" | "delete">) {
-  let routersLogged = false;
-  for (const { wormholeChainId, router, mintRecipient, circleDomain } of differences.routerEndpoints) {
-    // In no one is different, skip
-    if (!someoneIsDifferent([router, mintRecipient, circleDomain])) 
-      continue;
-
-    // Edge case: if only mintRecipient is different and the off chain values are 0 (the endpoint is disabled), skip
-    if (
-      someoneIsDifferent([mintRecipient]) && 
-      !someoneIsDifferent([router, circleDomain]) && 
-      (Number(router.onChain) === 0 && Number(circleDomain.onChain) === 0) &&
-      (Number(mintRecipient.offChain) === 0)
-    ) {
-      continue;
-    }
-
-    if (!routersLogged) {
-      log('Router endpoints:');
-      routersLogged = true;
-    }
-    
-    log(`WormholeChainId ${wormholeChainId}:`);
-    logComparision('router', router, log, valuesToShow);
-    logComparision('mintRecipient', mintRecipient, log, valuesToShow);
-    logComparision('circleDomain', circleDomain, log, valuesToShow);
-  }
 }