@haven_ai/sdk 0.1.17-alpha.0 → 0.1.19-alpha.0

package/dist/index.js

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from 'async_hooks';
 import { exact } from 'x402/schemes';
+import { hashTypedData } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { ethers } from 'ethers';
 import { createHash } from 'crypto';
@@ -240,6 +241,22 @@ function signHash(privateKey, hash) {
     );
   }
 }
+async function signUserOpTypedDataForDelegation(privateKey, typedData) {
+  try {
+    const wallet = new ethers.Wallet(privateKey);
+    const types = { ...typedData.types };
+    delete types.EIP712Domain;
+    return await wallet.signTypedData(
+      typedData.domain,
+      types,
+      typedData.message
+    );
+  } catch (err) {
+    throw new HavenSigningError(
+      `Failed to sign delegation UserOperation: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 function addressFromKey(privateKey) {
   try {
     return new ethers.Wallet(privateKey).address;
@@ -257,6 +274,24 @@ function verifySignature(hash, signature, expectedAddress) {
     return false;
   }
 }
+var RECEIPT_VERSION = "haven-receipt-1";
+function defaultRecover(hash, signature) {
+  return ethers.recoverAddress(hash, signature);
+}
+function verifyPaymentReceipt(receipt, recover = defaultRecover) {
+  const { delegate, signHash: signHash2, signature } = receipt.authorization;
+  if (!signature) return { verified: false, reason: "missing_signature" };
+  let recovered;
+  try {
+    recovered = recover(signHash2, signature);
+  } catch {
+    return { verified: false, reason: "bad_signature" };
+  }
+  if (recovered.toLowerCase() !== delegate.toLowerCase()) {
+    return { verified: false, reason: "signer_mismatch", recoveredSigner: recovered };
+  }
+  return { verified: true, recoveredSigner: recovered };
+}
 
 // src/base64.ts
 function normalizeBase64(value) {
@@ -301,6 +336,8 @@ function decodeBase64Json(value, label) {
 
 // src/x402.ts
 var BASE_USDC_ADDRESS = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+var BASE_SEPOLIA_USDC_ADDRESS = "0x036cbd53842c5426634e7929541ec2318f3dcf7e";
+var STANDARD_X402_USDC_ADDRESSES = /* @__PURE__ */ new Set([BASE_USDC_ADDRESS, BASE_SEPOLIA_USDC_ADDRESS]);
 var X402_IDEMPOTENCY_BUCKET_MS = 3e5;
 var DECIMAL_ATOMIC_AMOUNT_RE = /^[0-9]+$/;
 function isPositiveDecimalAtomicAmount(value) {
@@ -309,6 +346,12 @@ function isPositiveDecimalAtomicAmount(value) {
 function optionAuthorizationAmount(option) {
   return option.maxAmountRequired ?? option.amount;
 }
+var X402_MAX_AUTHORIZATION_WINDOW_SECONDS = 600;
+var X402_SETTLEMENT_FORWARD_MARGIN_SECONDS = 300;
+function clampAuthorizationWindow(seconds) {
+  const requested = typeof seconds === "number" && Number.isFinite(seconds) ? seconds : 30;
+  return Math.min(Math.max(Math.floor(requested), 1), X402_MAX_AUTHORIZATION_WINDOW_SECONDS);
+}
 function normalizePaymentOption(value) {
   const candidate = value;
   if (!candidate || typeof candidate !== "object" || typeof candidate.scheme !== "string" || typeof candidate.network !== "string" || typeof candidate.asset !== "string" || typeof candidate.payTo !== "string") {
@@ -330,7 +373,7 @@ function normalizePaymentOption(value) {
     mimeType: candidate.mimeType,
     asset: candidate.asset,
     payTo: candidate.payTo,
-    maxTimeoutSeconds: candidate.maxTimeoutSeconds ?? 30,
+    maxTimeoutSeconds: clampAuthorizationWindow(candidate.maxTimeoutSeconds),
     extra: candidate.extra
   };
 }
@@ -360,11 +403,15 @@ function normalizePaymentRequired(value) {
 var SUPPORTED_X402_NETWORKS = {
   "eip155:100": "Gnosis Chain",
   "eip155:8453": "Base",
-  "base": "Base"
+  "base": "Base",
+  "eip155:84532": "Base Sepolia",
+  "base-sepolia": "Base Sepolia"
 };
 var STANDARD_X402_NETWORKS = {
   "eip155:8453": "base",
-  "base": "base"
+  "base": "base",
+  "eip155:84532": "base-sepolia",
+  "base-sepolia": "base-sepolia"
 };
 var GNOSIS_TOKENS = {
   "0x0000000000000000000000000000000000000000": { symbol: "xDAI", decimals: 18 },
@@ -375,14 +422,21 @@ var BASE_TOKENS = {
   "0x0000000000000000000000000000000000000000": { symbol: "ETH", decimals: 18 },
   "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": { symbol: "USDC", decimals: 6 }
 };
+var BASE_SEPOLIA_TOKENS = {
+  "0x0000000000000000000000000000000000000000": { symbol: "ETH", decimals: 18 },
+  "0x036cbd53842c5426634e7929541ec2318f3dcf7e": { symbol: "USDC", decimals: 6 }
+};
 var ALL_TOKENS = {
   ...GNOSIS_TOKENS,
-  ...BASE_TOKENS
+  ...BASE_TOKENS,
+  ...BASE_SEPOLIA_TOKENS
 };
 var NETWORK_TOKENS = {
   "eip155:100": GNOSIS_TOKENS,
   "eip155:8453": BASE_TOKENS,
-  "base": BASE_TOKENS
+  "base": BASE_TOKENS,
+  "eip155:84532": BASE_SEPOLIA_TOKENS,
+  "base-sepolia": BASE_SEPOLIA_TOKENS
 };
 function parsePaymentRequired(response) {
   const v2Header = response.headers.get("PAYMENT-REQUIRED");
@@ -436,7 +490,7 @@ function selectPaymentOption(accepts) {
 function selectStandardPaymentOption(accepts) {
   if (!accepts || accepts.length === 0) return null;
   for (const opt of accepts) {
-    if (opt.scheme === "exact" && opt.network in STANDARD_X402_NETWORKS && opt.asset.toLowerCase() === BASE_USDC_ADDRESS && isPositiveDecimalAtomicAmount(optionAuthorizationAmount(opt))) {
+    if (opt.scheme === "exact" && opt.network in STANDARD_X402_NETWORKS && STANDARD_X402_USDC_ADDRESSES.has(opt.asset.toLowerCase()) && isPositiveDecimalAtomicAmount(optionAuthorizationAmount(opt))) {
       return opt;
     }
   }
@@ -450,8 +504,9 @@ function x402AuthorizationAmount(option) {
   return amount;
 }
 function buildX402ExpectedMessage(context) {
+  const version = context.typedDataHash ? 2 : 1;
   const payload = {
-    version: 1,
+    version,
     kind: "haven.x402.expected",
     paymentId: context.paymentId,
     payloadHash: context.payloadHash.toLowerCase(),
@@ -464,7 +519,10 @@ function buildX402ExpectedMessage(context) {
   if (context.expiresAt) {
     payload.expiresAt = context.expiresAt;
   }
-  return `Haven x402 expected context v1
+  if (context.typedDataHash) {
+    payload.typedDataHash = context.typedDataHash.toLowerCase();
+  }
+  return `Haven x402 expected context v${version}
 ${stableStringify(payload)}`;
 }
 function toStandardPaymentRequirements(paymentRequired, option) {
@@ -484,7 +542,15 @@ function toStandardPaymentRequirements(paymentRequired, option) {
     mimeType: option.mimeType ?? paymentRequired.resource.mimeType ?? "application/octet-stream",
     payTo: option.payTo,
     asset: option.asset,
-    maxTimeoutSeconds: option.maxTimeoutSeconds,
+    // Second enforcement point (#715): the parse path clamps too, but this is
+    // the last stop before the x402 library turns the timeout into
+    // `validBefore` — options constructed without parsing are bounded here.
+    // The forward margin (#1256) is added ONLY here, at signing: the parse
+    // path keeps recording the merchant's advertised timeout unchanged, and
+    // the library's `validBefore = now + this value` then carries enough
+    // slack to satisfy the facilitator's `validBefore ≥ now + maxTimeout`
+    // verify rule after our funding leg confirms.
+    maxTimeoutSeconds: clampAuthorizationWindow(option.maxTimeoutSeconds) + X402_SETTLEMENT_FORWARD_MARGIN_SECONDS,
     extra: option.extra
   };
 }
@@ -618,7 +684,8 @@ var CHAIN_EXPLORER_TX = {
   8453: "https://basescan.org/tx"
 };
 var CHAIN_USDC = {
-  8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+  8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
 };
 function buildExplorerUrl(chainId, txHash) {
   const base = CHAIN_EXPLORER_TX[chainId ?? 8453] ?? CHAIN_EXPLORER_TX[8453];
@@ -781,6 +848,16 @@ function parseSseJsonRpcMessages(text) {
 function selectJsonRpcResult(messages) {
   return messages.find((m) => "result" in m || "error" in m) ?? messages[messages.length - 1];
 }
+function x402TypedDataDigest(typedData) {
+  if (!typedData || typeof typedData !== "object") return void 0;
+  try {
+    return hashTypedData(typedData);
+  } catch (err) {
+    throw new HavenSigningError(
+      `The x402 funding intent carried a sign_data.typed_data that is not a valid EIP-712 payload (needs domain, types, primaryType, message), so its digest cannot be derived and no signer could accept it. Underlying error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 var HavenClient = class {
   apiKey;
   delegateKey;
@@ -930,6 +1007,11 @@ var HavenClient = class {
     if (!raw.sign_data?.hash) {
       throw new HavenApiError("No sign_hash returned from x402/authorize", 500, raw);
     }
+    if (raw.sign_data.signature_scheme !== void 0 && !raw.sign_data.typed_data) {
+      throw new HavenSigningError(
+        `This account's x402 funding intent declares signature scheme '${raw.sign_data.signature_scheme}' but carried no typed_data to sign. Refusing to fall back to the bare hash \u2014 the account would reject that signature on-chain. This is a backend contract violation; report it rather than working around it.`
+      );
+    }
     if (!raw.x402_expected_auth) {
       throw new HavenApiError("No x402 expected-context binding returned from x402/authorize", 500, raw);
     }
@@ -946,6 +1028,14 @@ var HavenClient = class {
       asset: option.asset,
       network: option.network,
       expectedAuth: raw.x402_expected_auth,
+      // #1138: the digest the delegation-rail expected context commits to.
+      // Re-derived locally, exactly like every other context field the edge
+      // signer is handed (amount, merchantTo, …) — none of them are trusted
+      // because they arrived, they are trusted because the reconstructed
+      // message has to match Haven's signature over it. A typed_data altered in
+      // transit therefore fails message equality and is refused, and the signer
+      // re-derives this digest a second time from the payload it actually signs.
+      expectedTypedDataHash: x402TypedDataDigest(raw.sign_data.typed_data),
       fundingTo
     };
   }
@@ -969,6 +1059,42 @@ var HavenClient = class {
     }
     return signature;
   }
+  /**
+   * Sign a payment's `sign_data` with the correct scheme for its rail.
+   *
+   * Dispatching on the server-provided scheme means a caller never has to
+   * know which rail an account is on; an unknown scheme is a hard error,
+   * never a guessed signature. The session rail's 'eip191_userop' is retired
+   * (#834) — the backend refuses those intents with HTTP 410 before any
+   * sign_data reaches a client, so encountering it here is a hard error too.
+   */
+  async signForData(signData) {
+    if (!this.delegateKey) {
+      throw new HavenSigningError(
+        "Cannot sign without a delegateKey. Pass the private key in HavenClient config, or sign externally."
+      );
+    }
+    const scheme = signData.signature_scheme;
+    if (scheme === "eip191_userop") {
+      throw new HavenSigningError(
+        "The session rail is retired \u2014 'eip191_userop' intents can no longer be signed. Re-onboard the account on the delegation rail."
+      );
+    }
+    if (scheme === "eip712_userop") {
+      if (!signData.typed_data) {
+        throw new HavenSigningError(
+          "sign_data.signature_scheme is eip712_userop but typed_data is missing \u2014 refusing to sign the bare hash (the account would reject it)."
+        );
+      }
+      return signUserOpTypedDataForDelegation(this.delegateKey, signData.typed_data);
+    }
+    if (scheme === void 0) {
+      return signHash(this.delegateKey, signData.hash);
+    }
+    throw new HavenSigningError(
+      `Unknown sign_data.signature_scheme '${scheme}' \u2014 refusing to guess a signing scheme. Update @haven_ai/sdk.`
+    );
+  }
   /**
    * Step 3: Submit a signature to execute the payment.
    *
@@ -1089,9 +1215,10 @@ var HavenClient = class {
     }
     const ethBalance = await provider.getBalance(delegateAddress);
     if (ethBalance > 0n) {
-      const gasPrice = (await provider.getFeeData()).gasPrice ?? 1000000n;
+      const fee = await provider.getFeeData();
+      const effectiveGasPrice = fee.maxFeePerGas ?? fee.gasPrice ?? 1000000n;
       const gasLimit = 21000n;
-      const gasCost = gasPrice * gasLimit;
+      const gasCost = effectiveGasPrice * gasLimit * 2n;
       const ethToSend = ethBalance > gasCost ? ethBalance - gasCost : 0n;
       if (ethToSend > 0n) {
         const tx = await wallet.sendTransaction({ to: safeAddress, value: ethToSend });
@@ -1204,6 +1331,18 @@ var HavenClient = class {
     const raw = await this.get(`/machine-payments/receipts${query}`);
     return raw.receipts.map((receipt) => this.mapPaymentReceipt(receipt));
   }
+  /**
+   * Fetch the verifiable receipt bundle for a settled payment and verify it
+   * locally. The server's own verification is ignored — the receipt is verified
+   * here (independently of Haven) by recovering the signer from the
+   * authorisation, so the result is trustworthy even if the backend lied.
+   */
+  async getReceipt(paymentId) {
+    const { receipt } = await this.get(
+      `/payments/${paymentId}/receipt`
+    );
+    return { receipt, verification: verifyPaymentReceipt(receipt) };
+  }
   /**
    * Rehydrate the x402/MPP resume-state bundle for a payment id.
    *
@@ -1346,7 +1485,7 @@ var HavenClient = class {
     if (!raw.sign_data?.hash) {
       throw new HavenApiError("No sign_hash returned from x402/authorize", 500, raw);
     }
-    const sig = signHash(this.delegateKey, raw.sign_data.hash);
+    const sig = await this.signForData(raw.sign_data);
     const execResult = await this.post(
       `/payments/${raw.payment_id}/sign`,
       { signature: sig }
@@ -1705,8 +1844,39 @@ var HavenClient = class {
       protocolReceiptHeaderName: "PAYMENT-RESPONSE",
       protocolReceiptHeader: retryResponse.headers.get("PAYMENT-RESPONSE") ?? void 0
     });
+    await this.reportMerchantReceipt(receipt.paymentId, retryResponse);
     return retryResponse;
   }
+  /**
+   * #956: capture the merchant's OWN receipt when the paid response carries
+   * one, and report it to Haven so the reporting feed can attach it next to
+   * the Haven-generated payment evidence (#498). Two supported signals on the
+   * paid response:
+   *
+   *   x-receipt-json: base64-encoded JSON receipt document (inline)
+   *   x-receipt-url:  https URL to the receipt document (reference)
+   *
+   * Strictly best-effort: absence is the normal case, and no failure here may
+   * ever affect the completed payment — the response is already paid for.
+   */
+  async reportMerchantReceipt(paymentId, response) {
+    try {
+      const inlineB64 = response.headers.get("x-receipt-json");
+      const url = response.headers.get("x-receipt-url");
+      if (!inlineB64 && !url) return;
+      let body = null;
+      if (inlineB64) {
+        if (inlineB64.length > Math.ceil(64 * 1024 * 4 / 3)) return;
+        const decoded = JSON.parse(Buffer.from(inlineB64, "base64").toString("utf8"));
+        if (decoded && typeof decoded === "object") body = { json: decoded };
+      } else if (url && url.startsWith("https://") && url.length <= 2048) {
+        body = { url };
+      }
+      if (!body) return;
+      await this.post(`/machine-payments/${paymentId}/merchant-receipt`, body);
+    } catch {
+    }
+  }
   /**
    * Deliver an already-signed x402 payment header to the merchant and return
    * the merchant's response. Used by the hosted MCP server to complete the
@@ -1794,6 +1964,7 @@ var HavenClient = class {
         protocolReceiptHeaderName: protocolReceiptHeader ? "PAYMENT-RESPONSE" : void 0,
         protocolReceiptHeader
       });
+      await this.reportMerchantReceipt(evidenceContext.paymentId, surfaced);
     }
     return {
       status: surfaced.status,
@@ -1888,7 +2059,7 @@ var HavenClient = class {
     if (!raw.sign_data?.hash) {
       throw new HavenApiError("No sign_hash returned from machine payment authorization", 500, raw);
     }
-    const sig = signHash(this.delegateKey, raw.sign_data.hash);
+    const sig = await this.signForData(raw.sign_data);
     const execResult = await this.post(
       `/payments/${raw.payment_id}/sign`,
       { signature: sig }
@@ -1991,6 +2162,7 @@ var HavenClient = class {
       protocolReceiptHeaderName: retryResponse.headers.has("Payment-Receipt") ? "Payment-Receipt" : retryResponse.headers.has("MACHINE-PAYMENT-RESPONSE") ? "MACHINE-PAYMENT-RESPONSE" : void 0,
       protocolReceiptHeader: retryResponse.headers.get("Payment-Receipt") ?? retryResponse.headers.get("MACHINE-PAYMENT-RESPONSE") ?? void 0
     });
+    await this.reportMerchantReceipt(receipt.paymentId, retryResponse);
     return retryResponse;
   }
   assertCanResumeX402(status, paymentRequired, option) {
@@ -2820,7 +2992,11 @@ var HavenClient = class {
       });
       const data = await res.json();
       if (!res.ok) {
-        const message = data.error ?? data.details ?? `API request failed`;
+        const record = data;
+        const errorText = typeof record.error === "string" ? record.error : void 0;
+        const rawDetails = record.details ?? record.detail;
+        const detailsText = typeof rawDetails === "string" ? rawDetails : rawDetails != null ? JSON.stringify(rawDetails) : void 0;
+        const message = errorText && detailsText ? `${errorText}: ${detailsText}` : errorText ?? detailsText ?? `API request failed`;
         throw new HavenApiError(message, res.status, data);
       }
       return data;
@@ -2848,6 +3024,12 @@ var HavenClient = class {
       txHash: raw.tx_hash,
       errorMessage: raw.error_message,
       explorerUrl: raw.explorer_url ?? (raw.tx_hash ? buildExplorerUrl(raw.chain_id, raw.tx_hash) : null),
+      fee: raw.fee ? {
+        amount: raw.fee.amount,
+        token: raw.fee.token,
+        basisPoints: raw.fee.basis_points,
+        applied: raw.fee.applied
+      } : null,
       createdAt: raw.created_at,
       signedAt: raw.signed_at,
       submittedAt: raw.submitted_at,
@@ -2871,6 +3053,12 @@ var HavenClient = class {
       expiresAt: raw.expires_at,
       chainId: raw.chain_id,
       message: raw.message,
+      fee: raw.fee ? {
+        amount: raw.fee.amount,
+        token: raw.fee.token,
+        basisPoints: raw.fee.basis_points,
+        applied: raw.fee.applied
+      } : null,
       amountAtomic: raw.amount_atomic ?? raw.x402?.amount_atomic ?? null,
       asset: raw.asset ?? raw.x402?.asset ?? null,
       network: raw.network ?? raw.x402?.network ?? null,
@@ -3016,13 +3204,13 @@ var toolDescriptions = {
   getAgent: {
     summary: "Return the authenticated agent identity AND its live spend authority in one call: Haven wallet, delegate, chain, raw status, a readiness signal, and per-token remaining allowance (atomic + human-readable). The recommended first call in a new session to confirm who you are and whether you can pay right now.",
     selectionGuidance: "Use this as the one-shot orientation/bootstrap at the start of a session, or whenever you need to confirm identity together with whether the agent can spend right now. For a detailed per-token breakdown (configured vs spent vs reset window) use haven_get_allowances.",
-    behavior: 'Reads identity plus the on-chain AllowanceModule snapshot in one shot. readiness is "ready" when at least one token has remaining on-chain allowance, "needs_approval" when the agent is active but has no remaining allowance to auto-spend (payments will be queued for the wallet owner to approve in Haven), and "revoked" when the credential is not active. allowances[] carries remainingAtomic and remainingDisplay per token. Identity fields (id, name, status, safeAddress, delegateAddress, chainId) are unchanged from before.',
+    behavior: 'Reads identity plus the live spend-authority snapshot in one shot \u2014 the on-chain AllowanceModule on the legacy rail, the active budget delegation on the delegation rail. readiness is "ready" when at least one token has remaining spend authority, "needs_approval" when the agent is active but has none, and "revoked" when the credential is not active. What an over-budget payment does differs by rail: on the legacy AllowanceModule rail it is queued for the wallet owner to approve in Haven; on the delegation rail there is no approval queue \u2014 an over-budget redemption reverts on-chain, so ask the owner to grant or raise the budget in Haven rather than waiting for an approval. allowances[] carries remainingAtomic and remainingDisplay per token. Identity fields (id, name, status, safeAddress, delegateAddress, chainId) are unchanged from before.',
     nextActionGuidance: ""
   },
   getAllowances: {
     summary: "Return configured and on-chain allowance state for the authenticated agent. On-chain allowance is the real spend gate.",
     selectionGuidance: "Use this when the user asks about allowance, budget, spend limit, remaining amount, remaining allowance, remaining budget, daily limit, reset period, what can I spend, or what the agent can still spend.",
-    behavior: "Reads the Safe AllowanceModule snapshot per token (allowance, spent, remaining, reset window). Configured amounts from Haven are returned alongside the on-chain truth.",
+    behavior: "Returns the per-token spend authority for the account's rail: the Safe AllowanceModule snapshot (allowance, spent, remaining, reset window) on the legacy rail, or the active budget delegation (remaining = the period budget; over-budget redemptions revert on-chain, nothing queues) on the delegation rail. Configured amounts from Haven are returned alongside.",
     nextActionGuidance: ""
   },
   listReceipts: {
@@ -3031,6 +3219,12 @@ var toolDescriptions = {
     behavior: "Returns the agent's recent machine-payment receipts ordered by recency. Proof header values are not returned.",
     nextActionGuidance: ""
   },
+  verifyReceipt: {
+    summary: "Verify a payment receipt offline \u2014 confirm the agent authorised the transfer.",
+    selectionGuidance: "Use this to check a receipt you already hold; it needs no network and does not trust Haven. Use the history tool to fetch receipts in the first place.",
+    behavior: "Recovers the signer from the receipt authorisation and confirms it matches the agent delegate. Returns verified true/false with the recovered signer or a reason. Pure and local \u2014 no backend call.",
+    nextActionGuidance: ""
+  },
   payMcpTool: {
     summary: "Call a named tool on an MCP merchant that requires an x402 payment, handling the full initialize \u2192 pay \u2192 retry round trip.",
     selectionGuidance: "Use this when the agent wants to call a specific tool on an MCP merchant (e.g. Soundside, Coinbase Bazaar) and payment is required. Prefer this over haven_pay_x402 when you know the merchant_url and tool_name \u2014 it builds the JSON-RPC envelope internally. Use haven_pay_x402 for arbitrary HTTP resources. Do NOT use for read-only allowance or budget questions \u2014 use haven_get_allowances.",
@@ -3418,20 +3612,72 @@ for that credential.
 `;
 var SKILL_FOLDER_NAME = "haven-pay";
 
+// src/node-version.ts
+var HAVEN_MINIMUM_NODE_VERSION = "24.0.0";
+function parseNodeVersion(value) {
+  const match = value.trim().match(/^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!match) return [0, 0, 0];
+  return [Number(match[1] ?? 0), Number(match[2] ?? 0), Number(match[3] ?? 0)];
+}
+function compareNodeVersions(left, right) {
+  const leftParts = parseNodeVersion(left);
+  const rightParts = parseNodeVersion(right);
+  for (let i = 0; i < 3; i += 1) {
+    if (leftParts[i] !== rightParts[i]) return leftParts[i] > rightParts[i] ? 1 : -1;
+  }
+  return 0;
+}
+function isSupportedNodeVersion(nodeVersion = process.versions.node, minimumNodeVersion = HAVEN_MINIMUM_NODE_VERSION) {
+  return compareNodeVersions(nodeVersion, minimumNodeVersion) >= 0;
+}
+function unsupportedNodeVersionMessage(options) {
+  const nodeVersion = options.nodeVersion ?? process.versions.node;
+  const minimum = options.minimumNodeVersion ?? HAVEN_MINIMUM_NODE_VERSION;
+  const lines = [
+    `${options.subject} requires Node.js >=${minimum}, but this is Node.js ${nodeVersion}.`,
+    "",
+    "Upgrade Node, then try again:",
+    `  nvm install ${major(minimum)} && nvm use ${major(minimum)}      (nvm)`,
+    `  fnm install ${major(minimum)} && fnm use ${major(minimum)}      (fnm)`,
+    `  volta install node@${major(minimum)}                 (volta)`,
+    `  or download Node ${major(minimum)} from https://nodejs.org`,
+    "",
+    "If you use a version manager, check that the agent runtime launching Haven picks up the same version \u2014 upgrading your shell does not always change what a desktop app spawns."
+  ];
+  if (options.retryHint) lines.push("", options.retryHint);
+  return lines.join("\n");
+}
+function major(version) {
+  return String(parseNodeVersion(version)[0]);
+}
+
 // src/sweep.ts
 var SWEEP_BASE_CHAIN_ID = 8453;
+var SWEEP_BASE_SEPOLIA_CHAIN_ID = 84532;
 var SWEEP_BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var SWEEP_BASE_SEPOLIA_USDC_ADDRESS = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
 var USDC_EIP712_DOMAIN_BY_CHAIN = {
   [SWEEP_BASE_CHAIN_ID]: {
     name: "USD Coin",
     version: "2",
     chainId: SWEEP_BASE_CHAIN_ID,
     verifyingContract: SWEEP_BASE_USDC_ADDRESS
+  },
+  [SWEEP_BASE_SEPOLIA_CHAIN_ID]: {
+    name: "USDC",
+    version: "2",
+    chainId: SWEEP_BASE_SEPOLIA_CHAIN_ID,
+    verifyingContract: SWEEP_BASE_SEPOLIA_USDC_ADDRESS
   }
 };
 var USDC_ADDRESS_BY_CHAIN = {
-  [SWEEP_BASE_CHAIN_ID]: SWEEP_BASE_USDC_ADDRESS
+  [SWEEP_BASE_CHAIN_ID]: SWEEP_BASE_USDC_ADDRESS,
+  [SWEEP_BASE_SEPOLIA_CHAIN_ID]: SWEEP_BASE_SEPOLIA_USDC_ADDRESS
 };
+var SWEEPABLE_CHAIN_IDS = Object.keys(USDC_ADDRESS_BY_CHAIN).map(Number);
+function isSweepableChain(chainId) {
+  return chainId in USDC_ADDRESS_BY_CHAIN;
+}
 var TRANSFER_WITH_AUTHORIZATION_TYPES = {
   TransferWithAuthorization: [
     { name: "from", type: "address" },
@@ -3446,7 +3692,7 @@ function sweepUsdcAddress(chainId) {
   const address = USDC_ADDRESS_BY_CHAIN[chainId];
   if (!address) {
     throw new HavenSigningError(
-      `Sweep is only supported on Base (chainId ${SWEEP_BASE_CHAIN_ID}). Got chainId ${chainId}.`
+      `Sweep is not supported on chain ${chainId}. Supported: ${SWEEPABLE_CHAIN_IDS.join(", ")}.`
     );
   }
   return address;
@@ -3455,7 +3701,7 @@ function sweepUsdcDomain(chainId) {
   const domain = USDC_EIP712_DOMAIN_BY_CHAIN[chainId];
   if (!domain) {
     throw new HavenSigningError(
-      `Sweep is only supported on Base (chainId ${SWEEP_BASE_CHAIN_ID}). Got chainId ${chainId}.`
+      `Sweep is not supported on chain ${chainId}. Supported: ${SWEEPABLE_CHAIN_IDS.join(", ")}.`
     );
   }
   return domain;
@@ -3510,6 +3756,6 @@ function stableStringify2(value) {
   return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify2(object[key])}`).join(",")}}`;
 }
 
-export { AGENT_PAYMENT_FAILURE_CODE_VALUES, AGENT_PAYMENT_NEXT_ACTION_VALUES, AGENT_PAYMENT_PHASE_VALUES, AGENT_PAYMENT_RAIL_VALUES, AgentPaymentFailureCode, AgentPaymentFailureCodeDescriptions, AgentPaymentFailureCodeSchema, AgentPaymentNextAction, AgentPaymentNextActionDescriptions, AgentPaymentNextActionSchema, AgentPaymentPhase, AgentPaymentPhaseDescriptions, AgentPaymentPhaseSchema, AgentPaymentRail, AgentPaymentRailDescriptions, AgentPaymentRailSchema, HAVEN_SKILL_MD, HavenApiError, HavenClient, HavenError, HavenPaymentStateError, HavenSigningError, HavenTimeoutError, SKILL_FOLDER_NAME, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_USDC_ADDRESS, TRANSFER_WITH_AUTHORIZATION_TYPES, addressFromKey, buildMachinePaymentIdempotencyKey, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, composeDescription, decodeBase64Json, decodeBase64Utf8, encodeBase64Json, encodeBase64Utf8, encodeMachinePaymentProof, encodePaymentProof, havenTools, parseMachinePaymentChallenge, parseMachinePaymentChallengeResponse, parsePaymentRequired, parsePaymentRequiredResponse, selectPaymentOption, selectStandardPaymentOption, signHash, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, toolDescriptions, verifySignature, x402AuthorizationAmount };
+export { AGENT_PAYMENT_FAILURE_CODE_VALUES, AGENT_PAYMENT_NEXT_ACTION_VALUES, AGENT_PAYMENT_PHASE_VALUES, AGENT_PAYMENT_RAIL_VALUES, AgentPaymentFailureCode, AgentPaymentFailureCodeDescriptions, AgentPaymentFailureCodeSchema, AgentPaymentNextAction, AgentPaymentNextActionDescriptions, AgentPaymentNextActionSchema, AgentPaymentPhase, AgentPaymentPhaseDescriptions, AgentPaymentPhaseSchema, AgentPaymentRail, AgentPaymentRailDescriptions, AgentPaymentRailSchema, HAVEN_MINIMUM_NODE_VERSION, HAVEN_SKILL_MD, HavenApiError, HavenClient, HavenError, HavenPaymentStateError, HavenSigningError, HavenTimeoutError, RECEIPT_VERSION, SKILL_FOLDER_NAME, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_SEPOLIA_CHAIN_ID, SWEEP_BASE_SEPOLIA_USDC_ADDRESS, SWEEP_BASE_USDC_ADDRESS, TRANSFER_WITH_AUTHORIZATION_TYPES, X402_MAX_AUTHORIZATION_WINDOW_SECONDS, X402_SETTLEMENT_FORWARD_MARGIN_SECONDS, addressFromKey, buildMachinePaymentIdempotencyKey, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, compareNodeVersions, composeDescription, decodeBase64Json, decodeBase64Utf8, encodeBase64Json, encodeBase64Utf8, encodeMachinePaymentProof, encodePaymentProof, havenTools, isSupportedNodeVersion, isSweepableChain, parseMachinePaymentChallenge, parseMachinePaymentChallengeResponse, parsePaymentRequired, parsePaymentRequiredResponse, selectPaymentOption, selectStandardPaymentOption, signHash, signUserOpTypedDataForDelegation, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, toolDescriptions, unsupportedNodeVersionMessage, verifyPaymentReceipt, verifySignature, x402AuthorizationAmount };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map