@cmdoss/suipay 0.1.0 → 0.1.1-dev.0

package/README.md

@@ -37,8 +37,10 @@ const quote = await client.quote(url, { body: JSON.stringify({ prompt: '...' })
 const result = await client.pay(url, { quote });
 ```
 
-Passing `quote` pins `payTo`, so a later offer cannot swap the recipient under
-the same cap. `pay` still refuses to sign more than that quote.
+Passing `quote` pins `payTo` and replays that quote's method, body, and
+content type. A later offer cannot swap the recipient or the coin. `maxAmount`
+can only tighten the quoted price, not raise it. A different body or content
+type is refused before anything is signed.
 
 ## Which package?
 

package/dist/index.d.ts

@@ -16,12 +16,19 @@ interface Quote {
     method: 'GET' | 'POST';
     /** Exact POST bytes the probe sent. Absent for GET. */
     body?: string;
+    /** Content type the probe sent. Null when the probe sent none. */
+    contentType: string | null;
 }
 interface QuoteRequest {
     /** HTTP method the resource is sold at. Defaults to POST, same as the shared pay-flow. */
     method?: 'GET' | 'POST';
     /** POST probe body. Ignored for GET. Defaults to `{}`. */
     body?: string;
+    /**
+     * POST content type. Undefined means `application/json`. Null means the
+     * probe sends no content type, which must match the later payment.
+     */
+    contentType?: string | null;
 }
 
 interface ClientOptions {
@@ -47,8 +54,8 @@ interface PayRequest {
     maxAmount?: string;
     asset?: string;
     /**
-     * Defaults to POST when `json` or `body` is set, otherwise GET. A quote
-     * remembers the method it probed, and pay replays that when this is omitted.
+     * Omitted with no body is GET, including the price probe. A body makes it
+     * POST. A quote's method wins when this is omitted.
      */
     method?: 'GET' | 'POST';
     dialect?: Quote['dialect'];

package/dist/index.js

@@ -6478,18 +6478,25 @@ async function createPayer(options) {
 }
 
 // src/quote.ts
-function probeInit(method, body) {
-  if (method === "GET") return { method: "GET" };
+function probeInit(method, body, contentType) {
+  if (method === "GET") return { method: "GET", redirect: "manual" };
+  const headers = {};
+  if (contentType) headers["content-type"] = contentType;
   return {
     method: "POST",
-    headers: { "content-type": "application/json" },
+    redirect: "manual",
+    headers,
     body
   };
 }
 async function quoteResource(url, fetchImpl = fetch, request = {}) {
   const method = request.method === "GET" ? "GET" : "POST";
-  const body = request.body ?? "{}";
-  const response = await fetchImpl(url, probeInit(method, body));
+  const body = method === "POST" ? request.body ?? "{}" : "";
+  const contentType = method === "GET" ? null : request.contentType === void 0 ? "application/json" : request.contentType;
+  const response = await fetchImpl(url, probeInit(method, body, contentType));
+  if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) {
+    throw new Error("quote refused a redirect");
+  }
   if (response.status !== 402) {
     throw new Error(`quote expected HTTP 402, got ${response.status}`);
   }
@@ -6509,7 +6516,8 @@ async function quoteResource(url, fetchImpl = fetch, request = {}) {
     dialect: mppOffer ? "mpp" : "x402",
     decimals: offer.decimals,
     method,
-    ...method === "POST" ? { body } : {}
+    ...method === "POST" ? { body } : {},
+    contentType
   };
 }
 
@@ -6545,18 +6553,86 @@ function contentTypeFrom(headers) {
   }
   return contentType;
 }
-function jsonBody(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error("pay json must be an object");
+function assertGatewayResource(resourceUrl, gatewayUrl) {
+  let resource;
+  let gateway;
+  try {
+    resource = new URL(resourceUrl);
+    gateway = new URL(gatewayUrl);
+  } catch {
+    throw new Error("resource URL must be absolute http(s) on the gateway origin");
+  }
+  if (resource.protocol !== "http:" && resource.protocol !== "https:") {
+    throw new Error("resource URL must be absolute http(s) on the gateway origin");
+  }
+  if (resource.origin !== gateway.origin) {
+    throw new Error(
+      `resource origin ${resource.origin} does not match gateway ${gateway.origin}`
+    );
+  }
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function canonicalJson(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null) return "null";
+  const type = typeof value;
+  if (type === "boolean") return value ? "true" : "false";
+  if (type === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("pay json must be finite; NaN and Infinity are not payable");
+    }
+    return JSON.stringify(value);
+  }
+  if (type === "string") return JSON.stringify(value);
+  if (type === "bigint" || type === "undefined" || type === "function" || type === "symbol") {
+    throw new Error(`pay json must not contain ${type}`);
+  }
+  const object = value;
+  if (typeof object.toJSON === "function") {
+    throw new Error("pay json must be a plain object; toJSON is not payable");
+  }
+  if (seen.has(object)) throw new Error("pay json must not be cyclic");
+  seen.add(object);
+  try {
+    if (Array.isArray(object)) {
+      return `[${object.map((item) => canonicalJson(item, seen)).join(",")}]`;
+    }
+    if (!isPlainObject(object)) throw new Error("pay json must be a plain object");
+    const entries = Object.entries(object).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item, seen)}`).join(",")}}`;
+  } finally {
+    seen.delete(object);
   }
-  return JSON.stringify(value);
+}
+function jsonBody(value) {
+  if (!isPlainObject(value)) throw new Error("pay json must be a plain object");
+  return canonicalJson(value);
 }
 function hasBytes(body) {
   if (body === void 0) return false;
   if (typeof body === "string") return body.length > 0;
   return body.byteLength > 0;
 }
-function resolvePay(url, input) {
+function sameBytes(left, right) {
+  if (left.byteLength !== right.byteLength) return false;
+  for (let i = 0; i < left.byteLength; i += 1) {
+    if (left[i] !== right[i]) return false;
+  }
+  return true;
+}
+function asBytes(body) {
+  return typeof body === "string" ? new TextEncoder().encode(body) : body;
+}
+function integerAmount(value, label) {
+  if (!/^[0-9]+$/.test(value)) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return BigInt(value);
+}
+function freezePay(url, input) {
   const quoted = input?.quote;
   if (quoted && quoted.resource !== url) {
     throw new Error("pay quote.resource must match the URL being paid");
@@ -6564,39 +6640,79 @@ function resolvePay(url, input) {
   if (input?.json !== void 0 && input.body !== void 0) {
     throw new Error("pay accepts json or body, not both");
   }
-  let contentType = contentTypeFrom(input?.headers);
+  const headerType = contentTypeFrom(input?.headers) ?? null;
   let body;
+  let contentType = headerType;
   if (input?.json !== void 0) {
     body = jsonBody(input.json);
-    contentType = contentType ?? "application/json";
+    contentType = headerType ?? "application/json";
+  } else if (typeof input?.body === "string") {
+    body = input.body;
+    contentType = headerType ?? "application/json";
   } else if (input?.body !== void 0) {
     body = input.body;
   } else if (typeof quoted?.body === "string") {
     body = quoted.body;
-    if (quoted.method === "POST") contentType = contentType ?? "application/json";
+    contentType = headerType ?? quoted.contentType;
+  }
+  const method = input?.method ?? quoted?.method ?? (body !== void 0 ? "POST" : "GET");
+  if (quoted && input?.method && input.method !== quoted.method) {
+    throw new Error("pay method must match the quote");
   }
-  const method = input?.method ?? quoted?.method ?? (body !== void 0 ? "POST" : void 0);
   if (method === "GET" && hasBytes(body)) {
     throw new Error('pay GET cannot carry a body; pass method: "POST"');
   }
-  return { quote: quoted, method, body, contentType };
-}
-function toPayInput(url, input, resolved) {
-  const quoted = resolved.quote;
-  const maxAmount = input?.maxAmount?.trim() || quoted?.amount;
-  const asset = input?.asset?.trim() || quoted?.asset;
-  if (!maxAmount || !asset) {
-    throw new Error("pay requires maxAmount and asset (or a quote that carries them)");
+  if (method === "GET" && contentType) {
+    throw new Error("pay GET cannot declare a content type");
   }
-  const dialect = input?.dialect ?? quoted?.dialect;
-  const recipient = quoted?.payTo;
+  if (quoted) {
+    if ((contentType ?? null) !== (quoted.contentType ?? null)) {
+      throw new Error("pay content type must match the quote");
+    }
+    if (quoted.body !== void 0 || body !== void 0) {
+      const quotedBytes = new TextEncoder().encode(quoted.body ?? "");
+      const paidBytes = body === void 0 ? new Uint8Array() : asBytes(body);
+      if (!sameBytes(quotedBytes, paidBytes)) {
+        throw new Error("pay body must match the quoted bytes");
+      }
+    }
+  }
+  return { method, body, contentType, quote: quoted };
+}
+function spendCeiling(input, quote2) {
+  if (!quote2) {
+    const maxAmount2 = input?.maxAmount?.trim();
+    const asset = input?.asset?.trim();
+    if (!maxAmount2 || !asset) {
+      throw new Error("pay requires maxAmount and asset (or a quote that carries them)");
+    }
+    integerAmount(maxAmount2, "maxAmount");
+    return { maxAmount: maxAmount2, asset };
+  }
+  const callerAsset = input?.asset?.trim();
+  if (callerAsset && callerAsset !== quote2.asset) {
+    throw new Error("pay asset must match the quote");
+  }
+  const quoted = integerAmount(quote2.amount.trim(), "quote.amount");
+  let maxAmount = quote2.amount.trim();
+  const callerRaw = input?.maxAmount?.trim();
+  if (callerRaw) {
+    const caller = integerAmount(callerRaw, "maxAmount");
+    if (caller < quoted) maxAmount = callerRaw;
+  }
+  return { maxAmount, asset: quote2.asset };
+}
+function toPayInput(resolved, quote2, input) {
+  const { maxAmount, asset } = spendCeiling(input, quote2);
+  const dialect = input?.dialect ?? quote2?.dialect;
+  const recipient = quote2?.payTo;
   return {
     intent: {
       maxAmount,
       asset,
       ...recipient ? { recipient } : {}
     },
-    ...resolved.method ? { method: resolved.method } : {},
+    method: resolved.method,
     ...dialect ? { dialect } : {},
     ...resolved.body !== void 0 ? { body: resolved.body } : {},
     ...resolved.contentType ? { contentType: resolved.contentType } : {}
@@ -6617,23 +6733,26 @@ async function createClient(options) {
   const payer = created.value;
   return {
     quote(url, request) {
+      assertGatewayResource(url, gatewayUrl);
       return quoteResource(url, fetchImpl ?? fetch, request);
     },
     async pay(url, input) {
-      let resolved = resolvePay(url, input);
-      const priced = input?.maxAmount?.trim() || input?.asset?.trim() || resolved.quote;
+      assertGatewayResource(url, gatewayUrl);
+      const frozen = freezePay(url, input);
+      const priced = input?.maxAmount?.trim() || input?.asset?.trim() || frozen.quote;
+      let quote2 = frozen.quote;
       if (!priced) {
-        if (resolved.body instanceof Uint8Array) {
+        if (frozen.body instanceof Uint8Array) {
           throw new Error("pay requires maxAmount and asset when body is raw bytes");
         }
-        const quote2 = await quoteResource(url, fetchImpl ?? fetch, {
-          ...resolved.method === "GET" ? { method: "GET" } : {},
-          ...typeof resolved.body === "string" ? { body: resolved.body } : {}
+        quote2 = await quoteResource(url, fetchImpl ?? fetch, {
+          method: frozen.method,
+          ...typeof frozen.body === "string" ? { body: frozen.body } : {},
+          contentType: frozen.contentType
         });
-        resolved = resolvePay(url, { ...input, quote: quote2 });
       }
-      const paid = await payer.pay(url, toPayInput(url, input, resolved));
-      return resolved.quote ? { ...paid, quote: resolved.quote } : paid;
+      const paid = await payer.pay(url, toPayInput(frozen, quote2, input));
+      return quote2 ? { ...paid, quote: quote2 } : paid;
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmdoss/suipay",
-  "version": "0.1.0",
+  "version": "0.1.1-dev.0",
   "private": false,
   "type": "module",
   "description": "SuiPay embeddable client \u2014 quote and pay a 402 from a spend-account grant.",