@dev.sail.money/sailor 0.0.2-27 → 0.0.2-28

package/packages/cli/dist/server.cjs

@@ -21541,7 +21541,7 @@ var require_mediaType = __commonJS({
       var subtype = match[2];
       var type = match[1];
       if (match[3]) {
-        var kvps = splitParameters2(match[3]).map(splitKeyValuePair);
+        var kvps = splitParameters3(match[3]).map(splitKeyValuePair);
         for (var j = 0; j < kvps.length; j++) {
           var pair = kvps[j];
           var key = pair[0].toLowerCase();
@@ -21659,7 +21659,7 @@ var require_mediaType = __commonJS({
       accepts.length = j + 1;
       return accepts;
     }
-    function splitParameters2(str) {
+    function splitParameters3(str) {
       var parameters = str.split(";");
       for (var i = 1, j = 0; i < parameters.length; i++) {
         if (quoteCount(parameters[j]) % 2 == 0) {
@@ -26374,7 +26374,7 @@ var require_websocket_server = __commonJS({
         socket.on("error", socketOnError);
         const key = req.headers["sec-websocket-key"];
         const upgrade = req.headers.upgrade;
-        const version5 = +req.headers["sec-websocket-version"];
+        const version6 = +req.headers["sec-websocket-version"];
         if (req.method !== "GET") {
           const message = "Invalid HTTP method";
           abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
@@ -26390,7 +26390,7 @@ var require_websocket_server = __commonJS({
           abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
           return;
         }
-        if (version5 !== 13 && version5 !== 8) {
+        if (version6 !== 13 && version6 !== 8) {
           const message = "Missing or invalid Sec-WebSocket-Version header";
           abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
             "Sec-WebSocket-Version": "13, 8"
@@ -26434,7 +26434,7 @@ var require_websocket_server = __commonJS({
         }
         if (this.options.verifyClient) {
           const info = {
-            origin: req.headers[`${version5 === 8 ? "sec-websocket-origin" : "origin"}`],
+            origin: req.headers[`${version6 === 8 ? "sec-websocket-origin" : "origin"}`],
             secure: !!(req.socket.authorized || req.socket.encrypted),
             req
           };
@@ -26567,84 +26567,819 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/version.js
+var version;
+var init_version = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/version.js"() {
+    version = "1.2.3";
+  }
+});
+
+// ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/errors.js
+var BaseError;
+var init_errors = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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 docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
+        const message = [
+          shortMessage || "An error occurred.",
+          "",
+          ...args.metaMessages ? [...args.metaMessages, ""] : [],
+          ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
+          ...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 = docsPath9;
+        this.metaMessages = args.metaMessages;
+        this.shortMessage = shortMessage;
+      }
+    };
+  }
+});
+
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/regex.js
 function execTyped(regex, string) {
   const match = regex.exec(string);
   return match?.groups;
 }
-var init_regex = __esm({
-  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/regex.js"() {
-  }
-});
-
-// ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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;
+var bytesRegex, integerRegex, isTupleRegex;
+var init_regex = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
+    init_regex();
+    tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
+  }
+});
+
+// ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
+    init_formatAbiParameter();
+  }
+});
+
+// ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
+    init_formatAbiParameters();
+  }
+});
+
+// ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
+var UnknownTypeError, UnknownSolidityTypeError;
+var init_abiItem = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
+var InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
+var init_abiParameter = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/errors/signature.js
+var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
+var init_signature = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/errors/struct.js
+var CircularReferenceError;
+var init_struct = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
+var InvalidParenthesisError;
+var init_splitParameters = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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++) {
-      const component = abiParameter.components[i];
-      type += formatAbiParameter(component);
-      if (i < length - 1)
-        type += ", ";
+      components_.push(parseAbiParameter(params[i], { structs }));
     }
-    const result = execTyped(tupleRegex, abiParameter.type);
-    type += `)${result?.array || ""}`;
-    return formatAbiParameter({
-      ...abiParameter,
-      type
-    });
+    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 ("indexed" in abiParameter && abiParameter.indexed)
-    type = `${type} indexed`;
-  if (abiParameter.name)
-    return `${type} ${abiParameter.name}`;
-  return 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;
 }
-var tupleRegex;
-var init_formatAbiParameter = __esm({
-  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
+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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
     init_regex();
-    tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
+    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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
-function formatAbiParameters(abiParameters) {
-  let params = "";
+// ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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];
-    params += formatAbiParameter(abiParameter);
-    if (i !== length - 1)
-      params += ", ";
+    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 params;
+  return components;
 }
-var init_formatAbiParameters = __esm({
-  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
-    init_formatAbiParameter();
+var typeWithoutTupleRegex;
+var init_structs = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/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";
+// ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/parseAbi.js
+function parseAbi(signatures) {
+  const structs = parseStructs(signatures);
+  const abi2 = [];
+  const length = signatures.length;
+  for (let i = 0; i < length; i++) {
+    const signature = signatures[i];
+    if (isStructSignature(signature))
+      continue;
+    abi2.push(parseSignature(signature, structs));
+  }
+  return abi2;
 }
-var init_formatAbiItem = __esm({
-  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
-    init_formatAbiParameters();
+var init_parseAbi = __esm({
+  "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
+    init_signatures();
+    init_structs();
+    init_utils();
   }
 });
 
@@ -26652,6 +27387,7 @@ var init_formatAbiItem = __esm({
 var init_exports = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@4.4.3/node_modules/abitype/dist/esm/exports/index.js"() {
     init_formatAbiItem();
+    init_parseAbi();
   }
 });
 
@@ -26704,10 +27440,10 @@ var init_size = __esm({
 });
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/version.js
-var version;
-var init_version = __esm({
+var version2;
+var init_version2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/version.js"() {
-    version = "2.51.3";
+    version2 = "2.51.3";
   }
 });
 
@@ -26719,15 +27455,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/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/base.js"() {
-    init_version();
+    init_version2();
     errorConfig = {
       getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${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)
@@ -26792,7 +27528,7 @@ var init_base = __esm({
         this.metaMessages = args.metaMessages;
         this.name = args.name ?? this.name;
         this.shortMessage = shortMessage;
-        this.version = version;
+        this.version = version2;
       }
       walk(fn) {
         return walk(this, fn);
@@ -26808,7 +27544,7 @@ var init_abi = __esm({
     init_formatAbiItem2();
     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}.`,
@@ -26817,12 +27553,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.",
@@ -26831,7 +27567,7 @@ var init_abi = __esm({
         ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
       }
     };
-    AbiFunctionNotFoundError = class extends BaseError {
+    AbiFunctionNotFoundError = class extends BaseError2 {
       constructor(functionName, { docsPath: docsPath9 } = {}) {
         super([
           `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
@@ -26842,7 +27578,7 @@ var init_abi = __esm({
         });
       }
     };
-    AbiItemAmbiguityError = class extends BaseError {
+    AbiItemAmbiguityError = class extends BaseError2 {
       constructor(x, y) {
         super("Found ambiguous types in overloaded ABI items.", {
           metaMessages: [
@@ -26856,14 +27592,14 @@ var init_abi = __esm({
         });
       }
     };
-    BytesSizeMismatchError = class extends BaseError {
+    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: docsPath9 }) {
         super([
           `Type "${type}" is not a valid encoding type.`,
@@ -26871,14 +27607,14 @@ var init_abi = __esm({
         ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
       }
     };
-    InvalidArrayError = class extends BaseError {
+    InvalidArrayError = class extends BaseError2 {
       constructor(value) {
         super([`Value "${value}" is not a valid array.`].join("\n"), {
           name: "InvalidArrayError"
         });
       }
     };
-    InvalidDefinitionTypeError = class extends BaseError {
+    InvalidDefinitionTypeError = class extends BaseError2 {
       constructor(type) {
         super([
           `"${type}" is not a valid definition type.`,
@@ -26894,12 +27630,12 @@ var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
 var init_data = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/data.js"() {
     init_base();
-    SliceOffsetOutOfBoundsError = class extends BaseError {
+    SliceOffsetOutOfBoundsError = class extends BaseError2 {
       constructor({ offset, position, size: size6 }) {
         super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size6}).`, { name: "SliceOffsetOutOfBoundsError" });
       }
     };
-    SizeExceedsPaddingSizeError = class extends BaseError {
+    SizeExceedsPaddingSizeError = class extends BaseError2 {
       constructor({ size: size6, targetSize, type }) {
         super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size6}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
       }
@@ -26952,12 +27688,12 @@ var IntegerOutOfRangeError, SizeOverflowError;
 var init_encoding = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/encoding.js"() {
     init_base();
-    IntegerOutOfRangeError = class extends BaseError {
+    IntegerOutOfRangeError = class extends BaseError2 {
       constructor({ max, min, signed, size: size6, value }) {
         super(`Number "${value}" is not in safe ${size6 ? `${size6 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
       }
     };
-    SizeOverflowError = class extends BaseError {
+    SizeOverflowError = class extends BaseError2 {
       constructor({ givenSize, maxSize }) {
         super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
       }
@@ -27146,7 +27882,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[index2] = nibbleLeft * 16 + nibbleRight;
   }
@@ -27392,7 +28128,7 @@ function randomBytes(bytesLength = 32) {
   throw new Error("crypto.getRandomValues must be defined");
 }
 var isLE, swap32IfBE, hasHexBuiltin, hexes2, asciis, Hash;
-var init_utils = __esm({
+var init_utils2 = __esm({
   "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js"() {
     init_cryptoNode();
     isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
@@ -27453,7 +28189,7 @@ var _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, SH
 var init_sha3 = __esm({
   "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js"() {
     init_u64();
-    init_utils();
+    init_utils2();
     _0n = BigInt(0);
     _1n = BigInt(1);
     _2n = BigInt(2);
@@ -27666,7 +28402,7 @@ function normalizeSignature(signature) {
     current += char;
   }
   if (!valid)
-    throw new BaseError("Unable to normalize signature.");
+    throw new BaseError2("Unable to normalize signature.");
   return result;
 }
 var init_normalizeSignature = __esm({
@@ -27717,7 +28453,7 @@ var InvalidAddressError;
 var init_address = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/address.js"() {
     init_base();
-    InvalidAddressError = class extends BaseError {
+    InvalidAddressError = class extends BaseError2 {
       constructor({ address }) {
         super(`Address "${address}" is invalid.`, {
           metaMessages: [
@@ -27903,11 +28639,11 @@ var init_slice = __esm({
 });
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/utils/regex.js
-var bytesRegex, integerRegex;
+var bytesRegex2, integerRegex2;
 var init_regex2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/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)?$/;
   }
 });
 
@@ -27953,7 +28689,7 @@ function prepareParam({ param, value }) {
   }
   if (param.type.startsWith("uint") || param.type.startsWith("int")) {
     const signed = param.type.startsWith("int");
-    const [, , size6 = "256"] = integerRegex.exec(param.type) ?? [];
+    const [, , size6 = "256"] = integerRegex2.exec(param.type) ?? [];
     return encodeNumber(value, {
       signed,
       size: Number(size6)
@@ -28057,7 +28793,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: size6 = 256 }) {
@@ -28329,19 +29065,19 @@ var NegativeOffsetError, PositionOutOfBoundsError, RecursiveReadLimitExceededErr
 var init_cursor = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/cursor.js"() {
     init_base();
-    NegativeOffsetError = class extends BaseError {
+    NegativeOffsetError = class extends BaseError2 {
       constructor({ offset }) {
         super(`Offset \`${offset}\` cannot be negative.`, {
           name: "NegativeOffsetError"
         });
       }
     };
-    PositionOutOfBoundsError = class extends BaseError {
+    PositionOutOfBoundsError = class extends BaseError2 {
       constructor({ length, position }) {
         super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
       }
     };
-    RecursiveReadLimitExceededError = class extends BaseError {
+    RecursiveReadLimitExceededError = class extends BaseError2 {
       constructor({ count, limit }) {
         super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
       }
@@ -28590,14 +29326,14 @@ var InvalidLegacyVError, InvalidSerializableTransactionError, InvalidStorageKeyS
 var init_transaction = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/transaction.js"() {
     init_base();
-    InvalidLegacyVError = class extends BaseError {
+    InvalidLegacyVError = class extends BaseError2 {
       constructor({ v }) {
         super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
           name: "InvalidLegacyVError"
         });
       }
     };
-    InvalidSerializableTransactionError = class extends BaseError {
+    InvalidSerializableTransactionError = class extends BaseError2 {
       constructor({ transaction }) {
         super("Cannot infer a transaction type from provided transaction.", {
           metaMessages: [
@@ -28618,7 +29354,7 @@ var init_transaction = __esm({
         });
       }
     };
-    InvalidStorageKeySizeError = class extends BaseError {
+    InvalidStorageKeySizeError = class extends BaseError2 {
       constructor({ storageKey }) {
         super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
       }
@@ -28724,7 +29460,7 @@ function getSizeOfLength(length) {
     return 3;
   if (length < 2 ** 32)
     return 4;
-  throw new BaseError("Length is too large.");
+  throw new BaseError2("Length is too large.");
 }
 var init_toRlp = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/utils/encoding/toRlp.js"() {
@@ -28767,7 +29503,7 @@ var init_node = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/node.js"() {
     init_formatGwei();
     init_base();
-    ExecutionRevertedError = class extends BaseError {
+    ExecutionRevertedError = class extends BaseError2 {
       constructor({ cause, message } = {}) {
         const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
         super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
@@ -28788,7 +29524,7 @@ var init_node = __esm({
       writable: true,
       value: /execution reverted|gas required exceeds allowance/
     });
-    FeeCapTooHighError = class extends BaseError {
+    FeeCapTooHighError = class extends BaseError2 {
       constructor({ cause, maxFeePerGas } = {}) {
         super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
           cause,
@@ -28802,7 +29538,7 @@ var init_node = __esm({
       writable: true,
       value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
     });
-    FeeCapTooLowError = class extends BaseError {
+    FeeCapTooLowError = class extends BaseError2 {
       constructor({ cause, maxFeePerGas } = {}) {
         super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
           cause,
@@ -28816,7 +29552,7 @@ var init_node = __esm({
       writable: true,
       value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
     });
-    NonceTooHighError = class extends BaseError {
+    NonceTooHighError = class extends BaseError2 {
       constructor({ cause, nonce } = {}) {
         super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
       }
@@ -28827,7 +29563,7 @@ var init_node = __esm({
       writable: true,
       value: /nonce too high/
     });
-    NonceTooLowError = class extends BaseError {
+    NonceTooLowError = class extends BaseError2 {
       constructor({ cause, nonce } = {}) {
         super([
           `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
@@ -28841,7 +29577,7 @@ var init_node = __esm({
       writable: true,
       value: /nonce too low|transaction already imported|already known/
     });
-    NonceMaxValueError = class extends BaseError {
+    NonceMaxValueError = class extends BaseError2 {
       constructor({ cause, nonce } = {}) {
         super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
       }
@@ -28852,7 +29588,7 @@ var init_node = __esm({
       writable: true,
       value: /nonce has max value/
     });
-    InsufficientFundsError = class extends BaseError {
+    InsufficientFundsError = class extends BaseError2 {
       constructor({ cause } = {}) {
         super([
           "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
@@ -28878,7 +29614,7 @@ var init_node = __esm({
       writable: true,
       value: /insufficient funds|exceeds transaction sender account balance/
     });
-    IntrinsicGasTooHighError = class extends BaseError {
+    IntrinsicGasTooHighError = class extends BaseError2 {
       constructor({ cause, gas } = {}) {
         super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
           cause,
@@ -28892,7 +29628,7 @@ var init_node = __esm({
       writable: true,
       value: /intrinsic gas too high|gas limit reached/
     });
-    IntrinsicGasTooLowError = class extends BaseError {
+    IntrinsicGasTooLowError = class extends BaseError2 {
       constructor({ cause, gas } = {}) {
         super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
           cause,
@@ -28906,7 +29642,7 @@ var init_node = __esm({
       writable: true,
       value: /intrinsic gas too low/
     });
-    TransactionTypeNotSupportedError = class extends BaseError {
+    TransactionTypeNotSupportedError = class extends BaseError2 {
       constructor({ cause }) {
         super("The transaction type is not supported for this chain.", {
           cause,
@@ -28920,7 +29656,7 @@ var init_node = __esm({
       writable: true,
       value: /transaction type not valid/
     });
-    TipAboveFeeCapError = class extends BaseError {
+    TipAboveFeeCapError = class extends BaseError2 {
       constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
         super([
           `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ""}).`
@@ -29102,7 +29838,7 @@ function Maj(a, b, c) {
 var HashMD, SHA256_IV, SHA512_IV;
 var init_md = __esm({
   "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_md.js"() {
-    init_utils();
+    init_utils2();
     HashMD = class extends Hash {
       constructor(blockLen, outputLen, padOffset, isLE2) {
         super();
@@ -29230,7 +29966,7 @@ var init_sha2 = __esm({
   "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha2.js"() {
     init_md();
     init_u64();
-    init_utils();
+    init_utils2();
     SHA256_K = /* @__PURE__ */ Uint32Array.from([
       1116352408,
       1899447441,
@@ -29598,10 +30334,10 @@ var init_sha2562 = __esm({
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
 function commitmentToVersionedHash(parameters) {
-  const { commitment, version: version5 = 1 } = parameters;
+  const { commitment, version: version6 = 1 } = parameters;
   const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
   const versionedHash = sha2563(commitment, "bytes");
-  versionedHash.set([version5], 0);
+  versionedHash.set([version6], 0);
   return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
 }
 var init_commitmentToVersionedHash = __esm({
@@ -29613,14 +30349,14 @@ var init_commitmentToVersionedHash = __esm({
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
 function commitmentsToVersionedHashes(parameters) {
-  const { commitments, version: version5 } = parameters;
+  const { commitments, version: version6 } = parameters;
   const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
   const hashes = [];
   for (const commitment of commitments) {
     hashes.push(commitmentToVersionedHash({
       commitment,
       to,
-      version: version5
+      version: version6
     }));
   }
   return hashes;
@@ -29659,7 +30395,7 @@ var init_blob2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/blob.js"() {
     init_kzg();
     init_base();
-    BlobSizeTooLargeError = class extends BaseError {
+    BlobSizeTooLargeError = class extends BaseError2 {
       constructor({ maxSize, size: size6 }) {
         super("Blob size is too large.", {
           metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size6} bytes`],
@@ -29667,12 +30403,12 @@ var init_blob2 = __esm({
         });
       }
     };
-    EmptyBlobError = class extends BaseError {
+    EmptyBlobError = class extends BaseError2 {
       constructor() {
         super("Blob data must not be empty.", { name: "EmptyBlobError" });
       }
     };
-    InvalidVersionedHashSizeError = class extends BaseError {
+    InvalidVersionedHashSizeError = class extends BaseError2 {
       constructor({ hash: hash4, size: size6 }) {
         super(`Versioned hash "${hash4}" size is invalid.`, {
           metaMessages: ["Expected: 32", `Received: ${size6}`],
@@ -29680,12 +30416,12 @@ var init_blob2 = __esm({
         });
       }
     };
-    InvalidVersionedHashVersionError = class extends BaseError {
-      constructor({ hash: hash4, version: version5 }) {
+    InvalidVersionedHashVersionError = class extends BaseError2 {
+      constructor({ hash: hash4, version: version6 }) {
         super(`Versioned hash "${hash4}" version is invalid.`, {
           metaMessages: [
             `Expected: ${versionedHashVersionKzg}`,
-            `Received: ${version5}`
+            `Received: ${version6}`
           ],
           name: "InvalidVersionedHashVersionError"
         });
@@ -29989,7 +30725,7 @@ function memoized(fn) {
   };
 }
 var _0n2, _1n2, hasHexBuiltin2, hexes3, asciis2, isPosBig, bitMask, u8n, u8fr, validatorFns;
-var init_utils2 = __esm({
+var init_utils3 = __esm({
   "../../node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/utils.js"() {
     _0n2 = /* @__PURE__ */ BigInt(0);
     _1n2 = /* @__PURE__ */ BigInt(1);
@@ -30020,7 +30756,7 @@ var InvalidChainIdError;
 var init_chain = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/chain.js"() {
     init_base();
-    InvalidChainIdError = class extends BaseError {
+    InvalidChainIdError = class extends BaseError2 {
       constructor({ chainId }) {
         super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
       }
@@ -30050,13 +30786,13 @@ function assertTransactionEIP4844(transaction) {
       throw new EmptyBlobError();
     for (const hash4 of blobVersionedHashes) {
       const size_ = size(hash4);
-      const version5 = hexToNumber(slice(hash4, 0, 1));
+      const version6 = hexToNumber(slice(hash4, 0, 1));
       if (size_ !== 32)
         throw new InvalidVersionedHashSizeError({ hash: hash4, size: size_ });
-      if (version5 !== versionedHashVersionKzg)
+      if (version6 !== versionedHashVersionKzg)
         throw new InvalidVersionedHashVersionError({
           hash: hash4,
-          version: version5
+          version: version6
         });
     }
   }
@@ -30080,7 +30816,7 @@ function assertTransactionEIP2930(transaction) {
   if (to && !isAddress(to))
     throw new InvalidAddressError({ address: to });
   if (maxPriorityFeePerGas || maxFeePerGas)
-    throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
+    throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
   if (gasPrice && gasPrice > maxUint256)
     throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
 }
@@ -30091,7 +30827,7 @@ function assertTransactionLegacy(transaction) {
   if (typeof chainId !== "undefined" && chainId <= 0)
     throw new InvalidChainIdError({ chainId });
   if (maxPriorityFeePerGas || maxFeePerGas)
-    throw new BaseError("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
+    throw new BaseError2("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
   if (gasPrice && gasPrice > maxUint256)
     throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
 }
@@ -30395,7 +31131,7 @@ var Rho160, Id160, Pi160, idxLR, idxL, idxR, shifts160, shiftsL160, shiftsR160,
 var init_legacy = __esm({
   "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/legacy.js"() {
     init_md();
-    init_utils();
+    init_utils2();
     Rho160 = /* @__PURE__ */ Uint8Array.from([
       7,
       4,
@@ -30550,14 +31286,14 @@ var init_typedData = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/errors/typedData.js"() {
     init_stringify();
     init_base();
-    InvalidDomainError = class extends BaseError {
+    InvalidDomainError = class extends BaseError2 {
       constructor({ domain }) {
         super(`Invalid domain "${stringify(domain)}".`, {
           metaMessages: ["Must be a valid EIP-712 domain."]
         });
       }
     };
-    InvalidPrimaryTypeError = class extends BaseError {
+    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",
@@ -30565,7 +31301,7 @@ var init_typedData = __esm({
         });
       }
     };
-    InvalidStructTypeError = class extends BaseError {
+    InvalidStructTypeError = class extends BaseError2 {
       constructor({ type }) {
         super(`Struct type "${type}" is invalid.`, {
           metaMessages: ["Struct type must not be a Solidity type."],
@@ -30583,7 +31319,7 @@ function validateTypedData(parameters) {
     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, {
@@ -30593,7 +31329,7 @@ function validateTypedData(parameters) {
       }
       if (type === "address" && typeof value === "string" && !isAddress(value))
         throw new InvalidAddressError({ 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))
@@ -30775,7 +31511,7 @@ var init_hashTypedData = __esm({
 var HMAC, hmac;
 var init_hmac = __esm({
   "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/hmac.js"() {
-    init_utils();
+    init_utils2();
     HMAC = class extends Hash {
       constructor(hash4, _key) {
         super();
@@ -31095,8 +31831,8 @@ function mapHashToField(key, fieldOrder, isLE2 = false) {
 var _0n3, _1n3, _2n2, _3n, _4n, _5n, _8n, FIELD_FIELDS;
 var init_modular = __esm({
   "../../node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/modular.js"() {
-    init_utils();
     init_utils2();
+    init_utils3();
     _0n3 = BigInt(0);
     _1n3 = BigInt(1);
     _2n2 = /* @__PURE__ */ BigInt(2);
@@ -31359,7 +32095,7 @@ var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
 var init_curve = __esm({
   "../../node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/curve.js"() {
     init_modular();
-    init_utils2();
+    init_utils3();
     _0n4 = BigInt(0);
     _1n4 = BigInt(1);
     pointPrecomputes = /* @__PURE__ */ new WeakMap();
@@ -32247,7 +32983,7 @@ var init_weierstrass = __esm({
   "../../node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/weierstrass.js"() {
     init_curve();
     init_modular();
-    init_utils2();
+    init_utils3();
     DERErr = class extends Error {
       constructor(m = "") {
         super(m);
@@ -32376,7 +33112,7 @@ function createCurve(curveDef, defHash) {
 var init_shortw_utils = __esm({
   "../../node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/_shortw_utils.js"() {
     init_hmac();
-    init_utils();
+    init_utils2();
     init_weierstrass();
   }
 });
@@ -32531,7 +33267,7 @@ var os2ip;
 var init_hash_to_curve = __esm({
   "../../node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/hash-to-curve.js"() {
     init_modular();
-    init_utils2();
+    init_utils3();
     os2ip = bytesToNumberBE;
   }
 });
@@ -32642,11 +33378,11 @@ var secp256k1P, secp256k1N, _0n6, _1n6, _2n4, divNearest, Fpk1, secp256k1, TAGGE
 var init_secp256k1 = __esm({
   "../../node_modules/.pnpm/@noble+curves@1.9.1/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");
@@ -32800,27 +33536,29 @@ var init_serializeSignature = __esm({
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/index.js
 var init_esm = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.4.3/node_modules/viem/_esm/index.js"() {
+    init_exports();
     init_address2();
     init_encodeFunctionData();
+    init_toBytes();
     init_keccak256();
     init_hashTypedData();
   }
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/version.js
-var version2;
-var init_version2 = __esm({
+var version3;
+var init_version3 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/version.js"() {
-    version2 = "1.2.3";
+    version3 = "1.2.3";
   }
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/errors.js
-var BaseError2;
-var init_errors = __esm({
+var BaseError3;
+var init_errors2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/errors.js"() {
-    init_version2();
-    BaseError2 = class _BaseError extends Error {
+    init_version3();
+    BaseError3 = 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 docsPath9 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
@@ -32830,7 +33568,7 @@ var init_errors = __esm({
           ...args.metaMessages ? [...args.metaMessages, ""] : [],
           ...docsPath9 ? [`Docs: https://abitype.dev${docsPath9}`] : [],
           ...details ? [`Details: ${details}`] : [],
-          `Version: abitype@${version2}`
+          `Version: abitype@${version3}`
         ].join("\n");
         super(message);
         Object.defineProperty(this, "details", {
@@ -32879,12 +33617,12 @@ function execTyped2(regex, string) {
   const match = regex.exec(string);
   return match?.groups;
 }
-var bytesRegex2, integerRegex2, isTupleRegex;
+var bytesRegex3, integerRegex3, isTupleRegex2;
 var init_regex3 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/regex.js"() {
-    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)?$/;
-    isTupleRegex = /^\(.+?\).*?$/;
+    bytesRegex3 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+    integerRegex3 = /^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)?$/;
+    isTupleRegex2 = /^\(.+?\).*?$/;
   }
 });
 
@@ -32960,64 +33698,64 @@ var init_formatAbiItem3 = __esm({
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
-function isErrorSignature(signature) {
-  return errorSignatureRegex.test(signature);
+function isErrorSignature2(signature) {
+  return errorSignatureRegex2.test(signature);
 }
-function execErrorSignature(signature) {
-  return execTyped2(errorSignatureRegex, signature);
+function execErrorSignature2(signature) {
+  return execTyped2(errorSignatureRegex2, signature);
 }
-function isEventSignature(signature) {
-  return eventSignatureRegex.test(signature);
+function isEventSignature2(signature) {
+  return eventSignatureRegex2.test(signature);
 }
-function execEventSignature(signature) {
-  return execTyped2(eventSignatureRegex, signature);
+function execEventSignature2(signature) {
+  return execTyped2(eventSignatureRegex2, signature);
 }
-function isFunctionSignature(signature) {
-  return functionSignatureRegex.test(signature);
+function isFunctionSignature2(signature) {
+  return functionSignatureRegex2.test(signature);
 }
-function execFunctionSignature(signature) {
-  return execTyped2(functionSignatureRegex, signature);
+function execFunctionSignature2(signature) {
+  return execTyped2(functionSignatureRegex2, signature);
 }
-function isStructSignature(signature) {
-  return structSignatureRegex.test(signature);
+function isStructSignature2(signature) {
+  return structSignatureRegex2.test(signature);
 }
-function execStructSignature(signature) {
-  return execTyped2(structSignatureRegex, signature);
+function execStructSignature2(signature) {
+  return execTyped2(structSignatureRegex2, signature);
 }
-function isConstructorSignature(signature) {
-  return constructorSignatureRegex.test(signature);
+function isConstructorSignature2(signature) {
+  return constructorSignatureRegex2.test(signature);
 }
-function execConstructorSignature(signature) {
-  return execTyped2(constructorSignatureRegex, signature);
+function execConstructorSignature2(signature) {
+  return execTyped2(constructorSignatureRegex2, signature);
 }
-function isFallbackSignature(signature) {
-  return fallbackSignatureRegex.test(signature);
+function isFallbackSignature2(signature) {
+  return fallbackSignatureRegex2.test(signature);
 }
-function execFallbackSignature(signature) {
-  return execTyped2(fallbackSignatureRegex, signature);
+function execFallbackSignature2(signature) {
+  return execTyped2(fallbackSignatureRegex2, signature);
 }
-function isReceiveSignature(signature) {
-  return receiveSignatureRegex.test(signature);
+function isReceiveSignature2(signature) {
+  return receiveSignatureRegex2.test(signature);
 }
-var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, modifiers, eventModifiers, functionModifiers;
-var init_signatures = __esm({
+var errorSignatureRegex2, eventSignatureRegex2, functionSignatureRegex2, structSignatureRegex2, constructorSignatureRegex2, fallbackSignatureRegex2, receiveSignatureRegex2, modifiers, eventModifiers2, functionModifiers2;
+var init_signatures2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
     init_regex3();
-    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$/;
+    errorSignatureRegex2 = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+    eventSignatureRegex2 = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+    functionSignatureRegex2 = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
+    structSignatureRegex2 = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
+    constructorSignatureRegex2 = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
+    fallbackSignatureRegex2 = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
+    receiveSignatureRegex2 = /^receive\(\) external payable$/;
     modifiers = /* @__PURE__ */ new Set([
       "memory",
       "indexed",
       "storage",
       "calldata"
     ]);
-    eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
-    functionModifiers = /* @__PURE__ */ new Set([
+    eventModifiers2 = /* @__PURE__ */ new Set(["indexed"]);
+    functionModifiers2 = /* @__PURE__ */ new Set([
       "calldata",
       "memory",
       "storage"
@@ -33026,11 +33764,11 @@ var init_signatures = __esm({
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
-var InvalidAbiItemError, UnknownTypeError, UnknownSolidityTypeError;
-var init_abiItem = __esm({
+var InvalidAbiItemError2, UnknownTypeError2, UnknownSolidityTypeError2;
+var init_abiItem2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
-    init_errors();
-    InvalidAbiItemError = class extends BaseError2 {
+    init_errors2();
+    InvalidAbiItemError2 = class extends BaseError3 {
       constructor({ signature }) {
         super("Failed to parse ABI item.", {
           details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
@@ -33044,7 +33782,7 @@ var init_abiItem = __esm({
         });
       }
     };
-    UnknownTypeError = class extends BaseError2 {
+    UnknownTypeError2 = class extends BaseError3 {
       constructor({ type }) {
         super("Unknown type.", {
           metaMessages: [
@@ -33059,7 +33797,7 @@ var init_abiItem = __esm({
         });
       }
     };
-    UnknownSolidityTypeError = class extends BaseError2 {
+    UnknownSolidityTypeError2 = class extends BaseError3 {
       constructor({ type }) {
         super("Unknown type.", {
           metaMessages: [`Type "${type}" is not a valid ABI type.`]
@@ -33076,11 +33814,11 @@ var init_abiItem = __esm({
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
-var InvalidAbiParametersError, InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
-var init_abiParameter = __esm({
+var InvalidAbiParametersError2, InvalidParameterError2, SolidityProtectedKeywordError2, InvalidModifierError2, InvalidFunctionModifierError2, InvalidAbiTypeParameterError2;
+var init_abiParameter2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
-    init_errors();
-    InvalidAbiParametersError = class extends BaseError2 {
+    init_errors2();
+    InvalidAbiParametersError2 = class extends BaseError3 {
       constructor({ params }) {
         super("Failed to parse ABI parameters.", {
           details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
@@ -33094,7 +33832,7 @@ var init_abiParameter = __esm({
         });
       }
     };
-    InvalidParameterError = class extends BaseError2 {
+    InvalidParameterError2 = class extends BaseError3 {
       constructor({ param }) {
         super("Invalid ABI parameter.", {
           details: param
@@ -33107,7 +33845,7 @@ var init_abiParameter = __esm({
         });
       }
     };
-    SolidityProtectedKeywordError = class extends BaseError2 {
+    SolidityProtectedKeywordError2 = class extends BaseError3 {
       constructor({ param, name }) {
         super("Invalid ABI parameter.", {
           details: param,
@@ -33123,7 +33861,7 @@ var init_abiParameter = __esm({
         });
       }
     };
-    InvalidModifierError = class extends BaseError2 {
+    InvalidModifierError2 = class extends BaseError3 {
       constructor({ param, type, modifier }) {
         super("Invalid ABI parameter.", {
           details: param,
@@ -33139,7 +33877,7 @@ var init_abiParameter = __esm({
         });
       }
     };
-    InvalidFunctionModifierError = class extends BaseError2 {
+    InvalidFunctionModifierError2 = class extends BaseError3 {
       constructor({ param, type, modifier }) {
         super("Invalid ABI parameter.", {
           details: param,
@@ -33156,7 +33894,7 @@ var init_abiParameter = __esm({
         });
       }
     };
-    InvalidAbiTypeParameterError = class extends BaseError2 {
+    InvalidAbiTypeParameterError2 = class extends BaseError3 {
       constructor({ abiParameter }) {
         super("Invalid ABI parameter.", {
           details: JSON.stringify(abiParameter, null, 2),
@@ -33174,11 +33912,11 @@ var init_abiParameter = __esm({
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/signature.js
-var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
-var init_signature = __esm({
+var InvalidSignatureError2, UnknownSignatureError2, InvalidStructSignatureError2;
+var init_signature2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
-    init_errors();
-    InvalidSignatureError = class extends BaseError2 {
+    init_errors2();
+    InvalidSignatureError2 = class extends BaseError3 {
       constructor({ signature, type }) {
         super(`Invalid ${type} signature.`, {
           details: signature
@@ -33191,7 +33929,7 @@ var init_signature = __esm({
         });
       }
     };
-    UnknownSignatureError = class extends BaseError2 {
+    UnknownSignatureError2 = class extends BaseError3 {
       constructor({ signature }) {
         super("Unknown signature.", {
           details: signature
@@ -33204,7 +33942,7 @@ var init_signature = __esm({
         });
       }
     };
-    InvalidStructSignatureError = class extends BaseError2 {
+    InvalidStructSignatureError2 = class extends BaseError3 {
       constructor({ signature }) {
         super("Invalid struct signature.", {
           details: signature,
@@ -33222,11 +33960,11 @@ var init_signature = __esm({
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/struct.js
-var CircularReferenceError;
-var init_struct = __esm({
+var CircularReferenceError2;
+var init_struct2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
-    init_errors();
-    CircularReferenceError = class extends BaseError2 {
+    init_errors2();
+    CircularReferenceError2 = class extends BaseError3 {
       constructor({ type }) {
         super("Circular reference detected.", {
           metaMessages: [`Struct "${type}" is a circular reference.`]
@@ -33243,11 +33981,11 @@ var init_struct = __esm({
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
-var InvalidParenthesisError;
-var init_splitParameters = __esm({
+var InvalidParenthesisError2;
+var init_splitParameters2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
-    init_errors();
-    InvalidParenthesisError = class extends BaseError2 {
+    init_errors2();
+    InvalidParenthesisError2 = class extends BaseError3 {
       constructor({ current, depth }) {
         super("Unbalanced parentheses.", {
           metaMessages: [
@@ -33267,7 +34005,7 @@ var init_splitParameters = __esm({
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/runtime/cache.js
-function getParameterCacheKey(param, type, structs) {
+function getParameterCacheKey2(param, type, structs) {
   let structKey = "";
   if (structs)
     for (const struct of Object.entries(structs)) {
@@ -33283,10 +34021,10 @@ function getParameterCacheKey(param, type, structs) {
     return `${type}:${param}${structKey}`;
   return `${param}${structKey}`;
 }
-var parameterCache;
-var init_cache = __esm({
+var parameterCache2;
+var init_cache2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
-    parameterCache = /* @__PURE__ */ new Map([
+    parameterCache2 = /* @__PURE__ */ new Map([
       // Unnamed
       ["address", { type: "address" }],
       ["bool", { type: "bool" }],
@@ -33344,45 +34082,45 @@ var init_cache = __esm({
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/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))
+function parseSignature2(signature, structs = {}) {
+  if (isFunctionSignature2(signature))
+    return parseFunctionSignature2(signature, structs);
+  if (isEventSignature2(signature))
+    return parseEventSignature2(signature, structs);
+  if (isErrorSignature2(signature))
+    return parseErrorSignature2(signature, structs);
+  if (isConstructorSignature2(signature))
+    return parseConstructorSignature2(signature, structs);
+  if (isFallbackSignature2(signature))
+    return parseFallbackSignature2(signature);
+  if (isReceiveSignature2(signature))
     return {
       type: "receive",
       stateMutability: "payable"
     };
-  throw new UnknownSignatureError({ signature });
+  throw new UnknownSignatureError2({ signature });
 }
-function parseFunctionSignature(signature, structs = {}) {
-  const match = execFunctionSignature(signature);
+function parseFunctionSignature2(signature, structs = {}) {
+  const match = execFunctionSignature2(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "function" });
-  const inputParams = splitParameters(match.parameters);
+    throw new InvalidSignatureError2({ signature, type: "function" });
+  const inputParams = splitParameters2(match.parameters);
   const inputs = [];
   const inputLength = inputParams.length;
   for (let i = 0; i < inputLength; i++) {
-    inputs.push(parseAbiParameter(inputParams[i], {
-      modifiers: functionModifiers,
+    inputs.push(parseAbiParameter3(inputParams[i], {
+      modifiers: functionModifiers2,
       structs,
       type: "function"
     }));
   }
   const outputs = [];
   if (match.returns) {
-    const outputParams = splitParameters(match.returns);
+    const outputParams = splitParameters2(match.returns);
     const outputLength = outputParams.length;
     for (let i = 0; i < outputLength; i++) {
-      outputs.push(parseAbiParameter(outputParams[i], {
-        modifiers: functionModifiers,
+      outputs.push(parseAbiParameter3(outputParams[i], {
+        modifiers: functionModifiers2,
         structs,
         type: "function"
       }));
@@ -33396,66 +34134,66 @@ function parseFunctionSignature(signature, structs = {}) {
     outputs
   };
 }
-function parseEventSignature(signature, structs = {}) {
-  const match = execEventSignature(signature);
+function parseEventSignature2(signature, structs = {}) {
+  const match = execEventSignature2(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "event" });
-  const params = splitParameters(match.parameters);
+    throw new InvalidSignatureError2({ signature, type: "event" });
+  const params = splitParameters2(match.parameters);
   const abiParameters = [];
   const length = params.length;
   for (let i = 0; i < length; i++)
-    abiParameters.push(parseAbiParameter(params[i], {
-      modifiers: eventModifiers,
+    abiParameters.push(parseAbiParameter3(params[i], {
+      modifiers: eventModifiers2,
       structs,
       type: "event"
     }));
   return { name: match.name, type: "event", inputs: abiParameters };
 }
-function parseErrorSignature(signature, structs = {}) {
-  const match = execErrorSignature(signature);
+function parseErrorSignature2(signature, structs = {}) {
+  const match = execErrorSignature2(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "error" });
-  const params = splitParameters(match.parameters);
+    throw new InvalidSignatureError2({ signature, type: "error" });
+  const params = splitParameters2(match.parameters);
   const abiParameters = [];
   const length = params.length;
   for (let i = 0; i < length; i++)
-    abiParameters.push(parseAbiParameter(params[i], { structs, type: "error" }));
+    abiParameters.push(parseAbiParameter3(params[i], { structs, type: "error" }));
   return { name: match.name, type: "error", inputs: abiParameters };
 }
-function parseConstructorSignature(signature, structs = {}) {
-  const match = execConstructorSignature(signature);
+function parseConstructorSignature2(signature, structs = {}) {
+  const match = execConstructorSignature2(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "constructor" });
-  const params = splitParameters(match.parameters);
+    throw new InvalidSignatureError2({ signature, type: "constructor" });
+  const params = splitParameters2(match.parameters);
   const abiParameters = [];
   const length = params.length;
   for (let i = 0; i < length; i++)
-    abiParameters.push(parseAbiParameter(params[i], { structs, type: "constructor" }));
+    abiParameters.push(parseAbiParameter3(params[i], { structs, type: "constructor" }));
   return {
     type: "constructor",
     stateMutability: match.stateMutability ?? "nonpayable",
     inputs: abiParameters
   };
 }
-function parseFallbackSignature(signature) {
-  const match = execFallbackSignature(signature);
+function parseFallbackSignature2(signature) {
+  const match = execFallbackSignature2(signature);
   if (!match)
-    throw new InvalidSignatureError({ signature, type: "fallback" });
+    throw new InvalidSignatureError2({ 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 = execTyped2(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
+function parseAbiParameter3(param, options) {
+  const parameterCacheKey = getParameterCacheKey2(param, options?.type, options?.structs);
+  if (parameterCache2.has(parameterCacheKey))
+    return parameterCache2.get(parameterCacheKey);
+  const isTuple = isTupleRegex2.test(param);
+  const match = execTyped2(isTuple ? abiParameterWithTupleRegex2 : abiParameterWithoutTupleRegex2, param);
   if (!match)
-    throw new InvalidParameterError({ param });
-  if (match.name && isSolidityKeyword(match.name))
-    throw new SolidityProtectedKeywordError({ param, name: match.name });
+    throw new InvalidParameterError2({ param });
+  if (match.name && isSolidityKeyword2(match.name))
+    throw new SolidityProtectedKeywordError2({ param, name: match.name });
   const name = match.name ? { name: match.name } : {};
   const indexed = match.modifier === "indexed" ? { indexed: true } : {};
   const structs = options?.structs ?? {};
@@ -33463,34 +34201,34 @@ function parseAbiParameter(param, options) {
   let components = {};
   if (isTuple) {
     type = "tuple";
-    const params = splitParameters(match.type);
+    const params = splitParameters2(match.type);
     const components_ = [];
     const length = params.length;
     for (let i = 0; i < length; i++) {
-      components_.push(parseAbiParameter(params[i], { structs }));
+      components_.push(parseAbiParameter3(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)) {
+  } else if (dynamicIntegerRegex2.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 (!(options?.type === "struct") && !isSolidityType2(type))
+      throw new UnknownSolidityTypeError2({ type });
   }
   if (match.modifier) {
     if (!options?.modifiers?.has?.(match.modifier))
-      throw new InvalidModifierError({
+      throw new InvalidModifierError2({
         param,
         type: options?.type,
         modifier: match.modifier
       });
-    if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
-      throw new InvalidFunctionModifierError({
+    if (functionModifiers2.has(match.modifier) && !isValidDataLocation2(type, !!match.array))
+      throw new InvalidFunctionModifierError2({
         param,
         type: options?.type,
         modifier: match.modifier
@@ -33502,69 +34240,69 @@ function parseAbiParameter(param, options) {
     ...indexed,
     ...components
   };
-  parameterCache.set(parameterCacheKey, abiParameter);
+  parameterCache2.set(parameterCacheKey, abiParameter);
   return abiParameter;
 }
-function splitParameters(params, result = [], current = "", depth = 0) {
+function splitParameters2(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);
+        return depth === 0 ? splitParameters2(tail, [...result, current.trim()]) : splitParameters2(tail, result, `${current}${char}`, depth);
       case "(":
-        return splitParameters(tail, result, `${current}${char}`, depth + 1);
+        return splitParameters2(tail, result, `${current}${char}`, depth + 1);
       case ")":
-        return splitParameters(tail, result, `${current}${char}`, depth - 1);
+        return splitParameters2(tail, result, `${current}${char}`, depth - 1);
       default:
-        return splitParameters(tail, result, `${current}${char}`, depth);
+        return splitParameters2(tail, result, `${current}${char}`, depth);
     }
   }
   if (current === "")
     return result;
   if (depth !== 0)
-    throw new InvalidParenthesisError({ current, depth });
+    throw new InvalidParenthesisError2({ current, depth });
   result.push(current.trim());
   return result;
 }
-function isSolidityType(type) {
-  return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex2.test(type) || integerRegex2.test(type);
+function isSolidityType2(type) {
+  return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex3.test(type) || integerRegex3.test(type);
 }
-function isSolidityKeyword(name) {
-  return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex2.test(name) || integerRegex2.test(name) || protectedKeywordsRegex.test(name);
+function isSolidityKeyword2(name) {
+  return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex3.test(name) || integerRegex3.test(name) || protectedKeywordsRegex2.test(name);
 }
-function isValidDataLocation(type, isArray) {
+function isValidDataLocation2(type, isArray) {
   return isArray || type === "bytes" || type === "string" || type === "tuple";
 }
-var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
-var init_utils3 = __esm({
+var abiParameterWithoutTupleRegex2, abiParameterWithTupleRegex2, dynamicIntegerRegex2, protectedKeywordsRegex2;
+var init_utils4 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
     init_regex3();
-    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)$/;
+    init_abiItem2();
+    init_abiParameter2();
+    init_signature2();
+    init_splitParameters2();
+    init_cache2();
+    init_signatures2();
+    abiParameterWithoutTupleRegex2 = /^(?<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$_]*))?$/;
+    abiParameterWithTupleRegex2 = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+    dynamicIntegerRegex2 = /^u?int$/;
+    protectedKeywordsRegex2 = /^(?: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/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/runtime/structs.js
-function parseStructs(signatures) {
+function parseStructs2(signatures) {
   const shallowStructs = {};
   const signaturesLength = signatures.length;
   for (let i = 0; i < signaturesLength; i++) {
     const signature = signatures[i];
-    if (!isStructSignature(signature))
+    if (!isStructSignature2(signature))
       continue;
-    const match = execStructSignature(signature);
+    const match = execStructSignature2(signature);
     if (!match)
-      throw new InvalidSignatureError({ signature, type: "struct" });
+      throw new InvalidSignatureError2({ signature, type: "struct" });
     const properties = match.properties.split(";");
     const components = [];
     const propertiesLength = properties.length;
@@ -33573,13 +34311,13 @@ function parseStructs(signatures) {
       const trimmed = property.trim();
       if (!trimmed)
         continue;
-      const abiParameter = parseAbiParameter(trimmed, {
+      const abiParameter = parseAbiParameter3(trimmed, {
         type: "struct"
       });
       components.push(abiParameter);
     }
     if (!components.length)
-      throw new InvalidStructSignatureError({ signature });
+      throw new InvalidStructSignatureError2({ signature });
     shallowStructs[match.name] = components;
   }
   const resolvedStructs = {};
@@ -33587,139 +34325,139 @@ function parseStructs(signatures) {
   const entriesLength = entries.length;
   for (let i = 0; i < entriesLength; i++) {
     const [name, parameters] = entries[i];
-    resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
+    resolvedStructs[name] = resolveStructs2(parameters, shallowStructs);
   }
   return resolvedStructs;
 }
-function resolveStructs(abiParameters = [], structs = {}, ancestors = /* @__PURE__ */ new Set()) {
+function resolveStructs2(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);
+    const isTuple = isTupleRegex2.test(abiParameter.type);
     if (isTuple)
       components.push(abiParameter);
     else {
-      const match = execTyped2(typeWithoutTupleRegex, abiParameter.type);
+      const match = execTyped2(typeWithoutTupleRegex2, abiParameter.type);
       if (!match?.type)
-        throw new InvalidAbiTypeParameterError({ abiParameter });
+        throw new InvalidAbiTypeParameterError2({ abiParameter });
       const { array, type } = match;
       if (type in structs) {
         if (ancestors.has(type))
-          throw new CircularReferenceError({ type });
+          throw new CircularReferenceError2({ type });
         components.push({
           ...abiParameter,
           type: `tuple${array ?? ""}`,
-          components: resolveStructs(structs[type], structs, /* @__PURE__ */ new Set([...ancestors, type]))
+          components: resolveStructs2(structs[type], structs, /* @__PURE__ */ new Set([...ancestors, type]))
         });
       } else {
-        if (isSolidityType(type))
+        if (isSolidityType2(type))
           components.push(abiParameter);
         else
-          throw new UnknownTypeError({ type });
+          throw new UnknownTypeError2({ type });
       }
     }
   }
   return components;
 }
-var typeWithoutTupleRegex;
-var init_structs = __esm({
+var typeWithoutTupleRegex2;
+var init_structs2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
     init_regex3();
-    init_abiItem();
-    init_abiParameter();
-    init_signature();
-    init_struct();
-    init_signatures();
-    init_utils3();
-    typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
+    init_abiItem2();
+    init_abiParameter2();
+    init_signature2();
+    init_struct2();
+    init_signatures2();
+    init_utils4();
+    typeWithoutTupleRegex2 = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
   }
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/parseAbi.js
-function parseAbi(signatures) {
-  const structs = parseStructs(signatures);
+function parseAbi2(signatures) {
+  const structs = parseStructs2(signatures);
   const abi2 = [];
   const length = signatures.length;
   for (let i = 0; i < length; i++) {
     const signature = signatures[i];
-    if (isStructSignature(signature))
+    if (isStructSignature2(signature))
       continue;
-    abi2.push(parseSignature(signature, structs));
+    abi2.push(parseSignature2(signature, structs));
   }
   return abi2;
 }
-var init_parseAbi = __esm({
+var init_parseAbi2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
-    init_signatures();
-    init_structs();
-    init_utils3();
+    init_signatures2();
+    init_structs2();
+    init_utils4();
   }
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js
-function parseAbiItem(signature) {
+function parseAbiItem2(signature) {
   let abiItem;
   if (typeof signature === "string")
-    abiItem = parseSignature(signature);
+    abiItem = parseSignature2(signature);
   else {
-    const structs = parseStructs(signature);
+    const structs = parseStructs2(signature);
     const length = signature.length;
     for (let i = 0; i < length; i++) {
       const signature_ = signature[i];
-      if (isStructSignature(signature_))
+      if (isStructSignature2(signature_))
         continue;
-      abiItem = parseSignature(signature_, structs);
+      abiItem = parseSignature2(signature_, structs);
       break;
     }
   }
   if (!abiItem)
-    throw new InvalidAbiItemError({ signature });
+    throw new InvalidAbiItemError2({ signature });
   return abiItem;
 }
 var init_parseAbiItem = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/parseAbiItem.js"() {
-    init_abiItem();
-    init_signatures();
-    init_structs();
-    init_utils3();
+    init_abiItem2();
+    init_signatures2();
+    init_structs2();
+    init_utils4();
   }
 });
 
 // ../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js
-function parseAbiParameters(params) {
+function parseAbiParameters2(params) {
   const abiParameters = [];
   if (typeof params === "string") {
-    const parameters = splitParameters(params);
+    const parameters = splitParameters2(params);
     const length = parameters.length;
     for (let i = 0; i < length; i++) {
-      abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));
+      abiParameters.push(parseAbiParameter3(parameters[i], { modifiers }));
     }
   } else {
-    const structs = parseStructs(params);
+    const structs = parseStructs2(params);
     const length = params.length;
     for (let i = 0; i < length; i++) {
       const signature = params[i];
-      if (isStructSignature(signature))
+      if (isStructSignature2(signature))
         continue;
-      const parameters = splitParameters(signature);
+      const parameters = splitParameters2(signature);
       const length2 = parameters.length;
       for (let k = 0; k < length2; k++) {
-        abiParameters.push(parseAbiParameter(parameters[k], { modifiers, structs }));
+        abiParameters.push(parseAbiParameter3(parameters[k], { modifiers, structs }));
       }
     }
   }
   if (abiParameters.length === 0)
-    throw new InvalidAbiParametersError({ params });
+    throw new InvalidAbiParametersError2({ params });
   return abiParameters;
 }
 var init_parseAbiParameters = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/human-readable/parseAbiParameters.js"() {
-    init_abiParameter();
-    init_signatures();
-    init_structs();
-    init_utils3();
-    init_utils3();
+    init_abiParameter2();
+    init_signatures2();
+    init_structs2();
+    init_utils4();
+    init_utils4();
   }
 });
 
@@ -33728,7 +34466,7 @@ var init_exports2 = __esm({
   "../../node_modules/.pnpm/abitype@1.2.3_typescript@5.9.3_zod@3.25.76/node_modules/abitype/dist/esm/exports/index.js"() {
     init_formatAbiItem3();
     init_formatAbiParameters2();
-    init_parseAbi();
+    init_parseAbi2();
     init_parseAbiItem();
     init_parseAbiParameters();
   }
@@ -33783,10 +34521,10 @@ var init_size2 = __esm({
 });
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/version.js
-var version3;
-var init_version3 = __esm({
+var version4;
+var init_version4 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/version.js"() {
-    version3 = "2.51.3";
+    version4 = "2.51.3";
   }
 });
 
@@ -33798,15 +34536,15 @@ function walk2(err, fn) {
     return walk2(err.cause, fn);
   return fn ? null : err;
 }
-var errorConfig2, BaseError3;
+var errorConfig2, BaseError4;
 var init_base2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/base.js"() {
-    init_version3();
+    init_version4();
     errorConfig2 = {
       getDocsUrl: ({ docsBaseUrl, docsPath: docsPath9 = "", docsSlug }) => docsPath9 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath9}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
-      version: `viem@${version3}`
+      version: `viem@${version4}`
     };
-    BaseError3 = class _BaseError extends Error {
+    BaseError4 = class _BaseError extends Error {
       constructor(shortMessage, args = {}) {
         const details = (() => {
           if (args.cause instanceof _BaseError)
@@ -33871,7 +34609,7 @@ var init_base2 = __esm({
         this.metaMessages = args.metaMessages;
         this.name = args.name ?? this.name;
         this.shortMessage = shortMessage;
-        this.version = version3;
+        this.version = version4;
       }
       walk(fn) {
         return walk2(this, fn);
@@ -33887,7 +34625,7 @@ var init_abi2 = __esm({
     init_formatAbiItem4();
     init_size2();
     init_base2();
-    AbiConstructorNotFoundError = class extends BaseError3 {
+    AbiConstructorNotFoundError = class extends BaseError4 {
       constructor({ docsPath: docsPath9 }) {
         super([
           "A constructor was not found on the ABI.",
@@ -33898,7 +34636,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiConstructorParamsNotFoundError = class extends BaseError3 {
+    AbiConstructorParamsNotFoundError = class extends BaseError4 {
       constructor({ docsPath: docsPath9 }) {
         super([
           "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
@@ -33909,7 +34647,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiDecodingDataSizeTooSmallError = class extends BaseError3 {
+    AbiDecodingDataSizeTooSmallError = class extends BaseError4 {
       constructor({ data, params, size: size6 }) {
         super([`Data size of ${size6} bytes is too small for given parameters.`].join("\n"), {
           metaMessages: [
@@ -33941,7 +34679,7 @@ var init_abi2 = __esm({
         this.size = size6;
       }
     };
-    AbiDecodingZeroDataError = class extends BaseError3 {
+    AbiDecodingZeroDataError = class extends BaseError4 {
       constructor({ cause } = {}) {
         super('Cannot decode zero data ("0x") with ABI parameters.', {
           name: "AbiDecodingZeroDataError",
@@ -33949,7 +34687,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiEncodingArrayLengthMismatchError2 = class extends BaseError3 {
+    AbiEncodingArrayLengthMismatchError2 = class extends BaseError4 {
       constructor({ expectedLength, givenLength, type }) {
         super([
           `ABI encoding array length mismatch for type ${type}.`,
@@ -33958,12 +34696,12 @@ var init_abi2 = __esm({
         ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
       }
     };
-    AbiEncodingBytesSizeMismatchError2 = class extends BaseError3 {
+    AbiEncodingBytesSizeMismatchError2 = class extends BaseError4 {
       constructor({ expectedSize, value }) {
         super(`Size of bytes "${value}" (bytes${size2(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
       }
     };
-    AbiEncodingLengthMismatchError2 = class extends BaseError3 {
+    AbiEncodingLengthMismatchError2 = class extends BaseError4 {
       constructor({ expectedLength, givenLength }) {
         super([
           "ABI encoding params/values length mismatch.",
@@ -33972,7 +34710,7 @@ var init_abi2 = __esm({
         ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
       }
     };
-    AbiErrorInputsNotFoundError = class extends BaseError3 {
+    AbiErrorInputsNotFoundError = class extends BaseError4 {
       constructor(errorName, { docsPath: docsPath9 }) {
         super([
           `Arguments (\`args\`) were provided to "${errorName}", but "${errorName}" on the ABI does not contain any parameters (\`inputs\`).`,
@@ -33984,7 +34722,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiErrorNotFoundError = class extends BaseError3 {
+    AbiErrorNotFoundError = class extends BaseError4 {
       constructor(errorName, { docsPath: docsPath9 } = {}) {
         super([
           `Error ${errorName ? `"${errorName}" ` : ""}not found on ABI.`,
@@ -33995,7 +34733,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiErrorSignatureNotFoundError = class extends BaseError3 {
+    AbiErrorSignatureNotFoundError = class extends BaseError4 {
       constructor(signature, { docsPath: docsPath9, cause }) {
         super([
           `Encoded error signature "${signature}" not found on ABI.`,
@@ -34015,7 +34753,7 @@ var init_abi2 = __esm({
         this.signature = signature;
       }
     };
-    AbiEventSignatureEmptyTopicsError = class extends BaseError3 {
+    AbiEventSignatureEmptyTopicsError = class extends BaseError4 {
       constructor({ docsPath: docsPath9 }) {
         super("Cannot extract event signature from empty topics.", {
           docsPath: docsPath9,
@@ -34023,7 +34761,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiEventSignatureNotFoundError = class extends BaseError3 {
+    AbiEventSignatureNotFoundError = class extends BaseError4 {
       constructor(signature, { docsPath: docsPath9 }) {
         super([
           `Encoded event signature "${signature}" not found on ABI.`,
@@ -34035,7 +34773,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiEventNotFoundError = class extends BaseError3 {
+    AbiEventNotFoundError = class extends BaseError4 {
       constructor(eventName, { docsPath: docsPath9 } = {}) {
         super([
           `Event ${eventName ? `"${eventName}" ` : ""}not found on ABI.`,
@@ -34046,7 +34784,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiFunctionNotFoundError2 = class extends BaseError3 {
+    AbiFunctionNotFoundError2 = class extends BaseError4 {
       constructor(functionName, { docsPath: docsPath9 } = {}) {
         super([
           `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
@@ -34057,7 +34795,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiFunctionOutputsNotFoundError = class extends BaseError3 {
+    AbiFunctionOutputsNotFoundError = class extends BaseError4 {
       constructor(functionName, { docsPath: docsPath9 }) {
         super([
           `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
@@ -34069,7 +34807,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiFunctionSignatureNotFoundError = class extends BaseError3 {
+    AbiFunctionSignatureNotFoundError = class extends BaseError4 {
       constructor(signature, { docsPath: docsPath9 }) {
         super([
           `Encoded function signature "${signature}" not found on ABI.`,
@@ -34081,7 +34819,7 @@ var init_abi2 = __esm({
         });
       }
     };
-    AbiItemAmbiguityError2 = class extends BaseError3 {
+    AbiItemAmbiguityError2 = class extends BaseError4 {
       constructor(x, y) {
         super("Found ambiguous types in overloaded ABI items.", {
           metaMessages: [
@@ -34095,14 +34833,14 @@ var init_abi2 = __esm({
         });
       }
     };
-    BytesSizeMismatchError2 = class extends BaseError3 {
+    BytesSizeMismatchError2 = class extends BaseError4 {
       constructor({ expectedSize, givenSize }) {
         super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
           name: "BytesSizeMismatchError"
         });
       }
     };
-    DecodeLogDataMismatch = class extends BaseError3 {
+    DecodeLogDataMismatch = class extends BaseError4 {
       constructor({ abiItem, data, params, size: size6 }) {
         super([
           `Data size of ${size6} bytes is too small for non-indexed event parameters.`
@@ -34143,7 +34881,7 @@ var init_abi2 = __esm({
         this.size = size6;
       }
     };
-    DecodeLogTopicsMismatch = class extends BaseError3 {
+    DecodeLogTopicsMismatch = class extends BaseError4 {
       constructor({ abiItem, param }) {
         super([
           `Expected a topic for indexed event parameter${param.name ? ` "${param.name}"` : ""} on event "${formatAbiItem4(abiItem, { includeName: true })}".`
@@ -34157,7 +34895,7 @@ var init_abi2 = __esm({
         this.abiItem = abiItem;
       }
     };
-    InvalidAbiEncodingTypeError2 = class extends BaseError3 {
+    InvalidAbiEncodingTypeError2 = class extends BaseError4 {
       constructor(type, { docsPath: docsPath9 }) {
         super([
           `Type "${type}" is not a valid encoding type.`,
@@ -34165,7 +34903,7 @@ var init_abi2 = __esm({
         ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiEncodingType" });
       }
     };
-    InvalidAbiDecodingTypeError = class extends BaseError3 {
+    InvalidAbiDecodingTypeError = class extends BaseError4 {
       constructor(type, { docsPath: docsPath9 }) {
         super([
           `Type "${type}" is not a valid decoding type.`,
@@ -34173,14 +34911,14 @@ var init_abi2 = __esm({
         ].join("\n"), { docsPath: docsPath9, name: "InvalidAbiDecodingType" });
       }
     };
-    InvalidArrayError2 = class extends BaseError3 {
+    InvalidArrayError2 = class extends BaseError4 {
       constructor(value) {
         super([`Value "${value}" is not a valid array.`].join("\n"), {
           name: "InvalidArrayError"
         });
       }
     };
-    InvalidDefinitionTypeError2 = class extends BaseError3 {
+    InvalidDefinitionTypeError2 = class extends BaseError4 {
       constructor(type) {
         super([
           `"${type}" is not a valid definition type.`,
@@ -34196,17 +34934,17 @@ var SliceOffsetOutOfBoundsError2, SizeExceedsPaddingSizeError2, InvalidBytesLeng
 var init_data2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/data.js"() {
     init_base2();
-    SliceOffsetOutOfBoundsError2 = class extends BaseError3 {
+    SliceOffsetOutOfBoundsError2 = class extends BaseError4 {
       constructor({ offset, position, size: size6 }) {
         super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size6}).`, { name: "SliceOffsetOutOfBoundsError" });
       }
     };
-    SizeExceedsPaddingSizeError2 = class extends BaseError3 {
+    SizeExceedsPaddingSizeError2 = class extends BaseError4 {
       constructor({ size: size6, targetSize, type }) {
         super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size6}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
       }
     };
-    InvalidBytesLengthError = class extends BaseError3 {
+    InvalidBytesLengthError = class extends BaseError4 {
       constructor({ size: size6, targetSize, type }) {
         super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size6} ${type} long.`, { name: "InvalidBytesLengthError" });
       }
@@ -34259,24 +34997,24 @@ var IntegerOutOfRangeError2, InvalidBytesBooleanError, InvalidHexBooleanError2,
 var init_encoding2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/encoding.js"() {
     init_base2();
-    IntegerOutOfRangeError2 = class extends BaseError3 {
+    IntegerOutOfRangeError2 = class extends BaseError4 {
       constructor({ max, min, signed, size: size6, value }) {
         super(`Number "${value}" is not in safe ${size6 ? `${size6 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
       }
     };
-    InvalidBytesBooleanError = class extends BaseError3 {
+    InvalidBytesBooleanError = class extends BaseError4 {
       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"
         });
       }
     };
-    InvalidHexBooleanError2 = class extends BaseError3 {
+    InvalidHexBooleanError2 = class extends BaseError4 {
       constructor(hex) {
         super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
       }
     };
-    SizeOverflowError2 = class extends BaseError3 {
+    SizeOverflowError2 = class extends BaseError4 {
       constructor({ givenSize, maxSize }) {
         super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
       }
@@ -34478,7 +35216,7 @@ function hexToBytes4(hex_, opts = {}) {
     const nibbleLeft = charCodeToBase162(hexString.charCodeAt(j++));
     const nibbleRight = charCodeToBase162(hexString.charCodeAt(j++));
     if (nibbleLeft === void 0 || nibbleRight === void 0) {
-      throw new BaseError3(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+      throw new BaseError4(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
     }
     bytes[index2] = nibbleLeft * 16 + nibbleRight;
   }
@@ -34586,7 +35324,7 @@ function normalizeSignature2(signature) {
     current += char;
   }
   if (!valid)
-    throw new BaseError3("Unable to normalize signature.");
+    throw new BaseError4("Unable to normalize signature.");
   return result;
 }
 var init_normalizeSignature2 = __esm({
@@ -34637,7 +35375,7 @@ var InvalidAddressError2;
 var init_address3 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/address.js"() {
     init_base2();
-    InvalidAddressError2 = class extends BaseError3 {
+    InvalidAddressError2 = class extends BaseError4 {
       constructor({ address }) {
         super(`Address "${address}" is invalid.`, {
           metaMessages: [
@@ -34830,11 +35568,11 @@ var init_slice2 = __esm({
 });
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/regex.js
-var bytesRegex3, integerRegex3;
+var bytesRegex4, integerRegex4;
 var init_regex4 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/regex.js"() {
-    bytesRegex3 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
-    integerRegex3 = /^(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)?$/;
+    bytesRegex4 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+    integerRegex4 = /^(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)?$/;
   }
 });
 
@@ -34880,7 +35618,7 @@ function prepareParam2({ param, value }) {
   }
   if (param.type.startsWith("uint") || param.type.startsWith("int")) {
     const signed = param.type.startsWith("int");
-    const [, , size6 = "256"] = integerRegex3.exec(param.type) ?? [];
+    const [, , size6 = "256"] = integerRegex4.exec(param.type) ?? [];
     return encodeNumber2(value, {
       signed,
       size: Number(size6)
@@ -34984,7 +35722,7 @@ function encodeBytes2(value, { param }) {
 }
 function encodeBool2(value) {
   if (typeof value !== "boolean")
-    throw new BaseError3(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+    throw new BaseError4(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
   return { dynamic: false, encoded: padHex2(boolToHex2(value)) };
 }
 function encodeNumber2(value, { signed, size: size6 = 256 }) {
@@ -35305,19 +36043,19 @@ var NegativeOffsetError2, PositionOutOfBoundsError2, RecursiveReadLimitExceededE
 var init_cursor3 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/cursor.js"() {
     init_base2();
-    NegativeOffsetError2 = class extends BaseError3 {
+    NegativeOffsetError2 = class extends BaseError4 {
       constructor({ offset }) {
         super(`Offset \`${offset}\` cannot be negative.`, {
           name: "NegativeOffsetError"
         });
       }
     };
-    PositionOutOfBoundsError2 = class extends BaseError3 {
+    PositionOutOfBoundsError2 = class extends BaseError4 {
       constructor({ length, position }) {
         super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
       }
     };
-    RecursiveReadLimitExceededError2 = class extends BaseError3 {
+    RecursiveReadLimitExceededError2 = class extends BaseError4 {
       constructor({ count, limit }) {
         super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
       }
@@ -35890,14 +36628,14 @@ var AccountStateConflictError, StateAssignmentConflictError;
 var init_stateOverride = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/stateOverride.js"() {
     init_base2();
-    AccountStateConflictError = class extends BaseError3 {
+    AccountStateConflictError = class extends BaseError4 {
       constructor({ address }) {
         super(`State for account "${address}" is set multiple times.`, {
           name: "AccountStateConflictError"
         });
       }
     };
-    StateAssignmentConflictError = class extends BaseError3 {
+    StateAssignmentConflictError = class extends BaseError4 {
       constructor() {
         super("state and stateDiff are set on the same account.", {
           name: "StateAssignmentConflictError"
@@ -35923,14 +36661,14 @@ var init_transaction2 = __esm({
     init_formatEther();
     init_formatGwei2();
     init_base2();
-    InvalidLegacyVError2 = class extends BaseError3 {
+    InvalidLegacyVError2 = class extends BaseError4 {
       constructor({ v }) {
         super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
           name: "InvalidLegacyVError"
         });
       }
     };
-    InvalidSerializableTransactionError2 = class extends BaseError3 {
+    InvalidSerializableTransactionError2 = class extends BaseError4 {
       constructor({ transaction }) {
         super("Cannot infer a transaction type from provided transaction.", {
           metaMessages: [
@@ -35951,12 +36689,12 @@ var init_transaction2 = __esm({
         });
       }
     };
-    InvalidStorageKeySizeError2 = class extends BaseError3 {
+    InvalidStorageKeySizeError2 = class extends BaseError4 {
       constructor({ storageKey }) {
         super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: "InvalidStorageKeySizeError" });
       }
     };
-    TransactionExecutionError = class extends BaseError3 {
+    TransactionExecutionError = class extends BaseError4 {
       constructor(cause, { account, docsPath: docsPath9, chain: chain2, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
         const prettyArgs = prettyPrint2({
           chain: chain2 && `${chain2?.name} (id: ${chain2?.id})`,
@@ -35989,7 +36727,7 @@ var init_transaction2 = __esm({
         this.cause = cause;
       }
     };
-    TransactionNotFoundError = class extends BaseError3 {
+    TransactionNotFoundError = class extends BaseError4 {
       constructor({ blockHash, blockNumber, blockTag, hash: hash4, index: index2 }) {
         let identifier = "Transaction";
         if (blockTag && index2 !== void 0)
@@ -36005,14 +36743,14 @@ var init_transaction2 = __esm({
         });
       }
     };
-    TransactionReceiptNotFoundError = class extends BaseError3 {
+    TransactionReceiptNotFoundError = class extends BaseError4 {
       constructor({ hash: hash4 }) {
         super(`Transaction receipt with hash "${hash4}" could not be found. The Transaction may not be processed on a block yet.`, {
           name: "TransactionReceiptNotFoundError"
         });
       }
     };
-    TransactionReceiptRevertedError = class extends BaseError3 {
+    TransactionReceiptRevertedError = class extends BaseError4 {
       constructor({ receipt }) {
         super(`Transaction with hash "${receipt.transactionHash}" reverted.`, {
           metaMessages: [
@@ -36033,7 +36771,7 @@ var init_transaction2 = __esm({
         this.receipt = receipt;
       }
     };
-    WaitForTransactionReceiptTimeoutError = class extends BaseError3 {
+    WaitForTransactionReceiptTimeoutError = class extends BaseError4 {
       constructor({ hash: hash4 }) {
         super(`Timed out while waiting for transaction with hash "${hash4}" to be confirmed.`, { name: "WaitForTransactionReceiptTimeoutError" });
       }
@@ -36055,7 +36793,7 @@ function isAbortError(error) {
   return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
 }
 var getContractAddress, getUrl;
-var init_utils4 = __esm({
+var init_utils5 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/utils.js"() {
     getContractAddress = (address) => address;
     getUrl = (url) => {
@@ -36089,8 +36827,8 @@ var init_contract = __esm({
     init_base2();
     init_stateOverride();
     init_transaction2();
-    init_utils4();
-    CallExecutionError = class extends BaseError3 {
+    init_utils5();
+    CallExecutionError = class extends BaseError4 {
       constructor(cause, { account: account_, docsPath: docsPath9, chain: chain2, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
         const account = account_ ? parseAccount(account_) : void 0;
         let prettyArgs = prettyPrint2({
@@ -36127,7 +36865,7 @@ ${prettyStateOverride(stateOverride)}`;
         this.cause = cause;
       }
     };
-    ContractFunctionExecutionError = class extends BaseError3 {
+    ContractFunctionExecutionError = class extends BaseError4 {
       constructor(cause, { abi: abi2, args, contractAddress, docsPath: docsPath9, functionName, sender }) {
         const abiItem = getAbiItem2({ abi: abi2, args, name: functionName });
         const formattedArgs = abiItem ? formatAbiItemWithArgs({
@@ -36203,7 +36941,7 @@ ${prettyStateOverride(stateOverride)}`;
         this.sender = sender;
       }
     };
-    ContractFunctionRevertedError = class extends BaseError3 {
+    ContractFunctionRevertedError = class extends BaseError4 {
       constructor({ abi: abi2, data, functionName, message, cause: error }) {
         let cause;
         let decodedData;
@@ -36283,7 +37021,7 @@ ${prettyStateOverride(stateOverride)}`;
         this.signature = signature;
       }
     };
-    ContractFunctionZeroDataError = class extends BaseError3 {
+    ContractFunctionZeroDataError = class extends BaseError4 {
       constructor({ functionName, cause }) {
         super(`The contract function "${functionName}" returned no data ("0x").`, {
           metaMessages: [
@@ -36297,7 +37035,7 @@ ${prettyStateOverride(stateOverride)}`;
         });
       }
     };
-    CounterfactualDeploymentFailedError = class extends BaseError3 {
+    CounterfactualDeploymentFailedError = class extends BaseError4 {
       constructor({ factory }) {
         super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
           metaMessages: [
@@ -36309,7 +37047,7 @@ ${prettyStateOverride(stateOverride)}`;
         });
       }
     };
-    RawContractError = class extends BaseError3 {
+    RawContractError = class extends BaseError4 {
       constructor({ data, message }) {
         super(message || "", { name: "RawContractError" });
         Object.defineProperty(this, "code", {
@@ -36336,8 +37074,8 @@ var init_request = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/request.js"() {
     init_stringify2();
     init_base2();
-    init_utils4();
-    HttpRequestError = class extends BaseError3 {
+    init_utils5();
+    HttpRequestError = class extends BaseError4 {
       constructor({ body, cause, details, headers, status, url }) {
         super("HTTP request failed.", {
           cause,
@@ -36379,7 +37117,7 @@ var init_request = __esm({
         this.url = url;
       }
     };
-    RpcRequestError = class extends BaseError3 {
+    RpcRequestError = class extends BaseError4 {
       constructor({ body, error, url }) {
         super("RPC Request failed.", {
           cause: error,
@@ -36410,7 +37148,7 @@ var init_request = __esm({
         this.url = url;
       }
     };
-    TimeoutError = class extends BaseError3 {
+    TimeoutError = class extends BaseError4 {
       constructor({ body, url }) {
         super("The request took too long to respond.", {
           details: "The request timed out.",
@@ -36436,7 +37174,7 @@ var init_rpc = __esm({
     init_base2();
     init_request();
     unknownErrorCode = -1;
-    RpcError = class extends BaseError3 {
+    RpcError = class extends BaseError4 {
       constructor(cause, { code, docsPath: docsPath9, metaMessages, name, shortMessage }) {
         super(shortMessage, {
           cause,
@@ -36885,7 +37623,7 @@ var init_node2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/node.js"() {
     init_formatGwei2();
     init_base2();
-    ExecutionRevertedError2 = class extends BaseError3 {
+    ExecutionRevertedError2 = class extends BaseError4 {
       constructor({ cause, message } = {}) {
         const reason = message?.replace("execution reverted: ", "")?.replace("execution reverted", "");
         super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
@@ -36906,7 +37644,7 @@ var init_node2 = __esm({
       writable: true,
       value: /execution reverted|gas required exceeds allowance/
     });
-    FeeCapTooHighError2 = class extends BaseError3 {
+    FeeCapTooHighError2 = class extends BaseError4 {
       constructor({ cause, maxFeePerGas } = {}) {
         super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei2(maxFeePerGas)} gwei` : ""}) cannot be higher than the maximum allowed value (2^256-1).`, {
           cause,
@@ -36920,7 +37658,7 @@ var init_node2 = __esm({
       writable: true,
       value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
     });
-    FeeCapTooLowError2 = class extends BaseError3 {
+    FeeCapTooLowError2 = class extends BaseError4 {
       constructor({ cause, maxFeePerGas } = {}) {
         super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei2(maxFeePerGas)}` : ""} gwei) cannot be lower than the block base fee.`, {
           cause,
@@ -36934,7 +37672,7 @@ var init_node2 = __esm({
       writable: true,
       value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
     });
-    NonceTooHighError2 = class extends BaseError3 {
+    NonceTooHighError2 = class extends BaseError4 {
       constructor({ cause, nonce } = {}) {
         super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is higher than the next one expected.`, { cause, name: "NonceTooHighError" });
       }
@@ -36945,7 +37683,7 @@ var init_node2 = __esm({
       writable: true,
       value: /nonce too high/
     });
-    NonceTooLowError2 = class extends BaseError3 {
+    NonceTooLowError2 = class extends BaseError4 {
       constructor({ cause, nonce } = {}) {
         super([
           `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
@@ -36959,7 +37697,7 @@ var init_node2 = __esm({
       writable: true,
       value: /nonce too low|transaction already imported|already known/
     });
-    NonceMaxValueError2 = class extends BaseError3 {
+    NonceMaxValueError2 = class extends BaseError4 {
       constructor({ cause, nonce } = {}) {
         super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
       }
@@ -36970,7 +37708,7 @@ var init_node2 = __esm({
       writable: true,
       value: /nonce has max value/
     });
-    InsufficientFundsError2 = class extends BaseError3 {
+    InsufficientFundsError2 = class extends BaseError4 {
       constructor({ cause } = {}) {
         super([
           "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
@@ -36996,7 +37734,7 @@ var init_node2 = __esm({
       writable: true,
       value: /insufficient funds|exceeds transaction sender account balance/
     });
-    IntrinsicGasTooHighError2 = class extends BaseError3 {
+    IntrinsicGasTooHighError2 = class extends BaseError4 {
       constructor({ cause, gas } = {}) {
         super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction exceeds the limit allowed for the block.`, {
           cause,
@@ -37010,7 +37748,7 @@ var init_node2 = __esm({
       writable: true,
       value: /intrinsic gas too high|gas limit reached/
     });
-    IntrinsicGasTooLowError2 = class extends BaseError3 {
+    IntrinsicGasTooLowError2 = class extends BaseError4 {
       constructor({ cause, gas } = {}) {
         super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
           cause,
@@ -37024,7 +37762,7 @@ var init_node2 = __esm({
       writable: true,
       value: /intrinsic gas too low/
     });
-    TransactionTypeNotSupportedError2 = class extends BaseError3 {
+    TransactionTypeNotSupportedError2 = class extends BaseError4 {
       constructor({ cause }) {
         super("The transaction type is not supported for this chain.", {
           cause,
@@ -37038,7 +37776,7 @@ var init_node2 = __esm({
       writable: true,
       value: /transaction type not valid/
     });
-    TipAboveFeeCapError2 = class extends BaseError3 {
+    TipAboveFeeCapError2 = class extends BaseError4 {
       constructor({ cause, maxPriorityFeePerGas, maxFeePerGas } = {}) {
         super([
           `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas ? ` = ${formatGwei2(maxPriorityFeePerGas)} gwei` : ""}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei2(maxFeePerGas)} gwei` : ""}).`
@@ -37054,7 +37792,7 @@ var init_node2 = __esm({
       writable: true,
       value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
     });
-    UnknownNodeError = class extends BaseError3 {
+    UnknownNodeError = class extends BaseError4 {
       constructor({ cause }) {
         super(`An error occurred while executing: ${cause?.shortMessage}`, {
           cause,
@@ -37068,8 +37806,8 @@ var init_node2 = __esm({
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/errors/getNodeError.js
 function getNodeError(err, args) {
   const message = (err.details || "").toLowerCase();
-  const executionRevertedError = err instanceof BaseError3 ? err.walk((e) => e?.code === ExecutionRevertedError2.code) : err;
-  if (executionRevertedError instanceof BaseError3)
+  const executionRevertedError = err instanceof BaseError4 ? err.walk((e) => e?.code === ExecutionRevertedError2.code) : err;
+  if (executionRevertedError instanceof BaseError4)
     return new ExecutionRevertedError2({
       cause: err,
       message: executionRevertedError.details
@@ -37401,7 +38139,7 @@ var init_assertRequest = __esm({
 function formatBlockParameter(parameters) {
   const { blockHash, blockNumber, blockTag, requireCanonical } = parameters;
   if (requireCanonical !== void 0 && !blockHash)
-    throw new BaseError3("`requireCanonical` can only be provided when `blockHash` is set.");
+    throw new BaseError4("`requireCanonical` can only be provided when `blockHash` is set.");
   if (blockHash)
     return requireCanonical ? { blockHash, requireCanonical } : { blockHash };
   if (typeof blockNumber === "bigint")
@@ -37462,20 +38200,20 @@ var init_decodeFunctionResult = __esm({
 });
 
 // ../../node_modules/.pnpm/ox@0.14.25_typescript@5.9.3_zod@3.25.76/node_modules/ox/_esm/core/version.js
-var version4;
-var init_version4 = __esm({
+var version5;
+var init_version5 = __esm({
   "../../node_modules/.pnpm/ox@0.14.25_typescript@5.9.3_zod@3.25.76/node_modules/ox/_esm/core/version.js"() {
-    version4 = "0.1.1";
+    version5 = "0.1.1";
   }
 });
 
 // ../../node_modules/.pnpm/ox@0.14.25_typescript@5.9.3_zod@3.25.76/node_modules/ox/_esm/core/internal/errors.js
 function getVersion() {
-  return version4;
+  return version5;
 }
-var init_errors2 = __esm({
+var init_errors3 = __esm({
   "../../node_modules/.pnpm/ox@0.14.25_typescript@5.9.3_zod@3.25.76/node_modules/ox/_esm/core/internal/errors.js"() {
-    init_version4();
+    init_version5();
   }
 });
 
@@ -37487,11 +38225,11 @@ function walk3(err, fn) {
     return walk3(err.cause, fn);
   return fn ? null : err;
 }
-var BaseError4;
+var BaseError5;
 var init_Errors = __esm({
   "../../node_modules/.pnpm/ox@0.14.25_typescript@5.9.3_zod@3.25.76/node_modules/ox/_esm/core/Errors.js"() {
-    init_errors2();
-    BaseError4 = class _BaseError extends Error {
+    init_errors3();
+    BaseError5 = class _BaseError extends Error {
       static setStaticOptions(options) {
         _BaseError.prototype.docsOrigin = options.docsOrigin;
         _BaseError.prototype.showVersion = options.showVersion;
@@ -37519,7 +38257,7 @@ var init_Errors = __esm({
         const docsBaseUrl = options.docsOrigin ?? _BaseError.prototype.docsOrigin;
         const docs = `${docsBaseUrl}${docsPath9 ?? ""}`;
         const showVersion = Boolean(options.version ?? _BaseError.prototype.showVersion);
-        const version5 = options.version ?? _BaseError.prototype.version;
+        const version6 = options.version ?? _BaseError.prototype.version;
         const message = [
           shortMessage || "An error occurred.",
           ...options.metaMessages ? ["", ...options.metaMessages] : [],
@@ -37527,7 +38265,7 @@ var init_Errors = __esm({
             "",
             details ? `Details: ${details}` : void 0,
             docsPath9 ? `See: ${docs}` : void 0,
-            showVersion ? `Version: ${version5}` : void 0
+            showVersion ? `Version: ${version6}` : void 0
           ] : []
         ].filter((x) => typeof x === "string").join("\n");
         super(message, options.cause ? { cause: options.cause } : void 0);
@@ -37592,13 +38330,13 @@ var init_Errors = __esm({
         this.docsPath = docsPath9;
         this.shortMessage = shortMessage;
         this.showVersion = showVersion;
-        this.version = version5;
+        this.version = version6;
       }
       walk(fn) {
         return walk3(this, fn);
       }
     };
-    Object.defineProperty(BaseError4, "defaultStaticOptions", {
+    Object.defineProperty(BaseError5, "defaultStaticOptions", {
       enumerable: true,
       configurable: true,
       writable: true,
@@ -37609,7 +38347,7 @@ var init_Errors = __esm({
       }
     });
     (() => {
-      BaseError4.setStaticOptions(BaseError4.defaultStaticOptions);
+      BaseError5.setStaticOptions(BaseError5.defaultStaticOptions);
     })();
   }
 });
@@ -37810,7 +38548,7 @@ function fromHex(value, options = {}) {
     const nibbleLeft = charCodeToBase163(hexString.charCodeAt(j++));
     const nibbleRight = charCodeToBase163(hexString.charCodeAt(j++));
     if (nibbleLeft === void 0 || nibbleRight === void 0) {
-      throw new BaseError4(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+      throw new BaseError5(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
     }
     bytes[index2] = nibbleLeft << 4 | nibbleRight;
   }
@@ -37897,7 +38635,7 @@ var init_Bytes = __esm({
     init_Json();
     decoder = /* @__PURE__ */ new TextDecoder();
     encoder5 = /* @__PURE__ */ new TextEncoder();
-    InvalidBytesBooleanError2 = class extends BaseError4 {
+    InvalidBytesBooleanError2 = class extends BaseError5 {
       constructor(bytes) {
         super(`Bytes value \`${bytes}\` is not a valid boolean.`, {
           metaMessages: [
@@ -37912,7 +38650,7 @@ var init_Bytes = __esm({
         });
       }
     };
-    InvalidBytesTypeError = class extends BaseError4 {
+    InvalidBytesTypeError = class extends BaseError5 {
       constructor(value) {
         super(`Value \`${typeof value === "object" ? stringify3(value) : value}\` of type \`${typeof value}\` is an invalid Bytes value.`, {
           metaMessages: ["Bytes values must be of type `Bytes`."]
@@ -37925,7 +38663,7 @@ var init_Bytes = __esm({
         });
       }
     };
-    SizeOverflowError3 = class extends BaseError4 {
+    SizeOverflowError3 = class extends BaseError5 {
       constructor({ givenSize, maxSize }) {
         super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
         Object.defineProperty(this, "name", {
@@ -37936,7 +38674,7 @@ var init_Bytes = __esm({
         });
       }
     };
-    SliceOffsetOutOfBoundsError3 = class extends BaseError4 {
+    SliceOffsetOutOfBoundsError3 = class extends BaseError5 {
       constructor({ offset, position, size: size6 }) {
         super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size6}\`).`);
         Object.defineProperty(this, "name", {
@@ -37947,7 +38685,7 @@ var init_Bytes = __esm({
         });
       }
     };
-    SizeExceedsPaddingSizeError3 = class extends BaseError4 {
+    SizeExceedsPaddingSizeError3 = class extends BaseError5 {
       constructor({ size: size6, targetSize, type }) {
         super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size6}\`) exceeds padding size (\`${targetSize}\`).`);
         Object.defineProperty(this, "name", {
@@ -38093,7 +38831,7 @@ var init_Hex = __esm({
     init_Json();
     encoder6 = /* @__PURE__ */ new TextEncoder();
     hexes5 = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
-    IntegerOutOfRangeError3 = class extends BaseError4 {
+    IntegerOutOfRangeError3 = class extends BaseError5 {
       constructor({ max, min, signed, size: size6, value }) {
         super(`Number \`${value}\` is not in safe${size6 ? ` ${size6 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
         Object.defineProperty(this, "name", {
@@ -38104,7 +38842,7 @@ var init_Hex = __esm({
         });
       }
     };
-    InvalidHexTypeError = class extends BaseError4 {
+    InvalidHexTypeError = class extends BaseError5 {
       constructor(value) {
         super(`Value \`${typeof value === "object" ? stringify3(value) : value}\` of type \`${typeof value}\` is an invalid hex type.`, {
           metaMessages: ['Hex types must be represented as `"0x${string}"`.']
@@ -38117,7 +38855,7 @@ var init_Hex = __esm({
         });
       }
     };
-    InvalidHexValueError = class extends BaseError4 {
+    InvalidHexValueError = class extends BaseError5 {
       constructor(value) {
         super(`Value \`${value}\` is an invalid hex value.`, {
           metaMessages: [
@@ -38132,7 +38870,7 @@ var init_Hex = __esm({
         });
       }
     };
-    SizeOverflowError4 = class extends BaseError4 {
+    SizeOverflowError4 = class extends BaseError5 {
       constructor({ givenSize, maxSize }) {
         super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
         Object.defineProperty(this, "name", {
@@ -38143,7 +38881,7 @@ var init_Hex = __esm({
         });
       }
     };
-    SliceOffsetOutOfBoundsError4 = class extends BaseError4 {
+    SliceOffsetOutOfBoundsError4 = class extends BaseError5 {
       constructor({ offset, position, size: size6 }) {
         super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size6}\`).`);
         Object.defineProperty(this, "name", {
@@ -38154,7 +38892,7 @@ var init_Hex = __esm({
         });
       }
     };
-    SizeExceedsPaddingSizeError4 = class extends BaseError4 {
+    SizeExceedsPaddingSizeError4 = class extends BaseError5 {
       constructor({ size: size6, targetSize, type }) {
         super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size6}\`) exceeds padding size (\`${targetSize}\`).`);
         Object.defineProperty(this, "name", {
@@ -38601,7 +39339,7 @@ var ChainDoesNotSupportContract, ClientChainNotConfiguredError, InvalidChainIdEr
 var init_chain2 = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/chain.js"() {
     init_base2();
-    ChainDoesNotSupportContract = class extends BaseError3 {
+    ChainDoesNotSupportContract = class extends BaseError4 {
       constructor({ blockNumber, chain: chain2, contract }) {
         super(`Chain "${chain2.name}" does not support contract "${contract.name}".`, {
           metaMessages: [
@@ -38616,14 +39354,14 @@ var init_chain2 = __esm({
         });
       }
     };
-    ClientChainNotConfiguredError = class extends BaseError3 {
+    ClientChainNotConfiguredError = class extends BaseError4 {
       constructor() {
         super("No chain was provided to the Client.", {
           name: "ClientChainNotConfiguredError"
         });
       }
     };
-    InvalidChainIdError2 = class extends BaseError3 {
+    InvalidChainIdError2 = class extends BaseError4 {
       constructor({ chainId }) {
         super(typeof chainId === "number" ? `Chain ID "${chainId}" is invalid.` : "Chain ID is invalid.", { name: "InvalidChainIdError" });
       }
@@ -38775,8 +39513,8 @@ var init_ccip = __esm({
   "../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/ccip.js"() {
     init_stringify2();
     init_base2();
-    init_utils4();
-    OffchainLookupError = class extends BaseError3 {
+    init_utils5();
+    OffchainLookupError = class extends BaseError4 {
       constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
         super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
           cause,
@@ -38797,7 +39535,7 @@ var init_ccip = __esm({
         });
       }
     };
-    OffchainLookupResponseMalformedError = class extends BaseError3 {
+    OffchainLookupResponseMalformedError = class extends BaseError4 {
       constructor({ result, url }) {
         super("Offchain gateway response is malformed. Response data must be a hex value.", {
           metaMessages: [
@@ -38808,7 +39546,7 @@ var init_ccip = __esm({
         });
       }
     };
-    OffchainLookupSenderMismatchError = class extends BaseError3 {
+    OffchainLookupSenderMismatchError = class extends BaseError4 {
       constructor({ sender, to }) {
         super("Reverted sender address does not match target contract address (`to`).", {
           metaMessages: [
@@ -39071,7 +39809,7 @@ var init_ccip2 = __esm({
     init_call();
     init_ccip();
     init_request();
-    init_utils4();
+    init_utils5();
     init_decodeErrorResult();
     init_encodeAbiParameters2();
     init_isAddressEqual();
@@ -39114,9 +39852,9 @@ async function call(client, args) {
   const { account: account_ = client.account, authorizationList, batch = Boolean(client.batch?.multicall), blockHash, blockNumber, blockTag = client.experimental_blockTag ?? "latest", requireCanonical, accessList, blobs, blockOverrides, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, requestOptions, to, value, stateOverride, ...rest } = args;
   const account = account_ ? parseAccount(account_) : void 0;
   if (code && (factory || factoryData))
-    throw new BaseError3("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
+    throw new BaseError4("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
   if (code && to)
-    throw new BaseError3("Cannot provide both `code` & `to` as parameters.");
+    throw new BaseError4("Cannot provide both `code` & `to` as parameters.");
   const deploylessCallViaBytecode = code && data_;
   const deploylessCallViaFactory = factory && factoryData && to && data_;
   const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
@@ -39329,7 +40067,7 @@ function hasStateOverrideForAddress(rpcStateOverride, address) {
 function toDeploylessCallViaBytecodeData(parameters) {
   const { code, data } = parameters;
   return encodeDeployData({
-    abi: parseAbi(["constructor(bytes, bytes)"]),
+    abi: parseAbi2(["constructor(bytes, bytes)"]),
     bytecode: deploylessCallViaBytecodeBytecode,
     args: [code, data]
   });
@@ -39337,13 +40075,13 @@ function toDeploylessCallViaBytecodeData(parameters) {
 function toDeploylessCallViaFactoryData(parameters) {
   const { data, factory, factoryData, to } = parameters;
   return encodeDeployData({
-    abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
+    abi: parseAbi2(["constructor(address, bytes, address, bytes)"]),
     bytecode: deploylessCallViaFactoryBytecode,
     args: [to, data, factory, factoryData]
   });
 }
 function getRevertErrorData(err) {
-  if (!(err instanceof BaseError3))
+  if (!(err instanceof BaseError4))
     return void 0;
   const error = err.walk();
   return typeof error?.data === "object" ? error.data?.data : error.data;
@@ -39360,7 +40098,7 @@ var init_call = __esm({
     init_base2();
     init_chain2();
     init_contract();
-    init_utils4();
+    init_utils5();
     init_decodeFunctionResult();
     init_encodeDeployData();
     init_encodeFunctionData2();
@@ -39705,6 +40443,25 @@ var SailKernelAbi = [
   }
 ];
 
+// ../sdk/dist/capabilities.js
+init_esm();
+var DISPATCH_TYPE_STRINGS = {
+  conjunctive: "Dispatch(address account,address target,uint256 value,bytes32 dataHash,uint256 nonce,uint256 deadline)",
+  selective: "Dispatch(address account,address permission,address target,uint256 value,bytes32 dataHash,uint256 nonce,uint256 deadline)"
+};
+var REGISTER_PERMISSION_TYPE_STRINGS = {
+  noDeadline: "RegisterPermission(address account,address permission,uint256 nonce)",
+  withDeadline: "RegisterPermission(address account,address permission,uint256 nonce,uint256 deadline)"
+};
+var DISPATCH_TYPEHASHES = {
+  conjunctive: keccak256(toBytes(DISPATCH_TYPE_STRINGS.conjunctive)),
+  selective: keccak256(toBytes(DISPATCH_TYPE_STRINGS.selective))
+};
+var REGISTER_PERMISSION_TYPEHASHES = {
+  noDeadline: keccak256(toBytes(REGISTER_PERMISSION_TYPE_STRINGS.noDeadline)),
+  withDeadline: keccak256(toBytes(REGISTER_PERMISSION_TYPE_STRINGS.withDeadline))
+};
+
 // ../sdk/dist/deployments.js
 var CREATE2_KERNEL = "0x02ABC18B65A328de2e749F56ba79ACF2718a6659";
 var CREATE2_GOVERNANCE = "0x7A478118715791728BDE3bc7A4D7ECfdEB89C6EC";
@@ -39858,6 +40615,64 @@ function getSailDeployment(chainId) {
   return deployment;
 }
 
+// ../sdk/dist/errors.js
+init_esm();
+var KERNEL_ERROR_SIGNATURES = [
+  "error AccountAlreadyRegistered(address account)",
+  "error AccountNotRegistered(address account)",
+  "error AccountSelfTarget()",
+  "error ArrayLengthMismatch()",
+  "error BatchPermissionDenied()",
+  "error BatchSubcallFailed(uint256 index, address target)",
+  "error BatchTooLong(uint256 length)",
+  "error BatchZeroTarget(uint256 index)",
+  "error DeadlineExpired(uint256 deadline, uint256 current)",
+  "error DistributorBpsTooLarge(uint256 bps)",
+  "error EmptyBatch()",
+  "error FeePolicyNotSet()",
+  "error FeeTokenMismatch(address provided, address expected)",
+  "error FeeTooLarge(uint256 requested, uint256 maxAllowed)",
+  "error FeeTransferFailed()",
+  "error InsufficientFee(uint256 required, uint256 provided)",
+  "error InvalidInitializer()",
+  "error InvalidManagerSignature()",
+  "error InvalidSignerSignature()",
+  "error KernelSelfTarget(uint256 index)",
+  // SAIL-405: setManager rejects a no-op rotation (newManager == current).
+  "error ManagerUnchanged()",
+  "error ModuleNotEnabled()",
+  // Present in the deployed conjunctive kernel; dropped in the latest source.
+  "error NoPermissionsRegistered(address account)",
+  "error NotAContract(address addr)",
+  "error NotGovernance()",
+  "error NotManager(address caller, address expected)",
+  "error NotPermissionSigner()",
+  "error NotTimelock()",
+  "error PermissionAlreadyRegistered(address permission)",
+  "error PermissionDenied(address permission)",
+  "error PermissionNotBatchAware(address permission)",
+  "error PermissionNotRegistered(address permission)",
+  "error ProtocolPaused()",
+  "error SafeExecutionFailed()",
+  "error SessionInactive(address account)",
+  "error TooManyPermissions(address account, uint256 limit)",
+  "error UntrustedFactory(address factory)",
+  "error UntrustedFeePolicy(address policy)",
+  "error UntrustedModuleSetup(address setup)",
+  "error UntrustedProxyCodehash(bytes32 codehash)",
+  "error UntrustedSingleton(address singleton)",
+  "error ZeroAddress()",
+  "error ZeroFee()"
+];
+var KERNEL_ERROR_ABI = parseAbi(KERNEL_ERROR_SIGNATURES);
+
+// ../sdk/dist/lifi.js
+init_esm();
+var ERC20_ABI = parseAbi([
+  "function approve(address spender, uint256 amount)",
+  "function allowance(address owner, address spender) view returns (uint256)"
+]);
+
 // ../sdk/dist/keyring.js
 var import_node_crypto = require("node:crypto");
 var import_node_fs = require("node:fs");
@@ -39869,7 +40684,7 @@ init_secp256k1();
 init_hmac();
 init_legacy();
 init_sha2();
-init_utils();
+init_utils2();
 
 // ../../node_modules/.pnpm/@scure+base@1.2.6/node_modules/@scure/base/lib/esm/index.js
 function isBytes3(a) {
@@ -40128,7 +40943,7 @@ var HDKey = class _HDKey {
   static fromExtendedKey(base58key, versions = BITCOIN_VERSIONS) {
     const keyBuffer = base58check.decode(base58key);
     const keyView = createView(keyBuffer);
-    const version5 = keyView.getUint32(0, false);
+    const version6 = keyView.getUint32(0, false);
     const opt = {
       versions,
       depth: keyBuffer[4],
@@ -40138,7 +40953,7 @@ var HDKey = class _HDKey {
     };
     const key = keyBuffer.slice(45);
     const isPriv = key[0] === 0;
-    if (version5 !== versions[isPriv ? "private" : "public"]) {
+    if (version6 !== versions[isPriv ? "private" : "public"]) {
       throw new Error("Version mismatch");
     }
     if (isPriv) {
@@ -40291,18 +41106,18 @@ var HDKey = class _HDKey {
       xpub: this.publicExtendedKey
     };
   }
-  serialize(version5, key) {
+  serialize(version6, key) {
     if (!this.chainCode) {
       throw new Error("No chainCode set");
     }
     abytes(key, 33);
-    return concatBytes(toU32(version5), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key);
+    return concatBytes(toU32(version6), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key);
   }
 };
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/pbkdf2.js
 init_hmac();
-init_utils();
+init_utils2();
 function pbkdf2Init(hash4, _password, _salt, _opts) {
   ahash(hash4);
   const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
@@ -40762,7 +41577,7 @@ init_abi2();
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/log.js
 init_base2();
-var FilterTypeNotSupportedError = class extends BaseError3 {
+var FilterTypeNotSupportedError = class extends BaseError4 {
   constructor(type) {
     super(`Filter type "${type}" is not supported.`, {
       name: "FilterTypeNotSupportedError"
@@ -40874,7 +41689,7 @@ init_request();
 init_rpc();
 var EXECUTION_REVERTED_ERROR_CODE = 3;
 function getContractError(err, { abi: abi2, address, args, docsPath: docsPath9, functionName, sender }) {
-  const error = err instanceof RawContractError ? err : err instanceof BaseError3 ? err.walk((err2) => "data" in err2) || err.walk() : {};
+  const error = err instanceof RawContractError ? err : err instanceof BaseError4 ? err.walk((err2) => "data" in err2) || err.walk() : {};
   const { code, data, details, message, shortMessage } = error;
   const cause = (() => {
     if (err instanceof AbiDecodingZeroDataError)
@@ -41047,7 +41862,7 @@ function getSizeOfLength2(length) {
     return 3;
   if (length < 2 ** 32)
     return 4;
-  throw new BaseError3("Length is too large.");
+  throw new BaseError4("Length is too large.");
 }
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/authorization/hashAuthorization.js
@@ -41085,7 +41900,7 @@ init_formatEther();
 init_formatGwei2();
 init_base2();
 init_transaction2();
-var EstimateGasExecutionError = class extends BaseError3 {
+var EstimateGasExecutionError = class extends BaseError4 {
   constructor(cause, { account, docsPath: docsPath9, chain: chain2, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value }) {
     const prettyArgs = prettyPrint2({
       from: account?.address,
@@ -41146,21 +41961,21 @@ init_parseAccount();
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/fee.js
 init_formatGwei2();
 init_base2();
-var BaseFeeScalarError = class extends BaseError3 {
+var BaseFeeScalarError = class extends BaseError4 {
   constructor() {
     super("`baseFeeMultiplier` must be greater than 1.", {
       name: "BaseFeeScalarError"
     });
   }
 };
-var Eip1559FeesNotSupportedError = class extends BaseError3 {
+var Eip1559FeesNotSupportedError = class extends BaseError4 {
   constructor() {
     super("Chain does not support EIP-1559 fees.", {
       name: "Eip1559FeesNotSupportedError"
     });
   }
 };
-var MaxFeePerGasTooLowError = class extends BaseError3 {
+var MaxFeePerGasTooLowError = class extends BaseError4 {
   constructor({ maxPriorityFeePerGas }) {
     super(`\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei2(maxPriorityFeePerGas)} gwei).`, { name: "MaxFeePerGasTooLowError" });
   }
@@ -41171,7 +41986,7 @@ init_fromHex2();
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/block.js
 init_base2();
-var BlockNotFoundError = class extends BaseError3 {
+var BlockNotFoundError = class extends BaseError4 {
   constructor({ blockHash, blockNumber }) {
     let identifier = "Block";
     if (blockHash)
@@ -41473,23 +42288,23 @@ function sha2564(value, to_) {
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/blob/commitmentToVersionedHash.js
 function commitmentToVersionedHash2(parameters) {
-  const { commitment, version: version5 = 1 } = parameters;
+  const { commitment, version: version6 = 1 } = parameters;
   const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
   const versionedHash = sha2564(commitment, "bytes");
-  versionedHash.set([version5], 0);
+  versionedHash.set([version6], 0);
   return to === "bytes" ? versionedHash : bytesToHex4(versionedHash);
 }
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/blob/commitmentsToVersionedHashes.js
 function commitmentsToVersionedHashes2(parameters) {
-  const { commitments, version: version5 } = parameters;
+  const { commitments, version: version6 } = parameters;
   const to = parameters.to ?? (typeof commitments[0] === "string" ? "hex" : "bytes");
   const hashes = [];
   for (const commitment of commitments) {
     hashes.push(commitmentToVersionedHash2({
       commitment,
       to,
-      version: version5
+      version: version6
     }));
   }
   return hashes;
@@ -41509,7 +42324,7 @@ var versionedHashVersionKzg2 = 1;
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/blob.js
 init_base2();
-var BlobSizeTooLargeError2 = class extends BaseError3 {
+var BlobSizeTooLargeError2 = class extends BaseError4 {
   constructor({ maxSize, size: size6 }) {
     super("Blob size is too large.", {
       metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size6} bytes`],
@@ -41517,12 +42332,12 @@ var BlobSizeTooLargeError2 = class extends BaseError3 {
     });
   }
 };
-var EmptyBlobError2 = class extends BaseError3 {
+var EmptyBlobError2 = class extends BaseError4 {
   constructor() {
     super("Blob data must not be empty.", { name: "EmptyBlobError" });
   }
 };
-var InvalidVersionedHashSizeError2 = class extends BaseError3 {
+var InvalidVersionedHashSizeError2 = class extends BaseError4 {
   constructor({ hash: hash4, size: size6 }) {
     super(`Versioned hash "${hash4}" size is invalid.`, {
       metaMessages: ["Expected: 32", `Received: ${size6}`],
@@ -41530,12 +42345,12 @@ var InvalidVersionedHashSizeError2 = class extends BaseError3 {
     });
   }
 };
-var InvalidVersionedHashVersionError2 = class extends BaseError3 {
-  constructor({ hash: hash4, version: version5 }) {
+var InvalidVersionedHashVersionError2 = class extends BaseError4 {
+  constructor({ hash: hash4, version: version6 }) {
     super(`Versioned hash "${hash4}" version is invalid.`, {
       metaMessages: [
         `Expected: ${versionedHashVersionKzg2}`,
-        `Received: ${version5}`
+        `Received: ${version6}`
       ],
       name: "InvalidVersionedHashVersionError"
     });
@@ -42000,7 +42815,7 @@ async function estimateGas(client, args) {
         return await recoverAuthorizationAddress({
           authorization: args.authorizationList[0]
         }).catch(() => {
-          throw new BaseError3("`to` is required. Could not infer from `authorizationList`");
+          throw new BaseError4("`to` is required. Could not infer from `authorizationList`");
         });
       return void 0;
     })();
@@ -42505,7 +43320,7 @@ function observe(observerId, callbacks, fn) {
 }
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/wait.js
-init_utils4();
+init_utils5();
 async function wait(time, { signal } = {}) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
@@ -42815,7 +43630,7 @@ async function sendRawTransaction(client, { serializedTransaction }) {
 }
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/promise/withRetry.js
-init_utils4();
+init_utils5();
 function withRetry(fn, { delay: delay_ = 100, retryCount = 2, shouldRetry: shouldRetry2 = () => true, signal } = {}) {
   return new Promise((resolve, reject) => {
     const attemptRetry = async ({ count = 0 } = {}) => {
@@ -42958,7 +43773,7 @@ init_toHex2();
 init_base2();
 init_contract();
 function isNullUniversalResolverError(err) {
-  if (!(err instanceof BaseError3))
+  if (!(err instanceof BaseError4))
     return false;
   const cause = err.walk((e) => e instanceof ContractFunctionRevertedError);
   if (!(cause instanceof ContractFunctionRevertedError))
@@ -43135,7 +43950,7 @@ function decodeAddress2({ coinType, data, args }) {
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/ens.js
 init_base2();
-var EnsAvatarInvalidMetadataError = class extends BaseError3 {
+var EnsAvatarInvalidMetadataError = class extends BaseError4 {
   constructor({ data }) {
     super("Unable to extract image from metadata. The metadata may be malformed or invalid.", {
       metaMessages: [
@@ -43147,19 +43962,19 @@ var EnsAvatarInvalidMetadataError = class extends BaseError3 {
     });
   }
 };
-var EnsAvatarInvalidNftUriError = class extends BaseError3 {
+var EnsAvatarInvalidNftUriError = class extends BaseError4 {
   constructor({ reason }) {
     super(`ENS NFT avatar URI is invalid. ${reason}`, {
       name: "EnsAvatarInvalidNftUriError"
     });
   }
 };
-var EnsAvatarUriResolutionError = class extends BaseError3 {
+var EnsAvatarUriResolutionError = class extends BaseError4 {
   constructor({ uri }) {
     super(`Unable to resolve ENS avatar URI "${uri}". The URI may be malformed, invalid, or does not respond with a valid image.`, { name: "EnsAvatarUriResolutionError" });
   }
 };
-var EnsAvatarUnsupportedNamespaceError = class extends BaseError3 {
+var EnsAvatarUnsupportedNamespaceError = class extends BaseError4 {
   constructor({ namespace }) {
     super(`ENS NFT avatar namespace "${namespace}" is not supported. Must be "erc721" or "erc1155".`, { name: "EnsAvatarUnsupportedNamespaceError" });
   }
@@ -43570,7 +44385,7 @@ async function createAccessList(client, args) {
       params: [request, block]
     });
     if (response.error)
-      throw new BaseError3(response.error, { details: response.error });
+      throw new BaseError4(response.error, { details: response.error });
     return {
       accessList: response.accessList,
       gasUsed: BigInt(response.gasUsed)
@@ -43772,7 +44587,7 @@ async function getDelegation(client, { address, blockNumber, blockTag = "latest"
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/eip712.js
 init_base2();
-var Eip712DomainNotFoundError = class extends BaseError3 {
+var Eip712DomainNotFoundError = class extends BaseError4 {
   constructor({ address }) {
     super(`No EIP-712 domain found on contract "${address}".`, {
       metaMessages: [
@@ -43790,7 +44605,7 @@ var Eip712DomainNotFoundError = class extends BaseError3 {
 async function getEip712Domain(client, parameters) {
   const { address, factory, factoryData } = parameters;
   try {
-    const [fields, name, version5, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
+    const [fields, name, version6, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
       abi,
       address,
       functionName: "eip712Domain",
@@ -43800,7 +44615,7 @@ async function getEip712Domain(client, parameters) {
     return {
       domain: {
         name,
-        version: version5,
+        version: version6,
         chainId: Number(chainId),
         verifyingContract,
         salt
@@ -43921,13 +44736,13 @@ function assertTransactionEIP48442(transaction) {
       throw new EmptyBlobError2();
     for (const hash4 of blobVersionedHashes) {
       const size_ = size2(hash4);
-      const version5 = hexToNumber3(slice2(hash4, 0, 1));
+      const version6 = hexToNumber3(slice2(hash4, 0, 1));
       if (size_ !== 32)
         throw new InvalidVersionedHashSizeError2({ hash: hash4, size: size_ });
-      if (version5 !== versionedHashVersionKzg2)
+      if (version6 !== versionedHashVersionKzg2)
         throw new InvalidVersionedHashVersionError2({
           hash: hash4,
-          version: version5
+          version: version6
         });
     }
   }
@@ -43951,7 +44766,7 @@ function assertTransactionEIP29302(transaction) {
   if (to && !isAddress2(to))
     throw new InvalidAddressError2({ address: to });
   if (maxPriorityFeePerGas || maxFeePerGas)
-    throw new BaseError3("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
+    throw new BaseError4("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.");
   if (gasPrice && gasPrice > maxUint2562)
     throw new FeeCapTooHighError2({ maxFeePerGas: gasPrice });
 }
@@ -43962,7 +44777,7 @@ function assertTransactionLegacy2(transaction) {
   if (typeof chainId !== "undefined" && chainId <= 0)
     throw new InvalidChainIdError2({ chainId });
   if (maxPriorityFeePerGas || maxFeePerGas)
-    throw new BaseError3("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
+    throw new BaseError4("`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.");
   if (gasPrice && gasPrice > maxUint2562)
     throw new FeeCapTooHighError2({ maxFeePerGas: gasPrice });
 }
@@ -44222,7 +45037,7 @@ async function verifyAuthorization({ address, authorization, signature }) {
 init_base2();
 init_request();
 init_rpc();
-init_utils4();
+init_utils5();
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/promise/withDedupe.js
 init_lru2();
@@ -44353,7 +45168,7 @@ function buildRequest(request, options = {}) {
           case WalletConnectSessionSettlementError.code:
             throw new WalletConnectSessionSettlementError(err);
           default:
-            if (err_ instanceof BaseError3)
+            if (err_ instanceof BaseError4)
               throw err_;
             throw new UnknownRpcError(err);
         }
@@ -44428,10 +45243,10 @@ init_fromHex2();
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/rpc/http.js
 init_request();
-init_utils4();
+init_utils5();
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/utils/promise/withTimeout.js
-init_utils4();
+init_utils5();
 function withTimeout(fn, { errorInstance = new Error("timed out"), timeout, signal }) {
   return new Promise((resolve, reject) => {
     ;
@@ -44626,14 +45441,14 @@ init_address3();
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/typedData.js
 init_stringify2();
 init_base2();
-var InvalidDomainError2 = class extends BaseError3 {
+var InvalidDomainError2 = class extends BaseError4 {
   constructor({ domain }) {
     super(`Invalid domain "${stringify2(domain)}".`, {
       metaMessages: ["Must be a valid EIP-712 domain."]
     });
   }
 };
-var InvalidPrimaryTypeError2 = class extends BaseError3 {
+var InvalidPrimaryTypeError2 = class extends BaseError4 {
   constructor({ primaryType, types }) {
     super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
       docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
@@ -44641,7 +45456,7 @@ var InvalidPrimaryTypeError2 = class extends BaseError3 {
     });
   }
 };
-var InvalidStructTypeError2 = class extends BaseError3 {
+var InvalidStructTypeError2 = class extends BaseError4 {
   constructor({ type }) {
     super(`Struct type "${type}" is invalid.`, {
       metaMessages: ["Struct type must not be a Solidity type."],
@@ -44661,7 +45476,7 @@ function validateTypedData2(parameters) {
     for (const param of struct) {
       const { name, type } = param;
       const value = data[name];
-      const integerMatch = type.match(integerRegex3);
+      const integerMatch = type.match(integerRegex4);
       if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
         const [_type, base, size_] = integerMatch;
         numberToHex2(value, {
@@ -44671,7 +45486,7 @@ function validateTypedData2(parameters) {
       }
       if (type === "address" && typeof value === "string" && !isAddress2(value))
         throw new InvalidAddressError2({ address: value });
-      const bytesMatch = type.match(bytesRegex3);
+      const bytesMatch = type.match(bytesRegex4);
       if (bytesMatch) {
         const [_type, size_] = bytesMatch;
         if (size_ && size2(value) !== Number.parseInt(size_, 10))
@@ -44984,7 +45799,7 @@ function toHex3(publicKey, options = {}) {
   );
   return publicKey_;
 }
-var InvalidError = class extends BaseError4 {
+var InvalidError = class extends BaseError5 {
   constructor({ publicKey }) {
     super(`Value \`${stringify3(publicKey)}\` is not a valid public key.`, {
       metaMessages: [
@@ -45001,7 +45816,7 @@ var InvalidError = class extends BaseError4 {
     });
   }
 };
-var InvalidPrefixError = class extends BaseError4 {
+var InvalidPrefixError = class extends BaseError5 {
   constructor({ prefix, cause }) {
     super(`Prefix "${prefix}" is invalid.`, {
       cause
@@ -45014,7 +45829,7 @@ var InvalidPrefixError = class extends BaseError4 {
     });
   }
 };
-var InvalidCompressedPrefixError = class extends BaseError4 {
+var InvalidCompressedPrefixError = class extends BaseError5 {
   constructor() {
     super("Prefix must be 2 or 3 for compressed public keys.");
     Object.defineProperty(this, "name", {
@@ -45025,7 +45840,7 @@ var InvalidCompressedPrefixError = class extends BaseError4 {
     });
   }
 };
-var InvalidUncompressedPrefixError = class extends BaseError4 {
+var InvalidUncompressedPrefixError = class extends BaseError5 {
   constructor() {
     super("Prefix must be 4 for uncompressed public keys.");
     Object.defineProperty(this, "name", {
@@ -45036,7 +45851,7 @@ var InvalidUncompressedPrefixError = class extends BaseError4 {
     });
   }
 };
-var InvalidSerializedSizeError = class extends BaseError4 {
+var InvalidSerializedSizeError = class extends BaseError5 {
   constructor({ publicKey }) {
     super(`Value \`${publicKey}\` is an invalid public key size.`, {
       metaMessages: [
@@ -45111,7 +45926,7 @@ function validate3(address, options = {}) {
     return false;
   }
 }
-var InvalidAddressError3 = class extends BaseError4 {
+var InvalidAddressError3 = class extends BaseError5 {
   constructor({ address, cause }) {
     super(`Address "${address}" is invalid.`, {
       cause
@@ -45124,7 +45939,7 @@ var InvalidAddressError3 = class extends BaseError4 {
     });
   }
 };
-var InvalidInputError = class extends BaseError4 {
+var InvalidInputError = class extends BaseError5 {
   constructor() {
     super("Address is not a 20 byte (40 hexadecimal character) value.");
     Object.defineProperty(this, "name", {
@@ -45135,7 +45950,7 @@ var InvalidInputError = class extends BaseError4 {
     });
   }
 };
-var InvalidChecksumError = class extends BaseError4 {
+var InvalidChecksumError = class extends BaseError5 {
   constructor() {
     super("Address does not match its checksum counterpart.");
     Object.defineProperty(this, "name", {
@@ -45159,8 +45974,8 @@ init_Hex();
 
 // ../../node_modules/.pnpm/ox@0.14.25_typescript@5.9.3_zod@3.25.76/node_modules/ox/_esm/core/Solidity.js
 var arrayRegex = /^(.*)\[([0-9]*)\]$/;
-var bytesRegex4 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
-var integerRegex4 = /^(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)?$/;
+var bytesRegex5 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+var integerRegex5 = /^(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)?$/;
 var maxInt83 = 2n ** (8n - 1n) - 1n;
 var maxInt163 = 2n ** (16n - 1n) - 1n;
 var maxInt243 = 2n ** (24n - 1n) - 1n;
@@ -45457,7 +46272,7 @@ function prepareParameter({ checksumAddress: checksumAddress3 = false, parameter
   }
   if (parameter.type.startsWith("uint") || parameter.type.startsWith("int")) {
     const signed = parameter.type.startsWith("int");
-    const [, , size6 = "256"] = integerRegex4.exec(parameter.type) ?? [];
+    const [, , size6 = "256"] = integerRegex5.exec(parameter.type) ?? [];
     return encodeNumber3(value, {
       signed,
       size: Number(size6)
@@ -45564,7 +46379,7 @@ function encodeBytes3(value, { type }) {
 }
 function encodeBoolean(value) {
   if (typeof value !== "boolean")
-    throw new BaseError4(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+    throw new BaseError5(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
   return { dynamic: false, encoded: padLeft(fromBoolean(value)) };
 }
 function encodeNumber3(value, { signed, size: size6 }) {
@@ -45816,7 +46631,7 @@ function create(bytes, { recursiveReadLimit = 8192 } = {}) {
   cursor.recursiveReadLimit = recursiveReadLimit;
   return cursor;
 }
-var NegativeOffsetError3 = class extends BaseError4 {
+var NegativeOffsetError3 = class extends BaseError5 {
   constructor({ offset }) {
     super(`Offset \`${offset}\` cannot be negative.`);
     Object.defineProperty(this, "name", {
@@ -45827,7 +46642,7 @@ var NegativeOffsetError3 = class extends BaseError4 {
     });
   }
 };
-var PositionOutOfBoundsError3 = class extends BaseError4 {
+var PositionOutOfBoundsError3 = class extends BaseError5 {
   constructor({ length, position }) {
     super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`);
     Object.defineProperty(this, "name", {
@@ -45838,7 +46653,7 @@ var PositionOutOfBoundsError3 = class extends BaseError4 {
     });
   }
 };
-var RecursiveReadLimitExceededError3 = class extends BaseError4 {
+var RecursiveReadLimitExceededError3 = class extends BaseError5 {
   constructor({ count, limit }) {
     super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`);
     Object.defineProperty(this, "name", {
@@ -45924,7 +46739,7 @@ function encodePacked2(types, values) {
       return value;
     if (type === "bool")
       return padLeft(fromBoolean(value), isArray ? 32 : 1);
-    const intMatch = type.match(integerRegex4);
+    const intMatch = type.match(integerRegex5);
     if (intMatch) {
       const [_type, baseType, bits = "256"] = intMatch;
       const size6 = Number.parseInt(bits, 10) / 8;
@@ -45933,7 +46748,7 @@ function encodePacked2(types, values) {
         signed: baseType === "int"
       });
     }
-    const bytesMatch = type.match(bytesRegex4);
+    const bytesMatch = type.match(bytesRegex5);
     if (bytesMatch) {
       const [_type, size6] = bytesMatch;
       if (Number.parseInt(size6, 10) !== (value.length - 2) / 2)
@@ -45960,12 +46775,12 @@ function encodePacked2(types, values) {
 })(encodePacked2 || (encodePacked2 = {}));
 function from5(parameters) {
   if (Array.isArray(parameters) && typeof parameters[0] === "string")
-    return parseAbiParameters(parameters);
+    return parseAbiParameters2(parameters);
   if (typeof parameters === "string")
-    return parseAbiParameters(parameters);
+    return parseAbiParameters2(parameters);
   return parameters;
 }
-var DataSizeTooSmallError = class extends BaseError4 {
+var DataSizeTooSmallError = class extends BaseError5 {
   constructor({ data, parameters, size: size6 }) {
     super(`Data size of ${size6} bytes is too small for given parameters.`, {
       metaMessages: [
@@ -45981,7 +46796,7 @@ var DataSizeTooSmallError = class extends BaseError4 {
     });
   }
 };
-var ZeroDataError = class extends BaseError4 {
+var ZeroDataError = class extends BaseError5 {
   constructor() {
     super('Cannot decode zero data ("0x") with ABI parameters.');
     Object.defineProperty(this, "name", {
@@ -45992,7 +46807,7 @@ var ZeroDataError = class extends BaseError4 {
     });
   }
 };
-var ArrayLengthMismatchError = class extends BaseError4 {
+var ArrayLengthMismatchError = class extends BaseError5 {
   constructor({ expectedLength, givenLength, type }) {
     super(`Array length mismatch for type \`${type}\`. Expected: \`${expectedLength}\`. Given: \`${givenLength}\`.`);
     Object.defineProperty(this, "name", {
@@ -46003,7 +46818,7 @@ var ArrayLengthMismatchError = class extends BaseError4 {
     });
   }
 };
-var BytesSizeMismatchError3 = class extends BaseError4 {
+var BytesSizeMismatchError3 = class extends BaseError5 {
   constructor({ expectedSize, value }) {
     super(`Size of bytes "${value}" (bytes${size4(value)}) does not match expected size (bytes${expectedSize}).`);
     Object.defineProperty(this, "name", {
@@ -46014,7 +46829,7 @@ var BytesSizeMismatchError3 = class extends BaseError4 {
     });
   }
 };
-var LengthMismatchError = class extends BaseError4 {
+var LengthMismatchError = class extends BaseError5 {
   constructor({ expectedLength, givenLength }) {
     super([
       "ABI encoding parameters/values length mismatch.",
@@ -46029,7 +46844,7 @@ var LengthMismatchError = class extends BaseError4 {
     });
   }
 };
-var InvalidArrayError3 = class extends BaseError4 {
+var InvalidArrayError3 = class extends BaseError5 {
   constructor(value) {
     super(`Value \`${value}\` is not a valid array.`);
     Object.defineProperty(this, "name", {
@@ -46040,7 +46855,7 @@ var InvalidArrayError3 = class extends BaseError4 {
     });
   }
 };
-var InvalidTypeError = class extends BaseError4 {
+var InvalidTypeError = class extends BaseError5 {
   constructor(type) {
     super(`Type \`${type}\` is not a valid ABI Type.`);
     Object.defineProperty(this, "name", {
@@ -46149,7 +46964,7 @@ function getSizeOfLength3(length) {
     return 3;
   if (length <= 4294967295)
     return 4;
-  throw new BaseError4("Length is too large.");
+  throw new BaseError5("Length is too large.");
 }
 
 // ../../node_modules/.pnpm/ox@0.14.25_typescript@5.9.3_zod@3.25.76/node_modules/ox/_esm/core/Signature.js
@@ -46266,7 +47081,7 @@ function vToYParity(v) {
     return v % 2 === 0 ? 1 : 0;
   throw new InvalidVError({ value: v });
 }
-var InvalidSerializedSizeError2 = class extends BaseError4 {
+var InvalidSerializedSizeError2 = class extends BaseError5 {
   constructor({ signature }) {
     super(`Value \`${signature}\` is an invalid signature size.`, {
       metaMessages: [
@@ -46282,7 +47097,7 @@ var InvalidSerializedSizeError2 = class extends BaseError4 {
     });
   }
 };
-var MissingPropertiesError = class extends BaseError4 {
+var MissingPropertiesError = class extends BaseError5 {
   constructor({ signature }) {
     super(`Signature \`${stringify3(signature)}\` is missing either an \`r\`, \`s\`, or \`yParity\` property.`);
     Object.defineProperty(this, "name", {
@@ -46293,7 +47108,7 @@ var MissingPropertiesError = class extends BaseError4 {
     });
   }
 };
-var InvalidRError = class extends BaseError4 {
+var InvalidRError = class extends BaseError5 {
   constructor({ value }) {
     super(`Value \`${value}\` is an invalid r value. r must be a positive integer less than 2^256.`);
     Object.defineProperty(this, "name", {
@@ -46304,7 +47119,7 @@ var InvalidRError = class extends BaseError4 {
     });
   }
 };
-var InvalidSError = class extends BaseError4 {
+var InvalidSError = class extends BaseError5 {
   constructor({ value }) {
     super(`Value \`${value}\` is an invalid s value. s must be a positive integer less than 2^256.`);
     Object.defineProperty(this, "name", {
@@ -46315,7 +47130,7 @@ var InvalidSError = class extends BaseError4 {
     });
   }
 };
-var InvalidYParityError = class extends BaseError4 {
+var InvalidYParityError = class extends BaseError5 {
   constructor({ value }) {
     super(`Value \`${value}\` is an invalid y-parity value. Y-parity must be 0 or 1.`);
     Object.defineProperty(this, "name", {
@@ -46326,7 +47141,7 @@ var InvalidYParityError = class extends BaseError4 {
     });
   }
 };
-var InvalidVError = class extends BaseError4 {
+var InvalidVError = class extends BaseError5 {
   constructor({ value }) {
     super(`Value \`${value}\` is an invalid v value. v must be 27, 28 or >=35.`);
     Object.defineProperty(this, "name", {
@@ -46456,7 +47271,7 @@ function validate4(value) {
     return false;
   }
 }
-var InvalidWrappedSignatureError = class extends BaseError4 {
+var InvalidWrappedSignatureError = class extends BaseError5 {
   constructor(wrapped) {
     super(`Value \`${wrapped}\` is an invalid ERC-8010 wrapped signature.`);
     Object.defineProperty(this, "name", {
@@ -46715,7 +47530,7 @@ async function multicall(client, parameters) {
     }
   }
   if (results.length !== contracts.length)
-    throw new BaseError3("multicall results mismatch");
+    throw new BaseError4("multicall results mismatch");
   return results;
 }
 
@@ -46866,7 +47681,7 @@ function normalizeSignature3(signature) {
     current += char;
   }
   if (!valid)
-    throw new BaseError4("Unable to normalize signature.");
+    throw new BaseError5("Unable to normalize signature.");
   return result;
 }
 function isArgOfType3(arg, abiParameter) {
@@ -46932,9 +47747,9 @@ function from10(abiItem, options = {}) {
   const { prepare = true } = options;
   const item = (() => {
     if (Array.isArray(abiItem))
-      return parseAbiItem(abiItem);
+      return parseAbiItem2(abiItem);
     if (typeof abiItem === "string")
-      return parseAbiItem(abiItem);
+      return parseAbiItem2(abiItem);
     return abiItem;
   })();
   return {
@@ -47051,7 +47866,7 @@ function getSignatureHash(...parameters) {
     return abiItem.hash;
   return keccak2563(fromString2(getSignature(abiItem)));
 }
-var AmbiguityError = class extends BaseError4 {
+var AmbiguityError = class extends BaseError5 {
   constructor(x, y) {
     super("Found ambiguous types in overloaded ABI Items.", {
       metaMessages: [
@@ -47071,7 +47886,7 @@ var AmbiguityError = class extends BaseError4 {
     });
   }
 };
-var NotFoundError = class extends BaseError4 {
+var NotFoundError = class extends BaseError5 {
   constructor({ name, data, type = "item" }) {
     const selector = (() => {
       if (name)
@@ -47161,7 +47976,7 @@ async function simulateCalls(client, parameters) {
   const { blockNumber, blockTag, calls, stateOverrides, traceAssetChanges, traceTransfers, validation } = parameters;
   const account = parameters.account ? parseAccount(parameters.account) : void 0;
   if (traceAssetChanges && !account)
-    throw new BaseError3("`account` is required when `traceAssetChanges` is true");
+    throw new BaseError4("`account` is required when `traceAssetChanges` is true");
   const getBalanceData = account ? encode3(from11("constructor(bytes, bytes)"), {
     bytecode: deploylessCallViaBytecodeBytecode,
     args: [
@@ -47443,7 +48258,7 @@ function validate5(wrapped) {
     return false;
   }
 }
-var InvalidWrappedSignatureError2 = class extends BaseError4 {
+var InvalidWrappedSignatureError2 = class extends BaseError5 {
   constructor(wrapped) {
     super(`Value \`${wrapped}\` is an invalid ERC-6492 wrapped signature.`);
     Object.defineProperty(this, "name", {
@@ -48467,7 +49282,7 @@ init_request();
 
 // ../../node_modules/.pnpm/viem@2.51.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@5.0.10_zod@3.25.76/node_modules/viem/_esm/errors/transport.js
 init_base2();
-var UrlRequiredError = class extends BaseError3 {
+var UrlRequiredError = class extends BaseError4 {
   constructor() {
     super("No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.", {
       docsPath: "/docs/clients/intro",