uvd-x402-sdk 2.104.2 → 2.104.3

package/dist/adapters/index.d.mts

@@ -1,5 +1,5 @@
 import { X as X402Version, a as PaymentResult } from '../index-DARXHuQl.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';
+export { E as EnvKeyAdapter, O as OWSAccountInfo, a as OWSCore, b as OWSSignResult, c as OWSWallet, d as OWSWalletAdapter, e as OWSWalletAdapterOptions } from '../ows-DJu424iz.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-DARXHuQl.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';
+export { E as EnvKeyAdapter, O as OWSAccountInfo, a as OWSCore, b as OWSSignResult, c as OWSWallet, d as OWSWalletAdapter, e as OWSWalletAdapterOptions } from '../ows-CW-g7qGw.js';
 import '../wallet-T0NFUUkT.js';
 import 'ethers';
 

package/dist/adapters/index.js

@@ -1545,8 +1545,124 @@ function assertTypedDataIntegersExact(doc, where = "typed data", code = "INVALID
   }
   assertNoInexactNumber(message, `${where} message`, code);
 }
+var MIN_EXACT_DIGITS = 22;
+var MAX_EXACT_DIGITS = 78;
+var MAX_DOUBLE_DIGITS = 17;
+function doubleShaped(literal) {
+  const significant = literal.replace(/^-/, "").replace(/0+$/, "");
+  return significant.length <= MAX_DOUBLE_DIGITS || BigInt(literal) === BigInt(Number(literal));
+}
+var JSON_NUMBER = /-?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/y;
+var JSON_SPACE = /[ \t\n\r]*/y;
+function dataDescriptor(value) {
+  const descriptor = /* @__PURE__ */ Object.create(null);
+  descriptor.value = value;
+  descriptor.writable = true;
+  descriptor.enumerable = true;
+  descriptor.configurable = true;
+  return descriptor;
+}
+function parseJsonExact(input) {
+  const text = String(input);
+  let pos = 0;
+  let wide = false;
+  const fail = (what) => {
+    throw new SyntaxError(`${what} in JSON at position ${pos}`);
+  };
+  const space = () => {
+    JSON_SPACE.lastIndex = pos;
+    if (JSON_SPACE.exec(text)) pos = JSON_SPACE.lastIndex;
+  };
+  const string = () => {
+    if (text[pos] !== '"') fail("Expected a string");
+    let end = pos + 1;
+    while (end < text.length && text[end] !== '"') end += text[end] === "\\" ? 2 : 1;
+    if (end >= text.length) fail("Unterminated string");
+    const value = JSON.parse(text.slice(pos, end + 1));
+    pos = end + 1;
+    return value;
+  };
+  const key = () => {
+    const name = string();
+    space();
+    if (text[pos] !== ":") fail("Expected ':'");
+    pos += 1;
+    space();
+    return name;
+  };
+  const scalar = () => {
+    if (text[pos] === '"') return string();
+    for (const [word, value] of [["true", true], ["false", false], ["null", null]]) {
+      if (text.startsWith(word, pos)) {
+        pos += word.length;
+        return value;
+      }
+    }
+    JSON_NUMBER.lastIndex = pos;
+    const match = JSON_NUMBER.exec(text);
+    if (!match) return fail("Unexpected token");
+    pos = JSON_NUMBER.lastIndex;
+    const literal = match[0];
+    const digits = literal.length - (literal.startsWith("-") ? 1 : 0);
+    if (match[1] === void 0 && match[2] === void 0 && digits >= MIN_EXACT_DIGITS && digits <= MAX_EXACT_DIGITS && !doubleShaped(literal)) {
+      wide = true;
+      return BigInt(literal);
+    }
+    return Number(literal);
+  };
+  const stack = [];
+  space();
+  for (; ; ) {
+    let value;
+    if (text[pos] === "[") {
+      pos += 1;
+      space();
+      if (text[pos] !== "]") {
+        stack.push({ kind: "array", items: [] });
+        continue;
+      }
+      pos += 1;
+      value = [];
+    } else if (text[pos] === "{") {
+      pos += 1;
+      space();
+      if (text[pos] !== "}") {
+        stack.push({ kind: "object", object: {}, key: key() });
+        continue;
+      }
+      pos += 1;
+      value = {};
+    } else {
+      value = scalar();
+    }
+    for (; ; ) {
+      space();
+      const top = stack[stack.length - 1];
+      if (top === void 0) {
+        if (pos !== text.length) fail("Unexpected non-whitespace character after JSON");
+        return wide ? value : JSON.parse(text);
+      }
+      const close = top.kind === "array" ? "]" : "}";
+      if (top.kind === "array") {
+        top.items.push(value);
+      } else {
+        Object.defineProperty(top.object, top.key, dataDescriptor(value));
+      }
+      if (text[pos] === ",") {
+        pos += 1;
+        space();
+        if (top.kind === "object") top.key = key();
+        break;
+      }
+      if (text[pos] !== close) fail(`Expected ',' or '${close}'`);
+      pos += 1;
+      stack.pop();
+      value = top.kind === "array" ? top.items : top.object;
+    }
+  }
+}
 function parseTypedDataJson(text, where = "typed data", code = "INVALID_CONFIG") {
-  const doc = JSON.parse(text);
+  const doc = parseJsonExact(text);
   assertTypedDataIntegersExact(doc, where, code);
   return doc;
 }
@@ -1589,11 +1705,18 @@ var EnvKeyAdapter = class {
   /**
    * Sign EIP-712 typed structured data.
    *
+   * An integer of 22 to 78 digits written as a JSON number (a 32-byte salt)
+   * is read with every digit, as Python's `json` reads it, not rounded the
+   * way `JSON.parse` rounds it.
+   *
    * @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.
+   *   (or `domain.chainId`) is a JSON number above 2**53 - 1 of up to 21
+   *   digits (a JavaScript hop may have rounded it and written it back in
+   *   digits) or written with an exponent or a fraction (`7.76e+76`): it is
+   *   refused instead of signed. Write uints as strings. An integer out of
+   *   its field's range is refused by ethers (`value out-of-bounds`).
    */
   async signTypedData(typedData) {
     const parsed = parseTypedDataJson(typedData);
@@ -1856,7 +1979,14 @@ function prepareTypedData(input) {
     EIP712Domain: EIP712_DOMAIN_FIELDS.filter(([name]) => domain[name] != null).map(
       ([name, type]) => ({ name, type })
     ),
-    ...structs
+    // Each field as ethers hashes it, name and type: any other key (a wide
+    // number in it is a bigint) never reaches OWS or JSON.stringify.
+    ...Object.fromEntries(
+      Object.entries(structs).map(([struct, fields]) => [
+        struct,
+        fields.map(({ name, type }) => ({ name, type }))
+      ])
+    )
   };
   const owsDomain = owsValue("EIP712Domain", domain, all, "domain");
   const owsMessage = owsValue(root, message, all, "message");
@@ -1988,7 +2118,7 @@ var OWSWalletAdapter = class {
   async signTypedData(typedData) {
     let parsed;
     try {
-      parsed = JSON.parse(typedData);
+      parsed = parseJsonExact(typedData);
     } catch {
       throw refuse("typedData is not a JSON string");
     }