@farcaster/create-mini-app 0.0.5 → 0.0.7

package/templates/default/node_modules/.vite/deps/chunk-PK65EOOR.js

@@ -0,0 +1,4416 @@
+// ../../../../node_modules/.pnpm/abitype@1.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/version.js
+var version = "1.0.7";
+
+// ../../../../node_modules/.pnpm/abitype@1.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/errors.js
+var BaseError = class _BaseError extends Error {
+  constructor(shortMessage, args = {}) {
+    var _a;
+    const details = args.cause instanceof _BaseError ? args.cause.details : ((_a = args.cause) == null ? void 0 : _a.message) ? args.cause.message : args.details;
+    const docsPath4 = args.cause instanceof _BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
+    const message = [
+      shortMessage || "An error occurred.",
+      "",
+      ...args.metaMessages ? [...args.metaMessages, ""] : [],
+      ...docsPath4 ? [`Docs: https://abitype.dev${docsPath4}`] : [],
+      ...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 = docsPath4;
+    this.metaMessages = args.metaMessages;
+    this.shortMessage = shortMessage;
+  }
+};
+
+// ../../../../node_modules/.pnpm/abitype@1.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/regex.js
+function execTyped(regex, string) {
+  const match = regex.exec(string);
+  return match == null ? void 0 : match.groups;
+}
+var bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+var 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)?$/;
+var isTupleRegex = /^\(.+?\).*?$/;
+
+// ../../../../node_modules/.pnpm/abitype@1.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
+var tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
+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 == null ? void 0 : result.array) ?? ""}`;
+    return formatAbiParameter({
+      ...abiParameter,
+      type
+    });
+  }
+  if ("indexed" in abiParameter && abiParameter.indexed)
+    type = `${type} indexed`;
+  if (abiParameter.name)
+    return `${type} ${abiParameter.name}`;
+  return type;
+}
+
+// ../../../../node_modules/.pnpm/abitype@1.0.7_typescript@5.8.2_zod@3.24.1/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;
+}
+
+// ../../../../node_modules/.pnpm/abitype@1.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
+function formatAbiItem(abiItem) {
+  var _a;
+  if (abiItem.type === "function")
+    return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== "nonpayable" ? ` ${abiItem.stateMutability}` : ""}${((_a = abiItem.outputs) == null ? void 0 : _a.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.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
+var errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+function isErrorSignature(signature) {
+  return errorSignatureRegex.test(signature);
+}
+function execErrorSignature(signature) {
+  return execTyped(errorSignatureRegex, signature);
+}
+var eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+function isEventSignature(signature) {
+  return eventSignatureRegex.test(signature);
+}
+function execEventSignature(signature) {
+  return execTyped(eventSignatureRegex, signature);
+}
+var functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
+function isFunctionSignature(signature) {
+  return functionSignatureRegex.test(signature);
+}
+function execFunctionSignature(signature) {
+  return execTyped(functionSignatureRegex, signature);
+}
+var structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
+function isStructSignature(signature) {
+  return structSignatureRegex.test(signature);
+}
+function execStructSignature(signature) {
+  return execTyped(structSignatureRegex, signature);
+}
+var constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
+function isConstructorSignature(signature) {
+  return constructorSignatureRegex.test(signature);
+}
+function execConstructorSignature(signature) {
+  return execTyped(constructorSignatureRegex, signature);
+}
+var fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
+function isFallbackSignature(signature) {
+  return fallbackSignatureRegex.test(signature);
+}
+var receiveSignatureRegex = /^receive\(\) external payable$/;
+function isReceiveSignature(signature) {
+  return receiveSignatureRegex.test(signature);
+}
+var eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
+var functionModifiers = /* @__PURE__ */ new Set([
+  "calldata",
+  "memory",
+  "storage"
+]);
+
+// ../../../../node_modules/.pnpm/abitype@1.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
+var 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"
+    });
+  }
+};
+var 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.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
+var InvalidParameterError = class extends BaseError {
+  constructor({ param }) {
+    super("Invalid ABI parameter.", {
+      details: param
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "InvalidParameterError"
+    });
+  }
+};
+var 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"
+    });
+  }
+};
+var 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"
+    });
+  }
+};
+var 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"
+    });
+  }
+};
+var 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.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/errors/signature.js
+var 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"
+    });
+  }
+};
+var UnknownSignatureError = class extends BaseError {
+  constructor({ signature }) {
+    super("Unknown signature.", {
+      details: signature
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "UnknownSignatureError"
+    });
+  }
+};
+var 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.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/errors/struct.js
+var 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.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
+var 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.0.7_typescript@5.8.2_zod@3.24.1/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;
+}
+var 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.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/runtime/utils.js
+function parseSignature(signature, structs = {}) {
+  if (isFunctionSignature(signature)) {
+    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
+    };
+  }
+  if (isEventSignature(signature)) {
+    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 };
+  }
+  if (isErrorSignature(signature)) {
+    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 };
+  }
+  if (isConstructorSignature(signature)) {
+    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
+    };
+  }
+  if (isFallbackSignature(signature))
+    return { type: "fallback" };
+  if (isReceiveSignature(signature))
+    return {
+      type: "receive",
+      stateMutability: "payable"
+    };
+  throw new UnknownSignatureError({ signature });
+}
+var abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+var abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+var dynamicIntegerRegex = /^u?int$/;
+function parseAbiParameter(param, options) {
+  var _a, _b;
+  const parameterCacheKey = getParameterCacheKey(param, options == null ? void 0 : options.type, options == null ? void 0 : 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 == null ? void 0 : options.structs) ?? {};
+  let type;
+  let components = {};
+  if (isTuple) {
+    type = "tuple";
+    const params = splitParameters(match.type);
+    const components_ = [];
+    const length = params.length;
+    for (let i = 0; i < length; i++) {
+      components_.push(parseAbiParameter(params[i], { structs }));
+    }
+    components = { components: components_ };
+  } else if (match.type in structs) {
+    type = "tuple";
+    components = { components: structs[match.type] };
+  } else if (dynamicIntegerRegex.test(match.type)) {
+    type = `${match.type}256`;
+  } else {
+    type = match.type;
+    if (!((options == null ? void 0 : options.type) === "struct") && !isSolidityType(type))
+      throw new UnknownSolidityTypeError({ type });
+  }
+  if (match.modifier) {
+    if (!((_b = (_a = options == null ? void 0 : options.modifiers) == null ? void 0 : _a.has) == null ? void 0 : _b.call(_a, match.modifier)))
+      throw new InvalidModifierError({
+        param,
+        type: options == null ? void 0 : options.type,
+        modifier: match.modifier
+      });
+    if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))
+      throw new InvalidFunctionModifierError({
+        param,
+        type: options == null ? void 0 : options.type,
+        modifier: match.modifier
+      });
+  }
+  const abiParameter = {
+    type: `${type}${match.array ?? ""}`,
+    ...name,
+    ...indexed,
+    ...components
+  };
+  parameterCache.set(parameterCacheKey, abiParameter);
+  return abiParameter;
+}
+function splitParameters(params, result = [], current = "", depth = 0) {
+  const length = params.trim().length;
+  for (let i = 0; i < length; i++) {
+    const char = params[i];
+    const tail = params.slice(i + 1);
+    switch (char) {
+      case ",":
+        return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);
+      case "(":
+        return splitParameters(tail, result, `${current}${char}`, depth + 1);
+      case ")":
+        return splitParameters(tail, result, `${current}${char}`, depth - 1);
+      default:
+        return splitParameters(tail, result, `${current}${char}`, depth);
+    }
+  }
+  if (current === "")
+    return result;
+  if (depth !== 0)
+    throw new InvalidParenthesisError({ current, depth });
+  result.push(current.trim());
+  return result;
+}
+function isSolidityType(type) {
+  return type === "address" || type === "bool" || type === "function" || type === "string" || bytesRegex.test(type) || integerRegex.test(type);
+}
+var 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)$/;
+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";
+}
+
+// ../../../../node_modules/.pnpm/abitype@1.0.7_typescript@5.8.2_zod@3.24.1/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;
+}
+var typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
+function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {
+  const components = [];
+  const length = abiParameters.length;
+  for (let i = 0; i < length; i++) {
+    const abiParameter = abiParameters[i];
+    const isTuple = isTupleRegex.test(abiParameter.type);
+    if (isTuple)
+      components.push(abiParameter);
+    else {
+      const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
+      if (!(match == null ? void 0 : match.type))
+        throw new InvalidAbiTypeParameterError({ abiParameter });
+      const { array, type } = match;
+      if (type in structs) {
+        if (ancestors.has(type))
+          throw new CircularReferenceError({ type });
+        components.push({
+          ...abiParameter,
+          type: `tuple${array ?? ""}`,
+          components: resolveStructs(structs[type] ?? [], structs, /* @__PURE__ */ new Set([...ancestors, type]))
+        });
+      } else {
+        if (isSolidityType(type))
+          components.push(abiParameter);
+        else
+          throw new UnknownTypeError({ type });
+      }
+    }
+  }
+  return components;
+}
+
+// ../../../../node_modules/.pnpm/abitype@1.0.7_typescript@5.8.2_zod@3.24.1/node_modules/abitype/dist/esm/human-readable/parseAbi.js
+function parseAbi(signatures) {
+  const structs = parseStructs(signatures);
+  const abi = [];
+  const length = signatures.length;
+  for (let i = 0; i < length; i++) {
+    const signature = signatures[i];
+    if (isStructSignature(signature))
+      continue;
+    abi.push(parseSignature(signature, structs));
+  }
+  return abi;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/accounts/utils/parseAccount.js
+function parseAccount(account) {
+  if (typeof account === "string")
+    return { address: account, type: "json-rpc" };
+  return account;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/constants/abis.js
+var multicall3Abi = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            name: "target",
+            type: "address"
+          },
+          {
+            name: "allowFailure",
+            type: "bool"
+          },
+          {
+            name: "callData",
+            type: "bytes"
+          }
+        ],
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate3",
+    outputs: [
+      {
+        components: [
+          {
+            name: "success",
+            type: "bool"
+          },
+          {
+            name: "returnData",
+            type: "bytes"
+          }
+        ],
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var universalResolverErrors = [
+  {
+    inputs: [],
+    name: "ResolverNotFound",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ResolverWildcardNotSupported",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ResolverNotContract",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        name: "returnData",
+        type: "bytes"
+      }
+    ],
+    name: "ResolverError",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            name: "status",
+            type: "uint16"
+          },
+          {
+            name: "message",
+            type: "string"
+          }
+        ],
+        name: "errors",
+        type: "tuple[]"
+      }
+    ],
+    name: "HttpError",
+    type: "error"
+  }
+];
+var universalResolverResolveAbi = [
+  ...universalResolverErrors,
+  {
+    name: "resolve",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "name", type: "bytes" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: [
+      { name: "", type: "bytes" },
+      { name: "address", type: "address" }
+    ]
+  },
+  {
+    name: "resolve",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "name", type: "bytes" },
+      { name: "data", type: "bytes" },
+      { name: "gateways", type: "string[]" }
+    ],
+    outputs: [
+      { name: "", type: "bytes" },
+      { name: "address", type: "address" }
+    ]
+  }
+];
+var universalResolverReverseAbi = [
+  ...universalResolverErrors,
+  {
+    name: "reverse",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "bytes", name: "reverseName" }],
+    outputs: [
+      { type: "string", name: "resolvedName" },
+      { type: "address", name: "resolvedAddress" },
+      { type: "address", name: "reverseResolver" },
+      { type: "address", name: "resolver" }
+    ]
+  },
+  {
+    name: "reverse",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { type: "bytes", name: "reverseName" },
+      { type: "string[]", name: "gateways" }
+    ],
+    outputs: [
+      { type: "string", name: "resolvedName" },
+      { type: "address", name: "resolvedAddress" },
+      { type: "address", name: "reverseResolver" },
+      { type: "address", name: "resolver" }
+    ]
+  }
+];
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/constants/contract.js
+var aggregate3Signature = "0x82ad56cb";
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/constants/contracts.js
+var deploylessCallViaBytecodeBytecode = "0x608060405234801561001057600080fd5b5060405161018e38038061018e83398101604081905261002f91610124565b6000808351602085016000f59050803b61004857600080fd5b6000808351602085016000855af16040513d6000823e81610067573d81fd5b3d81f35b634e487b7160e01b600052604160045260246000fd5b600082601f83011261009257600080fd5b81516001600160401b038111156100ab576100ab61006b565b604051601f8201601f19908116603f011681016001600160401b03811182821017156100d9576100d961006b565b6040528181528382016020018510156100f157600080fd5b60005b82811015610110576020818601810151838301820152016100f4565b506000918101602001919091529392505050565b6000806040838503121561013757600080fd5b82516001600160401b0381111561014d57600080fd5b61015985828601610081565b602085015190935090506001600160401b0381111561017757600080fd5b61018385828601610081565b915050925092905056fe";
+var deploylessCallViaFactoryBytecode = "0x608060405234801561001057600080fd5b506040516102c03803806102c083398101604081905261002f916101e6565b836001600160a01b03163b6000036100e457600080836001600160a01b03168360405161005c9190610270565b6000604051808303816000865af19150503d8060008114610099576040519150601f19603f3d011682016040523d82523d6000602084013e61009e565b606091505b50915091508115806100b857506001600160a01b0386163b155b156100e1578060405163101bb98d60e01b81526004016100d8919061028c565b60405180910390fd5b50505b6000808451602086016000885af16040513d6000823e81610103573d81fd5b3d81f35b80516001600160a01b038116811461011e57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561015457818101518382015260200161013c565b50506000910152565b600082601f83011261016e57600080fd5b81516001600160401b0381111561018757610187610123565b604051601f8201601f19908116603f011681016001600160401b03811182821017156101b5576101b5610123565b6040528181528382016020018510156101cd57600080fd5b6101de826020830160208701610139565b949350505050565b600080600080608085870312156101fc57600080fd5b61020585610107565b60208601519094506001600160401b0381111561022157600080fd5b61022d8782880161015d565b93505061023c60408601610107565b60608601519092506001600160401b0381111561025857600080fd5b6102648782880161015d565b91505092959194509250565b60008251610282818460208701610139565b9190910192915050565b60208152600082518060208401526102ab816040850160208701610139565b601f01601f1916919091016040019291505056fe";
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/version.js
+var version2 = "2.21.57";
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/base.js
+var errorConfig = {
+  getDocsUrl: ({ docsBaseUrl, docsPath: docsPath4 = "", docsSlug }) => docsPath4 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath4}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
+  version: `viem@${version2}`
+};
+var BaseError2 = class _BaseError extends Error {
+  constructor(shortMessage, args = {}) {
+    var _a;
+    const details = (() => {
+      var _a2;
+      if (args.cause instanceof _BaseError)
+        return args.cause.details;
+      if ((_a2 = args.cause) == null ? void 0 : _a2.message)
+        return args.cause.message;
+      return args.details;
+    })();
+    const docsPath4 = (() => {
+      if (args.cause instanceof _BaseError)
+        return args.cause.docsPath || args.docsPath;
+      return args.docsPath;
+    })();
+    const docsUrl = (_a = errorConfig.getDocsUrl) == null ? void 0 : _a.call(errorConfig, { ...args, docsPath: docsPath4 });
+    const message = [
+      shortMessage || "An error occurred.",
+      "",
+      ...args.metaMessages ? [...args.metaMessages, ""] : [],
+      ...docsUrl ? [`Docs: ${docsUrl}`] : [],
+      ...details ? [`Details: ${details}`] : [],
+      ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
+    ].join("\n");
+    super(message, args.cause ? { cause: args.cause } : void 0);
+    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, "version", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "BaseError"
+    });
+    this.details = details;
+    this.docsPath = docsPath4;
+    this.metaMessages = args.metaMessages;
+    this.name = args.name ?? this.name;
+    this.shortMessage = shortMessage;
+    this.version = version2;
+  }
+  walk(fn) {
+    return walk(this, fn);
+  }
+};
+function walk(err, fn) {
+  if (fn == null ? void 0 : fn(err))
+    return err;
+  if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
+    return walk(err.cause, fn);
+  return fn ? null : err;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/chain.js
+var ChainDoesNotSupportContract = class extends BaseError2 {
+  constructor({ blockNumber, chain, contract }) {
+    super(`Chain "${chain.name}" does not support contract "${contract.name}".`, {
+      metaMessages: [
+        "This could be due to any of the following:",
+        ...blockNumber && contract.blockCreated && contract.blockCreated > blockNumber ? [
+          `- The contract "${contract.name}" was not deployed until block ${contract.blockCreated} (current block ${blockNumber}).`
+        ] : [
+          `- The chain does not have the contract "${contract.name}" configured.`
+        ]
+      ],
+      name: "ChainDoesNotSupportContract"
+    });
+  }
+};
+var ClientChainNotConfiguredError = class extends BaseError2 {
+  constructor() {
+    super("No chain was provided to the Client.", {
+      name: "ClientChainNotConfiguredError"
+    });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/constants/solidity.js
+var solidityError = {
+  inputs: [
+    {
+      name: "message",
+      type: "string"
+    }
+  ],
+  name: "Error",
+  type: "error"
+};
+var solidityPanic = {
+  inputs: [
+    {
+      name: "reason",
+      type: "uint256"
+    }
+  ],
+  name: "Panic",
+  type: "error"
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/abi/formatAbiItem.js
+function formatAbiItem2(abiItem, { includeName = false } = {}) {
+  if (abiItem.type !== "function" && abiItem.type !== "event" && abiItem.type !== "error")
+    throw new InvalidDefinitionTypeError(abiItem.type);
+  return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
+}
+function formatAbiParams(params, { includeName = false } = {}) {
+  if (!params)
+    return "";
+  return params.map((param) => formatAbiParam(param, { includeName })).join(includeName ? ", " : ",");
+}
+function formatAbiParam(param, { includeName }) {
+  if (param.type.startsWith("tuple")) {
+    return `(${formatAbiParams(param.components, { includeName })})${param.type.slice("tuple".length)}`;
+  }
+  return param.type + (includeName && param.name ? ` ${param.name}` : "");
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/data/isHex.js
+function isHex(value, { strict = true } = {}) {
+  if (!value)
+    return false;
+  if (typeof value !== "string")
+    return false;
+  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/data/size.js
+function size(value) {
+  if (isHex(value, { strict: false }))
+    return Math.ceil((value.length - 2) / 2);
+  return value.length;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/abi.js
+var AbiConstructorNotFoundError = class extends BaseError2 {
+  constructor({ docsPath: docsPath4 }) {
+    super([
+      "A constructor was not found on the ABI.",
+      "Make sure you are using the correct ABI and that the constructor exists on it."
+    ].join("\n"), {
+      docsPath: docsPath4,
+      name: "AbiConstructorNotFoundError"
+    });
+  }
+};
+var AbiConstructorParamsNotFoundError = class extends BaseError2 {
+  constructor({ docsPath: docsPath4 }) {
+    super([
+      "Constructor arguments were provided (`args`), but a constructor parameters (`inputs`) were not found on the ABI.",
+      "Make sure you are using the correct ABI, and that the `inputs` attribute on the constructor exists."
+    ].join("\n"), {
+      docsPath: docsPath4,
+      name: "AbiConstructorParamsNotFoundError"
+    });
+  }
+};
+var AbiDecodingDataSizeTooSmallError = class extends BaseError2 {
+  constructor({ data, params, size: size2 }) {
+    super([`Data size of ${size2} bytes is too small for given parameters.`].join("\n"), {
+      metaMessages: [
+        `Params: (${formatAbiParams(params, { includeName: true })})`,
+        `Data:   ${data} (${size2} bytes)`
+      ],
+      name: "AbiDecodingDataSizeTooSmallError"
+    });
+    Object.defineProperty(this, "data", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "params", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "size", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.data = data;
+    this.params = params;
+    this.size = size2;
+  }
+};
+var AbiDecodingZeroDataError = class extends BaseError2 {
+  constructor() {
+    super('Cannot decode zero data ("0x") with ABI parameters.', {
+      name: "AbiDecodingZeroDataError"
+    });
+  }
+};
+var AbiEncodingArrayLengthMismatchError = class extends BaseError2 {
+  constructor({ expectedLength, givenLength, type }) {
+    super([
+      `ABI encoding array length mismatch for type ${type}.`,
+      `Expected length: ${expectedLength}`,
+      `Given length: ${givenLength}`
+    ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
+  }
+};
+var AbiEncodingBytesSizeMismatchError = class extends BaseError2 {
+  constructor({ expectedSize, value }) {
+    super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
+  }
+};
+var AbiEncodingLengthMismatchError = class extends BaseError2 {
+  constructor({ expectedLength, givenLength }) {
+    super([
+      "ABI encoding params/values length mismatch.",
+      `Expected length (params): ${expectedLength}`,
+      `Given length (values): ${givenLength}`
+    ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
+  }
+};
+var AbiErrorSignatureNotFoundError = class extends BaseError2 {
+  constructor(signature, { docsPath: docsPath4 }) {
+    super([
+      `Encoded error signature "${signature}" not found on ABI.`,
+      "Make sure you are using the correct ABI and that the error exists on it.",
+      `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`
+    ].join("\n"), {
+      docsPath: docsPath4,
+      name: "AbiErrorSignatureNotFoundError"
+    });
+    Object.defineProperty(this, "signature", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.signature = signature;
+  }
+};
+var AbiFunctionNotFoundError = class extends BaseError2 {
+  constructor(functionName, { docsPath: docsPath4 } = {}) {
+    super([
+      `Function ${functionName ? `"${functionName}" ` : ""}not found on ABI.`,
+      "Make sure you are using the correct ABI and that the function exists on it."
+    ].join("\n"), {
+      docsPath: docsPath4,
+      name: "AbiFunctionNotFoundError"
+    });
+  }
+};
+var AbiFunctionOutputsNotFoundError = class extends BaseError2 {
+  constructor(functionName, { docsPath: docsPath4 }) {
+    super([
+      `Function "${functionName}" does not contain any \`outputs\` on ABI.`,
+      "Cannot decode function result without knowing what the parameter types are.",
+      "Make sure you are using the correct ABI and that the function exists on it."
+    ].join("\n"), {
+      docsPath: docsPath4,
+      name: "AbiFunctionOutputsNotFoundError"
+    });
+  }
+};
+var AbiItemAmbiguityError = class extends BaseError2 {
+  constructor(x, y) {
+    super("Found ambiguous types in overloaded ABI items.", {
+      metaMessages: [
+        `\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
+        `\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
+        "",
+        "These types encode differently and cannot be distinguished at runtime.",
+        "Remove one of the ambiguous items in the ABI."
+      ],
+      name: "AbiItemAmbiguityError"
+    });
+  }
+};
+var InvalidAbiEncodingTypeError = class extends BaseError2 {
+  constructor(type, { docsPath: docsPath4 }) {
+    super([
+      `Type "${type}" is not a valid encoding type.`,
+      "Please provide a valid ABI type."
+    ].join("\n"), { docsPath: docsPath4, name: "InvalidAbiEncodingType" });
+  }
+};
+var InvalidAbiDecodingTypeError = class extends BaseError2 {
+  constructor(type, { docsPath: docsPath4 }) {
+    super([
+      `Type "${type}" is not a valid decoding type.`,
+      "Please provide a valid ABI type."
+    ].join("\n"), { docsPath: docsPath4, name: "InvalidAbiDecodingType" });
+  }
+};
+var InvalidArrayError = class extends BaseError2 {
+  constructor(value) {
+    super([`Value "${value}" is not a valid array.`].join("\n"), {
+      name: "InvalidArrayError"
+    });
+  }
+};
+var InvalidDefinitionTypeError = class extends BaseError2 {
+  constructor(type) {
+    super([
+      `"${type}" is not a valid definition type.`,
+      'Valid types: "function", "event", "error"'
+    ].join("\n"), { name: "InvalidDefinitionTypeError" });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/data.js
+var SliceOffsetOutOfBoundsError = class extends BaseError2 {
+  constructor({ offset, position, size: size2 }) {
+    super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
+  }
+};
+var SizeExceedsPaddingSizeError = class extends BaseError2 {
+  constructor({ size: size2, targetSize, type }) {
+    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+  }
+};
+var InvalidBytesLengthError = class extends BaseError2 {
+  constructor({ size: size2, targetSize, type }) {
+    super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} is expected to be ${targetSize} ${type} long, but is ${size2} ${type} long.`, { name: "InvalidBytesLengthError" });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/data/slice.js
+function slice(value, start, end, { strict } = {}) {
+  if (isHex(value, { strict: false }))
+    return sliceHex(value, start, end, {
+      strict
+    });
+  return sliceBytes(value, start, end, {
+    strict
+  });
+}
+function assertStartOffset(value, start) {
+  if (typeof start === "number" && start > 0 && start > size(value) - 1)
+    throw new SliceOffsetOutOfBoundsError({
+      offset: start,
+      position: "start",
+      size: size(value)
+    });
+}
+function assertEndOffset(value, start, end) {
+  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
+    throw new SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: "end",
+      size: size(value)
+    });
+  }
+}
+function sliceBytes(value_, start, end, { strict } = {}) {
+  assertStartOffset(value_, start);
+  const value = value_.slice(start, end);
+  if (strict)
+    assertEndOffset(value, start, end);
+  return value;
+}
+function sliceHex(value_, start, end, { strict } = {}) {
+  assertStartOffset(value_, start);
+  const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
+  if (strict)
+    assertEndOffset(value, start, end);
+  return value;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/data/pad.js
+function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
+  if (typeof hexOrBytes === "string")
+    return padHex(hexOrBytes, { dir, size: size2 });
+  return padBytes(hexOrBytes, { dir, size: size2 });
+}
+function padHex(hex_, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return hex_;
+  const hex = hex_.replace("0x", "");
+  if (hex.length > size2 * 2)
+    throw new SizeExceedsPaddingSizeError({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size2,
+      type: "hex"
+    });
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size2 * 2, "0")}`;
+}
+function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return bytes;
+  if (bytes.length > size2)
+    throw new SizeExceedsPaddingSizeError({
+      size: bytes.length,
+      targetSize: size2,
+      type: "bytes"
+    });
+  const paddedBytes = new Uint8Array(size2);
+  for (let i = 0; i < size2; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+  }
+  return paddedBytes;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/encoding.js
+var IntegerOutOfRangeError = class extends BaseError2 {
+  constructor({ max, min, signed, size: size2, value }) {
+    super(`Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+  }
+};
+var InvalidBytesBooleanError = class extends BaseError2 {
+  constructor(bytes) {
+    super(`Bytes value "${bytes}" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.`, {
+      name: "InvalidBytesBooleanError"
+    });
+  }
+};
+var InvalidHexBooleanError = class extends BaseError2 {
+  constructor(hex) {
+    super(`Hex value "${hex}" is not a valid boolean. The hex value must be "0x0" (false) or "0x1" (true).`, { name: "InvalidHexBooleanError" });
+  }
+};
+var SizeOverflowError = class extends BaseError2 {
+  constructor({ givenSize, maxSize }) {
+    super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/data/trim.js
+function trim(hexOrBytes, { dir = "left" } = {}) {
+  let data = typeof hexOrBytes === "string" ? hexOrBytes.replace("0x", "") : hexOrBytes;
+  let sliceLength = 0;
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === "left" ? i : data.length - i - 1].toString() === "0")
+      sliceLength++;
+    else
+      break;
+  }
+  data = dir === "left" ? data.slice(sliceLength) : data.slice(0, data.length - sliceLength);
+  if (typeof hexOrBytes === "string") {
+    if (data.length === 1 && dir === "right")
+      data = `${data}0`;
+    return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
+  }
+  return data;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/encoding/fromHex.js
+function assertSize(hexOrBytes, { size: size2 }) {
+  if (size(hexOrBytes) > size2)
+    throw new SizeOverflowError({
+      givenSize: size(hexOrBytes),
+      maxSize: size2
+    });
+}
+function fromHex(hex, toOrOpts) {
+  const opts = typeof toOrOpts === "string" ? { to: toOrOpts } : toOrOpts;
+  const to = opts.to;
+  if (to === "number")
+    return hexToNumber(hex, opts);
+  if (to === "bigint")
+    return hexToBigInt(hex, opts);
+  if (to === "string")
+    return hexToString(hex, opts);
+  if (to === "boolean")
+    return hexToBool(hex, opts);
+  return hexToBytes(hex, opts);
+}
+function hexToBigInt(hex, opts = {}) {
+  const { signed } = opts;
+  if (opts.size)
+    assertSize(hex, { size: opts.size });
+  const value = BigInt(hex);
+  if (!signed)
+    return value;
+  const size2 = (hex.length - 2) / 2;
+  const max = (1n << BigInt(size2) * 8n - 1n) - 1n;
+  if (value <= max)
+    return value;
+  return value - BigInt(`0x${"f".padStart(size2 * 2, "f")}`) - 1n;
+}
+function hexToBool(hex_, opts = {}) {
+  let hex = hex_;
+  if (opts.size) {
+    assertSize(hex, { size: opts.size });
+    hex = trim(hex);
+  }
+  if (trim(hex) === "0x00")
+    return false;
+  if (trim(hex) === "0x01")
+    return true;
+  throw new InvalidHexBooleanError(hex);
+}
+function hexToNumber(hex, opts = {}) {
+  return Number(hexToBigInt(hex, opts));
+}
+function hexToString(hex, opts = {}) {
+  let bytes = hexToBytes(hex);
+  if (opts.size) {
+    assertSize(bytes, { size: opts.size });
+    bytes = trim(bytes, { dir: "right" });
+  }
+  return new TextDecoder().decode(bytes);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/encoding/toHex.js
+var hexes = Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+function toHex(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToHex(value, opts);
+  if (typeof value === "string") {
+    return stringToHex(value, opts);
+  }
+  if (typeof value === "boolean")
+    return boolToHex(value, opts);
+  return bytesToHex(value, opts);
+}
+function boolToHex(value, opts = {}) {
+  const hex = `0x${Number(value)}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { size: opts.size });
+  }
+  return hex;
+}
+function bytesToHex(value, opts = {}) {
+  let string = "";
+  for (let i = 0; i < value.length; i++) {
+    string += hexes[value[i]];
+  }
+  const hex = `0x${string}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { dir: "right", size: opts.size });
+  }
+  return hex;
+}
+function numberToHex(value_, opts = {}) {
+  const { signed, size: size2 } = opts;
+  const value = BigInt(value_);
+  let maxValue;
+  if (size2) {
+    if (signed)
+      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size2) * 8n) - 1n;
+  } else if (typeof value_ === "number") {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+  }
+  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+  if (maxValue && value > maxValue || value < minValue) {
+    const suffix = typeof value_ === "bigint" ? "n" : "";
+    throw new IntegerOutOfRangeError({
+      max: maxValue ? `${maxValue}${suffix}` : void 0,
+      min: `${minValue}${suffix}`,
+      signed,
+      size: size2,
+      value: `${value_}${suffix}`
+    });
+  }
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size2)
+    return pad(hex, { size: size2 });
+  return hex;
+}
+var encoder = new TextEncoder();
+function stringToHex(value_, opts = {}) {
+  const value = encoder.encode(value_);
+  return bytesToHex(value, opts);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/encoding/toBytes.js
+var encoder2 = new TextEncoder();
+function toBytes(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToBytes(value, opts);
+  if (typeof value === "boolean")
+    return boolToBytes(value, opts);
+  if (isHex(value))
+    return hexToBytes(value, opts);
+  return stringToBytes(value, opts);
+}
+function boolToBytes(value, opts = {}) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { size: opts.size });
+  }
+  return bytes;
+}
+var charCodeMap = {
+  zero: 48,
+  nine: 57,
+  A: 65,
+  F: 70,
+  a: 97,
+  f: 102
+};
+function charCodeToBase16(char) {
+  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+    return char - charCodeMap.zero;
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
+    return char - (charCodeMap.A - 10);
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
+    return char - (charCodeMap.a - 10);
+  return void 0;
+}
+function hexToBytes(hex_, opts = {}) {
+  let hex = hex_;
+  if (opts.size) {
+    assertSize(hex, { size: opts.size });
+    hex = pad(hex, { dir: "right", size: opts.size });
+  }
+  let hexString = hex.slice(2);
+  if (hexString.length % 2)
+    hexString = `0${hexString}`;
+  const length = hexString.length / 2;
+  const bytes = new Uint8Array(length);
+  for (let index = 0, j = 0; index < length; index++) {
+    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    if (nibbleLeft === void 0 || nibbleRight === void 0) {
+      throw new BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes[index] = nibbleLeft * 16 + nibbleRight;
+  }
+  return bytes;
+}
+function numberToBytes(value, opts) {
+  const hex = numberToHex(value, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value, opts = {}) {
+  const bytes = encoder2.encode(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { dir: "right", size: opts.size });
+  }
+  return bytes;
+}
+
+// ../../../../node_modules/.pnpm/@noble+hashes@1.6.1/node_modules/@noble/hashes/esm/_assert.js
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+
+// ../../../../node_modules/.pnpm/@noble+hashes@1.6.1/node_modules/@noble/hashes/esm/_u64.js
+var U32_MASK64 = BigInt(2 ** 32 - 1);
+var _32n = BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  let Ah = new Uint32Array(lst.length);
+  let Al = new Uint32Array(lst.length);
+  for (let i = 0; i < lst.length; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+
+// ../../../../node_modules/.pnpm/@noble+hashes@1.6.1/node_modules/@noble/hashes/esm/crypto.js
+var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+
+// ../../../../node_modules/.pnpm/@noble+hashes@1.6.1/node_modules/@noble/hashes/esm/utils.js
+var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+var rotr = (word, shift) => word << 32 - shift | word >>> shift;
+var rotl = (word, shift) => word << shift | word >>> 32 - shift >>> 0;
+var isLE = (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+var byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+function byteSwap32(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+}
+var hexes2 = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("utf8ToBytes expected string, got " + typeof str);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes2(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+var Hash = class {
+  // Safe version that clones internal state
+  clone() {
+    return this._cloneInto();
+  }
+};
+function wrapConstructor(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+function wrapXOFConstructorWithOpts(hashCons) {
+  const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
+  const tmp = hashCons({});
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  return hashC;
+}
+
+// ../../../../node_modules/.pnpm/@noble+hashes@1.6.1/node_modules/@noble/hashes/esm/sha3.js
+var SHA3_PI = [];
+var SHA3_ROTL = [];
+var _SHA3_IOTA = [];
+var _0n = BigInt(0);
+var _1n = BigInt(1);
+var _2n = BigInt(2);
+var _7n = BigInt(7);
+var _256n = BigInt(256);
+var _0x71n = BigInt(113);
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+  [x, y] = [y, (2 * x + 3 * y) % 5];
+  SHA3_PI.push(2 * (5 * y + x));
+  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+  let t = _0n;
+  for (let j = 0; j < 7; j++) {
+    R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+    if (R & _2n)
+      t ^= _1n << (_1n << BigInt(j)) - _1n;
+  }
+  _SHA3_IOTA.push(t);
+}
+var [SHA3_IOTA_H, SHA3_IOTA_L] = split(_SHA3_IOTA, true);
+var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  B.fill(0);
+}
+var Keccak = class _Keccak extends Hash {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+    super();
+    this.blockLen = blockLen;
+    this.suffix = suffix;
+    this.outputLen = outputLen;
+    this.enableXOF = enableXOF;
+    this.rounds = rounds;
+    this.pos = 0;
+    this.posOut = 0;
+    this.finished = false;
+    this.destroyed = false;
+    anumber(outputLen);
+    if (0 >= this.blockLen || this.blockLen >= 200)
+      throw new Error("Sha3 supports only keccak-f1600 function");
+    this.state = new Uint8Array(200);
+    this.state32 = u32(this.state);
+  }
+  keccak() {
+    if (!isLE)
+      byteSwap32(this.state32);
+    keccakP(this.state32, this.rounds);
+    if (!isLE)
+      byteSwap32(this.state32);
+    this.posOut = 0;
+    this.pos = 0;
+  }
+  update(data) {
+    aexists(this);
+    const { blockLen, state } = this;
+    data = toBytes2(data);
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      for (let i = 0; i < take; i++)
+        state[this.pos++] ^= data[pos++];
+      if (this.pos === blockLen)
+        this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = true;
+    const { state, suffix, pos, blockLen } = this;
+    state[pos] ^= suffix;
+    if ((suffix & 128) !== 0 && pos === blockLen - 1)
+      this.keccak();
+    state[blockLen - 1] ^= 128;
+    this.keccak();
+  }
+  writeInto(out) {
+    aexists(this, false);
+    abytes(out);
+    this.finish();
+    const bufferOut = this.state;
+    const { blockLen } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen)
+        this.keccak();
+      const take = Math.min(blockLen - this.posOut, len - pos);
+      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+      this.posOut += take;
+      pos += take;
+    }
+    return out;
+  }
+  xofInto(out) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(out);
+  }
+  xof(bytes) {
+    anumber(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out) {
+    aoutput(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = true;
+    this.state.fill(0);
+  }
+  _cloneInto(to) {
+    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+    to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+    to.state32.set(this.state32);
+    to.pos = this.pos;
+    to.posOut = this.posOut;
+    to.finished = this.finished;
+    to.rounds = rounds;
+    to.suffix = suffix;
+    to.outputLen = outputLen;
+    to.enableXOF = enableXOF;
+    to.destroyed = this.destroyed;
+    return to;
+  }
+};
+var gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
+var sha3_224 = gen(6, 144, 224 / 8);
+var sha3_256 = gen(6, 136, 256 / 8);
+var sha3_384 = gen(6, 104, 384 / 8);
+var sha3_512 = gen(6, 72, 512 / 8);
+var keccak_224 = gen(1, 144, 224 / 8);
+var keccak_256 = gen(1, 136, 256 / 8);
+var keccak_384 = gen(1, 104, 384 / 8);
+var keccak_512 = gen(1, 72, 512 / 8);
+var genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+var shake128 = genShake(31, 168, 128 / 8);
+var shake256 = genShake(31, 136, 256 / 8);
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/hash/keccak256.js
+function keccak256(value, to_) {
+  const to = to_ || "hex";
+  const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
+  if (to === "bytes")
+    return bytes;
+  return toHex(bytes);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/hash/hashSignature.js
+var hash = (value) => keccak256(toBytes(value));
+function hashSignature(sig) {
+  return hash(sig);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/hash/normalizeSignature.js
+function normalizeSignature(signature) {
+  let active = true;
+  let current = "";
+  let level = 0;
+  let result = "";
+  let valid = false;
+  for (let i = 0; i < signature.length; i++) {
+    const char = signature[i];
+    if (["(", ")", ","].includes(char))
+      active = true;
+    if (char === "(")
+      level++;
+    if (char === ")")
+      level--;
+    if (!active)
+      continue;
+    if (level === 0) {
+      if (char === " " && ["event", "function", ""].includes(result))
+        result = "";
+      else {
+        result += char;
+        if (char === ")") {
+          valid = true;
+          break;
+        }
+      }
+      continue;
+    }
+    if (char === " ") {
+      if (signature[i - 1] !== "," && current !== "," && current !== ",(") {
+        current = "";
+        active = false;
+      }
+      continue;
+    }
+    result += char;
+    current += char;
+  }
+  if (!valid)
+    throw new BaseError2("Unable to normalize signature.");
+  return result;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/hash/toSignature.js
+var toSignature = (def) => {
+  const def_ = (() => {
+    if (typeof def === "string")
+      return def;
+    return formatAbiItem(def);
+  })();
+  return normalizeSignature(def_);
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/hash/toSignatureHash.js
+function toSignatureHash(fn) {
+  return hashSignature(toSignature(fn));
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/hash/toFunctionSelector.js
+var toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/address.js
+var InvalidAddressError = class extends BaseError2 {
+  constructor({ address }) {
+    super(`Address "${address}" is invalid.`, {
+      metaMessages: [
+        "- Address must be a hex value of 20 bytes (40 hex characters).",
+        "- Address must match its checksum counterpart."
+      ],
+      name: "InvalidAddressError"
+    });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/lru.js
+var LruMap = class extends Map {
+  constructor(size2) {
+    super();
+    Object.defineProperty(this, "maxSize", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.maxSize = size2;
+  }
+  get(key) {
+    const value = super.get(key);
+    if (super.has(key) && value !== void 0) {
+      this.delete(key);
+      super.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    super.set(key, value);
+    if (this.maxSize && this.size > this.maxSize) {
+      const firstKey = this.keys().next().value;
+      if (firstKey)
+        this.delete(firstKey);
+    }
+    return this;
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/address/isAddress.js
+var addressRegex = /^0x[a-fA-F0-9]{40}$/;
+var isAddressCache = new LruMap(8192);
+function isAddress(address, options) {
+  const { strict = true } = options ?? {};
+  const cacheKey = `${address}.${strict}`;
+  if (isAddressCache.has(cacheKey))
+    return isAddressCache.get(cacheKey);
+  const result = (() => {
+    if (!addressRegex.test(address))
+      return false;
+    if (address.toLowerCase() === address)
+      return true;
+    if (strict)
+      return checksumAddress(address) === address;
+    return true;
+  })();
+  isAddressCache.set(cacheKey, result);
+  return result;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/address/getAddress.js
+var checksumAddressCache = new LruMap(8192);
+function checksumAddress(address_, chainId) {
+  if (checksumAddressCache.has(`${address_}.${chainId}`))
+    return checksumAddressCache.get(`${address_}.${chainId}`);
+  const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
+  const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
+  const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
+  for (let i = 0; i < 40; i += 2) {
+    if (hash2[i >> 1] >> 4 >= 8 && address[i]) {
+      address[i] = address[i].toUpperCase();
+    }
+    if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
+      address[i + 1] = address[i + 1].toUpperCase();
+    }
+  }
+  const result = `0x${address.join("")}`;
+  checksumAddressCache.set(`${address_}.${chainId}`, result);
+  return result;
+}
+function getAddress(address, chainId) {
+  if (!isAddress(address, { strict: false }))
+    throw new InvalidAddressError({ address });
+  return checksumAddress(address, chainId);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/cursor.js
+var NegativeOffsetError = class extends BaseError2 {
+  constructor({ offset }) {
+    super(`Offset \`${offset}\` cannot be negative.`, {
+      name: "NegativeOffsetError"
+    });
+  }
+};
+var PositionOutOfBoundsError = class extends BaseError2 {
+  constructor({ length, position }) {
+    super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: "PositionOutOfBoundsError" });
+  }
+};
+var RecursiveReadLimitExceededError = class extends BaseError2 {
+  constructor({ count, limit }) {
+    super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: "RecursiveReadLimitExceededError" });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/cursor.js
+var staticCursor = {
+  bytes: new Uint8Array(),
+  dataView: new DataView(new ArrayBuffer(0)),
+  position: 0,
+  positionReadCount: /* @__PURE__ */ new Map(),
+  recursiveReadCount: 0,
+  recursiveReadLimit: Number.POSITIVE_INFINITY,
+  assertReadLimit() {
+    if (this.recursiveReadCount >= this.recursiveReadLimit)
+      throw new RecursiveReadLimitExceededError({
+        count: this.recursiveReadCount + 1,
+        limit: this.recursiveReadLimit
+      });
+  },
+  assertPosition(position) {
+    if (position < 0 || position > this.bytes.length - 1)
+      throw new PositionOutOfBoundsError({
+        length: this.bytes.length,
+        position
+      });
+  },
+  decrementPosition(offset) {
+    if (offset < 0)
+      throw new NegativeOffsetError({ offset });
+    const position = this.position - offset;
+    this.assertPosition(position);
+    this.position = position;
+  },
+  getReadCount(position) {
+    return this.positionReadCount.get(position || this.position) || 0;
+  },
+  incrementPosition(offset) {
+    if (offset < 0)
+      throw new NegativeOffsetError({ offset });
+    const position = this.position + offset;
+    this.assertPosition(position);
+    this.position = position;
+  },
+  inspectByte(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position);
+    return this.bytes[position];
+  },
+  inspectBytes(length, position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position + length - 1);
+    return this.bytes.subarray(position, position + length);
+  },
+  inspectUint8(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position);
+    return this.bytes[position];
+  },
+  inspectUint16(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position + 1);
+    return this.dataView.getUint16(position);
+  },
+  inspectUint24(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position + 2);
+    return (this.dataView.getUint16(position) << 8) + this.dataView.getUint8(position + 2);
+  },
+  inspectUint32(position_) {
+    const position = position_ ?? this.position;
+    this.assertPosition(position + 3);
+    return this.dataView.getUint32(position);
+  },
+  pushByte(byte) {
+    this.assertPosition(this.position);
+    this.bytes[this.position] = byte;
+    this.position++;
+  },
+  pushBytes(bytes) {
+    this.assertPosition(this.position + bytes.length - 1);
+    this.bytes.set(bytes, this.position);
+    this.position += bytes.length;
+  },
+  pushUint8(value) {
+    this.assertPosition(this.position);
+    this.bytes[this.position] = value;
+    this.position++;
+  },
+  pushUint16(value) {
+    this.assertPosition(this.position + 1);
+    this.dataView.setUint16(this.position, value);
+    this.position += 2;
+  },
+  pushUint24(value) {
+    this.assertPosition(this.position + 2);
+    this.dataView.setUint16(this.position, value >> 8);
+    this.dataView.setUint8(this.position + 2, value & ~4294967040);
+    this.position += 3;
+  },
+  pushUint32(value) {
+    this.assertPosition(this.position + 3);
+    this.dataView.setUint32(this.position, value);
+    this.position += 4;
+  },
+  readByte() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectByte();
+    this.position++;
+    return value;
+  },
+  readBytes(length, size2) {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectBytes(length);
+    this.position += size2 ?? length;
+    return value;
+  },
+  readUint8() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectUint8();
+    this.position += 1;
+    return value;
+  },
+  readUint16() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectUint16();
+    this.position += 2;
+    return value;
+  },
+  readUint24() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectUint24();
+    this.position += 3;
+    return value;
+  },
+  readUint32() {
+    this.assertReadLimit();
+    this._touch();
+    const value = this.inspectUint32();
+    this.position += 4;
+    return value;
+  },
+  get remaining() {
+    return this.bytes.length - this.position;
+  },
+  setPosition(position) {
+    const oldPosition = this.position;
+    this.assertPosition(position);
+    this.position = position;
+    return () => this.position = oldPosition;
+  },
+  _touch() {
+    if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
+      return;
+    const count = this.getReadCount();
+    this.positionReadCount.set(this.position, count + 1);
+    if (count > 0)
+      this.recursiveReadCount++;
+  }
+};
+function createCursor(bytes, { recursiveReadLimit = 8192 } = {}) {
+  const cursor = Object.create(staticCursor);
+  cursor.bytes = bytes;
+  cursor.dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  cursor.positionReadCount = /* @__PURE__ */ new Map();
+  cursor.recursiveReadLimit = recursiveReadLimit;
+  return cursor;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/encoding/fromBytes.js
+function bytesToBigInt(bytes, opts = {}) {
+  if (typeof opts.size !== "undefined")
+    assertSize(bytes, { size: opts.size });
+  const hex = bytesToHex(bytes, opts);
+  return hexToBigInt(hex, opts);
+}
+function bytesToBool(bytes_, opts = {}) {
+  let bytes = bytes_;
+  if (typeof opts.size !== "undefined") {
+    assertSize(bytes, { size: opts.size });
+    bytes = trim(bytes);
+  }
+  if (bytes.length > 1 || bytes[0] > 1)
+    throw new InvalidBytesBooleanError(bytes);
+  return Boolean(bytes[0]);
+}
+function bytesToNumber(bytes, opts = {}) {
+  if (typeof opts.size !== "undefined")
+    assertSize(bytes, { size: opts.size });
+  const hex = bytesToHex(bytes, opts);
+  return hexToNumber(hex, opts);
+}
+function bytesToString(bytes_, opts = {}) {
+  let bytes = bytes_;
+  if (typeof opts.size !== "undefined") {
+    assertSize(bytes, { size: opts.size });
+    bytes = trim(bytes, { dir: "right" });
+  }
+  return new TextDecoder().decode(bytes);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/data/concat.js
+function concat(values) {
+  if (typeof values[0] === "string")
+    return concatHex(values);
+  return concatBytes(values);
+}
+function concatBytes(values) {
+  let length = 0;
+  for (const arr of values) {
+    length += arr.length;
+  }
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const arr of values) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function concatHex(values) {
+  return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/regex.js
+var 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)?$/;
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
+function encodeAbiParameters(params, values) {
+  if (params.length !== values.length)
+    throw new AbiEncodingLengthMismatchError({
+      expectedLength: params.length,
+      givenLength: values.length
+    });
+  const preparedParams = prepareParams({
+    params,
+    values
+  });
+  const data = encodeParams(preparedParams);
+  if (data.length === 0)
+    return "0x";
+  return data;
+}
+function prepareParams({ params, values }) {
+  const preparedParams = [];
+  for (let i = 0; i < params.length; i++) {
+    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
+  }
+  return preparedParams;
+}
+function prepareParam({ param, value }) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return encodeArray(value, { length, param: { ...param, type } });
+  }
+  if (param.type === "tuple") {
+    return encodeTuple(value, {
+      param
+    });
+  }
+  if (param.type === "address") {
+    return encodeAddress(value);
+  }
+  if (param.type === "bool") {
+    return encodeBool(value);
+  }
+  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+    const signed = param.type.startsWith("int");
+    const [, , size2 = "256"] = integerRegex2.exec(param.type) ?? [];
+    return encodeNumber(value, {
+      signed,
+      size: Number(size2)
+    });
+  }
+  if (param.type.startsWith("bytes")) {
+    return encodeBytes(value, { param });
+  }
+  if (param.type === "string") {
+    return encodeString(value);
+  }
+  throw new InvalidAbiEncodingTypeError(param.type, {
+    docsPath: "/docs/contract/encodeAbiParameters"
+  });
+}
+function encodeParams(preparedParams) {
+  let staticSize = 0;
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic)
+      staticSize += 32;
+    else
+      staticSize += size(encoded);
+  }
+  const staticParams = [];
+  const dynamicParams = [];
+  let dynamicSize = 0;
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic) {
+      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
+      dynamicParams.push(encoded);
+      dynamicSize += size(encoded);
+    } else {
+      staticParams.push(encoded);
+    }
+  }
+  return concat([...staticParams, ...dynamicParams]);
+}
+function encodeAddress(value) {
+  if (!isAddress(value))
+    throw new InvalidAddressError({ address: value });
+  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+}
+function encodeArray(value, { length, param }) {
+  const dynamic = length === null;
+  if (!Array.isArray(value))
+    throw new InvalidArrayError(value);
+  if (!dynamic && value.length !== length)
+    throw new AbiEncodingArrayLengthMismatchError({
+      expectedLength: length,
+      givenLength: value.length,
+      type: `${param.type}[${length}]`
+    });
+  let dynamicChild = false;
+  const preparedParams = [];
+  for (let i = 0; i < value.length; i++) {
+    const preparedParam = prepareParam({ param, value: value[i] });
+    if (preparedParam.dynamic)
+      dynamicChild = true;
+    preparedParams.push(preparedParam);
+  }
+  if (dynamic || dynamicChild) {
+    const data = encodeParams(preparedParams);
+    if (dynamic) {
+      const length2 = numberToHex(preparedParams.length, { size: 32 });
+      return {
+        dynamic: true,
+        encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
+      };
+    }
+    if (dynamicChild)
+      return { dynamic: true, encoded: data };
+  }
+  return {
+    dynamic: false,
+    encoded: concat(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function encodeBytes(value, { param }) {
+  const [, paramSize] = param.type.split("bytes");
+  const bytesSize = size(value);
+  if (!paramSize) {
+    let value_ = value;
+    if (bytesSize % 32 !== 0)
+      value_ = padHex(value_, {
+        dir: "right",
+        size: Math.ceil((value.length - 2) / 2 / 32) * 32
+      });
+    return {
+      dynamic: true,
+      encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_])
+    };
+  }
+  if (bytesSize !== Number.parseInt(paramSize))
+    throw new AbiEncodingBytesSizeMismatchError({
+      expectedSize: Number.parseInt(paramSize),
+      value
+    });
+  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
+}
+function encodeBool(value) {
+  if (typeof value !== "boolean")
+    throw new BaseError2(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+  return { dynamic: false, encoded: padHex(boolToHex(value)) };
+}
+function encodeNumber(value, { signed, size: size2 = 256 }) {
+  if (typeof size2 === "number") {
+    const max = 2n ** (BigInt(size2) - (signed ? 1n : 0n)) - 1n;
+    const min = signed ? -max - 1n : 0n;
+    if (value > max || value < min)
+      throw new IntegerOutOfRangeError({
+        max: max.toString(),
+        min: min.toString(),
+        signed,
+        size: size2 / 8,
+        value: value.toString()
+      });
+  }
+  return {
+    dynamic: false,
+    encoded: numberToHex(value, {
+      size: 32,
+      signed
+    })
+  };
+}
+function encodeString(value) {
+  const hexValue = stringToHex(value);
+  const partsLength = Math.ceil(size(hexValue) / 32);
+  const parts = [];
+  for (let i = 0; i < partsLength; i++) {
+    parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
+      dir: "right"
+    }));
+  }
+  return {
+    dynamic: true,
+    encoded: concat([
+      padHex(numberToHex(size(hexValue), { size: 32 })),
+      ...parts
+    ])
+  };
+}
+function encodeTuple(value, { param }) {
+  let dynamic = false;
+  const preparedParams = [];
+  for (let i = 0; i < param.components.length; i++) {
+    const param_ = param.components[i];
+    const index = Array.isArray(value) ? i : param_.name;
+    const preparedParam = prepareParam({
+      param: param_,
+      value: value[index]
+    });
+    preparedParams.push(preparedParam);
+    if (preparedParam.dynamic)
+      dynamic = true;
+  }
+  return {
+    dynamic,
+    encoded: dynamic ? encodeParams(preparedParams) : concat(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function getArrayComponents(type) {
+  const matches = type.match(/^(.*)\[(\d+)?\]$/);
+  return matches ? (
+    // Return `null` if the array is dynamic.
+    [matches[2] ? Number(matches[2]) : null, matches[1]]
+  ) : void 0;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/abi/decodeAbiParameters.js
+function decodeAbiParameters(params, data) {
+  const bytes = typeof data === "string" ? hexToBytes(data) : data;
+  const cursor = createCursor(bytes);
+  if (size(bytes) === 0 && params.length > 0)
+    throw new AbiDecodingZeroDataError();
+  if (size(data) && size(data) < 32)
+    throw new AbiDecodingDataSizeTooSmallError({
+      data: typeof data === "string" ? data : bytesToHex(data),
+      params,
+      size: size(data)
+    });
+  let consumed = 0;
+  const values = [];
+  for (let i = 0; i < params.length; ++i) {
+    const param = params[i];
+    cursor.setPosition(consumed);
+    const [data2, consumed_] = decodeParameter(cursor, param, {
+      staticPosition: 0
+    });
+    consumed += consumed_;
+    values.push(data2);
+  }
+  return values;
+}
+function decodeParameter(cursor, param, { staticPosition }) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return decodeArray(cursor, { ...param, type }, { length, staticPosition });
+  }
+  if (param.type === "tuple")
+    return decodeTuple(cursor, param, { staticPosition });
+  if (param.type === "address")
+    return decodeAddress(cursor);
+  if (param.type === "bool")
+    return decodeBool(cursor);
+  if (param.type.startsWith("bytes"))
+    return decodeBytes(cursor, param, { staticPosition });
+  if (param.type.startsWith("uint") || param.type.startsWith("int"))
+    return decodeNumber(cursor, param);
+  if (param.type === "string")
+    return decodeString(cursor, { staticPosition });
+  throw new InvalidAbiDecodingTypeError(param.type, {
+    docsPath: "/docs/contract/decodeAbiParameters"
+  });
+}
+var sizeOfLength = 32;
+var sizeOfOffset = 32;
+function decodeAddress(cursor) {
+  const value = cursor.readBytes(32);
+  return [checksumAddress(bytesToHex(sliceBytes(value, -20))), 32];
+}
+function decodeArray(cursor, param, { length, staticPosition }) {
+  if (!length) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    const startOfData = start + sizeOfLength;
+    cursor.setPosition(start);
+    const length2 = bytesToNumber(cursor.readBytes(sizeOfLength));
+    const dynamicChild = hasDynamicChild(param);
+    let consumed2 = 0;
+    const value2 = [];
+    for (let i = 0; i < length2; ++i) {
+      cursor.setPosition(startOfData + (dynamicChild ? i * 32 : consumed2));
+      const [data, consumed_] = decodeParameter(cursor, param, {
+        staticPosition: startOfData
+      });
+      consumed2 += consumed_;
+      value2.push(data);
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value2, 32];
+  }
+  if (hasDynamicChild(param)) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    const value2 = [];
+    for (let i = 0; i < length; ++i) {
+      cursor.setPosition(start + i * 32);
+      const [data] = decodeParameter(cursor, param, {
+        staticPosition: start
+      });
+      value2.push(data);
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value2, 32];
+  }
+  let consumed = 0;
+  const value = [];
+  for (let i = 0; i < length; ++i) {
+    const [data, consumed_] = decodeParameter(cursor, param, {
+      staticPosition: staticPosition + consumed
+    });
+    consumed += consumed_;
+    value.push(data);
+  }
+  return [value, consumed];
+}
+function decodeBool(cursor) {
+  return [bytesToBool(cursor.readBytes(32), { size: 32 }), 32];
+}
+function decodeBytes(cursor, param, { staticPosition }) {
+  const [_, size2] = param.type.split("bytes");
+  if (!size2) {
+    const offset = bytesToNumber(cursor.readBytes(32));
+    cursor.setPosition(staticPosition + offset);
+    const length = bytesToNumber(cursor.readBytes(32));
+    if (length === 0) {
+      cursor.setPosition(staticPosition + 32);
+      return ["0x", 32];
+    }
+    const data = cursor.readBytes(length);
+    cursor.setPosition(staticPosition + 32);
+    return [bytesToHex(data), 32];
+  }
+  const value = bytesToHex(cursor.readBytes(Number.parseInt(size2), 32));
+  return [value, 32];
+}
+function decodeNumber(cursor, param) {
+  const signed = param.type.startsWith("int");
+  const size2 = Number.parseInt(param.type.split("int")[1] || "256");
+  const value = cursor.readBytes(32);
+  return [
+    size2 > 48 ? bytesToBigInt(value, { signed }) : bytesToNumber(value, { signed }),
+    32
+  ];
+}
+function decodeTuple(cursor, param, { staticPosition }) {
+  const hasUnnamedChild = param.components.length === 0 || param.components.some(({ name }) => !name);
+  const value = hasUnnamedChild ? [] : {};
+  let consumed = 0;
+  if (hasDynamicChild(param)) {
+    const offset = bytesToNumber(cursor.readBytes(sizeOfOffset));
+    const start = staticPosition + offset;
+    for (let i = 0; i < param.components.length; ++i) {
+      const component = param.components[i];
+      cursor.setPosition(start + consumed);
+      const [data, consumed_] = decodeParameter(cursor, component, {
+        staticPosition: start
+      });
+      consumed += consumed_;
+      value[hasUnnamedChild ? i : component == null ? void 0 : component.name] = data;
+    }
+    cursor.setPosition(staticPosition + 32);
+    return [value, 32];
+  }
+  for (let i = 0; i < param.components.length; ++i) {
+    const component = param.components[i];
+    const [data, consumed_] = decodeParameter(cursor, component, {
+      staticPosition
+    });
+    value[hasUnnamedChild ? i : component == null ? void 0 : component.name] = data;
+    consumed += consumed_;
+  }
+  return [value, consumed];
+}
+function decodeString(cursor, { staticPosition }) {
+  const offset = bytesToNumber(cursor.readBytes(32));
+  const start = staticPosition + offset;
+  cursor.setPosition(start);
+  const length = bytesToNumber(cursor.readBytes(32));
+  if (length === 0) {
+    cursor.setPosition(staticPosition + 32);
+    return ["", 32];
+  }
+  const data = cursor.readBytes(length, 32);
+  const value = bytesToString(trim(data));
+  cursor.setPosition(staticPosition + 32);
+  return [value, 32];
+}
+function hasDynamicChild(param) {
+  var _a;
+  const { type } = param;
+  if (type === "string")
+    return true;
+  if (type === "bytes")
+    return true;
+  if (type.endsWith("[]"))
+    return true;
+  if (type === "tuple")
+    return (_a = param.components) == null ? void 0 : _a.some(hasDynamicChild);
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents && hasDynamicChild({ ...param, type: arrayComponents[1] }))
+    return true;
+  return false;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/abi/decodeErrorResult.js
+function decodeErrorResult(parameters) {
+  const { abi, data } = parameters;
+  const signature = slice(data, 0, 4);
+  if (signature === "0x")
+    throw new AbiDecodingZeroDataError();
+  const abi_ = [...abi || [], solidityError, solidityPanic];
+  const abiItem = abi_.find((x) => x.type === "error" && signature === toFunctionSelector(formatAbiItem2(x)));
+  if (!abiItem)
+    throw new AbiErrorSignatureNotFoundError(signature, {
+      docsPath: "/docs/contract/decodeErrorResult"
+    });
+  return {
+    abiItem,
+    args: "inputs" in abiItem && abiItem.inputs && abiItem.inputs.length > 0 ? decodeAbiParameters(abiItem.inputs, slice(data, 4)) : void 0,
+    errorName: abiItem.name
+  };
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/stringify.js
+var stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
+  const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
+  return typeof replacer === "function" ? replacer(key, value2) : value2;
+}, space);
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/hash/toEventSelector.js
+var toEventSelector = toSignatureHash;
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/abi/getAbiItem.js
+function getAbiItem(parameters) {
+  const { abi, args = [], name } = parameters;
+  const isSelector = isHex(name, { strict: false });
+  const abiItems = abi.filter((abiItem) => {
+    if (isSelector) {
+      if (abiItem.type === "function")
+        return toFunctionSelector(abiItem) === name;
+      if (abiItem.type === "event")
+        return toEventSelector(abiItem) === name;
+      return false;
+    }
+    return "name" in abiItem && abiItem.name === name;
+  });
+  if (abiItems.length === 0)
+    return void 0;
+  if (abiItems.length === 1)
+    return abiItems[0];
+  let matchedAbiItem = void 0;
+  for (const abiItem of abiItems) {
+    if (!("inputs" in abiItem))
+      continue;
+    if (!args || args.length === 0) {
+      if (!abiItem.inputs || abiItem.inputs.length === 0)
+        return abiItem;
+      continue;
+    }
+    if (!abiItem.inputs)
+      continue;
+    if (abiItem.inputs.length === 0)
+      continue;
+    if (abiItem.inputs.length !== args.length)
+      continue;
+    const matched = args.every((arg, index) => {
+      const abiParameter = "inputs" in abiItem && abiItem.inputs[index];
+      if (!abiParameter)
+        return false;
+      return isArgOfType(arg, abiParameter);
+    });
+    if (matched) {
+      if (matchedAbiItem && "inputs" in matchedAbiItem && matchedAbiItem.inputs) {
+        const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
+        if (ambiguousTypes)
+          throw new AbiItemAmbiguityError({
+            abiItem,
+            type: ambiguousTypes[0]
+          }, {
+            abiItem: matchedAbiItem,
+            type: ambiguousTypes[1]
+          });
+      }
+      matchedAbiItem = abiItem;
+    }
+  }
+  if (matchedAbiItem)
+    return matchedAbiItem;
+  return abiItems[0];
+}
+function isArgOfType(arg, abiParameter) {
+  const argType = typeof arg;
+  const abiParameterType = abiParameter.type;
+  switch (abiParameterType) {
+    case "address":
+      return isAddress(arg, { strict: false });
+    case "bool":
+      return argType === "boolean";
+    case "function":
+      return argType === "string";
+    case "string":
+      return argType === "string";
+    default: {
+      if (abiParameterType === "tuple" && "components" in abiParameter)
+        return Object.values(abiParameter.components).every((component, index) => {
+          return isArgOfType(Object.values(arg)[index], component);
+        });
+      if (/^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)?$/.test(abiParameterType))
+        return argType === "number" || argType === "bigint";
+      if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
+        return argType === "string" || arg instanceof Uint8Array;
+      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+        return Array.isArray(arg) && arg.every((x) => isArgOfType(x, {
+          ...abiParameter,
+          // Pop off `[]` or `[M]` from end of type
+          type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, "")
+        }));
+      }
+      return false;
+    }
+  }
+}
+function getAmbiguousTypes(sourceParameters, targetParameters, args) {
+  for (const parameterIndex in sourceParameters) {
+    const sourceParameter = sourceParameters[parameterIndex];
+    const targetParameter = targetParameters[parameterIndex];
+    if (sourceParameter.type === "tuple" && targetParameter.type === "tuple" && "components" in sourceParameter && "components" in targetParameter)
+      return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
+    const types = [sourceParameter.type, targetParameter.type];
+    const ambiguous = (() => {
+      if (types.includes("address") && types.includes("bytes20"))
+        return true;
+      if (types.includes("address") && types.includes("string"))
+        return isAddress(args[parameterIndex], { strict: false });
+      if (types.includes("address") && types.includes("bytes"))
+        return isAddress(args[parameterIndex], { strict: false });
+      return false;
+    })();
+    if (ambiguous)
+      return types;
+  }
+  return;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/constants/unit.js
+var etherUnits = {
+  gwei: 9,
+  wei: 18
+};
+var gweiUnits = {
+  ether: -9,
+  wei: 9
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/unit/formatUnits.js
+function formatUnits(value, decimals) {
+  let display = value.toString();
+  const negative = display.startsWith("-");
+  if (negative)
+    display = display.slice(1);
+  display = display.padStart(decimals, "0");
+  let [integer, fraction] = [
+    display.slice(0, display.length - decimals),
+    display.slice(display.length - decimals)
+  ];
+  fraction = fraction.replace(/(0+)$/, "");
+  return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/unit/formatEther.js
+function formatEther(wei, unit = "wei") {
+  return formatUnits(wei, etherUnits[unit]);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/unit/formatGwei.js
+function formatGwei(wei, unit = "wei") {
+  return formatUnits(wei, gweiUnits[unit]);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/stateOverride.js
+var AccountStateConflictError = class extends BaseError2 {
+  constructor({ address }) {
+    super(`State for account "${address}" is set multiple times.`, {
+      name: "AccountStateConflictError"
+    });
+  }
+};
+var StateAssignmentConflictError = class extends BaseError2 {
+  constructor() {
+    super("state and stateDiff are set on the same account.", {
+      name: "StateAssignmentConflictError"
+    });
+  }
+};
+function prettyStateMapping(stateMapping) {
+  return stateMapping.reduce((pretty, { slot, value }) => {
+    return `${pretty}        ${slot}: ${value}
+`;
+  }, "");
+}
+function prettyStateOverride(stateOverride) {
+  return stateOverride.reduce((pretty, { address, ...state }) => {
+    let val = `${pretty}    ${address}:
+`;
+    if (state.nonce)
+      val += `      nonce: ${state.nonce}
+`;
+    if (state.balance)
+      val += `      balance: ${state.balance}
+`;
+    if (state.code)
+      val += `      code: ${state.code}
+`;
+    if (state.state) {
+      val += "      state:\n";
+      val += prettyStateMapping(state.state);
+    }
+    if (state.stateDiff) {
+      val += "      stateDiff:\n";
+      val += prettyStateMapping(state.stateDiff);
+    }
+    return val;
+  }, "  State Override:\n").slice(0, -1);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/transaction.js
+function prettyPrint(args) {
+  const entries = Object.entries(args).map(([key, value]) => {
+    if (value === void 0 || value === false)
+      return null;
+    return [key, value];
+  }).filter(Boolean);
+  const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
+  return entries.map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`).join("\n");
+}
+var FeeConflictError = class extends BaseError2 {
+  constructor() {
+    super([
+      "Cannot specify both a `gasPrice` and a `maxFeePerGas`/`maxPriorityFeePerGas`.",
+      "Use `maxFeePerGas`/`maxPriorityFeePerGas` for EIP-1559 compatible networks, and `gasPrice` for others."
+    ].join("\n"), { name: "FeeConflictError" });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/utils.js
+var getUrl = (url) => url;
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/contract.js
+var CallExecutionError = class extends BaseError2 {
+  constructor(cause, { account: account_, docsPath: docsPath4, chain, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride }) {
+    var _a;
+    const account = account_ ? parseAccount(account_) : void 0;
+    let prettyArgs = prettyPrint({
+      from: account == null ? void 0 : account.address,
+      to,
+      value: typeof value !== "undefined" && `${formatEther(value)} ${((_a = chain == null ? void 0 : chain.nativeCurrency) == null ? void 0 : _a.symbol) || "ETH"}`,
+      data,
+      gas,
+      gasPrice: typeof gasPrice !== "undefined" && `${formatGwei(gasPrice)} gwei`,
+      maxFeePerGas: typeof maxFeePerGas !== "undefined" && `${formatGwei(maxFeePerGas)} gwei`,
+      maxPriorityFeePerGas: typeof maxPriorityFeePerGas !== "undefined" && `${formatGwei(maxPriorityFeePerGas)} gwei`,
+      nonce
+    });
+    if (stateOverride) {
+      prettyArgs += `
+${prettyStateOverride(stateOverride)}`;
+    }
+    super(cause.shortMessage, {
+      cause,
+      docsPath: docsPath4,
+      metaMessages: [
+        ...cause.metaMessages ? [...cause.metaMessages, " "] : [],
+        "Raw Call Arguments:",
+        prettyArgs
+      ].filter(Boolean),
+      name: "CallExecutionError"
+    });
+    Object.defineProperty(this, "cause", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.cause = cause;
+  }
+};
+var CounterfactualDeploymentFailedError = class extends BaseError2 {
+  constructor({ factory }) {
+    super(`Deployment for counterfactual contract call failed${factory ? ` for factory "${factory}".` : ""}`, {
+      metaMessages: [
+        "Please ensure:",
+        "- The `factory` is a valid contract deployment factory (ie. Create2 Factory, ERC-4337 Factory, etc).",
+        "- The `factoryData` is a valid encoded function call for contract deployment function on the factory."
+      ],
+      name: "CounterfactualDeploymentFailedError"
+    });
+  }
+};
+var RawContractError = class extends BaseError2 {
+  constructor({ data, message }) {
+    super(message || "", { name: "RawContractError" });
+    Object.defineProperty(this, "code", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 3
+    });
+    Object.defineProperty(this, "data", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.data = data;
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/abi/decodeFunctionResult.js
+var docsPath = "/docs/contract/decodeFunctionResult";
+function decodeFunctionResult(parameters) {
+  const { abi, args, functionName, data } = parameters;
+  let abiItem = abi[0];
+  if (functionName) {
+    const item = getAbiItem({ abi, args, name: functionName });
+    if (!item)
+      throw new AbiFunctionNotFoundError(functionName, { docsPath });
+    abiItem = item;
+  }
+  if (abiItem.type !== "function")
+    throw new AbiFunctionNotFoundError(void 0, { docsPath });
+  if (!abiItem.outputs)
+    throw new AbiFunctionOutputsNotFoundError(abiItem.name, { docsPath });
+  const values = decodeAbiParameters(abiItem.outputs, data);
+  if (values && values.length > 1)
+    return values;
+  if (values && values.length === 1)
+    return values[0];
+  return void 0;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/abi/encodeDeployData.js
+var docsPath2 = "/docs/contract/encodeDeployData";
+function encodeDeployData(parameters) {
+  const { abi, args, bytecode } = parameters;
+  if (!args || args.length === 0)
+    return bytecode;
+  const description = abi.find((x) => "type" in x && x.type === "constructor");
+  if (!description)
+    throw new AbiConstructorNotFoundError({ docsPath: docsPath2 });
+  if (!("inputs" in description))
+    throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath2 });
+  if (!description.inputs || description.inputs.length === 0)
+    throw new AbiConstructorParamsNotFoundError({ docsPath: docsPath2 });
+  const data = encodeAbiParameters(description.inputs, args);
+  return concatHex([bytecode, data]);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/abi/prepareEncodeFunctionData.js
+var docsPath3 = "/docs/contract/encodeFunctionData";
+function prepareEncodeFunctionData(parameters) {
+  const { abi, args, functionName } = parameters;
+  let abiItem = abi[0];
+  if (functionName) {
+    const item = getAbiItem({
+      abi,
+      args,
+      name: functionName
+    });
+    if (!item)
+      throw new AbiFunctionNotFoundError(functionName, { docsPath: docsPath3 });
+    abiItem = item;
+  }
+  if (abiItem.type !== "function")
+    throw new AbiFunctionNotFoundError(void 0, { docsPath: docsPath3 });
+  return {
+    abi: [abiItem],
+    functionName: toFunctionSelector(formatAbiItem2(abiItem))
+  };
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/abi/encodeFunctionData.js
+function encodeFunctionData(parameters) {
+  const { args } = parameters;
+  const { abi, functionName } = (() => {
+    var _a;
+    if (parameters.abi.length === 1 && ((_a = parameters.functionName) == null ? void 0 : _a.startsWith("0x")))
+      return parameters;
+    return prepareEncodeFunctionData(parameters);
+  })();
+  const abiItem = abi[0];
+  const signature = functionName;
+  const data = "inputs" in abiItem && abiItem.inputs ? encodeAbiParameters(abiItem.inputs, args ?? []) : void 0;
+  return concatHex([signature, data ?? "0x"]);
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/chain/getChainContractAddress.js
+function getChainContractAddress({ blockNumber, chain, contract: name }) {
+  var _a;
+  const contract = (_a = chain == null ? void 0 : chain.contracts) == null ? void 0 : _a[name];
+  if (!contract)
+    throw new ChainDoesNotSupportContract({
+      chain,
+      contract: { name }
+    });
+  if (blockNumber && contract.blockCreated && contract.blockCreated > blockNumber)
+    throw new ChainDoesNotSupportContract({
+      blockNumber,
+      chain,
+      contract: {
+        name,
+        blockCreated: contract.blockCreated
+      }
+    });
+  return contract.address;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/node.js
+var ExecutionRevertedError = class extends BaseError2 {
+  constructor({ cause, message } = {}) {
+    var _a;
+    const reason = (_a = message == null ? void 0 : message.replace("execution reverted: ", "")) == null ? void 0 : _a.replace("execution reverted", "");
+    super(`Execution reverted ${reason ? `with reason: ${reason}` : "for an unknown reason"}.`, {
+      cause,
+      name: "ExecutionRevertedError"
+    });
+  }
+};
+Object.defineProperty(ExecutionRevertedError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 3
+});
+Object.defineProperty(ExecutionRevertedError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /execution reverted/
+});
+var 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,
+      name: "FeeCapTooHighError"
+    });
+  }
+};
+Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
+});
+var 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,
+      name: "FeeCapTooLowError"
+    });
+  }
+};
+Object.defineProperty(FeeCapTooLowError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /max fee per gas less than block base fee|fee cap less than block base fee|transaction is outdated/
+});
+var 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" });
+  }
+};
+Object.defineProperty(NonceTooHighError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /nonce too high/
+});
+var NonceTooLowError = class extends BaseError2 {
+  constructor({ cause, nonce } = {}) {
+    super([
+      `Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}is lower than the current nonce of the account.`,
+      "Try increasing the nonce or find the latest nonce with `getTransactionCount`."
+    ].join("\n"), { cause, name: "NonceTooLowError" });
+  }
+};
+Object.defineProperty(NonceTooLowError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /nonce too low|transaction already imported|already known/
+});
+var NonceMaxValueError = class extends BaseError2 {
+  constructor({ cause, nonce } = {}) {
+    super(`Nonce provided for the transaction ${nonce ? `(${nonce}) ` : ""}exceeds the maximum allowed nonce.`, { cause, name: "NonceMaxValueError" });
+  }
+};
+Object.defineProperty(NonceMaxValueError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /nonce has max value/
+});
+var InsufficientFundsError = class extends BaseError2 {
+  constructor({ cause } = {}) {
+    super([
+      "The total cost (gas * gas fee + value) of executing this transaction exceeds the balance of the account."
+    ].join("\n"), {
+      cause,
+      metaMessages: [
+        "This error could arise when the account does not have enough funds to:",
+        " - pay for the total gas fee,",
+        " - pay for the value to send.",
+        " ",
+        "The cost of the transaction is calculated as `gas * gas fee + value`, where:",
+        " - `gas` is the amount of gas needed for transaction to execute,",
+        " - `gas fee` is the gas fee,",
+        " - `value` is the amount of ether to send to the recipient."
+      ],
+      name: "InsufficientFundsError"
+    });
+  }
+};
+Object.defineProperty(InsufficientFundsError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /insufficient funds|exceeds transaction sender account balance/
+});
+var 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,
+      name: "IntrinsicGasTooHighError"
+    });
+  }
+};
+Object.defineProperty(IntrinsicGasTooHighError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /intrinsic gas too high|gas limit reached/
+});
+var IntrinsicGasTooLowError = class extends BaseError2 {
+  constructor({ cause, gas } = {}) {
+    super(`The amount of gas ${gas ? `(${gas}) ` : ""}provided for the transaction is too low.`, {
+      cause,
+      name: "IntrinsicGasTooLowError"
+    });
+  }
+};
+Object.defineProperty(IntrinsicGasTooLowError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /intrinsic gas too low/
+});
+var TransactionTypeNotSupportedError = class extends BaseError2 {
+  constructor({ cause }) {
+    super("The transaction type is not supported for this chain.", {
+      cause,
+      name: "TransactionTypeNotSupportedError"
+    });
+  }
+};
+Object.defineProperty(TransactionTypeNotSupportedError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /transaction type not valid/
+});
+var 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` : ""}).`
+    ].join("\n"), {
+      cause,
+      name: "TipAboveFeeCapError"
+    });
+  }
+};
+Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
+});
+var UnknownNodeError = class extends BaseError2 {
+  constructor({ cause }) {
+    super(`An error occurred while executing: ${cause == null ? void 0 : cause.shortMessage}`, {
+      cause,
+      name: "UnknownNodeError"
+    });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/request.js
+var HttpRequestError = class extends BaseError2 {
+  constructor({ body, cause, details, headers, status, url }) {
+    super("HTTP request failed.", {
+      cause,
+      details,
+      metaMessages: [
+        status && `Status: ${status}`,
+        `URL: ${getUrl(url)}`,
+        body && `Request body: ${stringify(body)}`
+      ].filter(Boolean),
+      name: "HttpRequestError"
+    });
+    Object.defineProperty(this, "body", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "headers", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "status", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "url", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.body = body;
+    this.headers = headers;
+    this.status = status;
+    this.url = url;
+  }
+};
+var RpcRequestError = class extends BaseError2 {
+  constructor({ body, error, url }) {
+    super("RPC Request failed.", {
+      cause: error,
+      details: error.message,
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
+      name: "RpcRequestError"
+    });
+    Object.defineProperty(this, "code", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "data", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.code = error.code;
+    this.data = error.data;
+  }
+};
+var TimeoutError = class extends BaseError2 {
+  constructor({ body, url }) {
+    super("The request took too long to respond.", {
+      details: "The request timed out.",
+      metaMessages: [`URL: ${getUrl(url)}`, `Request body: ${stringify(body)}`],
+      name: "TimeoutError"
+    });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/rpc.js
+var unknownErrorCode = -1;
+var RpcError = class extends BaseError2 {
+  constructor(cause, { code, docsPath: docsPath4, metaMessages, name, shortMessage }) {
+    super(shortMessage, {
+      cause,
+      docsPath: docsPath4,
+      metaMessages: metaMessages || (cause == null ? void 0 : cause.metaMessages),
+      name: name || "RpcError"
+    });
+    Object.defineProperty(this, "code", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.name = name || cause.name;
+    this.code = cause instanceof RpcRequestError ? cause.code : code ?? unknownErrorCode;
+  }
+};
+var ProviderRpcError = class extends RpcError {
+  constructor(cause, options) {
+    super(cause, options);
+    Object.defineProperty(this, "data", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.data = options.data;
+  }
+};
+var ParseRpcError = class _ParseRpcError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _ParseRpcError.code,
+      name: "ParseRpcError",
+      shortMessage: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
+    });
+  }
+};
+Object.defineProperty(ParseRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32700
+});
+var InvalidRequestRpcError = class _InvalidRequestRpcError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _InvalidRequestRpcError.code,
+      name: "InvalidRequestRpcError",
+      shortMessage: "JSON is not a valid request object."
+    });
+  }
+};
+Object.defineProperty(InvalidRequestRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32600
+});
+var MethodNotFoundRpcError = class _MethodNotFoundRpcError extends RpcError {
+  constructor(cause, { method } = {}) {
+    super(cause, {
+      code: _MethodNotFoundRpcError.code,
+      name: "MethodNotFoundRpcError",
+      shortMessage: `The method${method ? ` "${method}"` : ""} does not exist / is not available.`
+    });
+  }
+};
+Object.defineProperty(MethodNotFoundRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32601
+});
+var InvalidParamsRpcError = class _InvalidParamsRpcError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _InvalidParamsRpcError.code,
+      name: "InvalidParamsRpcError",
+      shortMessage: [
+        "Invalid parameters were provided to the RPC method.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
+    });
+  }
+};
+Object.defineProperty(InvalidParamsRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32602
+});
+var InternalRpcError = class _InternalRpcError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _InternalRpcError.code,
+      name: "InternalRpcError",
+      shortMessage: "An internal error was received."
+    });
+  }
+};
+Object.defineProperty(InternalRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32603
+});
+var InvalidInputRpcError = class _InvalidInputRpcError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _InvalidInputRpcError.code,
+      name: "InvalidInputRpcError",
+      shortMessage: [
+        "Missing or invalid parameters.",
+        "Double check you have provided the correct parameters."
+      ].join("\n")
+    });
+  }
+};
+Object.defineProperty(InvalidInputRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32e3
+});
+var ResourceNotFoundRpcError = class _ResourceNotFoundRpcError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _ResourceNotFoundRpcError.code,
+      name: "ResourceNotFoundRpcError",
+      shortMessage: "Requested resource not found."
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "ResourceNotFoundRpcError"
+    });
+  }
+};
+Object.defineProperty(ResourceNotFoundRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32001
+});
+var ResourceUnavailableRpcError = class _ResourceUnavailableRpcError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _ResourceUnavailableRpcError.code,
+      name: "ResourceUnavailableRpcError",
+      shortMessage: "Requested resource not available."
+    });
+  }
+};
+Object.defineProperty(ResourceUnavailableRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32002
+});
+var TransactionRejectedRpcError = class _TransactionRejectedRpcError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _TransactionRejectedRpcError.code,
+      name: "TransactionRejectedRpcError",
+      shortMessage: "Transaction creation failed."
+    });
+  }
+};
+Object.defineProperty(TransactionRejectedRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32003
+});
+var MethodNotSupportedRpcError = class _MethodNotSupportedRpcError extends RpcError {
+  constructor(cause, { method } = {}) {
+    super(cause, {
+      code: _MethodNotSupportedRpcError.code,
+      name: "MethodNotSupportedRpcError",
+      shortMessage: `Method${method ? ` "${method}"` : ""} is not implemented.`
+    });
+  }
+};
+Object.defineProperty(MethodNotSupportedRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32004
+});
+var LimitExceededRpcError = class _LimitExceededRpcError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _LimitExceededRpcError.code,
+      name: "LimitExceededRpcError",
+      shortMessage: "Request exceeds defined limit."
+    });
+  }
+};
+Object.defineProperty(LimitExceededRpcError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32005
+});
+var JsonRpcVersionUnsupportedError = class _JsonRpcVersionUnsupportedError extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _JsonRpcVersionUnsupportedError.code,
+      name: "JsonRpcVersionUnsupportedError",
+      shortMessage: "Version of JSON-RPC protocol is not supported."
+    });
+  }
+};
+Object.defineProperty(JsonRpcVersionUnsupportedError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: -32006
+});
+var UserRejectedRequestError = class _UserRejectedRequestError extends ProviderRpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _UserRejectedRequestError.code,
+      name: "UserRejectedRequestError",
+      shortMessage: "User rejected the request."
+    });
+  }
+};
+Object.defineProperty(UserRejectedRequestError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 4001
+});
+var UnauthorizedProviderError = class _UnauthorizedProviderError extends ProviderRpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _UnauthorizedProviderError.code,
+      name: "UnauthorizedProviderError",
+      shortMessage: "The requested method and/or account has not been authorized by the user."
+    });
+  }
+};
+Object.defineProperty(UnauthorizedProviderError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 4100
+});
+var UnsupportedProviderMethodError = class _UnsupportedProviderMethodError extends ProviderRpcError {
+  constructor(cause, { method } = {}) {
+    super(cause, {
+      code: _UnsupportedProviderMethodError.code,
+      name: "UnsupportedProviderMethodError",
+      shortMessage: `The Provider does not support the requested method${method ? ` " ${method}"` : ""}.`
+    });
+  }
+};
+Object.defineProperty(UnsupportedProviderMethodError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 4200
+});
+var ProviderDisconnectedError = class _ProviderDisconnectedError extends ProviderRpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _ProviderDisconnectedError.code,
+      name: "ProviderDisconnectedError",
+      shortMessage: "The Provider is disconnected from all chains."
+    });
+  }
+};
+Object.defineProperty(ProviderDisconnectedError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 4900
+});
+var ChainDisconnectedError = class _ChainDisconnectedError extends ProviderRpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _ChainDisconnectedError.code,
+      name: "ChainDisconnectedError",
+      shortMessage: "The Provider is not connected to the requested chain."
+    });
+  }
+};
+Object.defineProperty(ChainDisconnectedError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 4901
+});
+var SwitchChainError = class _SwitchChainError extends ProviderRpcError {
+  constructor(cause) {
+    super(cause, {
+      code: _SwitchChainError.code,
+      name: "SwitchChainError",
+      shortMessage: "An error occurred when attempting to switch chain."
+    });
+  }
+};
+Object.defineProperty(SwitchChainError, "code", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 4902
+});
+var UnknownRpcError = class extends RpcError {
+  constructor(cause) {
+    super(cause, {
+      name: "UnknownRpcError",
+      shortMessage: "An unknown RPC error occurred."
+    });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/errors/getNodeError.js
+function getNodeError(err, args) {
+  const message = (err.details || "").toLowerCase();
+  const executionRevertedError = err instanceof BaseError2 ? err.walk((e) => (e == null ? void 0 : e.code) === ExecutionRevertedError.code) : err;
+  if (executionRevertedError instanceof BaseError2)
+    return new ExecutionRevertedError({
+      cause: err,
+      message: executionRevertedError.details
+    });
+  if (ExecutionRevertedError.nodeMessage.test(message))
+    return new ExecutionRevertedError({
+      cause: err,
+      message: err.details
+    });
+  if (FeeCapTooHighError.nodeMessage.test(message))
+    return new FeeCapTooHighError({
+      cause: err,
+      maxFeePerGas: args == null ? void 0 : args.maxFeePerGas
+    });
+  if (FeeCapTooLowError.nodeMessage.test(message))
+    return new FeeCapTooLowError({
+      cause: err,
+      maxFeePerGas: args == null ? void 0 : args.maxFeePerGas
+    });
+  if (NonceTooHighError.nodeMessage.test(message))
+    return new NonceTooHighError({ cause: err, nonce: args == null ? void 0 : args.nonce });
+  if (NonceTooLowError.nodeMessage.test(message))
+    return new NonceTooLowError({ cause: err, nonce: args == null ? void 0 : args.nonce });
+  if (NonceMaxValueError.nodeMessage.test(message))
+    return new NonceMaxValueError({ cause: err, nonce: args == null ? void 0 : args.nonce });
+  if (InsufficientFundsError.nodeMessage.test(message))
+    return new InsufficientFundsError({ cause: err });
+  if (IntrinsicGasTooHighError.nodeMessage.test(message))
+    return new IntrinsicGasTooHighError({ cause: err, gas: args == null ? void 0 : args.gas });
+  if (IntrinsicGasTooLowError.nodeMessage.test(message))
+    return new IntrinsicGasTooLowError({ cause: err, gas: args == null ? void 0 : args.gas });
+  if (TransactionTypeNotSupportedError.nodeMessage.test(message))
+    return new TransactionTypeNotSupportedError({ cause: err });
+  if (TipAboveFeeCapError.nodeMessage.test(message))
+    return new TipAboveFeeCapError({
+      cause: err,
+      maxFeePerGas: args == null ? void 0 : args.maxFeePerGas,
+      maxPriorityFeePerGas: args == null ? void 0 : args.maxPriorityFeePerGas
+    });
+  return new UnknownNodeError({
+    cause: err
+  });
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/errors/getCallError.js
+function getCallError(err, { docsPath: docsPath4, ...args }) {
+  const cause = (() => {
+    const cause2 = getNodeError(err, args);
+    if (cause2 instanceof UnknownNodeError)
+      return err;
+    return cause2;
+  })();
+  return new CallExecutionError(cause, {
+    docsPath: docsPath4,
+    ...args
+  });
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/formatters/extract.js
+function extract(value_, { format }) {
+  if (!format)
+    return {};
+  const value = {};
+  function extract_(formatted2) {
+    const keys = Object.keys(formatted2);
+    for (const key of keys) {
+      if (key in value_)
+        value[key] = value_[key];
+      if (formatted2[key] && typeof formatted2[key] === "object" && !Array.isArray(formatted2[key]))
+        extract_(formatted2[key]);
+    }
+  }
+  const formatted = format(value_ || {});
+  extract_(formatted);
+  return value;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/formatters/formatter.js
+function defineFormatter(type, format) {
+  return ({ exclude, format: overrides }) => {
+    return {
+      exclude,
+      format: (args) => {
+        const formatted = format(args);
+        if (exclude) {
+          for (const key of exclude) {
+            delete formatted[key];
+          }
+        }
+        return {
+          ...formatted,
+          ...overrides(args)
+        };
+      },
+      type
+    };
+  };
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/formatters/transactionRequest.js
+var rpcTransactionType = {
+  legacy: "0x0",
+  eip2930: "0x1",
+  eip1559: "0x2",
+  eip4844: "0x3",
+  eip7702: "0x4"
+};
+function formatTransactionRequest(request) {
+  const rpcRequest = {};
+  if (typeof request.authorizationList !== "undefined")
+    rpcRequest.authorizationList = formatAuthorizationList(request.authorizationList);
+  if (typeof request.accessList !== "undefined")
+    rpcRequest.accessList = request.accessList;
+  if (typeof request.blobVersionedHashes !== "undefined")
+    rpcRequest.blobVersionedHashes = request.blobVersionedHashes;
+  if (typeof request.blobs !== "undefined") {
+    if (typeof request.blobs[0] !== "string")
+      rpcRequest.blobs = request.blobs.map((x) => bytesToHex(x));
+    else
+      rpcRequest.blobs = request.blobs;
+  }
+  if (typeof request.data !== "undefined")
+    rpcRequest.data = request.data;
+  if (typeof request.from !== "undefined")
+    rpcRequest.from = request.from;
+  if (typeof request.gas !== "undefined")
+    rpcRequest.gas = numberToHex(request.gas);
+  if (typeof request.gasPrice !== "undefined")
+    rpcRequest.gasPrice = numberToHex(request.gasPrice);
+  if (typeof request.maxFeePerBlobGas !== "undefined")
+    rpcRequest.maxFeePerBlobGas = numberToHex(request.maxFeePerBlobGas);
+  if (typeof request.maxFeePerGas !== "undefined")
+    rpcRequest.maxFeePerGas = numberToHex(request.maxFeePerGas);
+  if (typeof request.maxPriorityFeePerGas !== "undefined")
+    rpcRequest.maxPriorityFeePerGas = numberToHex(request.maxPriorityFeePerGas);
+  if (typeof request.nonce !== "undefined")
+    rpcRequest.nonce = numberToHex(request.nonce);
+  if (typeof request.to !== "undefined")
+    rpcRequest.to = request.to;
+  if (typeof request.type !== "undefined")
+    rpcRequest.type = rpcTransactionType[request.type];
+  if (typeof request.value !== "undefined")
+    rpcRequest.value = numberToHex(request.value);
+  return rpcRequest;
+}
+var defineTransactionRequest = defineFormatter("transactionRequest", formatTransactionRequest);
+function formatAuthorizationList(authorizationList) {
+  return authorizationList.map((authorization) => ({
+    address: authorization.contractAddress,
+    r: authorization.r,
+    s: authorization.s,
+    chainId: numberToHex(authorization.chainId),
+    nonce: numberToHex(authorization.nonce),
+    ...typeof authorization.yParity !== "undefined" ? { yParity: numberToHex(authorization.yParity) } : {},
+    ...typeof authorization.v !== "undefined" && typeof authorization.yParity === "undefined" ? { v: numberToHex(authorization.v) } : {}
+  }));
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/promise/withResolvers.js
+function withResolvers() {
+  let resolve = () => void 0;
+  let reject = () => void 0;
+  const promise = new Promise((resolve_, reject_) => {
+    resolve = resolve_;
+    reject = reject_;
+  });
+  return { promise, resolve, reject };
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/promise/createBatchScheduler.js
+var schedulerCache = /* @__PURE__ */ new Map();
+function createBatchScheduler({ fn, id, shouldSplitBatch, wait = 0, sort }) {
+  const exec = async () => {
+    const scheduler = getScheduler();
+    flush();
+    const args = scheduler.map(({ args: args2 }) => args2);
+    if (args.length === 0)
+      return;
+    fn(args).then((data) => {
+      if (sort && Array.isArray(data))
+        data.sort(sort);
+      for (let i = 0; i < scheduler.length; i++) {
+        const { resolve } = scheduler[i];
+        resolve == null ? void 0 : resolve([data[i], data]);
+      }
+    }).catch((err) => {
+      for (let i = 0; i < scheduler.length; i++) {
+        const { reject } = scheduler[i];
+        reject == null ? void 0 : reject(err);
+      }
+    });
+  };
+  const flush = () => schedulerCache.delete(id);
+  const getBatchedArgs = () => getScheduler().map(({ args }) => args);
+  const getScheduler = () => schedulerCache.get(id) || [];
+  const setScheduler = (item) => schedulerCache.set(id, [...getScheduler(), item]);
+  return {
+    flush,
+    async schedule(args) {
+      const { promise, resolve, reject } = withResolvers();
+      const split2 = shouldSplitBatch == null ? void 0 : shouldSplitBatch([...getBatchedArgs(), args]);
+      if (split2)
+        exec();
+      const hasActiveScheduler = getScheduler().length > 0;
+      if (hasActiveScheduler) {
+        setScheduler({ args, resolve, reject });
+        return promise;
+      }
+      setScheduler({ args, resolve, reject });
+      setTimeout(exec, wait);
+      return promise;
+    }
+  };
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/stateOverride.js
+function serializeStateMapping(stateMapping) {
+  if (!stateMapping || stateMapping.length === 0)
+    return void 0;
+  return stateMapping.reduce((acc, { slot, value }) => {
+    if (slot.length !== 66)
+      throw new InvalidBytesLengthError({
+        size: slot.length,
+        targetSize: 66,
+        type: "hex"
+      });
+    if (value.length !== 66)
+      throw new InvalidBytesLengthError({
+        size: value.length,
+        targetSize: 66,
+        type: "hex"
+      });
+    acc[slot] = value;
+    return acc;
+  }, {});
+}
+function serializeAccountStateOverride(parameters) {
+  const { balance, nonce, state, stateDiff, code } = parameters;
+  const rpcAccountStateOverride = {};
+  if (code !== void 0)
+    rpcAccountStateOverride.code = code;
+  if (balance !== void 0)
+    rpcAccountStateOverride.balance = numberToHex(balance);
+  if (nonce !== void 0)
+    rpcAccountStateOverride.nonce = numberToHex(nonce);
+  if (state !== void 0)
+    rpcAccountStateOverride.state = serializeStateMapping(state);
+  if (stateDiff !== void 0) {
+    if (rpcAccountStateOverride.state)
+      throw new StateAssignmentConflictError();
+    rpcAccountStateOverride.stateDiff = serializeStateMapping(stateDiff);
+  }
+  return rpcAccountStateOverride;
+}
+function serializeStateOverride(parameters) {
+  if (!parameters)
+    return void 0;
+  const rpcStateOverride = {};
+  for (const { address, ...accountState } of parameters) {
+    if (!isAddress(address, { strict: false }))
+      throw new InvalidAddressError({ address });
+    if (rpcStateOverride[address])
+      throw new AccountStateConflictError({ address });
+    rpcStateOverride[address] = serializeAccountStateOverride(accountState);
+  }
+  return rpcStateOverride;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/constants/number.js
+var maxInt8 = 2n ** (8n - 1n) - 1n;
+var maxInt16 = 2n ** (16n - 1n) - 1n;
+var maxInt24 = 2n ** (24n - 1n) - 1n;
+var maxInt32 = 2n ** (32n - 1n) - 1n;
+var maxInt40 = 2n ** (40n - 1n) - 1n;
+var maxInt48 = 2n ** (48n - 1n) - 1n;
+var maxInt56 = 2n ** (56n - 1n) - 1n;
+var maxInt64 = 2n ** (64n - 1n) - 1n;
+var maxInt72 = 2n ** (72n - 1n) - 1n;
+var maxInt80 = 2n ** (80n - 1n) - 1n;
+var maxInt88 = 2n ** (88n - 1n) - 1n;
+var maxInt96 = 2n ** (96n - 1n) - 1n;
+var maxInt104 = 2n ** (104n - 1n) - 1n;
+var maxInt112 = 2n ** (112n - 1n) - 1n;
+var maxInt120 = 2n ** (120n - 1n) - 1n;
+var maxInt128 = 2n ** (128n - 1n) - 1n;
+var maxInt136 = 2n ** (136n - 1n) - 1n;
+var maxInt144 = 2n ** (144n - 1n) - 1n;
+var maxInt152 = 2n ** (152n - 1n) - 1n;
+var maxInt160 = 2n ** (160n - 1n) - 1n;
+var maxInt168 = 2n ** (168n - 1n) - 1n;
+var maxInt176 = 2n ** (176n - 1n) - 1n;
+var maxInt184 = 2n ** (184n - 1n) - 1n;
+var maxInt192 = 2n ** (192n - 1n) - 1n;
+var maxInt200 = 2n ** (200n - 1n) - 1n;
+var maxInt208 = 2n ** (208n - 1n) - 1n;
+var maxInt216 = 2n ** (216n - 1n) - 1n;
+var maxInt224 = 2n ** (224n - 1n) - 1n;
+var maxInt232 = 2n ** (232n - 1n) - 1n;
+var maxInt240 = 2n ** (240n - 1n) - 1n;
+var maxInt248 = 2n ** (248n - 1n) - 1n;
+var maxInt256 = 2n ** (256n - 1n) - 1n;
+var minInt8 = -(2n ** (8n - 1n));
+var minInt16 = -(2n ** (16n - 1n));
+var minInt24 = -(2n ** (24n - 1n));
+var minInt32 = -(2n ** (32n - 1n));
+var minInt40 = -(2n ** (40n - 1n));
+var minInt48 = -(2n ** (48n - 1n));
+var minInt56 = -(2n ** (56n - 1n));
+var minInt64 = -(2n ** (64n - 1n));
+var minInt72 = -(2n ** (72n - 1n));
+var minInt80 = -(2n ** (80n - 1n));
+var minInt88 = -(2n ** (88n - 1n));
+var minInt96 = -(2n ** (96n - 1n));
+var minInt104 = -(2n ** (104n - 1n));
+var minInt112 = -(2n ** (112n - 1n));
+var minInt120 = -(2n ** (120n - 1n));
+var minInt128 = -(2n ** (128n - 1n));
+var minInt136 = -(2n ** (136n - 1n));
+var minInt144 = -(2n ** (144n - 1n));
+var minInt152 = -(2n ** (152n - 1n));
+var minInt160 = -(2n ** (160n - 1n));
+var minInt168 = -(2n ** (168n - 1n));
+var minInt176 = -(2n ** (176n - 1n));
+var minInt184 = -(2n ** (184n - 1n));
+var minInt192 = -(2n ** (192n - 1n));
+var minInt200 = -(2n ** (200n - 1n));
+var minInt208 = -(2n ** (208n - 1n));
+var minInt216 = -(2n ** (216n - 1n));
+var minInt224 = -(2n ** (224n - 1n));
+var minInt232 = -(2n ** (232n - 1n));
+var minInt240 = -(2n ** (240n - 1n));
+var minInt248 = -(2n ** (248n - 1n));
+var minInt256 = -(2n ** (256n - 1n));
+var maxUint8 = 2n ** 8n - 1n;
+var maxUint16 = 2n ** 16n - 1n;
+var maxUint24 = 2n ** 24n - 1n;
+var maxUint32 = 2n ** 32n - 1n;
+var maxUint40 = 2n ** 40n - 1n;
+var maxUint48 = 2n ** 48n - 1n;
+var maxUint56 = 2n ** 56n - 1n;
+var maxUint64 = 2n ** 64n - 1n;
+var maxUint72 = 2n ** 72n - 1n;
+var maxUint80 = 2n ** 80n - 1n;
+var maxUint88 = 2n ** 88n - 1n;
+var maxUint96 = 2n ** 96n - 1n;
+var maxUint104 = 2n ** 104n - 1n;
+var maxUint112 = 2n ** 112n - 1n;
+var maxUint120 = 2n ** 120n - 1n;
+var maxUint128 = 2n ** 128n - 1n;
+var maxUint136 = 2n ** 136n - 1n;
+var maxUint144 = 2n ** 144n - 1n;
+var maxUint152 = 2n ** 152n - 1n;
+var maxUint160 = 2n ** 160n - 1n;
+var maxUint168 = 2n ** 168n - 1n;
+var maxUint176 = 2n ** 176n - 1n;
+var maxUint184 = 2n ** 184n - 1n;
+var maxUint192 = 2n ** 192n - 1n;
+var maxUint200 = 2n ** 200n - 1n;
+var maxUint208 = 2n ** 208n - 1n;
+var maxUint216 = 2n ** 216n - 1n;
+var maxUint224 = 2n ** 224n - 1n;
+var maxUint232 = 2n ** 232n - 1n;
+var maxUint240 = 2n ** 240n - 1n;
+var maxUint248 = 2n ** 248n - 1n;
+var maxUint256 = 2n ** 256n - 1n;
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/transaction/assertRequest.js
+function assertRequest(args) {
+  const { account: account_, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to } = args;
+  const account = account_ ? parseAccount(account_) : void 0;
+  if (account && !isAddress(account.address))
+    throw new InvalidAddressError({ address: account.address });
+  if (to && !isAddress(to))
+    throw new InvalidAddressError({ address: to });
+  if (typeof gasPrice !== "undefined" && (typeof maxFeePerGas !== "undefined" || typeof maxPriorityFeePerGas !== "undefined"))
+    throw new FeeConflictError();
+  if (maxFeePerGas && maxFeePerGas > maxUint256)
+    throw new FeeCapTooHighError({ maxFeePerGas });
+  if (maxPriorityFeePerGas && maxFeePerGas && maxPriorityFeePerGas > maxFeePerGas)
+    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/actions/public/call.js
+async function call(client, args) {
+  var _a, _b, _c, _d;
+  const { account: account_ = client.account, batch = Boolean((_a = client.batch) == null ? void 0 : _a.multicall), blockNumber, blockTag = "latest", accessList, blobs, code, data: data_, factory, factoryData, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, stateOverride, ...rest } = args;
+  const account = account_ ? parseAccount(account_) : void 0;
+  if (code && (factory || factoryData))
+    throw new BaseError2("Cannot provide both `code` & `factory`/`factoryData` as parameters.");
+  if (code && to)
+    throw new BaseError2("Cannot provide both `code` & `to` as parameters.");
+  const deploylessCallViaBytecode = code && data_;
+  const deploylessCallViaFactory = factory && factoryData && to && data_;
+  const deploylessCall = deploylessCallViaBytecode || deploylessCallViaFactory;
+  const data = (() => {
+    if (deploylessCallViaBytecode)
+      return toDeploylessCallViaBytecodeData({
+        code,
+        data: data_
+      });
+    if (deploylessCallViaFactory)
+      return toDeploylessCallViaFactoryData({
+        data: data_,
+        factory,
+        factoryData,
+        to
+      });
+    return data_;
+  })();
+  try {
+    assertRequest(args);
+    const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+    const block = blockNumberHex || blockTag;
+    const rpcStateOverride = serializeStateOverride(stateOverride);
+    const chainFormat = (_d = (_c = (_b = client.chain) == null ? void 0 : _b.formatters) == null ? void 0 : _c.transactionRequest) == null ? void 0 : _d.format;
+    const format = chainFormat || formatTransactionRequest;
+    const request = format({
+      // Pick out extra data that might exist on the chain's transaction request type.
+      ...extract(rest, { format: chainFormat }),
+      from: account == null ? void 0 : account.address,
+      accessList,
+      blobs,
+      data,
+      gas,
+      gasPrice,
+      maxFeePerBlobGas,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      nonce,
+      to: deploylessCall ? void 0 : to,
+      value
+    });
+    if (batch && shouldPerformMulticall({ request }) && !rpcStateOverride) {
+      try {
+        return await scheduleMulticall(client, {
+          ...request,
+          blockNumber,
+          blockTag
+        });
+      } catch (err) {
+        if (!(err instanceof ClientChainNotConfiguredError) && !(err instanceof ChainDoesNotSupportContract))
+          throw err;
+      }
+    }
+    const response = await client.request({
+      method: "eth_call",
+      params: rpcStateOverride ? [
+        request,
+        block,
+        rpcStateOverride
+      ] : [request, block]
+    });
+    if (response === "0x")
+      return { data: void 0 };
+    return { data: response };
+  } catch (err) {
+    const data2 = getRevertErrorData(err);
+    const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await import("./ccip-LLOJAQYN.js");
+    if (client.ccipRead !== false && (data2 == null ? void 0 : data2.slice(0, 10)) === offchainLookupSignature2 && to)
+      return { data: await offchainLookup2(client, { data: data2, to }) };
+    if (deploylessCall && (data2 == null ? void 0 : data2.slice(0, 10)) === "0x101bb98d")
+      throw new CounterfactualDeploymentFailedError({ factory });
+    throw getCallError(err, {
+      ...args,
+      account,
+      chain: client.chain
+    });
+  }
+}
+function shouldPerformMulticall({ request }) {
+  const { data, to, ...request_ } = request;
+  if (!data)
+    return false;
+  if (data.startsWith(aggregate3Signature))
+    return false;
+  if (!to)
+    return false;
+  if (Object.values(request_).filter((x) => typeof x !== "undefined").length > 0)
+    return false;
+  return true;
+}
+async function scheduleMulticall(client, args) {
+  var _a;
+  const { batchSize = 1024, wait = 0 } = typeof ((_a = client.batch) == null ? void 0 : _a.multicall) === "object" ? client.batch.multicall : {};
+  const { blockNumber, blockTag = "latest", data, multicallAddress: multicallAddress_, to } = args;
+  let multicallAddress = multicallAddress_;
+  if (!multicallAddress) {
+    if (!client.chain)
+      throw new ClientChainNotConfiguredError();
+    multicallAddress = getChainContractAddress({
+      blockNumber,
+      chain: client.chain,
+      contract: "multicall3"
+    });
+  }
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+  const block = blockNumberHex || blockTag;
+  const { schedule } = createBatchScheduler({
+    id: `${client.uid}.${block}`,
+    wait,
+    shouldSplitBatch(args2) {
+      const size2 = args2.reduce((size3, { data: data2 }) => size3 + (data2.length - 2), 0);
+      return size2 > batchSize * 2;
+    },
+    fn: async (requests) => {
+      const calls = requests.map((request) => ({
+        allowFailure: true,
+        callData: request.data,
+        target: request.to
+      }));
+      const calldata = encodeFunctionData({
+        abi: multicall3Abi,
+        args: [calls],
+        functionName: "aggregate3"
+      });
+      const data2 = await client.request({
+        method: "eth_call",
+        params: [
+          {
+            data: calldata,
+            to: multicallAddress
+          },
+          block
+        ]
+      });
+      return decodeFunctionResult({
+        abi: multicall3Abi,
+        args: [calls],
+        functionName: "aggregate3",
+        data: data2 || "0x"
+      });
+    }
+  });
+  const [{ returnData, success }] = await schedule({ data, to });
+  if (!success)
+    throw new RawContractError({ data: returnData });
+  if (returnData === "0x")
+    return { data: void 0 };
+  return { data: returnData };
+}
+function toDeploylessCallViaBytecodeData(parameters) {
+  const { code, data } = parameters;
+  return encodeDeployData({
+    abi: parseAbi(["constructor(bytes, bytes)"]),
+    bytecode: deploylessCallViaBytecodeBytecode,
+    args: [code, data]
+  });
+}
+function toDeploylessCallViaFactoryData(parameters) {
+  const { data, factory, factoryData, to } = parameters;
+  return encodeDeployData({
+    abi: parseAbi(["constructor(address, bytes, address, bytes)"]),
+    bytecode: deploylessCallViaFactoryBytecode,
+    args: [to, data, factory, factoryData]
+  });
+}
+function getRevertErrorData(err) {
+  var _a;
+  if (!(err instanceof BaseError2))
+    return void 0;
+  const error = err.walk();
+  return typeof (error == null ? void 0 : error.data) === "object" ? (_a = error.data) == null ? void 0 : _a.data : error.data;
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/errors/ccip.js
+var OffchainLookupError = class extends BaseError2 {
+  constructor({ callbackSelector, cause, data, extraData, sender, urls }) {
+    var _a;
+    super(cause.shortMessage || "An error occurred while fetching for an offchain result.", {
+      cause,
+      metaMessages: [
+        ...cause.metaMessages || [],
+        ((_a = cause.metaMessages) == null ? void 0 : _a.length) ? "" : [],
+        "Offchain Gateway Call:",
+        urls && [
+          "  Gateway URL(s):",
+          ...urls.map((url) => `    ${getUrl(url)}`)
+        ],
+        `  Sender: ${sender}`,
+        `  Data: ${data}`,
+        `  Callback selector: ${callbackSelector}`,
+        `  Extra data: ${extraData}`
+      ].flat(),
+      name: "OffchainLookupError"
+    });
+  }
+};
+var OffchainLookupResponseMalformedError = class extends BaseError2 {
+  constructor({ result, url }) {
+    super("Offchain gateway response is malformed. Response data must be a hex value.", {
+      metaMessages: [
+        `Gateway URL: ${getUrl(url)}`,
+        `Response: ${stringify(result)}`
+      ],
+      name: "OffchainLookupResponseMalformedError"
+    });
+  }
+};
+var OffchainLookupSenderMismatchError = class extends BaseError2 {
+  constructor({ sender, to }) {
+    super("Reverted sender address does not match target contract address (`to`).", {
+      metaMessages: [
+        `Contract address: ${to}`,
+        `OffchainLookup sender address: ${sender}`
+      ],
+      name: "OffchainLookupSenderMismatchError"
+    });
+  }
+};
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/address/isAddressEqual.js
+function isAddressEqual(a, b) {
+  if (!isAddress(a, { strict: false }))
+    throw new InvalidAddressError({ address: a });
+  if (!isAddress(b, { strict: false }))
+    throw new InvalidAddressError({ address: b });
+  return a.toLowerCase() === b.toLowerCase();
+}
+
+// ../../../../node_modules/.pnpm/viem@2.21.57_bufferutil@4.0.9_typescript@5.8.2_utf-8-validate@5.0.10_zod@3.24.1/node_modules/viem/_esm/utils/ccip.js
+var offchainLookupSignature = "0x556f1830";
+var offchainLookupAbiItem = {
+  name: "OffchainLookup",
+  type: "error",
+  inputs: [
+    {
+      name: "sender",
+      type: "address"
+    },
+    {
+      name: "urls",
+      type: "string[]"
+    },
+    {
+      name: "callData",
+      type: "bytes"
+    },
+    {
+      name: "callbackFunction",
+      type: "bytes4"
+    },
+    {
+      name: "extraData",
+      type: "bytes"
+    }
+  ]
+};
+async function offchainLookup(client, { blockNumber, blockTag, data, to }) {
+  const { args } = decodeErrorResult({
+    data,
+    abi: [offchainLookupAbiItem]
+  });
+  const [sender, urls, callData, callbackSelector, extraData] = args;
+  const { ccipRead } = client;
+  const ccipRequest_ = ccipRead && typeof (ccipRead == null ? void 0 : ccipRead.request) === "function" ? ccipRead.request : ccipRequest;
+  try {
+    if (!isAddressEqual(to, sender))
+      throw new OffchainLookupSenderMismatchError({ sender, to });
+    const result = await ccipRequest_({ data: callData, sender, urls });
+    const { data: data_ } = await call(client, {
+      blockNumber,
+      blockTag,
+      data: concat([
+        callbackSelector,
+        encodeAbiParameters([{ type: "bytes" }, { type: "bytes" }], [result, extraData])
+      ]),
+      to
+    });
+    return data_;
+  } catch (err) {
+    throw new OffchainLookupError({
+      callbackSelector,
+      cause: err,
+      data,
+      extraData,
+      sender,
+      urls
+    });
+  }
+}
+async function ccipRequest({ data, sender, urls }) {
+  var _a;
+  let error = new Error("An unknown error occurred.");
+  for (let i = 0; i < urls.length; i++) {
+    const url = urls[i];
+    const method = url.includes("{data}") ? "GET" : "POST";
+    const body = method === "POST" ? { data, sender } : void 0;
+    const headers = method === "POST" ? { "Content-Type": "application/json" } : {};
+    try {
+      const response = await fetch(url.replace("{sender}", sender).replace("{data}", data), {
+        body: JSON.stringify(body),
+        headers,
+        method
+      });
+      let result;
+      if ((_a = response.headers.get("Content-Type")) == null ? void 0 : _a.startsWith("application/json")) {
+        result = (await response.json()).data;
+      } else {
+        result = await response.text();
+      }
+      if (!response.ok) {
+        error = new HttpRequestError({
+          body,
+          details: (result == null ? void 0 : result.error) ? stringify(result.error) : response.statusText,
+          headers: response.headers,
+          status: response.status,
+          url
+        });
+        continue;
+      }
+      if (!isHex(result)) {
+        error = new OffchainLookupResponseMalformedError({
+          result,
+          url
+        });
+        continue;
+      }
+      return result;
+    } catch (err) {
+      error = new HttpRequestError({
+        body,
+        details: err.message,
+        url
+      });
+    }
+  }
+  throw error;
+}
+
+export {
+  BaseError2 as BaseError,
+  fromHex,
+  hexToNumber,
+  numberToHex,
+  stringToHex,
+  LruMap,
+  aexists,
+  aoutput,
+  createView,
+  rotr,
+  rotl,
+  toBytes2 as toBytes,
+  Hash,
+  wrapConstructor,
+  keccak256,
+  getAddress,
+  stringify,
+  HttpRequestError,
+  RpcRequestError,
+  TimeoutError,
+  ParseRpcError,
+  InvalidRequestRpcError,
+  MethodNotFoundRpcError,
+  InvalidParamsRpcError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  TransactionRejectedRpcError,
+  MethodNotSupportedRpcError,
+  LimitExceededRpcError,
+  JsonRpcVersionUnsupportedError,
+  UserRejectedRequestError,
+  UnauthorizedProviderError,
+  UnsupportedProviderMethodError,
+  ProviderDisconnectedError,
+  ChainDisconnectedError,
+  SwitchChainError,
+  UnknownRpcError,
+  defineFormatter,
+  offchainLookupSignature,
+  offchainLookupAbiItem,
+  offchainLookup,
+  ccipRequest
+};
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=chunk-PK65EOOR.js.map