@zeroxyz/sdk 0.3.0 → 0.5.0

package/dist/{chunk-FH6C6TXR.js → chunk-RY3VFSIE.js}

@@ -77,6 +77,16 @@ var ZeroPaymentError = class extends ZeroError {
     this.name = "ZeroPaymentError";
   }
 };
+var ZeroInsufficientFundsError = class extends ZeroError {
+  have;
+  need;
+  constructor(message, init) {
+    super("insufficient_funds", message, { cause: init.cause });
+    this.name = "ZeroInsufficientFundsError";
+    this.have = init.have;
+    this.need = init.need;
+  }
+};
 var ZeroSessionCloseFailedError = class extends ZeroError {
   session;
   response;
@@ -423,7 +433,12 @@ var FETCH_SKIP_REASONS = Object.freeze({
   bodyReadFailed: "body_read_failed",
   mppSessionCloseFailedNotRecorded: "mpp_session_close_failed_not_recorded",
   paidButStill402NotRecorded: FETCH_WARNINGS.paidButStill402NotRecorded,
-  paymentSettlementUnconfirmed: FETCH_WARNINGS.paymentSettlementUnconfirmed
+  paymentSettlementUnconfirmed: FETCH_WARNINGS.paymentSettlementUnconfirmed,
+  // Pre-sign abort: deliberately NOT recorded as a run — the wallet was
+  // empty before we reached the capability, so charging it as a 402 would
+  // corrupt cap reliability. The wallet funnel is tracked via the
+  // fetch_executed.outcome analytics event instead.
+  insufficientFunds: "insufficient_funds_not_recorded"
 });
 var MAX_RECEIPT_HEADER_BYTES = 8 * 1024;
 var decodeSessionReceiptHeader = (header) => {
@@ -565,6 +580,7 @@ var Payments = class {
     );
     let capturedAmount = null;
     let capturedNetwork;
+    let preflightError = null;
     const x402 = registerExactEvmScheme(new x402Client(), { signer: account });
     x402.onBeforePaymentCreation(async (context) => {
       const selected = context.selectedRequirements;
@@ -598,6 +614,29 @@ var Payments = class {
           reason: `Payment of ${capturedAmount} USDC exceeds maxPay ${input.maxPay}`
         };
       }
+      const detected = networkToChain(capturedNetwork);
+      const balanceChain = detected === "base-sepolia" ? "base-sepolia" : "base";
+      let balance = null;
+      try {
+        balance = await this.readUsdcBalance(account.address, balanceChain);
+      } catch (readErr) {
+        this.client.logger?.({
+          level: "warn",
+          message: "Pre-flight balance read failed; proceeding to attempt payment",
+          meta: {
+            chain: balanceChain,
+            error: readErr instanceof Error ? readErr.message : String(readErr)
+          }
+        });
+      }
+      if (balance !== null && balance < rawAmountUnits) {
+        const have = formatUnits(balance, 6);
+        preflightError = new ZeroInsufficientFundsError(
+          `wallet has ${have} USDC on Base, needs ${capturedAmount}.`,
+          { have, need: capturedAmount }
+        );
+        return { abort: true, reason: preflightError.message };
+      }
     });
     const configuredFetch = buildConfiguredFetch(this.client, {
       timeoutMs: input.timeoutMs
@@ -618,6 +657,7 @@ var Payments = class {
         signal: input.signal
       });
     } catch (err) {
+      if (preflightError) throw preflightError;
       if (err instanceof ZeroError) throw err;
       throw new ZeroPaymentError(
         `x402 payment failed: ${err instanceof Error ? err.message : String(err)}`,
@@ -862,23 +902,29 @@ var Payments = class {
     );
     if (tempoBalance < requiredRaw) {
       if (coerced.chain === "tempo-testnet") {
-        throw new ZeroPaymentError(
-          `Insufficient pathUSD on Tempo testnet: have ${formatUnits(tempoBalance, 6)}, need ${capturedAmount}. Fund via the Tempo testnet faucet: https://docs.tempo.xyz/quickstart/faucet`
+        const have = formatUnits(tempoBalance, 6);
+        throw new ZeroInsufficientFundsError(
+          `Insufficient pathUSD on Tempo testnet: have ${have}, need ${capturedAmount}. Fund via the Tempo testnet faucet: https://docs.tempo.xyz/quickstart/faucet`,
+          { have, need: capturedAmount }
         );
       }
-      await this.bridgeBaseToTempo(account, requiredRaw - tempoBalance);
+      await this.bridgeBaseToTempo(account, requiredRaw - tempoBalance, {
+        isSessionDeposit: challenge.intent === "session",
+        depositTotal: capturedAmount
+      });
     }
     return capturedAmount;
   };
-  bridgeBaseToTempo = async (account, requiredAmount) => {
+  bridgeBaseToTempo = async (account, requiredAmount, depositContext) => {
     this.ensureRelayClient();
     const baseBalance = await this.readUsdcBalance(account.address, "base");
     const buffer = calculateBuffer(baseBalance);
     const bridgeAmount = requiredAmount + buffer;
     if (baseBalance < bridgeAmount) {
-      throw new ZeroPaymentError(
-        `Insufficient Base USDC to bridge: have ${formatUnits(baseBalance, 6)}, need ${formatUnits(bridgeAmount, 6)} (${formatUnits(requiredAmount, 6)} + ${formatUnits(buffer, 6)} buffer). This capability uses an MPP payment channel, which is pre-funded up front. Either fund your wallet on Base, or pass \`maxPay\` to size a smaller channel (e.g. \`maxPay: '0.05'\` for a ~5-cent channel sized for a single cheap call).`
-      );
+      const have = formatUnits(baseBalance, 6);
+      const need = formatUnits(bridgeAmount, 6);
+      const message = depositContext?.isSessionDeposit ? `wallet has ${have} USDC on Base, but this capability pre-funds a ${depositContext.depositTotal} USDC MPP payment channel up front (the channel is deposited before the call, so it asks for more than a single charge). Needs ${need} on Base to open it \u2014 fund the wallet, or pass a smaller \`maxPay\` (e.g. '0.05') to size the channel down to one cheap call.` : `wallet has ${have} USDC on Base, needs ${need} to fund this capability's MPP payment channel (${formatUnits(requiredAmount, 6)} + ${formatUnits(buffer, 6)} buffer). Tip: pass a smaller \`maxPay\` (e.g. '0.05') to size a cheaper channel.`;
+      throw new ZeroInsufficientFundsError(message, { have, need });
     }
     this.client.logger?.({
       level: "info",
@@ -1098,7 +1144,7 @@ var Payments = class {
 
 // package.json
 var package_default = {
-  version: "0.3.0"};
+  version: "0.5.0"};
 
 // src/version.ts
 var SDK_VERSION = package_default.version;
@@ -1755,6 +1801,11 @@ var capabilityResponseSchema = z.object({
   lastUsedAt: z.string().nullable().optional(),
   lastSuccessfullyRanAt: z.string().nullable().optional()
 });
+var resolveCapabilityResponseSchema = z.object({
+  capabilityId: z.string(),
+  capabilitySlug: z.string(),
+  matchedVia: z.enum(["exact", "template"])
+});
 
 // src/namespaces/capabilities.ts
 var Capabilities = class {
@@ -1771,6 +1822,31 @@ var Capabilities = class {
     },
     capabilityResponseSchema
   );
+  // Resolve a raw endpoint URL + method back to the capability that owns it,
+  // for the `zero fetch <url>` case where the client has no local search
+  // context to match against (a memoized/cross-session URL). Returns null on
+  // 404 — i.e. no match or an ambiguous multi-match, both of which the server
+  // reports as 404 (resolveByUrl fails closed rather than mis-attribute).
+  // The URL travels in the POST body so it stays out of access logs and is
+  // never stored; the caller uses the returned capabilityId to record an
+  // attributed run without the URL ever touching the run row (ZERO-335).
+  resolveByUrl = async (url, method, opts = {}) => {
+    try {
+      return await request(
+        this.client,
+        {
+          method: "POST",
+          path: "/v1/capabilities/resolve",
+          body: { url, method },
+          signal: opts.signal
+        },
+        resolveCapabilityResponseSchema
+      );
+    } catch (err) {
+      if (err instanceof ZeroApiError && err.status === 404) return null;
+      throw err;
+    }
+  };
 };
 var createRunResponseSchema = z.object({
   runId: z.string()
@@ -2351,14 +2427,17 @@ var resolveRecordingClient = (client, opts) => {
   const canRecord = opts.account !== void 0 || credentials.kind === "account" || credentials.kind === "session";
   return { recordingClient, canRecord };
 };
-var recordErrorFetchRun = async (client, opts, result) => {
-  if (opts.capabilityId === void 0) return;
+var recordErrorFetchRun = async (client, opts, result, capabilityIdOverride) => {
+  const effectiveCapId = opts.capabilityId;
+  if (effectiveCapId === void 0) return;
   const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
   if (!canRecord) return;
+  const fetchOriginForRecord = opts.capabilityId === void 0 ? "direct_url" : opts.fetchOrigin;
   try {
     const created = await recordingClient.runs.create({
-      capabilityId: opts.capabilityId,
+      capabilityId: effectiveCapId,
       ...opts.searchId && { searchId: opts.searchId },
+      ...fetchOriginForRecord && { fetchOrigin: fetchOriginForRecord },
       ...result.status !== null && { status: result.status },
       latencyMs: result.latencyMs,
       ...opts.requestSchema && { requestSchema: opts.requestSchema }
@@ -2368,7 +2447,7 @@ var recordErrorFetchRun = async (client, opts, result) => {
   } catch {
   }
 };
-var recordTimeoutRun = async (client, opts, err, startedAt, capabilityIdRequested) => {
+var recordTimeoutRun = async (client, opts, err, startedAt, capabilityIdRequested, capabilityIdOverride) => {
   const result = errorFetchResult(
     startedAt,
     err.message,
@@ -2405,6 +2484,11 @@ var clientFetch = async (client, url, opts = {}) => {
   const startedAt = Date.now();
   const capabilityIdRequested = opts.capabilityId !== void 0;
   const method = opts.method ?? (opts.body !== void 0 ? "POST" : "GET");
+  const { canRecord: canRecordForResolve } = resolveRecordingClient(
+    client,
+    opts
+  );
+  const resolvePromise = !capabilityIdRequested && canRecordForResolve ? client.capabilities.resolveByUrl(redactUrl(url), method).catch(() => null) : Promise.resolve(null);
   const probeHeaders = withDefaultContentType(opts.headers, opts.body);
   const requestInit = {
     method,
@@ -2480,6 +2564,15 @@ var clientFetch = async (client, url, opts = {}) => {
             session: err.session
           };
           warnings.push(FETCH_WARNINGS.mppSessionCloseFailed);
+        } else if (err instanceof ZeroInsufficientFundsError) {
+          return errorFetchResult(
+            startedAt,
+            err.message,
+            FETCH_SKIP_REASONS.insufficientFunds,
+            capabilityIdRequested,
+            "insufficient_funds",
+            null
+          );
         } else if (err instanceof ZeroPaymentError || err instanceof ZeroAuthError) {
           const result2 = errorFetchResult(
             startedAt,
@@ -2587,7 +2680,15 @@ var clientFetch = async (client, url, opts = {}) => {
     else if (closeFailed)
       skipReasons.push(FETCH_SKIP_REASONS.mppSessionCloseFailedNotRecorded);
   }
-  if (opts.capabilityId !== void 0 && !paidButStill402 && !closeFailed) {
+  const resolvedCap = await resolvePromise;
+  const effectiveCapabilityId = opts.capabilityId ?? resolvedCap?.capabilityId;
+  const capabilityResolution = !capabilityIdRequested && canRecordForResolve ? resolvedCap !== null ? {
+    resolved: true,
+    capabilityId: resolvedCap.capabilityId,
+    capabilitySlug: resolvedCap.capabilitySlug,
+    matchedVia: resolvedCap.matchedVia
+  } : { resolved: false } : void 0;
+  if (effectiveCapabilityId !== void 0 && !paidButStill402 && !closeFailed) {
     const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
     if (!canRecord) {
       skipReasons.push("no_credentials");
@@ -2607,8 +2708,11 @@ var clientFetch = async (client, url, opts = {}) => {
           }
         }
         const result2 = await recordingClient.runs.create({
-          capabilityId: opts.capabilityId,
+          capabilityId: effectiveCapabilityId,
           searchId: opts.searchId,
+          // Auto-resolved runs are always direct_url — they only fire when
+          // no capabilityId was supplied (the direct_url path by definition).
+          ...opts.capabilityId === void 0 ? { fetchOrigin: "direct_url" } : opts.fetchOrigin && { fetchOrigin: opts.fetchOrigin },
           status: response.status,
           latencyMs,
           ...opts.requestSchema && { requestSchema: opts.requestSchema },
@@ -2641,7 +2745,7 @@ var clientFetch = async (client, url, opts = {}) => {
           message: "Failed to record run for fetch",
           meta: {
             url: redactUrl(url),
-            capabilityId: opts.capabilityId,
+            capabilityId: effectiveCapabilityId,
             error: errorMessage2,
             errorCode: code
           }
@@ -2669,6 +2773,8 @@ var clientFetch = async (client, url, opts = {}) => {
     result.runTrackingSkipped = skipReasons;
   }
   if (warnings.length > 0) result.warnings = warnings;
+  if (capabilityResolution !== void 0)
+    result.capabilityResolution = capabilityResolution;
   return result;
 };
 var searchResultSchema = z.object({
@@ -3083,5 +3189,5 @@ var ZeroClient = class _ZeroClient {
 };
 
 export { Auth, AuthDevice, BUG_REPORT_CATEGORIES, BugReports, Capabilities, DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, FETCH_SKIP_REASONS, FETCH_WARNINGS, Payments, Runs, SDK_VERSION, TEMPO_CHAIN_ID, TEMPO_TESTNET_CHAIN_ID, Wallet, ZeroApiError, ZeroAuthError, ZeroClient, ZeroConfigurationError, ZeroError, ZeroPaymentError, ZeroSessionCloseFailedError, ZeroTimeoutError, ZeroValidationError, ZeroWalletError, coerceTempoChainId, createManagedAccount, paymentHasAnchor, tempoChainLabelFromId };
-//# sourceMappingURL=chunk-FH6C6TXR.js.map
-//# sourceMappingURL=chunk-FH6C6TXR.js.map
+//# sourceMappingURL=chunk-RY3VFSIE.js.map
+//# sourceMappingURL=chunk-RY3VFSIE.js.map