@capxul/cli 4.20.0-beta.1

package/dist/lib-BOge5QZP.mjs

@@ -0,0 +1,2154 @@
+import { _ as __commonJSMin, n as require_lib$2, r as require_lib$1, t as require_lib$3 } from "./main.mjs";
+import { a as require_lib$4, i as require_lib$5, n as require_lib$6, t as require_lib$7 } from "./lib-DH_xJGSE.mjs";
+import { r as require_lib$8, t as require_lib$9 } from "./lib-C8ENT9j6.mjs";
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/_version.js
+var require__version = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.version = void 0;
+	exports.version = "abi/5.8.0";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/fragments.js
+var require_fragments = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ErrorFragment = exports.FunctionFragment = exports.ConstructorFragment = exports.EventFragment = exports.Fragment = exports.ParamType = exports.FormatTypes = void 0;
+	var bignumber_1 = require_lib$4();
+	var properties_1 = require_lib$5();
+	var logger_1 = require_lib$1();
+	var _version_1 = require__version();
+	var logger = new logger_1.Logger(_version_1.version);
+	var _constructorGuard = {};
+	var ModifiersBytes = {
+		calldata: true,
+		memory: true,
+		storage: true
+	};
+	var ModifiersNest = {
+		calldata: true,
+		memory: true
+	};
+	function checkModifier(type, name) {
+		if (type === "bytes" || type === "string") {
+			if (ModifiersBytes[name]) return true;
+		} else if (type === "address") {
+			if (name === "payable") return true;
+		} else if (type.indexOf("[") >= 0 || type === "tuple") {
+			if (ModifiersNest[name]) return true;
+		}
+		if (ModifiersBytes[name] || name === "payable") logger.throwArgumentError("invalid modifier", "name", name);
+		return false;
+	}
+	function parseParamType(param, allowIndexed) {
+		var originalParam = param;
+		function throwError(i) {
+			logger.throwArgumentError("unexpected character at position " + i, "param", param);
+		}
+		param = param.replace(/\s/g, " ");
+		function newNode(parent) {
+			var node = {
+				type: "",
+				name: "",
+				parent,
+				state: { allowType: true }
+			};
+			if (allowIndexed) node.indexed = false;
+			return node;
+		}
+		var parent = {
+			type: "",
+			name: "",
+			state: { allowType: true }
+		};
+		var node = parent;
+		for (var i = 0; i < param.length; i++) {
+			var c = param[i];
+			switch (c) {
+				case "(":
+					if (node.state.allowType && node.type === "") node.type = "tuple";
+					else if (!node.state.allowParams) throwError(i);
+					node.state.allowType = false;
+					node.type = verifyType(node.type);
+					node.components = [newNode(node)];
+					node = node.components[0];
+					break;
+				case ")":
+					delete node.state;
+					if (node.name === "indexed") {
+						if (!allowIndexed) throwError(i);
+						node.indexed = true;
+						node.name = "";
+					}
+					if (checkModifier(node.type, node.name)) node.name = "";
+					node.type = verifyType(node.type);
+					var child = node;
+					node = node.parent;
+					if (!node) throwError(i);
+					delete child.parent;
+					node.state.allowParams = false;
+					node.state.allowName = true;
+					node.state.allowArray = true;
+					break;
+				case ",":
+					delete node.state;
+					if (node.name === "indexed") {
+						if (!allowIndexed) throwError(i);
+						node.indexed = true;
+						node.name = "";
+					}
+					if (checkModifier(node.type, node.name)) node.name = "";
+					node.type = verifyType(node.type);
+					var sibling = newNode(node.parent);
+					node.parent.components.push(sibling);
+					delete node.parent;
+					node = sibling;
+					break;
+				case " ":
+					if (node.state.allowType) {
+						if (node.type !== "") {
+							node.type = verifyType(node.type);
+							delete node.state.allowType;
+							node.state.allowName = true;
+							node.state.allowParams = true;
+						}
+					}
+					if (node.state.allowName) {
+						if (node.name !== "") {
+							if (node.name === "indexed") {
+								if (!allowIndexed) throwError(i);
+								if (node.indexed) throwError(i);
+								node.indexed = true;
+								node.name = "";
+							} else if (checkModifier(node.type, node.name)) node.name = "";
+							else node.state.allowName = false;
+						}
+					}
+					break;
+				case "[":
+					if (!node.state.allowArray) throwError(i);
+					node.type += c;
+					node.state.allowArray = false;
+					node.state.allowName = false;
+					node.state.readArray = true;
+					break;
+				case "]":
+					if (!node.state.readArray) throwError(i);
+					node.type += c;
+					node.state.readArray = false;
+					node.state.allowArray = true;
+					node.state.allowName = true;
+					break;
+				default: if (node.state.allowType) {
+					node.type += c;
+					node.state.allowParams = true;
+					node.state.allowArray = true;
+				} else if (node.state.allowName) {
+					node.name += c;
+					delete node.state.allowArray;
+				} else if (node.state.readArray) node.type += c;
+				else throwError(i);
+			}
+		}
+		if (node.parent) logger.throwArgumentError("unexpected eof", "param", param);
+		delete parent.state;
+		if (node.name === "indexed") {
+			if (!allowIndexed) throwError(originalParam.length - 7);
+			if (node.indexed) throwError(originalParam.length - 7);
+			node.indexed = true;
+			node.name = "";
+		} else if (checkModifier(node.type, node.name)) node.name = "";
+		parent.type = verifyType(parent.type);
+		return parent;
+	}
+	function populate(object, params) {
+		for (var key in params) (0, properties_1.defineReadOnly)(object, key, params[key]);
+	}
+	exports.FormatTypes = Object.freeze({
+		sighash: "sighash",
+		minimal: "minimal",
+		full: "full",
+		json: "json"
+	});
+	var paramTypeArray = /* @__PURE__ */ new RegExp(/^(.*)\[([0-9]*)\]$/);
+	var ParamType = function() {
+		function ParamType(constructorGuard, params) {
+			if (constructorGuard !== _constructorGuard) logger.throwError("use fromString", logger_1.Logger.errors.UNSUPPORTED_OPERATION, { operation: "new ParamType()" });
+			populate(this, params);
+			var match = this.type.match(paramTypeArray);
+			if (match) populate(this, {
+				arrayLength: parseInt(match[2] || "-1"),
+				arrayChildren: ParamType.fromObject({
+					type: match[1],
+					components: this.components
+				}),
+				baseType: "array"
+			});
+			else populate(this, {
+				arrayLength: null,
+				arrayChildren: null,
+				baseType: this.components != null ? "tuple" : this.type
+			});
+			this._isParamType = true;
+			Object.freeze(this);
+		}
+		ParamType.prototype.format = function(format) {
+			if (!format) format = exports.FormatTypes.sighash;
+			if (!exports.FormatTypes[format]) logger.throwArgumentError("invalid format type", "format", format);
+			if (format === exports.FormatTypes.json) {
+				var result_1 = {
+					type: this.baseType === "tuple" ? "tuple" : this.type,
+					name: this.name || void 0
+				};
+				if (typeof this.indexed === "boolean") result_1.indexed = this.indexed;
+				if (this.components) result_1.components = this.components.map(function(comp) {
+					return JSON.parse(comp.format(format));
+				});
+				return JSON.stringify(result_1);
+			}
+			var result = "";
+			if (this.baseType === "array") {
+				result += this.arrayChildren.format(format);
+				result += "[" + (this.arrayLength < 0 ? "" : String(this.arrayLength)) + "]";
+			} else if (this.baseType === "tuple") {
+				if (format !== exports.FormatTypes.sighash) result += this.type;
+				result += "(" + this.components.map(function(comp) {
+					return comp.format(format);
+				}).join(format === exports.FormatTypes.full ? ", " : ",") + ")";
+			} else result += this.type;
+			if (format !== exports.FormatTypes.sighash) {
+				if (this.indexed === true) result += " indexed";
+				if (format === exports.FormatTypes.full && this.name) result += " " + this.name;
+			}
+			return result;
+		};
+		ParamType.from = function(value, allowIndexed) {
+			if (typeof value === "string") return ParamType.fromString(value, allowIndexed);
+			return ParamType.fromObject(value);
+		};
+		ParamType.fromObject = function(value) {
+			if (ParamType.isParamType(value)) return value;
+			return new ParamType(_constructorGuard, {
+				name: value.name || null,
+				type: verifyType(value.type),
+				indexed: value.indexed == null ? null : !!value.indexed,
+				components: value.components ? value.components.map(ParamType.fromObject) : null
+			});
+		};
+		ParamType.fromString = function(value, allowIndexed) {
+			function ParamTypify(node) {
+				return ParamType.fromObject({
+					name: node.name,
+					type: node.type,
+					indexed: node.indexed,
+					components: node.components
+				});
+			}
+			return ParamTypify(parseParamType(value, !!allowIndexed));
+		};
+		ParamType.isParamType = function(value) {
+			return !!(value != null && value._isParamType);
+		};
+		return ParamType;
+	}();
+	exports.ParamType = ParamType;
+	function parseParams(value, allowIndex) {
+		return splitNesting(value).map(function(param) {
+			return ParamType.fromString(param, allowIndex);
+		});
+	}
+	var Fragment = function() {
+		function Fragment(constructorGuard, params) {
+			if (constructorGuard !== _constructorGuard) logger.throwError("use a static from method", logger_1.Logger.errors.UNSUPPORTED_OPERATION, { operation: "new Fragment()" });
+			populate(this, params);
+			this._isFragment = true;
+			Object.freeze(this);
+		}
+		Fragment.from = function(value) {
+			if (Fragment.isFragment(value)) return value;
+			if (typeof value === "string") return Fragment.fromString(value);
+			return Fragment.fromObject(value);
+		};
+		Fragment.fromObject = function(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 logger.throwArgumentError("invalid fragment object", "value", value);
+		};
+		Fragment.fromString = function(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 logger.throwArgumentError("unsupported fragment", "value", value);
+		};
+		Fragment.isFragment = function(value) {
+			return !!(value && value._isFragment);
+		};
+		return Fragment;
+	}();
+	exports.Fragment = Fragment;
+	var EventFragment = function(_super) {
+		__extends(EventFragment, _super);
+		function EventFragment() {
+			return _super !== null && _super.apply(this, arguments) || this;
+		}
+		EventFragment.prototype.format = function(format) {
+			if (!format) format = exports.FormatTypes.sighash;
+			if (!exports.FormatTypes[format]) logger.throwArgumentError("invalid format type", "format", format);
+			if (format === exports.FormatTypes.json) return JSON.stringify({
+				type: "event",
+				anonymous: this.anonymous,
+				name: this.name,
+				inputs: this.inputs.map(function(input) {
+					return JSON.parse(input.format(format));
+				})
+			});
+			var result = "";
+			if (format !== exports.FormatTypes.sighash) result += "event ";
+			result += this.name + "(" + this.inputs.map(function(input) {
+				return input.format(format);
+			}).join(format === exports.FormatTypes.full ? ", " : ",") + ") ";
+			if (format !== exports.FormatTypes.sighash) {
+				if (this.anonymous) result += "anonymous ";
+			}
+			return result.trim();
+		};
+		EventFragment.from = function(value) {
+			if (typeof value === "string") return EventFragment.fromString(value);
+			return EventFragment.fromObject(value);
+		};
+		EventFragment.fromObject = function(value) {
+			if (EventFragment.isEventFragment(value)) return value;
+			if (value.type !== "event") logger.throwArgumentError("invalid event object", "value", value);
+			return new EventFragment(_constructorGuard, {
+				name: verifyIdentifier(value.name),
+				anonymous: value.anonymous,
+				inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [],
+				type: "event"
+			});
+		};
+		EventFragment.fromString = function(value) {
+			var match = value.match(regexParen);
+			if (!match) logger.throwArgumentError("invalid event string", "value", value);
+			var anonymous = false;
+			match[3].split(" ").forEach(function(modifier) {
+				switch (modifier.trim()) {
+					case "anonymous":
+						anonymous = true;
+						break;
+					case "": break;
+					default: logger.warn("unknown modifier: " + modifier);
+				}
+			});
+			return EventFragment.fromObject({
+				name: match[1].trim(),
+				anonymous,
+				inputs: parseParams(match[2], true),
+				type: "event"
+			});
+		};
+		EventFragment.isEventFragment = function(value) {
+			return value && value._isFragment && value.type === "event";
+		};
+		return EventFragment;
+	}(Fragment);
+	exports.EventFragment = EventFragment;
+	function parseGas(value, params) {
+		params.gas = null;
+		var comps = value.split("@");
+		if (comps.length !== 1) {
+			if (comps.length > 2) logger.throwArgumentError("invalid human-readable ABI signature", "value", value);
+			if (!comps[1].match(/^[0-9]+$/)) logger.throwArgumentError("invalid human-readable ABI signature gas", "value", value);
+			params.gas = bignumber_1.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(function(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) {
+		var 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) logger.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) logger.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") logger.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) logger.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") logger.throwArgumentError("unable to determine stateMutability", "value", value);
+		return result;
+	}
+	var ConstructorFragment = function(_super) {
+		__extends(ConstructorFragment, _super);
+		function ConstructorFragment() {
+			return _super !== null && _super.apply(this, arguments) || this;
+		}
+		ConstructorFragment.prototype.format = function(format) {
+			if (!format) format = exports.FormatTypes.sighash;
+			if (!exports.FormatTypes[format]) logger.throwArgumentError("invalid format type", "format", format);
+			if (format === exports.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(function(input) {
+					return JSON.parse(input.format(format));
+				})
+			});
+			if (format === exports.FormatTypes.sighash) logger.throwError("cannot format a constructor for sighash", logger_1.Logger.errors.UNSUPPORTED_OPERATION, { operation: "format(sighash)" });
+			var result = "constructor(" + this.inputs.map(function(input) {
+				return input.format(format);
+			}).join(format === exports.FormatTypes.full ? ", " : ",") + ") ";
+			if (this.stateMutability && this.stateMutability !== "nonpayable") result += this.stateMutability + " ";
+			return result.trim();
+		};
+		ConstructorFragment.from = function(value) {
+			if (typeof value === "string") return ConstructorFragment.fromString(value);
+			return ConstructorFragment.fromObject(value);
+		};
+		ConstructorFragment.fromObject = function(value) {
+			if (ConstructorFragment.isConstructorFragment(value)) return value;
+			if (value.type !== "constructor") logger.throwArgumentError("invalid constructor object", "value", value);
+			var state = verifyState(value);
+			if (state.constant) logger.throwArgumentError("constructor cannot be constant", "value", value);
+			return new ConstructorFragment(_constructorGuard, {
+				name: null,
+				type: value.type,
+				inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : [],
+				payable: state.payable,
+				stateMutability: state.stateMutability,
+				gas: value.gas ? bignumber_1.BigNumber.from(value.gas) : null
+			});
+		};
+		ConstructorFragment.fromString = function(value) {
+			var params = { type: "constructor" };
+			value = parseGas(value, params);
+			var parens = value.match(regexParen);
+			if (!parens || parens[1].trim() !== "constructor") logger.throwArgumentError("invalid constructor string", "value", value);
+			params.inputs = parseParams(parens[2].trim(), false);
+			parseModifiers(parens[3].trim(), params);
+			return ConstructorFragment.fromObject(params);
+		};
+		ConstructorFragment.isConstructorFragment = function(value) {
+			return value && value._isFragment && value.type === "constructor";
+		};
+		return ConstructorFragment;
+	}(Fragment);
+	exports.ConstructorFragment = ConstructorFragment;
+	var FunctionFragment = function(_super) {
+		__extends(FunctionFragment, _super);
+		function FunctionFragment() {
+			return _super !== null && _super.apply(this, arguments) || this;
+		}
+		FunctionFragment.prototype.format = function(format) {
+			if (!format) format = exports.FormatTypes.sighash;
+			if (!exports.FormatTypes[format]) logger.throwArgumentError("invalid format type", "format", format);
+			if (format === exports.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(function(input) {
+					return JSON.parse(input.format(format));
+				}),
+				outputs: this.outputs.map(function(output) {
+					return JSON.parse(output.format(format));
+				})
+			});
+			var result = "";
+			if (format !== exports.FormatTypes.sighash) result += "function ";
+			result += this.name + "(" + this.inputs.map(function(input) {
+				return input.format(format);
+			}).join(format === exports.FormatTypes.full ? ", " : ",") + ") ";
+			if (format !== exports.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(function(output) {
+					return output.format(format);
+				}).join(", ") + ") ";
+				if (this.gas != null) result += "@" + this.gas.toString() + " ";
+			}
+			return result.trim();
+		};
+		FunctionFragment.from = function(value) {
+			if (typeof value === "string") return FunctionFragment.fromString(value);
+			return FunctionFragment.fromObject(value);
+		};
+		FunctionFragment.fromObject = function(value) {
+			if (FunctionFragment.isFunctionFragment(value)) return value;
+			if (value.type !== "function") logger.throwArgumentError("invalid function object", "value", value);
+			var state = verifyState(value);
+			return new FunctionFragment(_constructorGuard, {
+				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_1.BigNumber.from(value.gas) : null
+			});
+		};
+		FunctionFragment.fromString = function(value) {
+			var params = { type: "function" };
+			value = parseGas(value, params);
+			var comps = value.split(" returns ");
+			if (comps.length > 2) logger.throwArgumentError("invalid function string", "value", value);
+			var parens = comps[0].match(regexParen);
+			if (!parens) logger.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) {
+				var returns = comps[1].match(regexParen);
+				if (returns[1].trim() != "" || returns[3].trim() != "") logger.throwArgumentError("unexpected tokens", "value", value);
+				params.outputs = parseParams(returns[2], false);
+			} else params.outputs = [];
+			return FunctionFragment.fromObject(params);
+		};
+		FunctionFragment.isFunctionFragment = function(value) {
+			return value && value._isFragment && value.type === "function";
+		};
+		return FunctionFragment;
+	}(ConstructorFragment);
+	exports.FunctionFragment = FunctionFragment;
+	function checkForbidden(fragment) {
+		var sig = fragment.format();
+		if (sig === "Error(string)" || sig === "Panic(uint256)") logger.throwArgumentError("cannot specify user defined " + sig + " error", "fragment", fragment);
+		return fragment;
+	}
+	var ErrorFragment = function(_super) {
+		__extends(ErrorFragment, _super);
+		function ErrorFragment() {
+			return _super !== null && _super.apply(this, arguments) || this;
+		}
+		ErrorFragment.prototype.format = function(format) {
+			if (!format) format = exports.FormatTypes.sighash;
+			if (!exports.FormatTypes[format]) logger.throwArgumentError("invalid format type", "format", format);
+			if (format === exports.FormatTypes.json) return JSON.stringify({
+				type: "error",
+				name: this.name,
+				inputs: this.inputs.map(function(input) {
+					return JSON.parse(input.format(format));
+				})
+			});
+			var result = "";
+			if (format !== exports.FormatTypes.sighash) result += "error ";
+			result += this.name + "(" + this.inputs.map(function(input) {
+				return input.format(format);
+			}).join(format === exports.FormatTypes.full ? ", " : ",") + ") ";
+			return result.trim();
+		};
+		ErrorFragment.from = function(value) {
+			if (typeof value === "string") return ErrorFragment.fromString(value);
+			return ErrorFragment.fromObject(value);
+		};
+		ErrorFragment.fromObject = function(value) {
+			if (ErrorFragment.isErrorFragment(value)) return value;
+			if (value.type !== "error") logger.throwArgumentError("invalid error object", "value", value);
+			return checkForbidden(new ErrorFragment(_constructorGuard, {
+				type: value.type,
+				name: verifyIdentifier(value.name),
+				inputs: value.inputs ? value.inputs.map(ParamType.fromObject) : []
+			}));
+		};
+		ErrorFragment.fromString = function(value) {
+			var params = { type: "error" };
+			var parens = value.match(regexParen);
+			if (!parens) logger.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));
+		};
+		ErrorFragment.isErrorFragment = function(value) {
+			return value && value._isFragment && value.type === "error";
+		};
+		return ErrorFragment;
+	}(Fragment);
+	exports.ErrorFragment = ErrorFragment;
+	function verifyType(type) {
+		if (type.match(/^uint($|[^1-9])/)) type = "uint256" + type.substring(4);
+		else if (type.match(/^int($|[^1-9])/)) type = "int256" + type.substring(3);
+		return type;
+	}
+	var regexIdentifier = /* @__PURE__ */ new RegExp("^[a-zA-Z$_][a-zA-Z0-9$_]*$");
+	function verifyIdentifier(value) {
+		if (!value || !value.match(regexIdentifier)) logger.throwArgumentError("invalid identifier \"" + value + "\"", "value", value);
+		return value;
+	}
+	var regexParen = /* @__PURE__ */ new RegExp("^([^)(]*)\\((.*)\\)([^)(]*)$");
+	function splitNesting(value) {
+		value = value.trim();
+		var result = [];
+		var accum = "";
+		var depth = 0;
+		for (var offset = 0; offset < value.length; offset++) {
+			var c = value[offset];
+			if (c === "," && depth === 0) {
+				result.push(accum);
+				accum = "";
+			} else {
+				accum += c;
+				if (c === "(") depth++;
+				else if (c === ")") {
+					depth--;
+					if (depth === -1) logger.throwArgumentError("unbalanced parenthesis", "value", value);
+				}
+			}
+		}
+		if (accum) result.push(accum);
+		return result;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/abstract-coder.js
+var require_abstract_coder = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Reader = exports.Writer = exports.Coder = exports.checkResultErrors = void 0;
+	var bytes_1 = require_lib$2();
+	var bignumber_1 = require_lib$4();
+	var properties_1 = require_lib$5();
+	var logger_1 = require_lib$1();
+	var _version_1 = require__version();
+	var logger = new logger_1.Logger(_version_1.version);
+	function checkResultErrors(result) {
+		var errors = [];
+		var checkErrors = function(path, object) {
+			if (!Array.isArray(object)) return;
+			for (var key in object) {
+				var childPath = path.slice();
+				childPath.push(key);
+				try {
+					checkErrors(childPath, object[key]);
+				} catch (error) {
+					errors.push({
+						path: childPath,
+						error
+					});
+				}
+			}
+		};
+		checkErrors([], result);
+		return errors;
+	}
+	exports.checkResultErrors = checkResultErrors;
+	exports.Coder = function() {
+		function Coder(name, type, localName, dynamic) {
+			this.name = name;
+			this.type = type;
+			this.localName = localName;
+			this.dynamic = dynamic;
+		}
+		Coder.prototype._throwError = function(message, value) {
+			logger.throwArgumentError(message, this.localName, value);
+		};
+		return Coder;
+	}();
+	exports.Writer = function() {
+		function Writer(wordSize) {
+			(0, properties_1.defineReadOnly)(this, "wordSize", wordSize || 32);
+			this._data = [];
+			this._dataLength = 0;
+			this._padding = new Uint8Array(wordSize);
+		}
+		Object.defineProperty(Writer.prototype, "data", {
+			get: function() {
+				return (0, bytes_1.hexConcat)(this._data);
+			},
+			enumerable: false,
+			configurable: true
+		});
+		Object.defineProperty(Writer.prototype, "length", {
+			get: function() {
+				return this._dataLength;
+			},
+			enumerable: false,
+			configurable: true
+		});
+		Writer.prototype._writeData = function(data) {
+			this._data.push(data);
+			this._dataLength += data.length;
+			return data.length;
+		};
+		Writer.prototype.appendWriter = function(writer) {
+			return this._writeData((0, bytes_1.concat)(writer._data));
+		};
+		Writer.prototype.writeBytes = function(value) {
+			var bytes = (0, bytes_1.arrayify)(value);
+			var paddingOffset = bytes.length % this.wordSize;
+			if (paddingOffset) bytes = (0, bytes_1.concat)([bytes, this._padding.slice(paddingOffset)]);
+			return this._writeData(bytes);
+		};
+		Writer.prototype._getValue = function(value) {
+			var bytes = (0, bytes_1.arrayify)(bignumber_1.BigNumber.from(value));
+			if (bytes.length > this.wordSize) logger.throwError("value out-of-bounds", logger_1.Logger.errors.BUFFER_OVERRUN, {
+				length: this.wordSize,
+				offset: bytes.length
+			});
+			if (bytes.length % this.wordSize) bytes = (0, bytes_1.concat)([this._padding.slice(bytes.length % this.wordSize), bytes]);
+			return bytes;
+		};
+		Writer.prototype.writeValue = function(value) {
+			return this._writeData(this._getValue(value));
+		};
+		Writer.prototype.writeUpdatableValue = function() {
+			var _this = this;
+			var offset = this._data.length;
+			this._data.push(this._padding);
+			this._dataLength += this.wordSize;
+			return function(value) {
+				_this._data[offset] = _this._getValue(value);
+			};
+		};
+		return Writer;
+	}();
+	exports.Reader = function() {
+		function Reader(data, wordSize, coerceFunc, allowLoose) {
+			(0, properties_1.defineReadOnly)(this, "_data", (0, bytes_1.arrayify)(data));
+			(0, properties_1.defineReadOnly)(this, "wordSize", wordSize || 32);
+			(0, properties_1.defineReadOnly)(this, "_coerceFunc", coerceFunc);
+			(0, properties_1.defineReadOnly)(this, "allowLoose", allowLoose);
+			this._offset = 0;
+		}
+		Object.defineProperty(Reader.prototype, "data", {
+			get: function() {
+				return (0, bytes_1.hexlify)(this._data);
+			},
+			enumerable: false,
+			configurable: true
+		});
+		Object.defineProperty(Reader.prototype, "consumed", {
+			get: function() {
+				return this._offset;
+			},
+			enumerable: false,
+			configurable: true
+		});
+		Reader.coerce = function(name, value) {
+			var match = name.match("^u?int([0-9]+)$");
+			if (match && parseInt(match[1]) <= 48) value = value.toNumber();
+			return value;
+		};
+		Reader.prototype.coerce = function(name, value) {
+			if (this._coerceFunc) return this._coerceFunc(name, value);
+			return Reader.coerce(name, value);
+		};
+		Reader.prototype._peekBytes = function(offset, length, loose) {
+			var alignedLength = Math.ceil(length / this.wordSize) * this.wordSize;
+			if (this._offset + alignedLength > this._data.length) {
+				if (this.allowLoose && loose && this._offset + length <= this._data.length) alignedLength = length;
+				else logger.throwError("data out-of-bounds", logger_1.Logger.errors.BUFFER_OVERRUN, {
+					length: this._data.length,
+					offset: this._offset + alignedLength
+				});
+			}
+			return this._data.slice(this._offset, this._offset + alignedLength);
+		};
+		Reader.prototype.subReader = function(offset) {
+			return new Reader(this._data.slice(this._offset + offset), this.wordSize, this._coerceFunc, this.allowLoose);
+		};
+		Reader.prototype.readBytes = function(length, loose) {
+			var bytes = this._peekBytes(0, length, !!loose);
+			this._offset += bytes.length;
+			return bytes.slice(0, length);
+		};
+		Reader.prototype.readValue = function() {
+			return bignumber_1.BigNumber.from(this.readBytes(this.wordSize));
+		};
+		return Reader;
+	}();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/address.js
+var require_address = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.AddressCoder = void 0;
+	var address_1 = require_lib$6();
+	var bytes_1 = require_lib$2();
+	exports.AddressCoder = function(_super) {
+		__extends(AddressCoder, _super);
+		function AddressCoder(localName) {
+			return _super.call(this, "address", "address", localName, false) || this;
+		}
+		AddressCoder.prototype.defaultValue = function() {
+			return "0x0000000000000000000000000000000000000000";
+		};
+		AddressCoder.prototype.encode = function(writer, value) {
+			try {
+				value = (0, address_1.getAddress)(value);
+			} catch (error) {
+				this._throwError(error.message, value);
+			}
+			return writer.writeValue(value);
+		};
+		AddressCoder.prototype.decode = function(reader) {
+			return (0, address_1.getAddress)((0, bytes_1.hexZeroPad)(reader.readValue().toHexString(), 20));
+		};
+		return AddressCoder;
+	}(require_abstract_coder().Coder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/anonymous.js
+var require_anonymous = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.AnonymousCoder = void 0;
+	exports.AnonymousCoder = function(_super) {
+		__extends(AnonymousCoder, _super);
+		function AnonymousCoder(coder) {
+			var _this = _super.call(this, coder.name, coder.type, void 0, coder.dynamic) || this;
+			_this.coder = coder;
+			return _this;
+		}
+		AnonymousCoder.prototype.defaultValue = function() {
+			return this.coder.defaultValue();
+		};
+		AnonymousCoder.prototype.encode = function(writer, value) {
+			return this.coder.encode(writer, value);
+		};
+		AnonymousCoder.prototype.decode = function(reader) {
+			return this.coder.decode(reader);
+		};
+		return AnonymousCoder;
+	}(require_abstract_coder().Coder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/array.js
+var require_array = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ArrayCoder = exports.unpack = exports.pack = void 0;
+	var logger_1 = require_lib$1();
+	var _version_1 = require__version();
+	var logger = new logger_1.Logger(_version_1.version);
+	var abstract_coder_1 = require_abstract_coder();
+	var anonymous_1 = require_anonymous();
+	function pack(writer, coders, values) {
+		var arrayValues = null;
+		if (Array.isArray(values)) arrayValues = values;
+		else if (values && typeof values === "object") {
+			var unique_1 = {};
+			arrayValues = coders.map(function(coder) {
+				var name = coder.localName;
+				if (!name) logger.throwError("cannot encode object for signature with missing names", logger_1.Logger.errors.INVALID_ARGUMENT, {
+					argument: "values",
+					coder,
+					value: values
+				});
+				if (unique_1[name]) logger.throwError("cannot encode object for signature with duplicate names", logger_1.Logger.errors.INVALID_ARGUMENT, {
+					argument: "values",
+					coder,
+					value: values
+				});
+				unique_1[name] = true;
+				return values[name];
+			});
+		} else logger.throwArgumentError("invalid tuple value", "tuple", values);
+		if (coders.length !== arrayValues.length) logger.throwArgumentError("types/value length mismatch", "tuple", values);
+		var staticWriter = new abstract_coder_1.Writer(writer.wordSize);
+		var dynamicWriter = new abstract_coder_1.Writer(writer.wordSize);
+		var updateFuncs = [];
+		coders.forEach(function(coder, index) {
+			var value = arrayValues[index];
+			if (coder.dynamic) {
+				var dynamicOffset_1 = dynamicWriter.length;
+				coder.encode(dynamicWriter, value);
+				var updateFunc_1 = staticWriter.writeUpdatableValue();
+				updateFuncs.push(function(baseOffset) {
+					updateFunc_1(baseOffset + dynamicOffset_1);
+				});
+			} else coder.encode(staticWriter, value);
+		});
+		updateFuncs.forEach(function(func) {
+			func(staticWriter.length);
+		});
+		var length = writer.appendWriter(staticWriter);
+		length += writer.appendWriter(dynamicWriter);
+		return length;
+	}
+	exports.pack = pack;
+	function unpack(reader, coders) {
+		var values = [];
+		var baseReader = reader.subReader(0);
+		coders.forEach(function(coder) {
+			var value = null;
+			if (coder.dynamic) {
+				var offset = reader.readValue();
+				var offsetReader = baseReader.subReader(offset.toNumber());
+				try {
+					value = coder.decode(offsetReader);
+				} catch (error) {
+					if (error.code === logger_1.Logger.errors.BUFFER_OVERRUN) throw error;
+					value = error;
+					value.baseType = coder.name;
+					value.name = coder.localName;
+					value.type = coder.type;
+				}
+			} else try {
+				value = coder.decode(reader);
+			} catch (error) {
+				if (error.code === logger_1.Logger.errors.BUFFER_OVERRUN) throw error;
+				value = error;
+				value.baseType = coder.name;
+				value.name = coder.localName;
+				value.type = coder.type;
+			}
+			if (value != void 0) values.push(value);
+		});
+		var uniqueNames = coders.reduce(function(accum, coder) {
+			var name = coder.localName;
+			if (name) {
+				if (!accum[name]) accum[name] = 0;
+				accum[name]++;
+			}
+			return accum;
+		}, {});
+		coders.forEach(function(coder, index) {
+			var name = coder.localName;
+			if (!name || uniqueNames[name] !== 1) return;
+			if (name === "length") name = "_length";
+			if (values[name] != null) return;
+			var value = values[index];
+			if (value instanceof Error) Object.defineProperty(values, name, {
+				enumerable: true,
+				get: function() {
+					throw value;
+				}
+			});
+			else values[name] = value;
+		});
+		var _loop_1 = function(i) {
+			var value = values[i];
+			if (value instanceof Error) Object.defineProperty(values, i, {
+				enumerable: true,
+				get: function() {
+					throw value;
+				}
+			});
+		};
+		for (var i = 0; i < values.length; i++) _loop_1(i);
+		return Object.freeze(values);
+	}
+	exports.unpack = unpack;
+	exports.ArrayCoder = function(_super) {
+		__extends(ArrayCoder, _super);
+		function ArrayCoder(coder, length, localName) {
+			var _this = this;
+			var type = coder.type + "[" + (length >= 0 ? length : "") + "]";
+			var dynamic = length === -1 || coder.dynamic;
+			_this = _super.call(this, "array", type, localName, dynamic) || this;
+			_this.coder = coder;
+			_this.length = length;
+			return _this;
+		}
+		ArrayCoder.prototype.defaultValue = function() {
+			var defaultChild = this.coder.defaultValue();
+			var result = [];
+			for (var i = 0; i < this.length; i++) result.push(defaultChild);
+			return result;
+		};
+		ArrayCoder.prototype.encode = function(writer, value) {
+			if (!Array.isArray(value)) this._throwError("expected array value", value);
+			var count = this.length;
+			if (count === -1) {
+				count = value.length;
+				writer.writeValue(value.length);
+			}
+			logger.checkArgumentCount(value.length, count, "coder array" + (this.localName ? " " + this.localName : ""));
+			var coders = [];
+			for (var i = 0; i < value.length; i++) coders.push(this.coder);
+			return pack(writer, coders, value);
+		};
+		ArrayCoder.prototype.decode = function(reader) {
+			var count = this.length;
+			if (count === -1) {
+				count = reader.readValue().toNumber();
+				if (count * 32 > reader._data.length) logger.throwError("insufficient data length", logger_1.Logger.errors.BUFFER_OVERRUN, {
+					length: reader._data.length,
+					count
+				});
+			}
+			var coders = [];
+			for (var i = 0; i < count; i++) coders.push(new anonymous_1.AnonymousCoder(this.coder));
+			return reader.coerce(this.name, unpack(reader, coders));
+		};
+		return ArrayCoder;
+	}(abstract_coder_1.Coder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/boolean.js
+var require_boolean = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.BooleanCoder = void 0;
+	exports.BooleanCoder = function(_super) {
+		__extends(BooleanCoder, _super);
+		function BooleanCoder(localName) {
+			return _super.call(this, "bool", "bool", localName, false) || this;
+		}
+		BooleanCoder.prototype.defaultValue = function() {
+			return false;
+		};
+		BooleanCoder.prototype.encode = function(writer, value) {
+			return writer.writeValue(value ? 1 : 0);
+		};
+		BooleanCoder.prototype.decode = function(reader) {
+			return reader.coerce(this.type, !reader.readValue().isZero());
+		};
+		return BooleanCoder;
+	}(require_abstract_coder().Coder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/bytes.js
+var require_bytes = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.BytesCoder = exports.DynamicBytesCoder = void 0;
+	var bytes_1 = require_lib$2();
+	var DynamicBytesCoder = function(_super) {
+		__extends(DynamicBytesCoder, _super);
+		function DynamicBytesCoder(type, localName) {
+			return _super.call(this, type, type, localName, true) || this;
+		}
+		DynamicBytesCoder.prototype.defaultValue = function() {
+			return "0x";
+		};
+		DynamicBytesCoder.prototype.encode = function(writer, value) {
+			value = (0, bytes_1.arrayify)(value);
+			var length = writer.writeValue(value.length);
+			length += writer.writeBytes(value);
+			return length;
+		};
+		DynamicBytesCoder.prototype.decode = function(reader) {
+			return reader.readBytes(reader.readValue().toNumber(), true);
+		};
+		return DynamicBytesCoder;
+	}(require_abstract_coder().Coder);
+	exports.DynamicBytesCoder = DynamicBytesCoder;
+	exports.BytesCoder = function(_super) {
+		__extends(BytesCoder, _super);
+		function BytesCoder(localName) {
+			return _super.call(this, "bytes", localName) || this;
+		}
+		BytesCoder.prototype.decode = function(reader) {
+			return reader.coerce(this.name, (0, bytes_1.hexlify)(_super.prototype.decode.call(this, reader)));
+		};
+		return BytesCoder;
+	}(DynamicBytesCoder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/fixed-bytes.js
+var require_fixed_bytes = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.FixedBytesCoder = void 0;
+	var bytes_1 = require_lib$2();
+	exports.FixedBytesCoder = function(_super) {
+		__extends(FixedBytesCoder, _super);
+		function FixedBytesCoder(size, localName) {
+			var _this = this;
+			var name = "bytes" + String(size);
+			_this = _super.call(this, name, name, localName, false) || this;
+			_this.size = size;
+			return _this;
+		}
+		FixedBytesCoder.prototype.defaultValue = function() {
+			return "0x0000000000000000000000000000000000000000000000000000000000000000".substring(0, 2 + this.size * 2);
+		};
+		FixedBytesCoder.prototype.encode = function(writer, value) {
+			var data = (0, bytes_1.arrayify)(value);
+			if (data.length !== this.size) this._throwError("incorrect data length", value);
+			return writer.writeBytes(data);
+		};
+		FixedBytesCoder.prototype.decode = function(reader) {
+			return reader.coerce(this.name, (0, bytes_1.hexlify)(reader.readBytes(this.size)));
+		};
+		return FixedBytesCoder;
+	}(require_abstract_coder().Coder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/null.js
+var require_null = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.NullCoder = void 0;
+	exports.NullCoder = function(_super) {
+		__extends(NullCoder, _super);
+		function NullCoder(localName) {
+			return _super.call(this, "null", "", localName, false) || this;
+		}
+		NullCoder.prototype.defaultValue = function() {
+			return null;
+		};
+		NullCoder.prototype.encode = function(writer, value) {
+			if (value != null) this._throwError("not null", value);
+			return writer.writeBytes([]);
+		};
+		NullCoder.prototype.decode = function(reader) {
+			reader.readBytes(0);
+			return reader.coerce(this.name, null);
+		};
+		return NullCoder;
+	}(require_abstract_coder().Coder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/number.js
+var require_number = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.NumberCoder = void 0;
+	var bignumber_1 = require_lib$4();
+	var constants_1 = require_lib$7();
+	exports.NumberCoder = function(_super) {
+		__extends(NumberCoder, _super);
+		function NumberCoder(size, signed, localName) {
+			var _this = this;
+			var name = (signed ? "int" : "uint") + size * 8;
+			_this = _super.call(this, name, name, localName, false) || this;
+			_this.size = size;
+			_this.signed = signed;
+			return _this;
+		}
+		NumberCoder.prototype.defaultValue = function() {
+			return 0;
+		};
+		NumberCoder.prototype.encode = function(writer, value) {
+			var v = bignumber_1.BigNumber.from(value);
+			var maxUintValue = constants_1.MaxUint256.mask(writer.wordSize * 8);
+			if (this.signed) {
+				var bounds = maxUintValue.mask(this.size * 8 - 1);
+				if (v.gt(bounds) || v.lt(bounds.add(constants_1.One).mul(constants_1.NegativeOne))) this._throwError("value out-of-bounds", value);
+			} else if (v.lt(constants_1.Zero) || v.gt(maxUintValue.mask(this.size * 8))) this._throwError("value out-of-bounds", value);
+			v = v.toTwos(this.size * 8).mask(this.size * 8);
+			if (this.signed) v = v.fromTwos(this.size * 8).toTwos(8 * writer.wordSize);
+			return writer.writeValue(v);
+		};
+		NumberCoder.prototype.decode = function(reader) {
+			var value = reader.readValue().mask(this.size * 8);
+			if (this.signed) value = value.fromTwos(this.size * 8);
+			return reader.coerce(this.name, value);
+		};
+		return NumberCoder;
+	}(require_abstract_coder().Coder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/string.js
+var require_string = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.StringCoder = void 0;
+	var strings_1 = require_lib$8();
+	exports.StringCoder = function(_super) {
+		__extends(StringCoder, _super);
+		function StringCoder(localName) {
+			return _super.call(this, "string", localName) || this;
+		}
+		StringCoder.prototype.defaultValue = function() {
+			return "";
+		};
+		StringCoder.prototype.encode = function(writer, value) {
+			return _super.prototype.encode.call(this, writer, (0, strings_1.toUtf8Bytes)(value));
+		};
+		StringCoder.prototype.decode = function(reader) {
+			return (0, strings_1.toUtf8String)(_super.prototype.decode.call(this, reader));
+		};
+		return StringCoder;
+	}(require_bytes().DynamicBytesCoder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/coders/tuple.js
+var require_tuple = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.TupleCoder = void 0;
+	var abstract_coder_1 = require_abstract_coder();
+	var array_1 = require_array();
+	exports.TupleCoder = function(_super) {
+		__extends(TupleCoder, _super);
+		function TupleCoder(coders, localName) {
+			var _this = this;
+			var dynamic = false;
+			var types = [];
+			coders.forEach(function(coder) {
+				if (coder.dynamic) dynamic = true;
+				types.push(coder.type);
+			});
+			var type = "tuple(" + types.join(",") + ")";
+			_this = _super.call(this, "tuple", type, localName, dynamic) || this;
+			_this.coders = coders;
+			return _this;
+		}
+		TupleCoder.prototype.defaultValue = function() {
+			var values = [];
+			this.coders.forEach(function(coder) {
+				values.push(coder.defaultValue());
+			});
+			var uniqueNames = this.coders.reduce(function(accum, coder) {
+				var name = coder.localName;
+				if (name) {
+					if (!accum[name]) accum[name] = 0;
+					accum[name]++;
+				}
+				return accum;
+			}, {});
+			this.coders.forEach(function(coder, index) {
+				var name = coder.localName;
+				if (!name || uniqueNames[name] !== 1) return;
+				if (name === "length") name = "_length";
+				if (values[name] != null) return;
+				values[name] = values[index];
+			});
+			return Object.freeze(values);
+		};
+		TupleCoder.prototype.encode = function(writer, value) {
+			return (0, array_1.pack)(writer, this.coders, value);
+		};
+		TupleCoder.prototype.decode = function(reader) {
+			return reader.coerce(this.name, (0, array_1.unpack)(reader, this.coders));
+		};
+		return TupleCoder;
+	}(abstract_coder_1.Coder);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/abi-coder.js
+var require_abi_coder = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.defaultAbiCoder = exports.AbiCoder = void 0;
+	var bytes_1 = require_lib$2();
+	var properties_1 = require_lib$5();
+	var logger_1 = require_lib$1();
+	var _version_1 = require__version();
+	var logger = new logger_1.Logger(_version_1.version);
+	var abstract_coder_1 = require_abstract_coder();
+	var address_1 = require_address();
+	var array_1 = require_array();
+	var boolean_1 = require_boolean();
+	var bytes_2 = require_bytes();
+	var fixed_bytes_1 = require_fixed_bytes();
+	var null_1 = require_null();
+	var number_1 = require_number();
+	var string_1 = require_string();
+	var tuple_1 = require_tuple();
+	var fragments_1 = require_fragments();
+	var paramTypeBytes = /* @__PURE__ */ new RegExp(/^bytes([0-9]*)$/);
+	var paramTypeNumber = /* @__PURE__ */ new RegExp(/^(u?int)([0-9]*)$/);
+	var AbiCoder = function() {
+		function AbiCoder(coerceFunc) {
+			(0, properties_1.defineReadOnly)(this, "coerceFunc", coerceFunc || null);
+		}
+		AbiCoder.prototype._getCoder = function(param) {
+			var _this = this;
+			switch (param.baseType) {
+				case "address": return new address_1.AddressCoder(param.name);
+				case "bool": return new boolean_1.BooleanCoder(param.name);
+				case "string": return new string_1.StringCoder(param.name);
+				case "bytes": return new bytes_2.BytesCoder(param.name);
+				case "array": return new array_1.ArrayCoder(this._getCoder(param.arrayChildren), param.arrayLength, param.name);
+				case "tuple": return new tuple_1.TupleCoder((param.components || []).map(function(component) {
+					return _this._getCoder(component);
+				}), param.name);
+				case "": return new null_1.NullCoder(param.name);
+			}
+			var match = param.type.match(paramTypeNumber);
+			if (match) {
+				var size = parseInt(match[2] || "256");
+				if (size === 0 || size > 256 || size % 8 !== 0) logger.throwArgumentError("invalid " + match[1] + " bit length", "param", param);
+				return new number_1.NumberCoder(size / 8, match[1] === "int", param.name);
+			}
+			match = param.type.match(paramTypeBytes);
+			if (match) {
+				var size = parseInt(match[1]);
+				if (size === 0 || size > 32) logger.throwArgumentError("invalid bytes length", "param", param);
+				return new fixed_bytes_1.FixedBytesCoder(size, param.name);
+			}
+			return logger.throwArgumentError("invalid type", "type", param.type);
+		};
+		AbiCoder.prototype._getWordSize = function() {
+			return 32;
+		};
+		AbiCoder.prototype._getReader = function(data, allowLoose) {
+			return new abstract_coder_1.Reader(data, this._getWordSize(), this.coerceFunc, allowLoose);
+		};
+		AbiCoder.prototype._getWriter = function() {
+			return new abstract_coder_1.Writer(this._getWordSize());
+		};
+		AbiCoder.prototype.getDefaultValue = function(types) {
+			var _this = this;
+			var coders = types.map(function(type) {
+				return _this._getCoder(fragments_1.ParamType.from(type));
+			});
+			return new tuple_1.TupleCoder(coders, "_").defaultValue();
+		};
+		AbiCoder.prototype.encode = function(types, values) {
+			var _this = this;
+			if (types.length !== values.length) logger.throwError("types/values length mismatch", logger_1.Logger.errors.INVALID_ARGUMENT, {
+				count: {
+					types: types.length,
+					values: values.length
+				},
+				value: {
+					types,
+					values
+				}
+			});
+			var coders = types.map(function(type) {
+				return _this._getCoder(fragments_1.ParamType.from(type));
+			});
+			var coder = new tuple_1.TupleCoder(coders, "_");
+			var writer = this._getWriter();
+			coder.encode(writer, values);
+			return writer.data;
+		};
+		AbiCoder.prototype.decode = function(types, data, loose) {
+			var _this = this;
+			var coders = types.map(function(type) {
+				return _this._getCoder(fragments_1.ParamType.from(type));
+			});
+			return new tuple_1.TupleCoder(coders, "_").decode(this._getReader((0, bytes_1.arrayify)(data), loose));
+		};
+		return AbiCoder;
+	}();
+	exports.AbiCoder = AbiCoder;
+	exports.defaultAbiCoder = new AbiCoder();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/interface.js
+var require_interface = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __extends = exports && exports.__extends || (function() {
+		var extendStatics = function(d, b) {
+			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+				d.__proto__ = b;
+			} || function(d, b) {
+				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+			};
+			return extendStatics(d, b);
+		};
+		return function(d, b) {
+			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+			extendStatics(d, b);
+			function __() {
+				this.constructor = d;
+			}
+			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+		};
+	})();
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Interface = exports.Indexed = exports.ErrorDescription = exports.TransactionDescription = exports.LogDescription = exports.checkResultErrors = void 0;
+	var address_1 = require_lib$6();
+	var bignumber_1 = require_lib$4();
+	var bytes_1 = require_lib$2();
+	var hash_1 = require_lib$9();
+	var keccak256_1 = require_lib$3();
+	var properties_1 = require_lib$5();
+	var abi_coder_1 = require_abi_coder();
+	var abstract_coder_1 = require_abstract_coder();
+	Object.defineProperty(exports, "checkResultErrors", {
+		enumerable: true,
+		get: function() {
+			return abstract_coder_1.checkResultErrors;
+		}
+	});
+	var fragments_1 = require_fragments();
+	var logger_1 = require_lib$1();
+	var _version_1 = require__version();
+	var logger = new logger_1.Logger(_version_1.version);
+	var LogDescription = function(_super) {
+		__extends(LogDescription, _super);
+		function LogDescription() {
+			return _super !== null && _super.apply(this, arguments) || this;
+		}
+		return LogDescription;
+	}(properties_1.Description);
+	exports.LogDescription = LogDescription;
+	var TransactionDescription = function(_super) {
+		__extends(TransactionDescription, _super);
+		function TransactionDescription() {
+			return _super !== null && _super.apply(this, arguments) || this;
+		}
+		return TransactionDescription;
+	}(properties_1.Description);
+	exports.TransactionDescription = TransactionDescription;
+	var ErrorDescription = function(_super) {
+		__extends(ErrorDescription, _super);
+		function ErrorDescription() {
+			return _super !== null && _super.apply(this, arguments) || this;
+		}
+		return ErrorDescription;
+	}(properties_1.Description);
+	exports.ErrorDescription = ErrorDescription;
+	var Indexed = function(_super) {
+		__extends(Indexed, _super);
+		function Indexed() {
+			return _super !== null && _super.apply(this, arguments) || this;
+		}
+		Indexed.isIndexed = function(value) {
+			return !!(value && value._isIndexed);
+		};
+		return Indexed;
+	}(properties_1.Description);
+	exports.Indexed = Indexed;
+	var BuiltinErrors = {
+		"0x08c379a0": {
+			signature: "Error(string)",
+			name: "Error",
+			inputs: ["string"],
+			reason: true
+		},
+		"0x4e487b71": {
+			signature: "Panic(uint256)",
+			name: "Panic",
+			inputs: ["uint256"]
+		}
+	};
+	function wrapAccessError(property, error) {
+		var wrap = /* @__PURE__ */ new Error("deferred error during ABI decoding triggered accessing " + property);
+		wrap.error = error;
+		return wrap;
+	}
+	exports.Interface = function() {
+		function Interface(fragments) {
+			var _newTarget = this.constructor;
+			var _this = this;
+			var abi = [];
+			if (typeof fragments === "string") abi = JSON.parse(fragments);
+			else abi = fragments;
+			(0, properties_1.defineReadOnly)(this, "fragments", abi.map(function(fragment) {
+				return fragments_1.Fragment.from(fragment);
+			}).filter(function(fragment) {
+				return fragment != null;
+			}));
+			(0, properties_1.defineReadOnly)(this, "_abiCoder", (0, properties_1.getStatic)(_newTarget, "getAbiCoder")());
+			(0, properties_1.defineReadOnly)(this, "functions", {});
+			(0, properties_1.defineReadOnly)(this, "errors", {});
+			(0, properties_1.defineReadOnly)(this, "events", {});
+			(0, properties_1.defineReadOnly)(this, "structs", {});
+			this.fragments.forEach(function(fragment) {
+				var bucket = null;
+				switch (fragment.type) {
+					case "constructor":
+						if (_this.deploy) {
+							logger.warn("duplicate definition - constructor");
+							return;
+						}
+						(0, properties_1.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;
+				}
+				var signature = fragment.format();
+				if (bucket[signature]) {
+					logger.warn("duplicate definition - " + signature);
+					return;
+				}
+				bucket[signature] = fragment;
+			});
+			if (!this.deploy) (0, properties_1.defineReadOnly)(this, "deploy", fragments_1.ConstructorFragment.from({
+				payable: false,
+				type: "constructor"
+			}));
+			(0, properties_1.defineReadOnly)(this, "_isInterface", true);
+		}
+		Interface.prototype.format = function(format) {
+			if (!format) format = fragments_1.FormatTypes.full;
+			if (format === fragments_1.FormatTypes.sighash) logger.throwArgumentError("interface does not support formatting sighash", "format", format);
+			var abi = this.fragments.map(function(fragment) {
+				return fragment.format(format);
+			});
+			if (format === fragments_1.FormatTypes.json) return JSON.stringify(abi.map(function(j) {
+				return JSON.parse(j);
+			}));
+			return abi;
+		};
+		Interface.getAbiCoder = function() {
+			return abi_coder_1.defaultAbiCoder;
+		};
+		Interface.getAddress = function(address) {
+			return (0, address_1.getAddress)(address);
+		};
+		Interface.getSighash = function(fragment) {
+			return (0, bytes_1.hexDataSlice)((0, hash_1.id)(fragment.format()), 0, 4);
+		};
+		Interface.getEventTopic = function(eventFragment) {
+			return (0, hash_1.id)(eventFragment.format());
+		};
+		Interface.prototype.getFunction = function(nameOrSignatureOrSighash) {
+			if ((0, bytes_1.isHexString)(nameOrSignatureOrSighash)) {
+				for (var name_1 in this.functions) if (nameOrSignatureOrSighash === this.getSighash(name_1)) return this.functions[name_1];
+				logger.throwArgumentError("no matching function", "sighash", nameOrSignatureOrSighash);
+			}
+			if (nameOrSignatureOrSighash.indexOf("(") === -1) {
+				var name_2 = nameOrSignatureOrSighash.trim();
+				var matching = Object.keys(this.functions).filter(function(f) {
+					return f.split("(")[0] === name_2;
+				});
+				if (matching.length === 0) logger.throwArgumentError("no matching function", "name", name_2);
+				else if (matching.length > 1) logger.throwArgumentError("multiple matching functions", "name", name_2);
+				return this.functions[matching[0]];
+			}
+			var result = this.functions[fragments_1.FunctionFragment.fromString(nameOrSignatureOrSighash).format()];
+			if (!result) logger.throwArgumentError("no matching function", "signature", nameOrSignatureOrSighash);
+			return result;
+		};
+		Interface.prototype.getEvent = function(nameOrSignatureOrTopic) {
+			if ((0, bytes_1.isHexString)(nameOrSignatureOrTopic)) {
+				var topichash = nameOrSignatureOrTopic.toLowerCase();
+				for (var name_3 in this.events) if (topichash === this.getEventTopic(name_3)) return this.events[name_3];
+				logger.throwArgumentError("no matching event", "topichash", topichash);
+			}
+			if (nameOrSignatureOrTopic.indexOf("(") === -1) {
+				var name_4 = nameOrSignatureOrTopic.trim();
+				var matching = Object.keys(this.events).filter(function(f) {
+					return f.split("(")[0] === name_4;
+				});
+				if (matching.length === 0) logger.throwArgumentError("no matching event", "name", name_4);
+				else if (matching.length > 1) logger.throwArgumentError("multiple matching events", "name", name_4);
+				return this.events[matching[0]];
+			}
+			var result = this.events[fragments_1.EventFragment.fromString(nameOrSignatureOrTopic).format()];
+			if (!result) logger.throwArgumentError("no matching event", "signature", nameOrSignatureOrTopic);
+			return result;
+		};
+		Interface.prototype.getError = function(nameOrSignatureOrSighash) {
+			if ((0, bytes_1.isHexString)(nameOrSignatureOrSighash)) {
+				var getSighash = (0, properties_1.getStatic)(this.constructor, "getSighash");
+				for (var name_5 in this.errors) {
+					var error = this.errors[name_5];
+					if (nameOrSignatureOrSighash === getSighash(error)) return this.errors[name_5];
+				}
+				logger.throwArgumentError("no matching error", "sighash", nameOrSignatureOrSighash);
+			}
+			if (nameOrSignatureOrSighash.indexOf("(") === -1) {
+				var name_6 = nameOrSignatureOrSighash.trim();
+				var matching = Object.keys(this.errors).filter(function(f) {
+					return f.split("(")[0] === name_6;
+				});
+				if (matching.length === 0) logger.throwArgumentError("no matching error", "name", name_6);
+				else if (matching.length > 1) logger.throwArgumentError("multiple matching errors", "name", name_6);
+				return this.errors[matching[0]];
+			}
+			var result = this.errors[fragments_1.FunctionFragment.fromString(nameOrSignatureOrSighash).format()];
+			if (!result) logger.throwArgumentError("no matching error", "signature", nameOrSignatureOrSighash);
+			return result;
+		};
+		Interface.prototype.getSighash = function(fragment) {
+			if (typeof fragment === "string") try {
+				fragment = this.getFunction(fragment);
+			} catch (error) {
+				try {
+					fragment = this.getError(fragment);
+				} catch (_) {
+					throw error;
+				}
+			}
+			return (0, properties_1.getStatic)(this.constructor, "getSighash")(fragment);
+		};
+		Interface.prototype.getEventTopic = function(eventFragment) {
+			if (typeof eventFragment === "string") eventFragment = this.getEvent(eventFragment);
+			return (0, properties_1.getStatic)(this.constructor, "getEventTopic")(eventFragment);
+		};
+		Interface.prototype._decodeParams = function(params, data) {
+			return this._abiCoder.decode(params, data);
+		};
+		Interface.prototype._encodeParams = function(params, values) {
+			return this._abiCoder.encode(params, values);
+		};
+		Interface.prototype.encodeDeploy = function(values) {
+			return this._encodeParams(this.deploy.inputs, values || []);
+		};
+		Interface.prototype.decodeErrorResult = function(fragment, data) {
+			if (typeof fragment === "string") fragment = this.getError(fragment);
+			var bytes = (0, bytes_1.arrayify)(data);
+			if ((0, bytes_1.hexlify)(bytes.slice(0, 4)) !== this.getSighash(fragment)) logger.throwArgumentError("data signature does not match error " + fragment.name + ".", "data", (0, bytes_1.hexlify)(bytes));
+			return this._decodeParams(fragment.inputs, bytes.slice(4));
+		};
+		Interface.prototype.encodeErrorResult = function(fragment, values) {
+			if (typeof fragment === "string") fragment = this.getError(fragment);
+			return (0, bytes_1.hexlify)((0, bytes_1.concat)([this.getSighash(fragment), this._encodeParams(fragment.inputs, values || [])]));
+		};
+		Interface.prototype.decodeFunctionData = function(functionFragment, data) {
+			if (typeof functionFragment === "string") functionFragment = this.getFunction(functionFragment);
+			var bytes = (0, bytes_1.arrayify)(data);
+			if ((0, bytes_1.hexlify)(bytes.slice(0, 4)) !== this.getSighash(functionFragment)) logger.throwArgumentError("data signature does not match function " + functionFragment.name + ".", "data", (0, bytes_1.hexlify)(bytes));
+			return this._decodeParams(functionFragment.inputs, bytes.slice(4));
+		};
+		Interface.prototype.encodeFunctionData = function(functionFragment, values) {
+			if (typeof functionFragment === "string") functionFragment = this.getFunction(functionFragment);
+			return (0, bytes_1.hexlify)((0, bytes_1.concat)([this.getSighash(functionFragment), this._encodeParams(functionFragment.inputs, values || [])]));
+		};
+		Interface.prototype.decodeFunctionResult = function(functionFragment, data) {
+			if (typeof functionFragment === "string") functionFragment = this.getFunction(functionFragment);
+			var bytes = (0, bytes_1.arrayify)(data);
+			var reason = null;
+			var message = "";
+			var errorArgs = null;
+			var errorName = null;
+			var errorSignature = null;
+			switch (bytes.length % this._abiCoder._getWordSize()) {
+				case 0:
+					try {
+						return this._abiCoder.decode(functionFragment.outputs, bytes);
+					} catch (error) {}
+					break;
+				case 4:
+					var selector = (0, bytes_1.hexlify)(bytes.slice(0, 4));
+					var 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 {
+						var error = this.getError(selector);
+						errorArgs = this._abiCoder.decode(error.inputs, bytes.slice(4));
+						errorName = error.name;
+						errorSignature = error.format();
+					} catch (error) {}
+			}
+			return logger.throwError("call revert exception" + message, logger_1.Logger.errors.CALL_EXCEPTION, {
+				method: functionFragment.format(),
+				data: (0, bytes_1.hexlify)(data),
+				errorArgs,
+				errorName,
+				errorSignature,
+				reason
+			});
+		};
+		Interface.prototype.encodeFunctionResult = function(functionFragment, values) {
+			if (typeof functionFragment === "string") functionFragment = this.getFunction(functionFragment);
+			return (0, bytes_1.hexlify)(this._abiCoder.encode(functionFragment.outputs, values || []));
+		};
+		Interface.prototype.encodeFilterTopics = function(eventFragment, values) {
+			var _this = this;
+			if (typeof eventFragment === "string") eventFragment = this.getEvent(eventFragment);
+			if (values.length > eventFragment.inputs.length) logger.throwError("too many arguments for " + eventFragment.format(), logger_1.Logger.errors.UNEXPECTED_ARGUMENT, {
+				argument: "values",
+				value: values
+			});
+			var topics = [];
+			if (!eventFragment.anonymous) topics.push(this.getEventTopic(eventFragment));
+			var encodeTopic = function(param, value) {
+				if (param.type === "string") return (0, hash_1.id)(value);
+				else if (param.type === "bytes") return (0, keccak256_1.keccak256)((0, bytes_1.hexlify)(value));
+				if (param.type === "bool" && typeof value === "boolean") value = value ? "0x01" : "0x00";
+				if (param.type.match(/^u?int/)) value = bignumber_1.BigNumber.from(value).toHexString();
+				if (param.type === "address") _this._abiCoder.encode(["address"], [value]);
+				return (0, bytes_1.hexZeroPad)((0, bytes_1.hexlify)(value), 32);
+			};
+			values.forEach(function(value, index) {
+				var param = eventFragment.inputs[index];
+				if (!param.indexed) {
+					if (value != null) logger.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") logger.throwArgumentError("filtering with tuples or arrays not supported", "contract." + param.name, value);
+				else if (Array.isArray(value)) topics.push(value.map(function(value) {
+					return encodeTopic(param, value);
+				}));
+				else topics.push(encodeTopic(param, value));
+			});
+			while (topics.length && topics[topics.length - 1] === null) topics.pop();
+			return topics;
+		};
+		Interface.prototype.encodeEventLog = function(eventFragment, values) {
+			var _this = this;
+			if (typeof eventFragment === "string") eventFragment = this.getEvent(eventFragment);
+			var topics = [];
+			var dataTypes = [];
+			var dataValues = [];
+			if (!eventFragment.anonymous) topics.push(this.getEventTopic(eventFragment));
+			if (values.length !== eventFragment.inputs.length) logger.throwArgumentError("event arguments/values mismatch", "values", values);
+			eventFragment.inputs.forEach(function(param, index) {
+				var value = values[index];
+				if (param.indexed) {
+					if (param.type === "string") topics.push((0, hash_1.id)(value));
+					else if (param.type === "bytes") topics.push((0, keccak256_1.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
+			};
+		};
+		Interface.prototype.decodeEventLog = function(eventFragment, data, topics) {
+			if (typeof eventFragment === "string") eventFragment = this.getEvent(eventFragment);
+			if (topics != null && !eventFragment.anonymous) {
+				var topicHash = this.getEventTopic(eventFragment);
+				if (!(0, bytes_1.isHexString)(topics[0], 32) || topics[0].toLowerCase() !== topicHash) logger.throwError("fragment/topic mismatch", logger_1.Logger.errors.INVALID_ARGUMENT, {
+					argument: "topics[0]",
+					expected: topicHash,
+					value: topics[0]
+				});
+				topics = topics.slice(1);
+			}
+			var indexed = [];
+			var nonIndexed = [];
+			var dynamic = [];
+			eventFragment.inputs.forEach(function(param, index) {
+				if (param.indexed) {
+					if (param.type === "string" || param.type === "bytes" || param.baseType === "tuple" || param.baseType === "array") {
+						indexed.push(fragments_1.ParamType.fromObject({
+							type: "bytes32",
+							name: param.name
+						}));
+						dynamic.push(true);
+					} else {
+						indexed.push(param);
+						dynamic.push(false);
+					}
+				} else {
+					nonIndexed.push(param);
+					dynamic.push(false);
+				}
+			});
+			var resultIndexed = topics != null ? this._abiCoder.decode(indexed, (0, bytes_1.concat)(topics)) : null;
+			var resultNonIndexed = this._abiCoder.decode(nonIndexed, data, true);
+			var result = [];
+			var nonIndexedIndex = 0, indexedIndex = 0;
+			eventFragment.inputs.forEach(function(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) {
+					var value_1 = result[index];
+					if (value_1 instanceof Error) Object.defineProperty(result, param.name, {
+						enumerable: true,
+						get: function() {
+							throw wrapAccessError("property " + JSON.stringify(param.name), value_1);
+						}
+					});
+					else result[param.name] = value_1;
+				}
+			});
+			var _loop_1 = function(i) {
+				var value = result[i];
+				if (value instanceof Error) Object.defineProperty(result, i, {
+					enumerable: true,
+					get: function() {
+						throw wrapAccessError("index " + i, value);
+					}
+				});
+			};
+			for (var i = 0; i < result.length; i++) _loop_1(i);
+			return Object.freeze(result);
+		};
+		Interface.prototype.parseTransaction = function(tx) {
+			var 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_1.BigNumber.from(tx.value || "0")
+			});
+		};
+		Interface.prototype.parseLog = function(log) {
+			var 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)
+			});
+		};
+		Interface.prototype.parseError = function(data) {
+			var hexData = (0, bytes_1.hexlify)(data);
+			var 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)
+			});
+		};
+		Interface.isInterface = function(value) {
+			return !!(value && value._isInterface);
+		};
+		return Interface;
+	}();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+abi@5.8.0/node_modules/@ethersproject/abi/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.TransactionDescription = exports.LogDescription = exports.checkResultErrors = exports.Indexed = exports.Interface = exports.defaultAbiCoder = exports.AbiCoder = exports.FormatTypes = exports.ParamType = exports.FunctionFragment = exports.Fragment = exports.EventFragment = exports.ErrorFragment = exports.ConstructorFragment = void 0;
+	var fragments_1 = require_fragments();
+	Object.defineProperty(exports, "ConstructorFragment", {
+		enumerable: true,
+		get: function() {
+			return fragments_1.ConstructorFragment;
+		}
+	});
+	Object.defineProperty(exports, "ErrorFragment", {
+		enumerable: true,
+		get: function() {
+			return fragments_1.ErrorFragment;
+		}
+	});
+	Object.defineProperty(exports, "EventFragment", {
+		enumerable: true,
+		get: function() {
+			return fragments_1.EventFragment;
+		}
+	});
+	Object.defineProperty(exports, "FormatTypes", {
+		enumerable: true,
+		get: function() {
+			return fragments_1.FormatTypes;
+		}
+	});
+	Object.defineProperty(exports, "Fragment", {
+		enumerable: true,
+		get: function() {
+			return fragments_1.Fragment;
+		}
+	});
+	Object.defineProperty(exports, "FunctionFragment", {
+		enumerable: true,
+		get: function() {
+			return fragments_1.FunctionFragment;
+		}
+	});
+	Object.defineProperty(exports, "ParamType", {
+		enumerable: true,
+		get: function() {
+			return fragments_1.ParamType;
+		}
+	});
+	var abi_coder_1 = require_abi_coder();
+	Object.defineProperty(exports, "AbiCoder", {
+		enumerable: true,
+		get: function() {
+			return abi_coder_1.AbiCoder;
+		}
+	});
+	Object.defineProperty(exports, "defaultAbiCoder", {
+		enumerable: true,
+		get: function() {
+			return abi_coder_1.defaultAbiCoder;
+		}
+	});
+	var interface_1 = require_interface();
+	Object.defineProperty(exports, "checkResultErrors", {
+		enumerable: true,
+		get: function() {
+			return interface_1.checkResultErrors;
+		}
+	});
+	Object.defineProperty(exports, "Indexed", {
+		enumerable: true,
+		get: function() {
+			return interface_1.Indexed;
+		}
+	});
+	Object.defineProperty(exports, "Interface", {
+		enumerable: true,
+		get: function() {
+			return interface_1.Interface;
+		}
+	});
+	Object.defineProperty(exports, "LogDescription", {
+		enumerable: true,
+		get: function() {
+			return interface_1.LogDescription;
+		}
+	});
+	Object.defineProperty(exports, "TransactionDescription", {
+		enumerable: true,
+		get: function() {
+			return interface_1.TransactionDescription;
+		}
+	});
+}));
+//#endregion
+export default require_lib();
+export {};
+
+//# sourceMappingURL=lib-BOge5QZP.mjs.map