uvd-x402-sdk 2.101.0 → 2.102.0

package/dist/adapters/index.d.mts

@@ -1,5 +1,5 @@
 import { X as X402Version, a as PaymentResult } from '../index-DagQ74ZQ.mjs';
-export { E as EnvKeyAdapter, O as OWSAccountInfo, a as OWSCore, b as OWSSignResult, c as OWSWallet, d as OWSWalletAdapter, e as OWSWalletAdapterOptions } from '../ows-9uNT7ZSZ.mjs';
+export { E as EnvKeyAdapter, O as OWSAccountInfo, a as OWSCore, b as OWSSignResult, c as OWSWallet, d as OWSWalletAdapter, e as OWSWalletAdapterOptions } from '../ows-DazT4KQH.mjs';
 import '../wallet-T0NFUUkT.mjs';
 import 'ethers';
 

package/dist/adapters/index.d.ts

@@ -1,5 +1,5 @@
 import { X as X402Version, a as PaymentResult } from '../index-DagQ74ZQ.js';
-export { E as EnvKeyAdapter, O as OWSAccountInfo, a as OWSCore, b as OWSSignResult, c as OWSWallet, d as OWSWalletAdapter, e as OWSWalletAdapterOptions } from '../ows-Tt33WE0s.js';
+export { E as EnvKeyAdapter, O as OWSAccountInfo, a as OWSCore, b as OWSSignResult, c as OWSWallet, d as OWSWalletAdapter, e as OWSWalletAdapterOptions } from '../ows-BB6Sgj0W.js';
 import '../wallet-T0NFUUkT.js';
 import 'ethers';
 

package/dist/adapters/index.js

@@ -1443,6 +1443,110 @@ function useX402Wagmi(walletClient) {
     createPaymentFull
   };
 }
+var INTEGER_TYPE = /^u?int\d*$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function inexactNumberMessage(field, value) {
+  return `${field} is the JSON number ${String(value)}, larger in magnitude than Number.MAX_SAFE_INTEGER (2**53 - 1): JSON.parse has already rounded it, and signing it would sign a different integer than the one that was written. Send uints as decimal or 0x-hex strings (or a bigint)`;
+}
+function numberRefusal(path, value, code) {
+  return new X402Error(
+    Number.isInteger(value) ? inexactNumberMessage(path, value) : `${path} must be an integer, got the JSON number ${String(value)}`,
+    code
+  );
+}
+function findInexactNumber(value, path, seen = /* @__PURE__ */ new Set()) {
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) ? null : { path, value };
+  }
+  if (typeof value !== "object" || value === null || seen.has(value)) return null;
+  seen.add(value);
+  const entries = Array.isArray(value) ? value.map((item, i) => [`${path}[${i}]`, item]) : Object.entries(value).map(([key, item]) => [`${path}.${key}`, item]);
+  for (const [itemPath, item] of entries) {
+    const hit = findInexactNumber(item, itemPath, seen);
+    if (hit) return hit;
+  }
+  return null;
+}
+function assertNoInexactNumber(value, path, code = "INVALID_CONFIG") {
+  const hit = findInexactNumber(value, path);
+  if (hit) throw numberRefusal(hit.path, hit.value, code);
+}
+function rootStruct(structs, primaryType) {
+  try {
+    return ethers.ethers.TypedDataEncoder.from(
+      structs
+    ).primaryType;
+  } catch {
+    return typeof primaryType === "string" && Array.isArray(structs[primaryType]) ? primaryType : null;
+  }
+}
+function checkTyped(type, value, path, structs, code, ancestors = /* @__PURE__ */ new Set()) {
+  if (typeof value === "object" && value !== null) {
+    if (ancestors.has(value)) return;
+    ancestors.add(value);
+  }
+  try {
+    const array = /^(.*)\[(\d*)\]$/.exec(type);
+    if (array) {
+      if (Array.isArray(value)) {
+        value.forEach(
+          (item, i) => checkTyped(array[1], item, `${path}[${i}]`, structs, code, ancestors)
+        );
+      }
+      return;
+    }
+    const struct = structs[type];
+    if (Array.isArray(struct)) {
+      if (!isRecord(value)) return;
+      for (const field of struct) {
+        if (typeof field?.name === "string" && typeof field.type === "string") {
+          checkTyped(
+            field.type,
+            value[field.name],
+            `${path}.${field.name}`,
+            structs,
+            code,
+            ancestors
+          );
+        }
+      }
+      return;
+    }
+    if (INTEGER_TYPE.test(type) && typeof value === "number" && !Number.isSafeInteger(value)) {
+      throw numberRefusal(path, value, code);
+    }
+  } finally {
+    if (typeof value === "object" && value !== null) ancestors.delete(value);
+  }
+}
+function assertTypedDataIntegersExact(doc, where = "typed data", code = "INVALID_CONFIG") {
+  if (!isRecord(doc)) return;
+  const { domain, types, message, primaryType } = doc;
+  if (isRecord(domain) && typeof domain.chainId === "number" && !Number.isSafeInteger(domain.chainId)) {
+    throw numberRefusal(`${where} domain.chainId`, domain.chainId, code);
+  }
+  if (!isRecord(message)) return;
+  const structs = isRecord(types) ? { ...types } : {};
+  delete structs["EIP712Domain"];
+  const root = rootStruct(structs, primaryType);
+  if (root) {
+    checkTyped(root, message, `${where} message`, structs, code);
+    if (typeof primaryType === "string" && primaryType !== root && Array.isArray(structs[primaryType])) {
+      checkTyped(primaryType, message, `${where} message`, structs, code);
+    }
+    return;
+  }
+  assertNoInexactNumber(message, `${where} message`, code);
+}
+function parseTypedDataJson(text, where = "typed data", code = "INVALID_CONFIG") {
+  const doc = JSON.parse(text);
+  assertTypedDataIntegersExact(doc, where, code);
+  return doc;
+}
+
+// src/adapters/env-key.ts
 var EnvKeyAdapter = class {
   wallet;
   /**
@@ -1482,9 +1586,12 @@ var EnvKeyAdapter = class {
    *
    * @param typedData - JSON string with `domain`, `types`, `primaryType`, and `message` fields
    * @returns Object with signature and v/r/s components
+   * @throws {X402Error} `INVALID_CONFIG` when an integer field of `message`
+   *   (or `domain.chainId`) is a JSON number above 2**53 - 1: `JSON.parse`
+   *   rounded it, so it is refused instead of signed. Write uints as strings.
    */
   async signTypedData(typedData) {
-    const parsed = JSON.parse(typedData);
+    const parsed = parseTypedDataJson(typedData);
     const { domain, types, message } = parsed;
     const cleanTypes = { ...types };
     delete cleanTypes["EIP712Domain"];
@@ -1618,7 +1725,7 @@ var ETHERS_NAME_OF = { input: "data", gas: "gasLimit" };
 var TWO_127 = 1n << 127n;
 var TWO_128 = 1n << 128n;
 var TWO_256 = 1n << 256n;
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function shown(value) {
@@ -1635,6 +1742,7 @@ function refuse(message) {
 function toInteger(value, where) {
   if (typeof value === "bigint") return value;
   if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value);
+  if (typeof value === "number" && Number.isInteger(value)) throw refuse(inexactNumberMessage(where, value));
   if (typeof value === "string" && /^-?(0[xX][0-9a-fA-F]+|[0-9]+)$/.test(value)) {
     return value.startsWith("-") ? -BigInt(value.slice(1)) : BigInt(value);
   }
@@ -1662,7 +1770,7 @@ function owsValue(kind, value, types, where) {
   }
   const struct = types[kind];
   if (struct) {
-    if (!isRecord(value)) throw refuse(`${where}: ${kind} needs an object, got ${shown(value)}`);
+    if (!isRecord2(value)) throw refuse(`${where}: ${kind} needs an object, got ${shown(value)}`);
     const out = {};
     for (const field of struct) {
       if (value[field.name] === void 0) throw refuse(`${where}: ${kind} lacks ${field.name}`);
@@ -1716,11 +1824,11 @@ function owsValue(kind, value, types, where) {
   throw refuse(`${where}: unsupported EIP-712 type ${kind}`);
 }
 function prepareTypedData(input) {
-  if (!isRecord(input)) throw refuse("typed data must be an object with domain, types and message");
+  if (!isRecord2(input)) throw refuse("typed data must be an object with domain, types and message");
   const { domain, types, message, primaryType } = input;
-  if (!isRecord(domain)) throw refuse("typed data needs a domain object");
-  if (!isRecord(types)) throw refuse("typed data needs a types object");
-  if (!isRecord(message)) throw refuse("typed data needs a message object");
+  if (!isRecord2(domain)) throw refuse("typed data needs a domain object");
+  if (!isRecord2(types)) throw refuse("typed data needs a types object");
+  if (!isRecord2(message)) throw refuse("typed data needs a message object");
   const structs = { ...types };
   delete structs["EIP712Domain"];
   let root;
@@ -1798,7 +1906,7 @@ var OWSWalletAdapter = class {
   #chain;
   #address;
   constructor(ows, options) {
-    if (isRecord(ows) && "accounts" in ows && (options === void 0 || typeof options === "number")) {
+    if (isRecord2(ows) && "accounts" in ows && (options === void 0 || typeof options === "number")) {
       throw new X402Error(
         `OWSWalletAdapter no longer takes a wallet object with accounts (the deprecated OWSWallet shape, which never worked with @open-wallet-standard/core 1.x); ${MIGRATION}. Nothing was signed.`,
         "INVALID_CONFIG"
@@ -1813,7 +1921,7 @@ var OWSWalletAdapter = class {
         "INVALID_CONFIG"
       );
     }
-    const opts = isRecord(options) ? options : {};
+    const opts = isRecord2(options) ? options : {};
     if (typeof opts.wallet !== "string" || opts.wallet === "") {
       throw new X402Error("OWSWalletAdapter needs options.wallet: the name or id of a wallet in the vault", "INVALID_CONFIG");
     }