@vapi-network/mcp 0.1.0

package/dist/x402.js

@@ -0,0 +1,1339 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/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");
+}
+var init_isHex = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/data/isHex.js"() {
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/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;
+}
+var init_size = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/data/size.js"() {
+    init_isHex();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/version.js
+var version;
+var init_version = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/version.js"() {
+    version = "2.55.10";
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/base.js
+function walk(err, fn) {
+  if (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;
+}
+var errorConfig, BaseError;
+var init_base = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/base.js"() {
+    init_version();
+    errorConfig = {
+      getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
+      version: `viem@${version}`
+    };
+    BaseError = class _BaseError extends Error {
+      constructor(shortMessage, args = {}) {
+        const details = (() => {
+          if (args.cause instanceof _BaseError)
+            return args.cause.details;
+          if (args.cause?.message)
+            return args.cause.message;
+          return args.details;
+        })();
+        const docsPath = (() => {
+          if (args.cause instanceof _BaseError)
+            return args.cause.docsPath || args.docsPath;
+          return args.docsPath;
+        })();
+        const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath });
+        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 = docsPath;
+        this.metaMessages = args.metaMessages;
+        this.name = args.name ?? this.name;
+        this.shortMessage = shortMessage;
+        this.version = version;
+      }
+      walk(fn) {
+        return walk(this, fn);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/data.js
+var SizeExceedsPaddingSizeError;
+var init_data = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/data.js"() {
+    init_base();
+    SizeExceedsPaddingSizeError = class extends BaseError {
+      constructor({ size: size2, targetSize, type }) {
+        super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/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;
+}
+var init_pad = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/data/pad.js"() {
+    init_data();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/encoding.js
+var IntegerOutOfRangeError, SizeOverflowError;
+var init_encoding = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/encoding.js"() {
+    init_base();
+    IntegerOutOfRangeError = class extends BaseError {
+      constructor({ max, min, signed, size: size2, value }) {
+        super(`Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+      }
+    };
+    SizeOverflowError = class extends BaseError {
+      constructor({ givenSize, maxSize }) {
+        super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/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
+    });
+}
+var init_fromHex = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
+    init_encoding();
+    init_size();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/encoding/toHex.js
+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;
+}
+function stringToHex(value_, opts = {}) {
+  const value = encoder.encode(value_);
+  return bytesToHex(value, opts);
+}
+var hexes, encoder;
+var init_toHex = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/encoding/toHex.js"() {
+    init_encoding();
+    init_pad();
+    init_fromHex();
+    hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+    encoder = /* @__PURE__ */ new TextEncoder();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/encoding/toBytes.js
+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;
+}
+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 BaseError(`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;
+}
+var encoder2, charCodeMap;
+var init_toBytes = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
+    init_base();
+    init_isHex();
+    init_pad();
+    init_fromHex();
+    init_toHex();
+    encoder2 = /* @__PURE__ */ new TextEncoder();
+    charCodeMap = {
+      zero: 48,
+      nine: 57,
+      A: 65,
+      F: 70,
+      a: 97,
+      f: 102
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js
+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) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
+var init_u64 = __esm({
+  "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js"() {
+    U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+    _32n = /* @__PURE__ */ BigInt(32);
+    rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+    rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+    rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+    rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+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);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function byteSwap(word) {
+  return 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]);
+  }
+  return arr;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes2(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+function createHasher(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;
+}
+var isLE, swap32IfBE, Hash;
+var init_utils = __esm({
+  "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js"() {
+    isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+    swap32IfBE = isLE ? (u) => u : byteSwap32;
+    Hash = class {
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js
+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];
+  }
+  clean(B);
+}
+var _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, keccak_256;
+var init_sha3 = __esm({
+  "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js"() {
+    init_u64();
+    init_utils();
+    _0n = BigInt(0);
+    _1n = BigInt(1);
+    _2n = BigInt(2);
+    _7n = BigInt(7);
+    _256n = BigInt(256);
+    _0x71n = BigInt(113);
+    SHA3_PI = [];
+    SHA3_ROTL = [];
+    _SHA3_IOTA = [];
+    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 << /* @__PURE__ */ BigInt(j)) - _1n;
+      }
+      _SHA3_IOTA.push(t);
+    }
+    IOTAS = split(_SHA3_IOTA, true);
+    SHA3_IOTA_H = IOTAS[0];
+    SHA3_IOTA_L = IOTAS[1];
+    rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+    rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+    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.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
+        this.enableXOF = false;
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        anumber(outputLen);
+        if (!(0 < blockLen && blockLen < 200))
+          throw new Error("only keccak-f1600 function is supported");
+        this.state = new Uint8Array(200);
+        this.state32 = u32(this.state);
+      }
+      clone() {
+        return this._cloneInto();
+      }
+      keccak() {
+        swap32IfBE(this.state32);
+        keccakP(this.state32, this.rounds);
+        swap32IfBE(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+      }
+      update(data) {
+        aexists(this);
+        data = toBytes2(data);
+        abytes(data);
+        const { blockLen, state } = this;
+        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;
+        clean(this.state);
+      }
+      _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;
+      }
+    };
+    gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
+    keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/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);
+}
+var init_keccak256 = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/hash/keccak256.js"() {
+    init_sha3();
+    init_isHex();
+    init_toBytes();
+    init_toHex();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/address.js
+var InvalidAddressError;
+var init_address = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/address.js"() {
+    init_base();
+    InvalidAddressError = class extends BaseError {
+      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.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/lru.js
+var LruMap;
+var init_lru = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/lru.js"() {
+    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)) {
+          super.delete(key);
+          super.set(key, value);
+        }
+        return value;
+      }
+      set(key, value) {
+        if (super.has(key))
+          super.delete(key);
+        super.set(key, value);
+        if (this.maxSize && this.size > this.maxSize) {
+          const firstKey = super.keys().next().value;
+          if (firstKey !== void 0)
+            super.delete(firstKey);
+        }
+        return this;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/address/getAddress.js
+function checksumAddress(address_, chainId) {
+  if (checksumAddressCache.has(`${address_}.${chainId}`))
+    return checksumAddressCache.get(`${address_}.${chainId}`);
+  const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
+  const hash = keccak256(stringToBytes(hexAddress), "bytes");
+  const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
+  for (let i = 0; i < 40; i += 2) {
+    if (hash[i >> 1] >> 4 >= 8 && address[i]) {
+      address[i] = address[i].toUpperCase();
+    }
+    if ((hash[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);
+}
+var checksumAddressCache;
+var init_getAddress = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/address/getAddress.js"() {
+    init_address();
+    init_toBytes();
+    init_keccak256();
+    init_lru();
+    init_isAddress();
+    checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/address/isAddress.js
+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;
+}
+var addressRegex, isAddressCache;
+var init_isAddress = __esm({
+  "../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/utils/address/isAddress.js"() {
+    init_lru();
+    init_getAddress();
+    addressRegex = /^0x[a-fA-F0-9]{40}$/;
+    isAddressCache = /* @__PURE__ */ new LruMap(8192);
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.55.10_bufferutil@4.1.0_typescript@6.0.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/index.js
+init_getAddress();
+init_toHex();
+
+// ../x402-client/src/networks.ts
+var BASE_MAINNET_CAIP2 = "eip155:8453";
+var ARC_TESTNET_CAIP2 = "eip155:5042002";
+function canonicalIdentity(usdc, eip712Domain) {
+  return Object.freeze({
+    usdc: getAddress(usdc.toLowerCase()),
+    eip712Domain: Object.freeze({ ...eip712Domain })
+  });
+}
+var baseMainnetUsdc = canonicalIdentity("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", {
+  name: "USD Coin",
+  version: "2"
+});
+var arcTestnetUsdc = canonicalIdentity("0x3600000000000000000000000000000000000000", {
+  name: "USDC",
+  version: "2"
+});
+var CANONICAL_X402_USDC_NETWORKS = Object.freeze({
+  [BASE_MAINNET_CAIP2]: baseMainnetUsdc,
+  [ARC_TESTNET_CAIP2]: arcTestnetUsdc
+});
+function getCanonicalX402Usdc(network) {
+  if (!Object.hasOwn(CANONICAL_X402_USDC_NETWORKS, network)) {
+    return void 0;
+  }
+  return CANONICAL_X402_USDC_NETWORKS[network];
+}
+function browserNetwork(identity) {
+  return Object.freeze({
+    usdc: identity.usdc,
+    enabled: true,
+    eip712Domain: identity.eip712Domain
+  });
+}
+var BROWSER_ENABLED_X402_NETWORK_CONFIG = Object.freeze({
+  [BASE_MAINNET_CAIP2]: browserNetwork(baseMainnetUsdc),
+  [ARC_TESTNET_CAIP2]: browserNetwork(arcTestnetUsdc)
+});
+
+// ../x402-client/src/index.ts
+var MAX_CHALLENGE_BYTES = 1048576;
+var MAX_UINT256 = (1n << 256n) - 1n;
+var MAX_METADATA_DEPTH = 8;
+var MAX_METADATA_ENTRIES = 256;
+var MAX_METADATA_KEYS_PER_OBJECT = 64;
+var MAX_METADATA_ARRAY_LENGTH = 64;
+var MAX_METADATA_STRING_LENGTH = 16384;
+var EIP3009_AUTHORIZATION_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var X402Error = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "X402Error";
+  }
+  code;
+};
+function parse402Challenge(challenge, configuredNetworks, fallbackResourceUrl = "", requiredNetwork, expectedPayTo) {
+  if (!isRecord(challenge) || !Array.isArray(challenge.accepts)) {
+    throw new X402Error("invalid_challenge", "x402 challenge has no accepts array.");
+  }
+  if (challenge.x402Version !== void 0 && challenge.x402Version !== 2) {
+    throw new X402Error(
+      "unsupported_challenge",
+      `Unsupported x402 version: ${String(challenge.x402Version)}.`
+    );
+  }
+  const candidates = challenge.accepts.filter(isRecord);
+  const accepted = candidates.find((candidate) => {
+    const network2 = readString(candidate, "network");
+    const scheme = readString(candidate, "scheme");
+    if (scheme !== "exact" || !network2 || requiredNetwork && network2 !== requiredNetwork) {
+      return false;
+    }
+    const configured = configuredNetworks[network2];
+    if (!configured || configured.enabled === false) {
+      return false;
+    }
+    const asset2 = readString(candidate, "asset");
+    const payTo2 = readString(candidate, "payTo");
+    const amount = readAmount(candidate);
+    const maxTimeoutSeconds2 = readPositiveInteger(candidate.maxTimeoutSeconds);
+    const extra2 = readBoundedJsonRecord(candidate.extra);
+    const name2 = extra2 ? readString(extra2, "name") : null;
+    const version3 = extra2 ? readString(extra2, "version") : null;
+    const tokenDomain = canonicalTokenDomain(network2, configured);
+    if (!asset2 || !payTo2 || amount === null || maxTimeoutSeconds2 === null || !extra2 || !name2 || !version3 || !tokenDomain || name2 !== tokenDomain.name || version3 !== tokenDomain.version || extra2.assetTransferMethod !== void 0 && extra2.assetTransferMethod !== "eip3009") {
+      return false;
+    }
+    try {
+      return getAddress(asset2) === getAddress(configured.usdc) && (!expectedPayTo || getAddress(payTo2) === getAddress(expectedPayTo));
+    } catch {
+      return false;
+    }
+  });
+  if (!accepted) {
+    const offered = candidates.map(
+      (candidate) => `${readString(candidate, "scheme") ?? "?"}/${readString(candidate, "network") ?? "?"}`
+    ).join(", ");
+    const expected = requiredNetwork ? `required network ${requiredNetwork} and its configured USDC asset` : "a configured network and USDC asset";
+    throw new X402Error(
+      "unsupported_challenge",
+      `No exact x402 payment option matches ${expected}${offered ? ` (offered: ${offered})` : ""}.`
+    );
+  }
+  const network = readString(accepted, "network");
+  const asset = readString(accepted, "asset");
+  const payTo = readString(accepted, "payTo");
+  const amountAtomic = readAmount(accepted);
+  const maxTimeoutSeconds = readPositiveInteger(accepted.maxTimeoutSeconds);
+  const extra = readBoundedJsonRecord(accepted.extra);
+  const name = extra ? readString(extra, "name") : null;
+  const version2 = extra ? readString(extra, "version") : null;
+  if (!network || !asset || !payTo || amountAtomic === null || maxTimeoutSeconds === null || !extra || !name || !version2) {
+    throw new X402Error(
+      "invalid_challenge",
+      "x402 exact payment option is missing amount, asset, payTo, maxTimeoutSeconds, or EIP-712 domain fields."
+    );
+  }
+  let resource = readResource(challenge.resource, fallbackResourceUrl);
+  if (!resource.url) resource = readResource(accepted.resource, fallbackResourceUrl);
+  if (!resource.url) {
+    throw new X402Error("invalid_challenge", "x402 challenge is missing its resource URL.");
+  }
+  const extensions = challenge.extensions === void 0 ? void 0 : readBoundedJsonRecord(challenge.extensions);
+  if (challenge.extensions !== void 0 && !extensions) {
+    throw new X402Error(
+      "invalid_challenge",
+      "x402 challenge extensions exceed the supported JSON metadata limits."
+    );
+  }
+  try {
+    parseEip155ChainId(network);
+    return {
+      x402Version: 2,
+      amountAtomic,
+      resource,
+      accepted: {
+        scheme: "exact",
+        network,
+        asset: getAddress(asset),
+        amount: amountAtomic.toString(),
+        payTo: getAddress(payTo),
+        maxTimeoutSeconds,
+        extra: { ...extra, name, version: version2 }
+      },
+      ...extensions ? { extensions } : {}
+    };
+  } catch (error) {
+    if (error instanceof X402Error) throw error;
+    throw new X402Error(
+      "invalid_challenge",
+      "x402 challenge contains an invalid network or address.",
+      { cause: error }
+    );
+  }
+}
+async function parse402Response(response, configuredNetworks, requiredNetwork, expectedPayTo) {
+  const header = response.headers.get("payment-required");
+  let headerError;
+  if (header) {
+    try {
+      const quote = parse402Challenge(
+        decodeBase64Json(header),
+        configuredNetworks,
+        response.url,
+        requiredNetwork,
+        expectedPayTo
+      );
+      await response.body?.cancel().catch(() => void 0);
+      return quote;
+    } catch (error) {
+      headerError = error;
+    }
+  }
+  try {
+    return parse402Challenge(
+      await readBoundedJson(response, MAX_CHALLENGE_BYTES),
+      configuredNetworks,
+      response.url,
+      requiredNetwork,
+      expectedPayTo
+    );
+  } catch (error) {
+    if (headerError instanceof X402Error) throw headerError;
+    if (error instanceof X402Error) throw error;
+    throw new X402Error(
+      "invalid_challenge",
+      "x402 402 response has neither a valid payment-required header nor a JSON accepts[] body.",
+      { cause: error }
+    );
+  }
+}
+async function readBoundedJson(response, maximumBytes) {
+  if (!response.body) throw new Error("x402 response body is empty.");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const next = await reader.read();
+    if (next.done) break;
+    total += next.value.byteLength;
+    if (total > maximumBytes) {
+      await reader.cancel();
+      throw new Error(`x402 response exceeds ${maximumBytes} bytes.`);
+    }
+    chunks.push(next.value);
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+var MAX_AUTHORIZATION_WINDOW_SECONDS = 600;
+function buildEip3009TypedData(args) {
+  if (!/^0x[0-9a-fA-F]{64}$/.test(args.nonce)) {
+    throw new Error("EIP-3009 nonce must be a random 32-byte hex value.");
+  }
+  if (!Number.isSafeInteger(args.nowSeconds) || args.nowSeconds < 0) {
+    throw new Error("nowSeconds must be a non-negative integer.");
+  }
+  const windowSeconds = Math.min(
+    MAX_AUTHORIZATION_WINDOW_SECONDS,
+    args.quote.accepted.maxTimeoutSeconds
+  );
+  const authorization = {
+    from: getAddress(args.from),
+    to: args.quote.accepted.payTo,
+    value: args.quote.amountAtomic.toString(),
+    validAfter: "0",
+    validBefore: (args.nowSeconds + windowSeconds).toString(),
+    nonce: args.nonce
+  };
+  return {
+    authorization,
+    typedData: {
+      domain: {
+        name: args.quote.accepted.extra.name,
+        version: args.quote.accepted.extra.version,
+        chainId: parseEip155ChainId(args.quote.accepted.network),
+        verifyingContract: args.quote.accepted.asset
+      },
+      types: EIP3009_AUTHORIZATION_TYPES,
+      primaryType: "TransferWithAuthorization",
+      message: {
+        from: authorization.from,
+        to: authorization.to,
+        value: BigInt(authorization.value),
+        validAfter: 0n,
+        validBefore: BigInt(authorization.validBefore),
+        nonce: authorization.nonce
+      }
+    }
+  };
+}
+async function buildX402Payment(args) {
+  const nonce = args.nonce ?? randomNonce();
+  const { authorization, typedData } = buildEip3009TypedData({
+    from: args.signer.address,
+    quote: args.quote,
+    nonce,
+    nowSeconds: args.nowSeconds ?? Math.floor(Date.now() / 1e3)
+  });
+  const signature = await args.signer.signTypedData(typedData);
+  const payload = {
+    x402Version: 2,
+    resource: args.quote.resource,
+    accepted: args.quote.accepted,
+    payload: { signature, authorization },
+    ...args.quote.extensions ? { extensions: args.quote.extensions } : {}
+  };
+  return {
+    payload,
+    headers: {
+      "PAYMENT-SIGNATURE": encodeBase64Json(payload)
+    }
+  };
+}
+function assertMaxPrice(amountAtomic, maxPriceUsd) {
+  if (maxPriceUsd === void 0) return;
+  const maxAtomic = usdToAtomic(maxPriceUsd);
+  if (amountAtomic > maxAtomic) {
+    throw new X402Error(
+      "max_price_exceeded",
+      `x402 quote ${amountAtomic} atomic USDC exceeds maxPriceUsd ${maxPriceUsd} (${maxAtomic} atomic). Refusing to sign.`
+    );
+  }
+}
+function usdToAtomic(value) {
+  const normalized = typeof value === "number" ? String(value) : value.trim();
+  if (!/^\d+(?:\.\d{1,6})?$/.test(normalized)) {
+    throw new Error("maxPriceUsd must be a non-negative USD amount with at most 6 decimals.");
+  }
+  const [whole = "0", fraction = ""] = normalized.split(".");
+  return BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, "0"));
+}
+function parseSettlementResponse(headers) {
+  const encoded = headers.get("payment-response");
+  if (encoded) {
+    try {
+      return decodeBase64Json(encoded);
+    } catch {
+      return null;
+    }
+  }
+  const compatible = headers.get("x-payment-response");
+  if (!compatible) return null;
+  try {
+    return JSON.parse(compatible);
+  } catch {
+    try {
+      return decodeBase64Json(compatible);
+    } catch {
+      return null;
+    }
+  }
+}
+function classifySettlement(value) {
+  if (!isRecord(value) || typeof value.success !== "boolean") {
+    return "unknown";
+  }
+  return value.success ? "succeeded" : "rejected";
+}
+function parseEip155ChainId(network) {
+  const match = /^eip155:(\d+)$/.exec(network);
+  const chainId = match ? Number(match[1]) : Number.NaN;
+  if (!Number.isSafeInteger(chainId) || chainId <= 0) {
+    throw new Error(`Invalid EIP-155 network identifier: ${network}.`);
+  }
+  return chainId;
+}
+function randomNonce() {
+  const bytes = new Uint8Array(32);
+  globalThis.crypto.getRandomValues(bytes);
+  return bytesToHex(bytes);
+}
+function readAmount(value) {
+  const raw = value.amount ?? value.maxAmountRequired;
+  let parsed;
+  if (typeof raw === "string") {
+    if (raw.length === 0 || raw.length > 78 || !/^\d+$/.test(raw)) return null;
+    parsed = BigInt(raw);
+  } else if (typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0) {
+    parsed = BigInt(raw);
+  } else if (typeof raw === "bigint" && raw > 0n) {
+    parsed = raw;
+  } else {
+    return null;
+  }
+  if (parsed === 0n || parsed > MAX_UINT256) return null;
+  return parsed;
+}
+function readPositiveInteger(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value > 0) return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+  }
+  return null;
+}
+function canonicalTokenDomain(network, configured) {
+  const canonical = getCanonicalX402Usdc(network);
+  try {
+    if (canonical) {
+      return getAddress(configured.usdc) === canonical.usdc ? canonical.eip712Domain : null;
+    }
+  } catch {
+    return null;
+  }
+  const configuredDomain = configured.eip712Domain;
+  if (!configuredDomain?.name || !configuredDomain.version) return null;
+  return configuredDomain;
+}
+function readBoundedJsonRecord(value) {
+  if (!isRecord(value)) return null;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const budget = { entries: 0 };
+  try {
+    const cloned = cloneBoundedJson(value, 0, seen, budget);
+    return isRecord(cloned) ? cloned : null;
+  } catch {
+    return null;
+  }
+}
+function cloneBoundedJson(value, depth, seen, budget) {
+  if (depth > MAX_METADATA_DEPTH || budget.entries >= MAX_METADATA_ENTRIES) {
+    throw new Error("x402 metadata exceeds its structural limit.");
+  }
+  budget.entries += 1;
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    if (value.length > MAX_METADATA_STRING_LENGTH) {
+      throw new Error("x402 metadata string is too long.");
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("x402 metadata number must be finite.");
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new Error("x402 metadata must be JSON-compatible.");
+  }
+  if (seen.has(value)) throw new Error("x402 metadata must not contain cycles.");
+  seen.add(value);
+  if (Array.isArray(value)) {
+    if (value.length > MAX_METADATA_ARRAY_LENGTH) {
+      throw new Error("x402 metadata array is too long.");
+    }
+    return value.map((item) => cloneBoundedJson(item, depth + 1, seen, budget));
+  }
+  const keys = Object.keys(value);
+  if (keys.length > MAX_METADATA_KEYS_PER_OBJECT) {
+    throw new Error("x402 metadata object has too many keys.");
+  }
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) {
+    if (key.length > 256) throw new Error("x402 metadata key is too long.");
+    result[key] = cloneBoundedJson(
+      value[key],
+      depth + 1,
+      seen,
+      budget
+    );
+  }
+  return result;
+}
+function readResource(value, fallbackUrl) {
+  if (typeof value === "string") return { url: value };
+  if (!isRecord(value)) return { url: fallbackUrl };
+  const url = readString(value, "url") ?? fallbackUrl;
+  return {
+    url,
+    ...readString(value, "description") ? { description: readString(value, "description") } : {},
+    ...readString(value, "mimeType") ? { mimeType: readString(value, "mimeType") } : {},
+    ...readString(value, "serviceName") ? { serviceName: readString(value, "serviceName") } : {},
+    ...Array.isArray(value.tags) && value.tags.every((tag) => typeof tag === "string") ? { tags: value.tags } : {},
+    ...readString(value, "iconUrl") ? { iconUrl: readString(value, "iconUrl") } : {}
+  };
+}
+function readString(value, key) {
+  const field = value[key];
+  return typeof field === "string" && field.length > 0 ? field : null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function decodeBase64Json(value) {
+  const bytes = Uint8Array.from(globalThis.atob(value), (character) => character.charCodeAt(0));
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+function encodeBase64Json(value) {
+  const bytes = new TextEncoder().encode(JSON.stringify(value));
+  let binary = "";
+  for (let offset = 0; offset < bytes.length; offset += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+  }
+  return globalThis.btoa(binary);
+}
+
+// src/x402.ts
+function toSharedNetworks(networks) {
+  return Object.fromEntries(
+    Object.entries(networks).map(([network, configured]) => [
+      network,
+      {
+        usdc: configured.usdc,
+        enabled: Boolean(configured.rpcUrl.trim()),
+        ...configured.eip712Domain ? { eip712Domain: configured.eip712Domain } : {}
+      }
+    ])
+  );
+}
+function parse402Challenge2(challenge, configuredNetworks, fallbackResourceUrl = "", requiredNetwork, expectedPayTo) {
+  return parse402Challenge(
+    challenge,
+    toSharedNetworks(configuredNetworks),
+    fallbackResourceUrl,
+    requiredNetwork,
+    expectedPayTo
+  );
+}
+async function parse402Response2(response, configuredNetworks, requiredNetwork, expectedPayTo) {
+  return await parse402Response(
+    response,
+    toSharedNetworks(configuredNetworks),
+    requiredNetwork,
+    expectedPayTo
+  );
+}
+async function buildX402Payment2(args) {
+  const payment = await buildX402Payment({
+    signer: args.account,
+    quote: args.quote,
+    ...args.nowSeconds === void 0 ? {} : { nowSeconds: args.nowSeconds },
+    ...args.nonce === void 0 ? {} : { nonce: args.nonce }
+  });
+  return {
+    payload: payment.payload,
+    headers: {
+      ...payment.headers,
+      "X-PAYMENT": JSON.stringify({
+        x402Version: 2,
+        scheme: args.quote.accepted.scheme,
+        network: args.quote.accepted.network,
+        payload: payment.payload.payload
+      })
+    }
+  };
+}
+export {
+  EIP3009_AUTHORIZATION_TYPES,
+  X402Error,
+  assertMaxPrice,
+  buildEip3009TypedData,
+  buildX402Payment2 as buildX402Payment,
+  classifySettlement,
+  parse402Challenge2 as parse402Challenge,
+  parse402Response2 as parse402Response,
+  parseSettlementResponse,
+  usdToAtomic
+};
+//# sourceMappingURL=x402.js.map