@zeroxyz/cli 1.25.0 → 1.26.1

package/dist/index.js

@@ -8785,7 +8785,7 @@ var init_BlockOverrides = __esm({
 });
 
 // ../../node_modules/.pnpm/viem@2.52.2_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/constants/abis.js
-var multicall3Abi, batchGatewayAbi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, erc1271Abi, erc6492SignatureValidatorAbi;
+var multicall3Abi, batchGatewayAbi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, erc1271Abi, erc6492SignatureValidatorAbi, erc20Abi;
 var init_abis = __esm({
   "../../node_modules/.pnpm/viem@2.52.2_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/constants/abis.js"() {
     init_esm_shims();
@@ -9140,6 +9140,194 @@ var init_abis = __esm({
         name: "isValidSig"
       }
     ];
+    erc20Abi = [
+      {
+        type: "event",
+        name: "Approval",
+        inputs: [
+          {
+            indexed: true,
+            name: "owner",
+            type: "address"
+          },
+          {
+            indexed: true,
+            name: "spender",
+            type: "address"
+          },
+          {
+            indexed: false,
+            name: "value",
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "event",
+        name: "Transfer",
+        inputs: [
+          {
+            indexed: true,
+            name: "from",
+            type: "address"
+          },
+          {
+            indexed: true,
+            name: "to",
+            type: "address"
+          },
+          {
+            indexed: false,
+            name: "value",
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "allowance",
+        stateMutability: "view",
+        inputs: [
+          {
+            name: "owner",
+            type: "address"
+          },
+          {
+            name: "spender",
+            type: "address"
+          }
+        ],
+        outputs: [
+          {
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "approve",
+        stateMutability: "nonpayable",
+        inputs: [
+          {
+            name: "spender",
+            type: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        outputs: [
+          {
+            type: "bool"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [
+          {
+            name: "account",
+            type: "address"
+          }
+        ],
+        outputs: [
+          {
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "decimals",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "uint8"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "name",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "string"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "symbol",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "string"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "totalSupply",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "transfer",
+        stateMutability: "nonpayable",
+        inputs: [
+          {
+            name: "recipient",
+            type: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        outputs: [
+          {
+            type: "bool"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "transferFrom",
+        stateMutability: "nonpayable",
+        inputs: [
+          {
+            name: "sender",
+            type: "address"
+          },
+          {
+            name: "recipient",
+            type: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        outputs: [
+          {
+            type: "bool"
+          }
+        ]
+      }
+    ];
   }
 });
 
@@ -78480,7 +78668,7 @@ init_esm_shims();
 // ../sdk/dist/index.js
 init_esm_shims();
 
-// ../sdk/dist/chunk-UWPQEIGZ.js
+// ../sdk/dist/chunk-YB3TVCUC.js
 init_esm_shims();
 
 // ../../node_modules/.pnpm/viem@2.52.2_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/index.js
@@ -88445,6 +88633,8 @@ function http(url4, config3 = {}) {
 }
 
 // ../../node_modules/.pnpm/viem@2.52.2_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/index.js
+init_abis();
+init_number();
 init_encodeAbiParameters();
 init_encodeFunctionData();
 init_getAbiItem();
@@ -163979,8 +164169,6 @@ config2(en_default3());
 
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/index.js
 var zod_default = external_exports3;
-
-// ../sdk/dist/chunk-UWPQEIGZ.js
 var createManagedAccount = (client, address5, opts = {}) => {
   const signOptions = {
     // expectedAddress pins verification to this adapter's frozen address.
@@ -164196,43 +164384,50 @@ var normalizeTransportEnvelopeRequest = (url4, opts) => {
     body: hasInnerBody ? JSON.stringify(innerBody) : void 0
   };
 };
-var KNOWN_EIP712_DOMAINS = {
-  // Base mainnet USDC. On-chain `name()` is "USD Coin" (NOT "USDC")
-  // — verified via the contract's name() / version().
-  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": {
-    name: "USD Coin",
-    version: "2"
-  },
-  // Base Sepolia USDC. Testnet's on-chain `name()` is "USDC",
-  // differs from mainnet's "USD Coin".
-  "0x036cbd53842c5426634e7929541ec2318f3dcf7e": {
-    name: "USDC",
-    version: "2"
-  }
-};
-var trimmedOrUndefined = (v) => {
-  if (typeof v !== "string") return void 0;
-  const t = v.trim();
-  return t.length > 0 ? t : void 0;
+var package_default = {
+  version: "0.19.1"
 };
-var trimStringFields = (extra) => {
-  if (!extra) return extra;
-  const out = {};
-  for (const [k, v] of Object.entries(extra)) {
-    out[k] = typeof v === "string" ? v.trim() : v;
+var SDK_VERSION2 = package_default.version;
+var refreshResponseSchema = external_exports3.object({
+  accessToken: external_exports3.string(),
+  refreshToken: external_exports3.string()
+});
+var tryRefreshSession = async (client, callerSignal) => {
+  const credentials = client.getCredentials();
+  if (credentials.kind !== "session") return false;
+  if (!credentials.refreshToken) return false;
+  const url4 = `${client.baseUrl.replace(/\/$/, "")}/v1/auth/refresh`;
+  const timeoutSignal = AbortSignal.timeout(client.timeout);
+  const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+  let response;
+  try {
+    response = await client.fetchImpl(url4, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ refreshToken: credentials.refreshToken }),
+      signal
+    });
+  } catch {
+    return false;
   }
-  return out;
-};
-var withKnownEip712Domain = (asset, extra) => {
-  const trimmedExtra = trimStringFields(extra);
-  const known = KNOWN_EIP712_DOMAINS[(asset ?? "").toLowerCase()];
-  if (!known) return trimmedExtra;
-  return {
-    ...trimmedExtra,
-    name: trimmedOrUndefined(trimmedExtra?.name) ?? known.name,
-    version: trimmedOrUndefined(trimmedExtra?.version) ?? known.version
-  };
+  if (!response.ok) return false;
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return false;
+  }
+  const parsed = refreshResponseSchema.safeParse(body);
+  if (!parsed.success) return false;
+  await client.applyRefreshedTokens({
+    accessToken: parsed.data.accessToken,
+    refreshToken: parsed.data.refreshToken
+  });
+  return true;
 };
+var buildSessionAuthHeaders = (accessToken) => ({
+  authorization: `Bearer ${accessToken}`
+});
 var ABORT_SIGNAL_ANY_AVAILABLE = typeof AbortSignal !== "undefined" && typeof AbortSignal.any === "function";
 var headersToRecord = (h) => {
   const result = {};
@@ -164359,6 +164554,383 @@ var buildConfiguredFetch = (client, overrides2) => {
   };
   return impl;
 };
+var buildCanonicalMessage = (method, pathWithQuery, body, timestamp, nonce2) => {
+  const bodyHash = createHash("sha256").update(body ?? "").digest("hex");
+  return `${method}:${pathWithQuery}:${bodyHash}:${timestamp}:${nonce2}`;
+};
+var buildAccountAuthHeaders = async (account, method, pathWithQuery, body) => {
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const nonce2 = crypto.randomUUID();
+  const message2 = buildCanonicalMessage(
+    method,
+    pathWithQuery,
+    body,
+    timestamp,
+    nonce2
+  );
+  const signature2 = await account.signMessage({ message: message2 });
+  return {
+    "x-zero-address": account.address,
+    "x-zero-timestamp": timestamp,
+    "x-zero-nonce": nonce2,
+    "x-zero-signature": signature2
+  };
+};
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
+var sleep = (ms, signal) => new Promise((resolve7, reject) => {
+  if (signal?.aborted) {
+    reject(new DOMException("Aborted", "AbortError"));
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve7();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(new DOMException("Aborted", "AbortError"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var buildPathWithQuery = (path3, query) => {
+  const normalizedPath = path3.startsWith("/") ? path3 : `/${path3}`;
+  if (!query) return normalizedPath;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) params.set(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `${normalizedPath}?${qs}` : normalizedPath;
+};
+var joinUrl = (baseUrl, pathWithQuery) => {
+  const base4 = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return `${base4}${pathWithQuery}`;
+};
+var buildHeaders = async (client, method, pathWithQuery, hasBody, bodyStr) => {
+  const headers = { ...client.defaultHeaders };
+  if (hasBody) headers["content-type"] = "application/json";
+  headers["x-zero-sdk-version"] = SDK_VERSION2;
+  if (client.apiVersion) headers["x-zero-api-version"] = client.apiVersion;
+  const credentials = client.getCredentials();
+  if (credentials.kind === "session") {
+    Object.assign(headers, buildSessionAuthHeaders(credentials.accessToken));
+  } else if (credentials.kind === "account") {
+    const signed = await buildAccountAuthHeaders(
+      credentials.account,
+      method,
+      pathWithQuery,
+      bodyStr
+    );
+    Object.assign(headers, signed);
+  }
+  return headers;
+};
+var parseErrorBody = async (response) => {
+  try {
+    return await response.clone().json();
+  } catch {
+    try {
+      return await response.text();
+    } catch {
+      return void 0;
+    }
+  }
+};
+var errorMessageFromBody = (body, status) => {
+  if (body !== null && typeof body === "object" && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return `HTTP ${status}`;
+};
+var request2 = async (client, opts, schema) => {
+  const pathWithQuery = buildPathWithQuery(opts.path, opts.query);
+  const url4 = joinUrl(client.baseUrl, pathWithQuery);
+  const hasBody = opts.body !== void 0;
+  const bodyStr = hasBody ? JSON.stringify(
+    opts.body,
+    (_k, v) => typeof v === "bigint" ? v.toString() : v
+  ) : void 0;
+  const configuredFetch = buildConfiguredFetch(client);
+  const performOnce = async () => configuredFetch(url4, {
+    method: opts.method,
+    headers: await buildHeaders(
+      client,
+      opts.method,
+      pathWithQuery,
+      hasBody,
+      bodyStr
+    ),
+    body: bodyStr,
+    signal: opts.signal
+  });
+  let refreshAttempted = false;
+  const executeWithRefresh = async () => {
+    const response = await performOnce();
+    if (response.status !== 401 || refreshAttempted) return response;
+    const credentials = client.getCredentials();
+    if (credentials.kind !== "session") return response;
+    refreshAttempted = true;
+    const refreshed = await client.refreshSessionOnce(opts.signal);
+    if (!refreshed) return response;
+    return await performOnce();
+  };
+  let lastNetworkError;
+  for (let attempt = 0; attempt <= client.maxRetries; attempt++) {
+    let response;
+    try {
+      response = await executeWithRefresh();
+    } catch (e) {
+      if (e instanceof ZeroError) throw e;
+      lastNetworkError = e;
+      if (attempt < client.maxRetries) {
+        try {
+          await sleep(2 ** attempt * 200, opts.signal);
+        } catch (sleepErr) {
+          throw new ZeroApiError("Request aborted by caller", {
+            status: 0,
+            cause: sleepErr
+          });
+        }
+        continue;
+      }
+      throw new ZeroApiError("Network request failed", {
+        status: 0,
+        cause: e
+      });
+    }
+    if (response.ok) {
+      let text;
+      try {
+        text = await response.text();
+      } catch (e) {
+        throw new ZeroApiError("Response body read failed", {
+          status: response.status,
+          cause: e
+        });
+      }
+      let json3;
+      try {
+        json3 = JSON.parse(text);
+      } catch {
+      }
+      const parsed = schema.safeParse(json3);
+      if (!parsed.success) {
+        throw new ZeroValidationError(
+          `Response did not match expected schema for ${opts.method} ${opts.path}`,
+          { cause: parsed.error, body: text }
+        );
+      }
+      return parsed.data;
+    }
+    if (RETRYABLE_STATUS.has(response.status) && attempt < client.maxRetries) {
+      try {
+        await sleep(2 ** attempt * 200, opts.signal);
+      } catch (sleepErr) {
+        throw new ZeroApiError("Request aborted by caller", {
+          status: 0,
+          cause: sleepErr
+        });
+      }
+      continue;
+    }
+    const errorBody = await parseErrorBody(response);
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    throw new ZeroApiError(errorMessageFromBody(errorBody, response.status), {
+      status: response.status,
+      requestId,
+      body: errorBody
+    });
+  }
+  throw new ZeroApiError("Exhausted retries", {
+    status: 0,
+    cause: lastNetworkError
+  });
+};
+var TEMPO_SWEEP_FEE_HEADROOM = 5000n;
+var bridgeResponseSchema = external_exports3.object({
+  sourceChain: external_exports3.enum(["base", "tempo"]),
+  destinationChain: external_exports3.enum(["base", "tempo"]),
+  sourceAmountUsdc: external_exports3.string(),
+  transferId: external_exports3.string().optional(),
+  txHash: external_exports3.string().optional(),
+  status: external_exports3.literal("pending")
+});
+var callBridgeEndpoint = (client, input) => request2(
+  client,
+  {
+    method: "POST",
+    path: "/v1/users/me/wallets/bridge",
+    body: {
+      sourceChain: input.sourceChain,
+      destinationChain: input.destinationChain,
+      ...input.amountUsdc ? { amountUsdc: input.amountUsdc } : {},
+      ...input.walletAddress ? { walletAddress: input.walletAddress } : {}
+    },
+    signal: input.signal
+  },
+  bridgeResponseSchema
+);
+var relayInitialized = false;
+var ensureRelayClient = () => {
+  if (relayInitialized) return;
+  createClient2({
+    baseApiUrl: MAINNET_RELAY_API,
+    source: "zero-sdk",
+    chains: [
+      convertViemChainToRelayChain(base),
+      convertViemChainToRelayChain(tempo)
+    ]
+  });
+  relayInitialized = true;
+};
+var executeByoReverseBridge = async (input) => {
+  ensureRelayClient();
+  const { account } = input;
+  const tempoClient = createPublicClient({ chain: tempo, transport: http() });
+  const balance = await tempoClient.readContract({
+    address: USDC_TEMPO,
+    abi: erc20Abi,
+    functionName: "balanceOf",
+    args: [account.address]
+  });
+  const amountRaw = input.amountUsdc ? parseUnits(input.amountUsdc, USDC_DECIMALS) : balance - TEMPO_SWEEP_FEE_HEADROOM;
+  if (amountRaw <= 0n) {
+    throw new ZeroInsufficientFundsError("No USDC on Tempo to consolidate", {
+      have: formatUnits(balance, USDC_DECIMALS),
+      need: formatUnits(TEMPO_SWEEP_FEE_HEADROOM, USDC_DECIMALS)
+    });
+  }
+  if (amountRaw + TEMPO_SWEEP_FEE_HEADROOM > balance) {
+    const have = formatUnits(balance, USDC_DECIMALS);
+    throw new ZeroInsufficientFundsError(
+      `Tempo balance is ${have} USDC; bridging ${formatUnits(amountRaw, USDC_DECIMALS)} needs ${formatUnits(TEMPO_SWEEP_FEE_HEADROOM, USDC_DECIMALS)} fee headroom on top`,
+      {
+        have,
+        need: formatUnits(amountRaw + TEMPO_SWEEP_FEE_HEADROOM, USDC_DECIMALS)
+      }
+    );
+  }
+  const quote = await getClient().actions.getQuote({
+    chainId: tempo.id,
+    toChainId: base.id,
+    currency: USDC_TEMPO,
+    toCurrency: USDC_BASE,
+    amount: amountRaw.toString(),
+    tradeType: "EXACT_INPUT",
+    user: account.address,
+    recipient: account.address
+  });
+  const stepTxs = [];
+  for (const step of quote.steps ?? []) {
+    for (const item of step.items ?? []) {
+      const tx = item.data;
+      if (tx?.to) stepTxs.push(tx);
+    }
+  }
+  if (stepTxs.length === 0) {
+    throw new ZeroWalletError(
+      "Relay quote for the Tempo\u2192Base bridge contained no executable steps"
+    );
+  }
+  const walletClient = createWalletClient({
+    account,
+    chain: tempo,
+    transport: http()
+  });
+  const depository = stepTxs[0]?.to;
+  if (depository) {
+    const allowance = await tempoClient.readContract({
+      address: USDC_TEMPO,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [account.address, depository]
+    });
+    if (allowance < amountRaw) {
+      const approveParams = {
+        address: USDC_TEMPO,
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [depository, maxUint256],
+        feeToken: USDC_TEMPO
+      };
+      const approveHash = await walletClient.writeContract(
+        approveParams
+      );
+      const receipt = await tempoClient.waitForTransactionReceipt({
+        hash: approveHash
+      });
+      if (receipt.status !== "success") {
+        throw new ZeroWalletError(
+          `Tempo depository approve reverted (tx ${approveHash})`
+        );
+      }
+    }
+  }
+  let lastHash = null;
+  for (const tx of stepTxs) {
+    const stepParams = {
+      to: tx.to,
+      data: tx.data,
+      value: tx.value ? BigInt(tx.value) : 0n,
+      feeToken: USDC_TEMPO
+    };
+    lastHash = await walletClient.sendTransaction(
+      stepParams
+    );
+    const receipt = await tempoClient.waitForTransactionReceipt({
+      hash: lastHash
+    });
+    if (receipt.status !== "success") {
+      throw new ZeroWalletError(
+        `Tempo\u2192Base bridge deposit reverted (tx ${lastHash})`
+      );
+    }
+  }
+  return {
+    sourceChain: "tempo",
+    destinationChain: "base",
+    sourceAmountUsdc: formatUnits(amountRaw, USDC_DECIMALS),
+    txHash: lastHash ?? void 0,
+    status: "pending"
+  };
+};
+var KNOWN_EIP712_DOMAINS = {
+  // Base mainnet USDC. On-chain `name()` is "USD Coin" (NOT "USDC")
+  // — verified via the contract's name() / version().
+  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": {
+    name: "USD Coin",
+    version: "2"
+  },
+  // Base Sepolia USDC. Testnet's on-chain `name()` is "USDC",
+  // differs from mainnet's "USD Coin".
+  "0x036cbd53842c5426634e7929541ec2318f3dcf7e": {
+    name: "USDC",
+    version: "2"
+  }
+};
+var trimmedOrUndefined = (v) => {
+  if (typeof v !== "string") return void 0;
+  const t = v.trim();
+  return t.length > 0 ? t : void 0;
+};
+var trimStringFields = (extra) => {
+  if (!extra) return extra;
+  const out = {};
+  for (const [k, v] of Object.entries(extra)) {
+    out[k] = typeof v === "string" ? v.trim() : v;
+  }
+  return out;
+};
+var withKnownEip712Domain = (asset, extra) => {
+  const trimmedExtra = trimStringFields(extra);
+  const known = KNOWN_EIP712_DOMAINS[(asset ?? "").toLowerCase()];
+  if (!known) return trimmedExtra;
+  return {
+    ...trimmedExtra,
+    name: trimmedOrUndefined(trimmedExtra?.name) ?? known.name,
+    version: trimmedOrUndefined(trimmedExtra?.version) ?? known.version
+  };
+};
 var looksLikeX402Body = (body) => {
   if (!body || typeof body !== "object") return false;
   const b = body;
@@ -164423,6 +164995,9 @@ var networkToChain = (network) => {
 var MAX_PAY_RE = /^[0-9]+(\.[0-9]{1,6})?$/;
 var UINT_RE = /^[0-9]+$/;
 var MAX_AMOUNT_DIGITS = 30;
+var JIT_REVERSE_FEE_MARGIN = 50000n;
+var BRIDGE_FILL_POLL_INTERVAL_MS = 2e3;
+var BRIDGE_FILL_TIMEOUT_MS = 9e4;
 var USDC_BASE2 = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
 var USDC_TEMPO2 = "0x20c000000000000000000000b9537d11c60e8b50";
 var PATHUSD_TEMPO = "0x20c0000000000000000000000000000000000000";
@@ -164469,6 +165044,10 @@ var resolveDefaultPrefund = (displayCostAmount) => {
   return bounded.toFixed(6).replace(/\.?0+$/, "");
 };
 var isUintString = (v) => typeof v === "string" && v.length > 0 && v.length <= MAX_AMOUNT_DIGITS && UINT_RE.test(v);
+var buildTempoPaymentMethods = (parameters) => [
+  tempo2(parameters),
+  tempo2.sessionLegacy.method(parameters)
+];
 var coerceTempoChainId = (raw) => {
   const id = typeof raw === "number" && Number.isFinite(raw) ? raw : typeof raw === "string" && /^-?[0-9]+$/.test(raw) ? Number(raw) : null;
   if (id === TEMPO_CHAIN_ID2) return { id, chain: "tempo" };
@@ -164720,6 +165299,9 @@ var Payments = class {
         });
       }
       if (balance !== null && balance < rawAmountUnits) {
+        if (balanceChain === "base" && await this.tryJitReverseBridge(account, rawAmountUnits, balance)) {
+          return;
+        }
         const have = formatUnits(balance, 6);
         const requiredAmount = formatUnits(rawAmountUnits, 6);
         preflightError = new ZeroInsufficientFundsError(
@@ -164855,43 +165437,44 @@ var Payments = class {
     let capturedChallenge;
     let channelEntry;
     let openTimeCumulative;
+    const handleChannelUpdate = (entry) => {
+      let cumulative;
+      if (typeof entry.cumulativeAmount === "bigint") {
+        cumulative = entry.cumulativeAmount;
+      } else {
+        cumulative = 0n;
+        this.client.logger?.({
+          level: "warn",
+          message: "mppx emitted non-bigint cumulativeAmount; coerced to 0n",
+          meta: { actualType: typeof entry.cumulativeAmount }
+        });
+      }
+      if (openTimeCumulative === void 0 && entry.opened) {
+        openTimeCumulative = cumulative;
+      }
+      const wasOpened = channelEntry?.opened ?? false;
+      channelEntry = {
+        channelId: entry.channelId,
+        // mppx >=0.8 renamed the channel-entry escrow field from
+        // `escrowContract` to `escrow` (see SessionManager
+        // entryFromSnapshot); the legacy client still emits
+        // `escrowContract`. Read `escrow` first, fall back to the old
+        // name, then to any value we already latched so a later
+        // escrow-less emit can't blank an open channel's escrow.
+        escrowContract: entry.escrow ?? entry.escrowContract ?? channelEntry?.escrowContract ?? "0x0000000000000000000000000000000000000000",
+        cumulativeAmount: cumulative,
+        opened: wasOpened || entry.opened
+      };
+    };
+    const tempoMethodParams = {
+      account,
+      maxDeposit: input.maxPay ?? resolveDefaultPrefund(input.displayCostAmount),
+      onChannelUpdate: handleChannelUpdate
+    };
     const mppx = Mppx_exports.create({
       polyfill: false,
       fetch: configuredFetch,
-      methods: [
-        tempo2({
-          account,
-          maxDeposit: input.maxPay ?? resolveDefaultPrefund(input.displayCostAmount),
-          onChannelUpdate: (entry) => {
-            let cumulative;
-            if (typeof entry.cumulativeAmount === "bigint") {
-              cumulative = entry.cumulativeAmount;
-            } else {
-              cumulative = 0n;
-              this.client.logger?.({
-                level: "warn",
-                message: "mppx emitted non-bigint cumulativeAmount; coerced to 0n",
-                meta: { actualType: typeof entry.cumulativeAmount }
-              });
-            }
-            if (openTimeCumulative === void 0 && entry.opened) {
-              openTimeCumulative = cumulative;
-            }
-            const wasOpened = channelEntry?.opened ?? false;
-            channelEntry = {
-              channelId: entry.channelId,
-              // mppx >=0.8 renamed the channel-entry escrow field from
-              // `escrowContract` to `escrow` (see SessionManager
-              // entryFromSnapshot). Read `escrow` first, fall back to the
-              // old name, then to any value we already latched so a later
-              // escrow-less emit can't blank an open channel's escrow.
-              escrowContract: entry.escrow ?? entry.escrowContract ?? channelEntry?.escrowContract ?? "0x0000000000000000000000000000000000000000",
-              cumulativeAmount: cumulative,
-              opened: wasOpened || entry.opened
-            };
-          }
-        })
-      ],
+      methods: buildTempoPaymentMethods(tempoMethodParams),
       onChallenge: async (challenge2) => {
         capturedChallenge = challenge2;
         capturedAmount = await this.prepareTempoFunds(
@@ -165075,6 +165658,28 @@ var Payments = class {
       level: "info",
       message: `Bridging ${formatUnits(bridgeAmount, 6)} USDC from Base to Tempo...`
     });
+    if (this.client.getCredentials().kind === "session") {
+      const tempoBalanceBefore = await this.readUsdcBalance(
+        account.address,
+        "tempo"
+      );
+      const response = await callBridgeEndpoint(this.client, {
+        sourceChain: "base",
+        destinationChain: "tempo",
+        amountUsdc: formatUnits(bridgeAmount, 6)
+      });
+      const filled = await this.waitForUsdcBalance(
+        account.address,
+        "tempo",
+        tempoBalanceBefore + requiredAmount
+      );
+      if (!filled) {
+        throw new ZeroPaymentError(
+          "Base\u2192Tempo bridge did not fill in time; funds may still arrive \u2014 retry shortly"
+        );
+      }
+      return response.txHash ?? null;
+    }
     const walletClient = createWalletClient({
       account,
       chain: base,
@@ -165105,6 +165710,59 @@ var Payments = class {
     });
     return bridgeTxHash;
   };
+  // Recover an x402 shortfall from the wallet's Tempo balance. Returns true
+  // once the Base balance covers `requiredRaw`; false means "couldn't help"
+  // (not enough combined funds, bridge failure, or fill timeout) and the
+  // caller falls through to the normal insufficient-funds abort. Deliberately
+  // swallows errors — this path must never make a failing payment fail worse.
+  tryJitReverseBridge = async (account, requiredRaw, baseBalance) => {
+    try {
+      const tempoBalance = await this.readUsdcBalance(account.address, "tempo");
+      const usable = tempoBalance - JIT_REVERSE_FEE_MARGIN;
+      if (usable <= 0n || baseBalance + usable < requiredRaw) return false;
+      this.client.logger?.({
+        level: "info",
+        message: `Bridging ${formatUnits(tempoBalance, 6)} USDC from Tempo back to Base to cover this payment...`
+      });
+      if (this.client.getCredentials().kind === "session") {
+        await callBridgeEndpoint(this.client, {
+          sourceChain: "tempo",
+          destinationChain: "base"
+        });
+      } else {
+        await executeByoReverseBridge({ account });
+      }
+      return await this.waitForUsdcBalance(
+        account.address,
+        "base",
+        requiredRaw
+      );
+    } catch (err) {
+      this.client.logger?.({
+        level: "warn",
+        message: "JIT Tempo\u2192Base bridge failed; falling back to insufficient-funds",
+        meta: { error: err instanceof Error ? err.message : String(err) }
+      });
+      return false;
+    }
+  };
+  // Poll until the address's USDC balance on `chain` reaches `targetRaw`.
+  // Bridge fills typically land in 5-15s; the timeout is a generous multiple.
+  waitForUsdcBalance = async (address5, chain2, targetRaw, timeoutMs = BRIDGE_FILL_TIMEOUT_MS) => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise(
+        (resolve7) => setTimeout(resolve7, BRIDGE_FILL_POLL_INTERVAL_MS)
+      );
+      try {
+        if (await this.readUsdcBalance(address5, chain2) >= targetRaw) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    return false;
+  };
   ensureRelayClient = () => {
     if (this.relayInitialized) return;
     createClient2({
@@ -166121,10 +166779,6 @@ var clientFetch = async (client, url4, opts = {}) => {
     result.capabilityResolution = capabilityResolution;
   return result;
 };
-var package_default = {
-  version: "0.18.0"
-};
-var SDK_VERSION2 = package_default.version;
 var agentAuthMetadataSchema = external_exports3.object({
   token_endpoint: external_exports3.string().optional(),
   agent_auth: external_exports3.object({
@@ -166179,238 +166833,6 @@ var agentZeroSessionSchema = external_exports3.object({
   user: external_exports3.object({ id: external_exports3.string() }).loose(),
   walletAddress: external_exports3.string().optional()
 }).loose();
-var refreshResponseSchema = external_exports3.object({
-  accessToken: external_exports3.string(),
-  refreshToken: external_exports3.string()
-});
-var tryRefreshSession = async (client, callerSignal) => {
-  const credentials = client.getCredentials();
-  if (credentials.kind !== "session") return false;
-  if (!credentials.refreshToken) return false;
-  const url4 = `${client.baseUrl.replace(/\/$/, "")}/v1/auth/refresh`;
-  const timeoutSignal = AbortSignal.timeout(client.timeout);
-  const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
-  let response;
-  try {
-    response = await client.fetchImpl(url4, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ refreshToken: credentials.refreshToken }),
-      signal
-    });
-  } catch {
-    return false;
-  }
-  if (!response.ok) return false;
-  let body;
-  try {
-    body = await response.json();
-  } catch {
-    return false;
-  }
-  const parsed = refreshResponseSchema.safeParse(body);
-  if (!parsed.success) return false;
-  await client.applyRefreshedTokens({
-    accessToken: parsed.data.accessToken,
-    refreshToken: parsed.data.refreshToken
-  });
-  return true;
-};
-var buildSessionAuthHeaders = (accessToken) => ({
-  authorization: `Bearer ${accessToken}`
-});
-var buildCanonicalMessage = (method, pathWithQuery, body, timestamp, nonce2) => {
-  const bodyHash = createHash("sha256").update(body ?? "").digest("hex");
-  return `${method}:${pathWithQuery}:${bodyHash}:${timestamp}:${nonce2}`;
-};
-var buildAccountAuthHeaders = async (account, method, pathWithQuery, body) => {
-  const timestamp = Math.floor(Date.now() / 1e3).toString();
-  const nonce2 = crypto.randomUUID();
-  const message2 = buildCanonicalMessage(
-    method,
-    pathWithQuery,
-    body,
-    timestamp,
-    nonce2
-  );
-  const signature2 = await account.signMessage({ message: message2 });
-  return {
-    "x-zero-address": account.address,
-    "x-zero-timestamp": timestamp,
-    "x-zero-nonce": nonce2,
-    "x-zero-signature": signature2
-  };
-};
-var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
-var sleep = (ms, signal) => new Promise((resolve7, reject) => {
-  if (signal?.aborted) {
-    reject(new DOMException("Aborted", "AbortError"));
-    return;
-  }
-  const timer = setTimeout(() => {
-    signal?.removeEventListener("abort", onAbort);
-    resolve7();
-  }, ms);
-  const onAbort = () => {
-    clearTimeout(timer);
-    reject(new DOMException("Aborted", "AbortError"));
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-});
-var buildPathWithQuery = (path3, query) => {
-  const normalizedPath = path3.startsWith("/") ? path3 : `/${path3}`;
-  if (!query) return normalizedPath;
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(query)) {
-    if (value !== void 0) params.set(key, String(value));
-  }
-  const qs = params.toString();
-  return qs ? `${normalizedPath}?${qs}` : normalizedPath;
-};
-var joinUrl = (baseUrl, pathWithQuery) => {
-  const base3 = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-  return `${base3}${pathWithQuery}`;
-};
-var buildHeaders = async (client, method, pathWithQuery, hasBody, bodyStr) => {
-  const headers = { ...client.defaultHeaders };
-  if (hasBody) headers["content-type"] = "application/json";
-  headers["x-zero-sdk-version"] = SDK_VERSION2;
-  if (client.apiVersion) headers["x-zero-api-version"] = client.apiVersion;
-  const credentials = client.getCredentials();
-  if (credentials.kind === "session") {
-    Object.assign(headers, buildSessionAuthHeaders(credentials.accessToken));
-  } else if (credentials.kind === "account") {
-    const signed = await buildAccountAuthHeaders(
-      credentials.account,
-      method,
-      pathWithQuery,
-      bodyStr
-    );
-    Object.assign(headers, signed);
-  }
-  return headers;
-};
-var parseErrorBody = async (response) => {
-  try {
-    return await response.clone().json();
-  } catch {
-    try {
-      return await response.text();
-    } catch {
-      return void 0;
-    }
-  }
-};
-var errorMessageFromBody = (body, status) => {
-  if (body !== null && typeof body === "object" && "error" in body && typeof body.error === "string") {
-    return body.error;
-  }
-  return `HTTP ${status}`;
-};
-var request2 = async (client, opts, schema) => {
-  const pathWithQuery = buildPathWithQuery(opts.path, opts.query);
-  const url4 = joinUrl(client.baseUrl, pathWithQuery);
-  const hasBody = opts.body !== void 0;
-  const bodyStr = hasBody ? JSON.stringify(
-    opts.body,
-    (_k, v) => typeof v === "bigint" ? v.toString() : v
-  ) : void 0;
-  const configuredFetch = buildConfiguredFetch(client);
-  const performOnce = async () => configuredFetch(url4, {
-    method: opts.method,
-    headers: await buildHeaders(
-      client,
-      opts.method,
-      pathWithQuery,
-      hasBody,
-      bodyStr
-    ),
-    body: bodyStr,
-    signal: opts.signal
-  });
-  let refreshAttempted = false;
-  const executeWithRefresh = async () => {
-    const response = await performOnce();
-    if (response.status !== 401 || refreshAttempted) return response;
-    const credentials = client.getCredentials();
-    if (credentials.kind !== "session") return response;
-    refreshAttempted = true;
-    const refreshed = await client.refreshSessionOnce(opts.signal);
-    if (!refreshed) return response;
-    return await performOnce();
-  };
-  let lastNetworkError;
-  for (let attempt = 0; attempt <= client.maxRetries; attempt++) {
-    let response;
-    try {
-      response = await executeWithRefresh();
-    } catch (e) {
-      if (e instanceof ZeroError) throw e;
-      lastNetworkError = e;
-      if (attempt < client.maxRetries) {
-        try {
-          await sleep(2 ** attempt * 200, opts.signal);
-        } catch (sleepErr) {
-          throw new ZeroApiError("Request aborted by caller", {
-            status: 0,
-            cause: sleepErr
-          });
-        }
-        continue;
-      }
-      throw new ZeroApiError("Network request failed", {
-        status: 0,
-        cause: e
-      });
-    }
-    if (response.ok) {
-      let text;
-      try {
-        text = await response.text();
-      } catch (e) {
-        throw new ZeroApiError("Response body read failed", {
-          status: response.status,
-          cause: e
-        });
-      }
-      let json3;
-      try {
-        json3 = JSON.parse(text);
-      } catch {
-      }
-      const parsed = schema.safeParse(json3);
-      if (!parsed.success) {
-        throw new ZeroValidationError(
-          `Response did not match expected schema for ${opts.method} ${opts.path}`,
-          { cause: parsed.error, body: text }
-        );
-      }
-      return parsed.data;
-    }
-    if (RETRYABLE_STATUS.has(response.status) && attempt < client.maxRetries) {
-      try {
-        await sleep(2 ** attempt * 200, opts.signal);
-      } catch (sleepErr) {
-        throw new ZeroApiError("Request aborted by caller", {
-          status: 0,
-          cause: sleepErr
-        });
-      }
-      continue;
-    }
-    const errorBody = await parseErrorBody(response);
-    const requestId = response.headers.get("x-request-id") ?? void 0;
-    throw new ZeroApiError(errorMessageFromBody(errorBody, response.status), {
-      status: response.status,
-      requestId,
-      body: errorBody
-    });
-  }
-  throw new ZeroApiError("Exhausted retries", {
-    status: 0,
-    cause: lastNetworkError
-  });
-};
 var JWT_BEARER_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:jwt-bearer";
 var trimSlash = (value) => value.replace(/\/$/, "");
 var wrapNetworkError = (url4, err) => {
@@ -167422,12 +167844,14 @@ var Wallet = class {
     );
     let sum = 0n;
     const errors = [];
+    const breakdown = {};
     for (let i = 0; i < settled.length; i++) {
       const result = settled[i];
       const chainName = chains[i];
       if (!result || !chainName) continue;
       if (result.status === "fulfilled") {
         sum += result.value;
+        breakdown[chainName] = formatUnits(result.value, USDC_DECIMALS);
       } else {
         errors.push({ chain: chainName, message: errorMessage(result.reason) });
       }
@@ -167439,11 +167863,45 @@ var Wallet = class {
     }
     const balance = {
       amount: formatUnits(sum, USDC_DECIMALS),
-      asset: "USDC"
+      asset: "USDC",
+      breakdown
     };
     if (errors.length > 0) balance.errors = errors;
     return balance;
   };
+  // Move the wallet's Tempo USDC back to Base (a self-transfer — funds never
+  // leave the wallet, only the chain changes, minus ~$0.02 bridge fees).
+  // Session (managed) wallets go through the server's bridge endpoint;
+  // account (BYO) wallets execute client-side via Relay with the local key.
+  // Resolves when the bridge is initiated; the Base balance lands seconds
+  // later — poll `balance()` to observe it.
+  consolidate = async (opts = {}) => {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind === "session") {
+      return callBridgeEndpoint(this.client, {
+        sourceChain: "tempo",
+        destinationChain: "base",
+        amountUsdc: opts.amount,
+        walletAddress: opts.address,
+        signal: opts.signal
+      });
+    }
+    if (credentials.kind === "account") {
+      if (opts.address && opts.address.toLowerCase() !== credentials.account.address.toLowerCase()) {
+        throw new ZeroWalletError(
+          `consolidate({ address }) with account credentials can only target the account's own wallet (${credentials.account.address})`
+        );
+      }
+      return executeByoReverseBridge({
+        account: credentials.account,
+        amountUsdc: opts.amount,
+        signal: opts.signal
+      });
+    }
+    throw new ZeroWalletError(
+      "consolidate() requires a client constructed with an account or session credentials"
+    );
+  };
   // All wallets linked to the authenticated session user. Session-only.
   list = (opts = {}) => request2(
     this.client,
@@ -168324,7 +168782,7 @@ var placeholderFor = (fieldName, propSchema) => String(sampleValueFor(fieldName,
 
 // package.json
 var package_default2 = {
-  version: "1.25.0"};
+  version: "1.26.1"};
 
 // src/app.ts
 init_esm_shims();
@@ -172495,6 +172953,7 @@ var readStdin = async () => {
 
 // src/commands/wallet-command.ts
 var PRIVATE_KEY_PATTERN = /^0x[0-9a-fA-F]{64}$/;
+var TEMPO_DUST_USDC = 0.01;
 var parseProvider = (raw) => raw === "stripe" ? "stripe" : "coinbase";
 var safeFundingUrl = async (client, opts) => {
   try {
@@ -172526,6 +172985,19 @@ var walletBalanceCommand = (appContext) => new Command("balance").description("S
       address: target
     });
     console.log(`${balance.amount} ${balance.asset}`);
+    const tempoAmount = balance.breakdown?.tempo;
+    if (tempoAmount && Number.parseFloat(tempoAmount) >= TEMPO_DUST_USDC) {
+      console.log(
+        color.dim(
+          `  ${balance.breakdown?.base ?? "?"} USDC on Base network \xB7 ${tempoAmount} USDC on Tempo network`
+        )
+      );
+      console.log(
+        color.dim(
+          "  Zero bridges between networks automatically when you fetch; `zero wallet consolidate` moves Tempo funds back now."
+        )
+      );
+    }
     if (balance.errors?.length) {
       const failed = balance.errors.map((e) => e.chain).join(", ");
       console.error(
@@ -172538,6 +173010,66 @@ var walletBalanceCommand = (appContext) => new Command("balance").description("S
     process.exitCode = 1;
   }
 });
+var CONSOLIDATE_FILL_TIMEOUT_MS = 9e4;
+var CONSOLIDATE_POLL_INTERVAL_MS = 2e3;
+var walletConsolidateCommand = (appContext) => new Command("consolidate").description(
+  "Move your wallet's USDC from the Tempo network back to the Base network (self-transfer, ~$0.02 bridge fee)"
+).option(
+  "--amount <usdc>",
+  "Amount in USDC to move (defaults to the full Tempo balance)"
+).option(
+  "--address <address>",
+  "Consolidate a specific wallet on your profile (defaults to the primary)"
+).action(async (options) => {
+  const { client } = appContext.services;
+  if (options.address && !isAddress(options.address)) {
+    console.error("Invalid address (expected 0x + 40 hex chars).");
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const address5 = options.address ?? await client.wallet.address();
+    const before = await client.wallet.balance({ address: address5 });
+    const tempoBefore = before.breakdown?.tempo ?? "0";
+    if (!options.amount && Number.parseFloat(tempoBefore) < TEMPO_DUST_USDC) {
+      console.log("No USDC on the Tempo network \u2014 nothing to consolidate.");
+      return;
+    }
+    console.log(
+      `Bridging ${options.amount ?? tempoBefore} USDC from the Tempo network to the Base network (~10s)...`
+    );
+    await client.wallet.consolidate({
+      amount: options.amount,
+      address: options.address
+    });
+    const baseBefore = Number.parseFloat(before.breakdown?.base ?? "0");
+    const deadline = Date.now() + CONSOLIDATE_FILL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      await new Promise(
+        (resolve7) => setTimeout(resolve7, CONSOLIDATE_POLL_INTERVAL_MS)
+      );
+      try {
+        const now = await client.wallet.balance({ address: address5 });
+        const baseNow = Number.parseFloat(now.breakdown?.base ?? "0");
+        if (baseNow > baseBefore) {
+          console.log(
+            `Done. Base network: ${now.breakdown?.base} USDC \xB7 Tempo network: ${now.breakdown?.tempo ?? "0"} USDC (total ${now.amount}).`
+          );
+          return;
+        }
+      } catch {
+      }
+    }
+    console.log(
+      "Bridge initiated; the fill hasn't landed yet. Check `zero wallet balance` in a moment."
+    );
+  } catch (err) {
+    console.error(
+      err instanceof Error ? err.message : "Consolidation failed"
+    );
+    process.exitCode = 1;
+  }
+});
 var readPrivateKeyFromStdin = async () => {
   if (process.stdin.isTTY) {
     console.error(
@@ -172998,6 +173530,7 @@ var walletNicknameCommand = (appContext) => new Command("nickname").description(
 var walletCommand = (appContext) => {
   const cmd = new Command("wallet").description("Manage your wallet");
   cmd.addCommand(walletBalanceCommand(appContext));
+  cmd.addCommand(walletConsolidateCommand(appContext));
   cmd.addCommand(walletFundCommand(appContext));
   cmd.addCommand(walletAddressCommand(appContext));
   cmd.addCommand(walletSetCommand(appContext));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zeroxyz/cli",
-	"version": "1.25.0",
+	"version": "1.26.1",
 	"type": "module",
 	"bin": {
 		"zero": "dist/index.js",