@t2000/cli 10.25.0 → 10.26.0

package/dist/index.js

@@ -28618,11 +28618,65 @@ function preflightPay(input) {
   }
   return PREFLIGHT_OK;
 }
-async function payWithX402(args) {
-  const { signer, client } = args;
-  let options = args.options;
-  const pf = preflightPay({ url: options.url, maxPrice: options.maxPrice });
+async function probeX402(args) {
+  const { network } = args;
+  const pf = preflightPay({ url: args.options.url, maxPrice: args.options.maxPrice });
   if (!pf.valid) throw new T2000Error(pf.code, pf.error);
+  const { reqInit } = normalizePayRequest(args.options);
+  const probe = await fetch(args.options.url, reqInit);
+  if (probe.status !== 402) {
+    return {
+      kind: "free",
+      status: probe.status,
+      note: "No payment required \u2014 this endpoint served without a 402."
+    };
+  }
+  const pick = await pickSuiExactRequirements(probe, network);
+  if (pick.kind === "payable") {
+    const requirements = pick.requirements;
+    const priceUsdc = atomicToHuman(
+      BigInt(requirements.maxAmountRequired),
+      await assetDecimals(requirements.asset)
+    );
+    const { isX402EscrowRequirements } = await import("./dist-VUHPQJYY.js");
+    if (isX402EscrowRequirements(requirements)) {
+      return {
+        kind: "escrow",
+        priceUsdc,
+        payTo: requirements.payTo,
+        note: "This endpoint sells deliverable work through on-chain escrow, not an instant call. Hire it as a job instead \u2014 funds lock in a Job object and release on delivery."
+      };
+    }
+    return {
+      kind: "payable",
+      priceUsdc,
+      asset: requirements.asset,
+      payTo: requirements.payTo,
+      network
+    };
+  }
+  if (hasPaymentAuthenticateHeader(probe)) {
+    return {
+      kind: "unsupported",
+      reason: "header-only-402-unsupported",
+      note: "This seller answered a header-only 402 (WWW-Authenticate: Payment) with no payable x402 accepts[] envelope. That dialect is no longer supported \u2014 the seller must offer x402 (e.g. @t2000/serve emits it)."
+    };
+  }
+  if (pick.kind === "incomplete") {
+    return {
+      kind: "incomplete",
+      reason: "incomplete-x402-accepts",
+      note: "Seller's x402 challenge is incomplete (missing extra.suimpp) \u2014 the 402 advertises an exact/sui entry but carries no settlement challenge to bind a payment to."
+    };
+  }
+  return {
+    kind: "not-x402",
+    status: probe.status,
+    note: `Endpoint returned 402 without an x402 'exact' / sui:${network} requirement in the body. Nothing this SDK can pay.`
+  };
+}
+function normalizePayRequest(input) {
+  let options = input;
   const method = (options.method ?? "GET").toUpperCase();
   const canHaveBody = method !== "GET" && method !== "HEAD";
   if (canHaveBody && typeof options.body === "string" && isJsonText(options.body) && !hasContentType(options.headers)) {
@@ -28631,11 +28685,23 @@ async function payWithX402(args) {
       headers: { ...options.headers ?? {}, "content-type": "application/json" }
     };
   }
-  const reqInit = {
-    method,
-    headers: options.headers,
-    body: canHaveBody ? options.body : void 0
+  return {
+    options,
+    reqInit: {
+      method,
+      headers: options.headers,
+      body: canHaveBody ? options.body : void 0
+    }
   };
+}
+async function payWithX402(args) {
+  const { signer, client } = args;
+  let options = args.options;
+  const pf = preflightPay({ url: options.url, maxPrice: options.maxPrice });
+  if (!pf.valid) throw new T2000Error(pf.code, pf.error);
+  const normalized = normalizePayRequest(options);
+  options = normalized.options;
+  const reqInit = normalized.reqInit;
   const probe = await fetch(options.url, reqInit);
   if (probe.status !== 402) {
     return finalize(probe, { paid: false });
@@ -29311,10 +29377,19 @@ var RESOLVE_NAME_QUERY = `query ResolveSuins($name: String!) {
 }`;
 var SUI_ADDRESS_REGEX = /^0x[a-fA-F0-9]{1,64}$/i;
 var SUINS_NAME_REGEX = /^[a-z0-9-]+(\.[a-z0-9-]+)*\.sui$/;
+var AUDRIC_HANDLE_RE = /^([a-z0-9-]+)@audric$/i;
+function canonicalizeRecipientInput(raw) {
+  const trimmed = raw.trim();
+  const m = AUDRIC_HANDLE_RE.exec(trimmed);
+  if (m) {
+    return `${m[1].toLowerCase()}.audric.sui`;
+  }
+  return trimmed;
+}
 var InvalidAddressError = class extends Error {
   constructor(raw) {
     super(
-      `"${raw}" isn't a valid Sui address or SuiNS name. Pass a 0x-prefixed hex address (e.g. 0x40cd\u20263e62) or a SuiNS name ending in .sui (e.g. alex.sui).`
+      `"${raw}" isn't a valid Sui address or SuiNS name. Pass a 0x-prefixed hex address (e.g. 0x40cd\u20263e62), a SuiNS name ending in .sui (e.g. alex.sui), or a Passport handle (e.g. alex@audric).`
     );
     this.raw = raw;
     this.name = "InvalidAddressError";
@@ -29338,10 +29413,10 @@ var SuinsRpcError = class extends Error {
 };
 function looksLikeSuiNs(value) {
   if (!value) return false;
-  return SUINS_NAME_REGEX.test(value.trim().toLowerCase());
+  return SUINS_NAME_REGEX.test(canonicalizeRecipientInput(value).toLowerCase());
 }
 async function resolveSuinsViaRpc(rawName, ctx = {}) {
-  const name = rawName.trim().toLowerCase();
+  const name = canonicalizeRecipientInput(rawName).toLowerCase();
   if (!SUINS_NAME_REGEX.test(name)) {
     throw new InvalidAddressError(rawName);
   }
@@ -30113,6 +30188,15 @@ var T2000 = class _T2000 extends import_index2.default {
     return this._signer;
   }
   // -- MPP Payments --
+  /**
+   * READ-ONLY price probe for an x402 endpoint (S.919). Reports what `pay()`
+   * would cost without signing or spending, so a caller (Connect's
+   * `t2000_pay_probe`, the CLI, a UI) can show terms before committing.
+   * No limit gate: nothing moves.
+   */
+  async payProbe(options) {
+    return await probeX402({ network: this.client.network, options });
+  }
   async pay(options) {
     this.limits.assert({ operation: "pay", amountUsd: options.maxPrice ?? 0, force: options.force });
     const result = await payWithX402({ signer: this._signer, client: this.client, options });
@@ -30403,7 +30487,7 @@ var T2000 = class _T2000 extends import_index2.default {
    * with the live execute path (never resolve the same input two ways).
    */
   async resolveRecipient(input) {
-    const trimmed = input.trim();
+    const trimmed = canonicalizeRecipientInput(input);
     if (SUI_ADDRESS_REGEX.test(trimmed)) {
       return { address: trimmed.toLowerCase() };
     }
@@ -30427,7 +30511,7 @@ var T2000 = class _T2000 extends import_index2.default {
     }
     throw new T2000Error(
       "INVALID_ADDRESS",
-      `Cannot resolve recipient "${input}". Provide a 0x address or a .sui name.`
+      `Cannot resolve recipient "${input}". Provide a 0x address, a .sui name, or a Passport handle (name@audric).`
     );
   }
   async balance() {