@layerzerolabs/verify-contract 1.1.33 → 1.2.0

package/dist/index.mjs

@@ -7006,9 +7006,9 @@ var require_winston_transport = __commonJS({
         this.logv = options.logv;
       if (options.close)
         this.close = options.close;
-      this.once("pipe", (logger11) => {
-        this.levels = logger11.levels;
-        this.parent = logger11;
+      this.once("pipe", (logger12) => {
+        this.levels = logger12.levels;
+        this.parent = logger12;
       });
       this.once("unpipe", (src) => {
         if (src === this.parent) {
@@ -7986,7 +7986,7 @@ var require_diagnostics = __commonJS({
   "../../node_modules/.pnpm/@dabh+diagnostics@2.0.3/node_modules/@dabh/diagnostics/diagnostics.js"(exports, module) {
     var adapters = [];
     var modifiers = [];
-    var logger11 = function devnull() {
+    var logger12 = function devnull() {
     };
     function use(adapter) {
       if (~adapters.indexOf(adapter))
@@ -7995,7 +7995,7 @@ var require_diagnostics = __commonJS({
       return true;
     }
     function set(custom2) {
-      logger11 = custom2;
+      logger12 = custom2;
     }
     function enabled(namespace) {
       var async = [];
@@ -8026,7 +8026,7 @@ var require_diagnostics = __commonJS({
       return true;
     }
     function write() {
-      logger11.apply(logger11, arguments);
+      logger12.apply(logger12, arguments);
     }
     function process4(message) {
       for (var i = 0; i < modifiers.length; i++) {
@@ -11180,11 +11180,11 @@ var require_exception_handler = __commonJS({
        * TODO: add contructor description
        * @param {!Logger} logger - TODO: add param description
        */
-      constructor(logger11) {
-        if (!logger11) {
+      constructor(logger12) {
+        if (!logger12) {
           throw new Error("Logger is required to handle exceptions");
         }
-        this.logger = logger11;
+        this.logger = logger12;
         this.handlers = /* @__PURE__ */ new Map();
       }
       /**
@@ -11377,11 +11377,11 @@ var require_rejection_handler = __commonJS({
        * TODO: add contructor description
        * @param {!Logger} logger - TODO: add param description
        */
-      constructor(logger11) {
-        if (!logger11) {
+      constructor(logger12) {
+        if (!logger12) {
           throw new Error("Logger is required to handle rejections");
         }
-        this.logger = logger11;
+        this.logger = logger12;
         this.handlers = /* @__PURE__ */ new Map();
       }
       /**
@@ -11577,12 +11577,12 @@ var require_profiler = __commonJS({
        * @param {!Logger} logger - TODO: add param description.
        * @private
        */
-      constructor(logger11) {
+      constructor(logger12) {
         const Logger2 = require_logger();
-        if (typeof logger11 !== "object" || Array.isArray(logger11) || !(logger11 instanceof Logger2)) {
+        if (typeof logger12 !== "object" || Array.isArray(logger12) || !(logger12 instanceof Logger2)) {
           throw new Error("Logger is required for profiling");
         } else {
-          this.logger = logger11;
+          this.logger = logger12;
           this.start = Date.now();
         }
       }
@@ -11632,8 +11632,8 @@ var require_logger = __commonJS({
         this.configure(options);
       }
       child(defaultRequestMetadata) {
-        const logger11 = this;
-        return Object.create(logger11, {
+        const logger12 = this;
+        return Object.create(logger12, {
           write: {
             value: function(info) {
               const infoClone = Object.assign(
@@ -11645,7 +11645,7 @@ var require_logger = __commonJS({
                 infoClone.stack = info.stack;
                 infoClone.message = info.message;
               }
-              logger11.write(infoClone);
+              logger12.write(infoClone);
             }
           }
         });
@@ -12152,7 +12152,7 @@ var require_create_logger = __commonJS({
           super(options);
         }
       }
-      const logger11 = new DerivedLogger(opts);
+      const logger12 = new DerivedLogger(opts);
       Object.keys(opts.levels).forEach(function(level) {
         debug('Define prototype method for "%s"', level);
         if (level === "log") {
@@ -12160,14 +12160,14 @@ var require_create_logger = __commonJS({
           return;
         }
         DerivedLogger.prototype[level] = function(...args) {
-          const self2 = this || logger11;
+          const self2 = this || logger12;
           if (args.length === 1) {
             const [msg] = args;
             const info = msg && msg.message && msg || { message: msg };
             info.level = info[LEVEL] = level;
             self2._addDefaultMeta(info);
             self2.write(info);
-            return this || logger11;
+            return this || logger12;
           }
           if (args.length === 0) {
             self2.log(level, "");
@@ -12176,10 +12176,10 @@ var require_create_logger = __commonJS({
           return self2.log(level, ...args);
         };
         DerivedLogger.prototype[isLevelEnabledFunctionName(level)] = function() {
-          return (this || logger11).isLevelEnabled(level);
+          return (this || logger12).isLevelEnabled(level);
         };
       });
-      return logger11;
+      return logger12;
     };
   }
 });
@@ -12187,7 +12187,7 @@ var require_create_logger = __commonJS({
 // ../../node_modules/.pnpm/winston@3.11.0/node_modules/winston/lib/winston/container.js
 var require_container = __commonJS({
   "../../node_modules/.pnpm/winston@3.11.0/node_modules/winston/lib/winston/container.js"(exports, module) {
-    var createLogger = require_create_logger();
+    var createLogger2 = require_create_logger();
     module.exports = class Container {
       /**
        * Constructor function for the Container object responsible for managing a
@@ -12214,9 +12214,9 @@ var require_container = __commonJS({
           } else {
             options.transports = [];
           }
-          const logger11 = createLogger(options);
-          logger11.on("close", () => this._delete(id2));
-          this.loggers.set(id2, logger11);
+          const logger12 = createLogger2(options);
+          logger12.on("close", () => this._delete(id2));
+          this.loggers.set(id2, logger12);
         }
         return this.loggers.get(id2);
       }
@@ -12261,8 +12261,8 @@ var require_container = __commonJS({
         if (!this.loggers.has(id2)) {
           return;
         }
-        const logger11 = this.loggers.get(id2);
-        logger11.close();
+        const logger12 = this.loggers.get(id2);
+        logger12.close();
         this._delete(id2);
       }
       /**
@@ -64817,8 +64817,555 @@ var require_index_cjs = __commonJS({
   }
 });
 
+// src/common/networks.ts
+var ETHERSCAN_V2_URL = "https://api.etherscan.io/v2/api";
+var networks = {
+  // Ethereum
+  ethereum: {
+    chainId: 1,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["ethereum-mainnet"]
+  },
+  goerli: {
+    // DEPRECATED
+    chainId: 5,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["ethereum-goerli"]
+  },
+  sepolia: {
+    chainId: 11155111,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["sepolia-testnet", "eth-sepolia", "ethereum-sepolia"]
+  },
+  holesky: {
+    chainId: 17e3,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["holesky-testnet", "ethereum-holesky"]
+  },
+  hoodi: {
+    chainId: 560048,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["hoodi-testnet", "ethereum-hoodi"]
+  },
+  // Polygon
+  polygon: {
+    chainId: 137,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["polygon-mainnet"]
+  },
+  amoy: {
+    chainId: 80002,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["polygon-amoy", "polygon-sepolia", "polygon-testnet"]
+  },
+  // Arbitrum
+  arbitrum: {
+    chainId: 42161,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["arbitrum-mainnet"]
+  },
+  "arbitrum-nova": {
+    chainId: 42170,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["arbitrum-nova-mainnet"]
+  },
+  "arbitrum-goerli": {
+    // DEPRECATED
+    chainId: 421613,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  arbsep: {
+    chainId: 421614,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["arbsep-testnet", "arbitrum-sepolia", "arbitrum-testnet"]
+  },
+  // Optimism
+  optimism: {
+    chainId: 10,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["optimism-mainnet"]
+  },
+  "optimism-goerli": {
+    // DEPRECATED
+    chainId: 420,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  optsep: {
+    chainId: 11155420,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["optsep-testnet", "optimism-sepolia", "optimism-testnet"]
+  },
+  // Base
+  base: {
+    chainId: 8453,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["base-mainnet"]
+  },
+  "base-sepolia": {
+    chainId: 84532,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["base-testnet", "basesep"]
+  },
+  "base-goerli": {
+    // DEPRECATED
+    chainId: 84531,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // Avalanche
+  avalanche: {
+    chainId: 43114,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["avalanche-mainnet"]
+  },
+  fuji: {
+    chainId: 43113,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["avalanche-testnet", "avalanche-fuji"]
+  },
+  // BSC
+  bsc: {
+    chainId: 56,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["bsc-mainnet"]
+  },
+  "bsc-testnet": {
+    chainId: 97,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // Fantom
+  fantom: {
+    chainId: 250,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["fantom-mainnet"]
+  },
+  "fantom-testnet": {
+    chainId: 4002,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // Gnosis
+  gnosis: {
+    chainId: 100,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["gnosis-mainnet"]
+  },
+  // Blast
+  blast: {
+    chainId: 81457,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["blast-mainnet"]
+  },
+  "blast-sepolia": {
+    chainId: 168587773,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["blast-sepolia-testnet", "blast-testnet"]
+  },
+  // Linea / zkConsensys
+  linea: {
+    chainId: 59144,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["linea-mainnet", "zkconsensys", "zkconsensys-mainnet"]
+  },
+  "linea-sepolia": {
+    chainId: 59141,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["linea-sepolia-testnet", "linea-testnet", "lineasep"]
+  },
+  // Scroll
+  scroll: {
+    chainId: 534352,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["scroll-mainnet"]
+  },
+  "scroll-sepolia": {
+    chainId: 534351,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["scroll-sepolia-testnet", "scroll-testnet"]
+  },
+  // Moonbeam
+  moonbeam: {
+    chainId: 1284,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["moonbeam-mainnet"]
+  },
+  "moonbeam-testnet": {
+    chainId: 1287,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // Moonriver
+  moonriver: {
+    chainId: 1285,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["moonriver-mainnet"]
+  },
+  // Fraxtal
+  fraxtal: {
+    chainId: 252,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["fraxtal-mainnet"]
+  },
+  "fraxtal-hoodi": {
+    chainId: 2523,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["fraxtal-hoodi-testnet", "fraxtal-testnet"]
+  },
+  // Taiko
+  taiko: {
+    chainId: 167e3,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["taiko-mainnet"]
+  },
+  "taiko-hoodi": {
+    chainId: 167013,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["taiko-hoodi-testnet", "taiko-testnet"]
+  },
+  // Abstract
+  abstract: {
+    chainId: 2741,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["abstract-mainnet"]
+  },
+  "abstract-sepolia": {
+    chainId: 11124,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["abstract-sepolia-testnet", "abstract-testnet"]
+  },
+  // ApeChain
+  apechain: {
+    chainId: 33139,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["apechain-mainnet", "ape"]
+  },
+  "apechain-curtis": {
+    chainId: 33111,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["apechain-curtis-testnet", "apechain-testnet", "curtis"]
+  },
+  // Berachain
+  berachain: {
+    chainId: 80094,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["berachain-mainnet", "bera"]
+  },
+  "berachain-bepolia": {
+    chainId: 80069,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["berachain-bepolia-testnet", "berachain-testnet", "bepolia"]
+  },
+  // BitTorrent
+  bittorrent: {
+    chainId: 199,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["bittorrent-mainnet"]
+  },
+  "bittorrent-testnet": {
+    chainId: 1029,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // Celo
+  celo: {
+    chainId: 42220,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["celo-mainnet"]
+  },
+  "celo-sepolia": {
+    chainId: 11142220,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["celo-sepolia-testnet", "celo-testnet"]
+  },
+  // HyperEVM
+  hyperevm: {
+    chainId: 999,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["hyperevm-mainnet", "hyperliquid"]
+  },
+  // Katana
+  katana: {
+    chainId: 747474,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["katana-mainnet"]
+  },
+  "katana-bokuto": {
+    chainId: 737373,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["katana-bokuto-testnet", "katana-testnet"]
+  },
+  // Mantle
+  mantle: {
+    chainId: 5e3,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["mantle-mainnet"]
+  },
+  "mantle-sepolia": {
+    chainId: 5003,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["mantle-sepolia-testnet", "mantle-testnet", "mantlesep"]
+  },
+  // Memecore
+  "memecore-testnet": {
+    chainId: 43521,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["memecoreformicarium"]
+  },
+  // Monad
+  "monad-testnet": {
+    chainId: 10143,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // opBNB
+  opbnb: {
+    chainId: 204,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["opbnb-mainnet"]
+  },
+  "opbnb-testnet": {
+    chainId: 5611,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // Sei
+  sei: {
+    chainId: 1329,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["sei-mainnet"]
+  },
+  "sei-testnet": {
+    chainId: 1328,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // Sonic
+  sonic: {
+    chainId: 146,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["sonic-mainnet"]
+  },
+  "sonic-testnet": {
+    chainId: 14601,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // Sophon (DEPRECATED - will be deprecated on November 22, 2025)
+  sophon: {
+    chainId: 50104,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["sophon-mainnet"]
+  },
+  "sophon-sepolia": {
+    chainId: 531050104,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["sophon-sepolia-testnet", "sophon-testnet"]
+  },
+  // Swellchain
+  swellchain: {
+    chainId: 1923,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["swellchain-mainnet", "swell"]
+  },
+  "swellchain-testnet": {
+    chainId: 1924,
+    apiUrl: ETHERSCAN_V2_URL
+  },
+  // Unichain
+  unichain: {
+    chainId: 130,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["unichain-mainnet"]
+  },
+  "unichain-sepolia": {
+    chainId: 1301,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["unichain-sepolia-testnet", "unichain-testnet"]
+  },
+  // World
+  world: {
+    chainId: 480,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["world-mainnet", "worldchain"]
+  },
+  "world-sepolia": {
+    chainId: 4801,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["world-sepolia-testnet", "world-testnet"]
+  },
+  // XDC
+  xdc: {
+    chainId: 50,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["xdc-mainnet"]
+  },
+  "xdc-apothem": {
+    chainId: 51,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["xdc-apothem-testnet", "xdc-testnet"]
+  },
+  // zkSync
+  zksync: {
+    chainId: 324,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["zksync-mainnet"]
+  },
+  "zksync-sepolia": {
+    chainId: 300,
+    apiUrl: ETHERSCAN_V2_URL,
+    aliases: ["zksync-sepolia-testnet", "zksync-testnet", "zksyncsep"]
+  },
+  // Non-Etherscan Networks (custom explorers)
+  // chainId is not used for these networks
+  // Astar
+  astar: {
+    chainId: 0,
+    apiUrl: "https://astar.blockscout.com/api",
+    aliases: ["astar-mainnet"]
+  },
+  zkatana: {
+    chainId: 0,
+    apiUrl: "https://astar-zkevm.explorer.startale.com/api",
+    aliases: ["zkatana-mainnet"]
+  },
+  // Aurora
+  aurora: {
+    chainId: 0,
+    apiUrl: "https://explorer.mainnet.aurora.dev/api",
+    aliases: ["aurora-mainnet"]
+  },
+  // EBI
+  ebi: {
+    chainId: 0,
+    apiUrl: "https://explorer.ebi.xyz/api",
+    aliases: ["ebi-mainnet"]
+  },
+  // Etherlink
+  etherlink: {
+    chainId: 0,
+    apiUrl: "https://explorer.etherlink.com/api",
+    aliases: ["etherlink-mainnet"]
+  },
+  // Flare
+  flare: {
+    chainId: 0,
+    apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/14/etherscan",
+    aliases: ["flare-mainnet"]
+  },
+  // Gravity
+  gravity: {
+    chainId: 0,
+    apiUrl: "https://explorer.gravity.xyz/api",
+    aliases: ["gravity-mainnet"]
+  },
+  // IOTA
+  iota: {
+    chainId: 0,
+    apiUrl: "https://explorer.evm.iota.org/api",
+    aliases: ["iota-mainnet"]
+  },
+  // Kava
+  kava: {
+    chainId: 0,
+    apiUrl: "https://kavascan.com/api",
+    aliases: ["kava-mainnet"]
+  },
+  "kava-testnet": {
+    chainId: 0,
+    apiUrl: "https://testnet.kavascan.com/api"
+  },
+  // Klaytn
+  klaytn: {
+    chainId: 0,
+    apiUrl: "https://api-cypress.klaytnscope.com/api",
+    aliases: ["klaytn-mainnet"]
+  },
+  "klaytn-testnet": {
+    chainId: 0,
+    apiUrl: "https://api-baobab.klaytnscope.com/api"
+  },
+  // Manta
+  manta: {
+    chainId: 0,
+    apiUrl: "https://pacific-explorer.manta.network/api",
+    aliases: ["manta-mainnet"]
+  },
+  // Metis
+  metis: {
+    chainId: 0,
+    apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan",
+    aliases: ["metis-mainnet"]
+  },
+  // Mode
+  mode: {
+    chainId: 0,
+    apiUrl: "https://explorer.mode.network/api",
+    aliases: ["mode-mainnet"]
+  },
+  // Rarible
+  rarible: {
+    chainId: 0,
+    apiUrl: "https://mainnet.explorer.rarichain.org/api",
+    aliases: ["rarible-mainnet"]
+  },
+  // X Chain
+  xchain: {
+    chainId: 0,
+    apiUrl: "https://xchain-explorer.idex.io/api",
+    aliases: ["xchain-mainnet"]
+  },
+  // X Layer
+  xlayer: {
+    chainId: 0,
+    apiUrl: "https://www.oklink.com/api/v5/explorer/contract/verify-source-code-plugin/XLAYER",
+    aliases: ["xlayer-mainnet"]
+  }
+};
+
+// src/common/networks-loader.ts
+var NetworkRegistry = class {
+  constructor() {
+    __publicField(this, "apiUrls", /* @__PURE__ */ new Map());
+    __publicField(this, "chainIds", /* @__PURE__ */ new Map());
+    for (const [canonicalName, network] of Object.entries(networks)) {
+      const apiUrl = network.apiUrl;
+      const chainId = network.chainId;
+      if (apiUrl) {
+        this.apiUrls.set(canonicalName, apiUrl);
+      }
+      if (chainId) {
+        this.chainIds.set(canonicalName, chainId);
+      }
+      if (network.aliases) {
+        for (const alias of network.aliases) {
+          if (apiUrl) {
+            this.apiUrls.set(alias, apiUrl);
+          }
+          if (chainId) {
+            this.chainIds.set(alias, chainId);
+          }
+        }
+      }
+    }
+  }
+  getApiUrl(networkName) {
+    return this.apiUrls.get(networkName);
+  }
+  getChainId(networkName) {
+    return this.chainIds.get(networkName);
+  }
+  getAllNetworkNames() {
+    return Array.from(/* @__PURE__ */ new Set([...this.apiUrls.keys(), ...this.chainIds.keys()]));
+  }
+  getSupportedNetworks() {
+    const networks2 = /* @__PURE__ */ new Map();
+    const allNames = this.getAllNetworkNames();
+    for (const name of allNames) {
+      networks2.set(name, {
+        chainId: this.getChainId(name),
+        apiUrl: this.getApiUrl(name)
+      });
+    }
+    return networks2;
+  }
+};
+var networkRegistry = new NetworkRegistry();
+var getDefaultScanApiUrl = (networkName) => networkRegistry.getApiUrl(networkName);
+var getDefaultChainId = (networkName) => networkRegistry.getChainId(networkName);
+
 // src/common/url.ts
-var getDefaultScanApiUrl = (networkName) => DEFAULT_SCAN_API_URLS.get(networkName);
 var tryGetScanBrowserUrlFromScanUrl = (scanApiUrl) => {
   try {
     const urlObject = new URL(scanApiUrl);
@@ -64841,99 +65388,6 @@ var tryCreateScanContractUrl = (scanBrowserUrl, address) => {
     return void 0;
   }
 };
-var DEFAULT_SCAN_API_URLS = /* @__PURE__ */ new Map([
-  ["amoy", "https://amoy.polygonscan.com/api"],
-  ["amoy-mainnet", "https://amoy.polygonscan.com/api"],
-  ["arbitrum", "https://api.arbiscan.io/api"],
-  ["arbitrum-goerli", "https://api-goerli.arbiscan.io/api"],
-  ["arbitrum-mainnet", "https://api.arbiscan.io/api"],
-  ["arbsep-testnet", "https://api-sepolia.arbiscan.io/api"],
-  ["astar", "https://astar.blockscout.com/api"],
-  ["astar-mainnet", "https://astar.blockscout.com/api"],
-  ["aurora", "https://explorer.mainnet.aurora.dev/api"],
-  ["aurora-mainnet", "https://explorer.mainnet.aurora.dev/api"],
-  ["avalanche", "https://api.snowtrace.io/api"],
-  ["avalanche-mainnet", "https://api.snowtrace.io/api"],
-  ["avalanche-testnet", "https://api-testnet.snowtrace.io/api"],
-  ["base", "https://api.basescan.org/api"],
-  ["base-goerli", "https://api-goerli.basescan.org/api"],
-  ["base-mainnet", "https://api.basescan.org/api"],
-  ["blast", "https://api.blastscan.io/api"],
-  ["blast-mainnet", "https://api.blastscan.io/api"],
-  ["bsc", "https://api.bscscan.com/api"],
-  ["bsc-mainnet", "https://api.bscscan.com/api"],
-  ["bsc-testnet", "https://api-testnet.bscscan.com/api"],
-  ["ebi", "https://explorer.ebi.xyz/api"],
-  ["ebi-mainnet", "https://explorer.ebi.xyz/api"],
-  ["ethereum", "https://api.etherscan.io/api"],
-  ["ethereum-goerli", "https://api-goerli.etherscan.io/api"],
-  ["ethereum-mainnet", "https://api.etherscan.io/api"],
-  ["etherlink", "https://explorer.etherlink.com/api"],
-  ["etherlink-mainnet", "https://explorer.etherlink.com/api"],
-  ["fantom", "https://api.ftmscan.com/api"],
-  ["fantom-mainnet", "https://api.ftmscan.com/api"],
-  ["fantom-testnet", "https://api-testnet.ftmscan.com/api"],
-  ["flare", "https://api.routescan.io/v2/network/mainnet/evm/14/etherscan"],
-  ["flare-mainnet", "https://api.routescan.io/v2/network/mainnet/evm/14/etherscan"],
-  ["fraxtal", "https://api.fraxscan.com/api"],
-  ["fraxtal-mainnet", "https://api.fraxscan.com/api"],
-  ["fuji", "https://api-testnet.snowtrace.io/api"],
-  ["fuji-mainnet", "https://api-testnet.snowtrace.io/api"],
-  ["gnosis", "https://api.gnosisscan.io/api"],
-  ["gnosis-mainnet", "https://api.gnosisscan.io/api"],
-  ["goerli", "https://api-goerli.etherscan.io/api"],
-  ["goerli-mainnet", "https://api-goerli.etherscan.io/api"],
-  ["gravity", "https://explorer.gravity.xyz/api"],
-  ["gravity-mainnet", "https://explorer.gravity.xyz/api"],
-  ["iota", "https://explorer.evm.iota.org/api"],
-  ["iota-mainnet", "https://explorer.evm.iota.org/api"],
-  ["kava", "https://kavascan.com/api"],
-  ["kava-mainnet", "https://kavascan.com/api"],
-  ["kava-testnet", "https://testnet.kavascan.com/api"],
-  ["klaytn", "https://api-cypress.klaytnscope.com/api"],
-  ["klaytn-mainnet", "https://api-cypress.klaytnscope.com/api"],
-  ["klaytn-testnet", "https://api-baobab.klaytnscope.com/api"],
-  ["linea", "https://api.lineascan.build/api"],
-  ["linea-mainnet", "https://api.lineascan.build/api"],
-  ["mantle", "https://explorer.mantle.xyz/api"],
-  ["mantle-mainnet", "https://explorer.mantle.xyz/api"],
-  ["manta", "https://pacific-explorer.manta.network/api"],
-  ["manta-mainnet", "https://pacific-explorer.manta.network/api"],
-  ["metis", "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan"],
-  ["metis-mainnet", "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan"],
-  ["mode", "https://explorer.mode.network/api"],
-  ["mode-mainnet", "https://explorer.mode.network/api"],
-  ["moonbeam", "https://api-moonbeam.moonscan.io/api"],
-  ["moonbeam-mainnet", "https://api-moonbeam.moonscan.io/api"],
-  ["moonbeam-testnet", "https://api-moonbase.moonscan.io/api"],
-  ["moonriver", "https://api-moonriver.moonscan.io/api"],
-  ["moonriver-mainnet", "https://api-moonriver.moonscan.io/api"],
-  ["optimism", "https://api-optimistic.etherscan.io/api"],
-  ["optimism-goerli", "https://api-goerli-optimistic.etherscan.io/api"],
-  ["optimism-mainnet", "https://api-optimistic.etherscan.io/api"],
-  ["optsep-testnet", "https://api-sepolia-optimistic.etherscan.io/api"],
-  ["polygon", "https://api.polygonscan.com/api"],
-  ["polygon-mainnet", "https://api.polygonscan.com/api"],
-  ["rarible", "https://mainnet.explorer.rarichain.org/api"],
-  ["rarible-mainnet", "https://mainnet.explorer.rarichain.org/api"],
-  ["sepolia-testnet", "https://api-sepolia.etherscan.io/api"],
-  ["scroll", "https://api.scrollscan.com/api"],
-  ["scroll-mainnet", "https://api.scrollscan.com/api"],
-  ["sei", "https://seitrace.com/pacific-1/api"],
-  ["sei-mainnet", "https://seitrace.com/pacific-1/api"],
-  ["taiko", "https://api.taikoscan.io/api"],
-  ["taiko-mainnet", "https://api.taikoscan.io/api"],
-  ["xchain", "https://xchain-explorer.idex.io/api"],
-  ["xchain-mainnet", "https://xchain-explorer.idex.io/api"],
-  ["xlayer", "https://www.oklink.com/api/v5/explorer/contract/verify-source-code-plugin/XLAYER"],
-  ["xlayer-mainnet", "https://www.oklink.com/api/v5/explorer/contract/verify-source-code-plugin/XLAYER"],
-  ["zkatana", "https://astar-zkevm.explorer.startale.com/api"],
-  ["zkatana-mainnet", "https://astar-zkevm.explorer.startale.com/api"],
-  ["zkconsensys", "https://api.lineascan.build/api"],
-  ["zkconsensys-mainnet", "https://api.lineascan.build/api"],
-  ["zkpolygon", "https://api-zkevm.polygonscan.com/api"],
-  ["zkpolygon-mainnet", "https://api-zkevm.polygonscan.com/api"]
-]);
 
 // src/common/logger.ts
 var import_chalk = __toESM(require_source());
@@ -64958,16 +65412,16 @@ var anonymizeValue = (value) => {
   const invisiblePart = Array.from({ length: invisibleLength }).fill("*").join("");
   return `${visiblePart}${invisiblePart}`;
 };
-var createRecordLogger = (logger11, separator = "	") => (record) => {
-  logger11.info("");
+var createRecordLogger = (logger12, separator = "	") => (record) => {
+  logger12.info("");
   Object.entries(record).forEach(([label, value]) => {
     if (Array.isArray(value)) {
-      logger11.info(`${label}:`);
+      logger12.info(`${label}:`);
       value.forEach((item) => {
-        logger11.info(`${separator}	- ${import_chalk.default.bold(formatLoggableValue(item))}`);
+        logger12.info(`${separator}	- ${import_chalk.default.bold(formatLoggableValue(item))}`);
       });
     } else {
-      logger11.info(`${label}:${separator}${import_chalk.default.bold(formatLoggableValue(value))}`);
+      logger12.info(`${label}:${separator}${import_chalk.default.bold(formatLoggableValue(value))}`);
     }
   });
 };
@@ -64987,7 +65441,7 @@ var FALSE_SYMBOL = COLORS.error`⚠`;
 
 // src/common/config.ts
 var import_chalk2 = __toESM(require_source());
-var parseNetworksConfig = (logger11, partialNetworksConfig) => {
+var parseNetworksConfig = (logger12, partialNetworksConfig) => {
   return Object.entries(partialNetworksConfig != null ? partialNetworksConfig : {}).reduce((networksConfig, [networkName, networkConfig]) => {
     if (networkConfig == null) {
       return networksConfig;
@@ -65006,7 +65460,7 @@ Please provide the API URL:
     );
     const apiKey = networkConfig.apiKey || getScanApiKeyFromEnv(networkName);
     if (!apiKey) {
-      logger11.debug(`Could not find scan API key for network ${import_chalk2.default.bold(networkName)}
+      logger12.debug(`Could not find scan API key for network ${import_chalk2.default.bold(networkName)}
         
 Please provide the API key:
 
@@ -65016,7 +65470,7 @@ Please provide the API key:
     }
     const browserUrl = networkConfig.browserUrl || getScanBrowserUrlFromEnv(networkName) || tryGetScanBrowserUrlFromScanUrl(apiUrl);
     if (!browserUrl) {
-      logger11.debug(`Could not find scan browser URL key for network ${import_chalk2.default.bold(networkName)}
+      logger12.debug(`Could not find scan browser URL key for network ${import_chalk2.default.bold(networkName)}
 
   Browser URL is used to display a link to the verified contract
   after successful verification.
@@ -65026,10 +65480,22 @@ Please provide the API key:
   - As an browserUrl config parameter in ${networkName} config
   - As a SCAN_BROWSER_URL_${networkName} environment variable
   - As a SCAN_BROWSER_URL_${normalizeNetworkName(networkName)} environment variable`);
+    }
+    const chainId = networkConfig.chainId || getChainIdFromEnv(networkName) || getDefaultChainId(networkName);
+    if (!chainId) {
+      logger12.debug(`Could not find chain ID for network ${import_chalk2.default.bold(networkName)}
+
+  Chain ID is required for Etherscan API v2.
+
+  Please provide the chain ID:
+ 
+  - As a chainId config parameter in ${networkName} config
+  - As a SCAN_CHAIN_ID_${networkName} environment variable
+  - As a SCAN_CHAIN_ID_${normalizeNetworkName(networkName)} environment variable`);
     }
     return {
       ...networksConfig,
-      [networkName]: { apiUrl, apiKey, browserUrl }
+      [networkName]: { apiUrl, apiKey, browserUrl, chainId }
     };
   }, {});
 };
@@ -65045,6 +65511,11 @@ var getScanApiKeyFromEnv = (networkName) => {
   var _a, _b;
   return ((_a = process.env[`SCAN_API_KEY_${networkName}`]) == null ? void 0 : _a.trim()) || ((_b = process.env[`SCAN_API_KEY_${normalizeNetworkName(networkName)}`]) == null ? void 0 : _b.trim());
 };
+var getChainIdFromEnv = (networkName) => {
+  var _a, _b;
+  const chainIdStr = ((_a = process.env[`SCAN_CHAIN_ID_${networkName}`]) == null ? void 0 : _a.trim()) || ((_b = process.env[`SCAN_CHAIN_ID_${normalizeNetworkName(networkName)}`]) == null ? void 0 : _b.trim());
+  return chainIdStr ? parseInt(chainIdStr, 10) : void 0;
+};
 var normalizeNetworkName = (networkName) => networkName.toUpperCase().replaceAll("-", "_");
 
 // src/common/licenses.ts
@@ -68829,9 +69300,15 @@ var LogLevel = /* @__PURE__ */ ((LogLevel22) => {
   return LogLevel22;
 })(LogLevel || {});
 z.nativeEnum(LogLevel);
-(0, import_winston.format)((info, { label }) => ({
+var DEFAULT_LOG_LEVEL = "info";
+var createLogger = (level = DEFAULT_LOG_LEVEL, logFormat = import_winston.format.cli()) => (0, import_winston.createLogger)({
+  level,
+  format: logFormat,
+  transports: [new import_winston.transports.Console()]
+});
+(0, import_winston.format)((info, opts) => ({
   ...info,
-  message: `${label ? `[${label}] ` : ""}${info.message}`
+  message: `${(opts == null ? void 0 : opts.label) ? `[${opts.label}] ` : ""}${info.message}`
 }));
 ({
   TRUE: import_chalk3.default.rgb(0, 153, 0),
@@ -68845,6 +69322,7 @@ z.nativeEnum(LogLevel);
   DEFAULT_VALUE: import_chalk3.default.rgb(167, 125, 255)
   // MAGENTA
 });
+createLogger();
 var retry = async (callback, numAttempts, onRetry) => {
   assert4(numAttempts > 0, `Number of attempts for retry must be larger than 0, got ${numAttempts}`);
   for (let attempt = 0; attempt < numAttempts - 1; attempt++) {
@@ -74032,10 +74510,10 @@ var source_default2 = got;
 
 // src/common/etherscan.ts
 var Verification = class extends EventEmitter {
-  constructor(props, logger11) {
+  constructor(props, logger12) {
     super();
     this.props = props;
-    this.logger = logger11;
+    this.logger = logger12;
   }
   async verify() {
     try {
@@ -74073,7 +74551,7 @@ var Verification = class extends EventEmitter {
 ${JSON.stringify(request)}`);
     return await retry(
       async () => {
-        const response = await submitRequest(this.props.apiUrl, request);
+        const response = await submitRequest(this.props.apiUrl, request, this.props.chainId, this.props.apiKey);
         this.logger.verbose(`Received raw response from ${this.props.apiUrl}:
 
 ${JSON.stringify(response)}`);
@@ -74094,7 +74572,7 @@ ${JSON.stringify(response)}`);
   async __poll(guid) {
     while (true) {
       this.emit("poll", guid);
-      const result = await checkGuid(this.props.apiUrl, guid);
+      const result = await checkGuid(this.props.apiUrl, guid, this.props.chainId, this.props.apiKey);
       this.logger.verbose(`Received raw polling response from ${this.props.apiUrl}:
 
 ${JSON.stringify(result)}`);
@@ -74122,29 +74600,37 @@ ${JSON.stringify(result)}`);
     }
   }
 };
-var createVerification = (props, logger11) => new Verification(props, logger11);
+var createVerification = (props, logger12) => new Verification(props, logger12);
 var isPendingResult = (result) => !!(result == null ? void 0 : result.match(/Pending/gi));
 var isAlreadyVerifiedResult = (result) => !!(result == null ? void 0 : result.match(/already verified/gi));
 var isApiRateLimitedResult = (result) => !!(result == null ? void 0 : result.match(/rate/));
-var submitRequest = async (apiUrl, request) => {
-  try {
-    const response = await source_default2(apiUrl, {
-      method: "POST",
-      form: request,
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
-      }
-    }).json();
-    return ScanResponseSchema.parse(response);
-  } catch (error) {
-    throw new Error(`Failed to submit verification request: ${error}`);
-  }
+var submitRequest = async (apiUrl, request, chainId, apiKey) => {
+  const url = new URL(apiUrl);
+  const isEtherscanV2 = apiUrl.includes("api.etherscan.io/v2");
+  if (chainId !== void 0 && isEtherscanV2) {
+    url.searchParams.set("chainid", String(chainId));
+  }
+  if (apiKey) {
+    url.searchParams.set("apikey", apiKey);
+  }
+  const response = await source_default2(url.toString(), {
+    method: "POST",
+    form: request
+  }).json();
+  return ScanResponseSchema.parse(response);
 };
-var checkGuid = async (apiUrl, guid) => {
+var checkGuid = async (apiUrl, guid, chainId, apiKey) => {
   const url = new URL(apiUrl);
   url.searchParams.set("module", "contract");
   url.searchParams.set("action", "checkverifystatus");
   url.searchParams.set("guid", guid);
+  const isEtherscanV2 = apiUrl.includes("api.etherscan.io/v2");
+  if (chainId !== void 0 && isEtherscanV2) {
+    url.searchParams.set("chainid", String(chainId));
+  }
+  if (apiKey) {
+    url.searchParams.set("apikey", apiKey);
+  }
   try {
     const data = await source_default2(url).json();
     return ScanResponseSchema.parse(data);
@@ -74567,7 +75053,7 @@ Logger.levels = LogLevel2;
 var version2 = "bytes/5.7.0";
 
 // ../../node_modules/.pnpm/@ethersproject+bytes@5.7.0/node_modules/@ethersproject/bytes/lib.esm/index.js
-var logger = new Logger(version2);
+var logger2 = new Logger(version2);
 function isHexable(value) {
   return !!value.toHexString;
 }
@@ -74610,7 +75096,7 @@ function arrayify(value, options) {
     options = {};
   }
   if (typeof value === "number") {
-    logger.checkSafeUint53(value, "invalid arrayify value");
+    logger2.checkSafeUint53(value, "invalid arrayify value");
     const result = [];
     while (value) {
       result.unshift(value & 255);
@@ -74635,7 +75121,7 @@ function arrayify(value, options) {
       } else if (options.hexPad === "right") {
         hex += "0";
       } else {
-        logger.throwArgumentError("hex data is odd-length", "value", value);
+        logger2.throwArgumentError("hex data is odd-length", "value", value);
       }
     }
     const result = [];
@@ -74647,7 +75133,7 @@ function arrayify(value, options) {
   if (isBytes(value)) {
     return addSlice(new Uint8Array(value));
   }
-  return logger.throwArgumentError("invalid arrayify value", "value", value);
+  return logger2.throwArgumentError("invalid arrayify value", "value", value);
 }
 function concat(items) {
   const objects = items.map((item) => arrayify(item));
@@ -74674,7 +75160,7 @@ function hexlify(value, options) {
     options = {};
   }
   if (typeof value === "number") {
-    logger.checkSafeUint53(value, "invalid hexlify value");
+    logger2.checkSafeUint53(value, "invalid hexlify value");
     let hex = "";
     while (value) {
       hex = HexCharacters[value & 15] + hex;
@@ -74708,7 +75194,7 @@ function hexlify(value, options) {
       } else if (options.hexPad === "right") {
         value += "0";
       } else {
-        logger.throwArgumentError("hex data is odd-length", "value", value);
+        logger2.throwArgumentError("hex data is odd-length", "value", value);
       }
     }
     return value.toLowerCase();
@@ -74721,13 +75207,13 @@ function hexlify(value, options) {
     }
     return result;
   }
-  return logger.throwArgumentError("invalid hexlify value", "value", value);
+  return logger2.throwArgumentError("invalid hexlify value", "value", value);
 }
 function hexDataSlice(data, offset, endOffset) {
   if (typeof data !== "string") {
     data = hexlify(data);
   } else if (!isHexString(data) || data.length % 2) {
-    logger.throwArgumentError("invalid hexData", "value", data);
+    logger2.throwArgumentError("invalid hexData", "value", data);
   }
   offset = 2 + 2 * offset;
   if (endOffset != null) {
@@ -74746,10 +75232,10 @@ function hexZeroPad(value, length) {
   if (typeof value !== "string") {
     value = hexlify(value);
   } else if (!isHexString(value)) {
-    logger.throwArgumentError("invalid hex string", "value", value);
+    logger2.throwArgumentError("invalid hex string", "value", value);
   }
   if (value.length > 2 * length + 2) {
-    logger.throwArgumentError("value out of range", "value", arguments[1]);
+    logger2.throwArgumentError("value out of range", "value", arguments[1]);
   }
   while (value.length < 2 * length + 2) {
     value = "0x0" + value.substring(2);
@@ -74762,14 +75248,14 @@ var version3 = "bignumber/5.7.0";
 
 // ../../node_modules/.pnpm/@ethersproject+bignumber@5.7.0/node_modules/@ethersproject/bignumber/lib.esm/bignumber.js
 var BN = import_bn.default.BN;
-var logger2 = new Logger(version3);
+var logger3 = new Logger(version3);
 var _constructorGuard = {};
 var MAX_SAFE = 9007199254740991;
 var _warnedToStringRadix = false;
 var BigNumber = class _BigNumber {
   constructor(constructorGuard, hex) {
     if (constructorGuard !== _constructorGuard) {
-      logger2.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, {
+      logger3.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "new (BigNumber)"
       });
     }
@@ -74892,7 +75378,7 @@ var BigNumber = class _BigNumber {
       return BigInt(this.toString());
     } catch (e) {
     }
-    return logger2.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, {
+    return logger3.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, {
       value: this.toString()
     });
   }
@@ -74901,12 +75387,12 @@ var BigNumber = class _BigNumber {
       if (arguments[0] === 10) {
         if (!_warnedToStringRadix) {
           _warnedToStringRadix = true;
-          logger2.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
+          logger3.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
         }
       } else if (arguments[0] === 16) {
-        logger2.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger.errors.UNEXPECTED_ARGUMENT, {});
+        logger3.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger.errors.UNEXPECTED_ARGUMENT, {});
       } else {
-        logger2.throwError("BigNumber.toString does not accept parameters", Logger.errors.UNEXPECTED_ARGUMENT, {});
+        logger3.throwError("BigNumber.toString does not accept parameters", Logger.errors.UNEXPECTED_ARGUMENT, {});
       }
     }
     return toBN(this).toString(10);
@@ -74928,7 +75414,7 @@ var BigNumber = class _BigNumber {
       if (value.match(/^-?[0-9]+$/)) {
         return new _BigNumber(_constructorGuard, toHex(new BN(value)));
       }
-      return logger2.throwArgumentError("invalid BigNumber string", "value", value);
+      return logger3.throwArgumentError("invalid BigNumber string", "value", value);
     }
     if (typeof value === "number") {
       if (value % 1) {
@@ -74964,7 +75450,7 @@ var BigNumber = class _BigNumber {
         }
       }
     }
-    return logger2.throwArgumentError("invalid BigNumber value", "value", value);
+    return logger3.throwArgumentError("invalid BigNumber value", "value", value);
   }
   static isBigNumber(value) {
     return !!(value && value._isBigNumber);
@@ -74977,7 +75463,7 @@ function toHex(value) {
   if (value[0] === "-") {
     value = value.substring(1);
     if (value[0] === "-") {
-      logger2.throwArgumentError("invalid hex", "value", value);
+      logger3.throwArgumentError("invalid hex", "value", value);
     }
     value = toHex(value);
     if (value === "0x00") {
@@ -75014,7 +75500,7 @@ function throwFault(fault, operation, value) {
   if (value != null) {
     params.value = value;
   }
-  return logger2.throwError(fault, Logger.errors.NUMERIC_FAULT, params);
+  return logger3.throwError(fault, Logger.errors.NUMERIC_FAULT, params);
 }
 function _base36To16(value) {
   return new BN(value, 36).toString(16);
@@ -75024,7 +75510,7 @@ function _base36To16(value) {
 var version4 = "properties/5.7.0";
 
 // ../../node_modules/.pnpm/@ethersproject+properties@5.7.0/node_modules/@ethersproject/properties/lib.esm/index.js
-var logger3 = new Logger(version4);
+var logger4 = new Logger(version4);
 function defineReadOnly(object, name, value) {
   Object.defineProperty(object, name, {
     enumerable: true,
@@ -75067,7 +75553,7 @@ function _isFrozen(object) {
     }
     return true;
   }
-  return logger3.throwArgumentError(`Cannot deepCopy ${typeof object}`, "object", object);
+  return logger4.throwArgumentError(`Cannot deepCopy ${typeof object}`, "object", object);
 }
 function _deepCopy(object) {
   if (_isFrozen(object)) {
@@ -75087,7 +75573,7 @@ function _deepCopy(object) {
     }
     return result;
   }
-  return logger3.throwArgumentError(`Cannot deepCopy ${typeof object}`, "object", object);
+  return logger4.throwArgumentError(`Cannot deepCopy ${typeof object}`, "object", object);
 }
 function deepCopy(object) {
   return _deepCopy(object);
@@ -75104,7 +75590,7 @@ var Description = class {
 var version5 = "abi/5.7.0";
 
 // ../../node_modules/.pnpm/@ethersproject+abi@5.7.0/node_modules/@ethersproject/abi/lib.esm/fragments.js
-var logger4 = new Logger(version5);
+var logger5 = new Logger(version5);
 var _constructorGuard2 = {};
 var ModifiersBytes = { calldata: true, memory: true, storage: true };
 var ModifiersNest = { calldata: true, memory: true };
@@ -75123,14 +75609,14 @@ function checkModifier(type, name) {
     }
   }
   if (ModifiersBytes[name] || name === "payable") {
-    logger4.throwArgumentError("invalid modifier", "name", name);
+    logger5.throwArgumentError("invalid modifier", "name", name);
   }
   return false;
 }
 function parseParamType(param, allowIndexed) {
   let originalParam = param;
   function throwError(i) {
-    logger4.throwArgumentError(`unexpected character at position ${i}`, "param", param);
+    logger5.throwArgumentError(`unexpected character at position ${i}`, "param", param);
   }
   param = param.replace(/\s/g, " ");
   function newNode(parent2) {
@@ -75259,7 +75745,7 @@ function parseParamType(param, allowIndexed) {
     }
   }
   if (node.parent) {
-    logger4.throwArgumentError("unexpected eof", "param", param);
+    logger5.throwArgumentError("unexpected eof", "param", param);
   }
   delete parent.state;
   if (node.name === "indexed") {
@@ -75296,7 +75782,7 @@ var paramTypeArray = new RegExp(/^(.*)\[([0-9]*)\]$/);
 var ParamType = class _ParamType {
   constructor(constructorGuard, params) {
     if (constructorGuard !== _constructorGuard2) {
-      logger4.throwError("use fromString", Logger.errors.UNSUPPORTED_OPERATION, {
+      logger5.throwError("use fromString", Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "new ParamType()"
       });
     }
@@ -75330,7 +75816,7 @@ var ParamType = class _ParamType {
       format3 = FormatTypes.sighash;
     }
     if (!FormatTypes[format3]) {
-      logger4.throwArgumentError("invalid format type", "format", format3);
+      logger5.throwArgumentError("invalid format type", "format", format3);
     }
     if (format3 === FormatTypes.json) {
       let result2 = {
@@ -75407,7 +75893,7 @@ function parseParams(value, allowIndex) {
 var Fragment = class _Fragment {
   constructor(constructorGuard, params) {
     if (constructorGuard !== _constructorGuard2) {
-      logger4.throwError("use a static from method", Logger.errors.UNSUPPORTED_OPERATION, {
+      logger5.throwError("use a static from method", Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "new Fragment()"
       });
     }
@@ -75441,7 +75927,7 @@ var Fragment = class _Fragment {
       case "receive":
         return null;
     }
-    return logger4.throwArgumentError("invalid fragment object", "value", value);
+    return logger5.throwArgumentError("invalid fragment object", "value", value);
   }
   static fromString(value) {
     value = value.replace(/\s/g, " ");
@@ -75456,7 +75942,7 @@ var Fragment = class _Fragment {
     } else if (value.split(" ")[0] === "error") {
       return ErrorFragment.fromString(value.substring(5).trim());
     }
-    return logger4.throwArgumentError("unsupported fragment", "value", value);
+    return logger5.throwArgumentError("unsupported fragment", "value", value);
   }
   static isFragment(value) {
     return !!(value && value._isFragment);
@@ -75468,7 +75954,7 @@ var EventFragment = class _EventFragment extends Fragment {
       format3 = FormatTypes.sighash;
     }
     if (!FormatTypes[format3]) {
-      logger4.throwArgumentError("invalid format type", "format", format3);
+      logger5.throwArgumentError("invalid format type", "format", format3);
     }
     if (format3 === FormatTypes.json) {
       return JSON.stringify({
@@ -75501,7 +75987,7 @@ var EventFragment = class _EventFragment extends Fragment {
       return value;
     }
     if (value.type !== "event") {
-      logger4.throwArgumentError("invalid event object", "value", value);
+      logger5.throwArgumentError("invalid event object", "value", value);
     }
     const params = {
       name: verifyIdentifier(value.name),
@@ -75514,7 +76000,7 @@ var EventFragment = class _EventFragment extends Fragment {
   static fromString(value) {
     let match = value.match(regexParen);
     if (!match) {
-      logger4.throwArgumentError("invalid event string", "value", value);
+      logger5.throwArgumentError("invalid event string", "value", value);
     }
     let anonymous = false;
     match[3].split(" ").forEach((modifier) => {
@@ -75525,7 +76011,7 @@ var EventFragment = class _EventFragment extends Fragment {
         case "":
           break;
         default:
-          logger4.warn("unknown modifier: " + modifier);
+          logger5.warn("unknown modifier: " + modifier);
       }
     });
     return _EventFragment.fromObject({
@@ -75544,10 +76030,10 @@ function parseGas(value, params) {
   let comps = value.split("@");
   if (comps.length !== 1) {
     if (comps.length > 2) {
-      logger4.throwArgumentError("invalid human-readable ABI signature", "value", value);
+      logger5.throwArgumentError("invalid human-readable ABI signature", "value", value);
     }
     if (!comps[1].match(/^[0-9]+$/)) {
-      logger4.throwArgumentError("invalid human-readable ABI signature gas", "value", value);
+      logger5.throwArgumentError("invalid human-readable ABI signature gas", "value", value);
     }
     params.gas = BigNumber.from(comps[1]);
     return comps[0];
@@ -75599,19 +76085,19 @@ function verifyState(value) {
     result.constant = result.stateMutability === "view" || result.stateMutability === "pure";
     if (value.constant != null) {
       if (!!value.constant !== result.constant) {
-        logger4.throwArgumentError("cannot have constant function with mutability " + result.stateMutability, "value", value);
+        logger5.throwArgumentError("cannot have constant function with mutability " + result.stateMutability, "value", value);
       }
     }
     result.payable = result.stateMutability === "payable";
     if (value.payable != null) {
       if (!!value.payable !== result.payable) {
-        logger4.throwArgumentError("cannot have payable function with mutability " + result.stateMutability, "value", value);
+        logger5.throwArgumentError("cannot have payable function with mutability " + result.stateMutability, "value", value);
       }
     }
   } else if (value.payable != null) {
     result.payable = !!value.payable;
     if (value.constant == null && !result.payable && value.type !== "constructor") {
-      logger4.throwArgumentError("unable to determine stateMutability", "value", value);
+      logger5.throwArgumentError("unable to determine stateMutability", "value", value);
     }
     result.constant = !!value.constant;
     if (result.constant) {
@@ -75620,14 +76106,14 @@ function verifyState(value) {
       result.stateMutability = result.payable ? "payable" : "nonpayable";
     }
     if (result.payable && result.constant) {
-      logger4.throwArgumentError("cannot have constant payable function", "value", value);
+      logger5.throwArgumentError("cannot have constant payable function", "value", value);
     }
   } else if (value.constant != null) {
     result.constant = !!value.constant;
     result.payable = !result.constant;
     result.stateMutability = result.constant ? "view" : "payable";
   } else if (value.type !== "constructor") {
-    logger4.throwArgumentError("unable to determine stateMutability", "value", value);
+    logger5.throwArgumentError("unable to determine stateMutability", "value", value);
   }
   return result;
 }
@@ -75637,7 +76123,7 @@ var ConstructorFragment = class _ConstructorFragment extends Fragment {
       format3 = FormatTypes.sighash;
     }
     if (!FormatTypes[format3]) {
-      logger4.throwArgumentError("invalid format type", "format", format3);
+      logger5.throwArgumentError("invalid format type", "format", format3);
     }
     if (format3 === FormatTypes.json) {
       return JSON.stringify({
@@ -75649,7 +76135,7 @@ var ConstructorFragment = class _ConstructorFragment extends Fragment {
       });
     }
     if (format3 === FormatTypes.sighash) {
-      logger4.throwError("cannot format a constructor for sighash", Logger.errors.UNSUPPORTED_OPERATION, {
+      logger5.throwError("cannot format a constructor for sighash", Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "format(sighash)"
       });
     }
@@ -75670,11 +76156,11 @@ var ConstructorFragment = class _ConstructorFragment extends Fragment {
       return value;
     }
     if (value.type !== "constructor") {
-      logger4.throwArgumentError("invalid constructor object", "value", value);
+      logger5.throwArgumentError("invalid constructor object", "value", value);
     }
     let state = verifyState(value);
     if (state.constant) {
-      logger4.throwArgumentError("constructor cannot be constant", "value", value);
+      logger5.throwArgumentError("constructor cannot be constant", "value", value);
     }
     const params = {
       name: null,
@@ -75691,7 +76177,7 @@ var ConstructorFragment = class _ConstructorFragment extends Fragment {
     value = parseGas(value, params);
     let parens = value.match(regexParen);
     if (!parens || parens[1].trim() !== "constructor") {
-      logger4.throwArgumentError("invalid constructor string", "value", value);
+      logger5.throwArgumentError("invalid constructor string", "value", value);
     }
     params.inputs = parseParams(parens[2].trim(), false);
     parseModifiers(parens[3].trim(), params);
@@ -75707,7 +76193,7 @@ var FunctionFragment = class _FunctionFragment extends ConstructorFragment {
       format3 = FormatTypes.sighash;
     }
     if (!FormatTypes[format3]) {
-      logger4.throwArgumentError("invalid format type", "format", format3);
+      logger5.throwArgumentError("invalid format type", "format", format3);
     }
     if (format3 === FormatTypes.json) {
       return JSON.stringify({
@@ -75754,7 +76240,7 @@ var FunctionFragment = class _FunctionFragment extends ConstructorFragment {
       return value;
     }
     if (value.type !== "function") {
-      logger4.throwArgumentError("invalid function object", "value", value);
+      logger5.throwArgumentError("invalid function object", "value", value);
     }
     let state = verifyState(value);
     const params = {
@@ -75774,11 +76260,11 @@ var FunctionFragment = class _FunctionFragment extends ConstructorFragment {
     value = parseGas(value, params);
     let comps = value.split(" returns ");
     if (comps.length > 2) {
-      logger4.throwArgumentError("invalid function string", "value", value);
+      logger5.throwArgumentError("invalid function string", "value", value);
     }
     let parens = comps[0].match(regexParen);
     if (!parens) {
-      logger4.throwArgumentError("invalid function signature", "value", value);
+      logger5.throwArgumentError("invalid function signature", "value", value);
     }
     params.name = parens[1].trim();
     if (params.name) {
@@ -75789,7 +76275,7 @@ var FunctionFragment = class _FunctionFragment extends ConstructorFragment {
     if (comps.length > 1) {
       let returns = comps[1].match(regexParen);
       if (returns[1].trim() != "" || returns[3].trim() != "") {
-        logger4.throwArgumentError("unexpected tokens", "value", value);
+        logger5.throwArgumentError("unexpected tokens", "value", value);
       }
       params.outputs = parseParams(returns[2], false);
     } else {
@@ -75804,7 +76290,7 @@ var FunctionFragment = class _FunctionFragment extends ConstructorFragment {
 function checkForbidden(fragment) {
   const sig = fragment.format();
   if (sig === "Error(string)" || sig === "Panic(uint256)") {
-    logger4.throwArgumentError(`cannot specify user defined ${sig} error`, "fragment", fragment);
+    logger5.throwArgumentError(`cannot specify user defined ${sig} error`, "fragment", fragment);
   }
   return fragment;
 }
@@ -75814,7 +76300,7 @@ var ErrorFragment = class _ErrorFragment extends Fragment {
       format3 = FormatTypes.sighash;
     }
     if (!FormatTypes[format3]) {
-      logger4.throwArgumentError("invalid format type", "format", format3);
+      logger5.throwArgumentError("invalid format type", "format", format3);
     }
     if (format3 === FormatTypes.json) {
       return JSON.stringify({
@@ -75841,7 +76327,7 @@ var ErrorFragment = class _ErrorFragment extends Fragment {
       return value;
     }
     if (value.type !== "error") {
-      logger4.throwArgumentError("invalid error object", "value", value);
+      logger5.throwArgumentError("invalid error object", "value", value);
     }
     const params = {
       type: value.type,
@@ -75854,7 +76340,7 @@ var ErrorFragment = class _ErrorFragment extends Fragment {
     let params = { type: "error" };
     let parens = value.match(regexParen);
     if (!parens) {
-      logger4.throwArgumentError("invalid error signature", "value", value);
+      logger5.throwArgumentError("invalid error signature", "value", value);
     }
     params.name = parens[1].trim();
     if (params.name) {
@@ -75878,7 +76364,7 @@ function verifyType(type) {
 var regexIdentifier = new RegExp("^[a-zA-Z$_][a-zA-Z0-9$_]*$");
 function verifyIdentifier(value) {
   if (!value || !value.match(regexIdentifier)) {
-    logger4.throwArgumentError(`invalid identifier "${value}"`, "value", value);
+    logger5.throwArgumentError(`invalid identifier "${value}"`, "value", value);
   }
   return value;
 }
@@ -75900,7 +76386,7 @@ function splitNesting(value) {
       } else if (c === ")") {
         depth--;
         if (depth === -1) {
-          logger4.throwArgumentError("unbalanced parenthesis", "value", value);
+          logger5.throwArgumentError("unbalanced parenthesis", "value", value);
         }
       }
     }
@@ -75912,7 +76398,7 @@ function splitNesting(value) {
 }
 
 // ../../node_modules/.pnpm/@ethersproject+abi@5.7.0/node_modules/@ethersproject/abi/lib.esm/coders/abstract-coder.js
-var logger5 = new Logger(version5);
+var logger6 = new Logger(version5);
 var Coder = class {
   constructor(name, type, localName, dynamic) {
     this.name = name;
@@ -75921,7 +76407,7 @@ var Coder = class {
     this.dynamic = dynamic;
   }
   _throwError(message, value) {
-    logger5.throwArgumentError(message, this.localName, value);
+    logger6.throwArgumentError(message, this.localName, value);
   }
 };
 var Writer = class {
@@ -75957,7 +76443,7 @@ var Writer = class {
   _getValue(value) {
     let bytes = arrayify(BigNumber.from(value));
     if (bytes.length > this.wordSize) {
-      logger5.throwError("value out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
+      logger6.throwError("value out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
         length: this.wordSize,
         offset: bytes.length
       });
@@ -76014,7 +76500,7 @@ var Reader = class _Reader {
       if (this.allowLoose && loose && this._offset + length <= this._data.length) {
         alignedLength = length;
       } else {
-        logger5.throwError("data out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
+        logger6.throwError("data out-of-bounds", Logger.errors.BUFFER_OVERRUN, {
           length: this._data.length,
           offset: this._offset + alignedLength
         });
@@ -76045,10 +76531,10 @@ function keccak256(data) {
 var version6 = "address/5.7.0";
 
 // ../../node_modules/.pnpm/@ethersproject+address@5.7.0/node_modules/@ethersproject/address/lib.esm/index.js
-var logger6 = new Logger(version6);
+var logger7 = new Logger(version6);
 function getChecksumAddress(address) {
   if (!isHexString(address, 20)) {
-    logger6.throwArgumentError("invalid address", "address", address);
+    logger7.throwArgumentError("invalid address", "address", address);
   }
   address = address.toLowerCase();
   const chars = address.substring(2).split("");
@@ -76101,7 +76587,7 @@ function ibanChecksum(address) {
 function getAddress(address) {
   let result = null;
   if (typeof address !== "string") {
-    logger6.throwArgumentError("invalid address", "address", address);
+    logger7.throwArgumentError("invalid address", "address", address);
   }
   if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
     if (address.substring(0, 2) !== "0x") {
@@ -76109,11 +76595,11 @@ function getAddress(address) {
     }
     result = getChecksumAddress(address);
     if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && result !== address) {
-      logger6.throwArgumentError("bad address checksum", "address", address);
+      logger7.throwArgumentError("bad address checksum", "address", address);
     }
   } else if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
     if (address.substring(2, 4) !== ibanChecksum(address)) {
-      logger6.throwArgumentError("bad icap checksum", "address", address);
+      logger7.throwArgumentError("bad icap checksum", "address", address);
     }
     result = _base36To16(address.substring(4));
     while (result.length < 40) {
@@ -76121,7 +76607,7 @@ function getAddress(address) {
     }
     result = getChecksumAddress("0x" + result);
   } else {
-    logger6.throwArgumentError("invalid address", "address", address);
+    logger7.throwArgumentError("invalid address", "address", address);
   }
   return result;
 }
@@ -76165,7 +76651,7 @@ var AnonymousCoder = class extends Coder {
 };
 
 // ../../node_modules/.pnpm/@ethersproject+abi@5.7.0/node_modules/@ethersproject/abi/lib.esm/coders/array.js
-var logger7 = new Logger(version5);
+var logger8 = new Logger(version5);
 function pack(writer, coders, values) {
   let arrayValues = null;
   if (Array.isArray(values)) {
@@ -76175,14 +76661,14 @@ function pack(writer, coders, values) {
     arrayValues = coders.map((coder) => {
       const name = coder.localName;
       if (!name) {
-        logger7.throwError("cannot encode object for signature with missing names", Logger.errors.INVALID_ARGUMENT, {
+        logger8.throwError("cannot encode object for signature with missing names", Logger.errors.INVALID_ARGUMENT, {
           argument: "values",
           coder,
           value: values
         });
       }
       if (unique[name]) {
-        logger7.throwError("cannot encode object for signature with duplicate names", Logger.errors.INVALID_ARGUMENT, {
+        logger8.throwError("cannot encode object for signature with duplicate names", Logger.errors.INVALID_ARGUMENT, {
           argument: "values",
           coder,
           value: values
@@ -76192,10 +76678,10 @@ function pack(writer, coders, values) {
       return values[name];
     });
   } else {
-    logger7.throwArgumentError("invalid tuple value", "tuple", values);
+    logger8.throwArgumentError("invalid tuple value", "tuple", values);
   }
   if (coders.length !== arrayValues.length) {
-    logger7.throwArgumentError("types/value length mismatch", "tuple", values);
+    logger8.throwArgumentError("types/value length mismatch", "tuple", values);
   }
   let staticWriter = new Writer(writer.wordSize);
   let dynamicWriter = new Writer(writer.wordSize);
@@ -76327,7 +76813,7 @@ var ArrayCoder = class extends Coder {
       count = value.length;
       writer.writeValue(value.length);
     }
-    logger7.checkArgumentCount(value.length, count, "coder array" + (this.localName ? " " + this.localName : ""));
+    logger8.checkArgumentCount(value.length, count, "coder array" + (this.localName ? " " + this.localName : ""));
     let coders = [];
     for (let i = 0; i < value.length; i++) {
       coders.push(this.coder);
@@ -76339,7 +76825,7 @@ var ArrayCoder = class extends Coder {
     if (count === -1) {
       count = reader.readValue().toNumber();
       if (count * 32 > reader._data.length) {
-        logger7.throwError("insufficient data length", Logger.errors.BUFFER_OVERRUN, {
+        logger8.throwError("insufficient data length", Logger.errors.BUFFER_OVERRUN, {
           length: reader._data.length,
           count
         });
@@ -76485,7 +76971,7 @@ var NumberCoder = class extends Coder {
 var version7 = "strings/5.7.0";
 
 // ../../node_modules/.pnpm/@ethersproject+strings@5.7.0/node_modules/@ethersproject/strings/lib.esm/utf8.js
-var logger8 = new Logger(version7);
+var logger9 = new Logger(version7);
 var UnicodeNormalizationForm;
 (function(UnicodeNormalizationForm2) {
   UnicodeNormalizationForm2["current"] = "";
@@ -76505,7 +76991,7 @@ var Utf8ErrorReason;
   Utf8ErrorReason2["OVERLONG"] = "overlong representation";
 })(Utf8ErrorReason || (Utf8ErrorReason = {}));
 function errorFunc(reason, offset, bytes, output, badCodepoint) {
-  return logger8.throwArgumentError(`invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
+  return logger9.throwArgumentError(`invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
 }
 function ignoreFunc(reason, offset, bytes, output, badCodepoint) {
   if (reason === Utf8ErrorReason.BAD_PREFIX || reason === Utf8ErrorReason.UNEXPECTED_CONTINUE) {
@@ -76604,7 +77090,7 @@ function getUtf8CodePoints(bytes, onError) {
 }
 function toUtf8Bytes(str, form = UnicodeNormalizationForm.current) {
   if (form != UnicodeNormalizationForm.current) {
-    logger8.checkNormalize();
+    logger9.checkNormalize();
     str = str.normalize(form);
   }
   let result = [];
@@ -76717,7 +77203,7 @@ var TupleCoder = class extends Coder {
 };
 
 // ../../node_modules/.pnpm/@ethersproject+abi@5.7.0/node_modules/@ethersproject/abi/lib.esm/abi-coder.js
-var logger9 = new Logger(version5);
+var logger10 = new Logger(version5);
 var paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
 var paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
 var AbiCoder = class {
@@ -76747,7 +77233,7 @@ var AbiCoder = class {
     if (match) {
       let size = parseInt(match[2] || "256");
       if (size === 0 || size > 256 || size % 8 !== 0) {
-        logger9.throwArgumentError("invalid " + match[1] + " bit length", "param", param);
+        logger10.throwArgumentError("invalid " + match[1] + " bit length", "param", param);
       }
       return new NumberCoder(size / 8, match[1] === "int", param.name);
     }
@@ -76755,11 +77241,11 @@ var AbiCoder = class {
     if (match) {
       let size = parseInt(match[1]);
       if (size === 0 || size > 32) {
-        logger9.throwArgumentError("invalid bytes length", "param", param);
+        logger10.throwArgumentError("invalid bytes length", "param", param);
       }
       return new FixedBytesCoder(size, param.name);
     }
-    return logger9.throwArgumentError("invalid type", "type", param.type);
+    return logger10.throwArgumentError("invalid type", "type", param.type);
   }
   _getWordSize() {
     return 32;
@@ -76777,7 +77263,7 @@ var AbiCoder = class {
   }
   encode(types2, values) {
     if (types2.length !== values.length) {
-      logger9.throwError("types/values length mismatch", Logger.errors.INVALID_ARGUMENT, {
+      logger10.throwError("types/values length mismatch", Logger.errors.INVALID_ARGUMENT, {
         count: { types: types2.length, values: values.length },
         value: { types: types2, values }
       });
@@ -76802,7 +77288,7 @@ function id(text) {
 }
 
 // ../../node_modules/.pnpm/@ethersproject+abi@5.7.0/node_modules/@ethersproject/abi/lib.esm/interface.js
-var logger10 = new Logger(version5);
+var logger11 = new Logger(version5);
 var LogDescription = class extends Description {
 };
 var TransactionDescription = class extends Description {
@@ -76844,7 +77330,7 @@ var Interface = class {
       switch (fragment.type) {
         case "constructor":
           if (this.deploy) {
-            logger10.warn("duplicate definition - constructor");
+            logger11.warn("duplicate definition - constructor");
             return;
           }
           defineReadOnly(this, "deploy", fragment);
@@ -76863,7 +77349,7 @@ var Interface = class {
       }
       let signature = fragment.format();
       if (bucket[signature]) {
-        logger10.warn("duplicate definition - " + signature);
+        logger11.warn("duplicate definition - " + signature);
         return;
       }
       bucket[signature] = fragment;
@@ -76881,7 +77367,7 @@ var Interface = class {
       format3 = FormatTypes.full;
     }
     if (format3 === FormatTypes.sighash) {
-      logger10.throwArgumentError("interface does not support formatting sighash", "format", format3);
+      logger11.throwArgumentError("interface does not support formatting sighash", "format", format3);
     }
     const abi = this.fragments.map((fragment) => fragment.format(format3));
     if (format3 === FormatTypes.json) {
@@ -76910,7 +77396,7 @@ var Interface = class {
           return this.functions[name];
         }
       }
-      logger10.throwArgumentError("no matching function", "sighash", nameOrSignatureOrSighash);
+      logger11.throwArgumentError("no matching function", "sighash", nameOrSignatureOrSighash);
     }
     if (nameOrSignatureOrSighash.indexOf("(") === -1) {
       const name = nameOrSignatureOrSighash.trim();
@@ -76919,15 +77405,15 @@ var Interface = class {
         /* fix:) */
       )[0] === name);
       if (matching.length === 0) {
-        logger10.throwArgumentError("no matching function", "name", name);
+        logger11.throwArgumentError("no matching function", "name", name);
       } else if (matching.length > 1) {
-        logger10.throwArgumentError("multiple matching functions", "name", name);
+        logger11.throwArgumentError("multiple matching functions", "name", name);
       }
       return this.functions[matching[0]];
     }
     const result = this.functions[FunctionFragment.fromString(nameOrSignatureOrSighash).format()];
     if (!result) {
-      logger10.throwArgumentError("no matching function", "signature", nameOrSignatureOrSighash);
+      logger11.throwArgumentError("no matching function", "signature", nameOrSignatureOrSighash);
     }
     return result;
   }
@@ -76940,7 +77426,7 @@ var Interface = class {
           return this.events[name];
         }
       }
-      logger10.throwArgumentError("no matching event", "topichash", topichash);
+      logger11.throwArgumentError("no matching event", "topichash", topichash);
     }
     if (nameOrSignatureOrTopic.indexOf("(") === -1) {
       const name = nameOrSignatureOrTopic.trim();
@@ -76949,15 +77435,15 @@ var Interface = class {
         /* fix:) */
       )[0] === name);
       if (matching.length === 0) {
-        logger10.throwArgumentError("no matching event", "name", name);
+        logger11.throwArgumentError("no matching event", "name", name);
       } else if (matching.length > 1) {
-        logger10.throwArgumentError("multiple matching events", "name", name);
+        logger11.throwArgumentError("multiple matching events", "name", name);
       }
       return this.events[matching[0]];
     }
     const result = this.events[EventFragment.fromString(nameOrSignatureOrTopic).format()];
     if (!result) {
-      logger10.throwArgumentError("no matching event", "signature", nameOrSignatureOrTopic);
+      logger11.throwArgumentError("no matching event", "signature", nameOrSignatureOrTopic);
     }
     return result;
   }
@@ -76971,7 +77457,7 @@ var Interface = class {
           return this.errors[name];
         }
       }
-      logger10.throwArgumentError("no matching error", "sighash", nameOrSignatureOrSighash);
+      logger11.throwArgumentError("no matching error", "sighash", nameOrSignatureOrSighash);
     }
     if (nameOrSignatureOrSighash.indexOf("(") === -1) {
       const name = nameOrSignatureOrSighash.trim();
@@ -76980,15 +77466,15 @@ var Interface = class {
         /* fix:) */
       )[0] === name);
       if (matching.length === 0) {
-        logger10.throwArgumentError("no matching error", "name", name);
+        logger11.throwArgumentError("no matching error", "name", name);
       } else if (matching.length > 1) {
-        logger10.throwArgumentError("multiple matching errors", "name", name);
+        logger11.throwArgumentError("multiple matching errors", "name", name);
       }
       return this.errors[matching[0]];
     }
     const result = this.errors[FunctionFragment.fromString(nameOrSignatureOrSighash).format()];
     if (!result) {
-      logger10.throwArgumentError("no matching error", "signature", nameOrSignatureOrSighash);
+      logger11.throwArgumentError("no matching error", "signature", nameOrSignatureOrSighash);
     }
     return result;
   }
@@ -77029,7 +77515,7 @@ var Interface = class {
     }
     const bytes = arrayify(data);
     if (hexlify(bytes.slice(0, 4)) !== this.getSighash(fragment)) {
-      logger10.throwArgumentError(`data signature does not match error ${fragment.name}.`, "data", hexlify(bytes));
+      logger11.throwArgumentError(`data signature does not match error ${fragment.name}.`, "data", hexlify(bytes));
     }
     return this._decodeParams(fragment.inputs, bytes.slice(4));
   }
@@ -77049,7 +77535,7 @@ var Interface = class {
     }
     const bytes = arrayify(data);
     if (hexlify(bytes.slice(0, 4)) !== this.getSighash(functionFragment)) {
-      logger10.throwArgumentError(`data signature does not match function ${functionFragment.name}.`, "data", hexlify(bytes));
+      logger11.throwArgumentError(`data signature does not match function ${functionFragment.name}.`, "data", hexlify(bytes));
     }
     return this._decodeParams(functionFragment.inputs, bytes.slice(4));
   }
@@ -77108,7 +77594,7 @@ var Interface = class {
         break;
       }
     }
-    return logger10.throwError("call revert exception" + message, Logger.errors.CALL_EXCEPTION, {
+    return logger11.throwError("call revert exception" + message, Logger.errors.CALL_EXCEPTION, {
       method: functionFragment.format(),
       data: hexlify(data),
       errorArgs,
@@ -77130,7 +77616,7 @@ var Interface = class {
       eventFragment = this.getEvent(eventFragment);
     }
     if (values.length > eventFragment.inputs.length) {
-      logger10.throwError("too many arguments for " + eventFragment.format(), Logger.errors.UNEXPECTED_ARGUMENT, {
+      logger11.throwError("too many arguments for " + eventFragment.format(), Logger.errors.UNEXPECTED_ARGUMENT, {
         argument: "values",
         value: values
       });
@@ -77160,14 +77646,14 @@ var Interface = class {
       let param = eventFragment.inputs[index];
       if (!param.indexed) {
         if (value != null) {
-          logger10.throwArgumentError("cannot filter non-indexed parameters; must be null", "contract." + param.name, value);
+          logger11.throwArgumentError("cannot filter non-indexed parameters; must be null", "contract." + param.name, value);
         }
         return;
       }
       if (value == null) {
         topics.push(null);
       } else if (param.baseType === "array" || param.baseType === "tuple") {
-        logger10.throwArgumentError("filtering with tuples or arrays not supported", "contract." + param.name, value);
+        logger11.throwArgumentError("filtering with tuples or arrays not supported", "contract." + param.name, value);
       } else if (Array.isArray(value)) {
         topics.push(value.map((value2) => encodeTopic(param, value2)));
       } else {
@@ -77190,7 +77676,7 @@ var Interface = class {
       topics.push(this.getEventTopic(eventFragment));
     }
     if (values.length !== eventFragment.inputs.length) {
-      logger10.throwArgumentError("event arguments/values mismatch", "values", values);
+      logger11.throwArgumentError("event arguments/values mismatch", "values", values);
     }
     eventFragment.inputs.forEach((param, index) => {
       const value = values[index];
@@ -77222,7 +77708,7 @@ var Interface = class {
     if (topics != null && !eventFragment.anonymous) {
       let topicHash = this.getEventTopic(eventFragment);
       if (!isHexString(topics[0], 32) || topics[0].toLowerCase() !== topicHash) {
-        logger10.throwError("fragment/topic mismatch", Logger.errors.INVALID_ARGUMENT, { argument: "topics[0]", expected: topicHash, value: topics[0] });
+        logger11.throwError("fragment/topic mismatch", Logger.errors.INVALID_ARGUMENT, { argument: "topics[0]", expected: topicHash, value: topics[0] });
       }
       topics = topics.slice(1);
     }
@@ -77453,38 +77939,38 @@ var isFile2 = (pathlike) => {
     return false;
   }
 };
-var verifyNonTarget = async (config, logger11) => {
-  const networks = parseNetworksConfig(logger11, config.networks);
+var verifyNonTarget = async (config, logger12) => {
+  const networks2 = parseNetworksConfig(logger12, config.networks);
   const paths = parsePathsConfig(config.paths);
-  const recordLogger = createRecordLogger(logger11);
-  const verifyAll = createVerifyAll(logger11);
+  const recordLogger = createRecordLogger(logger12);
+  const verifyAll = createVerifyAll(logger12);
   const logResult = createLogVerificationResult(recordLogger);
   const verificationArtifacts = config.contracts.flatMap((contract) => {
     var _a;
     const { address, network, contractName, deployment: deploymentPathOrBasename } = contract;
-    logger11.info(`Collecting information for contract ${contractName} on network ${network}`);
-    const networkConfig = networks[network];
+    logger12.info(`Collecting information for contract ${contractName} on network ${network}`);
+    const networkConfig = networks2[network];
     if (networkConfig == null) {
-      logger11.info(`No network configured for contract ${contractName} on network ${network}`);
+      logger12.info(`No network configured for contract ${contractName} on network ${network}`);
       return [];
     }
     const deploymentPath = `${basename(deploymentPathOrBasename, ".json")}.json`;
     const contractDeploymentPath = resolve(paths.deployments, network, deploymentPath);
     if (!isFile2(contractDeploymentPath)) {
-      logger11.error(COLORS.error`Deployment file ${contractDeploymentPath} does not exist or is not a file`);
+      logger12.error(COLORS.error`Deployment file ${contractDeploymentPath} does not exist or is not a file`);
       return [];
     }
     const rawDeployment = __require(contractDeploymentPath);
     const deploymentParseResult = DeploymentSchema.safeParse(rawDeployment);
     if (!deploymentParseResult.success) {
-      logger11.error(COLORS.error`No network configured for contract ${contractName} on network ${network}`);
+      logger12.error(COLORS.error`No network configured for contract ${contractName} on network ${network}`);
       return [];
     }
     const deployment = deploymentParseResult.data;
     const contractClassName = basename(contractName, ".sol");
     const source = deployment.metadata.sources[contractName];
     if (source == null) {
-      logger11.error(
+      logger12.error(
         COLORS.error`Missing source for contract ${contractName} for network ${network} in ${deploymentPath}`
       );
       return [];
@@ -77504,6 +77990,7 @@ var verifyNonTarget = async (config, logger11) => {
     const submitProps = {
       apiUrl: networkConfig.apiUrl,
       apiKey: networkConfig.apiKey,
+      chainId: networkConfig.chainId,
       address,
       contractName: `${contractName}:${contractClassName}`,
       constructorArguments,
@@ -77532,38 +78019,38 @@ var verifyNonTarget = async (config, logger11) => {
     ];
   });
   if (verificationArtifacts.length === 0) {
-    logger11.warn("No contracts match the verification criteria, exiting");
+    logger12.warn("No contracts match the verification criteria, exiting");
     return [];
   }
   if (config.dryRun) {
-    logger11.debug("Dry run enabled, exiting");
+    logger12.debug("Dry run enabled, exiting");
     return [];
   }
   const results = await Promise.all(verifyAll(verificationArtifacts));
   results.forEach(logResult);
   return results;
 };
-var verifyTarget = async (config, logger11) => {
+var verifyTarget = async (config, logger12) => {
   const verify = parseFilterConfig(config.filter);
-  const networks = parseNetworksConfig(logger11, config.networks);
+  const networks2 = parseNetworksConfig(logger12, config.networks);
   const paths = parsePathsConfig(config.paths);
-  const recordLogger = createRecordLogger(logger11);
-  const verifyAll = createVerifyAll(logger11);
+  const recordLogger = createRecordLogger(logger12);
+  const verifyAll = createVerifyAll(logger12);
   const logResult = createLogVerificationResult(recordLogger);
   if (!isDirectory(paths.deployments)) {
     throw new Error(`Path ${paths.deployments} is not a directory`);
   }
   const deployedNetworkNames = new Set(readdirSync(paths.deployments));
-  const networkConfigEntries = Object.entries(networks);
-  logger11.debug("Verifying deployments for following networks:");
+  const networkConfigEntries = Object.entries(networks2);
+  logger12.debug("Verifying deployments for following networks:");
   networkConfigEntries.forEach(([networkName, networkConfig]) => {
-    logger11.debug(`		- ${networkName} (API URL ${networkConfig.apiUrl})`);
+    logger12.debug(`		- ${networkName} (API URL ${networkConfig.apiUrl})`);
   });
   const verificationArtifacts = networkConfigEntries.flatMap(
     ([networkName, networkConfig]) => {
-      logger11.info(`Collecting deployments for ${networkName}...`);
+      logger12.info(`Collecting deployments for ${networkName}...`);
       if (!deployedNetworkNames.has(networkName)) {
-        logger11.warn(`Could not find deployment for network ${networkName} in ${paths.deployments}`);
+        logger12.warn(`Could not find deployment for network ${networkName} in ${paths.deployments}`);
         return [];
       }
       const deploymentAbsolutePath = resolve(paths.deployments, networkName);
@@ -77571,7 +78058,7 @@ var verifyTarget = async (config, logger11) => {
         (fileName) => fileName.endsWith(".json")
       );
       return deployedContractFileNames.flatMap((fileName) => {
-        logger11.info(`Inspecting deployment file ${fileName} on network ${networkName}`);
+        logger12.info(`Inspecting deployment file ${fileName} on network ${networkName}`);
         const contractDeploymentPath = resolve(deploymentAbsolutePath, fileName);
         const rawDeployment = __require(contractDeploymentPath);
         const deploymentParseResult = DeploymentSchema.safeParse(rawDeployment);
@@ -77586,12 +78073,12 @@ var verifyTarget = async (config, logger11) => {
           var _a;
           const shouldVerifyHardhatDeploy = verify(contractName, compilationTarget, networkName);
           if (!shouldVerifyHardhatDeploy) {
-            logger11.debug(`Not verifying ${contractName} in ${fileName} on network ${networkName}`);
+            logger12.debug(`Not verifying ${contractName} in ${fileName} on network ${networkName}`);
             return [];
           }
           const source = deployment.metadata.sources[compilationTarget];
           if (source == null) {
-            logger11.error(COLORS.error`Could not find source for ${contractName} (${compilationTarget})`);
+            logger12.error(COLORS.error`Could not find source for ${contractName} (${compilationTarget})`);
             return [];
           }
           const licenseType = findLicenseType(source.content);
@@ -77600,6 +78087,7 @@ var verifyTarget = async (config, logger11) => {
           const submitProps = {
             apiUrl: networkConfig.apiUrl,
             apiKey: networkConfig.apiKey,
+            chainId: networkConfig.chainId,
             address: deployment.address,
             contractName: `${compilationTarget}:${contractName}`,
             constructorArguments,
@@ -77629,42 +78117,42 @@ var verifyTarget = async (config, logger11) => {
     }
   );
   if (verificationArtifacts.length === 0) {
-    logger11.warn("No contracts match the verification criteria, exiting");
+    logger12.warn("No contracts match the verification criteria, exiting");
     return [];
   }
   if (config.dryRun) {
-    logger11.debug("Dry run enabled, exiting");
+    logger12.debug("Dry run enabled, exiting");
     return [];
   }
   const results = await Promise.all(verifyAll(verificationArtifacts));
   results.forEach(logResult);
   return results;
 };
-var createVerifyAll = (logger11) => (artifacts) => {
+var createVerifyAll = (logger12) => (artifacts) => {
   return artifacts.map(async (artifact, index) => {
     const { submitProps } = artifact;
     const paletteColor = COLORS.palette[index % COLORS.palette.length];
     const counter = `[${index + 1}/${artifacts.length}]`;
     const contractName = import_chalk4.default.bold(submitProps.contractName);
     const networkName = import_chalk4.default.bold(artifact.networkName);
-    logger11.info(paletteColor`Verifying contract ${contractName} for network ${networkName} ${counter}`);
+    logger12.info(paletteColor`Verifying contract ${contractName} for network ${networkName} ${counter}`);
     try {
-      const verification = createVerification(submitProps, logger11);
+      const verification = createVerification(submitProps, logger12);
       verification.on("poll", (guid) => {
-        logger11.info(
+        logger12.info(
           paletteColor`Polling for verification status of ${contractName} for network ${networkName} (GUID ${guid}) ${counter}`
         );
       });
       verification.on("retry", (error, attempt) => {
-        logger11.verbose(`Received an error: ${error}`);
-        logger11.info(
+        logger12.verbose(`Received an error: ${error}`);
+        logger12.info(
           paletteColor`Retrying failed verification attempt of ${contractName} for network ${networkName} (attempt ${attempt + 1}) ${counter}`
         );
       });
       const result = await verification.verify();
       return { artifact, result };
     } catch (error) {
-      logger11.error(
+      logger12.error(
         COLORS.error`Problem verifying contract ${contractName} for network ${networkName} ${counter}: ${error} `
       );
       return { artifact, error };