@agent-score/commerce 2.5.0 → 2.6.1

package/dist/stripe-multichain/index.js

@@ -5,11 +5,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+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;
+  }
 };
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -101,7 +110,7 @@ var init_Errors = __esm({
         const docsBaseUrl = options.docsOrigin ?? _BaseError.prototype.docsOrigin;
         const docs = `${docsBaseUrl}${docsPath ?? ""}`;
         const showVersion = Boolean(options.version ?? _BaseError.prototype.showVersion);
-        const version3 = options.version ?? _BaseError.prototype.version;
+        const version4 = options.version ?? _BaseError.prototype.version;
         const message = [
           shortMessage || "An error occurred.",
           ...options.metaMessages ? ["", ...options.metaMessages] : [],
@@ -109,7 +118,7 @@ var init_Errors = __esm({
             "",
             details ? `Details: ${details}` : void 0,
             docsPath ? `See: ${docs}` : void 0,
-            showVersion ? `Version: ${version3}` : void 0
+            showVersion ? `Version: ${version4}` : void 0
           ] : []
         ].filter((x) => typeof x === "string").join("\n");
         super(message, options.cause ? { cause: options.cause } : void 0);
@@ -174,7 +183,7 @@ var init_Errors = __esm({
         this.docsPath = docsPath;
         this.shortMessage = shortMessage;
         this.showVersion = showVersion;
-        this.version = version3;
+        this.version = version4;
       }
       walk(fn) {
         return walk(this, fn);
@@ -304,16 +313,16 @@ var init_hmac = __esm({
         this.blockLen = this.iHash.blockLen;
         this.outputLen = this.iHash.outputLen;
         const blockLen = this.blockLen;
-        const pad3 = new Uint8Array(blockLen);
-        pad3.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
-        for (let i = 0; i < pad3.length; i++)
-          pad3[i] ^= 54;
-        this.iHash.update(pad3);
+        const pad4 = new Uint8Array(blockLen);
+        pad4.set(key.length > blockLen ? hash3.create().update(key).digest() : key);
+        for (let i = 0; i < pad4.length; i++)
+          pad4[i] ^= 54;
+        this.iHash.update(pad4);
         this.oHash = hash3.create();
-        for (let i = 0; i < pad3.length; i++)
-          pad3[i] ^= 54 ^ 92;
-        this.oHash.update(pad3);
-        clean(pad3);
+        for (let i = 0; i < pad4.length; i++)
+          pad4[i] ^= 54 ^ 92;
+        this.oHash.update(pad4);
+        clean(pad4);
       }
       update(buf) {
         aexists(this);
@@ -1052,19 +1061,19 @@ function charCodeToBase16(char) {
   return void 0;
 }
 function pad(bytes, options = {}) {
-  const { dir, size: size3 = 32 } = options;
-  if (size3 === 0)
+  const { dir, size: size4 = 32 } = options;
+  if (size4 === 0)
     return bytes;
-  if (bytes.length > size3)
+  if (bytes.length > size4)
     throw new SizeExceedsPaddingSizeError({
       size: bytes.length,
-      targetSize: size3,
+      targetSize: size4,
       type: "Bytes"
     });
-  const paddedBytes = new Uint8Array(size3);
-  for (let i = 0; i < size3; i++) {
+  const paddedBytes = new Uint8Array(size4);
+  for (let i = 0; i < size4; i++) {
     const padEnd = dir === "right";
-    paddedBytes[padEnd ? i : size3 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+    paddedBytes[padEnd ? i : size4 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
   }
   return paddedBytes;
 }
@@ -1123,17 +1132,17 @@ function assertEndOffset2(value, start, end) {
   }
 }
 function pad2(hex_, options = {}) {
-  const { dir, size: size3 = 32 } = options;
-  if (size3 === 0)
+  const { dir, size: size4 = 32 } = options;
+  if (size4 === 0)
     return hex_;
   const hex3 = hex_.replace("0x", "");
-  if (hex3.length > size3 * 2)
+  if (hex3.length > size4 * 2)
     throw new SizeExceedsPaddingSizeError2({
       size: Math.ceil(hex3.length / 2),
-      targetSize: size3,
+      targetSize: size4,
       type: "Hex"
     });
-  return `0x${hex3[dir === "right" ? "padEnd" : "padStart"](size3 * 2, "0")}`;
+  return `0x${hex3[dir === "right" ? "padEnd" : "padStart"](size4 * 2, "0")}`;
 }
 function trim2(value, options = {}) {
   const { dir = "left" } = options;
@@ -1290,14 +1299,14 @@ function fromBytes(value, options = {}) {
   return hex3;
 }
 function fromNumber(value, options = {}) {
-  const { signed, size: size3 } = options;
+  const { signed, size: size4 } = options;
   const value_ = BigInt(value);
   let maxValue;
-  if (size3) {
+  if (size4) {
     if (signed)
-      maxValue = (1n << BigInt(size3) * 8n - 1n) - 1n;
+      maxValue = (1n << BigInt(size4) * 8n - 1n) - 1n;
     else
-      maxValue = 2n ** (BigInt(size3) * 8n) - 1n;
+      maxValue = 2n ** (BigInt(size4) * 8n) - 1n;
   } else if (typeof value === "number") {
     maxValue = BigInt(Number.MAX_SAFE_INTEGER);
   }
@@ -1308,14 +1317,14 @@ function fromNumber(value, options = {}) {
       max: maxValue ? `${maxValue}${suffix}` : void 0,
       min: `${minValue}${suffix}`,
       signed,
-      size: size3,
+      size: size4,
       value: `${value}${suffix}`
     });
   }
-  const stringValue = (signed && value_ < 0 ? BigInt.asUintN(size3 * 8, BigInt(value_)) : value_).toString(16);
+  const stringValue = (signed && value_ < 0 ? BigInt.asUintN(size4 * 8, BigInt(value_)) : value_).toString(16);
   const hex3 = `0x${stringValue}`;
-  if (size3)
-    return padLeft(hex3, size3);
+  if (size4)
+    return padLeft(hex3, size4);
   return hex3;
 }
 function fromString(value, options = {}) {
@@ -1324,11 +1333,11 @@ function fromString(value, options = {}) {
 function isEqual(hexA, hexB) {
   return equalBytes(fromHex(hexA), fromHex(hexB));
 }
-function padLeft(value, size3) {
-  return pad2(value, { dir: "left", size: size3 });
+function padLeft(value, size4) {
+  return pad2(value, { dir: "left", size: size4 });
 }
-function padRight(value, size3) {
-  return pad2(value, { dir: "right", size: size3 });
+function padRight(value, size4) {
+  return pad2(value, { dir: "right", size: size4 });
 }
 function random2(length) {
   return fromBytes(random(length));
@@ -1357,8 +1366,8 @@ function toBigInt(hex3, options = {}) {
   const value = BigInt(hex3);
   if (!signed)
     return value;
-  const size3 = (hex3.length - 2) / 2;
-  const max_unsigned = (1n << BigInt(size3) * 8n) - 1n;
+  const size4 = (hex3.length - 2) / 2;
+  const max_unsigned = (1n << BigInt(size4) * 8n) - 1n;
   const max_signed = max_unsigned >> 1n;
   if (value <= max_signed)
     return value;
@@ -1378,16 +1387,16 @@ function toBytes2(hex3, options = {}) {
   return fromHex(hex3, options);
 }
 function toNumber(hex3, options = {}) {
-  const { signed, size: size3 } = options;
-  if (!signed && !size3)
+  const { signed, size: size4 } = options;
+  if (!signed && !size4)
     return Number(hex3);
   return Number(toBigInt(hex3, options));
 }
 function toString(hex3, options = {}) {
-  const { size: size3 } = options;
+  const { size: size4 } = options;
   let bytes = fromHex(hex3);
-  if (size3) {
-    assertSize(bytes, size3);
+  if (size4) {
+    assertSize(bytes, size4);
     bytes = trimRight(bytes);
   }
   return new TextDecoder().decode(bytes);
@@ -1414,8 +1423,8 @@ var init_Hex = __esm({
     encoder = /* @__PURE__ */ new TextEncoder();
     hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
     IntegerOutOfRangeError = class extends BaseError {
-      constructor({ max, min, signed, size: size3, value }) {
-        super(`Number \`${value}\` is not in safe${size3 ? ` ${size3 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
+      constructor({ max, min, signed, size: size4, value }) {
+        super(`Number \`${value}\` is not in safe${size4 ? ` ${size4 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -1492,8 +1501,8 @@ var init_Hex = __esm({
       }
     };
     SliceOffsetOutOfBoundsError2 = class extends BaseError {
-      constructor({ offset, position, size: size3 }) {
-        super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size3}\`).`);
+      constructor({ offset, position, size: size4 }) {
+        super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size4}\`).`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -1503,8 +1512,8 @@ var init_Hex = __esm({
       }
     };
     SizeExceedsPaddingSizeError2 = class extends BaseError {
-      constructor({ size: size3, targetSize, type }) {
-        super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size3}\`) exceeds padding size (\`${targetSize}\`).`);
+      constructor({ size: size4, targetSize, type }) {
+        super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size4}\`) exceeds padding size (\`${targetSize}\`).`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -1583,21 +1592,21 @@ function fromArray(value) {
   return value instanceof Uint8Array ? value : new Uint8Array(value);
 }
 function fromBoolean2(value, options = {}) {
-  const { size: size3 } = options;
+  const { size: size4 } = options;
   const bytes = new Uint8Array(1);
   bytes[0] = Number(value);
-  if (typeof size3 === "number") {
-    assertSize(bytes, size3);
-    return padLeft2(bytes, size3);
+  if (typeof size4 === "number") {
+    assertSize(bytes, size4);
+    return padLeft2(bytes, size4);
   }
   return bytes;
 }
 function fromHex(value, options = {}) {
-  const { size: size3 } = options;
+  const { size: size4 } = options;
   let hex3 = value;
-  if (size3) {
-    assertSize2(value, size3);
-    hex3 = padRight(value, size3);
+  if (size4) {
+    assertSize2(value, size4);
+    hex3 = padRight(value, size4);
   }
   let hexString = hex3.slice(2);
   if (hexString.length % 2)
@@ -1619,22 +1628,22 @@ function fromNumber2(value, options) {
   return fromHex(hex3);
 }
 function fromString2(value, options = {}) {
-  const { size: size3 } = options;
+  const { size: size4 } = options;
   const bytes = encoder2.encode(value);
-  if (typeof size3 === "number") {
-    assertSize(bytes, size3);
-    return padRight2(bytes, size3);
+  if (typeof size4 === "number") {
+    assertSize(bytes, size4);
+    return padRight2(bytes, size4);
   }
   return bytes;
 }
 function isEqual2(bytesA, bytesB) {
   return equalBytes(bytesA, bytesB);
 }
-function padLeft2(value, size3) {
-  return pad(value, { dir: "left", size: size3 });
+function padLeft2(value, size4) {
+  return pad(value, { dir: "left", size: size4 });
 }
-function padRight2(value, size3) {
-  return pad(value, { dir: "right", size: size3 });
+function padRight2(value, size4) {
+  return pad(value, { dir: "right", size: size4 });
 }
 function random(length) {
   return crypto.getRandomValues(new Uint8Array(length));
@@ -1651,17 +1660,17 @@ function slice2(value, start, end, options = {}) {
   return value_;
 }
 function toBigInt2(bytes, options = {}) {
-  const { size: size3 } = options;
-  if (typeof size3 !== "undefined")
-    assertSize(bytes, size3);
+  const { size: size4 } = options;
+  if (typeof size4 !== "undefined")
+    assertSize(bytes, size4);
   const hex3 = fromBytes(bytes, options);
   return toBigInt(hex3, options);
 }
 function toBoolean2(bytes, options = {}) {
-  const { size: size3 } = options;
+  const { size: size4 } = options;
   let bytes_ = bytes;
-  if (typeof size3 !== "undefined") {
-    assertSize(bytes_, size3);
+  if (typeof size4 !== "undefined") {
+    assertSize(bytes_, size4);
     bytes_ = trimLeft2(bytes_);
   }
   if (bytes_.length > 1 || bytes_[0] > 1)
@@ -1672,17 +1681,17 @@ function toHex(value, options = {}) {
   return fromBytes(value, options);
 }
 function toNumber2(bytes, options = {}) {
-  const { size: size3 } = options;
-  if (typeof size3 !== "undefined")
-    assertSize(bytes, size3);
+  const { size: size4 } = options;
+  if (typeof size4 !== "undefined")
+    assertSize(bytes, size4);
   const hex3 = fromBytes(bytes, options);
   return toNumber(hex3, options);
 }
 function toString2(bytes, options = {}) {
-  const { size: size3 } = options;
+  const { size: size4 } = options;
   let bytes_ = bytes;
-  if (typeof size3 !== "undefined") {
-    assertSize(bytes_, size3);
+  if (typeof size4 !== "undefined") {
+    assertSize(bytes_, size4);
     bytes_ = trimRight(bytes_);
   }
   return decoder.decode(bytes_);
@@ -1753,8 +1762,8 @@ var init_Bytes = __esm({
       }
     };
     SliceOffsetOutOfBoundsError = class extends BaseError {
-      constructor({ offset, position, size: size3 }) {
-        super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size3}\`).`);
+      constructor({ offset, position, size: size4 }) {
+        super(`Slice ${position === "start" ? "starting" : "ending"} at offset \`${offset}\` is out-of-bounds (size: \`${size4}\`).`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -1764,8 +1773,8 @@ var init_Bytes = __esm({
       }
     };
     SizeExceedsPaddingSizeError = class extends BaseError {
-      constructor({ size: size3, targetSize, type }) {
-        super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size3}\`) exceeds padding size (\`${targetSize}\`).`);
+      constructor({ size: size4, targetSize, type }) {
+        super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size4}\`) exceeds padding size (\`${targetSize}\`).`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -1835,7 +1844,7 @@ var init_lru = __esm({
   "node_modules/ox/_esm/core/internal/lru.js"() {
     "use strict";
     LruMap = class extends Map {
-      constructor(size3) {
+      constructor(size4) {
         super();
         Object.defineProperty(this, "maxSize", {
           enumerable: true,
@@ -1843,7 +1852,7 @@ var init_lru = __esm({
           writable: true,
           value: void 0
         });
-        this.maxSize = size3;
+        this.maxSize = size4;
       }
       get(key) {
         const value = super.get(key);
@@ -1904,11 +1913,11 @@ function assert3(value, options = {}) {
       });
   }
 }
-function checksum2(address2) {
-  if (checksum.has(address2))
-    return checksum.get(address2);
-  assert3(address2, { strict: false });
-  const hexAddress = address2.substring(2).toLowerCase();
+function checksum2(address3) {
+  if (checksum.has(address3))
+    return checksum.get(address3);
+  assert3(address3, { strict: false });
+  const hexAddress = address3.substring(2).toLowerCase();
   const hash3 = keccak256(fromString2(hexAddress), { as: "Bytes" });
   const characters = hexAddress.split("");
   for (let i = 0; i < 40; i += 2) {
@@ -1920,7 +1929,7 @@ function checksum2(address2) {
     }
   }
   const result = `0x${characters.join("")}`;
-  checksum.set(address2, result);
+  checksum.set(address3, result);
   return result;
 }
 var addressRegex, InvalidAddressError, InvalidInputError, InvalidChecksumError;
@@ -1933,8 +1942,8 @@ var init_Address = __esm({
     init_Hash();
     addressRegex = /^0x[a-fA-F0-9]{40}$/;
     InvalidAddressError = class extends BaseError {
-      constructor({ address: address2, cause }) {
-        super(`Address "${address2}" is invalid.`, {
+      constructor({ address: address3, cause }) {
+        super(`Address "${address3}" is invalid.`, {
           cause
         });
         Object.defineProperty(this, "name", {
@@ -2110,9 +2119,9 @@ var init_AbiParameters = __esm({
     (function(encodePacked2) {
       function encode2(type, value, isArray = false) {
         if (type === "address") {
-          const address2 = value;
-          assert3(address2);
-          return padLeft(address2.toLowerCase(), isArray ? 32 : 0);
+          const address3 = value;
+          assert3(address3);
+          return padLeft(address3.toLowerCase(), isArray ? 32 : 0);
         }
         if (type === "string")
           return fromString(value);
@@ -2123,18 +2132,18 @@ var init_AbiParameters = __esm({
         const intMatch = type.match(integerRegex);
         if (intMatch) {
           const [_type, baseType, bits = "256"] = intMatch;
-          const size3 = Number.parseInt(bits, 10) / 8;
+          const size4 = Number.parseInt(bits, 10) / 8;
           return fromNumber(value, {
-            size: isArray ? 32 : size3,
+            size: isArray ? 32 : size4,
             signed: baseType === "int"
           });
         }
         const bytesMatch = type.match(bytesRegex);
         if (bytesMatch) {
-          const [_type, size3] = bytesMatch;
-          if (Number.parseInt(size3, 10) !== (value.length - 2) / 2)
+          const [_type, size4] = bytesMatch;
+          if (Number.parseInt(size4, 10) !== (value.length - 2) / 2)
             throw new BytesSizeMismatchError({
-              expectedSize: Number.parseInt(size3, 10),
+              expectedSize: Number.parseInt(size4, 10),
               value
             });
           return padRight(value, isArray ? 32 : 0);
@@ -2289,7 +2298,7 @@ __export(Base64_exports, {
   toString: () => toString3
 });
 function fromBytes2(value, options = {}) {
-  const { pad: pad3 = true, url: url2 = false } = options;
+  const { pad: pad4 = true, url: url2 = false } = options;
   const encoded = new Uint8Array(Math.ceil(value.length / 3) * 4);
   for (let i = 0, j = 0; j < value.length; i += 4, j += 3) {
     const y = (value[j] << 16) + (value[j + 1] << 8) + (value[j + 2] | 0);
@@ -2301,9 +2310,9 @@ function fromBytes2(value, options = {}) {
   const k = value.length % 3;
   const end = Math.floor(value.length / 3) * 4 + (k && k + 1);
   let base643 = decoder2.decode(new Uint8Array(encoded.buffer, 0, end));
-  if (pad3 && k === 1)
+  if (pad4 && k === 1)
     base643 += "==";
-  if (pad3 && k === 2)
+  if (pad4 && k === 2)
     base643 += "=";
   if (url2)
     base643 = base643.replaceAll("+", "-").replaceAll("/", "_");
@@ -2317,8 +2326,8 @@ function fromString3(value, options = {}) {
 }
 function toBytes3(value) {
   const base643 = value.replace(/=+$/, "");
-  const size3 = base643.length;
-  const decoded = new Uint8Array(size3 + 3);
+  const size4 = base643.length;
+  const decoded = new Uint8Array(size4 + 3);
   encoder3.encodeInto(base643 + "===", decoded);
   for (let i = 0, j = 0; i < base643.length; i += 4, j += 3) {
     const x = (characterToInteger[decoded[i]] << 18) + (characterToInteger[decoded[i + 1]] << 12) + (characterToInteger[decoded[i + 2]] << 6) + characterToInteger[decoded[i + 3]];
@@ -2326,7 +2335,7 @@ function toBytes3(value) {
     decoded[j + 1] = x >> 8 & 255;
     decoded[j + 2] = x & 255;
   }
-  const decodedSize = (size3 >> 2) * 3 + (size3 % 4 && size3 % 4 - 1);
+  const decodedSize = (size4 >> 2) * 3 + (size4 % 4 && size4 % 4 - 1);
   return new Uint8Array(decoded.buffer, 0, decodedSize);
 }
 function toHex2(value) {
@@ -2608,8 +2617,8 @@ var init_Cbor = __esm({
       }
     };
     StringTooLargeError = class extends BaseError {
-      constructor({ size: size3 }) {
-        super(`String length exceeds maximum (4294967295): ${size3}`);
+      constructor({ size: size4 }) {
+        super(`String length exceeds maximum (4294967295): ${size4}`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -2619,8 +2628,8 @@ var init_Cbor = __esm({
       }
     };
     ArrayTooLargeError = class extends BaseError {
-      constructor({ size: size3 }) {
-        super(`Array length exceeds maximum (4294967295): ${size3}`);
+      constructor({ size: size4 }) {
+        super(`Array length exceeds maximum (4294967295): ${size4}`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -2630,8 +2639,8 @@ var init_Cbor = __esm({
       }
     };
     ObjectTooLargeError = class extends BaseError {
-      constructor({ size: size3 }) {
-        super(`Object size exceeds maximum (4294967295): ${size3}`);
+      constructor({ size: size4 }) {
+        super(`Object size exceeds maximum (4294967295): ${size4}`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -2641,8 +2650,8 @@ var init_Cbor = __esm({
       }
     };
     ByteStringTooLargeError = class extends BaseError {
-      constructor({ size: size3 }) {
-        super(`Byte string length exceeds maximum (4294967295): ${size3}`);
+      constructor({ size: size4 }) {
+        super(`Byte string length exceeds maximum (4294967295): ${size4}`);
         Object.defineProperty(this, "name", {
           enumerable: true,
           configurable: true,
@@ -2707,37 +2716,37 @@ var init_Cbor = __esm({
             };
           throw new NumberTooLargeError({ number: value.toString(10) });
         }
-        const positiveNumber = -1 - value;
+        const positiveNumber2 = -1 - value;
         if (value >= -24)
           return {
             length: 1,
-            encode: (cursor) => cursor.pushUint8(32 + positiveNumber)
+            encode: (cursor) => cursor.pushUint8(32 + positiveNumber2)
           };
-        if (positiveNumber <= 255)
+        if (positiveNumber2 <= 255)
           return {
             length: 2,
             // 1 byte prefix + 1 byte uint8
             encode: (cursor) => {
               cursor.pushUint8(56);
-              cursor.pushUint8(positiveNumber);
+              cursor.pushUint8(positiveNumber2);
             }
           };
-        if (positiveNumber <= 65535)
+        if (positiveNumber2 <= 65535)
           return {
             length: 3,
             // 1 byte prefix + 2 bytes uint16
             encode: (cursor) => {
               cursor.pushUint8(57);
-              cursor.pushUint16(positiveNumber);
+              cursor.pushUint16(positiveNumber2);
             }
           };
-        if (positiveNumber <= 4294967295)
+        if (positiveNumber2 <= 4294967295)
           return {
             length: 5,
             // 1 byte prefix + 4 bytes uint32
             encode: (cursor) => {
               cursor.pushUint8(58);
-              cursor.pushUint32(positiveNumber);
+              cursor.pushUint32(positiveNumber2);
             }
           };
         throw new NumberTooLargeError({ number: value.toString(10) });
@@ -2745,142 +2754,142 @@ var init_Cbor = __esm({
       getEncodable2.number = number4;
       function string4(value) {
         const encoded = fromString2(value);
-        const size3 = encoded.length;
-        if (size3 <= 23)
+        const size4 = encoded.length;
+        if (size4 <= 23)
           return {
-            length: 1 + size3,
+            length: 1 + size4,
             // 1 byte prefix + size bytes
             encode(cursor) {
-              cursor.pushUint8(96 + size3);
-              if (size3 > 0)
+              cursor.pushUint8(96 + size4);
+              if (size4 > 0)
                 cursor.pushBytes(encoded);
             }
           };
-        if (size3 <= 255)
+        if (size4 <= 255)
           return {
-            length: 2 + size3,
+            length: 2 + size4,
             // 1 byte prefix + 1 byte uint8 + size bytes
             encode(cursor) {
               cursor.pushUint8(120);
-              cursor.pushUint8(size3);
+              cursor.pushUint8(size4);
               cursor.pushBytes(encoded);
             }
           };
-        if (size3 <= 65535)
+        if (size4 <= 65535)
           return {
-            length: 3 + size3,
+            length: 3 + size4,
             // 1 byte prefix + 2 bytes uint16 + size bytes
             encode(cursor) {
               cursor.pushUint8(121);
-              cursor.pushUint16(size3);
+              cursor.pushUint16(size4);
               cursor.pushBytes(encoded);
             }
           };
-        if (size3 <= 4294967295)
+        if (size4 <= 4294967295)
           return {
-            length: 5 + size3,
+            length: 5 + size4,
             // 1 byte prefix + 4 bytes uint32 + size bytes
             encode(cursor) {
               cursor.pushUint8(122);
-              cursor.pushUint32(size3);
+              cursor.pushUint32(size4);
               cursor.pushBytes(encoded);
             }
           };
-        throw new StringTooLargeError({ size: size3 });
+        throw new StringTooLargeError({ size: size4 });
       }
       getEncodable2.string = string4;
       function array2(value) {
         const items = value.map((item) => getEncodable2(item));
         const bodyLength = items.reduce((acc, item) => acc + item.length, 0);
-        const size3 = value.length;
-        if (size3 <= 23)
+        const size4 = value.length;
+        if (size4 <= 23)
           return {
             length: 1 + bodyLength,
             // 1 byte prefix + body length
             encode(cursor) {
-              cursor.pushUint8(128 + size3);
+              cursor.pushUint8(128 + size4);
               for (const item of items)
                 item.encode(cursor);
             }
           };
-        if (size3 <= 255)
+        if (size4 <= 255)
           return {
             length: 2 + bodyLength,
             // 1 byte prefix + 1 byte uint8 + body length
             encode(cursor) {
               cursor.pushUint8(152);
-              cursor.pushUint8(size3);
+              cursor.pushUint8(size4);
               for (const item of items)
                 item.encode(cursor);
             }
           };
-        if (size3 <= 65535)
+        if (size4 <= 65535)
           return {
             length: 3 + bodyLength,
             // 1 byte prefix + 2 bytes uint16 + body length
             encode(cursor) {
               cursor.pushUint8(153);
-              cursor.pushUint16(size3);
+              cursor.pushUint16(size4);
               for (const item of items)
                 item.encode(cursor);
             }
           };
-        if (size3 <= 4294967295)
+        if (size4 <= 4294967295)
           return {
             length: 5 + bodyLength,
             // 1 byte prefix + 4 bytes uint32 + body length
             encode(cursor) {
               cursor.pushUint8(154);
-              cursor.pushUint32(size3);
+              cursor.pushUint32(size4);
               for (const item of items)
                 item.encode(cursor);
             }
           };
-        throw new ArrayTooLargeError({ size: size3 });
+        throw new ArrayTooLargeError({ size: size4 });
       }
       getEncodable2.array = array2;
       function byteString(value) {
-        const size3 = value.byteLength;
-        if (size3 <= 23)
+        const size4 = value.byteLength;
+        if (size4 <= 23)
           return {
-            length: 1 + size3,
+            length: 1 + size4,
             // 1 byte prefix + size bytes
             encode(cursor) {
-              cursor.pushUint8(64 + size3);
+              cursor.pushUint8(64 + size4);
               cursor.pushBytes(value);
             }
           };
-        if (size3 <= 255)
+        if (size4 <= 255)
           return {
-            length: 2 + size3,
+            length: 2 + size4,
             // 1 byte prefix + 1 byte uint8 + size bytes
             encode(cursor) {
               cursor.pushUint8(88);
-              cursor.pushUint8(size3);
+              cursor.pushUint8(size4);
               cursor.pushBytes(value);
             }
           };
-        if (size3 <= 65535)
+        if (size4 <= 65535)
           return {
-            length: 3 + size3,
+            length: 3 + size4,
             // 1 byte prefix + 2 bytes uint16 + size bytes
             encode(cursor) {
               cursor.pushUint8(89);
-              cursor.pushUint16(size3);
+              cursor.pushUint16(size4);
               cursor.pushBytes(value);
             }
           };
-        if (size3 <= 4294967295)
+        if (size4 <= 4294967295)
           return {
-            length: 5 + size3,
+            length: 5 + size4,
             // 1 byte prefix + 4 bytes uint32 + size bytes
             encode(cursor) {
               cursor.pushUint8(90);
-              cursor.pushUint32(size3);
+              cursor.pushUint32(size4);
               cursor.pushBytes(value);
             }
           };
-        throw new ByteStringTooLargeError({ size: size3 });
+        throw new ByteStringTooLargeError({ size: size4 });
       }
       getEncodable2.byteString = byteString;
       function object2(value) {
@@ -2890,59 +2899,59 @@ var init_Cbor = __esm({
           value: getEncodable2(value[key])
         }));
         const bodyLength = entries.reduce((acc, entry) => acc + entry.key.length + entry.value.length, 0);
-        const size3 = keys.length;
-        if (size3 <= 23)
+        const size4 = keys.length;
+        if (size4 <= 23)
           return {
             length: 1 + bodyLength,
             // 1 byte prefix + body length
             encode(cursor) {
-              cursor.pushUint8(160 + size3);
+              cursor.pushUint8(160 + size4);
               for (const entry of entries) {
                 entry.key.encode(cursor);
                 entry.value.encode(cursor);
               }
             }
           };
-        if (size3 <= 255)
+        if (size4 <= 255)
           return {
             length: 2 + bodyLength,
             // 1 byte prefix + 1 byte uint8 + body length
             encode(cursor) {
               cursor.pushUint8(184);
-              cursor.pushUint8(size3);
+              cursor.pushUint8(size4);
               for (const entry of entries) {
                 entry.key.encode(cursor);
                 entry.value.encode(cursor);
               }
             }
           };
-        if (size3 <= 65535)
+        if (size4 <= 65535)
           return {
             length: 3 + bodyLength,
             // 1 byte prefix + 2 bytes uint16 + body length
             encode(cursor) {
               cursor.pushUint8(185);
-              cursor.pushUint16(size3);
+              cursor.pushUint16(size4);
               for (const entry of entries) {
                 entry.key.encode(cursor);
                 entry.value.encode(cursor);
               }
             }
           };
-        if (size3 <= 4294967295)
+        if (size4 <= 4294967295)
           return {
             length: 5 + bodyLength,
             // 1 byte prefix + 4 bytes uint32 + body length
             encode(cursor) {
               cursor.pushUint8(186);
-              cursor.pushUint32(size3);
+              cursor.pushUint32(size4);
               for (const entry of entries) {
                 entry.key.encode(cursor);
                 entry.value.encode(cursor);
               }
             }
           };
-        throw new ObjectTooLargeError({ size: size3 });
+        throw new ObjectTooLargeError({ size: size4 });
       }
       getEncodable2.object = object2;
       function map2(value) {
@@ -2950,55 +2959,55 @@ var init_Cbor = __esm({
         for (const [k, v] of value)
           entries.push({ key: getEncodable2(k), value: getEncodable2(v) });
         const bodyLength = entries.reduce((acc, entry) => acc + entry.key.length + entry.value.length, 0);
-        const size3 = value.size;
-        if (size3 <= 23)
+        const size4 = value.size;
+        if (size4 <= 23)
           return {
             length: 1 + bodyLength,
             encode(cursor) {
-              cursor.pushUint8(160 + size3);
+              cursor.pushUint8(160 + size4);
               for (const entry of entries) {
                 entry.key.encode(cursor);
                 entry.value.encode(cursor);
               }
             }
           };
-        if (size3 <= 255)
+        if (size4 <= 255)
           return {
             length: 2 + bodyLength,
             encode(cursor) {
               cursor.pushUint8(184);
-              cursor.pushUint8(size3);
+              cursor.pushUint8(size4);
               for (const entry of entries) {
                 entry.key.encode(cursor);
                 entry.value.encode(cursor);
               }
             }
           };
-        if (size3 <= 65535)
+        if (size4 <= 65535)
           return {
             length: 3 + bodyLength,
             encode(cursor) {
               cursor.pushUint8(185);
-              cursor.pushUint16(size3);
+              cursor.pushUint16(size4);
               for (const entry of entries) {
                 entry.key.encode(cursor);
                 entry.value.encode(cursor);
               }
             }
           };
-        if (size3 <= 4294967295)
+        if (size4 <= 4294967295)
           return {
             length: 5 + bodyLength,
             encode(cursor) {
               cursor.pushUint8(186);
-              cursor.pushUint32(size3);
+              cursor.pushUint32(size4);
               for (const entry of entries) {
                 entry.key.encode(cursor);
                 entry.value.encode(cursor);
               }
             }
           };
-        throw new ObjectTooLargeError({ size: size3 });
+        throw new ObjectTooLargeError({ size: size4 });
       }
       getEncodable2.map = map2;
     })(getEncodable || (getEncodable = {}));
@@ -4434,6 +4443,60 @@ var init_BodyDigest = __esm({
   }
 });
 
+// node_modules/mppx/dist/Constants.js
+var Constants_exports = {};
+__export(Constants_exports, {
+  Headers: () => Headers,
+  Intents: () => Intents,
+  MethodDetailKeys: () => MethodDetailKeys,
+  Methods: () => Methods,
+  Schemes: () => Schemes,
+  SessionProtocols: () => SessionProtocols,
+  getMethodDetail: () => getMethodDetail
+});
+function getMethodDetail(methodDetails, key) {
+  if (!methodDetails || typeof methodDetails !== "object")
+    return void 0;
+  return methodDetails[key];
+}
+var Headers, Schemes, Methods, Intents, MethodDetailKeys, SessionProtocols;
+var init_Constants = __esm({
+  "node_modules/mppx/dist/Constants.js"() {
+    "use strict";
+    Headers = {
+      acceptPayment: "Accept-Payment",
+      authorization: "Authorization",
+      paymentReceipt: "Payment-Receipt",
+      paymentSession: "Payment-Session",
+      paymentSessionSnapshot: "Payment-Session-Snapshot",
+      wwwAuthenticate: "WWW-Authenticate"
+    };
+    Schemes = {
+      payment: "Payment"
+    };
+    Methods = {
+      evm: "evm",
+      stripe: "stripe",
+      tempo: "tempo"
+    };
+    Intents = {
+      charge: "charge",
+      session: "session",
+      subscription: "subscription"
+    };
+    MethodDetailKeys = {
+      sessionProtocol: "sessionProtocol",
+      sessionSnapshot: "sessionSnapshot"
+    };
+    SessionProtocols = {
+      /** Legacy contract-backed Tempo session protocol. */
+      v1: "v1",
+      /** TIP-1034 precompile-backed Tempo session protocol. */
+      v2: "v2"
+    };
+  }
+});
+
 // node_modules/mppx/dist/PaymentRequest.js
 var PaymentRequest_exports = {};
 __export(PaymentRequest_exports, {
@@ -5596,10 +5659,10 @@ var init_regexes = __esm({
     duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
     extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
     guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
-    uuid = (version3) => {
-      if (!version3)
+    uuid = (version4) => {
+      if (!version4)
         return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
-      return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version3}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+      return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version4}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
     };
     uuid4 = /* @__PURE__ */ uuid(4);
     uuid6 = /* @__PURE__ */ uuid(6);
@@ -5888,8 +5951,8 @@ var init_checks = __esm({
       });
       inst._zod.check = (payload) => {
         const input = payload.value;
-        const size3 = input.size;
-        if (size3 <= def.maximum)
+        const size4 = input.size;
+        if (size4 <= def.maximum)
           return;
         payload.issues.push({
           origin: getSizableOrigin(input),
@@ -5916,8 +5979,8 @@ var init_checks = __esm({
       });
       inst._zod.check = (payload) => {
         const input = payload.value;
-        const size3 = input.size;
-        if (size3 >= def.minimum)
+        const size4 = input.size;
+        if (size4 >= def.minimum)
           return;
         payload.issues.push({
           origin: getSizableOrigin(input),
@@ -5945,10 +6008,10 @@ var init_checks = __esm({
       });
       inst._zod.check = (payload) => {
         const input = payload.value;
-        const size3 = input.size;
-        if (size3 === def.size)
+        const size4 = input.size;
+        if (size4 === def.size)
           return;
-        const tooBig = size3 > def.size;
+        const tooBig = size4 > def.size;
         payload.issues.push({
           origin: getSizableOrigin(input),
           ...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size },
@@ -6997,7 +7060,7 @@ var init_schemas = __esm({
         try {
           if (parts.length !== 2)
             throw new Error();
-          const [address2, prefix] = parts;
+          const [address3, prefix] = parts;
           if (!prefix)
             throw new Error();
           const prefixNum = Number(prefix);
@@ -7005,7 +7068,7 @@ var init_schemas = __esm({
             throw new Error();
           if (prefixNum < 0 || prefixNum > 128)
             throw new Error();
-          new URL(`http://[${address2}]`);
+          new URL(`http://[${address3}]`);
         } catch {
           payload.issues.push({
             code: "invalid_format",
@@ -15358,11 +15421,11 @@ function _minSize(minimum, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _size(size3, params) {
+function _size(size4, params) {
   return new $ZodCheckSizeEquals({
     check: "size_equals",
     ...normalizeParams(params),
-    size: size3
+    size: size4
   });
 }
 // @__NO_SIDE_EFFECTS__
@@ -18776,7 +18839,7 @@ function fromMethod2(method, parameters) {
   const { description, digest, expires, id, meta: meta4, realm, secretKey } = parameters;
   const request = fromMethod(method, parameters.request);
   return from4({
-    ...id ? { id } : { secretKey },
+    ...id !== void 0 ? { id } : { secretKey },
     realm,
     method: methodName,
     intent,
@@ -18789,23 +18852,28 @@ function fromMethod2(method, parameters) {
 }
 function serialize2(challenge) {
   const parts = [
-    `id="${challenge.id}"`,
-    `realm="${challenge.realm}"`,
-    `method="${challenge.method}"`,
-    `intent="${challenge.intent}"`,
-    `request="${serialize(challenge.request)}"`
+    authParam("id", challenge.id),
+    authParam("realm", challenge.realm),
+    authParam("method", challenge.method),
+    authParam("intent", challenge.intent),
+    authParam("request", serialize(challenge.request))
   ];
   if (challenge.description !== void 0)
-    parts.push(`description="${challenge.description}"`);
+    parts.push(authParam("description", challenge.description));
   if (challenge.digest !== void 0)
-    parts.push(`digest="${challenge.digest}"`);
+    parts.push(authParam("digest", challenge.digest));
   if (challenge.expires !== void 0)
-    parts.push(`expires="${challenge.expires}"`);
+    parts.push(authParam("expires", challenge.expires));
   if (challenge.opaque !== void 0)
-    parts.push(`opaque="${challenge.opaque}"`);
+    parts.push(authParam("opaque", challenge.opaque));
   else if (challenge.meta !== void 0)
-    parts.push(`opaque="${serialize(challenge.meta)}"`);
-  return `Payment ${parts.join(", ")}`;
+    parts.push(authParam("opaque", serialize(challenge.meta)));
+  return `${Schemes.payment} ${parts.join(", ")}`;
+}
+function authParam(name, value) {
+  if (/[\r\n]/.test(value))
+    throw new Error("Invalid quoted-string value.");
+  return `${name}="${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 function deserialize2(value, options) {
   const params = extractPaymentAuthParams(value);
@@ -18815,6 +18883,8 @@ function deserialize2(value, options) {
   const { request, opaque, ...rest } = result;
   if (!request)
     throw new Error("Missing request parameter.");
+  if (request.length > maxRequestParameterLength)
+    throw new Error("Request parameter too large.");
   if (rest.method && !/^[a-z][a-z0-9:_-]*$/.test(rest.method))
     throw new Error(`Invalid method: "${rest.method}". Must be lowercase per spec.`);
   return from4({
@@ -18824,7 +18894,7 @@ function deserialize2(value, options) {
   }, options);
 }
 function extractPaymentAuthParams(header) {
-  const token = "Payment";
+  const token = Schemes.payment;
   let inQuotes = false;
   let escaped = false;
   for (let i = 0; i < header.length; i++) {
@@ -18893,23 +18963,30 @@ function readAuthParamValue(input, start) {
 }
 function readQuotedAuthParamValue(input, start) {
   let i = start;
-  let value = "";
   let escaped = false;
+  let segmentStart = start;
+  let parts;
   while (i < input.length) {
     const char = input[i];
     i++;
     if (escaped) {
-      value += char;
+      parts ??= [];
+      parts.push(char);
+      segmentStart = i;
       escaped = false;
       continue;
     }
     if (char === "\\") {
+      parts ??= [];
+      parts.push(input.slice(segmentStart, i - 1));
+      segmentStart = i;
       escaped = true;
       continue;
     }
-    if (char === '"')
+    if (char === '"') {
+      const value = parts ? [...parts, input.slice(segmentStart, i - 1)].join("") : input.slice(start, i - 1);
       return [value, i];
-    value += char;
+    }
   }
   throw new Error("Unterminated quoted-string.");
 }
@@ -18920,9 +18997,9 @@ function startsWithSchemeToken(value, index, token) {
   return Boolean(next && /\s/.test(next));
 }
 function fromHeaders(headers, options) {
-  const header = headers.get("WWW-Authenticate");
+  const header = headers.get(Headers.wwwAuthenticate);
   if (!header)
-    throw new Error("Missing WWW-Authenticate header.");
+    throw new Error(`Missing ${Headers.wwwAuthenticate} header.`);
   return deserialize2(header, options);
 }
 function fromResponse(response, options) {
@@ -18936,14 +19013,15 @@ function fromResponseList(response, options) {
   return fromHeadersList(response.headers, options);
 }
 function fromHeadersList(headers, options) {
-  const header = headers.get("WWW-Authenticate");
+  const header = headers.get(Headers.wwwAuthenticate);
   if (!header)
-    throw new Error("Missing WWW-Authenticate header.");
+    throw new Error(`Missing ${Headers.wwwAuthenticate} header.`);
   return deserializeList(header, options);
 }
 function deserializeList(value, options) {
   const starts = [];
-  for (const match of value.matchAll(/Payment\s+/gi)) {
+  const schemePattern = new RegExp(`${Schemes.payment}\\s+`, "gi");
+  for (const match of value.matchAll(schemePattern)) {
     starts.push(match.index);
   }
   if (starts.length === 0)
@@ -18979,14 +19057,16 @@ function computeId(challenge, options) {
   const mac3 = Hash_exports.hmac256(key, data, { as: "Bytes" });
   return Base64_exports.fromBytes(mac3, { url: true, pad: false });
 }
-var Schema;
+var maxRequestParameterLength, Schema;
 var init_Challenge = __esm({
   "node_modules/mppx/dist/Challenge.js"() {
     "use strict";
     init_esm2();
+    init_Constants();
     init_constantTimeEqual();
     init_PaymentRequest();
     init_zod();
+    maxRequestParameterLength = 16 * 1024;
     Schema = object({
       /** Optional human-readable description of the payment. */
       description: optional(string2()),
@@ -18995,7 +19075,7 @@ var init_Challenge = __esm({
       /** Optional expiration timestamp (ISO 8601). */
       expires: optional(datetime3()),
       /** Unique challenge identifier (HMAC-bound). */
-      id: string2(),
+      id: string2().check(_minLength(1)),
       /** Intent type (e.g., "charge", "session"). */
       intent: string2(),
       /** Payment method (e.g., "tempo", "stripe"). */
@@ -19025,7 +19105,7 @@ __export(Credential_exports, {
   serialize: () => serialize3
 });
 function deserialize3(value) {
-  const prefixMatch = value.match(/^Payment\s+(.+)$/i);
+  const prefixMatch = value.match(new RegExp(`^${Schemes.payment}\\s+(.+)$`, "i"));
   if (!prefixMatch?.[1])
     throw new MissingPaymentSchemeError();
   try {
@@ -19074,7 +19154,7 @@ function from5(parameters) {
   };
 }
 function fromRequest(request) {
-  const header = request.headers.get("Authorization");
+  const header = request.headers.get(Headers.authorization);
   if (!header)
     throw new MissingAuthorizationHeaderError();
   const payment = extractPaymentScheme(header);
@@ -19096,11 +19176,11 @@ function serialize3(credential) {
   };
   const json2 = JSON.stringify(wire);
   const encoded = Base64_exports.fromString(json2, { pad: false, url: true });
-  return `Payment ${encoded}`;
+  return `${Schemes.payment} ${encoded}`;
 }
 function extractPaymentScheme(header) {
-  const schemes = header.split(",").map((s) => s.trim());
-  return schemes.find((s) => /^Payment\s+/i.test(s)) ?? null;
+  const schemes2 = header.split(",").map((s) => s.trim());
+  return schemes2.find((s) => new RegExp(`^${Schemes.payment}\\s+`, "i").test(s)) ?? null;
 }
 var MissingAuthorizationHeaderError, MissingPaymentSchemeError, InvalidCredentialEncodingError;
 var init_Credential = __esm({
@@ -19108,6 +19188,7 @@ var init_Credential = __esm({
     "use strict";
     init_esm2();
     init_Challenge();
+    init_Constants();
     init_PaymentRequest();
     MissingAuthorizationHeaderError = class extends Error {
       name = "MissingAuthorizationHeaderError";
@@ -19138,6 +19219,7 @@ __export(Errors_exports2, {
   ChannelClosedError: () => ChannelClosedError,
   ChannelNotFoundError: () => ChannelNotFoundError,
   DeltaTooSmallError: () => DeltaTooSmallError,
+  Hints: () => Hints,
   InsufficientBalanceError: () => InsufficientBalanceError,
   InvalidChallengeError: () => InvalidChallengeError,
   InvalidPayloadError: () => InvalidPayloadError,
@@ -19152,13 +19234,20 @@ __export(Errors_exports2, {
   SignerMismatchError: () => SignerMismatchError,
   VerificationFailedError: () => VerificationFailedError
 });
-var PaymentError, MalformedCredentialError, InvalidChallengeError, VerificationFailedError, PaymentActionRequiredError, PaymentExpiredError, PaymentRequiredError, InvalidPayloadError, BadRequestError, PaymentInsufficientError, PaymentMethodUnsupportedError, InsufficientBalanceError, InvalidSignatureError, SignerMismatchError, AmountExceedsDepositError, DeltaTooSmallError, ChannelNotFoundError, ChannelClosedError;
+var Hints, PaymentError, MalformedCredentialError, InvalidChallengeError, VerificationFailedError, PaymentActionRequiredError, PaymentExpiredError, PaymentRequiredError, InvalidPayloadError, BadRequestError, PaymentInsufficientError, PaymentMethodUnsupportedError, InsufficientBalanceError, InvalidSignatureError, SignerMismatchError, AmountExceedsDepositError, DeltaTooSmallError, ChannelNotFoundError, ChannelClosedError;
 var init_Errors2 = __esm({
   "node_modules/mppx/dist/Errors.js"() {
     "use strict";
+    Hints = {
+      paymentRequired: "Use a supported wallet to pay for this resource using one of the supported payment methods returned in the WWW-Authenticate header. See https://mpp.dev/tools/wallet.md",
+      malformedCredential: "Use a supported wallet to construct valid credentials for one of the supported payment methods returned in the WWW-Authenticate header. See https://mpp.dev/tools/wallet.md",
+      methodUnsupported: "Use a supported wallet to pay for this resource using one of the supported payment methods returned in the WWW-Authenticate header. See https://mpp.dev/tools/wallet.md"
+    };
     PaymentError = class extends Error {
       /** HTTP status code. */
       status = 402;
+      /** Actionable hint for resolving the error (RFC 9457 extension member). */
+      hint;
       /** Converts the error to RFC 9457 Problem Details format. */
       toProblemDetails(challengeId) {
         return {
@@ -19166,6 +19255,7 @@ var init_Errors2 = __esm({
           title: this.title,
           status: this.status,
           detail: this.message,
+          ...this.hint && { hint: this.hint },
           ...challengeId && { challengeId }
         };
       }
@@ -19175,6 +19265,7 @@ var init_Errors2 = __esm({
       title = "Malformed Credential";
       status = 402;
       type = "https://paymentauth.org/problems/malformed-credential";
+      hint = Hints.malformedCredential;
       constructor(options = {}) {
         const { reason } = options;
         super(reason ? `Credential is malformed: ${reason}.` : "Credential is malformed.");
@@ -19223,6 +19314,7 @@ var init_Errors2 = __esm({
       name = "PaymentRequiredError";
       title = "Payment Required";
       type = "https://paymentauth.org/problems/payment-required";
+      hint = Hints.paymentRequired;
       constructor(options = {}) {
         const { description } = options;
         const parts = ["Payment is required"];
@@ -19264,6 +19356,7 @@ var init_Errors2 = __esm({
       title = "Method Unsupported";
       status = 400;
       type = "https://paymentauth.org/problems/method-unsupported";
+      hint = Hints.methodUnsupported;
       constructor(options = {}) {
         const { method } = options;
         super(method ? `Payment method "${method}" is not supported.` : "Payment method is not supported.");
@@ -19396,22 +19489,750 @@ var init_Expires = __esm({
   }
 });
 
-// node_modules/mppx/dist/Mcp.js
-var Mcp_exports = {};
-__export(Mcp_exports, {
-  credentialMetaKey: () => credentialMetaKey,
-  paymentRequiredCode: () => paymentRequiredCode,
-  paymentVerificationFailedCode: () => paymentVerificationFailedCode,
-  receiptMetaKey: () => receiptMetaKey
+// 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/viem/_esm/utils/data/isHex.js"() {
+    "use strict";
+  }
 });
-var paymentRequiredCode, paymentVerificationFailedCode, credentialMetaKey, receiptMetaKey;
-var init_Mcp = __esm({
-  "node_modules/mppx/dist/Mcp.js"() {
+
+// node_modules/viem/_esm/utils/data/size.js
+function size3(value) {
+  if (isHex(value, { strict: false }))
+    return Math.ceil((value.length - 2) / 2);
+  return value.length;
+}
+var init_size = __esm({
+  "node_modules/viem/_esm/utils/data/size.js"() {
     "use strict";
-    paymentRequiredCode = -32042;
-    paymentVerificationFailedCode = -32043;
-    credentialMetaKey = "org.paymentauth/credential";
-    receiptMetaKey = "org.paymentauth/receipt";
+    init_isHex();
+  }
+});
+
+// node_modules/viem/_esm/errors/version.js
+var version3;
+var init_version2 = __esm({
+  "node_modules/viem/_esm/errors/version.js"() {
+    "use strict";
+    version3 = "2.54.4";
+  }
+});
+
+// node_modules/viem/_esm/errors/base.js
+function walk2(err, fn) {
+  if (fn?.(err))
+    return err;
+  if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
+    return walk2(err.cause, fn);
+  return fn ? null : err;
+}
+var errorConfig, BaseError3;
+var init_base = __esm({
+  "node_modules/viem/_esm/errors/base.js"() {
+    "use strict";
+    init_version2();
+    errorConfig = {
+      getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
+      version: `viem@${version3}`
+    };
+    BaseError3 = 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 = version3;
+      }
+      walk(fn) {
+        return walk2(this, fn);
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/errors/data.js
+var SizeExceedsPaddingSizeError3;
+var init_data = __esm({
+  "node_modules/viem/_esm/errors/data.js"() {
+    "use strict";
+    init_base();
+    SizeExceedsPaddingSizeError3 = class extends BaseError3 {
+      constructor({ size: size4, targetSize, type }) {
+        super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size4}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/data/pad.js
+function pad3(hexOrBytes, { dir, size: size4 = 32 } = {}) {
+  if (typeof hexOrBytes === "string")
+    return padHex(hexOrBytes, { dir, size: size4 });
+  return padBytes(hexOrBytes, { dir, size: size4 });
+}
+function padHex(hex_, { dir, size: size4 = 32 } = {}) {
+  if (size4 === null)
+    return hex_;
+  const hex3 = hex_.replace("0x", "");
+  if (hex3.length > size4 * 2)
+    throw new SizeExceedsPaddingSizeError3({
+      size: Math.ceil(hex3.length / 2),
+      targetSize: size4,
+      type: "hex"
+    });
+  return `0x${hex3[dir === "right" ? "padEnd" : "padStart"](size4 * 2, "0")}`;
+}
+function padBytes(bytes, { dir, size: size4 = 32 } = {}) {
+  if (size4 === null)
+    return bytes;
+  if (bytes.length > size4)
+    throw new SizeExceedsPaddingSizeError3({
+      size: bytes.length,
+      targetSize: size4,
+      type: "bytes"
+    });
+  const paddedBytes = new Uint8Array(size4);
+  for (let i = 0; i < size4; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size4 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+  }
+  return paddedBytes;
+}
+var init_pad = __esm({
+  "node_modules/viem/_esm/utils/data/pad.js"() {
+    "use strict";
+    init_data();
+  }
+});
+
+// node_modules/viem/_esm/errors/encoding.js
+var IntegerOutOfRangeError2, SizeOverflowError3;
+var init_encoding = __esm({
+  "node_modules/viem/_esm/errors/encoding.js"() {
+    "use strict";
+    init_base();
+    IntegerOutOfRangeError2 = class extends BaseError3 {
+      constructor({ max, min, signed, size: size4, value }) {
+        super(`Number "${value}" is not in safe ${size4 ? `${size4 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+      }
+    };
+    SizeOverflowError3 = class extends BaseError3 {
+      constructor({ givenSize, maxSize }) {
+        super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/encoding/fromHex.js
+function assertSize3(hexOrBytes, { size: size4 }) {
+  if (size3(hexOrBytes) > size4)
+    throw new SizeOverflowError3({
+      givenSize: size3(hexOrBytes),
+      maxSize: size4
+    });
+}
+var init_fromHex = __esm({
+  "node_modules/viem/_esm/utils/encoding/fromHex.js"() {
+    "use strict";
+    init_encoding();
+    init_size();
+  }
+});
+
+// node_modules/viem/_esm/utils/encoding/toHex.js
+function toHex3(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 hex3 = `0x${Number(value)}`;
+  if (typeof opts.size === "number") {
+    assertSize3(hex3, { size: opts.size });
+    return pad3(hex3, { size: opts.size });
+  }
+  return hex3;
+}
+function bytesToHex(value, opts = {}) {
+  let string4 = "";
+  for (let i = 0; i < value.length; i++) {
+    string4 += hexes2[value[i]];
+  }
+  const hex3 = `0x${string4}`;
+  if (typeof opts.size === "number") {
+    assertSize3(hex3, { size: opts.size });
+    return pad3(hex3, { dir: "right", size: opts.size });
+  }
+  return hex3;
+}
+function numberToHex(value_, opts = {}) {
+  const { signed, size: size4 } = opts;
+  const value = BigInt(value_);
+  let maxValue;
+  if (size4) {
+    if (signed)
+      maxValue = (1n << BigInt(size4) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size4) * 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 IntegerOutOfRangeError2({
+      max: maxValue ? `${maxValue}${suffix}` : void 0,
+      min: `${minValue}${suffix}`,
+      signed,
+      size: size4,
+      value: `${value_}${suffix}`
+    });
+  }
+  const hex3 = `0x${(signed && value < 0 ? (1n << BigInt(size4 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size4)
+    return pad3(hex3, { size: size4 });
+  return hex3;
+}
+function stringToHex(value_, opts = {}) {
+  const value = encoder4.encode(value_);
+  return bytesToHex(value, opts);
+}
+var hexes2, encoder4;
+var init_toHex = __esm({
+  "node_modules/viem/_esm/utils/encoding/toHex.js"() {
+    "use strict";
+    init_encoding();
+    init_pad();
+    init_fromHex();
+    hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+    encoder4 = /* @__PURE__ */ new TextEncoder();
+  }
+});
+
+// node_modules/viem/_esm/utils/encoding/toBytes.js
+function toBytes4(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") {
+    assertSize3(bytes, { size: opts.size });
+    return pad3(bytes, { size: opts.size });
+  }
+  return bytes;
+}
+function charCodeToBase162(char) {
+  if (char >= charCodeMap2.zero && char <= charCodeMap2.nine)
+    return char - charCodeMap2.zero;
+  if (char >= charCodeMap2.A && char <= charCodeMap2.F)
+    return char - (charCodeMap2.A - 10);
+  if (char >= charCodeMap2.a && char <= charCodeMap2.f)
+    return char - (charCodeMap2.a - 10);
+  return void 0;
+}
+function hexToBytes(hex_, opts = {}) {
+  let hex3 = hex_;
+  if (opts.size) {
+    assertSize3(hex3, { size: opts.size });
+    hex3 = pad3(hex3, { dir: "right", size: opts.size });
+  }
+  let hexString = hex3.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 = charCodeToBase162(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase162(hexString.charCodeAt(j++));
+    if (nibbleLeft === void 0 || nibbleRight === void 0) {
+      throw new BaseError3(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes[index] = nibbleLeft * 16 + nibbleRight;
+  }
+  return bytes;
+}
+function numberToBytes(value, opts) {
+  const hex3 = numberToHex(value, opts);
+  return hexToBytes(hex3);
+}
+function stringToBytes(value, opts = {}) {
+  const bytes = encoder5.encode(value);
+  if (typeof opts.size === "number") {
+    assertSize3(bytes, { size: opts.size });
+    return pad3(bytes, { dir: "right", size: opts.size });
+  }
+  return bytes;
+}
+var encoder5, charCodeMap2;
+var init_toBytes = __esm({
+  "node_modules/viem/_esm/utils/encoding/toBytes.js"() {
+    "use strict";
+    init_base();
+    init_isHex();
+    init_pad();
+    init_fromHex();
+    init_toHex();
+    encoder5 = /* @__PURE__ */ new TextEncoder();
+    charCodeMap2 = {
+      zero: 48,
+      nine: 57,
+      A: 65,
+      F: 70,
+      a: 97,
+      f: 102
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/hash/keccak256.js
+function keccak2562(value, to_) {
+  const to = to_ || "hex";
+  const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes4(value) : value);
+  if (to === "bytes")
+    return bytes;
+  return toHex3(bytes);
+}
+var init_keccak256 = __esm({
+  "node_modules/viem/_esm/utils/hash/keccak256.js"() {
+    "use strict";
+    init_sha3();
+    init_isHex();
+    init_toBytes();
+    init_toHex();
+  }
+});
+
+// node_modules/viem/_esm/errors/address.js
+var InvalidAddressError2;
+var init_address = __esm({
+  "node_modules/viem/_esm/errors/address.js"() {
+    "use strict";
+    init_base();
+    InvalidAddressError2 = class extends BaseError3 {
+      constructor({ address: address3 }) {
+        super(`Address "${address3}" 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/viem/_esm/utils/lru.js
+var LruMap2;
+var init_lru2 = __esm({
+  "node_modules/viem/_esm/utils/lru.js"() {
+    "use strict";
+    LruMap2 = class extends Map {
+      constructor(size4) {
+        super();
+        Object.defineProperty(this, "maxSize", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        this.maxSize = size4;
+      }
+      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/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 hash3 = keccak2562(stringToBytes(hexAddress), "bytes");
+  const address3 = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
+  for (let i = 0; i < 40; i += 2) {
+    if (hash3[i >> 1] >> 4 >= 8 && address3[i]) {
+      address3[i] = address3[i].toUpperCase();
+    }
+    if ((hash3[i >> 1] & 15) >= 8 && address3[i + 1]) {
+      address3[i + 1] = address3[i + 1].toUpperCase();
+    }
+  }
+  const result = `0x${address3.join("")}`;
+  checksumAddressCache.set(`${address_}.${chainId}`, result);
+  return result;
+}
+function getAddress(address3, chainId) {
+  if (!isAddress(address3, { strict: false }))
+    throw new InvalidAddressError2({ address: address3 });
+  return checksumAddress(address3, chainId);
+}
+var checksumAddressCache;
+var init_getAddress = __esm({
+  "node_modules/viem/_esm/utils/address/getAddress.js"() {
+    "use strict";
+    init_address();
+    init_toBytes();
+    init_keccak256();
+    init_lru2();
+    init_isAddress();
+    checksumAddressCache = /* @__PURE__ */ new LruMap2(8192);
+  }
+});
+
+// node_modules/viem/_esm/utils/address/isAddress.js
+function isAddress(address3, options) {
+  const { strict = true } = options ?? {};
+  const cacheKey = `${address3}.${strict}`;
+  if (isAddressCache.has(cacheKey))
+    return isAddressCache.get(cacheKey);
+  const result = (() => {
+    if (!addressRegex2.test(address3))
+      return false;
+    if (address3.toLowerCase() === address3)
+      return true;
+    if (strict)
+      return checksumAddress(address3) === address3;
+    return true;
+  })();
+  isAddressCache.set(cacheKey, result);
+  return result;
+}
+var addressRegex2, isAddressCache;
+var init_isAddress = __esm({
+  "node_modules/viem/_esm/utils/address/isAddress.js"() {
+    "use strict";
+    init_lru2();
+    init_getAddress();
+    addressRegex2 = /^0x[a-fA-F0-9]{40}$/;
+    isAddressCache = /* @__PURE__ */ new LruMap2(8192);
+  }
+});
+
+// node_modules/viem/_esm/errors/unit.js
+var InvalidDecimalNumberError;
+var init_unit = __esm({
+  "node_modules/viem/_esm/errors/unit.js"() {
+    "use strict";
+    init_base();
+    InvalidDecimalNumberError = class extends BaseError3 {
+      constructor({ value }) {
+        super(`Number \`${value}\` is not a valid decimal number.`, {
+          name: "InvalidDecimalNumberError"
+        });
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/unit/parseUnits.js
+function parseUnits(value, decimals) {
+  if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
+    throw new InvalidDecimalNumberError({ value });
+  let [integer2, fraction = "0"] = value.split(".");
+  const negative = integer2.startsWith("-");
+  if (negative)
+    integer2 = integer2.slice(1);
+  fraction = fraction.replace(/(0+)$/, "");
+  if (decimals === 0) {
+    if (Math.round(Number(`.${fraction}`)) === 1)
+      integer2 = `${BigInt(integer2) + 1n}`;
+    fraction = "";
+  } else if (fraction.length > decimals) {
+    const [left, unit, right] = [
+      fraction.slice(0, decimals - 1),
+      fraction.slice(decimals - 1, decimals),
+      fraction.slice(decimals)
+    ];
+    const rounded = Math.round(Number(`${unit}.${right}`));
+    if (rounded > 9)
+      fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
+    else
+      fraction = `${left}${rounded}`;
+    if (fraction.length > decimals) {
+      fraction = fraction.slice(1);
+      integer2 = `${BigInt(integer2) + 1n}`;
+    }
+    fraction = fraction.slice(0, decimals);
+  } else {
+    fraction = fraction.padEnd(decimals, "0");
+  }
+  return BigInt(`${negative ? "-" : ""}${integer2}${fraction}`);
+}
+var init_parseUnits = __esm({
+  "node_modules/viem/_esm/utils/unit/parseUnits.js"() {
+    "use strict";
+    init_unit();
+  }
+});
+
+// node_modules/viem/_esm/index.js
+var init_esm3 = __esm({
+  "node_modules/viem/_esm/index.js"() {
+    "use strict";
+    init_getAddress();
+    init_parseUnits();
+  }
+});
+
+// node_modules/mppx/dist/x402/Assets.js
+var Assets_exports = {};
+__export(Assets_exports, {
+  base: () => base,
+  baseSepolia: () => baseSepolia,
+  define: () => define,
+  fromToken: () => fromToken,
+  isAsset: () => isAsset,
+  isRawAddress: () => isRawAddress,
+  isToken: () => isToken,
+  matches: () => matches,
+  resolve: () => resolve,
+  toChainId: () => toChainId,
+  toNetwork: () => toNetwork
+});
+function define(parameters) {
+  return {
+    [knownAsset]: true,
+    address: parameters.address,
+    decimals: parameters.decimals,
+    network: parameters.network,
+    transfer: parameters.transfer
+  };
+}
+function fromToken(token, parameters) {
+  const resolved = token(parameters.chainId);
+  return define({
+    address: resolved.address,
+    decimals: resolved.decimals,
+    network: toNetwork(parameters.chainId),
+    transfer: withTokenDefaults(parameters.transfer, resolved)
+  });
+}
+function isAsset(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  return value[knownAsset] === true;
+}
+function isToken(value) {
+  return typeof value === "function" && typeof value.addresses === "object" && typeof value.decimals === "number";
+}
+function isRawAddress(currency) {
+  return typeof currency === "string";
+}
+function resolve(currency, network) {
+  if (isAsset(currency)) {
+    if (currency.network !== network)
+      return void 0;
+    return {
+      address: currency.address,
+      decimals: currency.decimals,
+      transfer: currency.transfer
+    };
+  }
+  if (isToken(currency)) {
+    const address3 = currency.addresses[toChainId(network)];
+    if (!address3)
+      return void 0;
+    return {
+      address: address3,
+      decimals: currency.decimals,
+      name: currency.name
+    };
+  }
+  return {
+    address: currency
+  };
+}
+function matches(currency, acceptedCurrency, network) {
+  const resolved = resolve(currency, network);
+  if (!resolved)
+    return false;
+  return getAddress(resolved.address) === getAddress(acceptedCurrency);
+}
+function toNetwork(chainId) {
+  return `eip155:${chainId}`;
+}
+function toChainId(network) {
+  return Number(network.slice("eip155:".length));
+}
+function withTokenDefaults(transfer, token) {
+  if (transfer.type !== "eip3009")
+    return transfer;
+  if (transfer.name)
+    return { ...transfer, name: transfer.name };
+  if (!token.name)
+    throw new Error("EIP-3009 token assets require a token name.");
+  return {
+    ...transfer,
+    name: token.name
+  };
+}
+var knownAsset, base, baseSepolia;
+var init_Assets = __esm({
+  "node_modules/mppx/dist/x402/Assets.js"() {
+    "use strict";
+    init_esm3();
+    knownAsset = /* @__PURE__ */ Symbol("mppx.x402.asset");
+    base = {
+      USDC: define({
+        address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        decimals: 6,
+        network: "eip155:8453",
+        transfer: {
+          // USDC's EIP-712 domain name differs between Base and Base Sepolia.
+          name: "USD Coin",
+          type: "eip3009",
+          version: "2"
+        }
+      })
+    };
+    baseSepolia = {
+      USDC: define({
+        address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        decimals: 6,
+        network: "eip155:84532",
+        transfer: {
+          // Base Sepolia test USDC signs with the shorter EIP-712 domain name.
+          name: "USDC",
+          type: "eip3009",
+          version: "2"
+        }
+      })
+    };
+  }
+});
+
+// node_modules/mppx/dist/evm/Assets.js
+var Assets_exports2 = {};
+__export(Assets_exports2, {
+  base: () => base,
+  baseSepolia: () => baseSepolia,
+  define: () => define,
+  fromToken: () => fromToken,
+  isAsset: () => isAsset,
+  isRawAddress: () => isRawAddress,
+  isToken: () => isToken,
+  matches: () => matches,
+  resolve: () => resolve,
+  toChainId: () => toChainId,
+  toNetwork: () => toNetwork
+});
+var init_Assets2 = __esm({
+  "node_modules/mppx/dist/evm/Assets.js"() {
+    "use strict";
+    init_Assets();
+  }
+});
+
+// node_modules/mppx/dist/evm/Chains.js
+var Chains_exports = {};
+__export(Chains_exports, {
+  base: () => base2,
+  baseSepolia: () => baseSepolia2
+});
+var base2, baseSepolia2;
+var init_Chains = __esm({
+  "node_modules/mppx/dist/evm/Chains.js"() {
+    "use strict";
+    base2 = 8453;
+    baseSepolia2 = 84532;
   }
 });
 
@@ -19426,21 +20247,24 @@ function from6(method) {
   return method;
 }
 function toClient(method, options) {
-  const { context, createCredential } = options;
+  const { canHandleChallenge, context, createCredential } = options;
   return {
     ...method,
+    canHandleChallenge,
     context,
     createCredential
   };
 }
 function toServer(method, options) {
-  const { authorize, defaults, extensions, html, request, respond, stableBinding, transport, verify: verify3 } = options;
+  const { alias, authorize, defaults, extensions, html, preflight, request, respond, stableBinding, transport, verify: verify3 } = options;
   return {
     ...method,
+    alias,
     authorize,
     defaults,
     extensions,
     html,
+    preflight,
     request,
     respond,
     stableBinding,
@@ -19454,6 +20278,218 @@ var init_Method = __esm({
   }
 });
 
+// node_modules/mppx/dist/evm/Types.js
+var Types_exports = {};
+__export(Types_exports, {
+  AuthorizationConfigSchema: () => AuthorizationConfigSchema,
+  AuthorizationPayloadSchema: () => AuthorizationPayloadSchema,
+  ChargePayloadSchema: () => ChargePayloadSchema,
+  ChargeRequestInputSchema: () => ChargeRequestInputSchema,
+  ChargeRequestSchema: () => ChargeRequestSchema,
+  MethodDetailsSchema: () => MethodDetailsSchema,
+  authorizationDomain: () => authorizationDomain,
+  authorizationTypes: () => authorizationTypes,
+  challengeHash: () => challengeHash,
+  chargeIntent: () => chargeIntent,
+  credentialTypes: () => credentialTypes,
+  eip3009: () => eip3009,
+  evmNetworkPrefix: () => evmNetworkPrefix,
+  networkOf: () => networkOf,
+  paymentMethod: () => paymentMethod,
+  toSource: () => toSource
+});
+function authorizationDomain(parameters) {
+  return {
+    chainId: parameters.chainId,
+    name: parameters.authorization.name,
+    verifyingContract: parameters.currency,
+    version: parameters.authorization.version
+  };
+}
+function challengeHash(challenge) {
+  return Hash_exports.keccak256(Bytes_exports.fromString(`${challenge.id}${challenge.realm}`), {
+    as: "Hex"
+  });
+}
+function networkOf(chainId) {
+  return `${evmNetworkPrefix}${chainId}`;
+}
+function toSource(parameters) {
+  return `did:pkh:eip155:${parameters.chainId}:${parameters.address}`;
+}
+var paymentMethod, chargeIntent, evmNetworkPrefix, eip3009, credentialTypes, atomicAmount, AuthorizationConfigSchema, MethodDetailsSchema, ChargeRequestSchema, ChargeRequestInputSchema, AuthorizationPayloadSchema, ChargePayloadSchema, authorizationTypes;
+var init_Types = __esm({
+  "node_modules/mppx/dist/evm/Types.js"() {
+    "use strict";
+    init_esm2();
+    init_zod();
+    paymentMethod = "evm";
+    chargeIntent = "charge";
+    evmNetworkPrefix = "eip155:";
+    eip3009 = "eip3009";
+    credentialTypes = ["authorization"];
+    atomicAmount = string2().check(_regex(/^\d+$/, "Invalid atomic amount"));
+    AuthorizationConfigSchema = object({
+      name: string2().check(_minLength(1)),
+      version: string2().check(_minLength(1))
+    });
+    MethodDetailsSchema = object({
+      chainId: number2(),
+      credentialTypes: optional(array(_enum2(credentialTypes)).check(_minLength(1))),
+      decimals: optional(number2()),
+      permit2Address: optional(address()),
+      splits: optional(array(object({
+        amount: atomicAmount,
+        recipient: address()
+      })))
+    });
+    ChargeRequestSchema = object({
+      amount: atomicAmount,
+      currency: address(),
+      description: optional(string2()),
+      externalId: optional(string2()),
+      methodDetails: MethodDetailsSchema,
+      recipient: address()
+    });
+    ChargeRequestInputSchema = object({
+      amount: amount(),
+      chainId: number2(),
+      currency: address(),
+      credentialTypes: optional(array(_enum2(credentialTypes)).check(_minLength(1))),
+      decimals: number2(),
+      description: optional(string2()),
+      externalId: optional(string2()),
+      permit2Address: optional(address()),
+      recipient: address(),
+      splits: optional(array(object({
+        amount: atomicAmount,
+        recipient: address()
+      })))
+    });
+    AuthorizationPayloadSchema = object({
+      from: address(),
+      nonce: hash2(),
+      signature: signature(),
+      to: address(),
+      type: literal("authorization"),
+      validAfter: atomicAmount,
+      validBefore: atomicAmount,
+      value: atomicAmount
+    });
+    ChargePayloadSchema = AuthorizationPayloadSchema;
+    authorizationTypes = {
+      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" }
+      ]
+    };
+  }
+});
+
+// node_modules/mppx/dist/evm/Methods.js
+var Methods_exports = {};
+__export(Methods_exports, {
+  charge: () => charge
+});
+var charge;
+var init_Methods = __esm({
+  "node_modules/mppx/dist/evm/Methods.js"() {
+    "use strict";
+    init_esm3();
+    init_Method();
+    init_zod();
+    init_Types();
+    charge = from6({
+      name: paymentMethod,
+      intent: chargeIntent,
+      schema: {
+        credential: {
+          payload: ChargePayloadSchema
+        },
+        request: pipe(ChargeRequestInputSchema, transform(({ amount: amount2, chainId, credentialTypes: credentialTypes2 = ["authorization"], currency, decimals, permit2Address, recipient, splits, ...request }) => ({
+          ...request,
+          amount: parseUnits(amount2, decimals).toString(),
+          currency: getAddress(currency),
+          methodDetails: {
+            chainId,
+            credentialTypes: credentialTypes2,
+            decimals,
+            ...permit2Address ? { permit2Address: getAddress(permit2Address) } : {},
+            ...splits ? { splits } : {}
+          },
+          recipient: getAddress(recipient)
+        })))
+      }
+    });
+  }
+});
+
+// node_modules/mppx/dist/evm/index.js
+var evm_exports = {};
+__export(evm_exports, {
+  Assets: () => Assets_exports2,
+  AuthorizationConfigSchema: () => AuthorizationConfigSchema,
+  AuthorizationPayloadSchema: () => AuthorizationPayloadSchema,
+  Chains: () => Chains_exports,
+  ChargePayloadSchema: () => ChargePayloadSchema,
+  ChargeRequestInputSchema: () => ChargeRequestInputSchema,
+  ChargeRequestSchema: () => ChargeRequestSchema,
+  MethodDetailsSchema: () => MethodDetailsSchema,
+  Methods: () => Methods_exports,
+  Types: () => Types_exports,
+  assets: () => Assets_exports2,
+  authorizationDomain: () => authorizationDomain,
+  authorizationTypes: () => authorizationTypes,
+  chains: () => Chains_exports,
+  challengeHash: () => challengeHash,
+  charge: () => charge,
+  chargeIntent: () => chargeIntent,
+  credentialTypes: () => credentialTypes,
+  eip3009: () => eip3009,
+  evmNetworkPrefix: () => evmNetworkPrefix,
+  networkOf: () => networkOf,
+  paymentMethod: () => paymentMethod,
+  toSource: () => toSource
+});
+var init_evm = __esm({
+  "node_modules/mppx/dist/evm/index.js"() {
+    "use strict";
+    init_Assets2();
+    init_Chains();
+    init_Methods();
+    init_Types();
+    init_Assets2();
+    init_Chains();
+    init_Methods();
+    init_Types();
+  }
+});
+
+// node_modules/mppx/dist/Mcp.js
+var Mcp_exports = {};
+__export(Mcp_exports, {
+  credentialMetaKey: () => credentialMetaKey,
+  paymentRequiredCode: () => paymentRequiredCode,
+  paymentRequiredMetaKey: () => paymentRequiredMetaKey,
+  paymentVerificationFailedCode: () => paymentVerificationFailedCode,
+  receiptMetaKey: () => receiptMetaKey
+});
+var paymentRequiredCode, paymentVerificationFailedCode, credentialMetaKey, paymentRequiredMetaKey, receiptMetaKey;
+var init_Mcp = __esm({
+  "node_modules/mppx/dist/Mcp.js"() {
+    "use strict";
+    paymentRequiredCode = -32042;
+    paymentVerificationFailedCode = -32043;
+    credentialMetaKey = "org.paymentauth/credential";
+    paymentRequiredMetaKey = "org.paymentauth/payment-required";
+    receiptMetaKey = "org.paymentauth/receipt";
+  }
+});
+
 // node_modules/mppx/dist/Receipt.js
 var Receipt_exports = {};
 __export(Receipt_exports, {
@@ -19475,9 +20511,9 @@ function serialize4(receipt) {
   return Base64_exports.fromString(json2, { pad: false, url: true });
 }
 function fromResponse2(response) {
-  const header = response.headers.get("Payment-Receipt");
+  const header = response.headers.get(Headers.paymentReceipt);
   if (!header)
-    throw new Error("Missing Payment-Receipt header.");
+    throw new Error(`Missing ${Headers.paymentReceipt} header.`);
   return deserialize4(header);
 }
 var Schema2;
@@ -19485,6 +20521,7 @@ var init_Receipt = __esm({
   "node_modules/mppx/dist/Receipt.js"() {
     "use strict";
     init_esm2();
+    init_Constants();
     init_zod();
     Schema2 = object({
       /** Payment method used (e.g., "tempo", "stripe"). */
@@ -19512,8 +20549,37 @@ __export(Store_exports, {
   redis: () => redis,
   upstash: () => upstash
 });
-function from8(store) {
-  return store;
+function from8(store, options) {
+  return withKeyPrefix(store, options?.keyPrefix);
+}
+function withKeyPrefix(store, keyPrefix = "") {
+  if (!keyPrefix)
+    return store;
+  const cached2 = keyPrefixCache.get(store)?.get(keyPrefix);
+  if (cached2)
+    return cached2;
+  const backing = store;
+  const prefixedKey = (key) => `${keyPrefix}${key}`;
+  const prefixed = from8({
+    async get(key) {
+      return backing.get(prefixedKey(key));
+    },
+    async put(key, value) {
+      await backing.put(prefixedKey(key), value);
+    },
+    async delete(key) {
+      await backing.delete(prefixedKey(key));
+    },
+    ..."update" in store ? {
+      async update(key, fn) {
+        return store.update(prefixedKey(key), fn);
+      }
+    } : {}
+  });
+  const cachedByPrefix = keyPrefixCache.get(store) ?? /* @__PURE__ */ new Map();
+  cachedByPrefix.set(keyPrefix, prefixed);
+  keyPrefixCache.set(store, cachedByPrefix);
+  return prefixed;
 }
 function wrapJsonUpdate(update) {
   if (!update)
@@ -19530,7 +20596,7 @@ function wrapJsonUpdate(update) {
     }
   };
 }
-function cloudflare(kv) {
+function cloudflare(kv, options) {
   return from8({
     async get(key) {
       const raw = await kv.get(key);
@@ -19545,9 +20611,9 @@ function cloudflare(kv) {
       await kv.delete(key);
     },
     ...wrapJsonUpdate(kv.update)
-  });
+  }, options);
 }
-function memory() {
+function memory(options) {
   const store = /* @__PURE__ */ new Map();
   return from8({
     async get(key) {
@@ -19571,9 +20637,9 @@ function memory() {
         store.delete(key);
       return change.result;
     }
-  });
+  }, options);
 }
-function redis(client) {
+function redis(client, options) {
   return from8({
     async get(key) {
       const raw = await client.get(key);
@@ -19588,9 +20654,9 @@ function redis(client) {
       await client.del(key);
     },
     ...wrapJsonUpdate(client.update)
-  });
+  }, options);
 }
-function upstash(redis2) {
+function upstash(redis2, options) {
   return from8({
     async get(key) {
       return await redis2.get(key);
@@ -19604,12 +20670,288 @@ function upstash(redis2) {
     ...redis2.update ? {
       update: redis2.update
     } : {}
-  });
+  }, options);
 }
+var keyPrefixCache;
 var init_Store = __esm({
   "node_modules/mppx/dist/Store.js"() {
     "use strict";
     init_esm2();
+    keyPrefixCache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// node_modules/mppx/dist/internal/HeaderCodec.js
+function createJson(schema) {
+  return {
+    encode(value) {
+      return Base64_exports.fromString(JSON.stringify(schema.parse(value)));
+    },
+    decode(value) {
+      try {
+        return schema.parse(JSON.parse(Base64_exports.toString(value)));
+      } catch {
+        throw new InvalidJsonHeaderError();
+      }
+    }
+  };
+}
+var InvalidJsonHeaderError;
+var init_HeaderCodec = __esm({
+  "node_modules/mppx/dist/internal/HeaderCodec.js"() {
+    "use strict";
+    init_esm2();
+    InvalidJsonHeaderError = class extends Error {
+      name = "InvalidJsonHeaderError";
+      constructor() {
+        super("Invalid base64 JSON header.");
+      }
+    };
+  }
+});
+
+// node_modules/mppx/dist/x402/Types.js
+var Types_exports2 = {};
+__export(Types_exports2, {
+  ExactEip3009PayloadSchema: () => ExactEip3009PayloadSchema,
+  ExactPayloadSchema: () => ExactPayloadSchema,
+  ExactPermit2PayloadSchema: () => ExactPermit2PayloadSchema,
+  ExactTransferSchema: () => ExactTransferSchema,
+  ExtensionSchema: () => ExtensionSchema,
+  ExtensionsSchema: () => ExtensionsSchema,
+  PaymentPayloadSchema: () => PaymentPayloadSchema,
+  PaymentRequiredSchema: () => PaymentRequiredSchema,
+  PaymentRequirementsSchema: () => PaymentRequirementsSchema,
+  ResourceInfoSchema: () => ResourceInfoSchema,
+  SettleResponseSchema: () => SettleResponseSchema,
+  VerifyResponseSchema: () => VerifyResponseSchema,
+  assetTransferMethods: () => assetTransferMethods,
+  evmNetworkPrefix: () => evmNetworkPrefix2,
+  exactIntent: () => exactIntent,
+  paymentMethod: () => paymentMethod2,
+  paymentRequiredHeader: () => paymentRequiredHeader,
+  paymentResponseHeader: () => paymentResponseHeader,
+  paymentSignatureHeader: () => paymentSignatureHeader,
+  schemes: () => schemes,
+  syntheticChallengeIdPrefix: () => syntheticChallengeIdPrefix,
+  toPaymentRequirements: () => toPaymentRequirements,
+  versions: () => versions
+});
+function toPaymentRequirements(request) {
+  const { extensions: _extensions, resource: _resource, ...paymentRequirements } = request;
+  return PaymentRequirementsSchema.parse(paymentRequirements);
+}
+var versions, paymentMethod2, exactIntent, schemes, assetTransferMethods, evmNetworkPrefix2, syntheticChallengeIdPrefix, paymentRequiredHeader, paymentSignatureHeader, paymentResponseHeader, nonEmptyString, positiveNumber, atomicAmount2, address2, evmNetwork, ResourceInfoSchema, ExactTransferSchema, PaymentRequirementsSchema, ExtensionSchema, ExtensionsSchema, PaymentRequiredSchema, ExactEip3009PayloadSchema, ExactPermit2PayloadSchema, ExactPayloadSchema, PaymentPayloadSchema, VerifyResponseSchema, SettleResponseSchema;
+var init_Types2 = __esm({
+  "node_modules/mppx/dist/x402/Types.js"() {
+    "use strict";
+    init_zod();
+    versions = [2];
+    paymentMethod2 = "evm";
+    exactIntent = "charge";
+    schemes = ["exact"];
+    assetTransferMethods = ["eip3009", "permit2"];
+    evmNetworkPrefix2 = "eip155:";
+    syntheticChallengeIdPrefix = "x402:";
+    paymentRequiredHeader = "PAYMENT-REQUIRED";
+    paymentSignatureHeader = "PAYMENT-SIGNATURE";
+    paymentResponseHeader = "PAYMENT-RESPONSE";
+    nonEmptyString = string2().check(_minLength(1));
+    positiveNumber = number2().check(refine((value) => value > 0, "Must be positive"));
+    atomicAmount2 = string2().check(_regex(/^\d+$/, "Invalid atomic amount"));
+    address2 = address();
+    evmNetwork = string2().check(_regex(new RegExp(`^${evmNetworkPrefix2}\\d+$`), "Invalid EVM CAIP-2 network"));
+    ResourceInfoSchema = object({
+      description: optional(string2()),
+      iconUrl: optional(string2()),
+      mimeType: optional(string2()),
+      serviceName: optional(string2()),
+      tags: optional(array(string2())),
+      url: nonEmptyString
+    });
+    ExactTransferSchema = discriminatedUnion("type", [
+      object({
+        name: nonEmptyString,
+        type: literal("eip3009"),
+        version: nonEmptyString
+      }),
+      object({
+        name: optional(string2()),
+        type: literal("permit2"),
+        version: optional(string2())
+      })
+    ]);
+    PaymentRequirementsSchema = object({
+      amount: atomicAmount2,
+      asset: nonEmptyString,
+      extra: optional(record(string2(), unknown())),
+      maxTimeoutSeconds: positiveNumber,
+      network: evmNetwork,
+      payTo: nonEmptyString,
+      scheme: _enum2(schemes)
+    });
+    ExtensionSchema = object({
+      info: record(string2(), unknown()),
+      schema: record(string2(), unknown())
+    });
+    ExtensionsSchema = record(string2(), ExtensionSchema);
+    PaymentRequiredSchema = object({
+      accepts: array(PaymentRequirementsSchema).check(_minLength(1)),
+      error: optional(string2()),
+      extensions: optional(ExtensionsSchema),
+      resource: ResourceInfoSchema,
+      x402Version: literal(2)
+    });
+    ExactEip3009PayloadSchema = object({
+      authorization: object({
+        from: address2,
+        nonce: hash2(),
+        to: address2,
+        validAfter: atomicAmount2,
+        validBefore: atomicAmount2,
+        value: atomicAmount2
+      }),
+      signature: signature()
+    });
+    ExactPermit2PayloadSchema = object({
+      permit2Authorization: object({
+        deadline: atomicAmount2,
+        from: address2,
+        nonce: atomicAmount2,
+        permitted: object({
+          amount: atomicAmount2,
+          token: address2
+        }),
+        spender: address2,
+        witness: object({
+          to: address2,
+          validAfter: atomicAmount2
+        })
+      }),
+      signature: signature()
+    });
+    ExactPayloadSchema = union([ExactEip3009PayloadSchema, ExactPermit2PayloadSchema]);
+    PaymentPayloadSchema = object({
+      accepted: PaymentRequirementsSchema,
+      extensions: optional(ExtensionsSchema),
+      payload: ExactPayloadSchema,
+      resource: optional(ResourceInfoSchema),
+      x402Version: literal(2)
+    });
+    VerifyResponseSchema = object({
+      extensions: optional(ExtensionsSchema),
+      extra: optional(record(string2(), unknown())),
+      invalidMessage: optional(string2()),
+      invalidReason: optional(string2()),
+      isValid: boolean2(),
+      payer: optional(string2())
+    });
+    SettleResponseSchema = object({
+      amount: optional(atomicAmount2),
+      errorMessage: optional(string2()),
+      errorReason: optional(string2()),
+      extensions: optional(ExtensionsSchema),
+      extra: optional(record(string2(), unknown())),
+      network: nonEmptyString,
+      payer: optional(string2()),
+      success: boolean2(),
+      transaction: string2()
+    });
+  }
+});
+
+// node_modules/mppx/dist/x402/Header.js
+var Header_exports = {};
+__export(Header_exports, {
+  decodePaymentRequired: () => decodePaymentRequired,
+  decodePaymentRequiredEnvelope: () => decodePaymentRequiredEnvelope,
+  decodePaymentResponse: () => decodePaymentResponse,
+  decodePaymentSignature: () => decodePaymentSignature,
+  encodePaymentRequired: () => encodePaymentRequired,
+  encodePaymentResponse: () => encodePaymentResponse,
+  encodePaymentSignature: () => encodePaymentSignature
+});
+function decodePaymentRequiredEnvelope(value) {
+  try {
+    const parsed = JSON.parse(Base64_exports.toString(value));
+    return parsePaymentRequiredEnvelope(parsed);
+  } catch {
+    throw new InvalidJsonHeaderError();
+  }
+}
+var paymentRequired, paymentSignature, paymentResponse, encodePaymentRequired, decodePaymentRequired, encodePaymentSignature, decodePaymentSignature, encodePaymentResponse, decodePaymentResponse, parsePaymentRequiredEnvelope;
+var init_Header = __esm({
+  "node_modules/mppx/dist/x402/Header.js"() {
+    "use strict";
+    init_esm2();
+    init_HeaderCodec();
+    init_Types2();
+    paymentRequired = createJson(PaymentRequiredSchema);
+    paymentSignature = createJson(PaymentPayloadSchema);
+    paymentResponse = createJson(SettleResponseSchema);
+    encodePaymentRequired = paymentRequired.encode;
+    decodePaymentRequired = paymentRequired.decode;
+    encodePaymentSignature = paymentSignature.encode;
+    decodePaymentSignature = paymentSignature.decode;
+    encodePaymentResponse = paymentResponse.encode;
+    decodePaymentResponse = paymentResponse.decode;
+    parsePaymentRequiredEnvelope = (value) => {
+      if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new InvalidJsonHeaderError();
+      const record2 = value;
+      if (record2.x402Version !== 2 || !Array.isArray(record2.accepts))
+        throw new InvalidJsonHeaderError();
+      const resource = ResourceInfoSchema.parse(record2.resource);
+      const extensions = record2.extensions === void 0 ? void 0 : ExtensionsSchema.parse(record2.extensions);
+      return {
+        accepts: record2.accepts,
+        ...extensions ? { extensions } : {},
+        resource,
+        x402Version: 2
+      };
+    };
+  }
+});
+
+// node_modules/mppx/dist/x402/index.js
+var x402_exports = {};
+__export(x402_exports, {
+  Assets: () => Assets_exports,
+  ExactEip3009PayloadSchema: () => ExactEip3009PayloadSchema,
+  ExactPayloadSchema: () => ExactPayloadSchema,
+  ExactPermit2PayloadSchema: () => ExactPermit2PayloadSchema,
+  ExactTransferSchema: () => ExactTransferSchema,
+  ExtensionSchema: () => ExtensionSchema,
+  ExtensionsSchema: () => ExtensionsSchema,
+  Header: () => Header_exports,
+  PaymentPayloadSchema: () => PaymentPayloadSchema,
+  PaymentRequiredSchema: () => PaymentRequiredSchema,
+  PaymentRequirementsSchema: () => PaymentRequirementsSchema,
+  ResourceInfoSchema: () => ResourceInfoSchema,
+  SettleResponseSchema: () => SettleResponseSchema,
+  Types: () => Types_exports2,
+  VerifyResponseSchema: () => VerifyResponseSchema,
+  assetTransferMethods: () => assetTransferMethods,
+  assets: () => Assets_exports,
+  evmNetworkPrefix: () => evmNetworkPrefix2,
+  exactIntent: () => exactIntent,
+  paymentMethod: () => paymentMethod2,
+  paymentRequiredHeader: () => paymentRequiredHeader,
+  paymentResponseHeader: () => paymentResponseHeader,
+  paymentSignatureHeader: () => paymentSignatureHeader,
+  schemes: () => schemes,
+  syntheticChallengeIdPrefix: () => syntheticChallengeIdPrefix,
+  toPaymentRequirements: () => toPaymentRequirements,
+  versions: () => versions
+});
+var init_x402 = __esm({
+  "node_modules/mppx/dist/x402/index.js"() {
+    "use strict";
+    init_Assets();
+    init_Header();
+    init_Types2();
+    init_Assets();
+    init_Types2();
   }
 });
 
@@ -19618,6 +20960,7 @@ var dist_exports = {};
 __export(dist_exports, {
   BodyDigest: () => BodyDigest_exports,
   Challenge: () => Challenge_exports,
+  Constants: () => Constants_exports,
   Credential: () => Credential_exports,
   Errors: () => Errors_exports2,
   Expires: () => Expires_exports,
@@ -19626,6 +20969,8 @@ __export(dist_exports, {
   PaymentRequest: () => PaymentRequest_exports,
   Receipt: () => Receipt_exports,
   Store: () => Store_exports,
+  evm: () => evm_exports,
+  x402: () => x402_exports,
   z: () => zod_exports
 });
 var init_dist2 = __esm({
@@ -19633,14 +20978,17 @@ var init_dist2 = __esm({
     "use strict";
     init_BodyDigest();
     init_Challenge();
+    init_Constants();
     init_Credential();
     init_Errors2();
     init_Expires();
+    init_evm();
     init_Mcp();
     init_Method();
     init_PaymentRequest();
     init_Receipt();
     init_Store();
+    init_x402();
     init_zod();
   }
 });
@@ -19722,6 +21070,7 @@ async function createMultichainPaymentIntent({
 
 // src/stripe-multichain/pay_to_address.ts
 var DEFAULT_NETWORKS = ["tempo", "base", "solana"];
+var warnedRotatingSolanaMint = false;
 async function createPayToAddressFromStripePI(opts) {
   const fromCredential = await tryResolveFromCredential(opts);
   if (fromCredential !== null) return fromCredential;
@@ -19786,6 +21135,12 @@ async function mintAndCache(opts) {
   const staticRecipients = opts.staticRecipients ?? {};
   const requestedNetworks = opts.networks ?? [...DEFAULT_NETWORKS];
   const stripeNetworks = requestedNetworks.filter((n) => !(n in staticRecipients));
+  if (stripeNetworks.includes("solana") && !warnedRotatingSolanaMint) {
+    warnedRotatingSolanaMint = true;
+    console.warn(
+      "[stripe-multichain] Minting a per-PaymentIntent (rotating) Solana recipient. Solana MPP settle fails on @solana/mpp >=0.6.0 for rotating recipients: the client does not create the primary recipient ATA, so a fresh deposit address has no token account to receive into. Use a static Solana recipient with a pre-funded ATA (staticRecipients: { solana: '<wallet>' }), or drop 'solana' from networks."
+    );
+  }
   const idempotencyKey = opts.orderId ? `pi-${opts.orderId}-${opts.amountCents}` : void 0;
   const { paymentIntentId, depositAddresses } = await createMultichainPaymentIntent({
     stripe: opts.stripe,
@@ -19794,12 +21149,12 @@ async function mintAndCache(opts) {
     ...opts.metadata ? { metadata: opts.metadata } : {},
     ...idempotencyKey ? { idempotencyKey } : {}
   });
-  for (const address2 of Object.values(depositAddresses)) {
-    await opts.piCache.cacheAddress(address2);
-    opts.piCache.cachePaymentIntent(address2, paymentIntentId);
+  for (const address3 of Object.values(depositAddresses)) {
+    await opts.piCache.cacheAddress(address3);
+    opts.piCache.cachePaymentIntent(address3, paymentIntentId);
   }
-  for (const address2 of Object.values(staticRecipients)) {
-    await opts.piCache.cacheAddress(address2);
+  for (const address3 of Object.values(staticRecipients)) {
+    await opts.piCache.cacheAddress(address3);
   }
   const merged = { ...depositAddresses, ...staticRecipients };
   opts.piCache.cacheNetworkAddresses(paymentIntentId, merged);
@@ -19968,19 +21323,19 @@ function createPiCache({
   }, 6e4);
   if (typeof evict.unref === "function") evict.unref();
   return {
-    async cacheAddress(address2) {
+    async cacheAddress(address3) {
       const r = await getRedis();
-      if (r) await r.set(`${keyPrefix}${address2}`, "1", "EX", ttlSeconds).catch(() => {
+      if (r) await r.set(`${keyPrefix}${address3}`, "1", "EX", ttlSeconds).catch(() => {
       });
-      addrMemCache.set(address2, Date.now() + ttlSeconds * 1e3);
+      addrMemCache.set(address3, Date.now() + ttlSeconds * 1e3);
     },
-    async hasAddress(address2) {
+    async hasAddress(address3) {
       const r = await getRedis();
       if (r) {
-        const val = await r.get(`${keyPrefix}${address2}`).catch(() => null);
+        const val = await r.get(`${keyPrefix}${address3}`).catch(() => null);
         if (val) return true;
       }
-      const expiry = addrMemCache.get(address2);
+      const expiry = addrMemCache.get(address3);
       return !!expiry && expiry > Date.now();
     },
     cachePaymentIntent(depositAddress, paymentIntentId) {