@zeroxyz/sdk 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to `@zeroxyz/sdk` will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) — with the pre-1.0 caveat that minor versions may include breaking changes.
 
+## 0.4.0
+
+### Added
+
+- Pre-flight **balance gate** on paid `client.fetch()` / `payments.pay()` / `payments.payMpp()`. Before signing a paid leg the SDK reads the payer's USDC balance (x402 → Base; MPP → Tempo, including the Base→Tempo bridge math) and, if it can't cover the call, aborts with the new `ZeroInsufficientFundsError` instead of signing a doomed transaction. Previously an empty wallet signed anyway, the chain rejected, and the run was recorded at status 402 → the server classified it `payment_gated`, **indistinguishable from a capability that correctly payment-gates** — so unfunded wallets silently dinged cap reliability. (#585)
+- New `FetchOutcome` value **`insufficient_funds`** and new error class **`ZeroInsufficientFundsError`** (`ZeroErrorCode` `insufficient_funds`, carrying `have` / `need`). On this outcome `client.fetch()` records **no run** (`status: null`, `runTrackingSkipped` includes `insufficient_funds_not_recorded`) — a wallet condition is never charged against the capability; the wallet funnel stays observable via the `fetch_executed.outcome` analytics event. (#585)
+
+### Notes
+
+- The balance read is **fail-open**: an RPC error proceeds to attempt payment rather than re-introducing a false `payment_gated`. Free capabilities are unaffected — a non-402 response never enters the payment path, and a `0`-amount challenge passes the gate (`balance < 0` is never true). The `maxPay` contract is unchanged. (#585)
+
 ## 0.3.0
 
 ### Added

package/README.md

@@ -118,9 +118,15 @@ switch (result.outcome) {
   case "success":
     // 2xx/3xx — result.body / result.bodyRaw are populated.
     break;
+  case "insufficient_funds":
+    // Wallet balance is too low to cover the challenge amount. No payment
+    // was attempted. Top off via `zero wallet fund` (CLI) or fund the
+    // wallet before retrying. result.error is a ZeroInsufficientFundsError
+    // with .have and .need fields.
+    break;
   case "payment_failed":
-    // Couldn't pay: over your maxPay, insufficient balance, or an
-    // unrecognized 402 protocol. Nothing settled — generally safe to retry.
+    // Couldn't pay: over your maxPay or an unrecognized 402 protocol.
+    // Nothing settled — generally safe to retry.
     break;
   case "payment_rejected":
     // Paid, but the capability still returned 402 (a settlement/facilitator
@@ -277,10 +283,11 @@ The SDK throws typed errors instead of strings. Match them with `instanceof`:
 
 ```ts
 import {
-  ZeroApiError,                // a 4xx/5xx from Zero's own API
-  ZeroAuthError,               // missing auth, failed refresh, expired session
-  ZeroPaymentError,            // payment failed before settlement
-  ZeroSessionCloseFailedError, // MPP session-close voucher rejected
+  ZeroApiError,                  // a 4xx/5xx from Zero's own API
+  ZeroAuthError,                 // missing auth, failed refresh, expired session
+  ZeroInsufficientFundsError,    // wallet balance too low; .have and .need in USDC
+  ZeroPaymentError,              // payment failed before settlement
+  ZeroSessionCloseFailedError,   // MPP session-close voucher rejected
   ZeroTimeoutError,            // the configured timeout was exceeded
   ZeroConfigurationError,      // invalid ClientOptions
   ZeroWalletError,             // a wallet read or write failed
@@ -301,7 +308,7 @@ try {
 }
 ```
 
-`client.fetch()` reserves throwing for programmer errors — bad config, missing credentials, and the like. Expected runtime failures (`network_error`, `payment_failed`, an upstream `5xx`) come back as a `FetchResult` with the matching `outcome`, so you handle them by branching on the result rather than by catching.
+`client.fetch()` reserves throwing for programmer errors — bad config, missing credentials, and the like. Expected runtime failures (`insufficient_funds`, `network_error`, `payment_failed`, an upstream `5xx`) come back as a `FetchResult` with the matching `outcome`, so you handle them by branching on the result rather than by catching.
 
 ## Logging
 

package/dist/{chunk-LVK77C6A.cjs → chunk-5ZVIL7AZ.cjs}

@@ -79,6 +79,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;
@@ -425,7 +435,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) => {
@@ -567,6 +582,7 @@ var Payments = class {
     );
     let capturedAmount = null;
     let capturedNetwork;
+    let preflightError = null;
     const x402 = client.registerExactEvmScheme(new client$1.x402Client(), { signer: account });
     x402.onBeforePaymentCreation(async (context) => {
       const selected = context.selectedRequirements;
@@ -600,6 +616,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 = viem.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
@@ -620,6 +659,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)}`,
@@ -864,23 +904,29 @@ var Payments = class {
     );
     if (tempoBalance < requiredRaw) {
       if (coerced.chain === "tempo-testnet") {
-        throw new ZeroPaymentError(
-          `Insufficient pathUSD on Tempo testnet: have ${viem.formatUnits(tempoBalance, 6)}, need ${capturedAmount}. Fund via the Tempo testnet faucet: https://docs.tempo.xyz/quickstart/faucet`
+        const have = viem.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 ${viem.formatUnits(baseBalance, 6)}, need ${viem.formatUnits(bridgeAmount, 6)} (${viem.formatUnits(requiredAmount, 6)} + ${viem.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 = viem.formatUnits(baseBalance, 6);
+      const need = viem.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 (${viem.formatUnits(requiredAmount, 6)} + ${viem.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",
@@ -1100,7 +1146,7 @@ var Payments = class {
 
 // package.json
 var package_default = {
-  version: "0.3.0"};
+  version: "0.4.0"};
 
 // src/version.ts
 var SDK_VERSION = package_default.version;
@@ -2482,6 +2528,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,
@@ -3114,5 +3169,5 @@ exports.coerceTempoChainId = coerceTempoChainId;
 exports.createManagedAccount = createManagedAccount;
 exports.paymentHasAnchor = paymentHasAnchor;
 exports.tempoChainLabelFromId = tempoChainLabelFromId;
-//# sourceMappingURL=chunk-LVK77C6A.cjs.map
-//# sourceMappingURL=chunk-LVK77C6A.cjs.map
+//# sourceMappingURL=chunk-5ZVIL7AZ.cjs.map
+//# sourceMappingURL=chunk-5ZVIL7AZ.cjs.map