@agent-score/commerce 2.7.6 → 2.7.7

package/dist/stripe-multichain/index.mjs

@@ -23,11 +23,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from9, except, desc) => {
-  if (from9 && typeof from9 === "object" || typeof from9 === "function") {
-    for (let key of __getOwnPropNames(from9))
+var __copyProps = (to, from10, except, desc) => {
+  if (from10 && typeof from10 === "object" || typeof from10 === "function") {
+    for (let key of __getOwnPropNames(from10))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from9[key], enumerable: !(desc = __getOwnPropDesc(from9, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from10[key], enumerable: !(desc = __getOwnPropDesc(from10, key)) || desc.enumerable });
   }
   return to;
 };
@@ -19242,10 +19242,16 @@ var init_Errors2 = __esm({
       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 {
+      /** Safe method-specific context for diagnostics and relay responses. */
+      details;
       /** HTTP status code. */
       status = 402;
       /** Actionable hint for resolving the error (RFC 9457 extension member). */
       hint;
+      constructor(message, options = {}) {
+        super(message);
+        this.details = options.details;
+      }
       /** Converts the error to RFC 9457 Problem Details format. */
       toProblemDetails(challengeId) {
         return {
@@ -19253,6 +19259,7 @@ var init_Errors2 = __esm({
           title: this.title,
           status: this.status,
           detail: this.message,
+          ...this.details && Object.keys(this.details).length > 0 && { details: this.details },
           ...this.hint && { hint: this.hint },
           ...challengeId && { challengeId }
         };
@@ -19286,8 +19293,10 @@ var init_Errors2 = __esm({
       title = "Verification Failed";
       type = "https://paymentauth.org/problems/verification-failed";
       constructor(options = {}) {
-        const { reason } = options;
-        super(reason ? `Payment verification failed: ${reason}.` : "Payment verification failed.");
+        const { details, reason } = options;
+        super(reason ? `Payment verification failed: ${reason}.` : "Payment verification failed.", {
+          details
+        });
       }
     };
     PaymentActionRequiredError = class extends PaymentError {
@@ -19519,7 +19528,7 @@ var version3;
 var init_version2 = __esm({
   "node_modules/viem/_esm/errors/version.js"() {
     "use strict";
-    version3 = "2.55.2";
+    version3 = "2.55.8";
   }
 });
 
@@ -20004,60 +20013,93 @@ var init_isAddress = __esm({
   }
 });
 
-// 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))
+// node_modules/viem/_esm/utils/unit/Value.js
+function from6(value, decimals = 0) {
+  if (!Number.isInteger(decimals) || decimals < 0)
+    throw new InvalidDecimalsError({ decimals });
+  if (!/^-?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)$/.test(value))
     throw new InvalidDecimalNumberError({ value });
-  let [integer2, fraction = "0"] = value.split(".");
+  let [integer2 = "", fraction = "0"] = value.split(".");
   const negative = integer2.startsWith("-");
   if (negative)
     integer2 = integer2.slice(1);
+  if (integer2 === "")
+    integer2 = "0";
   fraction = fraction.replace(/(0+)$/, "");
   if (decimals === 0) {
-    if (Math.round(Number(`.${fraction}`)) === 1)
+    if (fraction.length > 0 && Number.parseInt(fraction[0], 10) >= 5)
       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}`;
+    const left = fraction.slice(0, decimals);
+    const roundDigit = Number.parseInt(fraction.slice(decimals, decimals + 1), 10);
+    if (roundDigit >= 5) {
+      const carried = carry(left);
+      if (carried.length > decimals) {
+        fraction = carried.slice(1);
+        integer2 = `${BigInt(integer2) + 1n}`;
+      } else {
+        fraction = carried;
+      }
+    } else {
+      fraction = left;
     }
-    fraction = fraction.slice(0, decimals);
   } else {
     fraction = fraction.padEnd(decimals, "0");
   }
   return BigInt(`${negative ? "-" : ""}${integer2}${fraction}`);
 }
+function carry(digits) {
+  const out = digits.split("");
+  let i = out.length - 1;
+  while (i >= 0) {
+    const d = Number.parseInt(out[i], 10) + 1;
+    if (d < 10) {
+      out[i] = String(d);
+      return out.join("");
+    }
+    out[i] = "0";
+    i--;
+  }
+  return `1${out.join("")}`;
+}
+var InvalidDecimalNumberError, InvalidDecimalsError;
+var init_Value2 = __esm({
+  "node_modules/viem/_esm/utils/unit/Value.js"() {
+    "use strict";
+    InvalidDecimalNumberError = class extends Error {
+      constructor({ value }) {
+        super(`Value \`${value}\` is not a valid decimal number.`);
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "Value.InvalidDecimalNumberError"
+        });
+      }
+    };
+    InvalidDecimalsError = class extends Error {
+      constructor({ decimals }) {
+        super(`\`decimals\` must be a non-negative integer. Got \`${decimals}\`.`);
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "Value.InvalidDecimalsError"
+        });
+      }
+    };
+  }
+});
+
+// node_modules/viem/_esm/utils/unit/parseUnits.js
+function parseUnits(value, decimals) {
+  return from6(value, decimals);
+}
 var init_parseUnits = __esm({
   "node_modules/viem/_esm/utils/unit/parseUnits.js"() {
     "use strict";
-    init_unit();
+    init_Value2();
   }
 });
 
@@ -20281,13 +20323,70 @@ var init_Chains = __esm({
 // node_modules/mppx/dist/Method.js
 var Method_exports = {};
 __export(Method_exports, {
-  from: () => from6,
+  broadcastCredential: () => broadcastCredential,
+  from: () => from7,
+  selectServerMethod: () => selectServerMethod,
   toClient: () => toClient,
-  toServer: () => toServer
+  toServer: () => toServer,
+  validateCredential: () => validateCredential
 });
-function from6(method) {
+function from7(method) {
   return method;
 }
+async function validateCredential(methods, input) {
+  const prepared = prepareCredential(methods, input);
+  if (!prepared.method.validate)
+    throw new VerificationFailedError({
+      details: { intent: prepared.method.intent, method: prepared.method.name },
+      reason: `${prepared.method.name}/${prepared.method.intent} does not support non-mutating credential validation`
+    });
+  return prepared.method.validate({
+    credential: prepared.credential,
+    request: prepared.request
+  });
+}
+async function broadcastCredential(methods, input) {
+  const prepared = prepareCredential(methods, input);
+  const { method } = prepared;
+  if (method.broadcast && method.validate)
+    await method.validate({ credential: prepared.credential, request: prepared.request });
+  const broadcast = method.broadcast ?? method.verify;
+  return broadcast({ credential: prepared.credential, request: prepared.request });
+}
+function prepareCredential(methods, input) {
+  const credential = typeof input === "string" ? deserialize3(input) : input;
+  const candidates = methods.filter((method2) => method2.name === credential.challenge.method && method2.intent === credential.challenge.intent);
+  const method = selectServerMethod(candidates, credential.challenge);
+  if (!method)
+    throw new InvalidChallengeError({
+      id: credential.challenge.id,
+      reason: `no registered method for ${credential.challenge.method}/${credential.challenge.intent}`
+    });
+  assert5(credential.challenge.expires, credential.challenge.id);
+  let payload;
+  try {
+    payload = method.schema.credential.payload.parse(credential.payload);
+  } catch (error51) {
+    throw new InvalidPayloadError(error51 instanceof Error ? { reason: error51.message } : {});
+  }
+  return {
+    credential: { ...credential, payload },
+    method,
+    request: credential.challenge.request
+  };
+}
+function selectServerMethod(methods, challenge) {
+  if (methods.length <= 1)
+    return methods[0];
+  if (challenge.method !== Methods.tempo || challenge.intent !== Intents.session)
+    return methods[0];
+  const sessionProtocol = getMethodDetail(challenge.request.methodDetails, MethodDetailKeys.sessionProtocol);
+  if (sessionProtocol === void 0 || sessionProtocol === SessionProtocols.v1)
+    return methods.find((method) => method.alias === "sessionLegacy") ?? methods[0];
+  if (sessionProtocol === SessionProtocols.v2)
+    return methods.find((method) => method.alias === void 0) ?? methods[0];
+  return void 0;
+}
 function toClient(method, options) {
   const { canHandleChallenge, context, createCredential } = options;
   return {
@@ -20298,7 +20397,16 @@ function toClient(method, options) {
   };
 }
 function toServer(method, options) {
-  const { alias, authorize, defaults, extensions, html, preflight, request, respond, stableBinding, transport, verify: verify3 } = options;
+  const { alias, authorize, defaults, extensions, html, preflight, request, respond, broadcast, stableBinding, transport, validate: validate4, verify: verify3 } = options;
+  const effectiveVerify = verify3 ?? (async (parameters) => {
+    if (validate4)
+      await validate4(parameters);
+    if (!broadcast)
+      throw new VerificationFailedError({
+        reason: `${method.name}/${method.intent} does not support credential broadcast`
+      });
+    return broadcast(parameters);
+  });
   return {
     ...method,
     alias,
@@ -20309,14 +20417,20 @@ function toServer(method, options) {
     preflight,
     request,
     respond,
+    broadcast,
     stableBinding,
     transport,
-    verify: verify3
+    validate: validate4,
+    verify: effectiveVerify
   };
 }
 var init_Method = __esm({
   "node_modules/mppx/dist/Method.js"() {
     "use strict";
+    init_Constants();
+    init_Credential();
+    init_Errors2();
+    init_Expires();
   }
 });
 
@@ -20445,7 +20559,7 @@ var init_Methods = __esm({
     init_Method();
     init_zod();
     init_Types();
-    charge = from6({
+    charge = from7({
       name: paymentMethod,
       intent: chargeIntent,
       schema: {
@@ -20537,15 +20651,15 @@ var Receipt_exports = {};
 __export(Receipt_exports, {
   Schema: () => Schema2,
   deserialize: () => deserialize4,
-  from: () => from7,
+  from: () => from8,
   fromResponse: () => fromResponse2,
   serialize: () => serialize4
 });
 function deserialize4(encoded) {
   const json2 = Base64_exports.toString(encoded);
-  return from7(JSON.parse(json2));
+  return from8(JSON.parse(json2));
 }
-function from7(parameters) {
+function from8(parameters) {
   return Schema2.parse(parameters);
 }
 function serialize4(receipt) {
@@ -20588,12 +20702,12 @@ var init_Receipt = __esm({
 var Store_exports = {};
 __export(Store_exports, {
   cloudflare: () => cloudflare,
-  from: () => from8,
+  from: () => from9,
   memory: () => memory,
   redis: () => redis,
   upstash: () => upstash
 });
-function from8(store, options) {
+function from9(store, options) {
   return withKeyPrefix(store, options?.keyPrefix);
 }
 function withKeyPrefix(store, keyPrefix = "") {
@@ -20604,7 +20718,7 @@ function withKeyPrefix(store, keyPrefix = "") {
     return cached2;
   const backing = store;
   const prefixedKey = (key) => `${keyPrefix}${key}`;
-  const prefixed = from8({
+  const prefixed = from9({
     async get(key) {
       return backing.get(prefixedKey(key));
     },
@@ -20641,7 +20755,7 @@ function wrapJsonUpdate(update) {
   };
 }
 function cloudflare(kv, options) {
-  return from8({
+  return from9({
     async get(key) {
       const raw = await kv.get(key);
       if (raw == null)
@@ -20659,7 +20773,7 @@ function cloudflare(kv, options) {
 }
 function memory(options) {
   const store = /* @__PURE__ */ new Map();
-  return from8({
+  return from9({
     async get(key) {
       const raw = store.get(key);
       if (raw === void 0)
@@ -20684,7 +20798,7 @@ function memory(options) {
   }, options);
 }
 function redis(client, options) {
-  return from8({
+  return from9({
     async get(key) {
       const raw = await client.get(key);
       if (raw == null)
@@ -20701,7 +20815,7 @@ function redis(client, options) {
   }, options);
 }
 function upstash(redis2, options) {
-  return from8({
+  return from9({
     async get(key) {
       return await redis2.get(key);
     },