@vultisig/cli 4.6.0 → 4.7.0

package/dist/index.js

@@ -1111,6 +1111,853 @@ var require_main = __commonJS({
   }
 });
 
+// ../../node_modules/abitype/dist/esm/version.js
+var version;
+var init_version = __esm({
+  "../../node_modules/abitype/dist/esm/version.js"() {
+    version = "1.2.3";
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/errors.js
+var BaseError;
+var init_errors = __esm({
+  "../../node_modules/abitype/dist/esm/errors.js"() {
+    init_version();
+    BaseError = class _BaseError extends Error {
+      constructor(shortMessage, args = {}) {
+        const details = args.cause instanceof _BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;
+        const docsPath = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
+        const message = [
+          shortMessage || "An error occurred.",
+          "",
+          ...args.metaMessages ? [...args.metaMessages, ""] : [],
+          ...docsPath ? [`Docs: https://abitype.dev${docsPath}`] : [],
+          ...details ? [`Details: ${details}`] : [],
+          `Version: abitype@${version}`
+        ].join("\n");
+        super(message);
+        Object.defineProperty(this, "details", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "docsPath", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "metaMessages", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "shortMessage", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "AbiTypeError"
+        });
+        if (args.cause)
+          this.cause = args.cause;
+        this.details = details;
+        this.docsPath = docsPath;
+        this.metaMessages = args.metaMessages;
+        this.shortMessage = shortMessage;
+      }
+    };
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/regex.js
+function execTyped(regex, string) {
+  const match = regex.exec(string);
+  return match?.groups;
+}
+var bytesRegex, integerRegex, isTupleRegex;
+var init_regex = __esm({
+  "../../node_modules/abitype/dist/esm/regex.js"() {
+    bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+    integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+    isTupleRegex = /^\(.+?\).*?$/;
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
+function formatAbiParameter(abiParameter) {
+  let type = abiParameter.type;
+  if (tupleRegex.test(abiParameter.type) && "components" in abiParameter) {
+    type = "(";
+    const length = abiParameter.components.length;
+    for (let i = 0; i < length; i++) {
+      const component = abiParameter.components[i];
+      type += formatAbiParameter(component);
+      if (i < length - 1)
+        type += ", ";
+    }
+    const result = execTyped(tupleRegex, abiParameter.type);
+    type += `)${result?.array || ""}`;
+    return formatAbiParameter({
+      ...abiParameter,
+      type
+    });
+  }
+  if ("indexed" in abiParameter && abiParameter.indexed)
+    type = `${type} indexed`;
+  if (abiParameter.name)
+    return `${type} ${abiParameter.name}`;
+  return type;
+}
+var tupleRegex;
+var init_formatAbiParameter = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
+    init_regex();
+    tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
+function formatAbiParameters(abiParameters) {
+  let params = "";
+  const length = abiParameters.length;
+  for (let i = 0; i < length; i++) {
+    const abiParameter = abiParameters[i];
+    params += formatAbiParameter(abiParameter);
+    if (i !== length - 1)
+      params += ", ";
+  }
+  return params;
+}
+var init_formatAbiParameters = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
+    init_formatAbiParameter();
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
+function formatAbiItem(abiItem) {
+  if (abiItem.type === "function")
+    return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${abiItem.outputs?.length ? ` returns (${formatAbiParameters(abiItem.outputs)})` : ""}`;
+  if (abiItem.type === "event")
+    return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+  if (abiItem.type === "error")
+    return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+  if (abiItem.type === "constructor")
+    return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === "payable" ? " payable" : ""}`;
+  if (abiItem.type === "fallback")
+    return `fallback() external${abiItem.stateMutability === "payable" ? " payable" : ""}`;
+  return "receive() external payable";
+}
+var init_formatAbiItem = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
+    init_formatAbiParameters();
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
+function isErrorSignature(signature) {
+  return errorSignatureRegex.test(signature);
+}
+function execErrorSignature(signature) {
+  return execTyped(errorSignatureRegex, signature);
+}
+function isEventSignature(signature) {
+  return eventSignatureRegex.test(signature);
+}
+function execEventSignature(signature) {
+  return execTyped(eventSignatureRegex, signature);
+}
+function isFunctionSignature(signature) {
+  return functionSignatureRegex.test(signature);
+}
+function execFunctionSignature(signature) {
+  return execTyped(functionSignatureRegex, signature);
+}
+function isStructSignature(signature) {
+  return structSignatureRegex.test(signature);
+}
+function execStructSignature(signature) {
+  return execTyped(structSignatureRegex, signature);
+}
+function isConstructorSignature(signature) {
+  return constructorSignatureRegex.test(signature);
+}
+function execConstructorSignature(signature) {
+  return execTyped(constructorSignatureRegex, signature);
+}
+function isFallbackSignature(signature) {
+  return fallbackSignatureRegex.test(signature);
+}
+function execFallbackSignature(signature) {
+  return execTyped(fallbackSignatureRegex, signature);
+}
+function isReceiveSignature(signature) {
+  return receiveSignatureRegex.test(signature);
+}
+var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, eventModifiers, functionModifiers;
+var init_signatures = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
+    init_regex();
+    errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+    eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+    functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
+    structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
+    constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
+    fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
+    receiveSignatureRegex = /^receive\(\) external payable$/;
+    eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
+    functionModifiers = /* @__PURE__ */ new Set([
+      "calldata",
+      "memory",
+      "storage"
+    ]);
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
+var UnknownTypeError, UnknownSolidityTypeError;
+var init_abiItem = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
+    init_errors();
+    UnknownTypeError = class extends BaseError {
+      constructor({ type }) {
+        super("Unknown type.", {
+          metaMessages: [
+            `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`
+          ]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "UnknownTypeError"
+        });
+      }
+    };
+    UnknownSolidityTypeError = class extends BaseError {
+      constructor({ type }) {
+        super("Unknown type.", {
+          metaMessages: [`Type "${type}" is not a valid ABI type.`]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "UnknownSolidityTypeError"
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
+var InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
+var init_abiParameter = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
+    init_errors();
+    InvalidParameterError = class extends BaseError {
+      constructor({ param }) {
+        super("Invalid ABI parameter.", {
+          details: param
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidParameterError"
+        });
+      }
+    };
+    SolidityProtectedKeywordError = class extends BaseError {
+      constructor({ param, name }) {
+        super("Invalid ABI parameter.", {
+          details: param,
+          metaMessages: [
+            `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`
+          ]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "SolidityProtectedKeywordError"
+        });
+      }
+    };
+    InvalidModifierError = class extends BaseError {
+      constructor({ param, type, modifier }) {
+        super("Invalid ABI parameter.", {
+          details: param,
+          metaMessages: [
+            `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`
+          ]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidModifierError"
+        });
+      }
+    };
+    InvalidFunctionModifierError = class extends BaseError {
+      constructor({ param, type, modifier }) {
+        super("Invalid ABI parameter.", {
+          details: param,
+          metaMessages: [
+            `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ""}.`,
+            `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`
+          ]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidFunctionModifierError"
+        });
+      }
+    };
+    InvalidAbiTypeParameterError = class extends BaseError {
+      constructor({ abiParameter }) {
+        super("Invalid ABI parameter.", {
+          details: JSON.stringify(abiParameter, null, 2),
+          metaMessages: ["ABI parameter type is invalid."]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidAbiTypeParameterError"
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/errors/signature.js
+var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
+var init_signature = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
+    init_errors();
+    InvalidSignatureError = class extends BaseError {
+      constructor({ signature, type }) {
+        super(`Invalid ${type} signature.`, {
+          details: signature
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidSignatureError"
+        });
+      }
+    };
+    UnknownSignatureError = class extends BaseError {
+      constructor({ signature }) {
+        super("Unknown signature.", {
+          details: signature
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "UnknownSignatureError"
+        });
+      }
+    };
+    InvalidStructSignatureError = class extends BaseError {
+      constructor({ signature }) {
+        super("Invalid struct signature.", {
+          details: signature,
+          metaMessages: ["No properties exist."]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidStructSignatureError"
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/errors/struct.js
+var CircularReferenceError;
+var init_struct = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
+    init_errors();
+    CircularReferenceError = class extends BaseError {
+      constructor({ type }) {
+        super("Circular reference detected.", {
+          metaMessages: [`Struct "${type}" is a circular reference.`]
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "CircularReferenceError"
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
+var InvalidParenthesisError;
+var init_splitParameters = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
+    init_errors();
+    InvalidParenthesisError = class extends BaseError {
+      constructor({ current, depth }) {
+        super("Unbalanced parentheses.", {
+          metaMessages: [
+            `"${current.trim()}" has too many ${depth > 0 ? "opening" : "closing"} parentheses.`
+          ],
+          details: `Depth "${depth}"`
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "InvalidParenthesisError"
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/runtime/cache.js
+function getParameterCacheKey(param, type, structs) {
+  let structKey = "";
+  if (structs)
+    for (const struct of Object.entries(structs)) {
+      if (!struct)
+        continue;
+      let propertyKey = "";
+      for (const property of struct[1]) {
+        propertyKey += `[${property.type}${property.name ? `:${property.name}` : ""}]`;
+      }
+      structKey += `(${struct[0]}{${propertyKey}})`;
+    }
+  if (type)
+    return `${type}:${param}${structKey}`;
+  return `${param}${structKey}`;
+}
+var parameterCache;
+var init_cache = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
+    parameterCache = /* @__PURE__ */ new Map([
+      // Unnamed
+      ["address", { type: "address" }],
+      ["bool", { type: "bool" }],
+      ["bytes", { type: "bytes" }],
+      ["bytes32", { type: "bytes32" }],
+      ["int", { type: "int256" }],
+      ["int256", { type: "int256" }],
+      ["string", { type: "string" }],
+      ["uint", { type: "uint256" }],
+      ["uint8", { type: "uint8" }],
+      ["uint16", { type: "uint16" }],
+      ["uint24", { type: "uint24" }],
+      ["uint32", { type: "uint32" }],
+      ["uint64", { type: "uint64" }],
+      ["uint96", { type: "uint96" }],
+      ["uint112", { type: "uint112" }],
+      ["uint160", { type: "uint160" }],
+      ["uint192", { type: "uint192" }],
+      ["uint256", { type: "uint256" }],
+      // Named
+      ["address owner", { type: "address", name: "owner" }],
+      ["address to", { type: "address", name: "to" }],
+      ["bool approved", { type: "bool", name: "approved" }],
+      ["bytes _data", { type: "bytes", name: "_data" }],
+      ["bytes data", { type: "bytes", name: "data" }],
+      ["bytes signature", { type: "bytes", name: "signature" }],
+      ["bytes32 hash", { type: "bytes32", name: "hash" }],
+      ["bytes32 r", { type: "bytes32", name: "r" }],
+      ["bytes32 root", { type: "bytes32", name: "root" }],
+      ["bytes32 s", { type: "bytes32", name: "s" }],
+      ["string name", { type: "string", name: "name" }],
+      ["string symbol", { type: "string", name: "symbol" }],
+      ["string tokenURI", { type: "string", name: "tokenURI" }],
+      ["uint tokenId", { type: "uint256", name: "tokenId" }],
+      ["uint8 v", { type: "uint8", name: "v" }],
+      ["uint256 balance", { type: "uint256", name: "balance" }],
+      ["uint256 tokenId", { type: "uint256", name: "tokenId" }],
+      ["uint256 value", { type: "uint256", name: "value" }],
+      // Indexed
+      [
+        "event:address indexed from",
+        { type: "address", name: "from", indexed: true }
+      ],
+      ["event:address indexed to", { type: "address", name: "to", indexed: true }],
+      [
+        "event:uint indexed tokenId",
+        { type: "uint256", name: "tokenId", indexed: true }
+      ],
+      [
+        "event:uint256 indexed tokenId",
+        { type: "uint256", name: "tokenId", indexed: true }
+      ]
+    ]);
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/runtime/utils.js
+function parseSignature(signature, structs = {}) {
+  if (isFunctionSignature(signature))
+    return parseFunctionSignature(signature, structs);
+  if (isEventSignature(signature))
+    return parseEventSignature(signature, structs);
+  if (isErrorSignature(signature))
+    return parseErrorSignature(signature, structs);
+  if (isConstructorSignature(signature))
+    return parseConstructorSignature(signature, structs);
+  if (isFallbackSignature(signature))
+    return parseFallbackSignature(signature);
+  if (isReceiveSignature(signature))
+    return {
+      type: "receive",
+      stateMutability: "payable"
+    };
+  throw new UnknownSignatureError({ signature });
+}
+function parseFunctionSignature(signature, structs = {}) {
+  const match = execFunctionSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "function" });
+  const inputParams = splitParameters(match.parameters);
+  const inputs = [];
+  const inputLength = inputParams.length;
+  for (let i = 0; i < inputLength; i++) {
+    inputs.push(parseAbiParameter(inputParams[i], {
+      modifiers: functionModifiers,
+      structs,
+      type: "function"
+    }));
+  }
+  const outputs = [];
+  if (match.returns) {
+    const outputParams = splitParameters(match.returns);
+    const outputLength = outputParams.length;
+    for (let i = 0; i < outputLength; i++) {
+      outputs.push(parseAbiParameter(outputParams[i], {
+        modifiers: functionModifiers,
+        structs,
+        type: "function"
+      }));
+    }
+  }
+  return {
+    name: match.name,
+    type: "function",
+    stateMutability: match.stateMutability ?? "nonpayable",
+    inputs,
+    outputs
+  };
+}
+function parseEventSignature(signature, structs = {}) {
+  const match = execEventSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "event" });
+  const params = splitParameters(match.parameters);
+  const abiParameters = [];
+  const length = params.length;
+  for (let i = 0; i < length; i++)
+    abiParameters.push(parseAbiParameter(params[i], {
+      modifiers: eventModifiers,
+      structs,
+      type: "event"
+    }));
+  return { name: match.name, type: "event", inputs: abiParameters };
+}
+function parseErrorSignature(signature, structs = {}) {
+  const match = execErrorSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "error" });
+  const params = splitParameters(match.parameters);
+  const abiParameters = [];
+  const length = params.length;
+  for (let i = 0; i < length; i++)
+    abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
+  return { name: match.name, type: "error", inputs: abiParameters };
+}
+function parseConstructorSignature(signature, structs = {}) {
+  const match = execConstructorSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "constructor" });
+  const params = splitParameters(match.parameters);
+  const abiParameters = [];
+  const length = params.length;
+  for (let i = 0; i < length; i++)
+    abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
+  return {
+    type: "constructor",
+    stateMutability: match.stateMutability ?? "nonpayable",
+    inputs: abiParameters
+  };
+}
+function parseFallbackSignature(signature) {
+  const match = execFallbackSignature(signature);
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: "fallback" });
+  return {
+    type: "fallback",
+    stateMutability: match.stateMutability ?? "nonpayable"
+  };
+}
+function parseAbiParameter(param, options) {
+  const parameterCacheKey = getParameterCacheKey(param, options?.type, options?.structs);
+  if (parameterCache.has(parameterCacheKey))
+    return parameterCache.get(parameterCacheKey);
+  const isTuple = isTupleRegex.test(param);
+  const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
+  if (!match)
+    throw new InvalidParameterError({ param });
+  if (match.name && isSolidityKeyword(match.name))
+    throw new SolidityProtectedKeywordError({ param, name: match.name });
+  const name = match.name ? { name: match.name } : {};
+  const indexed = match.modifier === "indexed" ? { indexed: true } : {};
+  const structs = options?.structs ?? {};
+  let type;
+  let components = {};
+  if (isTuple) {
+    type = "tuple";
+    const params = splitParameters(match.type);
+    const components_ = [];
+    const length = params.length;
+    for (let i = 0; i < length; i++) {
+      components_.push(parseAbiParameter(params[i], { structs }));
+    }
+    components = { components: components_ };
+  } else if (match.type in structs) {
+    type = "tuple";
+    components = { components: structs[match.type] };
+  } else if (dynamicIntegerRegex.test(match.type)) {
+    type = `${match.type}256`;
+  } else if (match.type === "address payable") {
+    type = "address";
+  } else {
+    type = match.type;
+    if (!(options?.type === "struct") && !isSolidityType(type))
+      throw new UnknownSolidityTypeError({ type });
+  }
+  if (match.modifier) {
+    if (!options?.modifiers?.has?.(match.modifier))
+      throw new InvalidModifierError({
+        param,
+        type: options?.type,
+        modifier: match.modifier
+      });
+    if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
+      throw new InvalidFunctionModifierError({
+        param,
+        type: options?.type,
+        modifier: match.modifier
+      });
+  }
+  const abiParameter = {
+    type: `${type}${match.array ?? ""}`,
+    ...name,
+    ...indexed,
+    ...components
+  };
+  parameterCache.set(parameterCacheKey, abiParameter);
+  return abiParameter;
+}
+function splitParameters(params, result = [], current = "", depth = 0) {
+  const length = params.trim().length;
+  for (let i = 0; i < length; i++) {
+    const char = params[i];
+    const tail = params.slice(i + 1);
+    switch (char) {
+      case ",":
+        return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
+      case "(":
+        return splitParameters(tail, result, `${current}${char}`, depth + 1);
+      case ")":
+        return splitParameters(tail, result, `${current}${char}`, depth - 1);
+      default:
+        return splitParameters(tail, result, `${current}${char}`, depth);
+    }
+  }
+  if (current === "")
+    return result;
+  if (depth !== 0)
+    throw new InvalidParenthesisError({ current, depth });
+  result.push(current.trim());
+  return result;
+}
+function isSolidityType(type) {
+  return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
+}
+function isSolidityKeyword(name) {
+  return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
+}
+function isValidDataLocation(type, isArray) {
+  return isArray || type === "bytes" || type === "string" || type === "tuple";
+}
+var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
+var init_utils = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
+    init_regex();
+    init_abiItem();
+    init_abiParameter();
+    init_signature();
+    init_splitParameters();
+    init_cache();
+    init_signatures();
+    abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*(?:\spayable)?)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+    abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+    dynamicIntegerRegex = /^u?int$/;
+    protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/runtime/structs.js
+function parseStructs(signatures) {
+  const shallowStructs = {};
+  const signaturesLength = signatures.length;
+  for (let i = 0; i < signaturesLength; i++) {
+    const signature = signatures[i];
+    if (!isStructSignature(signature))
+      continue;
+    const match = execStructSignature(signature);
+    if (!match)
+      throw new InvalidSignatureError({ signature, type: "struct" });
+    const properties = match.properties.split(";");
+    const components = [];
+    const propertiesLength = properties.length;
+    for (let k = 0; k < propertiesLength; k++) {
+      const property = properties[k];
+      const trimmed = property.trim();
+      if (!trimmed)
+        continue;
+      const abiParameter = parseAbiParameter(trimmed, {
+        type: "struct"
+      });
+      components.push(abiParameter);
+    }
+    if (!components.length)
+      throw new InvalidStructSignatureError({ signature });
+    shallowStructs[match.name] = components;
+  }
+  const resolvedStructs = {};
+  const entries = Object.entries(shallowStructs);
+  const entriesLength = entries.length;
+  for (let i = 0; i < entriesLength; i++) {
+    const [name, parameters] = entries[i];
+    resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
+  }
+  return resolvedStructs;
+}
+function resolveStructs(abiParameters = [], structs = {}, ancestors = /* @__PURE__ */ new Set()) {
+  const components = [];
+  const length = abiParameters.length;
+  for (let i = 0; i < length; i++) {
+    const abiParameter = abiParameters[i];
+    const isTuple = isTupleRegex.test(abiParameter.type);
+    if (isTuple)
+      components.push(abiParameter);
+    else {
+      const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
+      if (!match?.type)
+        throw new InvalidAbiTypeParameterError({ abiParameter });
+      const { array, type } = match;
+      if (type in structs) {
+        if (ancestors.has(type))
+          throw new CircularReferenceError({ type });
+        components.push({
+          ...abiParameter,
+          type: `tuple${array ?? ""}`,
+          components: resolveStructs(structs[type], structs, /* @__PURE__ */ new Set([...ancestors, type]))
+        });
+      } else {
+        if (isSolidityType(type))
+          components.push(abiParameter);
+        else
+          throw new UnknownTypeError({ type });
+      }
+    }
+  }
+  return components;
+}
+var typeWithoutTupleRegex;
+var init_structs = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
+    init_regex();
+    init_abiItem();
+    init_abiParameter();
+    init_signature();
+    init_struct();
+    init_signatures();
+    init_utils();
+    typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/human-readable/parseAbi.js
+function parseAbi(signatures) {
+  const structs = parseStructs(signatures);
+  const abi = [];
+  const length = signatures.length;
+  for (let i = 0; i < length; i++) {
+    const signature = signatures[i];
+    if (isStructSignature(signature))
+      continue;
+    abi.push(parseSignature(signature, structs));
+  }
+  return abi;
+}
+var init_parseAbi = __esm({
+  "../../node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
+    init_signatures();
+    init_structs();
+    init_utils();
+  }
+});
+
+// ../../node_modules/abitype/dist/esm/exports/index.js
+var init_exports = __esm({
+  "../../node_modules/abitype/dist/esm/exports/index.js"() {
+    init_formatAbiItem();
+    init_parseAbi();
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/abi/formatAbiItem.js
+function formatAbiItem2(abiItem, { includeName = false } = {}) {
+  if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
+    throw new InvalidDefinitionTypeError(abiItem.type);
+  return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
+}
+function formatAbiParams(params, { includeName = false } = {}) {
+  if (!params)
+    return "";
+  return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
+}
+function formatAbiParam(param, { includeName }) {
+  if (param.type.startsWith("tuple")) {
+    return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
+  }
+  return param.type + (includeName && param.name ? ` ${param.name}` : "");
+}
+var init_formatAbiItem2 = __esm({
+  "../../node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
+    init_abi();
+  }
+});
+
 // ../../node_modules/viem/_esm/utils/data/isHex.js
 function isHex(value, { strict = true } = {}) {
   if (!value)
@@ -1137,10 +1984,10 @@ var init_size = __esm({
 });
 
 // ../../node_modules/viem/_esm/errors/version.js
-var version;
-var init_version = __esm({
+var version2;
+var init_version2 = __esm({
   "../../node_modules/viem/_esm/errors/version.js"() {
-    version = "2.55.10";
+    version2 = "2.55.10";
   }
 });
 
@@ -1152,15 +1999,15 @@ function walk(err, fn) {
     return walk(err.cause, fn);
   return fn ? null : err;
 }
-var errorConfig, BaseError;
+var errorConfig, BaseError2;
 var init_base = __esm({
   "../../node_modules/viem/_esm/errors/base.js"() {
-    init_version();
+    init_version2();
     errorConfig = {
       getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
-      version: `viem@${version}`
+      version: `viem@${version2}`
     };
-    BaseError = class _BaseError extends Error {
+    BaseError2 = class _BaseError extends Error {
       constructor(shortMessage, args = {}) {
         const details = (() => {
           if (args.cause instanceof _BaseError)
@@ -1220,27 +2067,68 @@ var init_base = __esm({
           writable: true,
           value: "BaseError"
         });
-        this.details = details;
-        this.docsPath = docsPath;
-        this.metaMessages = args.metaMessages;
-        this.name = args.name ?? this.name;
-        this.shortMessage = shortMessage;
-        this.version = version;
+        this.details = details;
+        this.docsPath = docsPath;
+        this.metaMessages = args.metaMessages;
+        this.name = args.name ?? this.name;
+        this.shortMessage = shortMessage;
+        this.version = version2;
+      }
+      walk(fn) {
+        return walk(this, fn);
+      }
+    };
+  }
+});
+
+// ../../node_modules/viem/_esm/errors/abi.js
+var AbiDecodingDataSizeTooSmallError, AbiDecodingZeroDataError, AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiFunctionSignatureNotFoundError, BytesSizeMismatchError, InvalidAbiEncodingTypeError, InvalidAbiDecodingTypeError, InvalidArrayError, InvalidDefinitionTypeError;
+var init_abi = __esm({
+  "../../node_modules/viem/_esm/errors/abi.js"() {
+    init_formatAbiItem2();
+    init_size();
+    init_base();
+    AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
+      constructor({ data, params, size: size2 }) {
+        super([`Data size of ${size2} bytes is too small for given parameters.`].join("\n"), {
+          metaMessages: [
+            `Params: (${formatAbiParams(params, { includeName: true })})`,
+            `Data:   ${data} (${size2} bytes)`
+          ],
+          name: "AbiDecodingDataSizeTooSmallError"
+        });
+        Object.defineProperty(this, "data", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "params", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "size", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        this.data = data;
+        this.params = params;
+        this.size = size2;
       }
-      walk(fn) {
-        return walk(this, fn);
+    };
+    AbiDecodingZeroDataError = class extends BaseError2 {
+      constructor({ cause } = {}) {
+        super('Cannot decode zero data ("0x") with ABI parameters.', {
+          name: "AbiDecodingZeroDataError",
+          cause
+        });
       }
     };
-  }
-});
-
-// ../../node_modules/viem/_esm/errors/abi.js
-var AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, BytesSizeMismatchError, InvalidAbiEncodingTypeError, InvalidArrayError;
-var init_abi = __esm({
-  "../../node_modules/viem/_esm/errors/abi.js"() {
-    init_size();
-    init_base();
-    AbiEncodingArrayLengthMismatchError = class extends BaseError {
+    AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
       constructor({ expectedLength, givenLength, type }) {
         super([
           `ABI encoding array length mismatch for type ${type}.`,
@@ -1249,12 +2137,12 @@ var init_abi = __esm({
         ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
       }
     };
-    AbiEncodingBytesSizeMismatchError = class extends BaseError {
+    AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
       constructor({ expectedSize, value }) {
         super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
       }
     };
-    AbiEncodingLengthMismatchError = class extends BaseError {
+    AbiEncodingLengthMismatchError = class extends BaseError2 {
       constructor({ expectedLength, givenLength }) {
         super([
           "ABI encoding params/values length mismatch.",
@@ -1263,14 +2151,26 @@ var init_abi = __esm({
         ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
       }
     };
-    BytesSizeMismatchError = class extends BaseError {
+    AbiFunctionSignatureNotFoundError = class extends BaseError2 {
+      constructor(signature, { docsPath }) {
+        super([
+          `Encoded function signature "${signature}" not found on ABI.`,
+          "Make sure you are using the correct ABI and that the function exists on it.",
+          `You can look up the signature here: https://4byte.sourcify.dev/?q=${signature}.`
+        ].join("\n"), {
+          docsPath,
+          name: "AbiFunctionSignatureNotFoundError"
+        });
+      }
+    };
+    BytesSizeMismatchError = class extends BaseError2 {
       constructor({ expectedSize, givenSize }) {
         super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
           name: "BytesSizeMismatchError"
         });
       }
     };
-    InvalidAbiEncodingTypeError = class extends BaseError {
+    InvalidAbiEncodingTypeError = class extends BaseError2 {
       constructor(type, { docsPath }) {
         super([
           `Type "${type}" is not a valid encoding type.`,
@@ -1278,13 +2178,29 @@ var init_abi = __esm({
         ].join("\n"), { docsPath, name: "InvalidAbiEncodingType" });
       }
     };
-    InvalidArrayError = class extends BaseError {
+    InvalidAbiDecodingTypeError = class extends BaseError2 {
+      constructor(type, { docsPath }) {
+        super([
+          `Type "${type}" is not a valid decoding type.`,
+          "Please provide a valid ABI type."
+        ].join("\n"), { docsPath, name: "InvalidAbiDecodingType" });
+      }
+    };
+    InvalidArrayError = class extends BaseError2 {
       constructor(value) {
         super([`Value "${value}" is not a valid array.`].join("\n"), {
           name: "InvalidArrayError"
         });
       }
     };
+    InvalidDefinitionTypeError = class extends BaseError2 {
+      constructor(type) {
+        super([
+          `"${type}" is not a valid definition type.`,
+          'Valid types: "function", "event", "error"'
+        ].join("\n"), { name: "InvalidDefinitionTypeError" });
+      }
+    };
   }
 });
 
@@ -1293,12 +2209,12 @@ var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
 var init_data = __esm({
   "../../node_modules/viem/_esm/errors/data.js"() {
     init_base();
-    SliceOffsetOutOfBoundsError = class extends BaseError {
+    SliceOffsetOutOfBoundsError = class extends BaseError2 {
       constructor({ offset, position, size: size2 }) {
         super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
       }
     };
-    SizeExceedsPaddingSizeError = class extends BaseError {
+    SizeExceedsPaddingSizeError = class extends BaseError2 {
       constructor({ size: size2, targetSize, type }) {
         super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
       }
@@ -1347,16 +2263,23 @@ var init_pad = __esm({
 });
 
 // ../../node_modules/viem/_esm/errors/encoding.js
-var IntegerOutOfRangeError, SizeOverflowError;
+var IntegerOutOfRangeError, InvalidBytesBooleanError, SizeOverflowError;
 var init_encoding = __esm({
   "../../node_modules/viem/_esm/errors/encoding.js"() {
     init_base();
-    IntegerOutOfRangeError = class extends BaseError {
+    IntegerOutOfRangeError = class extends BaseError2 {
       constructor({ max, min, signed, size: size2, value }) {
         super(`Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
       }
     };
-    SizeOverflowError = class extends BaseError {
+    InvalidBytesBooleanError = class extends BaseError2 {
+      constructor(bytes) {
+        super(`Bytes value "${bytes}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
+          name: "InvalidBytesBooleanError"
+        });
+      }
+    };
+    SizeOverflowError = class extends BaseError2 {
       constructor({ givenSize, maxSize }) {
         super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
       }
@@ -1364,6 +2287,29 @@ var init_encoding = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/utils/data/trim.js
+function trim(hexOrBytes, { dir = "left" } = {}) {
+  let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
+  let sliceLength = 0;
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
+      sliceLength++;
+    else
+      break;
+  }
+  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+  if (typeof hexOrBytes === "string") {
+    if (data.length === 1 && dir === "right")
+      data = `${data}0`;
+    return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
+  }
+  return data;
+}
+var init_trim = __esm({
+  "../../node_modules/viem/_esm/utils/data/trim.js"() {
+  }
+});
+
 // ../../node_modules/viem/_esm/utils/encoding/fromHex.js
 function assertSize(hexOrBytes, { size: size2 }) {
   if (size(hexOrBytes) > size2)
@@ -1522,7 +2468,7 @@ function hexToBytes(hex_, opts = {}) {
     const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
     const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
     if (nibbleLeft === void 0 || nibbleRight === void 0) {
-      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+      throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
     }
     bytes[index] = nibbleLeft * 16 + nibbleRight;
   }
@@ -1697,7 +2643,7 @@ function randomBytes2(bytesLength = 32) {
   throw new Error("crypto.getRandomValues must be defined");
 }
 var isLE, swap32IfBE, Hash;
-var init_utils = __esm({
+var init_utils2 = __esm({
   "../../node_modules/@noble/hashes/esm/utils.js"() {
     init_cryptoNode();
     isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
@@ -1752,7 +2698,7 @@ var _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, SH
 var init_sha3 = __esm({
   "../../node_modules/@noble/hashes/esm/sha3.js"() {
     init_u64();
-    init_utils();
+    init_utils2();
     _0n = BigInt(0);
     _1n = BigInt(1);
     _2n = BigInt(2);
@@ -1912,12 +2858,102 @@ var init_keccak256 = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/utils/hash/hashSignature.js
+function hashSignature(sig) {
+  return hash(sig);
+}
+var hash;
+var init_hashSignature = __esm({
+  "../../node_modules/viem/_esm/utils/hash/hashSignature.js"() {
+    init_toBytes();
+    init_keccak256();
+    hash = (value) => keccak256(toBytes(value));
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/hash/normalizeSignature.js
+function normalizeSignature(signature) {
+  let active = true;
+  let current = "";
+  let level = 0;
+  let result = "";
+  let valid = false;
+  for (let i = 0; i < signature.length; i++) {
+    const char = signature[i];
+    if (["(", ")", ","].includes(char))
+      active = true;
+    if (char === "(")
+      level++;
+    if (char === ")")
+      level--;
+    if (!active)
+      continue;
+    if (level === 0) {
+      if (char === " " && ["event", "function", ""].includes(result))
+        result = "";
+      else {
+        result += char;
+        if (char === ")") {
+          valid = true;
+          break;
+        }
+      }
+      continue;
+    }
+    if (char === " ") {
+      if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
+        current = "";
+        active = false;
+      }
+      continue;
+    }
+    result += char;
+    current += char;
+  }
+  if (!valid)
+    throw new BaseError2("Unable to normalize signature.");
+  return result;
+}
+var init_normalizeSignature = __esm({
+  "../../node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
+    init_base();
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/hash/toSignature.js
+var toSignature;
+var init_toSignature = __esm({
+  "../../node_modules/viem/_esm/utils/hash/toSignature.js"() {
+    init_exports();
+    init_normalizeSignature();
+    toSignature = (def) => {
+      const def_ = (() => {
+        if (typeof def === "string")
+          return def;
+        return formatAbiItem(def);
+      })();
+      return normalizeSignature(def_);
+    };
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/hash/toSignatureHash.js
+function toSignatureHash(fn) {
+  return hashSignature(toSignature(fn));
+}
+var init_toSignatureHash = __esm({
+  "../../node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
+    init_hashSignature();
+    init_toSignature();
+  }
+});
+
 // ../../node_modules/viem/_esm/errors/address.js
 var InvalidAddressError2;
 var init_address = __esm({
   "../../node_modules/viem/_esm/errors/address.js"() {
     init_base();
-    InvalidAddressError2 = class extends BaseError {
+    InvalidAddressError2 = class extends BaseError2 {
       constructor({ address }) {
         super(`Address "${address}" is invalid.`, {
           metaMessages: [
@@ -1974,13 +3010,13 @@ function checksumAddress(address_, chainId) {
   if (checksumAddressCache.has(`${address_}.${chainId}`))
     return checksumAddressCache.get(`${address_}.${chainId}`);
   const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
-  const hash = keccak256(stringToBytes(hexAddress), "bytes");
+  const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
   const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
   for (let i = 0; i < 40; i += 2) {
-    if (hash[i >> 1] >> 4 >= 8 && address[i]) {
+    if (hash2[i >> 1] >> 4 >= 8 && address[i]) {
       address[i] = address[i].toUpperCase();
     }
-    if ((hash[i >> 1] & 15) >= 8 && address[i + 1]) {
+    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
       address[i + 1] = address[i + 1].toUpperCase();
     }
   }
@@ -2103,11 +3139,11 @@ var init_slice = __esm({
 });
 
 // ../../node_modules/viem/_esm/utils/regex.js
-var bytesRegex, integerRegex;
-var init_regex = __esm({
+var bytesRegex2, integerRegex2;
+var init_regex2 = __esm({
   "../../node_modules/viem/_esm/utils/regex.js"() {
-    bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
-    integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+    bytesRegex2 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+    integerRegex2 = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
   }
 });
 
@@ -2150,7 +3186,7 @@ function prepareParam({ param, value }) {
   }
   if (param.type.startsWith("uint") || param.type.startsWith("int")) {
     const signed = param.type.startsWith("int");
-    const [, , size2 = "256"] = integerRegex.exec(param.type) ?? [];
+    const [, , size2 = "256"] = integerRegex2.exec(param.type) ?? [];
     return encodeNumber(value, {
       signed,
       size: Number(size2)
@@ -2257,7 +3293,7 @@ function encodeBytes(value, { param }) {
 }
 function encodeBool(value) {
   if (typeof value !== "boolean")
-    throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+    throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
   return { dynamic: false, encoded: padHex(boolToHex(value)) };
 }
 function encodeNumber(value, { signed, size: size2 = 256 }) {
@@ -2351,7 +3387,467 @@ var init_encodeAbiParameters = __esm({
     init_size();
     init_slice();
     init_toHex();
-    init_regex();
+    init_regex2();
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/hash/toFunctionSelector.js
+var toFunctionSelector;
+var init_toFunctionSelector = __esm({
+  "../../node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
+    init_slice();
+    init_toSignatureHash();
+    toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
+  }
+});
+
+// ../../node_modules/viem/_esm/errors/cursor.js
+var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededError;
+var init_cursor = __esm({
+  "../../node_modules/viem/_esm/errors/cursor.js"() {
+    init_base();
+    NegativeOffsetError = class extends BaseError2 {
+      constructor({ offset }) {
+        super(`Offset \`${offset}\` cannot be negative.`, {
+          name: "NegativeOffsetError"
+        });
+      }
+    };
+    PositionOutOfBoundsError = class extends BaseError2 {
+      constructor({ length, position }) {
+        super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
+      }
+    };
+    RecursiveReadLimitExceededError = class extends BaseError2 {
+      constructor({ count, limit }) {
+        super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
+      }
+    };
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/cursor.js
+function createCursor(bytes, { recursiveReadLimit = 8192 } = {}) {
+  const cursor = Object.create(staticCursor);
+  cursor.bytes = bytes;
+  cursor.dataView = new DataView(bytes.buffer ?? bytes, bytes.byteOffset, bytes.byteLength);
+  cursor.positionReadCount = /* @__PURE__ */ new Map();
+  cursor.recursiveReadLimit = recursiveReadLimit;
+  return cursor;
+}
+var staticCursor;
+var init_cursor2 = __esm({
+  "../../node_modules/viem/_esm/utils/cursor.js"() {
+    init_cursor();
+    staticCursor = {
+      bytes: new Uint8Array(),
+      dataView: new DataView(new ArrayBuffer(0)),
+      position: 0,
+      positionReadCount: /* @__PURE__ */ new Map(),
+      recursiveReadCount: 0,
+      recursiveReadLimit: Number.POSITIVE_INFINITY,
+      assertReadLimit() {
+        if (this.recursiveReadCount >= this.recursiveReadLimit)
+          throw new RecursiveReadLimitExceededError({
+            count: this.recursiveReadCount + 1,
+            limit: this.recursiveReadLimit
+          });
+      },
+      assertPosition(position) {
+        if (position < 0 || position > this.bytes.length - 1)
+          throw new PositionOutOfBoundsError({
+            length: this.bytes.length,
+            position
+          });
+      },
+      decrementPosition(offset) {
+        if (offset < 0)
+          throw new NegativeOffsetError({ offset });
+        const position = this.position - offset;
+        this.assertPosition(position);
+        this.position = position;
+      },
+      getReadCount(position) {
+        return this.positionReadCount.get(position || this.position) || 0;
+      },
+      incrementPosition(offset) {
+        if (offset < 0)
+          throw new NegativeOffsetError({ offset });
+        const position = this.position + offset;
+        this.assertPosition(position);
+        this.position = position;
+      },
+      inspectByte(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position);
+        return this.bytes[position];
+      },
+      inspectBytes(length, position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position + length - 1);
+        return this.bytes.subarray(position, position + length);
+      },
+      inspectUint8(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position);
+        return this.bytes[position];
+      },
+      inspectUint16(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position + 1);
+        return this.dataView.getUint16(position);
+      },
+      inspectUint24(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position + 2);
+        return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
+      },
+      inspectUint32(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position + 3);
+        return this.dataView.getUint32(position);
+      },
+      pushByte(byte) {
+        this.assertPosition(this.position);
+        this.bytes[this.position] = byte;
+        this.position++;
+      },
+      pushBytes(bytes) {
+        this.assertPosition(this.position + bytes.length - 1);
+        this.bytes.set(bytes, this.position);
+        this.position += bytes.length;
+      },
+      pushUint8(value) {
+        this.assertPosition(this.position);
+        this.bytes[this.position] = value;
+        this.position++;
+      },
+      pushUint16(value) {
+        this.assertPosition(this.position + 1);
+        this.dataView.setUint16(this.position, value);
+        this.position += 2;
+      },
+      pushUint24(value) {
+        this.assertPosition(this.position + 2);
+        this.dataView.setUint16(this.position, value >> 8);
+        this.dataView.setUint8(this.position + 2, value & ~4294967040);
+        this.position += 3;
+      },
+      pushUint32(value) {
+        this.assertPosition(this.position + 3);
+        this.dataView.setUint32(this.position, value);
+        this.position += 4;
+      },
+      readByte() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectByte();
+        this.position++;
+        return value;
+      },
+      readBytes(length, size2) {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectBytes(length);
+        this.position += size2 ?? length;
+        return value;
+      },
+      readUint8() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectUint8();
+        this.position += 1;
+        return value;
+      },
+      readUint16() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectUint16();
+        this.position += 2;
+        return value;
+      },
+      readUint24() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectUint24();
+        this.position += 3;
+        return value;
+      },
+      readUint32() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectUint32();
+        this.position += 4;
+        return value;
+      },
+      get remaining() {
+        return this.bytes.length - this.position;
+      },
+      setPosition(position) {
+        const oldPosition = this.position;
+        this.assertPosition(position);
+        this.position = position;
+        return () => this.position = oldPosition;
+      },
+      _touch() {
+        if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
+          return;
+        const count = this.getReadCount();
+        this.positionReadCount.set(this.position, count + 1);
+        if (count > 0)
+          this.recursiveReadCount++;
+      }
+    };
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/encoding/fromBytes.js
+function bytesToBigInt(bytes, opts = {}) {
+  if (typeof opts.size !== "undefined")
+    assertSize(bytes, { size: opts.size });
+  const hex = bytesToHex(bytes);
+  return hexToBigInt(hex, opts);
+}
+function bytesToBool(bytes_, opts = {}) {
+  let bytes = bytes_;
+  if (typeof opts.size !== "undefined") {
+    assertSize(bytes, { size: opts.size });
+    bytes = trim(bytes);
+  }
+  if (bytes.length > 1 || bytes[0] > 1)
+    throw new InvalidBytesBooleanError(bytes);
+  return Boolean(bytes[0]);
+}
+function bytesToNumber(bytes, opts = {}) {
+  if (typeof opts.size !== "undefined")
+    assertSize(bytes, { size: opts.size });
+  const hex = bytesToHex(bytes);
+  return hexToNumber(hex, opts);
+}
+function bytesToString(bytes_, opts = {}) {
+  let bytes = bytes_;
+  if (typeof opts.size !== "undefined") {
+    assertSize(bytes, { size: opts.size });
+    bytes = trim(bytes, { dir: "right" });
+  }
+  return new TextDecoder().decode(bytes);
+}
+var init_fromBytes = __esm({
+  "../../node_modules/viem/_esm/utils/encoding/fromBytes.js"() {
+    init_encoding();
+    init_trim();
+    init_fromHex();
+    init_toHex();
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
+function decodeAbiParameters(params, data) {
+  const bytes = typeof data === "string" ? hexToBytes(data) : data;
+  const cursor = createCursor(bytes);
+  if (size(bytes) === 0 && params.length > 0)
+    throw new AbiDecodingZeroDataError();
+  if (size(data) && size(data) < 32)
+    throw new AbiDecodingDataSizeTooSmallError({
+      data: typeof data === "string" ? data : bytesToHex(data),
+      params,
+      size: size(data)
+    });
+  let consumed = 0;
+  const values = [];
+  for (let i = 0; i < params.length; ++i) {
+    const param = params[i];
+    if (consumed < bytes.length)
+      cursor.setPosition(consumed);
+    const [data2, consumed_] = decodeParameter(cursor, param, {
+      staticPosition: 0
+    });
+    consumed += consumed_;
+    values.push(data2);
+  }
+  return values;
+}
+function decodeParameter(cursor, param, { staticPosition }) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return decodeArray(cursor, { ...param, type }, { length, staticPosition });
+  }
+  if (param.type === "tuple")
+    return decodeTuple(cursor, param, { staticPosition });
+  if (param.type === "address")
+    return decodeAddress(cursor);
+  if (param.type === "bool")
+    return decodeBool(cursor);
+  if (param.type.startsWith("bytes"))
+    return decodeBytes(cursor, param, { staticPosition });
+  if (param.type.startsWith("uint") || param.type.startsWith("int"))
+    return decodeNumber(cursor, param);
+  if (param.type === "string")
+    return decodeString(cursor, { staticPosition });
+  throw new InvalidAbiDecodingTypeError(param.type, {
+    docsPath: "/docs/contract/decodeAbiParameters"
+  });
+}
+function decodeAddress(cursor) {
+  const value = cursor.readBytes(32);
+  return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
+}
+function decodeArray(cursor, param, { length, staticPosition }) {
+  if (length === null) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    const startOfData = start + sizeOfLength;
+    cursor.setPosition(start);
+    const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
+    const dynamicChild = hasDynamicChild(param);
+    let consumed2 = 0;
+    const value2 = [];
+    for (let i = 0; i < length2; ++i) {
+      cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
+      const [data, consumed_] = decodeParameter(cursor, param, {
+        staticPosition: startOfData
+      });
+      consumed2 += consumed_;
+      value2.push(data);
+      if (consumed_ === 0) {
+        cursor.assertReadLimit();
+        cursor._touch();
+      }
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value2, 32];
+  }
+  if (hasDynamicChild(param)) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    const value2 = [];
+    for (let i = 0; i < length; ++i) {
+      cursor.setPosition(start + i * 32);
+      const [data] = decodeParameter(cursor, param, {
+        staticPosition: start
+      });
+      value2.push(data);
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value2, 32];
+  }
+  let consumed = 0;
+  const value = [];
+  for (let i = 0; i < length; ++i) {
+    const [data, consumed_] = decodeParameter(cursor, param, {
+      staticPosition: staticPosition + consumed
+    });
+    consumed += consumed_;
+    value.push(data);
+    if (consumed_ === 0) {
+      cursor.assertReadLimit();
+      cursor._touch();
+    }
+  }
+  return [value, consumed];
+}
+function decodeBool(cursor) {
+  return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
+}
+function decodeBytes(cursor, param, { staticPosition }) {
+  const [_, size2] = param.type.split("bytes");
+  if (!size2) {
+    const offset = bytesToNumber(cursor.readBytes(32));
+    cursor.setPosition(staticPosition + offset);
+    const length = bytesToNumber(cursor.readBytes(32));
+    if (length === 0) {
+      cursor.setPosition(staticPosition + 32);
+      return ["0x", 32];
+    }
+    const data = cursor.readBytes(length);
+    cursor.setPosition(staticPosition + 32);
+    return [bytesToHex(data), 32];
+  }
+  const value = bytesToHex(cursor.readBytes(Number.parseInt(size2, 10), 32));
+  return [value, 32];
+}
+function decodeNumber(cursor, param) {
+  const signed = param.type.startsWith("int");
+  const size2 = Number.parseInt(param.type.split("int")[1] || "256", 10);
+  const value = cursor.readBytes(32);
+  return [
+    size2 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
+    32
+  ];
+}
+function decodeTuple(cursor, param, { staticPosition }) {
+  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+  const value = hasUnnamedChild ? [] : {};
+  let consumed = 0;
+  if (hasDynamicChild(param)) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    for (let i = 0; i < param.components.length; ++i) {
+      const component = param.components[i];
+      cursor.setPosition(start + consumed);
+      const [data, consumed_] = decodeParameter(cursor, component, {
+        staticPosition: start
+      });
+      consumed += consumed_;
+      value[hasUnnamedChild ? i : component?.name] = data;
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value, 32];
+  }
+  for (let i = 0; i < param.components.length; ++i) {
+    const component = param.components[i];
+    const [data, consumed_] = decodeParameter(cursor, component, {
+      staticPosition
+    });
+    value[hasUnnamedChild ? i : component?.name] = data;
+    consumed += consumed_;
+  }
+  return [value, consumed];
+}
+function decodeString(cursor, { staticPosition }) {
+  const offset = bytesToNumber(cursor.readBytes(32));
+  const start = staticPosition + offset;
+  cursor.setPosition(start);
+  const length = bytesToNumber(cursor.readBytes(32));
+  if (length === 0) {
+    cursor.setPosition(staticPosition + 32);
+    return ["", 32];
+  }
+  const data = cursor.readBytes(length, 32);
+  const value = bytesToString(data);
+  cursor.setPosition(staticPosition + 32);
+  return [value, 32];
+}
+function hasDynamicChild(param) {
+  const { type } = param;
+  if (type === "string")
+    return true;
+  if (type === "bytes")
+    return true;
+  if (type.endsWith("[]"))
+    return true;
+  if (type === "tuple")
+    return param.components?.some(hasDynamicChild);
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
+    return true;
+  return false;
+}
+var sizeOfLength, sizeOfOffset;
+var init_decodeAbiParameters = __esm({
+  "../../node_modules/viem/_esm/utils/abi/decodeAbiParameters.js"() {
+    init_abi();
+    init_getAddress();
+    init_cursor2();
+    init_size();
+    init_slice();
+    init_fromBytes();
+    init_toBytes();
+    init_toHex();
+    init_encodeAbiParameters();
+    sizeOfLength = 32;
+    sizeOfOffset = 32;
   }
 });
 
@@ -2421,7 +3917,7 @@ function Maj(a, b, c) {
 var HashMD, SHA256_IV;
 var init_md = __esm({
   "../../node_modules/@noble/hashes/esm/_md.js"() {
-    init_utils();
+    init_utils2();
     HashMD = class extends Hash {
       constructor(blockLen, outputLen, padOffset, isLE2) {
         super();
@@ -2530,7 +4026,7 @@ var SHA256_K, SHA256_W, SHA256, sha256;
 var init_sha2 = __esm({
   "../../node_modules/@noble/hashes/esm/sha2.js"() {
     init_md();
-    init_utils();
+    init_utils2();
     SHA256_K = /* @__PURE__ */ Uint32Array.from([
       1116352408,
       1899447441,
@@ -2676,26 +4172,26 @@ var init_sha2 = __esm({
 var HMAC, hmac;
 var init_hmac = __esm({
   "../../node_modules/@noble/hashes/esm/hmac.js"() {
-    init_utils();
+    init_utils2();
     HMAC = class extends Hash {
-      constructor(hash, _key) {
+      constructor(hash2, _key) {
         super();
         this.finished = false;
         this.destroyed = false;
-        ahash(hash);
+        ahash(hash2);
         const key = toBytes2(_key);
-        this.iHash = hash.create();
+        this.iHash = hash2.create();
         if (typeof this.iHash.update !== "function")
           throw new Error("Expected instance of class which extends utils.Hash");
         this.blockLen = this.iHash.blockLen;
         this.outputLen = this.iHash.outputLen;
         const blockLen = this.blockLen;
         const pad2 = new Uint8Array(blockLen);
-        pad2.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+        pad2.set(key.length > blockLen ? hash2.create().update(key).digest() : key);
         for (let i = 0; i < pad2.length; i++)
           pad2[i] ^= 54;
         this.iHash.update(pad2);
-        this.oHash = hash.create();
+        this.oHash = hash2.create();
         for (let i = 0; i < pad2.length; i++)
           pad2[i] ^= 54 ^ 92;
         this.oHash.update(pad2);
@@ -2741,8 +4237,8 @@ var init_hmac = __esm({
         this.iHash.destroy();
       }
     };
-    hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
-    hmac.create = (hash, key) => new HMAC(hash, key);
+    hmac = (hash2, key, message) => new HMAC(hash2, key).update(message).digest();
+    hmac.create = (hash2, key) => new HMAC(hash2, key);
   }
 });
 
@@ -2949,7 +4445,7 @@ function memoized(fn) {
   };
 }
 var _0n2, _1n2, hasHexBuiltin, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns;
-var init_utils2 = __esm({
+var init_utils3 = __esm({
   "../../node_modules/viem/node_modules/@noble/curves/esm/abstract/utils.js"() {
     _0n2 = /* @__PURE__ */ BigInt(0);
     _1n2 = /* @__PURE__ */ BigInt(1);
@@ -3225,8 +4721,8 @@ function mapHashToField(key, fieldOrder, isLE2 = false) {
 var _0n3, _1n3, _2n2, _3n, _4n, _5n, _8n, FIELD_FIELDS;
 var init_modular = __esm({
   "../../node_modules/viem/node_modules/@noble/curves/esm/abstract/modular.js"() {
-    init_utils();
     init_utils2();
+    init_utils3();
     _0n3 = BigInt(0);
     _1n3 = BigInt(1);
     _2n2 = /* @__PURE__ */ BigInt(2);
@@ -3489,7 +4985,7 @@ var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
 var init_curve = __esm({
   "../../node_modules/viem/node_modules/@noble/curves/esm/abstract/curve.js"() {
     init_modular();
-    init_utils2();
+    init_utils3();
     _0n4 = BigInt(0);
     _1n4 = BigInt(1);
     pointPrecomputes = /* @__PURE__ */ new WeakMap();
@@ -4162,14 +5658,14 @@ function weierstrass(curveDef) {
   function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
     if (["recovered", "canonical"].some((k) => k in opts))
       throw new Error("sign() legacy options not supported");
-    const { hash, randomBytes: randomBytes4 } = CURVE;
+    const { hash: hash2, randomBytes: randomBytes4 } = CURVE;
     let { lowS, prehash, extraEntropy: ent } = opts;
     if (lowS == null)
       lowS = true;
     msgHash = ensureBytes("msgHash", msgHash);
     validateSigVerOpts(opts);
     if (prehash)
-      msgHash = ensureBytes("prehashed msgHash", hash(msgHash));
+      msgHash = ensureBytes("prehashed msgHash", hash2(msgHash));
     const h1int = bits2int_modN(msgHash);
     const d = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d), int2octets(h1int)];
@@ -4377,7 +5873,7 @@ var init_weierstrass = __esm({
   "../../node_modules/viem/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
     init_curve();
     init_modular();
-    init_utils2();
+    init_utils3();
     DERErr = class extends Error {
       constructor(m = "") {
         super(m);
@@ -4492,21 +5988,21 @@ var init_weierstrass = __esm({
 });
 
 // ../../node_modules/viem/node_modules/@noble/curves/esm/_shortw_utils.js
-function getHash(hash) {
+function getHash(hash2) {
   return {
-    hash,
-    hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),
+    hash: hash2,
+    hmac: (key, ...msgs) => hmac(hash2, key, concatBytes(...msgs)),
     randomBytes: randomBytes2
   };
 }
 function createCurve(curveDef, defHash) {
-  const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });
+  const create = (hash2) => weierstrass({ ...curveDef, ...getHash(hash2) });
   return { ...create(defHash), create };
 }
 var init_shortw_utils = __esm({
   "../../node_modules/viem/node_modules/@noble/curves/esm/_shortw_utils.js"() {
     init_hmac();
-    init_utils();
+    init_utils2();
     init_weierstrass();
   }
 });
@@ -4578,7 +6074,7 @@ function hash_to_field(msg, count, options) {
     k: "isSafeInteger",
     hash: "hash"
   });
-  const { p, k, m, hash, expand, DST: _DST } = options;
+  const { p, k, m, hash: hash2, expand, DST: _DST } = options;
   abytes2(msg);
   anum(count);
   const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
@@ -4587,9 +6083,9 @@ function hash_to_field(msg, count, options) {
   const len_in_bytes = count * m * L;
   let prb;
   if (expand === "xmd") {
-    prb = expand_message_xmd(msg, DST, len_in_bytes, hash);
+    prb = expand_message_xmd(msg, DST, len_in_bytes, hash2);
   } else if (expand === "xof") {
-    prb = expand_message_xof(msg, DST, len_in_bytes, k, hash);
+    prb = expand_message_xof(msg, DST, len_in_bytes, k, hash2);
   } else if (expand === "_internal_pass") {
     prb = msg;
   } else {
@@ -4661,7 +6157,7 @@ var os2ip;
 var init_hash_to_curve = __esm({
   "../../node_modules/viem/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
     init_modular();
-    init_utils2();
+    init_utils3();
     os2ip = bytesToNumberBE;
   }
 });
@@ -4772,11 +6268,11 @@ var secp256k1P, secp256k1N, _0n6, _1n6, _2n4, divNearest, Fpk1, secp256k1, TAGGE
 var init_secp256k1 = __esm({
   "../../node_modules/viem/node_modules/@noble/curves/esm/secp256k1.js"() {
     init_sha2();
-    init_utils();
+    init_utils2();
     init_shortw_utils();
     init_hash_to_curve();
     init_modular();
-    init_utils2();
+    init_utils3();
     init_weierstrass();
     secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
     secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
@@ -4897,6 +6393,30 @@ var init_secp256k1 = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/utils/abi/decodeFunctionData.js
+function decodeFunctionData(parameters) {
+  const { abi, data } = parameters;
+  const signature = slice(data, 0, 4);
+  const description = abi.find((x) => x.type === "function" && signature === toFunctionSelector(formatAbiItem2(x)));
+  if (!description)
+    throw new AbiFunctionSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeFunctionData"
+    });
+  return {
+    functionName: description.name,
+    args: "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0
+  };
+}
+var init_decodeFunctionData = __esm({
+  "../../node_modules/viem/_esm/utils/abi/decodeFunctionData.js"() {
+    init_abi();
+    init_slice();
+    init_toFunctionSelector();
+    init_decodeAbiParameters();
+    init_formatAbiItem2();
+  }
+});
+
 // ../../node_modules/@msgpack/msgpack/dist.cjs/utils/utf8.cjs
 var require_utf8 = __commonJS({
   "../../node_modules/@msgpack/msgpack/dist.cjs/utils/utf8.cjs"(exports) {
@@ -6619,6 +8139,7 @@ import {
   Chain,
   getChainKind,
   StorageError,
+  toCosmosSequenceMismatchError,
   VaultError,
   VaultErrorCode,
   VaultImportError,
@@ -6966,6 +8487,20 @@ function classifyVaultError(err) {
     case VaultErrorCode.BroadcastFailed: {
       const broadcastChain = getBroadcastErrorChain(err.message);
       const isCosmosBroadcast = broadcastChain !== void 0 && getChainKind(broadcastChain) === "cosmos";
+      const sequenceMismatch = isCosmosBroadcast ? toCosmosSequenceMismatchError(err) : void 0;
+      if (sequenceMismatch?.recovery === "resign") {
+        return new InvalidInputError(
+          err.message,
+          "The account sequence changed after this transaction was prepared. Rebuild the transaction with the latest sequence and start a new signing ceremony; retrying the same signed bytes cannot succeed."
+        );
+      }
+      if (sequenceMismatch?.recovery === "wait") {
+        return new ExternalServiceError(
+          err.message,
+          "This transaction uses a future account sequence. Wait for the preceding transaction to be accepted before retrying these signed bytes.",
+          ["If the chain advances past this sequence, rebuild the transaction and start a new signing ceremony"]
+        );
+      }
       if (isCosmosBroadcast && matchCosmosDeliverTxFailure(err.message)) {
         return new InvalidInputError(
           err.message,
@@ -8385,13 +9920,13 @@ function readRecords() {
   }
   return records;
 }
-function recordBroadcast(fingerprint, hash, chain) {
-  if (!hash) return;
-  appendRecord({ t: "broadcast", fp: fingerprint, hash, chain, ts: nowMs() });
+function recordBroadcast(fingerprint, hash2, chain) {
+  if (!hash2) return;
+  appendRecord({ t: "broadcast", fp: fingerprint, hash: hash2, chain, ts: nowMs() });
 }
-function recordResolution(hash, status) {
-  if (!hash) return;
-  appendRecord({ t: "resolved", hash, status, ts: nowMs() });
+function recordResolution(hash2, status) {
+  if (!hash2) return;
+  appendRecord({ t: "resolved", hash: hash2, status, ts: nowMs() });
 }
 function findRecentDuplicate(fingerprint, options = {}) {
   const windowMs = options.windowMs ?? DEFAULT_BROADCAST_WINDOW_MS;
@@ -8858,7 +10393,13 @@ async function executeAddresses(ctx2) {
 }
 
 // src/commands/tokens.ts
+import { getChainKind as getChainKind3 } from "@vultisig/sdk";
 import chalk4 from "chalk";
+function canonicalTokenId(chain, id) {
+  const legacyPrefix = `${chain}-`;
+  const bareId = id.toLowerCase().startsWith(legacyPrefix.toLowerCase()) ? id.slice(legacyPrefix.length) : id;
+  return getChainKind3(chain) === "evm" ? bareId.toLowerCase() : bareId;
+}
 async function executeTokens(ctx2, options) {
   await ctx2.ensureActiveVault();
   if (options.discover) {
@@ -8917,9 +10458,10 @@ async function executeTokens(ctx2, options) {
 }
 async function addToken(ctx2, options) {
   const vault = await ctx2.ensureActiveVault();
+  const contractAddress = canonicalTokenId(options.chain, options.contractAddress);
   await vault.addToken(options.chain, {
-    id: `${options.chain}-${options.contractAddress}`,
-    contractAddress: options.contractAddress,
+    id: contractAddress,
+    contractAddress,
     symbol: options.symbol,
     name: options.name,
     decimals: options.decimals,
@@ -8935,6 +10477,10 @@ async function removeToken(ctx2, chain, tokenId) {
   if (!removed) {
     throw new TokenNotFoundError(`Token "${tokenId}" not found on ${chain}`);
   }
+  if (isJsonOutput()) {
+    outputJson({ chain, tokenId, removed: true });
+    return;
+  }
   success(`
 + Removed token ${tokenId} from ${chain}`);
 }
@@ -8956,15 +10502,18 @@ async function discoverTokens(ctx2, chain) {
     return;
   }
   const existingTokens = vault.getTokens(chain);
-  const existingAddresses = new Set(existingTokens.map((t) => t.contractAddress ?? t.id));
-  const newTokens = discovered.filter((d) => d.contractAddress && !existingAddresses.has(d.contractAddress));
+  const existingAddresses = new Set(existingTokens.map((t) => canonicalTokenId(chain, t.contractAddress ?? t.id)));
+  const newTokens = discovered.filter(
+    (d) => d.contractAddress && !existingAddresses.has(canonicalTokenId(chain, d.contractAddress))
+  );
   for (const d of newTokens) {
+    const contractAddress = canonicalTokenId(chain, d.contractAddress);
     await vault.addToken(chain, {
-      id: d.contractAddress,
+      id: contractAddress,
       symbol: d.ticker,
       name: d.ticker,
       decimals: d.decimals,
-      contractAddress: d.contractAddress,
+      contractAddress,
       chainId: chain,
       isNative: false
     });
@@ -10666,6 +12215,9 @@ Please specify more characters of the vault ID.`
 // src/commands/swap.ts
 import { toChainAmount } from "@vultisig/sdk";
 
+// ../../node_modules/viem/_esm/index.js
+init_exports();
+
 // ../../node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
 init_getAddress();
 init_keccak256();
@@ -10679,8 +12231,8 @@ init_isHex();
 init_size();
 init_fromHex();
 init_toHex();
-async function recoverPublicKey({ hash, signature }) {
-  const hashHex = isHex(hash) ? hash : toHex(hash);
+async function recoverPublicKey({ hash: hash2, signature }) {
+  const hashHex = isHex(hash2) ? hash2 : toHex(hash2);
   const { secp256k1: secp256k12 } = await Promise.resolve().then(() => (init_secp256k1(), secp256k1_exports));
   const signature_ = (() => {
     if (typeof signature === "object" && "r" in signature && "s" in signature) {
@@ -10710,8 +12262,8 @@ function toRecoveryBit(yParityOrV) {
 }
 
 // ../../node_modules/viem/_esm/utils/signature/recoverAddress.js
-async function recoverAddress({ hash, signature }) {
-  return publicKeyToAddress(await recoverPublicKey({ hash, signature }));
+async function recoverAddress({ hash: hash2, signature }) {
+  return publicKeyToAddress(await recoverPublicKey({ hash: hash2, signature }));
 }
 
 // ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
@@ -10727,14 +12279,14 @@ init_address();
 // ../../node_modules/viem/_esm/errors/typedData.js
 init_stringify();
 init_base();
-var InvalidDomainError = class extends BaseError {
+var InvalidDomainError = class extends BaseError2 {
   constructor({ domain }) {
     super(`Invalid domain "${stringify(domain)}".`, {
       metaMessages: ["Must be a valid EIP-712 domain."]
     });
   }
 };
-var InvalidPrimaryTypeError = class extends BaseError {
+var InvalidPrimaryTypeError = class extends BaseError2 {
   constructor({ primaryType, types }) {
     super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
       docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
@@ -10742,7 +12294,7 @@ var InvalidPrimaryTypeError = class extends BaseError {
     });
   }
 };
-var InvalidStructTypeError = class extends BaseError {
+var InvalidStructTypeError = class extends BaseError2 {
   constructor({ type }) {
     super(`Struct type "${type}" is invalid.`, {
       metaMessages: ["Struct type must not be a Solidity type."],
@@ -10755,14 +12307,14 @@ var InvalidStructTypeError = class extends BaseError {
 init_isAddress();
 init_size();
 init_toHex();
-init_regex();
+init_regex2();
 function validateTypedData(parameters) {
   const { domain, message, primaryType, types } = parameters;
   const validateData = (struct, data) => {
     for (const param of struct) {
       const { name, type } = param;
       const value = data[name];
-      const integerMatch = type.match(integerRegex);
+      const integerMatch = type.match(integerRegex2);
       if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
         const [_type, base, size_] = integerMatch;
         numberToHex(value, {
@@ -10772,7 +12324,7 @@ function validateTypedData(parameters) {
       }
       if (type === "address" && typeof value === "string" && !isAddress(value))
         throw new InvalidAddressError2({ address: value });
-      const bytesMatch = type.match(bytesRegex);
+      const bytesMatch = type.match(bytesRegex2);
       if (bytesMatch) {
         const [_type, size_] = bytesMatch;
         if (size_ && size(value) !== Number.parseInt(size_, 10))
@@ -10937,6 +12489,7 @@ function formatUnits(value, decimals) {
 }
 
 // ../../node_modules/viem/_esm/index.js
+init_decodeFunctionData();
 init_concat();
 init_toBytes();
 init_keccak256();
@@ -12167,15 +13720,16 @@ function extractSurfaceFromText(content, surfaceKey, parser) {
 import { randomUUID } from "node:crypto";
 
 // src/agent/toolOutputSigning.ts
-import { getChainKind as getChainKind4 } from "@vultisig/sdk";
+import { getChainKind as getChainKind5 } from "@vultisig/sdk";
 
 // src/agent/executor.ts
 import {
   Chain as Chain11,
   chainFeeCoin as chainFeeCoin2,
   computeEip712Hash,
-  getChainKind as getChainKind3,
+  getChainKind as getChainKind4,
   getEvmRpcUrl,
+  knownTokensIndex,
   parseThorSwapMemo,
   resolveChainReference,
   toCanonicalEvmSignature,
@@ -12583,6 +14137,18 @@ var EVM_CHAINS = /* @__PURE__ */ new Set([
   "Hyperliquid",
   "Sei"
 ]);
+var ERC20_TRANSFER_SELECTOR = "0xa9059cbb";
+var ERC20_TRANSFER_ABI = parseAbi(["function transfer(address to, uint256 value)"]);
+function decodeErc20Transfer(calldata) {
+  if (calldata.slice(0, ERC20_TRANSFER_SELECTOR.length).toLowerCase() !== ERC20_TRANSFER_SELECTOR) return null;
+  try {
+    const decoded = decodeFunctionData({ abi: ERC20_TRANSFER_ABI, data: calldata });
+    const [recipient, amount] = decoded.args;
+    return { recipient, amount };
+  } catch {
+    throw new Error("Invalid ERC-20 transfer calldata \u2014 refusing to sign");
+  }
+}
 var isEvmChain = (chain) => EVM_CHAINS.has(chain);
 var AgentExecutor = class {
   vault;
@@ -12717,7 +14283,7 @@ var AgentExecutor = class {
    */
   buildBroadcastIntent(payload, chain, overrideTx) {
     const source = overrideTx ?? payload;
-    const dataIsEvmCalldata = getChainKind3(chain) === "evm";
+    const dataIsEvmCalldata = getChainKind4(chain) === "evm";
     const nested = extractNestedTx(source);
     if (nested && (nested.to || nested.value || nested.data)) {
       return {
@@ -12823,7 +14389,7 @@ var AgentExecutor = class {
       const txArgs = txReadyData.txArgs;
       if (txArgs && typeof txArgs === "object" && typeof txArgs.to === "string" && typeof txArgs.amount === "string") {
         const chain2 = resolveChainFromTxReady(txReadyData) || Chain11.Ethereum;
-        if (getChainKind3(chain2) !== "evm") {
+        if (getChainKind4(chain2) !== "evm") {
           this.pendingPayloads.clear();
           this.pendingLegs = [];
           this.pendingPayloads.set("latest", {
@@ -12834,7 +14400,7 @@ var AgentExecutor = class {
           });
           if (this.verbose)
             process.stderr.write(
-              `[executor] Stored non-EVM server tx for chain ${chain2} (kind=${getChainKind3(chain2)})
+              `[executor] Stored non-EVM server tx for chain ${chain2} (kind=${getChainKind4(chain2)})
 `
             );
           return true;
@@ -12886,6 +14452,50 @@ var AgentExecutor = class {
   getPendingChain() {
     return this.pendingPayloads.get("latest")?.chain ?? null;
   }
+  /**
+   * If the transaction that will actually be signed carries ERC-20 `transfer`
+   * calldata, decode its destination and amount and cross-check them against
+   * the producer's declared values. Returns the decoded transfer (authoritative
+   * for the summary) when the signed tx is a transfer, or null otherwise.
+   *
+   * Reads the signed tx via {@link extractNestedTx} — the SAME resolution the
+   * signer uses (`swap_tx || send_tx || tx || txArgs.tx`) — not `txArgs.tx`
+   * alone: a `send_tx`/`tx`/`swap_tx` envelope, or one carrying both a benign
+   * `txArgs.tx` and a malicious higher-precedence key, must not be able to move
+   * funds to an address the consent summary never showed. Fails closed —
+   * clearing the buffered tx and throwing — on malformed transfer calldata or a
+   * producer/calldata recipient or amount mismatch, so a divergent envelope can
+   * never be signed. Invoked before the branch-specific summaries below so a
+   * transfer cannot be disguised as a swap/contract-call to skip the check.
+   */
+  assertConsistentTransfer(p) {
+    const signedTx = extractNestedTx(p);
+    const calldata = typeof signedTx?.data === "string" ? signedTx.data : "";
+    if (calldata === "" || calldata === "0x") return null;
+    let transfer;
+    try {
+      transfer = decodeErc20Transfer(calldata);
+    } catch (error2) {
+      this.clearPendingTransaction();
+      throw error2;
+    }
+    if (!transfer) return null;
+    const producerRecipient = typeof p?.txArgs?.to === "string" ? p.txArgs.to : "";
+    if (producerRecipient && transfer.recipient.toLowerCase() !== producerRecipient.toLowerCase()) {
+      this.clearPendingTransaction();
+      throw new Error(
+        `ERC-20 recipient mismatch \u2014 refusing to sign: txArgs.to ${producerRecipient} does not match calldata destination ${transfer.recipient}`
+      );
+    }
+    const producerAmount = typeof p?.txArgs?.amount === "string" ? p.txArgs.amount : "";
+    if (producerAmount && /^\d+$/.test(producerAmount) && BigInt(producerAmount) !== transfer.amount) {
+      this.clearPendingTransaction();
+      throw new Error(
+        `ERC-20 amount mismatch \u2014 refusing to sign: txArgs.amount ${producerAmount} does not match calldata value ${transfer.amount}`
+      );
+    }
+    return { recipient: transfer.recipient, amount: transfer.amount };
+  }
   /**
    * Human-readable one-line summary of the currently-buffered server tx
    * (set by storeServerTransaction), for the pre-sign confirmation prompt.
@@ -12897,6 +14507,7 @@ var AgentExecutor = class {
     if (!stored) return null;
     const p = stored.payload;
     const labels = p?.resolved?.labels ?? {};
+    const transfer = this.assertConsistentTransfer(p);
     if (p?.__buildTx) {
       const action = typeof p?.action === "string" && p.action ? ` [${p.action}]` : "";
       if (p?.__multiLeg) {
@@ -12919,16 +14530,36 @@ var AgentExecutor = class {
       if (labels.estimated_fee) parts.push(`est. fee ${labels.estimated_fee}`);
       return parts.join(" ");
     }
+    const signedTx = extractNestedTx(p);
+    const contractTo = typeof signedTx?.to === "string" ? signedTx.to : "";
+    const calldata = typeof signedTx?.data === "string" ? signedTx.data : "";
+    const isContractSend = !!contractTo && calldata !== "" && calldata !== "0x";
+    const producerRecipient = typeof p?.txArgs?.to === "string" ? p.txArgs.to : "";
+    const to = transfer?.recipient || producerRecipient || labels.recipient_echo || "?";
+    if (transfer) {
+      return this.renderErc20TransferSummary(transfer.amount, contractTo, stored.chain, to);
+    }
     const amount = labels.resolved_amount ?? p?.txArgs?.amount ?? "?";
     const symbol = labels.token_resolved || labels.token_symbol || "";
     const amountWithSymbol = symbol && !amount.endsWith(` ${symbol}`) ? `${amount} ${symbol}` : amount;
-    const to = p?.txArgs?.to || labels.recipient_echo || "?";
-    const contractTo = typeof p?.txArgs?.tx?.to === "string" ? p.txArgs.tx.to : "";
-    const calldata = typeof p?.txArgs?.tx?.data === "string" ? p.txArgs.tx.data : "";
-    const isContractSend = !!contractTo && calldata !== "" && calldata !== "0x";
     const contractPart = isContractSend && contractTo.toLowerCase() !== to.toLowerCase() ? ` (token contract ${contractTo})` : "";
     return `send ${amountWithSymbol} on ${stored.chain} to ${to}${contractPart}`;
   }
+  /**
+   * Render the consent amount for an ERC-20 transfer from the SIGNED calldata
+   * value, never a producer label. Known tokens use trusted decimals/ticker from
+   * knownTokensIndex; unknown tokens fall back to raw base units with an explicit
+   * unverified marker (the recipient is already cross-checked, so we never fail
+   * closed here).
+   */
+  renderErc20TransferSummary(amount, contractTo, chain, to) {
+    const known = knownTokensIndex[chain]?.[contractTo.toLowerCase()];
+    if (known) {
+      const contractPart = contractTo.toLowerCase() !== to.toLowerCase() ? ` (token contract ${contractTo})` : "";
+      return `send ${formatUnits(amount, known.decimals)} ${known.ticker} on ${chain} to ${to}${contractPart}`;
+    }
+    return `send ${amount} base units of token ${contractTo} (decimals unverified) on ${chain} to ${to}`;
+  }
   /**
    * Wrap a per-tool handler body with normalised success/failure → RecentAction
    * conversion. Replaces the legacy executeAction → ActionResult adapter that
@@ -13199,7 +14830,7 @@ var AgentExecutor = class {
    */
   async signServerTx(serverTxData, defaultChain, params) {
     const chain = resolveChainFromTxReady(serverTxData) || defaultChain;
-    const chainKind = getChainKind3(chain);
+    const chainKind = getChainKind4(chain);
     if (chainKind === "evm") {
       return this.signEvmServerTx(serverTxData, defaultChain, params);
     }
@@ -14186,7 +15817,7 @@ function resolveStrictEvmChain(chain, chainId) {
   const byName = resolveChain(chain);
   const byId = resolveChainId(chainId);
   if (!byName || !byId || byName !== byId) return null;
-  if (getChainKind4(byName) !== "evm") return null;
+  if (getChainKind5(byName) !== "evm") return null;
   return byName;
 }
 function asChainString(value) {
@@ -14250,7 +15881,7 @@ function buildTxReadyFromYieldOutput(toolName, output) {
   const chain = asChainString(env.chain);
   if (!chain) return null;
   const resolved = resolveChain(chain);
-  if (!resolved || getChainKind4(resolved) !== "evm") return null;
+  if (!resolved || getChainKind5(resolved) !== "evm") return null;
   const chainStr = chain;
   const rawTxs = env.transactions;
   if (!Array.isArray(rawTxs) || rawTxs.length === 0) return null;
@@ -15708,8 +17339,8 @@ var TX_CONFIRM_MAX_POLLS = 40;
 function hasUnacknowledgedBroadcastResult(results) {
   return results.some((r) => {
     if (!r.success || !r.data) return false;
-    const hash = r.data.tx_hash;
-    return typeof hash === "string" && hash.length > 0;
+    const hash2 = r.data.tx_hash;
+    return typeof hash2 === "string" && hash2.length > 0;
   });
 }
 function reportDeclinedSigning(executor, toolName, toolCallId, summary, input, ui) {
@@ -17547,7 +19178,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "4.6.0";
+    cachedVersion = "4.7.0";
     return cachedVersion;
   }
   try {
@@ -19935,8 +21566,8 @@ list, so it also changes what portfolio and balance --tokens report. Use
 Examples:
   vultisig tokens Ethereum
   vultisig tokens Ethereum --discover --output json
-  vultisig tokens Ethereum --add 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 --symbol USDC --decimals 6`
-).option("--symbol <symbol>", "Token symbol (for --add)").option("--name <name>", "Token name (for --add)").option("--decimals <decimals>", "Token decimals (for --add)", "18").action(
+  vultisig tokens Ethereum --add 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 --symbol USDC --name "USD Coin" --decimals 6`
+).option("--symbol <symbol>", "Token symbol (for --add)").option("--name <name>", "Token name (required with --add)").option("--decimals <decimals>", "Token decimals (for --add)", "18").action(
   withExit(
     async (chainStr, options) => {
       const chain = resolveChainOrThrow(chainStr);