@layerzerolabs/verify-contract 1.1.5 → 1.1.6

package/dist/index.js

@@ -7022,9 +7022,9 @@ var require_winston_transport = __commonJS({
         this.logv = options.logv;
       if (options.close)
         this.close = options.close;
-      this.once("pipe", (logger10) => {
-        this.levels = logger10.levels;
-        this.parent = logger10;
+      this.once("pipe", (logger11) => {
+        this.levels = logger11.levels;
+        this.parent = logger11;
       });
       this.once("unpipe", (src) => {
         if (src === this.parent) {
@@ -8000,7 +8000,7 @@ var require_diagnostics = __commonJS({
   "node_modules/@dabh/diagnostics/diagnostics.js"(exports, module) {
     var adapters = [];
     var modifiers = [];
-    var logger10 = function devnull() {
+    var logger11 = function devnull() {
     };
     function use(adapter) {
       if (~adapters.indexOf(adapter))
@@ -8009,7 +8009,7 @@ var require_diagnostics = __commonJS({
       return true;
     }
     function set(custom2) {
-      logger10 = custom2;
+      logger11 = custom2;
     }
     function enabled(namespace) {
       var async = [];
@@ -8040,7 +8040,7 @@ var require_diagnostics = __commonJS({
       return true;
     }
     function write() {
-      logger10.apply(logger10, arguments);
+      logger11.apply(logger11, arguments);
     }
     function process4(message) {
       for (var i = 0; i < modifiers.length; i++) {
@@ -11194,11 +11194,11 @@ var require_exception_handler = __commonJS({
        * TODO: add contructor description
        * @param {!Logger} logger - TODO: add param description
        */
-      constructor(logger10) {
-        if (!logger10) {
+      constructor(logger11) {
+        if (!logger11) {
           throw new Error("Logger is required to handle exceptions");
         }
-        this.logger = logger10;
+        this.logger = logger11;
         this.handlers = /* @__PURE__ */ new Map();
       }
       /**
@@ -11391,11 +11391,11 @@ var require_rejection_handler = __commonJS({
        * TODO: add contructor description
        * @param {!Logger} logger - TODO: add param description
        */
-      constructor(logger10) {
-        if (!logger10) {
+      constructor(logger11) {
+        if (!logger11) {
           throw new Error("Logger is required to handle rejections");
         }
-        this.logger = logger10;
+        this.logger = logger11;
         this.handlers = /* @__PURE__ */ new Map();
       }
       /**
@@ -11591,11 +11591,11 @@ var require_profiler = __commonJS({
        * @param {!Logger} logger - TODO: add param description.
        * @private
        */
-      constructor(logger10) {
-        if (!logger10) {
+      constructor(logger11) {
+        if (!logger11) {
           throw new Error("Logger is required for profiling.");
         }
-        this.logger = logger10;
+        this.logger = logger11;
         this.start = Date.now();
       }
       /**
@@ -11643,8 +11643,8 @@ var require_logger = __commonJS({
         this.configure(options);
       }
       child(defaultRequestMetadata) {
-        const logger10 = this;
-        return Object.create(logger10, {
+        const logger11 = this;
+        return Object.create(logger11, {
           write: {
             value: function(info) {
               const infoClone = Object.assign(
@@ -11656,7 +11656,7 @@ var require_logger = __commonJS({
                 infoClone.stack = info.stack;
                 infoClone.message = info.message;
               }
-              logger10.write(infoClone);
+              logger11.write(infoClone);
             }
           }
         });
@@ -12041,11 +12041,11 @@ var require_logger = __commonJS({
        * @param {string} id Unique id of the profiler
        * @returns {Logger} - TODO: add return description.
        */
-      profile(id, ...args) {
+      profile(id2, ...args) {
         const time = Date.now();
-        if (this.profilers[id]) {
-          const timeEnd = this.profilers[id];
-          delete this.profilers[id];
+        if (this.profilers[id2]) {
+          const timeEnd = this.profilers[id2];
+          delete this.profilers[id2];
           if (typeof args[args.length - 2] === "function") {
             console.warn(
               "Callback function no longer supported as of winston@3.0.0"
@@ -12055,10 +12055,10 @@ var require_logger = __commonJS({
           const info = typeof args[args.length - 1] === "object" ? args.pop() : {};
           info.level = info.level || "info";
           info.durationMs = time - timeEnd;
-          info.message = info.message || id;
+          info.message = info.message || id2;
           return this.write(info);
         }
-        this.profilers[id] = time;
+        this.profilers[id2] = time;
         return this;
       }
       /**
@@ -12163,7 +12163,7 @@ var require_create_logger = __commonJS({
           super(options);
         }
       }
-      const logger10 = new DerivedLogger(opts);
+      const logger11 = new DerivedLogger(opts);
       Object.keys(opts.levels).forEach(function(level) {
         debug('Define prototype method for "%s"', level);
         if (level === "log") {
@@ -12171,14 +12171,14 @@ var require_create_logger = __commonJS({
           return;
         }
         DerivedLogger.prototype[level] = function(...args) {
-          const self2 = this || logger10;
+          const self2 = this || logger11;
           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 || logger10;
+            return this || logger11;
           }
           if (args.length === 0) {
             self2.log(level, "");
@@ -12187,10 +12187,10 @@ var require_create_logger = __commonJS({
           return self2.log(level, ...args);
         };
         DerivedLogger.prototype[isLevelEnabledFunctionName(level)] = function() {
-          return (this || logger10).isLevelEnabled(level);
+          return (this || logger11).isLevelEnabled(level);
         };
       });
-      return logger10;
+      return logger11;
     };
   }
 });
@@ -12216,8 +12216,8 @@ var require_container = __commonJS({
        * @param {?Object} [options] - Options for the Logger instance.
        * @returns {Logger} - A configured Logger instance with a specified id.
        */
-      add(id, options) {
-        if (!this.loggers.has(id)) {
+      add(id2, options) {
+        if (!this.loggers.has(id2)) {
           options = Object.assign({}, options || this.options);
           const existing = options.transports || this.options.transports;
           if (existing) {
@@ -12225,11 +12225,11 @@ var require_container = __commonJS({
           } else {
             options.transports = [];
           }
-          const logger10 = createLogger(options);
-          logger10.on("close", () => this._delete(id));
-          this.loggers.set(id, logger10);
+          const logger11 = createLogger(options);
+          logger11.on("close", () => this._delete(id2));
+          this.loggers.set(id2, logger11);
         }
-        return this.loggers.get(id);
+        return this.loggers.get(id2);
       }
       /**
        * Retreives a `winston.Logger` instance for the specified `id`. If
@@ -12238,8 +12238,8 @@ var require_container = __commonJS({
        * @param {?Object} [options] - Options for the Logger instance.
        * @returns {Logger} - A configured Logger instance with a specified id.
        */
-      get(id, options) {
-        return this.add(id, options);
+      get(id2, options) {
+        return this.add(id2, options);
       }
       /**
        * Check if the container has a logger with the id.
@@ -12247,8 +12247,8 @@ var require_container = __commonJS({
        * @returns {boolean} - Boolean value indicating if this instance has a
        * logger with the specified `id`.
        */
-      has(id) {
-        return !!this.loggers.has(id);
+      has(id2) {
+        return !!this.loggers.has(id2);
       }
       /**
        * Closes a `Logger` instance with the specified `id` if it exists.
@@ -12256,9 +12256,9 @@ var require_container = __commonJS({
        * @param {?string} id - The id of the Logger instance to close.
        * @returns {undefined}
        */
-      close(id) {
-        if (id) {
-          return this._removeLogger(id);
+      close(id2) {
+        if (id2) {
+          return this._removeLogger(id2);
         }
         this.loggers.forEach((val, key) => this._removeLogger(key));
       }
@@ -12268,13 +12268,13 @@ var require_container = __commonJS({
        * @returns {undefined}
        * @private
        */
-      _removeLogger(id) {
-        if (!this.loggers.has(id)) {
+      _removeLogger(id2) {
+        if (!this.loggers.has(id2)) {
           return;
         }
-        const logger10 = this.loggers.get(id);
-        logger10.close();
-        this._delete(id);
+        const logger11 = this.loggers.get(id2);
+        logger11.close();
+        this._delete(id2);
       }
       /**
        * Deletes a `Logger` instance with the specified `id`.
@@ -12283,8 +12283,8 @@ var require_container = __commonJS({
        * @returns {undefined}
        * @private
        */
-      _delete(id) {
-        this.loggers.delete(id);
+      _delete(id2) {
+        this.loggers.delete(id2);
       }
     };
   }
@@ -55335,18 +55335,18 @@ var anonymizeValue = (value) => {
   const invisiblePart = Array.from({ length: invisibleLength }).fill("*").join("");
   return `${visiblePart}${invisiblePart}`;
 };
-var createRecordLogger = (logger10, separator = "	") => (record) => {
-  logger10.info("");
+var createRecordLogger = (logger11, separator = "	") => (record) => {
+  logger11.info("");
   Object.entries(record).forEach(([label, value]) => {
     if (Array.isArray(value)) {
-      logger10.info(`${label}:`);
+      logger11.info(`${label}:`);
       value.forEach((item) => {
-        logger10.info(
+        logger11.info(
           `${separator}	- ${import_chalk.default.bold(formatLoggableValue(item))}`
         );
       });
     } else {
-      logger10.info(
+      logger11.info(
         `${label}:${separator}${import_chalk.default.bold(formatLoggableValue(value))}`
       );
     }
@@ -55367,7 +55367,7 @@ var FALSE_SYMBOL = COLORS.error`⚠`;
 
 // src/common/config.ts
 var import_chalk2 = __toESM(require_source());
-var parseNetworksConfig = (logger10, partialNetworksConfig) => {
+var parseNetworksConfig = (logger11, partialNetworksConfig) => {
   return Object.entries(partialNetworksConfig != null ? partialNetworksConfig : {}).reduce(
     (networksConfig, [networkName, networkConfig]) => {
       if (networkConfig == null)
@@ -55388,7 +55388,7 @@ Please provide the API URL:
       );
       const apiKey = networkConfig.apiKey || getScanApiKeyFromEnv(networkName);
       if (!apiKey) {
-        logger10.debug(`Could not find scan API key for network ${import_chalk2.default.bold(
+        logger11.debug(`Could not find scan API key for network ${import_chalk2.default.bold(
           networkName
         )}
         
@@ -55400,7 +55400,7 @@ Please provide the API key:
       }
       const browserUrl = networkConfig.browserUrl || getScanBrowserUrlFromEnv(networkName) || tryGetScanBrowserUrlFromScanUrl(apiUrl);
       if (!browserUrl) {
-        logger10.debug(`Could not find scan browser URL key for network ${import_chalk2.default.bold(
+        logger11.debug(`Could not find scan browser URL key for network ${import_chalk2.default.bold(
           networkName
         )}
 
@@ -64496,16 +64496,7 @@ z.record(
     content: z.string()
   })
 );
-var MinimalAbiSchema = z.array(
-  z.object({
-    type: z.string(),
-    inputs: z.array(
-      z.object({
-        type: z.string().optional()
-      })
-    ).optional()
-  })
-);
+var MinimalAbiSchema = z.array(z.record(z.string(), z.any()));
 var MetadataSchema = z.object({
   language: z.string(),
   compiler: z.object({
@@ -65018,6 +65009,18 @@ function hexlify(value, options) {
   }
   return logger.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);
+  }
+  offset = 2 + 2 * offset;
+  if (endOffset != null) {
+    return "0x" + data.substring(offset, 2 + 2 * endOffset);
+  }
+  return "0x" + data.substring(offset);
+}
 function hexConcat(items) {
   let result = "0x";
   items.forEach((item) => {
@@ -65302,6 +65305,12 @@ function throwFault(fault, operation, value) {
 function _base36To16(value) {
   return new BN(value, 36).toString(16);
 }
+
+// node_modules/@ethersproject/properties/lib.esm/_version.js
+var version4 = "properties/5.7.0";
+
+// node_modules/@ethersproject/properties/lib.esm/index.js
+var logger3 = new Logger(version4);
 function defineReadOnly(object, name, value) {
   Object.defineProperty(object, name, {
     enumerable: true,
@@ -65309,6 +65318,73 @@ function defineReadOnly(object, name, value) {
     writable: false
   });
 }
+function getStatic(ctor, key) {
+  for (let i = 0; i < 32; i++) {
+    if (ctor[key]) {
+      return ctor[key];
+    }
+    if (!ctor.prototype || typeof ctor.prototype !== "object") {
+      break;
+    }
+    ctor = Object.getPrototypeOf(ctor.prototype).constructor;
+  }
+  return null;
+}
+var opaque = { bigint: true, boolean: true, "function": true, number: true, string: true };
+function _isFrozen(object) {
+  if (object === void 0 || object === null || opaque[typeof object]) {
+    return true;
+  }
+  if (Array.isArray(object) || typeof object === "object") {
+    if (!Object.isFrozen(object)) {
+      return false;
+    }
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+      let value = null;
+      try {
+        value = object[keys[i]];
+      } catch (error) {
+        continue;
+      }
+      if (!_isFrozen(value)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return logger3.throwArgumentError(`Cannot deepCopy ${typeof object}`, "object", object);
+}
+function _deepCopy(object) {
+  if (_isFrozen(object)) {
+    return object;
+  }
+  if (Array.isArray(object)) {
+    return Object.freeze(object.map((item) => deepCopy(item)));
+  }
+  if (typeof object === "object") {
+    const result = {};
+    for (const key in object) {
+      const value = object[key];
+      if (value === void 0) {
+        continue;
+      }
+      defineReadOnly(result, key, deepCopy(value));
+    }
+    return result;
+  }
+  return logger3.throwArgumentError(`Cannot deepCopy ${typeof object}`, "object", object);
+}
+function deepCopy(object) {
+  return _deepCopy(object);
+}
+var Description = class {
+  constructor(info) {
+    for (const key in info) {
+      this[key] = deepCopy(info[key]);
+    }
+  }
+};
 
 // node_modules/@ethersproject/abi/lib.esm/_version.js
 var version5 = "abi/5.7.0";
@@ -65611,6 +65687,472 @@ var ParamType = class _ParamType {
     return !!(value != null && value._isParamType);
   }
 };
+function parseParams(value, allowIndex) {
+  return splitNesting(value).map((param) => ParamType.fromString(param, allowIndex));
+}
+var Fragment = class _Fragment {
+  constructor(constructorGuard, params) {
+    if (constructorGuard !== _constructorGuard2) {
+      logger4.throwError("use a static from method", Logger.errors.UNSUPPORTED_OPERATION, {
+        operation: "new Fragment()"
+      });
+    }
+    populate(this, params);
+    this._isFragment = true;
+    Object.freeze(this);
+  }
+  static from(value) {
+    if (_Fragment.isFragment(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      return _Fragment.fromString(value);
+    }
+    return _Fragment.fromObject(value);
+  }
+  static fromObject(value) {
+    if (_Fragment.isFragment(value)) {
+      return value;
+    }
+    switch (value.type) {
+      case "function":
+        return FunctionFragment.fromObject(value);
+      case "event":
+        return EventFragment.fromObject(value);
+      case "constructor":
+        return ConstructorFragment.fromObject(value);
+      case "error":
+        return ErrorFragment.fromObject(value);
+      case "fallback":
+      case "receive":
+        return null;
+    }
+    return logger4.throwArgumentError("invalid fragment object", "value", value);
+  }
+  static fromString(value) {
+    value = value.replace(/\s/g, " ");
+    value = value.replace(/\(/g, " (").replace(/\)/g, ") ").replace(/\s+/g, " ");
+    value = value.trim();
+    if (value.split(" ")[0] === "event") {
+      return EventFragment.fromString(value.substring(5).trim());
+    } else if (value.split(" ")[0] === "function") {
+      return FunctionFragment.fromString(value.substring(8).trim());
+    } else if (value.split("(")[0].trim() === "constructor") {
+      return ConstructorFragment.fromString(value.trim());
+    } else if (value.split(" ")[0] === "error") {
+      return ErrorFragment.fromString(value.substring(5).trim());
+    }
+    return logger4.throwArgumentError("unsupported fragment", "value", value);
+  }
+  static isFragment(value) {
+    return !!(value && value._isFragment);
+  }
+};
+var EventFragment = class _EventFragment extends Fragment {
+  format(format2) {
+    if (!format2) {
+      format2 = FormatTypes.sighash;
+    }
+    if (!FormatTypes[format2]) {
+      logger4.throwArgumentError("invalid format type", "format", format2);
+    }
+    if (format2 === FormatTypes.json) {
+      return JSON.stringify({
+        type: "event",
+        anonymous: this.anonymous,
+        name: this.name,
+        inputs: this.inputs.map((input) => JSON.parse(input.format(format2)))
+      });
+    }
+    let result = "";
+    if (format2 !== FormatTypes.sighash) {
+      result += "event ";
+    }
+    result += this.name + "(" + this.inputs.map((input) => input.format(format2)).join(format2 === FormatTypes.full ? ", " : ",") + ") ";
+    if (format2 !== FormatTypes.sighash) {
+      if (this.anonymous) {
+        result += "anonymous ";
+      }
+    }
+    return result.trim();
+  }
+  static from(value) {
+    if (typeof value === "string") {
+      return _EventFragment.fromString(value);
+    }
+    return _EventFragment.fromObject(value);
+  }
+  static fromObject(value) {
+    if (_EventFragment.isEventFragment(value)) {
+      return value;
+    }
+    if (value.type !== "event") {
+      logger4.throwArgumentError("invalid event object", "value", value);
+    }
+    const params = {
+      name: verifyIdentifier(value.name),
+      anonymous: value.anonymous,
+      inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [],
+      type: "event"
+    };
+    return new _EventFragment(_constructorGuard2, params);
+  }
+  static fromString(value) {
+    let match = value.match(regexParen);
+    if (!match) {
+      logger4.throwArgumentError("invalid event string", "value", value);
+    }
+    let anonymous = false;
+    match[3].split(" ").forEach((modifier) => {
+      switch (modifier.trim()) {
+        case "anonymous":
+          anonymous = true;
+          break;
+        case "":
+          break;
+        default:
+          logger4.warn("unknown modifier: " + modifier);
+      }
+    });
+    return _EventFragment.fromObject({
+      name: match[1].trim(),
+      anonymous,
+      inputs: parseParams(match[2], true),
+      type: "event"
+    });
+  }
+  static isEventFragment(value) {
+    return value && value._isFragment && value.type === "event";
+  }
+};
+function parseGas(value, params) {
+  params.gas = null;
+  let comps = value.split("@");
+  if (comps.length !== 1) {
+    if (comps.length > 2) {
+      logger4.throwArgumentError("invalid human-readable ABI signature", "value", value);
+    }
+    if (!comps[1].match(/^[0-9]+$/)) {
+      logger4.throwArgumentError("invalid human-readable ABI signature gas", "value", value);
+    }
+    params.gas = BigNumber.from(comps[1]);
+    return comps[0];
+  }
+  return value;
+}
+function parseModifiers(value, params) {
+  params.constant = false;
+  params.payable = false;
+  params.stateMutability = "nonpayable";
+  value.split(" ").forEach((modifier) => {
+    switch (modifier.trim()) {
+      case "constant":
+        params.constant = true;
+        break;
+      case "payable":
+        params.payable = true;
+        params.stateMutability = "payable";
+        break;
+      case "nonpayable":
+        params.payable = false;
+        params.stateMutability = "nonpayable";
+        break;
+      case "pure":
+        params.constant = true;
+        params.stateMutability = "pure";
+        break;
+      case "view":
+        params.constant = true;
+        params.stateMutability = "view";
+        break;
+      case "external":
+      case "public":
+      case "":
+        break;
+      default:
+        console.log("unknown modifier: " + modifier);
+    }
+  });
+}
+function verifyState(value) {
+  let result = {
+    constant: false,
+    payable: true,
+    stateMutability: "payable"
+  };
+  if (value.stateMutability != null) {
+    result.stateMutability = value.stateMutability;
+    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);
+      }
+    }
+    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);
+      }
+    }
+  } 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);
+    }
+    result.constant = !!value.constant;
+    if (result.constant) {
+      result.stateMutability = "view";
+    } else {
+      result.stateMutability = result.payable ? "payable" : "nonpayable";
+    }
+    if (result.payable && result.constant) {
+      logger4.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);
+  }
+  return result;
+}
+var ConstructorFragment = class _ConstructorFragment extends Fragment {
+  format(format2) {
+    if (!format2) {
+      format2 = FormatTypes.sighash;
+    }
+    if (!FormatTypes[format2]) {
+      logger4.throwArgumentError("invalid format type", "format", format2);
+    }
+    if (format2 === FormatTypes.json) {
+      return JSON.stringify({
+        type: "constructor",
+        stateMutability: this.stateMutability !== "nonpayable" ? this.stateMutability : void 0,
+        payable: this.payable,
+        gas: this.gas ? this.gas.toNumber() : void 0,
+        inputs: this.inputs.map((input) => JSON.parse(input.format(format2)))
+      });
+    }
+    if (format2 === FormatTypes.sighash) {
+      logger4.throwError("cannot format a constructor for sighash", Logger.errors.UNSUPPORTED_OPERATION, {
+        operation: "format(sighash)"
+      });
+    }
+    let result = "constructor(" + this.inputs.map((input) => input.format(format2)).join(format2 === FormatTypes.full ? ", " : ",") + ") ";
+    if (this.stateMutability && this.stateMutability !== "nonpayable") {
+      result += this.stateMutability + " ";
+    }
+    return result.trim();
+  }
+  static from(value) {
+    if (typeof value === "string") {
+      return _ConstructorFragment.fromString(value);
+    }
+    return _ConstructorFragment.fromObject(value);
+  }
+  static fromObject(value) {
+    if (_ConstructorFragment.isConstructorFragment(value)) {
+      return value;
+    }
+    if (value.type !== "constructor") {
+      logger4.throwArgumentError("invalid constructor object", "value", value);
+    }
+    let state = verifyState(value);
+    if (state.constant) {
+      logger4.throwArgumentError("constructor cannot be constant", "value", value);
+    }
+    const params = {
+      name: null,
+      type: value.type,
+      inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [],
+      payable: state.payable,
+      stateMutability: state.stateMutability,
+      gas: value.gas ? BigNumber.from(value.gas) : null
+    };
+    return new _ConstructorFragment(_constructorGuard2, params);
+  }
+  static fromString(value) {
+    let params = { type: "constructor" };
+    value = parseGas(value, params);
+    let parens = value.match(regexParen);
+    if (!parens || parens[1].trim() !== "constructor") {
+      logger4.throwArgumentError("invalid constructor string", "value", value);
+    }
+    params.inputs = parseParams(parens[2].trim(), false);
+    parseModifiers(parens[3].trim(), params);
+    return _ConstructorFragment.fromObject(params);
+  }
+  static isConstructorFragment(value) {
+    return value && value._isFragment && value.type === "constructor";
+  }
+};
+var FunctionFragment = class _FunctionFragment extends ConstructorFragment {
+  format(format2) {
+    if (!format2) {
+      format2 = FormatTypes.sighash;
+    }
+    if (!FormatTypes[format2]) {
+      logger4.throwArgumentError("invalid format type", "format", format2);
+    }
+    if (format2 === FormatTypes.json) {
+      return JSON.stringify({
+        type: "function",
+        name: this.name,
+        constant: this.constant,
+        stateMutability: this.stateMutability !== "nonpayable" ? this.stateMutability : void 0,
+        payable: this.payable,
+        gas: this.gas ? this.gas.toNumber() : void 0,
+        inputs: this.inputs.map((input) => JSON.parse(input.format(format2))),
+        outputs: this.outputs.map((output) => JSON.parse(output.format(format2)))
+      });
+    }
+    let result = "";
+    if (format2 !== FormatTypes.sighash) {
+      result += "function ";
+    }
+    result += this.name + "(" + this.inputs.map((input) => input.format(format2)).join(format2 === FormatTypes.full ? ", " : ",") + ") ";
+    if (format2 !== FormatTypes.sighash) {
+      if (this.stateMutability) {
+        if (this.stateMutability !== "nonpayable") {
+          result += this.stateMutability + " ";
+        }
+      } else if (this.constant) {
+        result += "view ";
+      }
+      if (this.outputs && this.outputs.length) {
+        result += "returns (" + this.outputs.map((output) => output.format(format2)).join(", ") + ") ";
+      }
+      if (this.gas != null) {
+        result += "@" + this.gas.toString() + " ";
+      }
+    }
+    return result.trim();
+  }
+  static from(value) {
+    if (typeof value === "string") {
+      return _FunctionFragment.fromString(value);
+    }
+    return _FunctionFragment.fromObject(value);
+  }
+  static fromObject(value) {
+    if (_FunctionFragment.isFunctionFragment(value)) {
+      return value;
+    }
+    if (value.type !== "function") {
+      logger4.throwArgumentError("invalid function object", "value", value);
+    }
+    let state = verifyState(value);
+    const params = {
+      type: value.type,
+      name: verifyIdentifier(value.name),
+      constant: state.constant,
+      inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [],
+      outputs: value.outputs ? value.outputs.map(ParamType.fromObject) : [],
+      payable: state.payable,
+      stateMutability: state.stateMutability,
+      gas: value.gas ? BigNumber.from(value.gas) : null
+    };
+    return new _FunctionFragment(_constructorGuard2, params);
+  }
+  static fromString(value) {
+    let params = { type: "function" };
+    value = parseGas(value, params);
+    let comps = value.split(" returns ");
+    if (comps.length > 2) {
+      logger4.throwArgumentError("invalid function string", "value", value);
+    }
+    let parens = comps[0].match(regexParen);
+    if (!parens) {
+      logger4.throwArgumentError("invalid function signature", "value", value);
+    }
+    params.name = parens[1].trim();
+    if (params.name) {
+      verifyIdentifier(params.name);
+    }
+    params.inputs = parseParams(parens[2], false);
+    parseModifiers(parens[3].trim(), params);
+    if (comps.length > 1) {
+      let returns = comps[1].match(regexParen);
+      if (returns[1].trim() != "" || returns[3].trim() != "") {
+        logger4.throwArgumentError("unexpected tokens", "value", value);
+      }
+      params.outputs = parseParams(returns[2], false);
+    } else {
+      params.outputs = [];
+    }
+    return _FunctionFragment.fromObject(params);
+  }
+  static isFunctionFragment(value) {
+    return value && value._isFragment && value.type === "function";
+  }
+};
+function checkForbidden(fragment) {
+  const sig = fragment.format();
+  if (sig === "Error(string)" || sig === "Panic(uint256)") {
+    logger4.throwArgumentError(`cannot specify user defined ${sig} error`, "fragment", fragment);
+  }
+  return fragment;
+}
+var ErrorFragment = class _ErrorFragment extends Fragment {
+  format(format2) {
+    if (!format2) {
+      format2 = FormatTypes.sighash;
+    }
+    if (!FormatTypes[format2]) {
+      logger4.throwArgumentError("invalid format type", "format", format2);
+    }
+    if (format2 === FormatTypes.json) {
+      return JSON.stringify({
+        type: "error",
+        name: this.name,
+        inputs: this.inputs.map((input) => JSON.parse(input.format(format2)))
+      });
+    }
+    let result = "";
+    if (format2 !== FormatTypes.sighash) {
+      result += "error ";
+    }
+    result += this.name + "(" + this.inputs.map((input) => input.format(format2)).join(format2 === FormatTypes.full ? ", " : ",") + ") ";
+    return result.trim();
+  }
+  static from(value) {
+    if (typeof value === "string") {
+      return _ErrorFragment.fromString(value);
+    }
+    return _ErrorFragment.fromObject(value);
+  }
+  static fromObject(value) {
+    if (_ErrorFragment.isErrorFragment(value)) {
+      return value;
+    }
+    if (value.type !== "error") {
+      logger4.throwArgumentError("invalid error object", "value", value);
+    }
+    const params = {
+      type: value.type,
+      name: verifyIdentifier(value.name),
+      inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : []
+    };
+    return checkForbidden(new _ErrorFragment(_constructorGuard2, params));
+  }
+  static fromString(value) {
+    let params = { type: "error" };
+    let parens = value.match(regexParen);
+    if (!parens) {
+      logger4.throwArgumentError("invalid error signature", "value", value);
+    }
+    params.name = parens[1].trim();
+    if (params.name) {
+      verifyIdentifier(params.name);
+    }
+    params.inputs = parseParams(parens[2], false);
+    return checkForbidden(_ErrorFragment.fromObject(params));
+  }
+  static isErrorFragment(value) {
+    return value && value._isFragment && value.type === "error";
+  }
+};
 function verifyType(type) {
   if (type.match(/^uint($|[^1-9])/)) {
     type = "uint256" + type.substring(4);
@@ -65619,6 +66161,41 @@ function verifyType(type) {
   }
   return 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);
+  }
+  return value;
+}
+var regexParen = new RegExp("^([^)(]*)\\((.*)\\)([^)(]*)$");
+function splitNesting(value) {
+  value = value.trim();
+  let result = [];
+  let accum = "";
+  let depth = 0;
+  for (let offset = 0; offset < value.length; offset++) {
+    let c = value[offset];
+    if (c === "," && depth === 0) {
+      result.push(accum);
+      accum = "";
+    } else {
+      accum += c;
+      if (c === "(") {
+        depth++;
+      } else if (c === ")") {
+        depth--;
+        if (depth === -1) {
+          logger4.throwArgumentError("unbalanced parenthesis", "value", value);
+        }
+      }
+    }
+  }
+  if (accum) {
+    result.push(accum);
+  }
+  return result;
+}
 
 // node_modules/@ethersproject/abi/lib.esm/coders/abstract-coder.js
 var logger5 = new Logger(version5);
@@ -66505,23 +67082,574 @@ var AbiCoder = class {
 };
 var defaultAbiCoder = new AbiCoder();
 
+// node_modules/@ethersproject/hash/lib.esm/id.js
+function id(text) {
+  return keccak256(toUtf8Bytes(text));
+}
+
+// node_modules/@ethersproject/abi/lib.esm/interface.js
+var logger10 = new Logger(version5);
+var LogDescription = class extends Description {
+};
+var TransactionDescription = class extends Description {
+};
+var ErrorDescription = class extends Description {
+};
+var Indexed = class extends Description {
+  static isIndexed(value) {
+    return !!(value && value._isIndexed);
+  }
+};
+var BuiltinErrors = {
+  "0x08c379a0": { signature: "Error(string)", name: "Error", inputs: ["string"], reason: true },
+  "0x4e487b71": { signature: "Panic(uint256)", name: "Panic", inputs: ["uint256"] }
+};
+function wrapAccessError(property, error) {
+  const wrap = new Error(`deferred error during ABI decoding triggered accessing ${property}`);
+  wrap.error = error;
+  return wrap;
+}
+var Interface = class {
+  constructor(fragments) {
+    let abi = [];
+    if (typeof fragments === "string") {
+      abi = JSON.parse(fragments);
+    } else {
+      abi = fragments;
+    }
+    defineReadOnly(this, "fragments", abi.map((fragment) => {
+      return Fragment.from(fragment);
+    }).filter((fragment) => fragment != null));
+    defineReadOnly(this, "_abiCoder", getStatic(new.target, "getAbiCoder")());
+    defineReadOnly(this, "functions", {});
+    defineReadOnly(this, "errors", {});
+    defineReadOnly(this, "events", {});
+    defineReadOnly(this, "structs", {});
+    this.fragments.forEach((fragment) => {
+      let bucket = null;
+      switch (fragment.type) {
+        case "constructor":
+          if (this.deploy) {
+            logger10.warn("duplicate definition - constructor");
+            return;
+          }
+          defineReadOnly(this, "deploy", fragment);
+          return;
+        case "function":
+          bucket = this.functions;
+          break;
+        case "event":
+          bucket = this.events;
+          break;
+        case "error":
+          bucket = this.errors;
+          break;
+        default:
+          return;
+      }
+      let signature = fragment.format();
+      if (bucket[signature]) {
+        logger10.warn("duplicate definition - " + signature);
+        return;
+      }
+      bucket[signature] = fragment;
+    });
+    if (!this.deploy) {
+      defineReadOnly(this, "deploy", ConstructorFragment.from({
+        payable: false,
+        type: "constructor"
+      }));
+    }
+    defineReadOnly(this, "_isInterface", true);
+  }
+  format(format2) {
+    if (!format2) {
+      format2 = FormatTypes.full;
+    }
+    if (format2 === FormatTypes.sighash) {
+      logger10.throwArgumentError("interface does not support formatting sighash", "format", format2);
+    }
+    const abi = this.fragments.map((fragment) => fragment.format(format2));
+    if (format2 === FormatTypes.json) {
+      return JSON.stringify(abi.map((j) => JSON.parse(j)));
+    }
+    return abi;
+  }
+  // Sub-classes can override these to handle other blockchains
+  static getAbiCoder() {
+    return defaultAbiCoder;
+  }
+  static getAddress(address) {
+    return getAddress(address);
+  }
+  static getSighash(fragment) {
+    return hexDataSlice(id(fragment.format()), 0, 4);
+  }
+  static getEventTopic(eventFragment) {
+    return id(eventFragment.format());
+  }
+  // Find a function definition by any means necessary (unless it is ambiguous)
+  getFunction(nameOrSignatureOrSighash) {
+    if (isHexString(nameOrSignatureOrSighash)) {
+      for (const name in this.functions) {
+        if (nameOrSignatureOrSighash === this.getSighash(name)) {
+          return this.functions[name];
+        }
+      }
+      logger10.throwArgumentError("no matching function", "sighash", nameOrSignatureOrSighash);
+    }
+    if (nameOrSignatureOrSighash.indexOf("(") === -1) {
+      const name = nameOrSignatureOrSighash.trim();
+      const matching = Object.keys(this.functions).filter((f) => f.split(
+        "("
+        /* fix:) */
+      )[0] === name);
+      if (matching.length === 0) {
+        logger10.throwArgumentError("no matching function", "name", name);
+      } else if (matching.length > 1) {
+        logger10.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);
+    }
+    return result;
+  }
+  // Find an event definition by any means necessary (unless it is ambiguous)
+  getEvent(nameOrSignatureOrTopic) {
+    if (isHexString(nameOrSignatureOrTopic)) {
+      const topichash = nameOrSignatureOrTopic.toLowerCase();
+      for (const name in this.events) {
+        if (topichash === this.getEventTopic(name)) {
+          return this.events[name];
+        }
+      }
+      logger10.throwArgumentError("no matching event", "topichash", topichash);
+    }
+    if (nameOrSignatureOrTopic.indexOf("(") === -1) {
+      const name = nameOrSignatureOrTopic.trim();
+      const matching = Object.keys(this.events).filter((f) => f.split(
+        "("
+        /* fix:) */
+      )[0] === name);
+      if (matching.length === 0) {
+        logger10.throwArgumentError("no matching event", "name", name);
+      } else if (matching.length > 1) {
+        logger10.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);
+    }
+    return result;
+  }
+  // Find a function definition by any means necessary (unless it is ambiguous)
+  getError(nameOrSignatureOrSighash) {
+    if (isHexString(nameOrSignatureOrSighash)) {
+      const getSighash = getStatic(this.constructor, "getSighash");
+      for (const name in this.errors) {
+        const error = this.errors[name];
+        if (nameOrSignatureOrSighash === getSighash(error)) {
+          return this.errors[name];
+        }
+      }
+      logger10.throwArgumentError("no matching error", "sighash", nameOrSignatureOrSighash);
+    }
+    if (nameOrSignatureOrSighash.indexOf("(") === -1) {
+      const name = nameOrSignatureOrSighash.trim();
+      const matching = Object.keys(this.errors).filter((f) => f.split(
+        "("
+        /* fix:) */
+      )[0] === name);
+      if (matching.length === 0) {
+        logger10.throwArgumentError("no matching error", "name", name);
+      } else if (matching.length > 1) {
+        logger10.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);
+    }
+    return result;
+  }
+  // Get the sighash (the bytes4 selector) used by Solidity to identify a function
+  getSighash(fragment) {
+    if (typeof fragment === "string") {
+      try {
+        fragment = this.getFunction(fragment);
+      } catch (error) {
+        try {
+          fragment = this.getError(fragment);
+        } catch (_) {
+          throw error;
+        }
+      }
+    }
+    return getStatic(this.constructor, "getSighash")(fragment);
+  }
+  // Get the topic (the bytes32 hash) used by Solidity to identify an event
+  getEventTopic(eventFragment) {
+    if (typeof eventFragment === "string") {
+      eventFragment = this.getEvent(eventFragment);
+    }
+    return getStatic(this.constructor, "getEventTopic")(eventFragment);
+  }
+  _decodeParams(params, data) {
+    return this._abiCoder.decode(params, data);
+  }
+  _encodeParams(params, values) {
+    return this._abiCoder.encode(params, values);
+  }
+  encodeDeploy(values) {
+    return this._encodeParams(this.deploy.inputs, values || []);
+  }
+  decodeErrorResult(fragment, data) {
+    if (typeof fragment === "string") {
+      fragment = this.getError(fragment);
+    }
+    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));
+    }
+    return this._decodeParams(fragment.inputs, bytes.slice(4));
+  }
+  encodeErrorResult(fragment, values) {
+    if (typeof fragment === "string") {
+      fragment = this.getError(fragment);
+    }
+    return hexlify(concat([
+      this.getSighash(fragment),
+      this._encodeParams(fragment.inputs, values || [])
+    ]));
+  }
+  // Decode the data for a function call (e.g. tx.data)
+  decodeFunctionData(functionFragment, data) {
+    if (typeof functionFragment === "string") {
+      functionFragment = this.getFunction(functionFragment);
+    }
+    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));
+    }
+    return this._decodeParams(functionFragment.inputs, bytes.slice(4));
+  }
+  // Encode the data for a function call (e.g. tx.data)
+  encodeFunctionData(functionFragment, values) {
+    if (typeof functionFragment === "string") {
+      functionFragment = this.getFunction(functionFragment);
+    }
+    return hexlify(concat([
+      this.getSighash(functionFragment),
+      this._encodeParams(functionFragment.inputs, values || [])
+    ]));
+  }
+  // Decode the result from a function call (e.g. from eth_call)
+  decodeFunctionResult(functionFragment, data) {
+    if (typeof functionFragment === "string") {
+      functionFragment = this.getFunction(functionFragment);
+    }
+    let bytes = arrayify(data);
+    let reason = null;
+    let message = "";
+    let errorArgs = null;
+    let errorName = null;
+    let errorSignature = null;
+    switch (bytes.length % this._abiCoder._getWordSize()) {
+      case 0:
+        try {
+          return this._abiCoder.decode(functionFragment.outputs, bytes);
+        } catch (error) {
+        }
+        break;
+      case 4: {
+        const selector = hexlify(bytes.slice(0, 4));
+        const builtin = BuiltinErrors[selector];
+        if (builtin) {
+          errorArgs = this._abiCoder.decode(builtin.inputs, bytes.slice(4));
+          errorName = builtin.name;
+          errorSignature = builtin.signature;
+          if (builtin.reason) {
+            reason = errorArgs[0];
+          }
+          if (errorName === "Error") {
+            message = `; VM Exception while processing transaction: reverted with reason string ${JSON.stringify(errorArgs[0])}`;
+          } else if (errorName === "Panic") {
+            message = `; VM Exception while processing transaction: reverted with panic code ${errorArgs[0]}`;
+          }
+        } else {
+          try {
+            const error = this.getError(selector);
+            errorArgs = this._abiCoder.decode(error.inputs, bytes.slice(4));
+            errorName = error.name;
+            errorSignature = error.format();
+          } catch (error) {
+          }
+        }
+        break;
+      }
+    }
+    return logger10.throwError("call revert exception" + message, Logger.errors.CALL_EXCEPTION, {
+      method: functionFragment.format(),
+      data: hexlify(data),
+      errorArgs,
+      errorName,
+      errorSignature,
+      reason
+    });
+  }
+  // Encode the result for a function call (e.g. for eth_call)
+  encodeFunctionResult(functionFragment, values) {
+    if (typeof functionFragment === "string") {
+      functionFragment = this.getFunction(functionFragment);
+    }
+    return hexlify(this._abiCoder.encode(functionFragment.outputs, values || []));
+  }
+  // Create the filter for the event with search criteria (e.g. for eth_filterLog)
+  encodeFilterTopics(eventFragment, values) {
+    if (typeof eventFragment === "string") {
+      eventFragment = this.getEvent(eventFragment);
+    }
+    if (values.length > eventFragment.inputs.length) {
+      logger10.throwError("too many arguments for " + eventFragment.format(), Logger.errors.UNEXPECTED_ARGUMENT, {
+        argument: "values",
+        value: values
+      });
+    }
+    let topics = [];
+    if (!eventFragment.anonymous) {
+      topics.push(this.getEventTopic(eventFragment));
+    }
+    const encodeTopic = (param, value) => {
+      if (param.type === "string") {
+        return id(value);
+      } else if (param.type === "bytes") {
+        return keccak256(hexlify(value));
+      }
+      if (param.type === "bool" && typeof value === "boolean") {
+        value = value ? "0x01" : "0x00";
+      }
+      if (param.type.match(/^u?int/)) {
+        value = BigNumber.from(value).toHexString();
+      }
+      if (param.type === "address") {
+        this._abiCoder.encode(["address"], [value]);
+      }
+      return hexZeroPad(hexlify(value), 32);
+    };
+    values.forEach((value, index) => {
+      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);
+        }
+        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);
+      } else if (Array.isArray(value)) {
+        topics.push(value.map((value2) => encodeTopic(param, value2)));
+      } else {
+        topics.push(encodeTopic(param, value));
+      }
+    });
+    while (topics.length && topics[topics.length - 1] === null) {
+      topics.pop();
+    }
+    return topics;
+  }
+  encodeEventLog(eventFragment, values) {
+    if (typeof eventFragment === "string") {
+      eventFragment = this.getEvent(eventFragment);
+    }
+    const topics = [];
+    const dataTypes = [];
+    const dataValues = [];
+    if (!eventFragment.anonymous) {
+      topics.push(this.getEventTopic(eventFragment));
+    }
+    if (values.length !== eventFragment.inputs.length) {
+      logger10.throwArgumentError("event arguments/values mismatch", "values", values);
+    }
+    eventFragment.inputs.forEach((param, index) => {
+      const value = values[index];
+      if (param.indexed) {
+        if (param.type === "string") {
+          topics.push(id(value));
+        } else if (param.type === "bytes") {
+          topics.push(keccak256(value));
+        } else if (param.baseType === "tuple" || param.baseType === "array") {
+          throw new Error("not implemented");
+        } else {
+          topics.push(this._abiCoder.encode([param.type], [value]));
+        }
+      } else {
+        dataTypes.push(param);
+        dataValues.push(value);
+      }
+    });
+    return {
+      data: this._abiCoder.encode(dataTypes, dataValues),
+      topics
+    };
+  }
+  // Decode a filter for the event and the search criteria
+  decodeEventLog(eventFragment, data, topics) {
+    if (typeof eventFragment === "string") {
+      eventFragment = this.getEvent(eventFragment);
+    }
+    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] });
+      }
+      topics = topics.slice(1);
+    }
+    let indexed = [];
+    let nonIndexed = [];
+    let dynamic = [];
+    eventFragment.inputs.forEach((param, index) => {
+      if (param.indexed) {
+        if (param.type === "string" || param.type === "bytes" || param.baseType === "tuple" || param.baseType === "array") {
+          indexed.push(ParamType.fromObject({ type: "bytes32", name: param.name }));
+          dynamic.push(true);
+        } else {
+          indexed.push(param);
+          dynamic.push(false);
+        }
+      } else {
+        nonIndexed.push(param);
+        dynamic.push(false);
+      }
+    });
+    let resultIndexed = topics != null ? this._abiCoder.decode(indexed, concat(topics)) : null;
+    let resultNonIndexed = this._abiCoder.decode(nonIndexed, data, true);
+    let result = [];
+    let nonIndexedIndex = 0, indexedIndex = 0;
+    eventFragment.inputs.forEach((param, index) => {
+      if (param.indexed) {
+        if (resultIndexed == null) {
+          result[index] = new Indexed({ _isIndexed: true, hash: null });
+        } else if (dynamic[index]) {
+          result[index] = new Indexed({ _isIndexed: true, hash: resultIndexed[indexedIndex++] });
+        } else {
+          try {
+            result[index] = resultIndexed[indexedIndex++];
+          } catch (error) {
+            result[index] = error;
+          }
+        }
+      } else {
+        try {
+          result[index] = resultNonIndexed[nonIndexedIndex++];
+        } catch (error) {
+          result[index] = error;
+        }
+      }
+      if (param.name && result[param.name] == null) {
+        const value = result[index];
+        if (value instanceof Error) {
+          Object.defineProperty(result, param.name, {
+            enumerable: true,
+            get: () => {
+              throw wrapAccessError(`property ${JSON.stringify(param.name)}`, value);
+            }
+          });
+        } else {
+          result[param.name] = value;
+        }
+      }
+    });
+    for (let i = 0; i < result.length; i++) {
+      const value = result[i];
+      if (value instanceof Error) {
+        Object.defineProperty(result, i, {
+          enumerable: true,
+          get: () => {
+            throw wrapAccessError(`index ${i}`, value);
+          }
+        });
+      }
+    }
+    return Object.freeze(result);
+  }
+  // Given a transaction, find the matching function fragment (if any) and
+  // determine all its properties and call parameters
+  parseTransaction(tx) {
+    let fragment = this.getFunction(tx.data.substring(0, 10).toLowerCase());
+    if (!fragment) {
+      return null;
+    }
+    return new TransactionDescription({
+      args: this._abiCoder.decode(fragment.inputs, "0x" + tx.data.substring(10)),
+      functionFragment: fragment,
+      name: fragment.name,
+      signature: fragment.format(),
+      sighash: this.getSighash(fragment),
+      value: BigNumber.from(tx.value || "0")
+    });
+  }
+  // @TODO
+  //parseCallResult(data: BytesLike): ??
+  // Given an event log, find the matching event fragment (if any) and
+  // determine all its properties and values
+  parseLog(log) {
+    let fragment = this.getEvent(log.topics[0]);
+    if (!fragment || fragment.anonymous) {
+      return null;
+    }
+    return new LogDescription({
+      eventFragment: fragment,
+      name: fragment.name,
+      signature: fragment.format(),
+      topic: this.getEventTopic(fragment),
+      args: this.decodeEventLog(fragment, log.data, log.topics)
+    });
+  }
+  parseError(data) {
+    const hexData = hexlify(data);
+    let fragment = this.getError(hexData.substring(0, 10).toLowerCase());
+    if (!fragment) {
+      return null;
+    }
+    return new ErrorDescription({
+      args: this._abiCoder.decode(fragment.inputs, "0x" + hexData.substring(10)),
+      errorFragment: fragment,
+      name: fragment.name,
+      signature: fragment.format(),
+      sighash: this.getSighash(fragment)
+    });
+  }
+  /*
+  static from(value: Array<Fragment | string | JsonAbi> | string | Interface) {
+      if (Interface.isInterface(value)) {
+          return value;
+      }
+      if (typeof(value) === "string") {
+          return new Interface(JSON.parse(value));
+      }
+      return new Interface(value);
+  }
+  */
+  static isInterface(value) {
+    return !!(value && value._isInterface);
+  }
+};
+
 // src/common/abi.ts
 var parser = __toESM(require_index_cjs());
 var encodeContructorArguments = (abi, args) => {
   if (args == null || args.length === 0)
     return void 0;
-  const fragment = abi.flatMap((fragment2) => {
-    const parseResult = ConstructorSchema.safeParse(fragment2);
-    if (!parseResult.success)
-      return [];
-    return [parseResult.data];
-  }).at(0);
-  assert4__default.default(fragment != null, `Missing constructor fragment`);
-  const constructorArgumentTypes = fragment.inputs.map(({ type }) => type);
-  const encodedConstructorArguments = defaultAbiCoder.encode(
-    constructorArgumentTypes,
-    args
-  );
+  const iface = new Interface(abi);
+  const encodedConstructorArguments = iface.encodeDeploy(args);
   return encodedConstructorArguments.slice(2);
 };
 var getContructorABIFromSource = (source) => {
@@ -66567,10 +67695,6 @@ var getTypeFromTypeName = (typeName) => {
       );
   }
 };
-var ConstructorSchema = z.object({
-  inputs: z.array(z.object({ type: z.string() })),
-  type: z.literal("constructor")
-});
 var parsePathsConfig = (partialPathsConfig) => {
   var _a;
   return {
@@ -66615,11 +67739,11 @@ var isFile2 = (pathlike) => {
     return false;
   }
 };
-var verifyNonTarget = async (config, logger10) => {
-  const networks = parseNetworksConfig(logger10, config.networks);
+var verifyNonTarget = async (config, logger11) => {
+  const networks = parseNetworksConfig(logger11, config.networks);
   const paths = parsePathsConfig(config.paths);
-  const recordLogger = createRecordLogger(logger10);
-  const verifyAll = createVerifyAll(logger10);
+  const recordLogger = createRecordLogger(logger11);
+  const verifyAll = createVerifyAll(logger11);
   const logResult = createLogVerificationResult(recordLogger);
   const verificationArtifacts = config.contracts.flatMap(
     (contract) => {
@@ -66630,12 +67754,12 @@ var verifyNonTarget = async (config, logger10) => {
         contractName,
         deployment: deploymentPathOrBasename
       } = contract;
-      logger10.info(
+      logger11.info(
         `Collectiong information for contract ${contractName} on network ${network}`
       );
       const networkConfig = networks[network];
       if (networkConfig == null) {
-        logger10.info(
+        logger11.info(
           `No network configured for contract ${contractName} on network ${network}`
         );
         return [];
@@ -66650,7 +67774,7 @@ var verifyNonTarget = async (config, logger10) => {
         deploymentPath
       );
       if (!isFile2(contractDeploymentPath)) {
-        logger10.error(
+        logger11.error(
           COLORS.error`Deployment file ${contractDeploymentPath} does not exist or is not a file`
         );
         return [];
@@ -66658,7 +67782,7 @@ var verifyNonTarget = async (config, logger10) => {
       const rawDeployment = __require(contractDeploymentPath);
       const deploymentParseResult = DeploymentSchema.safeParse(rawDeployment);
       if (!deploymentParseResult.success) {
-        logger10.error(
+        logger11.error(
           COLORS.error`No network configured for contract ${contractName} on network ${network}`
         );
         return [];
@@ -66667,7 +67791,7 @@ var verifyNonTarget = async (config, logger10) => {
       const contractClassName = path.basename(contractName, ".sol");
       const source = deployment.metadata.sources[contractName];
       if (source == null) {
-        logger10.error(
+        logger11.error(
           COLORS.error`Missing source for contract ${contractName} for network ${network} in ${deploymentPath}`
         );
         return [];
@@ -66711,38 +67835,38 @@ var verifyNonTarget = async (config, logger10) => {
     }
   );
   if (verificationArtifacts.length === 0) {
-    logger10.warn("No contracts match the verification criteria, exiting");
+    logger11.warn("No contracts match the verification criteria, exiting");
     return [];
   }
   if (config.dryRun) {
-    logger10.debug("Dry run enabled, exiting");
+    logger11.debug("Dry run enabled, exiting");
     return [];
   }
   const results = await Promise.all(verifyAll(verificationArtifacts));
   results.forEach(logResult);
   return results;
 };
-var verifyTarget = async (config, logger10) => {
+var verifyTarget = async (config, logger11) => {
   const verify = parseFilterConfig(config.filter);
-  const networks = parseNetworksConfig(logger10, config.networks);
+  const networks = parseNetworksConfig(logger11, config.networks);
   const paths = parsePathsConfig(config.paths);
-  const recordLogger = createRecordLogger(logger10);
-  const verifyAll = createVerifyAll(logger10);
+  const recordLogger = createRecordLogger(logger11);
+  const verifyAll = createVerifyAll(logger11);
   const logResult = createLogVerificationResult(recordLogger);
   if (!isDirectory(paths.deployments)) {
     throw new Error(`Path ${paths.deployments} is not a directory`);
   }
   const deployedNetworkNames = new Set(fs.readdirSync(paths.deployments));
   const networkConfigEntries = Object.entries(networks);
-  logger10.debug("Verifying deployments for following networks:");
+  logger11.debug("Verifying deployments for following networks:");
   networkConfigEntries.forEach(([networkName, networkConfig]) => {
-    logger10.debug(`		- ${networkName} (API URL ${networkConfig.apiUrl})`);
+    logger11.debug(`		- ${networkName} (API URL ${networkConfig.apiUrl})`);
   });
   const verificationArtifacts = networkConfigEntries.flatMap(
     ([networkName, networkConfig]) => {
-      logger10.info(`Collecting deployments for ${networkName}...`);
+      logger11.info(`Collecting deployments for ${networkName}...`);
       if (!deployedNetworkNames.has(networkName)) {
-        logger10.warn(
+        logger11.warn(
           `Could not find deployment for network ${networkName} in ${paths.deployments}`
         );
         return [];
@@ -66753,7 +67877,7 @@ var verifyTarget = async (config, logger10) => {
       ).filter((fileName) => fileName.endsWith(".json"));
       return deployedContractFileNames.flatMap((fileName) => {
         var _a;
-        logger10.info(
+        logger11.info(
           `Inspecting deployment file ${fileName} on network ${networkName}`
         );
         const contractDeploymentPath = path.resolve(
@@ -66774,7 +67898,7 @@ var verifyTarget = async (config, logger10) => {
           (contractIdentifier) => compilationTargets[contractIdentifier] === contractName
         );
         if (compilationTarget == null) {
-          logger10.error(
+          logger11.error(
             COLORS.error`Could not find contract ${contractName} in the deployment file ${fileName} for network ${networkName}`
           );
           return [];
@@ -66785,14 +67909,14 @@ var verifyTarget = async (config, logger10) => {
           networkName
         );
         if (!shouldVerifyHardhatDeploy) {
-          logger10.debug(
+          logger11.debug(
             `No contracts to verify in ${fileName} on network ${networkName}, skipping`
           );
           return [];
         }
         const source = deployment.metadata.sources[compilationTarget];
         if (source == null) {
-          logger10.error(
+          logger11.error(
             COLORS.error`Could not find source for ${contractName} (${compilationTarget})`
           );
           return [];
@@ -66834,43 +67958,43 @@ var verifyTarget = async (config, logger10) => {
     }
   );
   if (verificationArtifacts.length === 0) {
-    logger10.warn("No contracts match the verification criteria, exiting");
+    logger11.warn("No contracts match the verification criteria, exiting");
     return [];
   }
   if (config.dryRun) {
-    logger10.debug("Dry run enabled, exiting");
+    logger11.debug("Dry run enabled, exiting");
     return [];
   }
   const results = await Promise.all(verifyAll(verificationArtifacts));
   results.forEach(logResult);
   return results;
 };
-var createVerifyAll = (logger10) => (artifacts) => {
+var createVerifyAll = (logger11) => (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_chalk3.default.bold(submitProps.contractName);
     const networkName = import_chalk3.default.bold(artifact.networkName);
-    logger10.info(
+    logger11.info(
       paletteColor`Verifying contract ${contractName} for network ${networkName} ${counter}`
     );
     try {
       const verification = createVerification(submitProps);
       verification.on("poll", (guid) => {
-        logger10.info(
+        logger11.info(
           paletteColor`Polling for verification status of ${contractName} for network ${networkName} (GUID ${guid}) ${counter}`
         );
       });
       verification.on("retry", (error, attempt) => {
-        logger10.info(
+        logger11.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) {
-      logger10.error(
+      logger11.error(
         COLORS.error`Problem verifying contract ${contractName} for network ${networkName} ${counter}: ${error} `
       );
       return { artifact, error };