@haven_ai/sdk 0.0.0-dev.202609031523.fd49e1a

package/dist/index.js

@@ -0,0 +1,4628 @@
+import { recoverTypedDataAddress, hashTypedData } from 'viem';
+import { ethers } from 'ethers';
+import { createHash } from 'crypto';
+import { AsyncLocalStorage } from 'async_hooks';
+import { exact } from 'x402/schemes';
+import { privateKeyToAccount } from 'viem/accounts';
+
+// src/client.ts
+
+// src/connector-channel.ts
+var CONNECTOR_PACKAGE_NAME = "@haven_ai/connect";
+var HAVEN_CONNECTOR_CHANNEL = "dev";
+var CHANNEL_PATTERN = /^[a-z][a-z0-9-]{0,31}$/;
+function isConnectorChannel(value) {
+  return CHANNEL_PATTERN.test(value);
+}
+function resolveConnectorChannel(raw, fallback = HAVEN_CONNECTOR_CHANNEL) {
+  const trimmed = (raw ?? "").trim();
+  if (trimmed === "") return fallback;
+  if (!isConnectorChannel(trimmed)) {
+    throw new Error(
+      `HAVEN_CONNECTOR_CHANNEL is set to ${JSON.stringify(raw)}, which is not a valid npm dist-tag (lowercase letter first, then letters, digits or hyphens). Refusing to start rather than fall back to the default channel, because falling back would hand out the production connector while looking configured.`
+    );
+  }
+  return trimmed;
+}
+function connectorSpec(channel = HAVEN_CONNECTOR_CHANNEL) {
+  return `${CONNECTOR_PACKAGE_NAME}@${channel}`;
+}
+function connectorRerunCommand(args, options) {
+  const channel = options?.channel ?? HAVEN_CONNECTOR_CHANNEL;
+  const flags = options?.npxFlags ? `${options.npxFlags} ` : "";
+  const command = `npx ${flags}${connectorSpec(channel)}`;
+  return args ? `${command} ${args}` : command;
+}
+
+// src/types.ts
+var DEFAULT_CONFIRMATION_TIMEOUT_MS = 9e4;
+var AgentPaymentPhase = {
+  /** The agent must sign and submit the prepared payment before Haven can relay it. */
+  AgentSignatureRequired: "agent_signature_required",
+  /** Haven has received the signed payment and the agent should poll for confirmation. */
+  PaymentSubmitted: "payment_submitted",
+  /** The direct payment is confirmed; the agent does not need to do more for this payment id. */
+  PaymentConfirmed: "payment_confirmed",
+  /**
+   * #2115: RETIRED wire value — no live rail produces it. It described the
+   * Safe rail's approval queue, which no longer exists. Kept so a stored value
+   * still typechecks; see `AgentPaymentPhaseDescriptions` below for the
+   * agent-visible wording, which this comment used to contradict.
+   */
+  UserApprovalRequired: "user_approval_required",
+  /** #2115: RETIRED wire value — no live rail produces it. Stop and tell the user. */
+  UserExecutionRequired: "user_execution_required",
+  /** #2115: RETIRED wire value — no live rail produces it. Stop and tell the user. */
+  WaitingForAdditionalApprovals: "waiting_for_additional_approvals",
+  /** The Haven funding leg was sent; the agent can continue the merchant/protocol leg. */
+  FundingSent: "funding_sent",
+  /** The payment was rejected and cannot proceed; the agent should stop and tell the user. */
+  Rejected: "rejected",
+  /** The payment expired before completion. */
+  Expired: "expired",
+  /** Haven could not complete the payment; the agent should stop and surface the failure. */
+  Failed: "failed",
+  /**
+   * Pre-flight check determined the delegate's existing balance plus the
+   * remaining on-chain budget cannot cover the requested amount, so no
+   * payment intent was created. The account must be funded or the agent's
+   * budget raised before retrying — #2115: the old wording contrasted this
+   * with `UserApprovalRequired` as if that were a live alternative, and named
+   * the retired rail's Safe and per-token allowance as the fix.
+   */
+  InsufficientFunds: "insufficient_funds",
+  /**
+   * Haven's funding leg (account → delegate, the #946 EIP-3009 bridge)
+   * confirmed on-chain, but the merchant rejected the x402 retry. The delegate
+   * wallet may hold stranded USDC that was never settled to the merchant. The
+   * agent should stop, tell the user, and wait for the sweep flow to reclaim
+   * the funds.
+   */
+  FundedButUnsettled: "funded_but_unsettled"
+};
+var AgentPaymentNextAction = {
+  /** Sign with the delegate key and submit the payment to Haven. */
+  SignAndSubmitPayment: "sign_and_submit_payment",
+  /** Poll getPaymentStatus later using this payment id. */
+  CheckStatusLater: "check_status_later",
+  /** No further agent action is required for this payment id. */
+  None: "none",
+  /**
+   * #2115: RETIRED wire value — no live rail produces it and nothing maps to
+   * it. Stop and tell the user rather than polling; no approval will arrive.
+   */
+  WaitForUserApproval: "wait_for_user_approval",
+  /** #2115: RETIRED wire value — no live rail produces it. Stop and tell the user rather than polling. */
+  WaitForUserToCompletePayment: "wait_for_user_to_complete_payment",
+  /** Resume this payment id and retry the original x402 request with the merchant payment header. */
+  RetryOriginalX402Request: "retry_original_x402_request",
+  /** Stop retrying this payment and tell the user what happened. */
+  StopAndTellUser: "stop_and_tell_user",
+  /** Ask again only if the user still wants the payment after expiry. */
+  RequestAgainIfUserStillWantsIt: "request_again_if_user_still_wants_it",
+  /** #1307: retry the SAME tool call, supplying the explicit context fields the server could not rehydrate. */
+  RetryWithExplicitContext: "retry_with_explicit_context",
+  /**
+   * The x402 funding/quote window expired. Re-quote the same logical merchant
+   * operation with the same idempotency key to stay double-charge-safe.
+   */
+  PaymentWindowExpired: "payment_window_expired",
+  /**
+   * Stop and tell the user that the originating Safe needs to be funded or
+   * the agent's per-token allowance needs to be raised before the payment
+   * can succeed. A user approval will not fix this state on its own.
+   */
+  FundSafeOrRaiseAllowance: "fund_safe_or_raise_allowance",
+  /**
+   * The delegate wallet may hold funds that were sent from the Safe but never
+   * settled to the merchant. The wallet owner should initiate a sweep to
+   * return those funds to the originating Safe.
+   */
+  SweepStrandedFunds: "sweep_stranded_funds"
+};
+var AgentPaymentFailureCode = {
+  /** A merchant-authoritative x402 price exceeds the caller's pre-funding max_amount cap. */
+  PriceExceedsMax: "PRICE_EXCEEDS_MAX",
+  /** The x402 funding/quote window expired before the signer or hosted settle step could finish. */
+  PaymentWindowExpired: "PAYMENT_WINDOW_EXPIRED",
+  /** The Haven funding leg succeeded, but the merchant rejected the paid retry. */
+  MerchantRejectedAfterFunding: "MERCHANT_REJECTED_AFTER_FUNDING",
+  /** #1300 review: funding is on-chain but the merchant never ANSWERED the
+   *  paid retry within the timeout. NOT proof of rejection — the merchant
+   *  holds a valid EIP-3009 authorization and may still settle late, so the
+   *  guidance is verify-then-sweep, never blind sweep. */
+  MerchantUnresponsiveAfterFunding: "MERCHANT_UNRESPONSIVE_AFTER_FUNDING",
+  /**
+   * #1307: the caller omitted merchant_url/tool_name (asking Haven to
+   * rehydrate the stored MCP merchant-call context by payment_id), but no
+   * usable context was stored for this intent — either it was never an
+   * MCP-tool quote, or the stored context is incomplete. The fallback is
+   * mechanical: re-send merchant_url, tool_name, arguments, and
+   * mcp_transport explicitly (the version-skew path).
+   */
+  MerchantCallContextUnavailable: "MERCHANT_CALL_CONTEXT_UNAVAILABLE",
+  /**
+   * #1351: the caller supplied BOTH the atomic `max_amount` and the
+   * human-denominated `max_amount_human` cap for one purchase. Haven refuses
+   * to guess which the user meant — the two differ by a factor of 10^decimals,
+   * so picking wrong is exactly the silent-overspend this cap exists to
+   * prevent. Rejected before any merchant probe, funding intent, or signature.
+   */
+  AmbiguousMaxAmount: "AMBIGUOUS_MAX_AMOUNT",
+  /**
+   * #1351: a human-denominated cap was supplied, but it cannot be converted to
+   * atomic units against THIS quote — either the quote's asset has no known
+   * decimals on its network, or the cap carries more fraction digits than the
+   * asset can represent (truncating it would silently change the user's cap).
+   * The fallback is the exact atomic `max_amount`.
+   */
+  MaxAmountUnconvertible: "MAX_AMOUNT_UNCONVERTIBLE"
+};
+var AgentPaymentRail = {
+  /** Standard Haven payment from the user's Safe through an approved delegate allowance. */
+  Direct: "direct",
+  /** x402 HTTP 402 payment flow with a Haven funding leg and merchant retry leg. */
+  X402: "x402",
+  /** Machine Payment Protocol family — categorical value used as a resume-state discriminator. */
+  Mpp: "mpp",
+  /** Haven internal MPP demo rail. Not for production traffic. */
+  MppDemo: "mpp_demo",
+  /** Crypto-settled MPP rail. */
+  MppCrypto: "mpp_crypto",
+  /** Stripe-deposit-backed MPP rail. */
+  StripeDeposit: "stripe_deposit",
+  /** Stripe Payment Token MPP rail. */
+  Spt: "spt"
+};
+var AGENT_PAYMENT_PHASE_VALUES = Object.values(AgentPaymentPhase);
+var AGENT_PAYMENT_NEXT_ACTION_VALUES = Object.values(AgentPaymentNextAction);
+var AGENT_PAYMENT_FAILURE_CODE_VALUES = Object.values(AgentPaymentFailureCode);
+var AGENT_PAYMENT_RAIL_VALUES = Object.values(AgentPaymentRail);
+var AgentPaymentPhaseDescriptions = {
+  [AgentPaymentPhase.AgentSignatureRequired]: "The agent must sign and submit the prepared payment before Haven can relay it.",
+  [AgentPaymentPhase.PaymentSubmitted]: "Haven has received the signed payment and the agent should poll for confirmation.",
+  [AgentPaymentPhase.PaymentConfirmed]: "The direct payment is confirmed; the agent does not need to do more for this payment id.",
+  [AgentPaymentPhase.UserApprovalRequired]: "Retired wire value: no live rail produces it. It described the Safe rail's approval queue, which no longer exists \u2014 an out-of-policy payment is declined before any money moves. If it is ever seen, stop and tell the user; no approval is pending.",
+  [AgentPaymentPhase.UserExecutionRequired]: "Retired wire value: no live rail produces it. Stop and tell the user.",
+  [AgentPaymentPhase.WaitingForAdditionalApprovals]: "Retired wire value: no live rail produces it. Stop and tell the user.",
+  [AgentPaymentPhase.FundingSent]: "The Haven funding leg was sent; the agent can continue the merchant/protocol leg.",
+  [AgentPaymentPhase.Rejected]: "The payment was rejected and cannot proceed; the agent should stop and tell the user.",
+  [AgentPaymentPhase.Expired]: "The payment expired before completion.",
+  [AgentPaymentPhase.Failed]: "Haven could not complete the payment; the agent should stop and surface the failure.",
+  [AgentPaymentPhase.InsufficientFunds]: "Pre-flight check determined the delegate balance plus the remaining on-chain budget cannot cover the requested amount, so no payment was created. The account must be funded or the agent budget raised before retrying.",
+  [AgentPaymentPhase.FundedButUnsettled]: "Haven's funding leg confirmed on-chain but the merchant rejected the x402 retry. The delegate wallet may hold stranded funds. The agent should stop and wait for the wallet owner to sweep the stranded funds back to the account."
+};
+var AgentPaymentNextActionDescriptions = {
+  [AgentPaymentNextAction.SignAndSubmitPayment]: "Sign with the delegate key and submit the payment to Haven.",
+  [AgentPaymentNextAction.CheckStatusLater]: "Poll getPaymentStatus later using this payment id.",
+  [AgentPaymentNextAction.None]: "No further agent action is required for this payment id.",
+  [AgentPaymentNextAction.WaitForUserApproval]: "Retired wire value: no live rail produces it, and nothing maps to it. It described a per-payment approval queue that no longer exists. If it is ever seen, stop and tell the user rather than polling \u2014 no approval will arrive.",
+  [AgentPaymentNextAction.WaitForUserToCompletePayment]: "Retired wire value: no live rail produces it. Stop and tell the user rather than polling.",
+  [AgentPaymentNextAction.RetryOriginalX402Request]: "Resume this payment id and retry the original x402 request with the merchant payment header.",
+  [AgentPaymentNextAction.StopAndTellUser]: "Stop retrying this payment and tell the user what happened.",
+  [AgentPaymentNextAction.RequestAgainIfUserStillWantsIt]: "Ask again only if the user still wants the payment after expiry.",
+  [AgentPaymentNextAction.PaymentWindowExpired]: "The x402 funding/quote window expired. Re-quote with the same idempotency key before asking the signer to build a merchant payment header again.",
+  [AgentPaymentNextAction.FundSafeOrRaiseAllowance]: "Stop and tell the user that the account needs to be funded or the agent budget raised before the payment can succeed.",
+  [AgentPaymentNextAction.RetryWithExplicitContext]: "Retry the same tool call, this time passing merchant_url, tool_name, arguments, and mcp_transport explicitly \u2014 the server had no stored context to rehydrate for this payment id.",
+  [AgentPaymentNextAction.SweepStrandedFunds]: "Tell the user that funds may be stranded in the delegate wallet and prompt them to initiate a sweep in Haven to return them to the originating account."
+};
+var AgentPaymentFailureCodeDescriptions = {
+  [AgentPaymentFailureCode.PriceExceedsMax]: "The merchant-authoritative x402 amount exceeds the caller's max_amount cap. No funding transfer was created; ask the user before retrying with a larger cap.",
+  [AgentPaymentFailureCode.PaymentWindowExpired]: "The x402 funding/quote window expired before the signer or hosted settle step could finish. Re-quote via haven_pay_mcp_tool with the same idempotency key to avoid duplicate funding.",
+  [AgentPaymentFailureCode.MerchantRejectedAfterFunding]: "The Haven funding leg succeeded, but the merchant rejected the paid retry. Stop retrying the merchant and reconcile stranded delegate funds with haven_sweep_delegate.",
+  [AgentPaymentFailureCode.MerchantUnresponsiveAfterFunding]: "The Haven funding leg succeeded, but the merchant did not answer the paid retry before the timeout. The merchant may still settle late \u2014 check haven_get_payment_status (and retry haven_complete_mcp_tool once) BEFORE sweeping; sweep only if no settlement appears.",
+  [AgentPaymentFailureCode.MerchantCallContextUnavailable]: "merchant_url/tool_name were omitted and no stored merchant call context is available for this payment_id. Re-send merchant_url, tool_name, arguments, and mcp_transport explicitly.",
+  [AgentPaymentFailureCode.AmbiguousMaxAmount]: "Both max_amount (atomic units) and max_amount_human (whole tokens) were supplied for one purchase. Nothing was contacted and nothing was spent. Re-send with exactly ONE: max_amount_human for a cap the user stated in tokens, max_amount for an exact atomic figure.",
+  [AgentPaymentFailureCode.MaxAmountUnconvertible]: "max_amount_human could not be converted to atomic units against this quote's asset \u2014 either its decimals are unknown to Haven or the cap has more decimal places than the asset supports. Nothing was spent. Round the cap, or re-send it as an exact atomic max_amount."
+};
+var AgentPaymentWarningCode = {
+  /** No max_amount cap was supplied — the live quoted price was accepted as-is. */
+  MissingMaxAmount: "MISSING_MAX_AMOUNT",
+  /** The signing window closes soon; sign promptly or re-quote with the same idempotency key. */
+  QuoteExpiresSoon: "QUOTE_EXPIRES_SOON",
+  /** The merchant URL was resolved via discovery — pass the RESOLVED url forward. */
+  MerchantUrlDiscovered: "MERCHANT_URL_DISCOVERED",
+  /**
+   * #1306: the catalog's last-verified price_atomic differs from the LIVE
+   * merchant quote for a guided catalog purchase. The catalog price is only
+   * ever indicative; the live quote in the same response is authoritative.
+   */
+  CatalogPriceDiffers: "CATALOG_PRICE_DIFFERS",
+  /**
+   * #1306: the rail-aware allowance/budget pre-check could not be read (RPC
+   * failure, etc). `sufficient` is reported as null rather than a fabricated
+   * true/false — the on-chain policy remains the actual gate either way.
+   */
+  AllowanceCheckUnavailable: "ALLOWANCE_CHECK_UNAVAILABLE",
+  /**
+   * #1319: the delegation-rail read itself SUCCEEDED, but the remaining
+   * figure it returned is the #1145 fallback (the full configured budget)
+   * rather than a live ERC20PeriodTransferEnforcer read — `sufficient` is a
+   * real true/false, just computed from an optimistic number. Distinct from
+   * {@link AgentPaymentWarningCode.AllowanceCheckUnavailable}, which fires
+   * when the read failed outright and `sufficient` degrades to null. The
+   * on-chain policy re-checks at redemption either way; this only says the
+   * guidance shown here may be optimistic.
+   */
+  AllowanceReadOptimistic: "ALLOWANCE_READ_OPTIMISTIC"
+};
+var AgentPaymentRailDescriptions = {
+  [AgentPaymentRail.Direct]: "Standard Haven payment from the user-controlled account, redeeming the agent's on-chain budget delegation.",
+  [AgentPaymentRail.X402]: "x402 HTTP 402 payment flow with a Haven funding leg and merchant retry leg.",
+  [AgentPaymentRail.Mpp]: "Categorical MPP rail value used as a resume-state discriminator. Response bodies carry a granular mpp_* value instead.",
+  [AgentPaymentRail.MppDemo]: "Haven internal MPP demo rail. Not for production traffic.",
+  [AgentPaymentRail.MppCrypto]: "Crypto-settled MPP rail.",
+  [AgentPaymentRail.StripeDeposit]: "Stripe-deposit-backed MPP rail.",
+  [AgentPaymentRail.Spt]: "Stripe Payment Token MPP rail."
+};
+var AgentPaymentPhaseSchema = {
+  type: "string",
+  enum: AGENT_PAYMENT_PHASE_VALUES,
+  description: "Stable Haven agent payment state phase.",
+  "x-enumDescriptions": AgentPaymentPhaseDescriptions
+};
+var AgentPaymentNextActionSchema = {
+  type: "string",
+  enum: AGENT_PAYMENT_NEXT_ACTION_VALUES,
+  description: "Stable next action an agent should take for a Haven payment state.",
+  "x-enumDescriptions": AgentPaymentNextActionDescriptions
+};
+var AgentPaymentFailureCodeSchema = {
+  type: "string",
+  enum: AGENT_PAYMENT_FAILURE_CODE_VALUES,
+  description: "Stable machine-readable failure codes for Haven agent payment recovery paths.",
+  "x-enumDescriptions": AgentPaymentFailureCodeDescriptions
+};
+var AgentPaymentRailSchema = {
+  type: "string",
+  enum: AGENT_PAYMENT_RAIL_VALUES,
+  description: "Stable rail identifier for Haven agent payment states.",
+  "x-enumDescriptions": AgentPaymentRailDescriptions
+};
+var HavenError = class extends Error {
+  constructor(message, code, statusCode, paymentId) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.paymentId = paymentId;
+    this.name = "HavenError";
+  }
+  code;
+  statusCode;
+  paymentId;
+};
+var HavenApiError = class extends HavenError {
+  constructor(message, statusCode, body, paymentId) {
+    super(message, "API_ERROR", statusCode, paymentId);
+    this.body = body;
+    this.name = "HavenApiError";
+  }
+  body;
+};
+var MerchantTimeoutError = class extends HavenApiError {
+  merchantErrorCode = "merchant_timeout";
+  constructor(message) {
+    super(message, 504);
+    this.name = "MerchantTimeoutError";
+  }
+};
+var X402UnexpectedStatusError = class extends HavenApiError {
+  x402ErrorCode = "unexpected_non_402_status";
+  constructor(message, statusCode) {
+    super(message, statusCode);
+    this.name = "X402UnexpectedStatusError";
+  }
+};
+var X402AlreadySettledError = class extends HavenApiError {
+  constructor(message, receipt, basis) {
+    super(message, 409, void 0, receipt.paymentId);
+    this.receipt = receipt;
+    this.basis = basis;
+    this.name = "X402AlreadySettledError";
+  }
+  receipt;
+  basis;
+  x402ErrorCode = "already_settled";
+};
+var HavenPaymentStateError = class extends HavenApiError {
+  constructor(message, statusCode, state, body) {
+    super(message, statusCode, body, state.paymentId);
+    this.state = state;
+    this.name = "HavenPaymentStateError";
+  }
+  state;
+  resumeState;
+  get status() {
+    return this.state.status;
+  }
+  get phase() {
+    return this.state.phase;
+  }
+  get nextAction() {
+    return this.state.nextAction;
+  }
+};
+var HavenSigningError = class extends HavenError {
+  constructor(message) {
+    super(message, "SIGNING_ERROR");
+    this.name = "HavenSigningError";
+  }
+};
+var SignerRefusalCode = {
+  /** `SUPPORTED_X402_EXPECTED_VERSIONS` in `@haven_ai/signer` does not include the received version. */
+  UnsupportedExpectedContextVersion: "UNSUPPORTED_EXPECTED_CONTEXT_VERSION",
+  /** `SUPPORTED_SWEEP_BINDING_VERSIONS` in `@haven_ai/signer` does not include the received version. */
+  UnsupportedSweepBindingVersion: "UNSUPPORTED_SWEEP_BINDING_VERSION"
+};
+function signerUpdateFallback(channel = HAVEN_CONNECTOR_CHANNEL) {
+  return `Update @haven_ai/signer by rerunning \`${connectorRerunCommand(void 0, { channel })}\`, which reinstalls the pinned MCP runtime, then retry the same signing call. Nothing was signed or spent \u2014 the quote or payment this version came from is unaffected and does not need to be re-quoted.`;
+}
+var SIGNER_UPDATE_FALLBACK = signerUpdateFallback();
+var HavenUnsupportedSignerVersionError = class extends HavenError {
+  constructor(message, code, supportedVersions, receivedVersion, fallback) {
+    super(message, code);
+    this.supportedVersions = supportedVersions;
+    this.receivedVersion = receivedVersion;
+    this.fallback = fallback;
+    this.name = "HavenUnsupportedSignerVersionError";
+  }
+  supportedVersions;
+  receivedVersion;
+  fallback;
+};
+var HavenTimeoutError = class extends HavenError {
+  constructor(paymentId) {
+    super(
+      `Timed out waiting for payment ${paymentId} to confirm`,
+      "TIMEOUT",
+      void 0,
+      paymentId
+    );
+    this.name = "HavenTimeoutError";
+  }
+};
+
+// src/signer.ts
+function signHash(privateKey, hash) {
+  try {
+    const signingKey = new ethers.SigningKey(privateKey);
+    const sig = signingKey.sign(hash);
+    return sig.serialized;
+  } catch (err) {
+    throw new HavenSigningError(
+      `Failed to sign hash: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function signTypedDataVerbatim(privateKey, typedData, label) {
+  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 ${label}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function signUserOpTypedDataForDelegation(privateKey, typedData) {
+  return signTypedDataVerbatim(privateKey, typedData, "delegation UserOperation");
+}
+async function signSettlementDelegationTypedData(privateKey, typedData) {
+  return signTypedDataVerbatim(privateKey, typedData, "x402 settlement delegation");
+}
+function addressFromKey(privateKey) {
+  try {
+    return new ethers.Wallet(privateKey).address;
+  } catch (err) {
+    throw new HavenSigningError(
+      `Invalid private key: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function verifySignature(hash, signature, expectedAddress) {
+  try {
+    const recovered = ethers.recoverAddress(hash, signature);
+    return recovered.toLowerCase() === expectedAddress.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+
+// src/base64.ts
+function normalizeBase64(value) {
+  const standard = value.replace(/-/g, "+").replace(/_/g, "/");
+  const remainder = standard.length % 4;
+  return remainder === 0 ? standard : standard + "=".repeat(4 - remainder);
+}
+function encodeBase64Utf8(value) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(value, "utf8").toString("base64");
+  }
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function decodeBase64Utf8(value) {
+  const normalized = normalizeBase64(value);
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(normalized, "base64").toString("utf8");
+  }
+  const binary = atob(normalized);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new TextDecoder().decode(bytes);
+}
+function encodeBase64Json(value) {
+  return encodeBase64Utf8(JSON.stringify(value));
+}
+function decodeBase64Json(value, label) {
+  try {
+    return JSON.parse(decodeBase64Utf8(value));
+  } catch (err) {
+    if (label) throw new Error(`Failed to decode ${label}`);
+    throw err;
+  }
+}
+
+// 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_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" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function sweepUsdcAddress(chainId) {
+  const address = USDC_ADDRESS_BY_CHAIN[chainId];
+  if (!address) {
+    throw new HavenSigningError(
+      `Sweep is not supported on chain ${chainId}. Supported: ${SWEEPABLE_CHAIN_IDS.join(", ")}.`
+    );
+  }
+  return address;
+}
+function sweepUsdcDomain(chainId) {
+  const domain = USDC_EIP712_DOMAIN_BY_CHAIN[chainId];
+  if (!domain) {
+    throw new HavenSigningError(
+      `Sweep is not supported on chain ${chainId}. Supported: ${SWEEPABLE_CHAIN_IDS.join(", ")}.`
+    );
+  }
+  return domain;
+}
+function sameAddress(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function buildSweepTypedData(auth) {
+  const domain = sweepUsdcDomain(auth.chainId);
+  const expectedToken = sweepUsdcAddress(auth.chainId);
+  if (!sameAddress(auth.token, expectedToken)) {
+    throw new HavenSigningError(
+      `Sweep token ${auth.token} is not the canonical USDC contract for chain ${auth.chainId}.`
+    );
+  }
+  if (!/^0x[0-9a-fA-F]{64}$/.test(auth.nonce)) {
+    throw new HavenSigningError("Sweep nonce must be a 0x-prefixed 32-byte hex string.");
+  }
+  return {
+    domain,
+    types: TRANSFER_WITH_AUTHORIZATION_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: auth.from,
+      to: auth.to,
+      value: BigInt(auth.value),
+      validAfter: BigInt(auth.validAfter),
+      validBefore: BigInt(auth.validBefore),
+      nonce: auth.nonce
+    }
+  };
+}
+function buildSweepAuthorizationMessage(auth) {
+  return `Haven sweep authorization v1
+${stableStringify({
+    version: 1,
+    kind: "haven.sweep.authorization",
+    from: auth.from.toLowerCase(),
+    to: auth.to.toLowerCase(),
+    value: auth.value,
+    validAfter: auth.validAfter,
+    validBefore: auth.validBefore,
+    nonce: auth.nonce.toLowerCase(),
+    token: auth.token.toLowerCase(),
+    chainId: auth.chainId
+  })}`;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
+}
+
+// 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]+$/;
+var X402_PAYMENT_HEADER_MAX_LENGTH = 65536;
+var BASE64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
+var ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+var SIGNATURE_RE = /^0x[0-9a-fA-F]{130}$/;
+var NONCE_RE = /^0x[0-9a-fA-F]{64}$/;
+var X402PaymentHeaderValidationError = class extends Error {
+  constructor() {
+    super("Invalid X-PAYMENT header.");
+    this.name = "X402PaymentHeaderValidationError";
+  }
+};
+function isPositiveDecimalAtomicAmount(value) {
+  return DECIMAL_ATOMIC_AMOUNT_RE.test(value) && BigInt(value) > 0n;
+}
+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") {
+    return null;
+  }
+  const amount = typeof candidate.amount === "string" ? candidate.amount : typeof candidate.maxAmountRequired === "string" ? candidate.maxAmountRequired : null;
+  if (!amount) return null;
+  if (!isPositiveDecimalAtomicAmount(amount)) return null;
+  if (candidate.maxAmountRequired !== void 0 && (typeof candidate.maxAmountRequired !== "string" || !isPositiveDecimalAtomicAmount(candidate.maxAmountRequired))) {
+    return null;
+  }
+  return {
+    scheme: candidate.scheme,
+    network: candidate.network,
+    amount,
+    maxAmountRequired: candidate.maxAmountRequired,
+    resource: candidate.resource,
+    description: candidate.description,
+    mimeType: candidate.mimeType,
+    asset: candidate.asset,
+    payTo: candidate.payTo,
+    maxTimeoutSeconds: clampAuthorizationWindow(candidate.maxTimeoutSeconds),
+    extra: candidate.extra
+  };
+}
+function normalizePaymentRequired(value) {
+  const candidate = value;
+  if (!candidate || typeof candidate !== "object" || typeof candidate.x402Version !== "number" || !Array.isArray(candidate.accepts)) {
+    return null;
+  }
+  const accepts = candidate.accepts.map((option) => normalizePaymentOption(option)).filter((option) => !!option && typeof option === "object");
+  if (accepts.length === 0) return null;
+  const first = accepts[0];
+  const resourceUrl = candidate.resource?.url ?? first.resource;
+  if (!resourceUrl) return null;
+  const resource = {
+    ...candidate.resource && typeof candidate.resource === "object" ? candidate.resource : {},
+    url: resourceUrl,
+    description: candidate.resource?.description ?? first.description,
+    mimeType: candidate.resource?.mimeType ?? first.mimeType
+  };
+  return {
+    x402Version: candidate.x402Version,
+    resource,
+    accepts,
+    error: candidate.error,
+    ...candidate.extensions && typeof candidate.extensions === "object" ? { extensions: candidate.extensions } : {}
+  };
+}
+var SUPPORTED_X402_NETWORKS = {
+  "eip155:100": "Gnosis Chain",
+  "eip155:8453": "Base",
+  "base": "Base",
+  "eip155:84532": "Base Sepolia",
+  "base-sepolia": "Base Sepolia"
+};
+var STANDARD_X402_NETWORKS = {
+  "eip155:8453": "base",
+  "base": "base",
+  "eip155:84532": "base-sepolia",
+  "base-sepolia": "base-sepolia"
+};
+var GNOSIS_TOKENS = {
+  "0x0000000000000000000000000000000000000000": { symbol: "xDAI", decimals: 18 },
+  "0xcb444e90d8198415266c6a2724b7900fb12fc56e": { symbol: "EURe", decimals: 18 },
+  "0x2a22f9c3b484c3629090feed35f17ff8f88f76f0": { symbol: "USDC.e", decimals: 6 }
+};
+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_SEPOLIA_TOKENS
+};
+var NETWORK_TOKENS = {
+  "eip155:100": GNOSIS_TOKENS,
+  "eip155:8453": BASE_TOKENS,
+  "base": BASE_TOKENS,
+  "eip155:84532": BASE_SEPOLIA_TOKENS,
+  "base-sepolia": BASE_SEPOLIA_TOKENS
+};
+var X402_PAYMENT_HEADER_NAME = "PAYMENT-SIGNATURE";
+var X402_LEGACY_PAYMENT_HEADER_NAME = "X-PAYMENT";
+var X402_PAYMENT_REQUIRED_HEADER_NAME = "PAYMENT-REQUIRED";
+var X402_PAYMENT_RESPONSE_HEADER_NAME = "PAYMENT-RESPONSE";
+var X402_PAYMENT_HEADER_NAMES_SENT = `${X402_PAYMENT_HEADER_NAME}, ${X402_LEGACY_PAYMENT_HEADER_NAME}`;
+var X402_PAYMENT_HEADER_NAMES = [
+  X402_PAYMENT_HEADER_NAME,
+  X402_LEGACY_PAYMENT_HEADER_NAME
+];
+function x402PaymentHeaderNamesFor(paymentHeader) {
+  const both = [X402_PAYMENT_HEADER_NAME, X402_LEGACY_PAYMENT_HEADER_NAME];
+  let decoded;
+  try {
+    decoded = decodeBase64Json(paymentHeader);
+  } catch {
+    return both;
+  }
+  const accepted = decoded?.accepted;
+  if (!accepted || typeof accepted !== "object" || Array.isArray(accepted)) return both;
+  return isErc7710Option(accepted) ? [X402_PAYMENT_HEADER_NAME] : both;
+}
+function x402PaymentHeaderNamesSent(paymentHeader) {
+  return x402PaymentHeaderNamesFor(paymentHeader).join(", ");
+}
+function x402V2PaymentEnvelope(paymentRequired, accepted, payload) {
+  const resource = paymentRequired.resource;
+  const extensions = paymentRequired.extensions;
+  return {
+    x402Version: paymentRequired.x402Version,
+    ...resource && typeof resource === "object" && !Array.isArray(resource) ? { resource } : {},
+    accepted,
+    payload,
+    ...extensions && typeof extensions === "object" && !Array.isArray(extensions) ? { extensions } : {}
+  };
+}
+function parsePaymentRequired(response) {
+  const v2Header = response.headers.get("PAYMENT-REQUIRED");
+  if (v2Header) {
+    const parsed = normalizePaymentRequired(
+      decodeBase64Json(v2Header, "PAYMENT-REQUIRED header")
+    );
+    if (parsed) return parsed;
+  }
+  const v1Header = response.headers.get("X-PAYMENT");
+  if (v1Header) {
+    const parsed = normalizePaymentRequired(
+      decodeBase64Json(v1Header, "X-PAYMENT header")
+    );
+    if (parsed) return parsed;
+  }
+  throw new Error(
+    "No x402 payment headers found in 402 response. Expected PAYMENT-REQUIRED (v2) or X-PAYMENT (v1) header."
+  );
+}
+async function parsePaymentRequiredResponse(response) {
+  try {
+    return parsePaymentRequired(response);
+  } catch (headerErr) {
+    try {
+      const body = await response.clone().json();
+      const parsed = normalizePaymentRequired(body);
+      if (parsed) return parsed;
+    } catch {
+    }
+    throw headerErr;
+  }
+}
+function selectPaymentOption(accepts) {
+  if (!accepts || accepts.length === 0) return null;
+  for (const opt of accepts) {
+    if (opt.network in SUPPORTED_X402_NETWORKS) {
+      const networkTokens = NETWORK_TOKENS[opt.network];
+      if (networkTokens?.[opt.asset.toLowerCase()] && isPositiveDecimalAtomicAmount(optionAuthorizationAmount(opt))) {
+        return opt;
+      }
+    }
+  }
+  for (const opt of accepts) {
+    if (opt.network in SUPPORTED_X402_NETWORKS && isPositiveDecimalAtomicAmount(optionAuthorizationAmount(opt))) {
+      return opt;
+    }
+  }
+  return null;
+}
+var ERC7710_ASSET_TRANSFER_METHOD = "erc7710";
+function x402AssetTransferMethod(option) {
+  const raw = option.extra?.assetTransferMethod;
+  return typeof raw === "string" ? raw : null;
+}
+function isErc7710Option(option) {
+  return x402AssetTransferMethod(option) === ERC7710_ASSET_TRANSFER_METHOD;
+}
+function x402FacilitatorAddresses(option) {
+  const raw = option.extra?.facilitatorAddresses;
+  if (!Array.isArray(raw)) return null;
+  const addresses = raw.filter((a) => typeof a === "string" && ADDRESS_RE.test(a));
+  return addresses.length > 0 ? addresses : null;
+}
+function isPayableStandardOption(opt) {
+  return opt.scheme === "exact" && opt.network in STANDARD_X402_NETWORKS && STANDARD_X402_USDC_ADDRESSES.has(opt.asset.toLowerCase()) && isPositiveDecimalAtomicAmount(optionAuthorizationAmount(opt));
+}
+function selectStandardPaymentOption(accepts) {
+  if (!accepts || accepts.length === 0) return null;
+  for (const opt of accepts) {
+    if (opt === null || typeof opt !== "object") continue;
+    if (!isErc7710Option(opt) && isPayableStandardOption(opt)) return opt;
+  }
+  return null;
+}
+function selectErc7710PaymentOption(accepts) {
+  if (!accepts || accepts.length === 0) return null;
+  for (const opt of accepts) {
+    if (opt === null || typeof opt !== "object") continue;
+    if (isErc7710Option(opt) && isPayableStandardOption(opt)) return opt;
+  }
+  return null;
+}
+function selectX402SettlementScheme(accepts, opts) {
+  if (opts.delegationRail) {
+    const preferred = selectErc7710PaymentOption(accepts);
+    if (preferred) {
+      return {
+        scheme: "erc7710",
+        option: preferred,
+        facilitatorAddresses: x402FacilitatorAddresses(preferred)
+      };
+    }
+  }
+  const fallback = selectStandardPaymentOption(accepts);
+  if (fallback) return { scheme: "eip3009", option: fallback, facilitatorAddresses: null };
+  return null;
+}
+function x402AuthorizationAmount(option) {
+  const amount = optionAuthorizationAmount(option);
+  if (!isPositiveDecimalAtomicAmount(amount)) {
+    throw new Error("Invalid x402 amount: must be a positive decimal atomic amount");
+  }
+  return amount;
+}
+function buildX402ExpectedMessage(context) {
+  const version = context.payerDelegate ? 3 : context.typedDataHash ? 2 : 1;
+  const payload = {
+    version,
+    kind: "haven.x402.expected",
+    paymentId: context.paymentId,
+    payloadHash: context.payloadHash.toLowerCase(),
+    resourceUrl: context.resourceUrl,
+    merchantTo: context.merchantTo.toLowerCase(),
+    amount: context.amount,
+    asset: context.asset.toLowerCase(),
+    network: context.network
+  };
+  if (context.expiresAt) {
+    payload.expiresAt = context.expiresAt;
+  }
+  if (context.typedDataHash) {
+    payload.typedDataHash = context.typedDataHash.toLowerCase();
+  }
+  if (context.payerDelegate) {
+    payload.payerDelegate = context.payerDelegate.toLowerCase();
+    if (context.payerAgentId) {
+      payload.payerAgentId = context.payerAgentId;
+    }
+  }
+  return `Haven x402 expected context v${version}
+${stableStringify2(payload)}`;
+}
+function toStandardPaymentRequirements(paymentRequired, option) {
+  const network = STANDARD_X402_NETWORKS[option.network];
+  if (!network) {
+    throw new Error(`x402 exact payments are not supported on ${option.network}`);
+  }
+  if (option.scheme !== "exact") {
+    throw new Error(`Unsupported x402 scheme: ${option.scheme}`);
+  }
+  return {
+    scheme: "exact",
+    network,
+    maxAmountRequired: x402AuthorizationAmount(option),
+    resource: option.resource ?? paymentRequired.resource.url,
+    description: option.description ?? paymentRequired.resource.description ?? "Haven x402 payment",
+    mimeType: option.mimeType ?? paymentRequired.resource.mimeType ?? "application/octet-stream",
+    payTo: option.payTo,
+    asset: option.asset,
+    // 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
+  };
+}
+async function validateStandardX402PaymentHeader(paymentHeader, context) {
+  try {
+    if (typeof paymentHeader !== "string" || paymentHeader.length === 0 || paymentHeader.length > X402_PAYMENT_HEADER_MAX_LENGTH || paymentHeader.length % 4 !== 0 || !BASE64_RE.test(paymentHeader)) {
+      throw new Error("wire");
+    }
+    const decoded = decodeBase64Json(paymentHeader);
+    if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) throw new Error("shape");
+    const version = decoded.x402Version;
+    const payload = decoded.payload;
+    if (version !== 1 && version !== 2 || !payload || typeof payload !== "object" || Array.isArray(payload)) {
+      throw new Error("shape");
+    }
+    if (version === 1) {
+      if (!hasOnlyKeys(decoded, ["x402Version", "scheme", "network", "payload"])) throw new Error("shape");
+      if (decoded.scheme !== "exact" || decoded.network !== standardX402WireNetwork(context.network)) {
+        throw new Error("context");
+      }
+    } else {
+      if (!hasOnlyKeys(decoded, ["x402Version", "accepted", "payload"], ["resource", "extensions"])) {
+        throw new Error("shape");
+      }
+      if ("resource" in decoded && (!decoded.resource || typeof decoded.resource !== "object" || Array.isArray(decoded.resource))) {
+        throw new Error("shape");
+      }
+      if ("extensions" in decoded && (!decoded.extensions || typeof decoded.extensions !== "object" || Array.isArray(decoded.extensions))) {
+        throw new Error("shape");
+      }
+      const accepted = selectStandardPaymentOption([decoded.accepted]);
+      if (!accepted || !matchesHeaderContext(accepted, context)) throw new Error("context");
+    }
+    const record = payload;
+    if (!hasOnlyKeys(record, ["signature", "authorization"])) throw new Error("shape");
+    if (typeof record.signature !== "string" || !SIGNATURE_RE.test(record.signature)) throw new Error("shape");
+    const authorization = record.authorization;
+    if (!authorization || typeof authorization !== "object" || Array.isArray(authorization)) throw new Error("shape");
+    const auth = authorization;
+    if (!hasOnlyKeys(auth, ["from", "to", "value", "validAfter", "validBefore", "nonce"])) throw new Error("shape");
+    if (typeof auth.from !== "string" || !ADDRESS_RE.test(auth.from) || typeof auth.to !== "string" || !ADDRESS_RE.test(auth.to) || typeof auth.value !== "string" || !isPositiveDecimalAtomicAmount(auth.value) || typeof auth.validAfter !== "string" || !DECIMAL_ATOMIC_AMOUNT_RE.test(auth.validAfter) || typeof auth.validBefore !== "string" || !DECIMAL_ATOMIC_AMOUNT_RE.test(auth.validBefore) || typeof auth.nonce !== "string" || !NONCE_RE.test(auth.nonce)) {
+      throw new Error("shape");
+    }
+    if (!sameAddress2(auth.from, context.payer) || !sameAddress2(auth.to, context.merchantTo) || auth.value !== context.amountAtomic) {
+      throw new Error("context");
+    }
+    const validAfter = BigInt(auth.validAfter);
+    const validBefore = BigInt(auth.validBefore);
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    if (validBefore <= now || validAfter > validBefore) throw new Error("expired");
+    const typedData = buildSweepTypedData({
+      from: auth.from,
+      to: auth.to,
+      value: auth.value,
+      validAfter: auth.validAfter,
+      validBefore: auth.validBefore,
+      nonce: auth.nonce,
+      token: context.asset,
+      chainId: context.chainId
+    });
+    const recovered = await recoverTypedDataAddress({
+      ...typedData,
+      // `buildSweepTypedData` keeps the public domain framework-neutral;
+      // viem brands contract addresses at this crypto call boundary only.
+      domain: {
+        ...typedData.domain,
+        verifyingContract: typedData.domain.verifyingContract
+      },
+      message: {
+        ...typedData.message,
+        from: typedData.message.from,
+        to: typedData.message.to,
+        nonce: typedData.message.nonce
+      },
+      signature: record.signature
+    });
+    if (!sameAddress2(recovered, context.payer)) throw new Error("recovery");
+  } catch {
+    throw new X402PaymentHeaderValidationError();
+  }
+}
+function hasOnlyKeys(value, required, optional = []) {
+  return Object.keys(value).every((key) => required.includes(key) || optional.includes(key)) && required.every((key) => key in value);
+}
+function sameAddress2(left, right) {
+  return left.toLowerCase() === right.toLowerCase();
+}
+function standardX402WireNetwork(network) {
+  return STANDARD_X402_NETWORKS[network] ?? null;
+}
+function matchesHeaderContext(option, context) {
+  if (option.scheme !== "exact" || !sameAddress2(option.payTo, context.merchantTo) || !sameAddress2(option.asset, context.asset) || option.network !== context.network || x402AuthorizationAmount(option) !== context.amountAtomic) return false;
+  return option.resource === void 0 || option.resource === context.resourceUrl;
+}
+function buildX402IdempotencyKey(paymentRequired, option, now = Date.now()) {
+  const bucket = Math.floor(now / X402_IDEMPOTENCY_BUCKET_MS);
+  const material = [
+    paymentRequired.resource.url,
+    paymentRequired.resource.description ?? "",
+    option.payTo.toLowerCase(),
+    option.asset.toLowerCase(),
+    x402AuthorizationAmount(option),
+    option.network,
+    bucket
+  ].join("|");
+  return `x402:${createHash("sha256").update(material).digest("hex").slice(0, 16)}`;
+}
+function encodePaymentProof(receipt) {
+  const payload = {
+    x402Version: 2,
+    resource: receipt.resourceUrl ? { url: receipt.resourceUrl } : void 0,
+    accepted: receipt.accepted,
+    payload: {
+      type: "haven_tx_hash",
+      txHash: receipt.txHash,
+      paymentId: receipt.paymentId,
+      settledVia: "haven",
+      payer: receipt.payer,
+      chainId: receipt.chainId
+    }
+  };
+  return encodeBase64Json(payload);
+}
+function resolveTokenFromAddress(address, network) {
+  const lower = address.toLowerCase();
+  if (network && network in NETWORK_TOKENS) {
+    return NETWORK_TOKENS[network][lower] ?? null;
+  }
+  return ALL_TOKENS[lower] ?? null;
+}
+function stableStringify2(value) {
+  if (value === null || typeof value !== "object") {
+    const primitive = JSON.stringify(value);
+    return primitive === void 0 ? "undefined" : primitive;
+  }
+  if (value instanceof Date) return JSON.stringify(value.toISOString());
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify2(item)).join(",")}]`;
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify2(object[key])}`).join(",")}}`;
+}
+var DEFAULT_BASE_URL = "http://localhost:3001";
+var DEFAULT_REQUEST_TIMEOUT = 3e4;
+var HavenApiTransport = class {
+  apiKey;
+  baseUrl;
+  requestTimeout;
+  defaultHeaders;
+  requestContext = new AsyncLocalStorage();
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.requestTimeout = config.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+    this.defaultHeaders = { ...config.defaultHeaders ?? {} };
+  }
+  /** Run `fn` with extra headers scoped to its asynchronous Haven API work. */
+  withRequestContext(headers, fn) {
+    return this.requestContext.run({ headers: { ...headers } }, fn);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.requestTimeout);
+    try {
+      const contextHeaders = this.requestContext.getStore()?.headers ?? {};
+      const res = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`,
+          ...this.defaultHeaders,
+          ...contextHeaders
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      const data = await res.json();
+      if (!res.ok) {
+        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;
+    } catch (err) {
+      if (err instanceof HavenApiError) throw err;
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new HavenApiError(`Request to ${path} timed out`, 408);
+      }
+      throw new HavenApiError(
+        `Request to ${path} failed: ${err instanceof Error ? err.message : String(err)}`,
+        0
+      );
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/payment-mappers.ts
+function mapPaymentResult(raw, buildExplorerUrl2) {
+  return {
+    paymentId: raw.payment_id,
+    status: raw.status,
+    token: raw.token,
+    amount: raw.amount,
+    to: raw.to,
+    txHash: raw.tx_hash,
+    errorMessage: raw.error_message,
+    explorerUrl: raw.explorer_url ?? (raw.tx_hash ? buildExplorerUrl2(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,
+    confirmedAt: raw.confirmed_at,
+    expiresAt: raw.expires_at
+  };
+}
+function mapPaymentStatusResult(raw) {
+  return {
+    paymentId: raw.payment_id,
+    kind: raw.kind,
+    rail: raw.rail,
+    status: raw.status,
+    phase: raw.phase,
+    nextAction: raw.next_action,
+    amount: raw.amount,
+    token: raw.token,
+    resourceUrl: raw.resource_url,
+    merchantAddress: raw.merchant_address,
+    payerAddress: raw.payer_address ?? null,
+    txHash: raw.tx_hash,
+    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,
+    description: raw.description ?? raw.x402?.description ?? null,
+    idempotencyKey: raw.idempotency_key ?? raw.x402?.idempotency_key ?? null,
+    x402: raw.x402 ? {
+      amountAtomic: raw.x402.amount_atomic ?? raw.amount_atomic ?? null,
+      asset: raw.x402.asset ?? raw.asset ?? null,
+      network: raw.x402.network ?? raw.network ?? null,
+      resourceUrl: raw.x402.resource_url ?? raw.resource_url,
+      merchantAddress: raw.x402.merchant_address ?? raw.merchant_address,
+      description: raw.x402.description ?? raw.description ?? null,
+      idempotencyKey: raw.x402.idempotency_key ?? raw.idempotency_key ?? null
+    } : void 0
+  };
+}
+function mapPaymentReceipt(raw) {
+  const receipt = {
+    id: raw.id,
+    paymentId: raw.payment_id,
+    rail: raw.rail,
+    proofStatus: raw.proof_status,
+    txHash: raw.tx_hash,
+    chainId: raw.chain_id,
+    resourceUrl: raw.resource_url,
+    merchantAddress: raw.merchant_address,
+    payerAddress: raw.payer_address,
+    settlementAddress: raw.settlement_address,
+    tokenSymbol: raw.token_symbol,
+    tokenAddress: raw.token_address,
+    amountRaw: raw.amount_raw,
+    amount: raw.amount_human,
+    challengeId: raw.challenge_id,
+    idempotencyKey: raw.idempotency_key,
+    challengePayload: raw.challenge_payload,
+    selectedPayment: raw.selected_payment,
+    paymentProofHeaderName: raw.payment_proof_header_name,
+    protocolReceiptHeaderName: raw.protocol_receipt_header_name,
+    protocolReceiptPayload: raw.protocol_receipt_payload,
+    merchantStatus: raw.merchant_status,
+    confirmedAt: raw.confirmed_at,
+    createdAt: raw.created_at,
+    updatedAt: raw.updated_at
+  };
+  if ("payment_intent_id" in raw) {
+    receipt.paymentIntentId = raw.payment_intent_id ?? null;
+  }
+  if ("approval_request_id" in raw) {
+    receipt.approvalRequestId = raw.approval_request_id ?? null;
+  }
+  return receipt;
+}
+
+// src/payment-state.ts
+var PAYMENT_STATE_STATUS_CODES = {
+  pending: 202,
+  pending_approval: 202,
+  approved: 202,
+  proposed: 202,
+  executed: 200,
+  pending_signature: 409,
+  submitted: 409,
+  expired: 410,
+  failed: 502,
+  rejected: 409
+};
+function paymentStateStatusCode(status, fallback = 502) {
+  return PAYMENT_STATE_STATUS_CODES[status] ?? fallback;
+}
+function phaseForStatus(status) {
+  if (status === "pending_signature") return AgentPaymentPhase.AgentSignatureRequired;
+  if (status === "submitted") return AgentPaymentPhase.PaymentSubmitted;
+  if (status === "confirmed") return AgentPaymentPhase.PaymentConfirmed;
+  if (status === "pending" || status === "pending_approval") return AgentPaymentPhase.UserApprovalRequired;
+  if (status === "approved") return AgentPaymentPhase.UserExecutionRequired;
+  if (status === "proposed") return AgentPaymentPhase.WaitingForAdditionalApprovals;
+  if (status === "executed") return AgentPaymentPhase.FundingSent;
+  if (status === "rejected") return AgentPaymentPhase.Rejected;
+  if (status === "expired") return AgentPaymentPhase.Expired;
+  if (status === "failed") return AgentPaymentPhase.Failed;
+  return null;
+}
+function nextActionForStatus(status) {
+  if (status === "pending_signature") return AgentPaymentNextAction.SignAndSubmitPayment;
+  if (status === "submitted") return AgentPaymentNextAction.CheckStatusLater;
+  if (status === "confirmed") return AgentPaymentNextAction.None;
+  if (status === "pending" || status === "pending_approval") return AgentPaymentNextAction.StopAndTellUser;
+  if (status === "approved") return AgentPaymentNextAction.StopAndTellUser;
+  if (status === "proposed") return AgentPaymentNextAction.StopAndTellUser;
+  if (status === "executed") return AgentPaymentNextAction.StopAndTellUser;
+  if (status === "rejected") return AgentPaymentNextAction.StopAndTellUser;
+  if (status === "expired") return AgentPaymentNextAction.RequestAgainIfUserStillWantsIt;
+  if (status === "failed") return AgentPaymentNextAction.StopAndTellUser;
+  return null;
+}
+function messageForState(label, status, paymentId, nextAction) {
+  if (status === "pending" || status === "pending_approval") {
+    return `${label} is not payable: it is outside the agent's on-chain budget and no approval is pending (payment_id: ${paymentId}). Ask the user to grant or raise the budget in Haven.`;
+  }
+  if (status === "approved") {
+    return `This payment carries a retired status ("approved") that no live Haven rail produces (payment_id: ${paymentId}). Nothing is waiting to be completed \u2014 tell the user to review this payment in Haven.`;
+  }
+  if (status === "executed") {
+    return `This payment carries a retired status ("executed") that no live Haven rail produces (payment_id: ${paymentId}). Do not retry it \u2014 tell the user to review this payment in Haven.`;
+  }
+  if (status === "rejected") {
+    return `The user rejected this payment request (payment_id: ${paymentId}).`;
+  }
+  if (status === "expired") {
+    return `This payment request expired (payment_id: ${paymentId}).`;
+  }
+  return `${label} is ${status}; next_action=${nextAction} (payment_id: ${paymentId}).`;
+}
+function paymentStateFromRaw(label, raw) {
+  if (!raw.payment_id || !raw.status) return null;
+  const phase = raw.phase ?? phaseForStatus(raw.status);
+  const nextAction = raw.next_action ?? nextActionForStatus(raw.status);
+  if (!phase || !nextAction) return null;
+  const amount = raw.amount ?? raw.requested ?? "";
+  const token = raw.token ?? "";
+  const message = raw.message ?? raw.error ?? messageForState(label, raw.status, raw.payment_id, nextAction);
+  return {
+    paymentId: raw.payment_id,
+    kind: raw.kind === "payment_intent" ? "payment_intent" : "approval_request",
+    rail: raw.rail ?? "direct",
+    status: raw.status === "pending" ? "pending_approval" : raw.status,
+    phase,
+    nextAction,
+    amount,
+    token,
+    resourceUrl: raw.resource_url ?? null,
+    merchantAddress: raw.merchant_address ?? raw.merchant_to ?? null,
+    txHash: raw.tx_hash ?? null,
+    expiresAt: raw.expires_at ?? "",
+    chainId: raw.chain_id ?? 0,
+    message,
+    amountAtomic: raw.amount_atomic ?? raw.x402?.amount_atomic ?? raw.mpp?.amount_atomic ?? null,
+    asset: raw.asset ?? raw.x402?.asset ?? raw.mpp?.asset ?? null,
+    network: raw.network ?? raw.x402?.network ?? raw.mpp?.network ?? null,
+    description: raw.description ?? raw.x402?.description ?? raw.mpp?.description ?? null,
+    idempotencyKey: raw.idempotency_key ?? raw.x402?.idempotency_key ?? raw.mpp?.idempotency_key ?? null,
+    x402: raw.x402 ? {
+      amountAtomic: raw.x402.amount_atomic ?? raw.amount_atomic ?? null,
+      asset: raw.x402.asset ?? raw.asset ?? null,
+      network: raw.x402.network ?? raw.network ?? null,
+      resourceUrl: raw.x402.resource_url ?? raw.resource_url ?? null,
+      merchantAddress: raw.x402.merchant_address ?? raw.merchant_address ?? raw.merchant_to ?? null,
+      description: raw.x402.description ?? raw.description ?? null,
+      idempotencyKey: raw.x402.idempotency_key ?? raw.idempotency_key ?? null
+    } : void 0,
+    mpp: raw.mpp ? {
+      amountAtomic: raw.mpp.amount_atomic ?? raw.amount_atomic ?? null,
+      asset: raw.mpp.asset ?? raw.asset ?? null,
+      network: raw.mpp.network ?? raw.network ?? null,
+      resourceUrl: raw.mpp.resource_url ?? raw.resource_url ?? null,
+      merchantAddress: raw.mpp.merchant_address ?? raw.merchant_address ?? raw.merchant_to ?? null,
+      description: raw.mpp.description ?? raw.description ?? null,
+      idempotencyKey: raw.mpp.idempotency_key ?? raw.idempotency_key ?? null,
+      challengeId: raw.mpp.challenge_id ?? raw.challenge_id ?? null
+    } : void 0
+  };
+}
+function throwPaymentStateError(label, raw) {
+  const statusCode = paymentStateStatusCode(raw.status);
+  const state = paymentStateFromRaw(label, raw);
+  if (state) {
+    throw new HavenPaymentStateError(state.message, statusCode, state, raw);
+  }
+  if (raw.status === "pending_approval") {
+    throw new HavenApiError(
+      `${label} exceeds the agent's on-chain budget and was declined; no approval is pending and none will arrive (payment_id: ${raw.payment_id}).`,
+      statusCode,
+      raw
+    );
+  }
+  if (raw.status === "expired") {
+    throw new HavenApiError(
+      `${label} expired before it could be completed (payment_id: ${raw.payment_id}).`,
+      statusCode,
+      raw
+    );
+  }
+  const paymentId = raw.payment_id ? ` (payment_id: ${raw.payment_id})` : "";
+  const message = raw.error ?? `${label} ${raw.status}${paymentId}`;
+  throw new HavenApiError(message, statusCode, raw);
+}
+
+// src/mcp-merchant-transport.ts
+var DEFAULT_MERCHANT_TIMEOUT = 3e5;
+var MCP_NOTIFICATION_TIMEOUT = 1e4;
+var MCP_PROTOCOL_VERSION = "2025-06-18";
+var MCP_ACCEPT = "application/json, text/event-stream";
+var MCP_CLIENT_INFO = { name: "haven-sdk", version: "1" };
+var McpMerchantTransport = class {
+  merchantTimeout;
+  fetchImpl;
+  requestId = 0;
+  constructor(options = {}) {
+    this.merchantTimeout = options.merchantTimeout ?? DEFAULT_MERCHANT_TIMEOUT;
+    this.fetchImpl = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  }
+  /** Fetch a merchant with a settlement-sized timeout and caller cancellation. */
+  async fetch(url, init = {}, timeoutMs = this.merchantTimeout) {
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const signal = init.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal;
+    try {
+      return await this.fetchImpl(url, { ...init, signal });
+    } catch (err) {
+      if (timeoutSignal.aborted) {
+        throw new MerchantTimeoutError(`Merchant request timed out after ${timeoutMs}ms: ${url}`);
+      }
+      throw err;
+    }
+  }
+  /**
+   * Establish an MCP Streamable-HTTP session. Any handshake failure degrades
+   * to `undefined`, allowing the caller to fall back to plain x402.
+   */
+  async initialize(url, init, wallet) {
+    try {
+      const headers = new Headers(init?.headers);
+      headers.set("Content-Type", "application/json");
+      headers.set("Accept", MCP_ACCEPT);
+      if (wallet && !headers.has("x402-wallet")) headers.set("x402-wallet", wallet);
+      const response = await this.fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: ++this.requestId,
+          method: "initialize",
+          params: {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: MCP_CLIENT_INFO
+          }
+        })
+      });
+      if (!response.ok) return void 0;
+      const sessionId = response.headers.get("mcp-session-id");
+      if (!sessionId) return void 0;
+      const message = await this.readMessage(response);
+      if (message && "error" in message) return void 0;
+      await this.notifyInitialized(url, init, sessionId, wallet);
+      return sessionId;
+    } catch {
+      return void 0;
+    }
+  }
+  /** Add the MCP session and response-content negotiation headers. */
+  withSessionHeaders(init, sessionId) {
+    const headers = new Headers(init?.headers);
+    headers.set("mcp-session-id", sessionId);
+    headers.set("Accept", MCP_ACCEPT);
+    return { ...init, headers };
+  }
+  /** Read one JSON-RPC message from a JSON or SSE response without consuming it. */
+  async readMessage(response) {
+    let text;
+    try {
+      text = await response.clone().text();
+    } catch {
+      return void 0;
+    }
+    if ((response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+      return selectJsonRpcResult(parseSseJsonRpcMessages(text));
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Collapse an MCP SSE response to the JSON-RPC result. Non-SSE and
+   * unparseable responses pass through with their original body untouched.
+   */
+  async surfaceResult(response) {
+    if (!(response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+      return response;
+    }
+    let text;
+    try {
+      text = await response.clone().text();
+    } catch {
+      return response;
+    }
+    const message = selectJsonRpcResult(parseSseJsonRpcMessages(text));
+    if (!message) return response;
+    const body = "result" in message ? message.result : message;
+    const headers = new Headers(response.headers);
+    headers.set("content-type", "application/json");
+    headers.delete("content-length");
+    headers.delete("mcp-session-id");
+    return new Response(JSON.stringify(body), {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  /** Detect MCP transport from the URL or Coinbase Bazaar extension. */
+  async detect(url, paymentRequired, response) {
+    if (isMcpUrl(url)) return { handshakeRequired: true, source: "path" };
+    if (paymentRequired.extensions?.bazaar != null) {
+      return { handshakeRequired: true, source: "bazaar" };
+    }
+    if (await responseHasBazaarExtension(response)) {
+      return { handshakeRequired: true, source: "bazaar" };
+    }
+    return void 0;
+  }
+  /** Identify the conventional Streamable-HTTP MCP path without probing it. */
+  isMcpUrl(url) {
+    return isMcpUrl(url);
+  }
+  /** Detect Bazaar metadata without consuming the merchant response. */
+  hasBazaarExtension(response) {
+    return responseHasBazaarExtension(response);
+  }
+  /**
+   * Deliver an already-signed x402 header without changing the caller body.
+   *
+   * #2289: x402 v2 reads `PAYMENT-SIGNATURE`; v1 reads `X-PAYMENT`. Sending
+   * only the legacy name meant a strict v2 merchant never saw the header —
+   * indistinguishable, from the merchant's side, from sending no header at
+   * all, while on the EIP-3009 bridge the funding leg had already moved the
+   * money.
+   *
+   * #2341: WHICH names go on is per-payload, not always both — see
+   * `x402PaymentHeaderNamesFor`. Both for EIP-3009; `PAYMENT-SIGNATURE` alone
+   * for erc7710, whose header carries a whole delegation chain and answered
+   * HTTP 431 when duplicated. The decision is made here rather than by the
+   * caller so every path inherits it, and it is read from the payload rather
+   * than passed in, because a flag a caller supplies is a flag a caller can
+   * get wrong.
+   *
+   * Always `set`, never `append`, so a stale header on the caller's `init` is
+   * replaced rather than added to — a merchant that reads the first of two
+   * values would otherwise verify a superseded authorization. The name NOT
+   * being sent is deleted for the same reason: on erc7710 a stale `X-PAYMENT`
+   * left in place would be a superseded authorization we chose not to
+   * overwrite, which is worse than the duplicate this change removes.
+   */
+  async deliverPayment(url, init, paymentHeader) {
+    const headers = new Headers(init?.headers);
+    const send = x402PaymentHeaderNamesFor(paymentHeader);
+    for (const name of X402_PAYMENT_HEADER_NAMES) {
+      if (send.includes(name)) headers.set(name, paymentHeader);
+      else headers.delete(name);
+    }
+    return this.fetch(url, { ...init, headers });
+  }
+  async notifyInitialized(url, init, sessionId, wallet) {
+    try {
+      const headers = new Headers(init?.headers);
+      headers.set("Content-Type", "application/json");
+      headers.set("Accept", MCP_ACCEPT);
+      headers.set("mcp-session-id", sessionId);
+      if (wallet && !headers.has("x402-wallet")) headers.set("x402-wallet", wallet);
+      await this.fetch(
+        url,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })
+        },
+        MCP_NOTIFICATION_TIMEOUT
+      );
+    } catch {
+    }
+  }
+};
+async function captureMerchantResponse(response) {
+  const merchant_body = await response.text().catch(() => "");
+  return {
+    merchant_status: response.status,
+    merchant_status_text: response.statusText,
+    merchant_headers: Object.fromEntries(response.headers.entries()),
+    merchant_body
+  };
+}
+function isMcpUrl(url) {
+  try {
+    return new URL(url).pathname.replace(/\/+$/, "").endsWith("/mcp");
+  } catch {
+    return /\/mcp(?:[/?#]|$)/.test(url);
+  }
+}
+async function responseHasBazaarExtension(response) {
+  try {
+    const body = await response.clone().json();
+    return body?.extensions?.bazaar != null;
+  } catch {
+    return false;
+  }
+}
+function parseSseJsonRpcMessages(text) {
+  const messages = [];
+  let dataLines = [];
+  const flush = () => {
+    if (dataLines.length === 0) return;
+    try {
+      messages.push(JSON.parse(dataLines.join("\n")));
+    } catch {
+    }
+    dataLines = [];
+  };
+  for (const line of text.split(/\r?\n/)) {
+    if (line === "") {
+      flush();
+      continue;
+    }
+    if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
+  }
+  flush();
+  return messages;
+}
+function selectJsonRpcResult(messages) {
+  return messages.find((message) => "result" in message || "error" in message) ?? messages.at(-1);
+}
+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/account-reads.ts
+function safeBigInt(value) {
+  try {
+    return BigInt(value);
+  } catch {
+    return 0n;
+  }
+}
+function formatAtomicAmount(atomic, decimals) {
+  if (atomic < 0n) return "0.0";
+  const value = atomic.toString().padStart(decimals + 1, "0");
+  const whole = value.slice(0, value.length - decimals) || "0";
+  const fraction = value.slice(value.length - decimals).replace(/0+$/, "") || "0";
+  return `${whole}.${fraction}`;
+}
+function deriveReadiness(status, allowances) {
+  if (status !== "active") return "revoked";
+  return allowances.some((allowance) => safeBigInt(allowance.remainingAtomic) > 0n) ? "ready" : "needs_approval";
+}
+var AccountReads = class {
+  transport;
+  getPaymentStatus;
+  agentInFlight = null;
+  constructor(options) {
+    this.transport = options.transport;
+    this.getPaymentStatus = options.getPaymentStatus;
+  }
+  async getAgent() {
+    if (this.agentInFlight) return this.agentInFlight;
+    const request = this.fetchAgent();
+    this.agentInFlight = request;
+    request.finally(() => {
+      this.agentInFlight = null;
+    }).catch(() => {
+    });
+    return request;
+  }
+  async getAgentSummary() {
+    const [agent, allowanceSummary] = await Promise.all([this.getAgent(), this.getAllowances()]);
+    const allowances = allowanceSummary.allowances.map((allowance) => {
+      const token = resolveTokenFromAddress(allowance.tokenAddress);
+      const remainingDisplay = token ? `${formatAtomicAmount(safeBigInt(allowance.onchain.remaining), token.decimals)} ${allowance.tokenSymbol}` : `${allowance.onchain.remaining} ${allowance.tokenSymbol} (atomic; unknown decimals)`;
+      return {
+        tokenSymbol: allowance.tokenSymbol,
+        remainingAtomic: allowance.onchain.remaining,
+        remainingDisplay,
+        configuredAmount: allowance.configuredAmount,
+        resetPeriodMin: allowance.resetPeriodMin,
+        isResetPending: allowance.onchain.isResetPending
+      };
+    });
+    const readiness = deriveReadiness(agent.status, allowances);
+    return { ...agent, readiness, spend_authority_readiness: readiness, allowances };
+  }
+  async getAllowances() {
+    const raw = await this.transport.get("/machine-payments/allowances");
+    return {
+      agentId: raw.agent_id,
+      safeAddress: raw.safe_address,
+      delegateAddress: raw.delegate_address,
+      chainId: raw.chain_id,
+      allowances: raw.allowances.map((allowance) => ({
+        id: allowance.id,
+        tokenAddress: allowance.token_address,
+        tokenSymbol: allowance.token_symbol,
+        configuredAmount: allowance.configured_amount,
+        resetPeriodMin: allowance.reset_period_min,
+        onchain: {
+          amount: allowance.onchain.amount,
+          spent: allowance.onchain.spent,
+          remaining: allowance.onchain.remaining,
+          effectiveSpent: allowance.onchain.effective_spent,
+          resetTimeMin: allowance.onchain.reset_time_min,
+          lastResetMin: allowance.onchain.last_reset_min,
+          nonce: allowance.onchain.nonce,
+          isResetPending: allowance.onchain.is_reset_pending,
+          remainingIsFromChain: allowance.onchain.remaining_is_from_chain
+        }
+      }))
+    };
+  }
+  async getPostPurchaseAllowanceSummary(paymentId) {
+    const unavailable = (detail, payment2 = null) => ({
+      payment: payment2,
+      allowance: null,
+      warnings: [{
+        code: AgentPaymentWarningCode.AllowanceCheckUnavailable,
+        message: `Could not read the post-purchase allowance/budget for payment ${paymentId} (${detail}). The payment itself succeeded \u2014 the on-chain policy remains the actual spend gate; this only affects the remaining-budget figure reported here.`
+      }]
+    });
+    const [statusResult, agentResult, allowanceResult] = await Promise.allSettled([
+      this.getPaymentStatus(paymentId),
+      this.getAgent(),
+      this.getAllowances()
+    ]);
+    if (statusResult.status === "rejected") {
+      return unavailable(statusResult.reason instanceof Error ? statusResult.reason.message : String(statusResult.reason));
+    }
+    const payment = statusResult.value;
+    if (agentResult.status === "rejected") {
+      return unavailable(agentResult.reason instanceof Error ? agentResult.reason.message : String(agentResult.reason), payment);
+    }
+    if (allowanceResult.status === "rejected") {
+      return unavailable(allowanceResult.reason instanceof Error ? allowanceResult.reason.message : String(allowanceResult.reason), payment);
+    }
+    try {
+      const tokenAddress = payment.asset ?? payment.x402?.asset ?? null;
+      if (!tokenAddress) return unavailable("the settled payment does not carry a resolvable token address", payment);
+      const match = allowanceResult.value.allowances.find(
+        (allowance) => allowance.tokenAddress.toLowerCase() === tokenAddress.toLowerCase()
+      );
+      if (!match) return unavailable("no allowance/budget row matches the settled token", payment);
+      const token = resolveTokenFromAddress(match.tokenAddress);
+      const remainingDisplay = token ? `${formatAtomicAmount(safeBigInt(match.onchain.remaining), token.decimals)} ${match.tokenSymbol}` : void 0;
+      const rail = agentResult.value.executionRail;
+      return {
+        payment,
+        allowance: {
+          rail,
+          remaining_atomic: match.onchain.remaining,
+          ...remainingDisplay ? { remaining_display: remainingDisplay } : {},
+          token_symbol: match.tokenSymbol,
+          token_address: match.tokenAddress,
+          reset_period: match.resetPeriodMin,
+          source: rail === "delegation" ? "active_delegations" : "allowance_module"
+        },
+        warnings: []
+      };
+    } catch (error) {
+      return unavailable(error instanceof Error ? error.message : String(error));
+    }
+  }
+  async listReceipts(options = {}) {
+    const query = options.limit ? `?limit=${encodeURIComponent(String(options.limit))}` : "";
+    const raw = await this.transport.get(`/machine-payments/receipts${query}`);
+    return raw.receipts.map(mapPaymentReceipt);
+  }
+  async getReceipt(paymentId) {
+    const { receipt } = await this.transport.get(`/payments/${paymentId}/receipt`);
+    return { receipt, verification: verifyPaymentReceipt(receipt) };
+  }
+  async fetchAgent() {
+    const raw = await this.transport.get("/machine-payments/agent");
+    return {
+      id: raw.id,
+      name: raw.name,
+      status: raw.status,
+      safeAddress: raw.safe_address,
+      delegateAddress: raw.delegate_address,
+      chainId: raw.chain_id,
+      executionRail: raw.execution_rail === "delegation" ? "delegation" : "legacy"
+    };
+  }
+};
+function createJsonRpcProvider(url) {
+  return new ethers.JsonRpcProvider(url);
+}
+function createWallet(privateKey, provider) {
+  return new ethers.Wallet(privateKey, provider);
+}
+function createErc20Contract(address, abi, runner) {
+  return new ethers.Contract(address, abi, runner);
+}
+
+// src/delegate-sweep.ts
+function isWaitTimeout(err) {
+  return err?.code === "TIMEOUT";
+}
+async function waitForSweepTx(tx) {
+  let receipt;
+  try {
+    receipt = await tx.wait(1, DEFAULT_CONFIRMATION_TIMEOUT_MS);
+  } catch (err) {
+    if (!isWaitTimeout(err)) throw err;
+    return { txHash: tx.hash, confirmation: "unconfirmed" };
+  }
+  if (!receipt) return { txHash: tx.hash, confirmation: "unconfirmed" };
+  return { txHash: receipt.hash, confirmation: "confirmed" };
+}
+var DelegateSweepApi = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async sweepDelegate() {
+    if (!this.options.delegateKey) throw new HavenSigningError("delegateKey is required for sweepDelegate.");
+    const agent = await this.options.getAgent();
+    if (!agent.delegateAddress) throw new HavenApiError("Agent has no delegate address.", 422);
+    const rpcUrl = this.options.chainRpcs[agent.chainId];
+    if (!rpcUrl) throw new HavenApiError(`chainRpcs[${agent.chainId}] must be configured to sweep the delegate wallet.`, 422);
+    const provider = createJsonRpcProvider(rpcUrl);
+    const wallet = createWallet(this.options.delegateKey, provider);
+    const transfers = [];
+    if (isSweepableChain(agent.chainId)) {
+      const contract = createErc20Contract(sweepUsdcAddress(agent.chainId), ["function balanceOf(address) view returns (uint256)", "function transfer(address to, uint256 amount) returns (bool)"], wallet);
+      const balance2 = await contract.balanceOf(agent.delegateAddress);
+      if (balance2 > 0n) {
+        const tx = await contract.transfer(agent.safeAddress, balance2);
+        const { txHash, confirmation } = await waitForSweepTx(tx);
+        transfers.push({ asset: "USDC", amount: format(balance2, 6), amountAtomic: balance2.toString(), txHash, explorerUrl: this.options.buildExplorerUrl(agent.chainId, txHash), confirmation });
+      }
+    }
+    const balance = await provider.getBalance(agent.delegateAddress);
+    if (balance > 0n) {
+      const fee = await provider.getFeeData();
+      const send = balance - (fee.maxFeePerGas ?? fee.gasPrice ?? 1000000n) * 21000n * 2n;
+      if (send > 0n) {
+        const tx = await wallet.sendTransaction({ to: agent.safeAddress, value: send });
+        const { txHash, confirmation } = await waitForSweepTx(tx);
+        transfers.push({ asset: "ETH", amount: format(send, 18), amountAtomic: send.toString(), txHash, explorerUrl: this.options.buildExplorerUrl(agent.chainId, txHash), confirmation });
+      }
+    }
+    return { fromAddress: agent.delegateAddress, toAddress: agent.safeAddress, chainId: agent.chainId, transfers, unconfirmed: transfers.some((t) => t.confirmation === "unconfirmed") };
+  }
+  prepareSweep() {
+    return this.options.transport.post("/machine-payments/sweep/prepare", {});
+  }
+  submitSweep(authorization, signature) {
+    return this.options.transport.post("/machine-payments/sweep/submit", { authorization, signature });
+  }
+};
+function format(value, decimals) {
+  const raw = value.toString().padStart(decimals + 1, "0");
+  return `${raw.slice(0, -decimals) || "0"}.${raw.slice(-decimals).replace(/0+$/, "") || "0"}`;
+}
+
+// src/x402-protocol.ts
+var CHAIN_EXPLORER_TX = {
+  100: "https://gnosisscan.io/tx",
+  8453: "https://basescan.org/tx"
+};
+function buildExplorerUrl(chainId, txHash) {
+  const base = CHAIN_EXPLORER_TX[chainId ?? 8453] ?? CHAIN_EXPLORER_TX[8453];
+  return `${base}/${txHash}`;
+}
+function explorerUrlOrEmpty(chainId, txHash) {
+  return txHash ? buildExplorerUrl(chainId, txHash) : "";
+}
+function chainIdFromNetwork(network) {
+  if (network === "base") return 8453;
+  if (network === "base-sepolia") return 84532;
+  if (!network?.startsWith("eip155:")) return void 0;
+  const chainId = Number(network.slice("eip155:".length));
+  return Number.isFinite(chainId) ? chainId : void 0;
+}
+function chainIdOrNull(network) {
+  return chainIdFromNetwork(network) ?? null;
+}
+function sameAddress3(a, b) {
+  return Boolean(a && b && a.toLowerCase() === b.toLowerCase());
+}
+function decimalFromUsdcAtomic(value) {
+  const amount = BigInt(value);
+  const whole = amount / 1000000n;
+  const fraction = (amount % 1000000n).toString().padStart(6, "0").replace(/0+$/, "");
+  return fraction ? `${whole}.${fraction}` : whole.toString();
+}
+function normalizeDecimal(value) {
+  if (!value.includes(".")) return value.replace(/^0+(?=\d)/, "") || "0";
+  const [whole, fraction = ""] = value.split(".");
+  const normalizedWhole = whole.replace(/^0+(?=\d)/, "") || "0";
+  const normalizedFraction = fraction.replace(/0+$/, "");
+  return normalizedFraction ? `${normalizedWhole}.${normalizedFraction}` : normalizedWhole;
+}
+function x402PayerAddress(delegateAddress, x402Wallet) {
+  return delegateAddress ?? x402Wallet;
+}
+function withX402Wallet(init, wallet) {
+  if (!wallet) return init;
+  const headers = new Headers(init?.headers);
+  if (!headers.has("x402-wallet")) {
+    headers.set("x402-wallet", wallet);
+  }
+  return {
+    ...init,
+    headers
+  };
+}
+function snapshotRequestBody(body) {
+  if (body == null) return void 0;
+  if (typeof body === "string") return body;
+  if (body instanceof URLSearchParams) return body.toString();
+  throw new HavenApiError(
+    "Quote helpers can only capture resumable request bodies that are strings or URLSearchParams. For streams, blobs, or binary bodies, preserve the original request yourself and call the matching resume method with fresh init.",
+    400
+  );
+}
+function snapshotX402Request(url, init) {
+  return {
+    url,
+    method: init?.method ?? "GET",
+    headers: Array.from(new Headers(init?.headers).entries()),
+    body: snapshotRequestBody(init?.body)
+  };
+}
+function requestInitFromSnapshot(request) {
+  return {
+    method: request.method,
+    headers: request.headers,
+    body: request.body
+  };
+}
+function noCompatiblePaymentOptionError(accepts) {
+  const erc7710Only = selectErc7710PaymentOption(accepts) !== null;
+  return new HavenApiError(
+    "No compatible payment option found in x402 requirements. Haven supports standard x402 exact payments on Base USDC." + (erc7710Only ? " The only Haven-compatible option this merchant advertises is tagged extra.assetTransferMethod: 'erc7710' (direct settlement), which this EIP-3009 payment path cannot settle \u2014 the limitation is the settlement scheme, not the asset. Paying this merchant requires a delegation-rail erc7710 flow (settleX402Erc7710, or the hosted MCP purchase tools)." : ""),
+    400
+  );
+}
+function buildX402Quote(paymentRequired, request, idempotencyKey, mcpTransport) {
+  const standard = selectStandardPaymentOption(paymentRequired.accepts);
+  const option = standard ?? selectErc7710PaymentOption(paymentRequired.accepts);
+  if (!option) {
+    throw noCompatiblePaymentOptionError(paymentRequired.accepts);
+  }
+  const token = resolveTokenFromAddress(option.asset, option.network);
+  return {
+    rail: "x402",
+    idempotencyKey: idempotencyKey ?? buildX402IdempotencyKey(paymentRequired, option),
+    paymentRequired,
+    accepted: option,
+    acceptedScheme: standard ? "standard" : "erc7710",
+    request,
+    ...mcpTransport ? { mcpTransport } : {},
+    resourceUrl: paymentRequired.resource.url,
+    description: paymentRequired.resource.description ?? option.description ?? null,
+    mimeType: paymentRequired.resource.mimeType ?? option.mimeType ?? null,
+    amountAtomic: x402AuthorizationAmount(option),
+    amount: decimalFromUsdcAtomic(x402AuthorizationAmount(option)),
+    token: token?.symbol ?? "USDC",
+    // #1351: null when the asset is unrecognised on this network — the
+    // `token` fallback above is a LABEL, not evidence of 6 decimals, and a
+    // human-denominated cap must fail closed rather than convert against a
+    // guess. Same resolution as `token`, so the two never disagree.
+    decimals: token?.decimals ?? null,
+    asset: option.asset,
+    network: option.network,
+    chainId: chainIdOrNull(option.network),
+    merchantAddress: option.payTo,
+    maxTimeoutSeconds: option.maxTimeoutSeconds
+  };
+}
+function buildX402Receipt(input) {
+  const fundingExplorerUrl = input.explorerUrl || explorerUrlOrEmpty(input.chainId, input.txHash);
+  return {
+    success: true,
+    paymentId: input.paymentId,
+    txHash: input.txHash,
+    token: input.token,
+    amount: input.amount,
+    to: input.to,
+    resourceUrl: input.resourceUrl,
+    explorerUrl: input.explorerUrl,
+    accepted: input.accepted,
+    paymentHeader: input.paymentHeader,
+    merchantTo: input.merchantTo ?? input.accepted.payTo,
+    payer: input.payer,
+    chainId: input.chainId,
+    haven: {
+      paymentId: input.paymentId,
+      fundingTxHash: input.txHash,
+      fundingExplorerUrl
+    },
+    merchant: {
+      payTo: input.merchantTo ?? input.accepted.payTo
+    },
+    x402: {
+      amount: x402AuthorizationAmount(input.accepted),
+      token: input.token,
+      network: input.accepted.network,
+      asset: input.accepted.asset,
+      resource: input.accepted.resource ?? input.resourceUrl
+    }
+  };
+}
+function buildX402ResumeState(input) {
+  const token = resolveTokenFromAddress(input.accepted.asset, input.accepted.network);
+  return {
+    rail: "x402",
+    paymentId: input.paymentId,
+    idempotencyKey: input.idempotencyKey,
+    paymentRequired: input.paymentRequired,
+    accepted: input.accepted,
+    url: input.request?.url ?? input.paymentRequired.resource.url,
+    request: input.request,
+    resourceUrl: input.paymentRequired.resource.url,
+    description: input.paymentRequired.resource.description ?? input.accepted.description ?? null,
+    amountAtomic: x402AuthorizationAmount(input.accepted),
+    amount: decimalFromUsdcAtomic(x402AuthorizationAmount(input.accepted)),
+    token: token?.symbol ?? "USDC",
+    asset: input.accepted.asset,
+    network: input.accepted.network,
+    chainId: chainIdOrNull(input.accepted.network),
+    merchantAddress: input.accepted.payTo
+  };
+}
+function attachX402ResumeState(err, paymentRequired, accepted, idempotencyKey, request) {
+  if (!(err instanceof HavenPaymentStateError)) return;
+  if (err.state.rail !== "x402") return;
+  err.resumeState = buildX402ResumeState({
+    paymentId: err.state.paymentId,
+    paymentRequired,
+    accepted,
+    idempotencyKey,
+    request
+  });
+}
+function attachResumeState(err, input) {
+  attachX402ResumeState(
+    err,
+    input.paymentRequired,
+    input.accepted,
+    input.idempotencyKey,
+    input.request
+  );
+}
+function assertCanResumeX402(status, paymentRequired, option) {
+  if (status.rail !== "x402") {
+    throw new HavenPaymentStateError(
+      `Payment ${status.paymentId} is ${status.rail}, not x402.`,
+      409,
+      status
+    );
+  }
+  if (status.nextAction !== AgentPaymentNextAction.RetryOriginalX402Request) {
+    throw new HavenPaymentStateError(status.message, paymentStateStatusCode(status.status, 409), status);
+  }
+  if (!status.txHash) {
+    throw new HavenApiError(
+      `x402 payment ${status.paymentId} is ready to retry but has no Haven transaction hash.`,
+      502,
+      status,
+      status.paymentId
+    );
+  }
+  if (status.resourceUrl && status.resourceUrl !== paymentRequired.resource.url) {
+    throw new HavenApiError(
+      "x402 resume request does not match the approved resource URL.",
+      409,
+      { status, paymentRequired },
+      status.paymentId
+    );
+  }
+  if (status.merchantAddress && !sameAddress3(status.merchantAddress, option.payTo)) {
+    throw new HavenApiError(
+      "x402 resume request does not match the approved merchant.",
+      409,
+      { status, selectedPayment: option },
+      status.paymentId
+    );
+  }
+  const optionChainId = chainIdFromNetwork(option.network);
+  if (status.chainId && optionChainId && status.chainId !== optionChainId) {
+    throw new HavenApiError(
+      "x402 resume request does not match the approved network.",
+      409,
+      { status, selectedPayment: option },
+      status.paymentId
+    );
+  }
+  if (status.token && status.token !== "USDC") {
+    throw new HavenApiError(
+      "x402 resume request does not match the approved token.",
+      409,
+      { status, selectedPayment: option },
+      status.paymentId
+    );
+  }
+  const approvedAmount = status.amount ? normalizeDecimal(status.amount) : "";
+  const requestedAmount = normalizeDecimal(decimalFromUsdcAtomic(x402AuthorizationAmount(option)));
+  if (approvedAmount && approvedAmount !== requestedAmount) {
+    throw new HavenApiError(
+      "x402 resume request does not match the approved amount.",
+      409,
+      { status, selectedPayment: option },
+      status.paymentId
+    );
+  }
+}
+var X402FundingLeg = class {
+  delegateKey;
+  delegateAddress;
+  x402Wallet;
+  chainRpcs;
+  post;
+  signForData;
+  assertSignableAuthorizationState;
+  /**
+   * Receipts keyed by idempotency key, held only as long as the underlying
+   * EIP-3009 authorization is valid. The cache belongs to this module rather
+   * than to the facade because its expiry is read out of the authorization
+   * header itself — a 3009 artifact.
+   */
+  receiptCache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.delegateKey = options.delegateKey;
+    this.delegateAddress = options.delegateAddress;
+    this.x402Wallet = options.x402Wallet;
+    this.chainRpcs = options.chainRpcs;
+    this.post = options.post;
+    this.signForData = options.signForData;
+    this.assertSignableAuthorizationState = options.assertSignableAuthorizationState;
+  }
+  // ── Receipt cache ────────────────────────────────────────────────
+  /** A still-valid cached receipt for this key, or undefined. */
+  cachedReceipt(idempotencyKey) {
+    const cached = this.receiptCache.get(idempotencyKey);
+    if (cached && cached.expiresAt > Date.now()) return cached.receipt;
+    return void 0;
+  }
+  cacheReceipt(idempotencyKey, paymentHeader, receipt) {
+    const expiresAt = getPaymentHeaderValidBefore(paymentHeader);
+    if (expiresAt > Date.now()) {
+      this.receiptCache.set(idempotencyKey, { expiresAt, receipt });
+    }
+  }
+  // ── Authorization ────────────────────────────────────────────────
+  async authorize(paymentRequired, option, idempotencyKey) {
+    const raw = await this.post("/x402", {
+      url: paymentRequired.resource.url,
+      payTo: this.delegateAddress,
+      merchantPayTo: option.payTo,
+      amount: x402AuthorizationAmount(option),
+      asset: option.asset,
+      network: option.network,
+      description: paymentRequired.resource.description,
+      idempotencyKey,
+      // #1360: same explicit funding-leg declaration as createX402Intent —
+      // this local-key path derives payTo from the key (never stale), but the
+      // declaration keeps both writers of the 3009 shape loud-by-default.
+      settlementScheme: "eip3009"
+    });
+    const state = paymentStateFromRaw("x402 payment", raw);
+    const executedReplay = raw.success && raw.tx_hash ? "idempotency-collision" : state?.nextAction === AgentPaymentNextAction.RetryOriginalX402Request ? "approval-resume" : null;
+    if (executedReplay) {
+      const canFund = await this.delegateCanFund(
+        raw.chain_id ?? state?.chainId ?? chainIdFromNetwork(option.network),
+        option.asset,
+        x402AuthorizationAmount(option)
+      );
+      const refuse = executedReplay === "idempotency-collision" ? canFund !== true : canFund === false;
+      if (refuse) {
+        const settledReceipt = state && executedReplay === "approval-resume" ? this.receiptFromStatus(paymentRequired, option, void 0, state) : this.receiptFromAuthorization(paymentRequired, option, void 0, raw);
+        throw new X402AlreadySettledError(
+          canFund === false ? "This x402 payment already settled \u2014 the delegate no longer holds the funds to authorize it again. To buy the same item a second time, pass a distinct `idempotencyKey`; the synthesised key intentionally collapses repeat calls for the same product within a 5-minute window so a retried request cannot pay twice." : "This x402 payment already settled, and whether the delegate can still fund a new authorization could not be verified (no `chainRpcs` entry for this chain). Refusing rather than issue an authorization that may be unfundable. To buy the same item a second time, pass a distinct `idempotencyKey`; to finish an interrupted payment, resume it by `paymentId`.",
+          settledReceipt,
+          canFund === false ? "settled" : "unverifiable"
+        );
+      }
+    }
+    const paymentHeader = await this.createPaymentHeader(paymentRequired, option);
+    if (raw.success && raw.tx_hash) {
+      const receipt2 = this.receiptFromAuthorization(paymentRequired, option, paymentHeader, raw);
+      this.cacheReceipt(idempotencyKey, paymentHeader, receipt2);
+      return receipt2;
+    }
+    if (state?.nextAction === AgentPaymentNextAction.RetryOriginalX402Request) {
+      const receipt2 = this.receiptFromStatus(paymentRequired, option, paymentHeader, state);
+      this.cacheReceipt(idempotencyKey, paymentHeader, receipt2);
+      return receipt2;
+    }
+    this.assertSignableAuthorizationState("x402 payment", raw);
+    if (!raw.sign_data?.hash) {
+      throw new HavenApiError("No sign_hash returned from x402/authorize", 500, raw);
+    }
+    const sig = await this.signForData(raw.sign_data);
+    const execResult = await this.post(
+      `/payments/${raw.payment_id}/sign`,
+      { signature: sig }
+    );
+    if (execResult.status !== "confirmed") {
+      throwPaymentStateError("x402 payment", execResult);
+    }
+    await this.waitForFundingTx(
+      execResult.tx_hash,
+      execResult.chain_id ?? chainIdFromNetwork(option.network)
+    );
+    const receipt = this.receiptFromAuthorization(paymentRequired, option, paymentHeader, raw, execResult);
+    this.cacheReceipt(idempotencyKey, paymentHeader, receipt);
+    return receipt;
+  }
+  // ── Header minting ───────────────────────────────────────────────
+  async createPaymentHeader(paymentRequired, option) {
+    if (!this.delegateKey) {
+      throw new HavenSigningError("delegateKey is required to sign x402 payment headers.");
+    }
+    const account = privateKeyToAccount(this.delegateKey);
+    const requirements = toStandardPaymentRequirements(paymentRequired, option);
+    const header = await exact.evm.createPaymentHeader(
+      account,
+      paymentRequired.x402Version,
+      requirements
+    );
+    if (paymentRequired.x402Version < 2) return header;
+    const payment = decodeBase64Json(header);
+    return encodeBase64Json(x402V2PaymentEnvelope(paymentRequired, option, payment.payload));
+  }
+  // ── Receipt mapping ──────────────────────────────────────────────
+  receiptFromAuthorization(paymentRequired, option, paymentHeader, raw, execResult) {
+    const txHash = execResult?.tx_hash ?? raw.tx_hash ?? "";
+    const chainId = execResult?.chain_id ?? raw.chain_id ?? chainIdFromNetwork(option.network);
+    const token = execResult?.token ?? raw.token ?? "USDC";
+    const amount = execResult?.amount ?? raw.amount ?? decimalFromUsdcAtomic(x402AuthorizationAmount(option));
+    const to = execResult?.to ?? raw.to ?? this.delegateAddress ?? "";
+    const explorerUrl = execResult?.explorer_url ?? raw.explorer_url ?? explorerUrlOrEmpty(chainId, txHash);
+    const merchantTo = execResult?.merchant_to ?? raw.merchant_to ?? option.payTo;
+    const payer = raw.payer ?? raw.safe_address ?? raw.sign_data?.components.safe;
+    return buildX402Receipt({
+      paymentId: raw.payment_id,
+      txHash,
+      token,
+      amount,
+      to,
+      resourceUrl: paymentRequired.resource.url,
+      explorerUrl,
+      accepted: option,
+      paymentHeader,
+      merchantTo,
+      payer,
+      chainId
+    });
+  }
+  receiptFromStatus(paymentRequired, option, paymentHeader, status) {
+    if (!status.txHash) {
+      throw new HavenApiError(
+        `x402 payment ${status.paymentId} is ready to retry but has no Haven transaction hash.`,
+        502,
+        status,
+        status.paymentId
+      );
+    }
+    return buildX402Receipt({
+      paymentId: status.paymentId,
+      txHash: status.txHash,
+      token: status.token || "USDC",
+      amount: status.amount || decimalFromUsdcAtomic(x402AuthorizationAmount(option)),
+      to: this.delegateAddress ?? "",
+      resourceUrl: paymentRequired.resource.url,
+      explorerUrl: explorerUrlOrEmpty(status.chainId, status.txHash),
+      accepted: option,
+      paymentHeader,
+      merchantTo: status.merchantAddress ?? option.payTo,
+      payer: this.x402Wallet,
+      chainId: status.chainId || chainIdFromNetwork(option.network)
+    });
+  }
+  // ── On-chain reads ───────────────────────────────────────────────
+  /**
+   * Wait for a funding tx to be mined with ≥1 confirmation before the
+   * merchant retry, eliminating the race where the merchant's
+   * `balanceOf(delegate)` runs before the funding block propagates.
+   *
+   * Skipped when `chainRpcs` does not include the chain; in that case Haven's
+   * backend has already confirmed on-chain submission and callers accept the
+   * small propagation window as a trade-off for not configuring an RPC URL.
+   */
+  async waitForFundingTx(txHash, chainId, timeoutMs = 3e4) {
+    if (!txHash || !chainId) return;
+    const rpcUrl = this.chainRpcs[chainId];
+    if (!rpcUrl) return;
+    const provider = createJsonRpcProvider(rpcUrl);
+    const onChainReceipt = await provider.waitForTransaction(txHash, 1, timeoutMs);
+    if (!onChainReceipt || onChainReceipt.status !== 1) {
+      throw new HavenApiError(
+        "Funding tx did not confirm on-chain within the timeout window.",
+        500,
+        { txHash, chainId }
+      );
+    }
+  }
+  /**
+   * Can the delegate EOA still fund an authorization for `amountAtomic`?
+   *
+   * #1521: the only question that separates a legitimate resume (funding
+   * confirmed, merchant never paid — the delegate still holds the money) from
+   * a replayed settled payment (funding confirmed, merchant paid, delegate
+   * spent). The intent's own `status: 'confirmed'` is identical in both.
+   *
+   * The balance is asked of the CHAIN rather than of Haven's bookkeeping on
+   * purpose: the merchant-settlement evidence record is written by this SDK
+   * *after* the merchant call, so a client that dies between the two leaves
+   * the backend believing the merchant was never paid — the exact case the
+   * discriminator has to get right. The chain cannot be behind in that way.
+   *
+   * Returns `null` — never a guess — when `chainRpcs` has no entry for the
+   * chain or the read fails. Callers must treat that as "unverifiable", not
+   * as "funded".
+   */
+  async delegateCanFund(chainId, tokenAddress, amountAtomic, timeoutMs = 1e4) {
+    if (!chainId || !this.delegateAddress) return null;
+    const rpcUrl = this.chainRpcs[chainId];
+    if (!rpcUrl) return null;
+    try {
+      const provider = createJsonRpcProvider(rpcUrl);
+      const token = createErc20Contract(
+        tokenAddress,
+        ["function balanceOf(address) view returns (uint256)"],
+        provider
+      );
+      const balance = await Promise.race([
+        token.balanceOf(this.delegateAddress),
+        new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs).unref?.())
+      ]);
+      if (balance === null) return null;
+      return balance >= BigInt(amountAtomic);
+    } catch {
+      return null;
+    }
+  }
+};
+function getPaymentHeaderValidBefore(paymentHeader) {
+  try {
+    const payment = decodeBase64Json(
+      paymentHeader
+    );
+    const payload = payment.payload;
+    const validBeforeSeconds = Number(payload.authorization?.validBefore);
+    if (Number.isFinite(validBeforeSeconds)) return validBeforeSeconds * 1e3;
+  } catch {
+  }
+  return 0;
+}
+
+// src/x402-erc7710.ts
+var X402Erc7710 = class {
+  delegateKey;
+  post;
+  signForData;
+  getAgent;
+  constructor(options) {
+    this.delegateKey = options.delegateKey;
+    this.post = options.post;
+    this.signForData = options.signForData;
+    this.getAgent = options.getAgent;
+  }
+  /**
+   * Pay a merchant through **erc7710 direct settlement** (#1454, epic #1450).
+   *
+   * The whole point of this path is what it does NOT do. There is no funding
+   * leg: the merchant redeems a delegation chain and pulls from the treasury
+   * directly, so the delegate EOA never holds the money, no sweep can strand
+   * it, and the #713 reconciliation class does not apply. It is also why this
+   * method is SMALLER than the 3009 path — the backend assembles the merchant
+   * `X-PAYMENT` header in `assembleSettlementPayload`, so the SDK builds no
+   * header locally.
+   *
+   *     authorize (payTo = the MERCHANT) → sign the child → settle → header
+   *
+   * The caller then retries the merchant with that header. **Nothing has
+   * settled when this returns** — that is why it does not return an
+   * `X402Receipt`.
+   *
+   * Requires a delegation-rail account. The backend enforces that at the
+   * rail seam — a non-delegation account gets the #1986 retired-rail 410 from
+   * `POST /x402/authorize` whatever scheme it asks for (#2245) — and so does
+   * this method, before building a request the backend would only reject: an
+   * error a client can explain is worth more than a refusal it has to decode.
+   *
+   * **MCP callers must pass `options.resourceUrl`.** An in-band MCP 402
+   * challenge frequently carries no `resource` object at all, so
+   * `paymentRequired.resource?.url` is undefined and the backend answers
+   * "Valid url is required". The QA scenario this path was ported from falls
+   * back to the request URL for exactly that reason — the SDK cannot, because
+   * it never saw the request. Pass it.
+   */
+  async settle(paymentRequired, options = {}) {
+    if (!this.delegateKey) {
+      throw new HavenSigningError(
+        "delegateKey is required for x402 payments. Pass it in the HavenClient config."
+      );
+    }
+    const prepared = await this.prepare(paymentRequired, options);
+    const signature = await this.signForData(prepared.signData);
+    const paymentHeader = await this.submit(prepared.paymentId, signature);
+    return { ...prepared.settlement, paymentHeader };
+  }
+  /**
+   * The AUTHORIZE half of erc7710 settlement (#1456): select the scheme, build
+   * the request, and return the child to be signed — without signing it.
+   *
+   * Split out because the hosted topology cannot use `settleX402Erc7710()`:
+   * that method signs in-process with `delegateKey`, and hosted Haven does not
+   * have one and must not. The hosted MCP server drives these two halves with
+   * the LOCAL signer in between, so the key stays where it belongs and the
+   * request shaping stays in one place rather than being reimplemented.
+   */
+  async prepare(paymentRequired, options = {}) {
+    const delegationRail = options.delegationRail ?? (await this.getAgent()).executionRail === "delegation";
+    if (!delegationRail) {
+      throw new HavenApiError(
+        "erc7710 settlement requires a delegation-rail account; this one is not on it. Use authorizeX402() for the standard EIP-3009 path.",
+        400
+      );
+    }
+    const selection = selectX402SettlementScheme(paymentRequired.accepts, { delegationRail });
+    if (!selection || selection.scheme !== "erc7710") {
+      throw new HavenApiError(
+        "This merchant does not advertise an erc7710 settlement option (no accepts[] entry carries extra.assetTransferMethod: 'erc7710'). Use authorizeX402() for the standard EIP-3009 path.",
+        400
+      );
+    }
+    const option = selection.option;
+    const merchantPayTo = option.payTo;
+    const amountAtomic = x402AuthorizationAmount(option);
+    const raw = await this.post("/x402", {
+      url: options.resourceUrl ?? paymentRequired.resource?.url,
+      // #2373: the full 402 challenge, persisted verbatim by the backend
+      // (#1355) so the settle handoff can echo its resource/extensions into
+      // the X-PAYMENT envelope (#2361). This scheme decomposes the challenge
+      // into the fields below for AUTHORITY; the stored copy exists for the
+      // echo, which cannot be reconstructed from the decomposition — omitting
+      // it is how every erc7710 payment failed a merchant that enforces the
+      // spec's extensions-echo MUST. Same ≤64KB guard and omission behaviour
+      // as the 3009 path (client.ts): an oversized challenge omits the field
+      // rather than failing the payment, and the settle echo then omits too.
+      ...new TextEncoder().encode(JSON.stringify(paymentRequired)).length <= 65536 ? { paymentRequired } : {},
+      // payTo = the MERCHANT is what selects direct settlement server-side.
+      // The explicit settlementScheme must AGREE with that shape (#1360) —
+      // disagreement is a 400 by design, so that a stale delegate address
+      // becomes a loud mismatch instead of a silent reroute to the 3009 leg.
+      payTo: merchantPayTo,
+      settlementScheme: "erc7710",
+      // #2041: sent only when the caller supplied one, so an omitting caller's
+      // request body is byte-identical to the pre-#2041 shape.
+      ...options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
+      amount: amountAtomic,
+      asset: option.asset,
+      network: option.network,
+      // The v2 header echoes the accepted entry field-for-field, so the quoted
+      // timeout must round-trip or the merchant rejects the echo (#1064).
+      maxTimeoutSeconds: option.maxTimeoutSeconds,
+      // #1058: forward the advertised facilitators verbatim — the child becomes
+      // redeemable ONLY by them. `null` here means the merchant advertised none
+      // (or an empty array, which the backend 400s on), so the field is OMITTED
+      // rather than sent empty. See x402FacilitatorAddresses.
+      ...selection.facilitatorAddresses ? { facilitatorAddresses: selection.facilitatorAddresses } : {},
+      // #1307/#1547: persisted so the settle leg can rehydrate the merchant
+      // call by payment_id on this scheme too, not only on the 3009 bridge.
+      ...options.mcpCallContext ? { mcpCallContext: options.mcpCallContext } : {}
+    });
+    if (!raw.payment_id) {
+      throw new HavenApiError("No payment_id returned from x402/authorize", 500, raw);
+    }
+    const signData = raw.sign_data;
+    if (signData?.signature_scheme !== "eip712_delegation" || !signData.typed_data) {
+      throw new HavenApiError(
+        `x402/authorize did not return an erc7710 settlement child (signature_scheme was ${JSON.stringify(signData?.signature_scheme)}). Refusing to sign a payload this path did not ask for.`,
+        500,
+        raw
+      );
+    }
+    return {
+      paymentId: raw.payment_id,
+      signData,
+      settlement: {
+        paymentId: raw.payment_id,
+        merchantPayTo,
+        amountAtomic,
+        asset: option.asset,
+        network: option.network,
+        facilitatorAddresses: selection.facilitatorAddresses
+      }
+    };
+  }
+  /**
+   * The SETTLE half (#1456): exchange the signed child for the merchant header.
+   *
+   * The SDK builds no header on this path — the backend assembles the MetaMask
+   * erc7710 payload in `assembleSettlementPayload`. Whoever produced the
+   * signature (an in-process delegate key, or the local edge signer over the
+   * hosted boundary) is irrelevant here.
+   */
+  async submit(paymentId, signature) {
+    const settled = await this.post(
+      `/x402/${paymentId}/settle`,
+      { signature }
+    );
+    if (!settled.payment_header) {
+      throw new HavenApiError(
+        "x402 settle returned no payment_header \u2014 the merchant cannot be retried.",
+        500,
+        settled
+      );
+    }
+    return settled.payment_header;
+  }
+};
+
+// src/tool-adapter.ts
+function toolX402PaymentRequired(input) {
+  return {
+    x402Version: 2,
+    resource: { url: input.url, description: input.description },
+    accepts: [
+      {
+        scheme: "exact",
+        network: input.network,
+        amount: input.amount,
+        asset: input.asset,
+        payTo: input.payTo,
+        maxTimeoutSeconds: 30
+      }
+    ]
+  };
+}
+function x402ToolReceipt(receipt) {
+  return {
+    success: true,
+    payment_id: receipt.paymentId,
+    tx_hash: receipt.txHash,
+    token: receipt.token,
+    amount: receipt.amount,
+    to: receipt.to,
+    resource_url: receipt.resourceUrl,
+    explorer_url: receipt.explorerUrl,
+    payment_header: receipt.paymentHeader,
+    merchant_to: receipt.merchantTo,
+    payer: receipt.payer,
+    chain_id: receipt.chainId,
+    haven: receipt.haven,
+    merchant: receipt.merchant,
+    x402: receipt.x402
+  };
+}
+function toolError(err) {
+  if (err instanceof HavenPaymentStateError) {
+    return {
+      success: false,
+      payment_id: err.state.paymentId,
+      kind: err.state.kind,
+      rail: err.state.rail,
+      status: err.state.status,
+      phase: err.state.phase,
+      next_action: err.state.nextAction,
+      tx_hash: err.state.txHash,
+      token: err.state.token,
+      amount: err.state.amount,
+      resource_url: err.state.resourceUrl,
+      merchant_address: err.state.merchantAddress,
+      amount_atomic: err.state.amountAtomic,
+      asset: err.state.asset,
+      network: err.state.network,
+      description: err.state.description,
+      idempotency_key: err.state.idempotencyKey,
+      x402: err.state.x402 ? {
+        amount_atomic: err.state.x402.amountAtomic,
+        asset: err.state.x402.asset,
+        network: err.state.x402.network,
+        resource_url: err.state.x402.resourceUrl,
+        merchant_address: err.state.x402.merchantAddress,
+        description: err.state.x402.description,
+        idempotency_key: err.state.x402.idempotencyKey
+      } : void 0,
+      mpp: err.state.mpp ? {
+        amount_atomic: err.state.mpp.amountAtomic,
+        asset: err.state.mpp.asset,
+        network: err.state.mpp.network,
+        resource_url: err.state.mpp.resourceUrl,
+        merchant_address: err.state.mpp.merchantAddress,
+        description: err.state.mpp.description,
+        idempotency_key: err.state.mpp.idempotencyKey,
+        challenge_id: err.state.mpp.challengeId
+      } : void 0,
+      resume_state: err.resumeState,
+      expires_at: err.state.expiresAt,
+      chain_id: err.state.chainId,
+      message: err.state.message,
+      error: err.message
+    };
+  }
+  if (err instanceof HavenApiError) {
+    return {
+      success: false,
+      status_code: err.statusCode,
+      error: err.message,
+      body: err.body
+    };
+  }
+  return {
+    success: false,
+    error: err instanceof Error ? err.message : String(err)
+  };
+}
+
+// src/merchant-completion.ts
+var MERCHANT_BODY_SNIPPET_LIMIT = 1e3;
+var EVIDENCE_RETRY_DELAYS_MS = [1e3, 2e3, 4e3];
+var EVIDENCE_RETRYABLE_STATUS = 503;
+var MerchantCompletion = class {
+  post;
+  merchantTransport;
+  getPaymentStatus;
+  getAgent;
+  delegateAddress;
+  x402Wallet;
+  sleep;
+  constructor(options) {
+    this.sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    this.post = options.post;
+    this.merchantTransport = options.merchantTransport;
+    this.getPaymentStatus = options.getPaymentStatus;
+    this.getAgent = options.getAgent;
+    this.delegateAddress = options.delegateAddress;
+    this.x402Wallet = options.x402Wallet;
+  }
+  async retryRequest(url, initialInit, paymentRequired, receipt) {
+    if (!receipt.accepted) {
+      throw new HavenApiError("No accepted x402 option was recorded for payment retry", 500);
+    }
+    if (!receipt.paymentHeader) {
+      throw new HavenApiError("No x402 payment header was returned for payment retry", 500);
+    }
+    const retryResponse = await this.merchantTransport.deliverPayment(
+      url,
+      initialInit,
+      receipt.paymentHeader
+    );
+    if (!retryResponse.ok) {
+      const merchant = await captureMerchantResponse(retryResponse);
+      await this.recordRetryRejected({
+        rail: "x402",
+        paymentId: receipt.paymentId,
+        txHash: receipt.txHash,
+        resourceUrl: receipt.resourceUrl,
+        merchant,
+        details: {
+          merchant_to: receipt.merchantTo,
+          delegate_to: receipt.to
+        }
+      });
+      throw new HavenApiError(
+        "x402 retry failed after Haven funded the delegate wallet; reconciliation may be required.",
+        merchant.merchant_status,
+        {
+          marker: "x402_retry_rejected_after_funding",
+          payment_id: receipt.paymentId,
+          tx_hash: receipt.txHash,
+          resource_url: receipt.resourceUrl,
+          merchant_to: receipt.merchantTo,
+          delegate_to: receipt.to,
+          ...merchant
+        }
+      );
+    }
+    const merchantSettlement = parseMerchantSettlement(retryResponse.headers.get("PAYMENT-RESPONSE"));
+    if (receipt.merchant && merchantSettlement.settlementTxHash) {
+      receipt.merchant.settlementTxHash = merchantSettlement.settlementTxHash;
+      receipt.merchant.settlementExplorerUrl = buildExplorerUrl(
+        receipt.chainId,
+        merchantSettlement.settlementTxHash
+      );
+    }
+    await this.reportEvidence({
+      paymentId: receipt.paymentId,
+      rail: "x402",
+      txHash: receipt.txHash,
+      resourceUrl: receipt.resourceUrl,
+      merchantStatus: retryResponse.status,
+      challengePayload: paymentRequired,
+      selectedPayment: receipt.accepted,
+      paymentProofHeaderName: x402PaymentHeaderNamesSent(receipt.paymentHeader),
+      paymentProofHeader: receipt.paymentHeader,
+      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 {
+    }
+  }
+  async resolveCompletionContext(input) {
+    const status = await this.getPaymentStatus(input.paymentId);
+    if (status.rail !== "x402") {
+      throw new HavenPaymentStateError(
+        `Payment ${status.paymentId} is ${status.rail}, not x402.`,
+        409,
+        status
+      );
+    }
+    const readyForMerchantCompletion = input.noFundingLeg ? status.kind === "payment_intent" && status.status === "submitted" : status.nextAction === AgentPaymentNextAction.RetryOriginalX402Request || status.kind === "payment_intent" && status.status === "confirmed" && status.phase === AgentPaymentPhase.PaymentConfirmed && status.nextAction === AgentPaymentNextAction.None;
+    if (!readyForMerchantCompletion) {
+      throw new HavenPaymentStateError(status.message, paymentStateStatusCode(status.status, 409), status);
+    }
+    if (!input.noFundingLeg && !status.txHash) {
+      throw new HavenApiError(
+        `x402 payment ${status.paymentId} is ready for merchant completion but has no Haven transaction hash.`,
+        502,
+        status,
+        status.paymentId
+      );
+    }
+    const approvedResourceUrl = status.resourceUrl ?? status.x402?.resourceUrl ?? null;
+    if (approvedResourceUrl && approvedResourceUrl !== input.url) {
+      throw new HavenApiError(
+        "x402 merchant completion does not match the approved resource URL.",
+        409,
+        { status, url: input.url },
+        status.paymentId
+      );
+    }
+    return {
+      paymentId: status.paymentId,
+      txHash: status.txHash,
+      resourceUrl: approvedResourceUrl ?? input.url,
+      merchantAddress: status.merchantAddress ?? status.x402?.merchantAddress ?? null
+    };
+  }
+  async resolveWalletForMerchantCall() {
+    const localWallet = x402PayerAddress(this.delegateAddress, this.x402Wallet);
+    if (localWallet) return localWallet;
+    try {
+      const agent = await this.getAgent();
+      return agent.delegateAddress ?? void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  // #1328: authorizeMachinePayment / authorizeMppDemoPayment / resumeAuthorizedMpp
+  // / resumeMppPayment / fetchWithMachinePayment / retryMppRequest (the
+  // MACHINE-PAYMENT-CHALLENGE / mpp_demo client surface) are retired — the
+  // backend's POST /machine-payments/authorize refuses unconditionally now,
+  // and MACHINE-PAYMENT-CHALLENGE was never produced by any other Haven
+  // surface. Use the x402 flow (authorizeX402 / fetch / quoteX402 / payX402Quote)
+  // for agent-to-merchant payments.
+  async recordRetryRejected(input) {
+    try {
+      await this.post("/machine-payments/reconciliation-events", {
+        paymentId: input.paymentId,
+        rail: input.rail,
+        eventType: "merchant_retry_rejected_after_payment",
+        txHash: input.txHash,
+        reason: `Merchant returned HTTP ${input.merchant.merchant_status} after Haven payment confirmation`,
+        details: {
+          resource_url: input.resourceUrl,
+          retry_status: input.merchant.merchant_status,
+          retry_body: input.merchant.merchant_body.slice(0, MERCHANT_BODY_SNIPPET_LIMIT) || null,
+          ...input.details
+        }
+      });
+    } catch {
+    }
+  }
+  /**
+   * #2292: record what a merchant said to a retry **Haven did not make**.
+   *
+   * On the plain-HTTP x402 path Haven tells the agent to call the merchant
+   * itself — that is the keyless design, not an oversight — so the two writes
+   * above were reachable only from `completeX402MerchantCall`, where Haven IS
+   * the caller. A manual retry had nowhere to put its outcome, which left
+   * `intentStateFor`'s merchant-rejected branch dead on the one flow Haven
+   * prescribes and made the 15-minute grace window the only route to
+   * `funded_but_unsettled`.
+   *
+   * Three properties distinguish this from `recordRetryRejected` /
+   * `reportEvidence`, and each is deliberate:
+   *
+   * 1. **It does not swallow.** Those two are bookkeeping hung off a call
+   *    whose outcome is already decided, so an exception there would turn a
+   *    completed payment into a reported failure. Here the report IS the
+   *    caller's request; silently dropping it would recreate the exact
+   *    unobservability #2292 exists to remove.
+   * 2. **The anchor is server-side.** `txHash` and `resourceUrl` come from
+   *    the payment's own Haven record, never from the reporter — so a report
+   *    cannot be pointed at a different transaction or a different resource,
+   *    and it can never CONFIRM an intent (an erc7710 intent has no Haven
+   *    tx hash and is refused here rather than completed from a supplied one,
+   *    which is #2092's verified seam and stays its own path).
+   * 3. **It is evidence, never authority.** Haven does not and must not check
+   *    the claim: verifying it would mean calling the merchant, which is the
+   *    property this whole path exists to preserve. What bounds a false
+   *    report is scope — the backend routes resolve the payment
+   *    `WHERE agent_id = $`, so a caller can only ever describe its own
+   *    payment — plus the fact that nothing financial keys off the claim:
+   *    the sweep is balance-driven, the intent's status/amount/recipient are
+   *    untouched, and a false `accepted` runs the server's own on-chain
+   *    residue check, which re-flags stranded funds independently.
+   */
+  async reportMerchantOutcome(input) {
+    if (!Number.isInteger(input.merchantStatus) || input.merchantStatus < 100 || input.merchantStatus > 599) {
+      throw new HavenApiError(
+        `merchant_status must be an integer HTTP status from 100 to 599 (received ${input.merchantStatus}).`,
+        400,
+        void 0,
+        input.paymentId
+      );
+    }
+    const looksAccepted = input.merchantStatus >= 200 && input.merchantStatus < 300;
+    if (looksAccepted !== (input.outcome === "accepted")) {
+      throw new HavenApiError(
+        `outcome "${input.outcome}" contradicts merchant_status ${input.merchantStatus}: report "accepted" only for a 2xx and "rejected" only for a non-2xx.`,
+        400,
+        void 0,
+        input.paymentId
+      );
+    }
+    const status = await this.getPaymentStatus(input.paymentId);
+    if (status.rail !== "x402") {
+      throw new HavenPaymentStateError(
+        `Payment ${status.paymentId} is ${status.rail}, not x402 \u2014 there is no merchant retry to report.`,
+        409,
+        status
+      );
+    }
+    if (status.status !== "confirmed" || !status.txHash) {
+      throw new HavenPaymentStateError(
+        `Payment ${status.paymentId} has no confirmed Haven funding transaction to anchor a merchant report to (status ${status.status}). ${status.message}`,
+        paymentStateStatusCode(status.status, 409),
+        status
+      );
+    }
+    const resourceUrl = status.resourceUrl ?? status.x402?.resourceUrl ?? null;
+    if (!resourceUrl) {
+      throw new HavenApiError(
+        `Payment ${status.paymentId} has no recorded resource URL, so a merchant report cannot be stored.`,
+        409,
+        status,
+        status.paymentId
+      );
+    }
+    const txHash = status.txHash;
+    if (input.outcome === "rejected") {
+      await this.post("/machine-payments/reconciliation-events", {
+        paymentId: status.paymentId,
+        rail: "x402",
+        eventType: "merchant_retry_rejected_after_payment",
+        txHash,
+        reason: `Agent-reported: merchant returned HTTP ${input.merchantStatus} to a manual retry after Haven payment confirmation`,
+        details: {
+          resource_url: resourceUrl,
+          retry_status: input.merchantStatus,
+          retry_body: input.merchantBody?.slice(0, MERCHANT_BODY_SNIPPET_LIMIT) || null,
+          reported_by: "agent_manual_retry"
+        }
+      });
+      return { paymentId: status.paymentId, outcome: "rejected", txHash, resourceUrl, recorded: "reconciliation_event" };
+    }
+    await this.post("/machine-payments/evidence", {
+      paymentId: status.paymentId,
+      rail: "x402",
+      txHash,
+      resourceUrl,
+      merchantStatus: input.merchantStatus
+    });
+    return { paymentId: status.paymentId, outcome: "accepted", txHash, resourceUrl, recorded: "evidence" };
+  }
+  async reportEvidence(input) {
+    const body = {
+      paymentId: input.paymentId,
+      rail: input.rail,
+      txHash: input.txHash,
+      resourceUrl: input.resourceUrl,
+      merchantStatus: input.merchantStatus,
+      challengePayload: input.challengePayload,
+      selectedPayment: input.selectedPayment,
+      paymentProofHeaderName: input.paymentProofHeaderName,
+      paymentProofHeader: input.paymentProofHeader,
+      protocolReceiptHeaderName: input.protocolReceiptHeaderName,
+      protocolReceiptHeader: input.protocolReceiptHeader,
+      protocolReceiptPayload: input.protocolReceiptHeader ? parseProtocolReceiptHeader(input.protocolReceiptHeader) : void 0
+    };
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        await this.post("/machine-payments/evidence", body);
+        return;
+      } catch (err) {
+        const retryable = err instanceof HavenApiError && err.statusCode === EVIDENCE_RETRYABLE_STATUS;
+        if (!retryable || attempt >= EVIDENCE_RETRY_DELAYS_MS.length) return;
+        await this.sleep(EVIDENCE_RETRY_DELAYS_MS[attempt]);
+      }
+    }
+  }
+};
+function parseMerchantSettlement(header) {
+  if (!header) return {};
+  const parsed = parseProtocolReceiptHeader(header);
+  const tx = typeof parsed?.transaction === "string" ? parsed.transaction : typeof parsed?.txHash === "string" ? parsed.txHash : typeof parsed?.tx_hash === "string" ? parsed.tx_hash : null;
+  return { settlementTxHash: tx };
+}
+function parseProtocolReceiptHeader(value) {
+  try {
+    return decodeBase64Json(value);
+  } catch {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return void 0;
+    }
+  }
+}
+
+// src/client.ts
+var DEFAULT_POLLING_INTERVAL = 3e3;
+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)}`
+    );
+  }
+}
+function mapCatalogEntry(entry) {
+  return {
+    id: entry.id,
+    name: entry.name,
+    description: entry.description,
+    category: entry.category,
+    resourceUrl: entry.resource_url,
+    rail: entry.rail,
+    protocol: entry.protocol,
+    toolName: entry.tool_name,
+    toolArguments: entry.tool_arguments ?? null,
+    priceDisplay: entry.price_display,
+    priceAtomic: entry.price_atomic,
+    asset: entry.asset,
+    network: entry.network,
+    status: entry.status,
+    verifiedAt: entry.verified_at,
+    source: entry.source,
+    domainVerified: entry.domain_verified,
+    verifiedPayable: entry.verified_payable
+  };
+}
+var HavenClient = class {
+  delegateKey;
+  havenApi;
+  accountReads;
+  delegateSweep;
+  x402Wallet;
+  merchantTransport;
+  confirmationTimeout;
+  pollingInterval;
+  chainRpcs;
+  inFlightX402 = /* @__PURE__ */ new Map();
+  /**
+   * The EIP-3009 funding-leg lifecycle (#1618). The facade holds a reference
+   * and delegates; it does not reimplement any of it.
+   */
+  fundingLeg;
+  /**
+   * The erc7710 direct-settlement lifecycle (#1619). Separate from the funding
+   * leg on purpose: this scheme has no funding leg to share.
+   */
+  erc7710;
+  /**
+   * Merchant delivery and the evidence trail behind it (#1620). Scheme-neutral
+   * on purpose — both settlement schemes finish through the same door.
+   */
+  merchantCompletion;
+  /** Delegate address derived from the private key (if provided) */
+  delegateAddress;
+  constructor(config) {
+    this.delegateKey = config.delegateKey;
+    this.havenApi = new HavenApiTransport(config);
+    this.accountReads = new AccountReads({
+      transport: this.havenApi,
+      getPaymentStatus: (paymentId) => this.getPaymentStatus(paymentId)
+    });
+    this.delegateSweep = new DelegateSweepApi({
+      transport: this.havenApi,
+      delegateKey: config.delegateKey,
+      chainRpcs: config.chainRpcs ?? {},
+      getAgent: () => this.getAgent(),
+      buildExplorerUrl: (chainId, hash) => buildExplorerUrl(chainId, hash)
+    });
+    this.x402Wallet = config.x402Wallet;
+    this.merchantTransport = new McpMerchantTransport({ merchantTimeout: config.merchantTimeout });
+    this.confirmationTimeout = config.confirmationTimeout ?? DEFAULT_CONFIRMATION_TIMEOUT_MS;
+    this.pollingInterval = config.pollingInterval ?? DEFAULT_POLLING_INTERVAL;
+    this.chainRpcs = config.chainRpcs ?? {};
+    if (this.delegateKey) {
+      this.delegateAddress = addressFromKey(this.delegateKey);
+    }
+    this.fundingLeg = new X402FundingLeg({
+      delegateKey: this.delegateKey,
+      delegateAddress: this.delegateAddress,
+      x402Wallet: this.x402Wallet,
+      chainRpcs: this.chainRpcs,
+      post: (path, body) => this.post(path, body),
+      signForData: (signData) => this.signForData(signData),
+      assertSignableAuthorizationState: (label, raw) => this.throwIfNonSignableAuthorizationState(label, raw)
+    });
+    this.merchantCompletion = new MerchantCompletion({
+      post: (path, body) => this.post(path, body),
+      merchantTransport: this.merchantTransport,
+      getPaymentStatus: (paymentId) => this.getPaymentStatus(paymentId),
+      getAgent: () => this.getAgent(),
+      delegateAddress: this.delegateAddress,
+      x402Wallet: this.x402Wallet
+    });
+    this.erc7710 = new X402Erc7710({
+      delegateKey: this.delegateKey,
+      post: (path, body) => this.post(path, body),
+      signForData: (signData) => this.signForData(signData),
+      getAgent: () => this.getAgent()
+    });
+  }
+  /**
+   * Run `fn` with extra Haven-API headers scoped to the async work it
+   * performs. Used by the MCP server to tag every Haven API request that
+   * a single tool dispatch makes with `X-Haven-MCP-Tool: <name>` so the
+   * backend can write an audit-log row attributing the call.
+   *
+   * The headers are held in an `AsyncLocalStorage` so overlapping
+   * dispatches do not leak headers into each other's requests. The store
+   * inherits across `await` boundaries, so any Haven API call made while
+   * `fn` is awaiting will pick up the right headers.
+   *
+   * Has no effect on outbound merchant requests (x402 / MPP) — those
+   * never go through the internal `request<T>` path that reads the
+   * context.
+   */
+  withRequestContext(headers, fn) {
+    return this.havenApi.withRequestContext(headers, fn);
+  }
+  // ── High-Level API ───────────────────────────────────────────────
+  /**
+   * Send a payment in one call.
+   *
+   * Creates the intent, signs the hash, submits the signature,
+   * and polls until confirmed (or throws on failure/timeout).
+   *
+   * Requires `delegateKey` to be set in the client config.
+   */
+  async pay(request) {
+    if (!this.delegateKey) {
+      throw new HavenSigningError(
+        "Cannot use pay() without a delegateKey. Use createIntent() + submitSignature() for manual signing."
+      );
+    }
+    const intent = await this.createIntent(request);
+    const signature = this.sign(intent.signData.hash);
+    await this.submitSignature(intent.paymentId, signature);
+    return this.waitForConfirmation(intent.paymentId);
+  }
+  // ── Step-by-Step API ─────────────────────────────────────────────
+  /**
+   * Step 1: Create a payment intent.
+   *
+   * Returns the intent with the hash to sign.
+   */
+  async createIntent(request) {
+    const raw = await this.post("/payments", {
+      token: request.token,
+      amount: request.amount,
+      to: request.to,
+      ...request.idempotencyKey ? { idempotency_key: request.idempotencyKey } : {}
+    });
+    if (raw.status === "pending_approval") {
+      throwPaymentStateError("Payment", raw);
+    }
+    return {
+      paymentId: raw.payment_id,
+      status: "pending_signature",
+      expiresAt: raw.expires_at,
+      signData: raw.sign_data
+    };
+  }
+  /**
+   * Keyless x402 construct.
+   *
+   * The non-custodial half of an x402 payment: posts the funding request to
+   * `/x402` and returns the unsigned funding hash plus the data the caller
+   * needs to build and sign the EIP-3009 merchant header itself. Crucially it
+   * does **not** sign — neither the funding hash nor the merchant header — so
+   * it works without a `delegateKey`. Both delegate signatures happen on the
+   * machine that holds the key (the edge); the hosted MCP server relays only.
+   *
+   * Use this from the hosted, keyless server. The all-in-one `authorizeX402`
+   * remains for local clients that hold the key.
+   *
+   * Throws (via the shared payment-state path) when the amount exceeds the
+   * on-chain allowance — there is nothing to sign until the user approves.
+   */
+  async createX402Intent(paymentRequired, options = {}) {
+    const option = selectStandardPaymentOption(paymentRequired.accepts);
+    if (!option) {
+      throw noCompatiblePaymentOptionError(paymentRequired.accepts);
+    }
+    const fundingTo = options.delegateAddress ?? (await this.getAgent()).delegateAddress;
+    if (!fundingTo) {
+      throw new HavenApiError("Authenticated agent has no delegate address registered.", 502);
+    }
+    const idempotencyKey = options.idempotencyKey ?? buildX402IdempotencyKey(paymentRequired, option);
+    const raw = await this.post("/x402", {
+      url: paymentRequired.resource.url,
+      payTo: fundingTo,
+      merchantPayTo: option.payTo,
+      // #1360: this path ALWAYS means the EIP-3009 funding leg (payTo is the
+      // agent's own delegate EOA). Saying so explicitly turns a stale/rotated
+      // delegate address into the backend's LOUD shape-mismatch 400 instead
+      // of a silent reroute to the erc7710 settlement branch (the #1358
+      // review's open-budget misroute). Legacy-rail backends ignore the field.
+      settlementScheme: "eip3009",
+      amount: x402AuthorizationAmount(option),
+      asset: option.asset,
+      network: option.network,
+      description: paymentRequired.resource.description,
+      idempotencyKey,
+      // #1307: persisted so the settle leg can rehydrate it by payment_id.
+      ...options.mcpCallContext ? { mcpCallContext: options.mcpCallContext } : {},
+      // #1355: persisted so the SIGN leg can rehydrate it by payment_id — the
+      // local signer's context fetch then carries the 402 PaymentRequired and
+      // the agent passes only payment_id. Bounded: the backend rejects >64KB,
+      // so an oversized blob is omitted here (signer falls back to the
+      // caller-supplied copy) rather than failing the intent.
+      ...new TextEncoder().encode(JSON.stringify(paymentRequired)).length <= 65536 ? { paymentRequired } : {}
+    });
+    if (raw.status !== "pending_signature") {
+      throwPaymentStateError("x402 payment", raw);
+    }
+    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);
+    }
+    return {
+      paymentId: raw.payment_id,
+      idempotencyKey,
+      status: "pending_signature",
+      expiresAt: raw.expires_at,
+      signData: raw.sign_data,
+      accepted: option,
+      resourceUrl: paymentRequired.resource.url,
+      merchantTo: raw.merchant_to ?? option.payTo,
+      amountAtomic: x402AuthorizationAmount(option),
+      asset: option.asset,
+      network: option.network,
+      expectedAuth: raw.x402_expected_auth,
+      payerDelegate: raw.payer_delegate,
+      payerAgentId: raw.payer_agent_id,
+      // #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
+    };
+  }
+  /**
+   * Step 2: Sign a hash with the delegate key.
+   *
+   * Returns the 65-byte signature (0x-prefixed).
+   * Requires `delegateKey` to be set in the client config.
+   */
+  sign(hash) {
+    if (!this.delegateKey) {
+      throw new HavenSigningError(
+        "Cannot sign without a delegateKey. Pass the private key in HavenClient config, or sign externally."
+      );
+    }
+    const signature = signHash(this.delegateKey, hash);
+    if (!verifySignature(hash, signature, this.delegateAddress)) {
+      throw new HavenSigningError(
+        "Local signature verification failed \u2014 recovered address does not match delegate key."
+      );
+    }
+    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 === "eip712_delegation") {
+      if (!signData.typed_data) {
+        throw new HavenSigningError(
+          "sign_data.signature_scheme is eip712_delegation but typed_data is missing \u2014 refusing to sign the bare hash (the settlement would be rejected on redemption)."
+        );
+      }
+      return signSettlementDelegationTypedData(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.
+   *
+   * The signature can come from `client.sign()` or from external signing.
+   */
+  async submitSignature(paymentId, signature) {
+    const raw = await this.post(
+      `/payments/${paymentId}/sign`,
+      { signature }
+    );
+    return {
+      status: raw.status,
+      txHash: raw.tx_hash
+    };
+  }
+  /**
+   * Get the current status of a payment.
+   */
+  async getPayment(paymentId) {
+    const raw = await this.get(`/payments/${paymentId}`);
+    return mapPaymentResult(raw, buildExplorerUrl);
+  }
+  /**
+   * Get agent-actionable status for a payment intent or approval request.
+   *
+   * Use this for IDs returned by agent tools and machine-payment/x402 flows.
+   * `getPayment()` remains available for payment-intent-only integrations.
+   */
+  async getPaymentStatus(paymentId) {
+    const raw = await this.get(`/machine-payments/${paymentId}/status`);
+    return mapPaymentStatusResult(raw);
+  }
+  /**
+   * Get the agent identity tied to this API key.
+   */
+  async getAgent() {
+    return this.accountReads.getAgent();
+  }
+  /**
+   * One-shot "am I ready?" bootstrap: identity + live spend authority + a
+   * readiness signal, in a single call. Folds {@link getAgent} and
+   * {@link getAllowances} together and derives a {@link HavenAgentReadiness}
+   * so an agent can answer "who am I and can I pay right now" at session start
+   * without two round trips and manual assembly.
+   */
+  async getAgentSummary() {
+    return this.accountReads.getAgentSummary();
+  }
+  /**
+   * Sweep stranded USDC and ETH from the delegate EOA back to the originating Safe.
+   *
+   * The delegate key held by this client signs and submits the transfer transactions
+   * directly — Haven's backend never handles the key or constructs signed txs
+   * (CASP/MiCA Red Line #2). Funds always go to the Safe linked to this agent.
+   *
+   * Requires `chainRpcs` to be set for the agent's chain in `HavenClientConfig`.
+   */
+  async sweepDelegate() {
+    return this.delegateSweep.sweepDelegate();
+  }
+  /**
+   * Hosted (keyless) split-signer sweep — step 1 of 2.
+   *
+   * Asks the backend to build a gasless EIP-3009 sweep authorization for the
+   * delegate's stranded USDC. Returns `nothing_stranded` when the delegate is
+   * empty, otherwise an `authorization` + Haven `expected_auth` to hand to the
+   * edge signer's `haven_sign_sweep_delegate`. No key is required on this client.
+   */
+  async prepareSweep() {
+    return this.delegateSweep.prepareSweep();
+  }
+  /**
+   * Hosted (keyless) split-signer sweep — step 2 of 2.
+   *
+   * Relays the delegate-signed authorization. The Haven relayer submits the
+   * on-chain `transferWithAuthorization` and pays gas; this client never holds
+   * the key.
+   */
+  async submitSweep(authorization, signature) {
+    return this.delegateSweep.submitSweep(authorization, signature);
+  }
+  /**
+   * Get configured and on-chain allowances for the authenticated agent.
+   */
+  async getAllowances() {
+    return this.accountReads.getAllowances();
+  }
+  /**
+   * Post-purchase allowance/budget summary for a settled payment (#1310).
+   *
+   * Reuses the EXACT rail-aware read path {@link getAllowances} / #1306's
+   * catalog-purchase preflight `allowance` block use — `GET
+   * /machine-payments/allowances`, with delegation-rail values coming from
+   * the #1090 `deriveDelegationBudgets`-backed enforcer read, never
+   * `agent_allowances` — so this can never disagree with
+   * {@link getAllowances} for the same fixture. The settled token is
+   * resolved from {@link getPaymentStatus} so callers pass only
+   * `paymentId`, never a second haven_get_agent-style round trip.
+   *
+   * NEVER throws: any failed read (status lookup, agent lookup, or the
+   * allowance/budget lookup itself) degrades to `{ allowance: null,
+   * warnings: [ALLOWANCE_CHECK_UNAVAILABLE] }` rather than converting a
+   * successful settlement into a failure — the on-chain policy remains the
+   * actual spend gate regardless of whether this report can be produced.
+   *
+   * Freshness caveat (#1319): the delegation rail's on-chain enforcer read
+   * can silently fall back to the optimistic full period budget without
+   * throwing when the RPC read itself fails (#1145's fund-safe design,
+   * unchanged here). {@link getAllowances}'s `onchain.remainingIsFromChain`
+   * now carries that provenance on the wire, and the #1306 catalog-purchase
+   * preflight (`haven_prepare_catalog_purchase`) surfaces it as a warning —
+   * this summary does not (yet). `remaining_atomic` here reflects the last
+   * successful chain read, not a guaranteed-live one, and callers should not
+   * phrase it as guaranteed-fresh.
+   */
+  async getPostPurchaseAllowanceSummary(paymentId) {
+    return this.accountReads.getPostPurchaseAllowanceSummary(paymentId);
+  }
+  /**
+   * `haven_get_payment_status` convenience: fetch status and, for a
+   * genuinely SETTLED x402 payment, attach the same post-purchase
+   * allowance/budget summary a settle response carries.
+   *
+   * #1310/#1311 parity: this is the ONE home for logic that was duplicated
+   * verbatim in `packages/mcp-server/src/tools.ts` and `packages/mcp/src/tools.ts`
+   * (both hosted and local `haven_get_payment_status` handlers) — extracted
+   * here because both packages already depend on `@haven_ai/sdk` and call
+   * methods on a `HavenClient` instance, so this needed no new dependency
+   * edge. `funded_but_unsettled` is deliberately excluded: that phase means
+   * the merchant did NOT accept the retry. Every other phase/rail returns
+   * the status untouched.
+   */
+  async getPaymentStatusWithPostPurchaseAllowance(paymentId) {
+    const status = await this.getPaymentStatus(paymentId);
+    if (status.rail === AgentPaymentRail.X402 && status.phase === AgentPaymentPhase.PaymentConfirmed) {
+      const { allowance, warnings } = await this.getPostPurchaseAllowanceSummary(paymentId);
+      return { ...status, allowance, ...warnings.length > 0 ? { warnings } : {} };
+    }
+    return status;
+  }
+  /**
+   * Discover payable services from Haven's merchant catalog (epic #1717).
+   *
+   * Read-only: returns catalog entries (price, rail, protocol) so an agent
+   * can choose a service and pay it with the regular payment tools in the
+   * same session. Never creates payments or signatures.
+   */
+  async discoverTools(options = {}) {
+    const params = new URLSearchParams();
+    if (options.category) params.set("category", options.category);
+    if (options.search !== void 0) params.set("search", options.search);
+    if (options.rail) params.set("rail", options.rail);
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    const raw = await this.get(`/catalog${query}`);
+    let entries = raw.entries.map(mapCatalogEntry);
+    if (options.verified === "verified") entries = entries.filter((e) => e.source === "ingestion");
+    if (options.verified === "operator") entries = entries.filter((e) => e.source === "operator");
+    return entries;
+  }
+  /**
+   * Submit a merchant's payable (x402/MCP) endpoint to the Verified Payable
+   * Directory (epic #1717, #1716). Queue-only: writes a submission row and
+   * returns the id + verify_token. The request path makes no outbound
+   * request; domain-ownership proof and the read-only quote probe run later
+   * on the leader-locked monitor. Ownership proof is ALWAYS required before
+   * any listing — this method cannot skip it. `website` is a honeypot field
+   * that bots fill; leave it unset.
+   */
+  async submitCatalogEntry(resourceUrl, options = {}) {
+    const accepted = await this.post("/catalog/submit", {
+      resource_url: resourceUrl,
+      ...options.website ? { website: options.website } : {}
+    });
+    return {
+      id: accepted.id,
+      verifyToken: accepted.verify_token,
+      status: accepted.status
+    };
+  }
+  /**
+   * Fetch one submission's coarse status by id (epic #1717, #1716). Public
+   * and read-only. While the submission can still prove ownership the
+   * response carries the exact well-known / DNS-TXT `instructions`; the
+   * verify token is never returned here.
+   */
+  async getCatalogSubmissionStatus(id) {
+    return this.get(`/catalog/submit/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Fetch one curated catalog entry by id (#1306).
+   *
+   * Chain-scoped for free by the backend's SQL when the client is
+   * agent-authenticated (#1299): an unknown id and an id curated for a
+   * DIFFERENT chain than this agent's both 404 identically — this method does
+   * not (and must not) re-filter by chain in JS. Read-only, like
+   * {@link discoverTools}.
+   */
+  async getCatalogEntry(id) {
+    const raw = await this.get(`/catalog/${encodeURIComponent(id)}`);
+    return mapCatalogEntry(raw);
+  }
+  /**
+   * List recent machine-payment receipts/evidence for bookkeeping.
+   */
+  async listReceipts(options = {}) {
+    return this.accountReads.listReceipts(options);
+  }
+  /**
+   * 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) {
+    return this.accountReads.getReceipt(paymentId);
+  }
+  /**
+   * Rehydrate the x402 resume-state bundle for a payment id (#1328: the MPP
+   * resume-state variant retired along with the rest of the mpp_demo surface).
+   *
+   * The server returns stored protocol context only. The client still signs the
+   * merchant proof locally when resumeX402Payment() runs.
+   */
+  async getResumeState(paymentId) {
+    return this.get(`/payments/${paymentId}/resume_state`);
+  }
+  /**
+   * Poll until a payment reaches a terminal status (confirmed, failed, expired).
+   */
+  async waitForConfirmation(paymentId) {
+    const deadline = Date.now() + this.confirmationTimeout;
+    while (Date.now() < deadline) {
+      const result = await this.getPayment(paymentId);
+      if (result.status === "confirmed" || result.status === "failed" || result.status === "expired") {
+        return result;
+      }
+      await sleep(this.pollingInterval);
+    }
+    throw new HavenTimeoutError(paymentId);
+  }
+  // ── x402 Protocol Support ────────────────────────────────────────
+  /**
+   * Authorize an x402 payment.
+   *
+   * Takes the parsed PaymentRequired from a 402 response, selects a compatible
+   * option, funds the delegate wallet through Haven, and returns the standard
+   * x402 header that the merchant can verify and settle.
+   *
+   * Requires `delegateKey` to be set in the client config.
+   */
+  async authorizeX402(paymentRequired, options = {}) {
+    if (!this.delegateKey) {
+      throw new HavenSigningError(
+        "delegateKey is required for x402 payments. Pass it in the HavenClient config."
+      );
+    }
+    if (!this.delegateAddress) {
+      throw new HavenSigningError("delegateAddress could not be derived from delegateKey.");
+    }
+    const option = selectStandardPaymentOption(paymentRequired.accepts);
+    if (!option) {
+      throw noCompatiblePaymentOptionError(paymentRequired.accepts);
+    }
+    const idempotencyKey = options.idempotencyKey ?? buildX402IdempotencyKey(paymentRequired, option);
+    const cached = this.fundingLeg.cachedReceipt(idempotencyKey);
+    if (cached) return cached;
+    const inFlight = this.inFlightX402.get(idempotencyKey);
+    if (inFlight) return inFlight;
+    const promise = this.fundingLeg.authorize(paymentRequired, option, idempotencyKey);
+    this.inFlightX402.set(idempotencyKey, promise);
+    try {
+      return await promise;
+    } catch (err) {
+      attachResumeState(err, {
+        paymentRequired,
+        accepted: option,
+        idempotencyKey
+      });
+      throw err;
+    } finally {
+      this.inFlightX402.delete(idempotencyKey);
+    }
+  }
+  /**
+   * Probe a paid endpoint and return its x402 quote without creating a Haven
+   * payment or approval request.
+   */
+  async quoteX402(url, init, options = {}) {
+    const initialInit = withX402Wallet(init, x402PayerAddress(this.delegateAddress, this.x402Wallet));
+    const request = snapshotX402Request(url, initialInit);
+    const response = await this.merchantTransport.fetch(url, initialInit);
+    if (response.status !== 402) {
+      throw new X402UnexpectedStatusError(
+        `Expected an x402 quote response with HTTP 402, got HTTP ${response.status}.`,
+        response.status || 400
+      );
+    }
+    if (response.headers.get("MACHINE-PAYMENT-CHALLENGE")) {
+      throw new HavenApiError("quoteX402 only supports standard x402 Payment Required responses.", 400);
+    }
+    const paymentRequired = await parsePaymentRequiredResponse(response);
+    const mcpTransport = await this.merchantTransport.detect(url, paymentRequired, response);
+    return buildX402Quote(paymentRequired, request, options.idempotencyKey, mcpTransport);
+  }
+  /**
+   * Probe an MCP tool for its x402 quote without creating a payment.
+   *
+   * Unlike the generic {@link quoteX402} helper, this completes the
+   * Streamable-HTTP MCP lifecycle before sending the unpaid `tools/call`.
+   * Hosted MCP uses this path while remaining keyless: it resolves only the
+   * agent's public delegate address for `x402-wallet`; signing remains local.
+   * It refuses before the quote when the merchant does not establish a session;
+   * callers that need a plain x402 endpoint must use {@link quoteX402}.
+   */
+  async quoteMcpX402(url, init, options = {}) {
+    const wallet = await this.merchantCompletion.resolveWalletForMerchantCall();
+    const sessionId = await this.merchantTransport.initialize(url, init, wallet);
+    if (!sessionId) {
+      throw new HavenApiError(
+        "The merchant did not establish an MCP session before the x402 quote. No payment was created.",
+        502,
+        { mcpSessionNotEstablished: true }
+      );
+    }
+    let requestInit = withX402Wallet(init, wallet);
+    requestInit = this.merchantTransport.withSessionHeaders(requestInit, sessionId);
+    const quote = await this.quoteX402(url, requestInit, options);
+    return {
+      ...quote,
+      mcpTransport: quote.mcpTransport ?? { handshakeRequired: true, source: "path" }
+    };
+  }
+  /**
+   * Pay a previously inspected x402 quote and retry the exact captured request.
+   */
+  async payX402Quote(quote, options = {}) {
+    const idempotencyKey = options.idempotencyKey ?? quote.idempotencyKey;
+    try {
+      const receipt = await this.authorizeX402(quote.paymentRequired, { idempotencyKey });
+      return this.merchantCompletion.retryRequest(
+        quote.request.url,
+        requestInitFromSnapshot(quote.request),
+        quote.paymentRequired,
+        receipt
+      );
+    } catch (err) {
+      attachResumeState(err, {
+        paymentRequired: quote.paymentRequired,
+        accepted: quote.accepted,
+        idempotencyKey,
+        request: quote.request
+      });
+      throw err;
+    }
+  }
+  /**
+   * Pay a merchant through **erc7710 direct settlement** (#1454, epic #1450).
+   *
+   * **Nothing has settled when this returns** — that is why it does not return
+   * an `X402Receipt`; the caller still has to retry the merchant with the
+   * header. **MCP callers must pass `options.resourceUrl`**, because an in-band
+   * MCP 402 challenge frequently carries no `resource` object at all.
+   *
+   * Both caveats, and why this scheme has no funding leg, are explained where
+   * the lifecycle lives: `x402-erc7710.ts` (#1619).
+   */
+  async settleX402Erc7710(paymentRequired, options = {}) {
+    return this.erc7710.settle(paymentRequired, options);
+  }
+  /**
+   * The AUTHORIZE half of erc7710 settlement (#1456): select the scheme, build
+   * the request, and return the child to be signed — without signing it.
+   *
+   * Split out because the hosted topology cannot use `settleX402Erc7710()`:
+   * that method signs in-process with `delegateKey`, and hosted Haven does not
+   * have one and must not.
+   */
+  async prepareX402Erc7710(paymentRequired, options = {}) {
+    return this.erc7710.prepare(paymentRequired, options);
+  }
+  /**
+   * The SETTLE half (#1456): exchange the signed child for the merchant header.
+   *
+   * The SDK builds no header on this path — the backend assembles the MetaMask
+   * erc7710 payload. Whoever produced the signature (an in-process delegate
+   * key, or the local edge signer over the hosted boundary) is irrelevant.
+   */
+  async submitX402Erc7710(paymentId, signature) {
+    return this.erc7710.submit(paymentId, signature);
+  }
+  async resumeAuthorizedX402(input) {
+    if (!this.delegateKey) {
+      throw new HavenSigningError(
+        "delegateKey is required for x402 payments. Pass it in the HavenClient config."
+      );
+    }
+    if (!this.delegateAddress) {
+      throw new HavenSigningError("delegateAddress could not be derived from delegateKey.");
+    }
+    const option = selectStandardPaymentOption(input.paymentRequired.accepts);
+    if (!option) {
+      throw noCompatiblePaymentOptionError(input.paymentRequired.accepts);
+    }
+    const idempotencyKey = input.idempotencyKey ?? buildX402IdempotencyKey(input.paymentRequired, option);
+    const cached = this.fundingLeg.cachedReceipt(idempotencyKey);
+    if (cached) return cached;
+    const status = await this.getPaymentStatus(input.paymentId);
+    assertCanResumeX402(status, input.paymentRequired, option);
+    const canFund = await this.fundingLeg.delegateCanFund(
+      status.chainId ?? chainIdFromNetwork(option.network),
+      option.asset,
+      x402AuthorizationAmount(option)
+    );
+    if (canFund === false) {
+      throw new X402AlreadySettledError(
+        `x402 payment ${status.paymentId} has already settled \u2014 the delegate no longer holds the funds to authorize it again, so there is nothing left to resume.`,
+        this.fundingLeg.receiptFromStatus(input.paymentRequired, option, void 0, status),
+        "settled"
+      );
+    }
+    const paymentHeader = await this.fundingLeg.createPaymentHeader(input.paymentRequired, option);
+    const receipt = this.fundingLeg.receiptFromStatus(input.paymentRequired, option, paymentHeader, status);
+    this.fundingLeg.cacheReceipt(idempotencyKey, paymentHeader, receipt);
+    return receipt;
+  }
+  async resumeX402Payment(input) {
+    const inputInit = "init" in input ? input.init : void 0;
+    const initialInit = withX402Wallet(
+      inputInit ?? (input.request ? requestInitFromSnapshot(input.request) : void 0),
+      x402PayerAddress(this.delegateAddress, this.x402Wallet)
+    );
+    let paymentRequired = input.paymentRequired;
+    const url = input.url ?? input.request?.url;
+    if (!paymentRequired) {
+      if (!url) {
+        throw new HavenApiError("x402 resume requires the original URL or a captured request snapshot.", 400);
+      }
+      const response = await this.merchantTransport.fetch(url, initialInit);
+      if (response.status !== 402) {
+        throw new HavenApiError("Expected the original x402 request to return HTTP 402 before resuming.", 400);
+      }
+      paymentRequired = await parsePaymentRequiredResponse(response);
+    }
+    const receipt = await this.resumeAuthorizedX402({
+      paymentId: input.paymentId,
+      paymentRequired,
+      idempotencyKey: input.idempotencyKey
+    });
+    return this.merchantCompletion.retryRequest(url ?? paymentRequired.resource.url, initialInit, paymentRequired, receipt);
+  }
+  /**
+   * Fetch wrapper that automatically handles HTTP 402 responses.
+   *
+   * Works like the standard `fetch()` but intercepts 402 responses,
+   * pays via x402 through Haven, and retries the request.
+   *
+   * ```ts
+   * const response = await haven.fetch('https://paid-api.com/data')
+   * const data = await response.json()
+   * ```
+   *
+   * **MCP-over-x402 auto-handshake (issue #315):** when the endpoint is
+   * MCP-shaped — the URL path ends in `/mcp`, or the 402 body carries a
+   * Coinbase Bazaar `extensions.bazaar` block — the SDK runs the MCP
+   * `initialize` handshake, threads the resulting `mcp-session-id`,
+   * `Accept: application/json, text/event-stream`, and `x402-wallet` headers
+   * through every request, and collapses SSE responses to the JSON-RPC
+   * `result`. The caller just passes `(url, { body })` and never sees the
+   * protocol plumbing. A non-MCP server (handshake error / no session id)
+   * falls back to standard x402 behaviour.
+   *
+   * Requires `delegateKey` to be set in the client config.
+   */
+  async fetch(url, init, options = {}) {
+    let mcpSessionId;
+    if (this.merchantTransport.isMcpUrl(url)) {
+      mcpSessionId = await this.merchantTransport.initialize(url, init);
+    }
+    let requestInit = withX402Wallet(init, x402PayerAddress(this.delegateAddress, this.x402Wallet));
+    if (mcpSessionId) requestInit = this.merchantTransport.withSessionHeaders(requestInit, mcpSessionId);
+    const response = await this.merchantTransport.fetch(url, requestInit);
+    if (response.status !== 402) {
+      return mcpSessionId ? this.merchantTransport.surfaceResult(response) : response;
+    }
+    let paymentRequired;
+    try {
+      paymentRequired = await parsePaymentRequiredResponse(response);
+    } catch {
+      return response;
+    }
+    if (!mcpSessionId && await this.merchantTransport.hasBazaarExtension(response)) {
+      mcpSessionId = await this.merchantTransport.initialize(url, init);
+      if (mcpSessionId) requestInit = this.merchantTransport.withSessionHeaders(requestInit, mcpSessionId);
+    }
+    const request = snapshotX402Request(url, requestInit);
+    const option = selectStandardPaymentOption(paymentRequired.accepts);
+    const idempotencyKey = options.idempotencyKey ?? (option ? buildX402IdempotencyKey(paymentRequired, option) : void 0);
+    let receipt;
+    try {
+      receipt = await this.authorizeX402(paymentRequired, options);
+    } catch (err) {
+      if (option && idempotencyKey) {
+        attachResumeState(err, {
+          paymentRequired,
+          accepted: option,
+          idempotencyKey,
+          request
+        });
+      }
+      throw err;
+    }
+    const retryResponse = await this.merchantCompletion.retryRequest(url, requestInit, paymentRequired, receipt);
+    return mcpSessionId ? this.merchantTransport.surfaceResult(retryResponse) : retryResponse;
+  }
+  /**
+   * 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
+   * merchant leg of an MCP tool payment after the edge signer has built the
+   * merchant payment header.
+   *
+   * Custody note: this never needs the delegate key. It relays a signed,
+   * amount/merchant/nonce-bound EIP-3009 authorization the edge signer already
+   * produced — the hosted server cannot mint or reuse signing authority.
+   *
+   * When the URL is MCP-shaped (`/mcp` path) or the quote-time transport context
+   * says the merchant was Bazaar-discoverable, runs a fresh `initialize`
+   * handshake (the quote-time session is gone once funding confirms; the x402
+   * challenge is stateless w.r.t. the MCP session, so a fresh session is
+   * accepted), threads the session + wallet headers, sets the x402 payment
+   * header under the names that scheme requires (#2341), and
+   * collapses an SSE JSON-RPC response to its `result`.
+   */
+  /**
+   * Wait for a payment's Safe→delegate funding tx to reach ≥1 on-chain
+   * confirmation. The hosted x402 completion path MUST call this after funding
+   * and before delivering the merchant payment header, so the merchant's
+   * balanceOf(delegate) / transferWithAuthorization verification sees the funded
+   * balance — otherwise it rejects with "Payment verification failed". The
+   * SDK's local path already does this (see `X402FundingLeg.authorize`); the hosted
+   * split flow regressed when the 5→3 collapse removed the incidental
+   * inter-call latency that used to mask it.
+   *
+   * **NOT a no-op when the funding tx hash is absent** (#1508). The WAIT is
+   * skipped without a hash or a chain RPC, but the `GET /payments/:id` read
+   * below runs UNCONDITIONALLY — it is how the fallback hash and the chainId
+   * are obtained. That distinction is load-bearing: this method must never be
+   * called on a scheme with no funding leg, because the read itself fails once
+   * the intent reaches a status the backend maps to a non-2xx (`submitted` is a
+   * 409), turning a settled payment into a reported error. The previous wording
+   * here said "No-op when the funding tx hash ... is unavailable", and the
+   * hosted erc7710 path was written against that promise — see
+   * `deliverMerchantPayment`'s `noFundingLeg` option.
+   */
+  async ensureFundingConfirmed(paymentId, fundingTxHash) {
+    const status = await this.getPaymentStatus(paymentId);
+    await this.fundingLeg.waitForFundingTx(fundingTxHash ?? status.txHash ?? void 0, status.chainId);
+  }
+  async completeX402MerchantCall(input) {
+    const evidenceContext = await this.merchantCompletion.resolveCompletionContext({
+      paymentId: input.paymentId,
+      url: input.url,
+      noFundingLeg: input.noFundingLeg === true
+    });
+    const fundingTxHash = evidenceContext.txHash;
+    const shouldHandshakeMcp = this.merchantTransport.isMcpUrl(input.url) || input.mcpTransport?.handshakeRequired === true;
+    const x402Wallet = shouldHandshakeMcp ? await this.merchantCompletion.resolveWalletForMerchantCall() : x402PayerAddress(this.delegateAddress, this.x402Wallet);
+    let mcpSessionId;
+    if (shouldHandshakeMcp) {
+      mcpSessionId = await this.merchantTransport.initialize(input.url, input.init, x402Wallet);
+    }
+    let requestInit = withX402Wallet(input.init, x402Wallet) ?? {};
+    if (mcpSessionId) requestInit = this.merchantTransport.withSessionHeaders(requestInit, mcpSessionId);
+    const response = await this.merchantTransport.deliverPayment(input.url, requestInit, input.paymentHeader);
+    const surfaced = mcpSessionId ? await this.merchantTransport.surfaceResult(response) : response;
+    const protocolReceiptHeader = surfaced.headers.get("PAYMENT-RESPONSE") ?? void 0;
+    const settlement = parseMerchantSettlement(protocolReceiptHeader ?? null);
+    const text = await surfaced.text();
+    let body;
+    try {
+      body = text ? JSON.parse(text) : null;
+    } catch {
+      body = text;
+    }
+    if (!surfaced.ok) {
+      if (!input.noFundingLeg && fundingTxHash) {
+        await this.merchantCompletion.recordRetryRejected({
+          rail: "x402",
+          paymentId: evidenceContext.paymentId,
+          txHash: fundingTxHash,
+          resourceUrl: evidenceContext.resourceUrl,
+          merchant: {
+            merchant_status: surfaced.status,
+            merchant_status_text: surfaced.statusText,
+            merchant_headers: Object.fromEntries(surfaced.headers.entries()),
+            merchant_body: text
+          },
+          details: {
+            merchant_to: evidenceContext.merchantAddress
+          }
+        });
+      }
+    } else {
+      const evidenceTxHash = input.noFundingLeg ? settlement.settlementTxHash ?? void 0 : fundingTxHash ?? void 0;
+      if (evidenceTxHash) {
+        await this.merchantCompletion.reportEvidence({
+          paymentId: evidenceContext.paymentId,
+          rail: "x402",
+          txHash: evidenceTxHash,
+          resourceUrl: evidenceContext.resourceUrl,
+          merchantStatus: surfaced.status,
+          paymentProofHeaderName: x402PaymentHeaderNamesSent(input.paymentHeader),
+          paymentProofHeader: input.paymentHeader,
+          protocolReceiptHeaderName: protocolReceiptHeader ? "PAYMENT-RESPONSE" : void 0,
+          protocolReceiptHeader
+        });
+      }
+      await this.merchantCompletion.reportMerchantReceipt(evidenceContext.paymentId, surfaced);
+    }
+    return {
+      status: surfaced.status,
+      ok: surfaced.ok,
+      body,
+      settlementTxHash: settlement.settlementTxHash ?? void 0
+    };
+  }
+  /**
+   * #2292: report the outcome of a merchant retry the AGENT performed.
+   *
+   * The hosted `haven_complete_mcp_tool` / `completeX402MerchantCall` path is
+   * for merchants Haven calls itself. On the plain-HTTP x402 path Haven never
+   * talks to the merchant, so the outcome of that retry had no way back —
+   * see `MerchantCompletion.reportMerchantOutcome` for what is verified about
+   * a caller-asserted report and what deliberately is not.
+   */
+  async reportX402MerchantOutcome(input) {
+    return await this.merchantCompletion.reportMerchantOutcome(input);
+  }
+  /**
+   * GET /x402/:id/merchant-call-context — the settle-leg twin of #1263's
+   * sign-context fetch (#1307). Re-serves the stored merchant MCP-tool call
+   * context (merchant_url, tool_name, arguments, mcp_transport) recorded at
+   * quote time, so `haven_settle_mcp_tool` / `haven_complete_mcp_tool` can
+   * omit those fields and let Haven rehydrate them by payment_id instead of
+   * the caller re-threading them. Throws `HavenApiError` (404 unknown/foreign
+   * payment_id, 409 no stored context, 410 expired) — the caller decides the
+   * fallback (re-send the full context explicitly).
+   */
+  async getX402MerchantCallContext(paymentId) {
+    const raw = await this.get(
+      `/x402/${paymentId}/merchant-call-context`
+    );
+    return {
+      paymentId: raw.payment_id,
+      merchantUrl: raw.merchant_url,
+      toolName: raw.tool_name,
+      arguments: raw.arguments ?? {},
+      ...raw.mcp_transport ? {
+        mcpTransport: {
+          handshakeRequired: raw.mcp_transport.handshake_required,
+          source: raw.mcp_transport.source
+        }
+      } : {}
+    };
+  }
+  /**
+   * Wait for a funding tx to be mined with ≥1 confirmation before the
+   * merchant retry, eliminating the race where the merchant's
+   * `balanceOf(delegate)` runs before the funding block propagates.
+   *
+   * Skipped when `chainRpcs` does not include the chain; in that case Haven's
+   * backend has already confirmed on-chain submission and callers accept the
+   * small propagation window as a trade-off for not configuring an RPC URL.
+   */
+  throwIfNonSignableAuthorizationState(label, raw) {
+    if (raw.status === "pending_signature") return;
+    throwPaymentStateError(label, raw);
+  }
+  // ── Tool Execution (for agent frameworks) ────────────────────────
+  /**
+   * Execute a tool call by name and input.
+   *
+   * Designed to plug directly into agent tool-call handlers:
+   *
+   * ```ts
+   * if (block.type === 'tool_use') {
+   *   const result = await haven.executeTool(block.name, block.input)
+   *   // send result back to the model
+   * }
+   * ```
+   */
+  async executeTool(toolName, input) {
+    if (toolName === "make_payment") {
+      const { token, amount, to } = input;
+      try {
+        const result = await this.pay({ token, amount, to });
+        return {
+          success: result.status === "confirmed",
+          payment_id: result.paymentId,
+          status: result.status,
+          tx_hash: result.txHash,
+          token: result.token,
+          amount: result.amount,
+          to: result.to,
+          explorer_url: result.explorerUrl,
+          error: result.errorMessage
+        };
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+    if (toolName === "authorize_x402_payment") {
+      const { url, payTo, amount, asset, network, description, idempotencyKey } = input;
+      try {
+        const receipt = await this.authorizeX402(
+          toolX402PaymentRequired({ url, payTo, amount, asset, network, description }),
+          { idempotencyKey }
+        );
+        return x402ToolReceipt(receipt);
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+    if (toolName === "resume_x402_payment") {
+      const { payment_id, url, payTo, amount, asset, network, description, idempotencyKey } = input;
+      try {
+        const receipt = await this.resumeAuthorizedX402({
+          paymentId: payment_id,
+          paymentRequired: toolX402PaymentRequired({ url, payTo, amount, asset, network, description }),
+          idempotencyKey
+        });
+        return x402ToolReceipt(receipt);
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+    if (toolName === "get_payment_status") {
+      const { payment_id } = input;
+      const result = await this.getPaymentStatus(payment_id);
+      return {
+        payment_id: result.paymentId,
+        kind: result.kind,
+        rail: result.rail,
+        status: result.status,
+        phase: result.phase,
+        next_action: result.nextAction,
+        tx_hash: result.txHash,
+        token: result.token,
+        amount: result.amount,
+        resource_url: result.resourceUrl,
+        merchant_address: result.merchantAddress,
+        amount_atomic: result.amountAtomic,
+        asset: result.asset,
+        network: result.network,
+        description: result.description,
+        idempotency_key: result.idempotencyKey,
+        x402: result.x402,
+        mpp: result.mpp,
+        expires_at: result.expiresAt,
+        chain_id: result.chainId,
+        message: result.message
+      };
+    }
+    if (toolName === "get_allowances") {
+      return { ...await this.getAllowances() };
+    }
+    throw new Error(`Unknown tool: ${toolName}`);
+  }
+  // ── HTTP Helpers ─────────────────────────────────────────────────
+  async post(path, body) {
+    return this.havenApi.post(path, body);
+  }
+  async get(path) {
+    return this.havenApi.get(path);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/tool-descriptions.ts
+function composeDescription(d) {
+  return [d.summary, d.selectionGuidance, d.behavior, d.nextActionGuidance].filter(Boolean).join(" ");
+}
+var toolDescriptions = {
+  quoteX402: {
+    summary: "Inspect an HTTP 402 x402 paid resource without creating a Haven payment, signature, approval, or on-chain transaction.",
+    behavior: "Probes the merchant directly and parses the 402 response. Pure read-only client behavior \u2014 Haven is not contacted.",
+    nextActionGuidance: "On success the returned quote is the input to haven_pay_x402_quote. Do not call the merchant again \u2014 Haven re-uses the captured request when paying."
+  },
+  payX402: {
+    summary: "Pay an inspected x402 quote. The delegate key signs locally; Haven only validates and relays signed, on-chain-constrained payment transactions.",
+    selectionGuidance: "Do not use this for read-only allowance, budget, spend-limit, remaining-amount, reset-period, or what-can-I-spend questions; use the allowance lookup tool instead.",
+    behavior: "Signs the payment locally and returns the merchant response. Settlement is either direct account-to-merchant with no funding leg, or a bridge that first redeems the agent's budget delegation to fund the delegate wallet for an EIP-3009 authorization. A payment outside the on-chain budget is declined before any money moves; nothing is queued for a human to approve later.",
+    nextActionGuidance: "Preserve the returned resume_state \u2014 it identifies this payment if you need to ask about it later. This tool performs the merchant retry itself, so do not wait on a signal while the call is in flight. If the process crashes after this call and a later haven_get_payment_status reports nextAction=retry_original_x402_request, Haven's funding leg confirmed but no merchant response was ever recorded \u2014 call the resume tool with the preserved resume_state or payment_id instead of paying again. If the response carries phase=insufficient_funds and nextAction=fund_safe_or_raise_allowance, the payment cannot be retried until the account is funded or the agent budget raised \u2014 stop and tell the user the shortfall reported on the response."
+  },
+  payX402OneShot: {
+    summary: "Fetch an x402 paid HTTP resource in a single call. Handles the full probe -> pay -> retry round trip and returns the merchant response.",
+    selectionGuidance: "Prefer this over the quote+pay split when the agent just wants the paid resource and does not need to inspect the price first. If you already have a quote from haven_quote_x402, use haven_pay_x402_quote instead. Do not use for read-only allowance, budget, spend-limit, remaining-amount, reset-period, or what-can-I-spend questions; use the allowance lookup tool instead.",
+    behavior: "Calls the URL, parses any HTTP 402 x402 challenge, signs the payment locally, then retries the original request with the signed payment header (sent under PAYMENT-SIGNATURE, plus the legacy X-PAYMENT on the EIP-3009 path only) and returns the merchant response. Settlement is either direct account-to-merchant with no funding leg, or a bridge that first redeems the agent's budget delegation to fund the delegate wallet for an EIP-3009 authorization. A payment outside the on-chain budget is declined before any money moves; nothing is queued for a human to approve later. If the resource returns a non-402 status, returns it unchanged without contacting Haven.",
+    nextActionGuidance: "Preserve the returned resume_state or paymentId \u2014 either identifies this payment if you need to ask about it later. This tool performs the merchant retry itself, so do not wait on a signal while the call is in flight. If the process crashes after this call and a later haven_get_payment_status reports nextAction=retry_original_x402_request, Haven's funding leg confirmed but no merchant response was ever recorded \u2014 call the resume tool with the preserved resume_state or payment_id instead of paying again. If the response carries phase=insufficient_funds and nextAction=fund_safe_or_raise_allowance, the payment cannot be retried until the account is funded or the agent budget raised \u2014 stop and tell the user the shortfall reported on the response."
+  },
+  resumeX402: {
+    summary: "Resume an x402 payment whose Haven-side authorization already succeeded but whose merchant retry did not complete.",
+    behavior: "Accepts either resume_state or payment_id, validates the original x402 details against the authorized Haven funding, and retries the merchant request with the signed payment header (sent under PAYMENT-SIGNATURE, plus the legacy X-PAYMENT on the EIP-3009 path only). No new Haven payment is created.",
+    nextActionGuidance: "Only call this after haven_get_payment_status reports nextAction=retry_original_x402_request \u2014 that means Haven's funding leg confirmed but no merchant response was ever recorded, most often because the process crashed between funding and the merchant retry. Any other nextAction reports a conflict instead of retrying, so do not call this speculatively. Do not start a new merchant session and do not pay again \u2014 that would pay twice for one resource."
+  },
+  // #1328: quoteMpp / payMpp / resumeMpp (the mpp_demo challenge/quote/resume
+  // fragments) are retired along with the client surface they described —
+  // MACHINE-PAYMENT-CHALLENGE was never produced by anything besides the now
+  // deleted `/demo/mpp/*` route. Use the x402 fragments above instead.
+  getPaymentStatus: {
+    summary: "Fetch structured Haven payment status, including phase and nextAction taxonomy for agent recovery.",
+    behavior: "Accepts a payment intent id and returns the full state taxonomy (phase, nextAction, rail, amount, merchant, resource url, idempotency key, message).",
+    nextActionGuidance: ""
+  },
+  getResumeState: {
+    summary: "Rehydrate stored x402 resume_state by payment_id.",
+    behavior: "Returns the x402 context the agent originally received when the payment was authorized, reconstructed from Haven's database. This is context only; signing still happens locally when a resume tool is called.",
+    nextActionGuidance: ""
+  },
+  getAgent: {
+    summary: "Return the authenticated agent identity AND its live spend authority in one call: Haven wallet, delegate, chain, raw status, spend_authority_readiness, and per-token remaining allowance (atomic + human-readable). The recommended first call in a new session to confirm who you are and whether Haven will let you spend 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 live spend-authority snapshot in one shot \u2014 the agent's active on-chain budget delegation. spend_authority_readiness (readiness is a deprecated alias, same value) 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. It covers hosted identity + on-chain spend authority ONLY \u2014 the hosted server cannot see the LOCAL signer, so "ready" does not mean the signer can start; verify the signer with a signer tool call or connect --doctor. An over-budget payment is declined before any money moves: there is no approval queue, 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: "Returns the per-token spend authority for the account: the active budget delegation (remaining = the period budget, which re-arms natively at the period boundary). An over-budget payment is declined before any money moves; nothing queues. Configured amounts from Haven are returned alongside.",
+    nextActionGuidance: ""
+  },
+  listReceipts: {
+    summary: "List recent machine-payment receipts and evidence for bookkeeping.",
+    selectionGuidance: "Use this for transaction history, receipts, payment evidence, or bookkeeping; use the allowance tool instead for remaining allowance, budget, spend-limit, or what-can-I-spend questions.",
+    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 in one call.",
+    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.",
+    behavior: "Builds the JSON-RPC tools/call envelope, runs the MCP Streamable-HTTP initialize handshake automatically (if the endpoint is MCP-shaped), pays any HTTP 402 x402 challenge against the agent's on-chain budget delegation, and retries the request, returning the JSON-RPC result (the actual merchant output) on success. Amounts within the remaining on-chain budget execute automatically; anything outside it is declined before any money moves \u2014 follow the response's nextAction when present.",
+    nextActionGuidance: "On a decline, report the reason to the user and ask them to raise the budget in Haven \u2014 there is no approval queue to wait on. This tool retries the merchant itself while it runs, so do not wait on a signal mid-call. If the process crashes after payment, a later haven_get_payment_status call may report nextAction=retry_original_x402_request \u2014 resume via haven_resume_x402_payment instead of paying again."
+  },
+  discoverTools: {
+    summary: "Step 1 of a purchase: discover payable services from Haven's curated merchant catalog \u2014 names, prices, and which pay tool to use next.",
+    selectionGuidance: "Use this when the user asks what the agent can buy, pay for, or which paid services exist \u2014 or when you need a resource URL for a service the user described. Use verified=verified to show only self-submitted directory entries that passed domain-ownership proof and a live quote probe \u2014 never treat those badges as proof of merchant honesty, quality, or reliability. Do NOT use for balance, budget, or spend-limit questions \u2014 use haven_get_allowances. Do NOT use to pay \u2014 each returned entry names the pay tool to use next.",
+    behavior: "Use each entry's suggested_tool field first \u2014 it names the exact next call. Read-only lookup against Haven's curated catalog; entries are periodically re-verified against the live merchant and degraded entries are flagged. Use category for a case-insensitive category filter (for example, VPN or vpn), or search for a product name, category, or description term. Returns name, description, price, rail, resource URL, tool_name, tool_arguments, suggested_tool, and the provenance badges source/domain_verified/verified_payable. The catalog price (price_display/price_atomic, marked price_is_indicative) is a last-verified hint, NOT authoritative \u2014 the real price comes from the merchant's live 402 at pay time. Never creates a payment, signature, or approval.",
+    nextActionGuidance: `Pick an entry and pay it with the tool named in suggested_tool, passing the entry's resource_url, tool_name, and tool_arguments for MCP merchants. Confirm the price from the live pay-tool result (not the catalog), and pass the user's cap as max_amount_human in whole tokens ("no more than 1 USDC" \u2192 max_amount_human: "1") \u2014 never convert it to atomic units by hand.`
+  },
+  submitCatalogEntry: {
+    summary: "Submit a merchant's payable (x402/MCP) endpoint to Haven's Verified Payable Directory for verification and listing.",
+    selectionGuidance: "Use this when a merchant or seller asks to be listed in the directory, or when you have discovered a payable endpoint and want it registered. The submission is queue-only: it books a spot and returns a verify_token. The seller must then prove control of the domain (a well-known line or DNS TXT record); only after that plus a live quote probe does the entry become listed. Do NOT use to pay \u2014 check the returned status with getCatalogSubmissionStatus instead.",
+    behavior: "Sends the https resource_url to Haven's public submission endpoint. The request path makes no outbound request to the merchant. Returns id + verify_token + status; the verify_token is shown exactly once. Ownership proof is always required later and cannot be skipped from the agent side. The website field is a honeypot for bots \u2014 leave it unset.",
+    nextActionGuidance: "Give the verify_token and the well-known instructions (from getCatalogSubmissionStatus) to the merchant so they can publish the proof line, then poll the submission status until it reaches verified_payable or failed."
+  },
+  sweep_delegate: {
+    summary: "Sweep stranded USDC and/or ETH from the delegate wallet back to the originating Safe.",
+    selectionGuidance: "Use this when the user instructs you to recover stranded funds on the delegate wallet, or when a payment status returns nextAction=sweep_stranded_funds. Do NOT use for normal payments \u2014 use haven_pay_x402. Do NOT use to read balances only \u2014 use haven_get_allowances.",
+    behavior: `Reads the delegate EOA's on-chain USDC and ETH balances. For each non-zero balance, signs and submits a transfer from the delegate EOA to the originating Safe (hardcoded destination). The delegate key signs locally \u2014 Haven never sees it and the backend never constructs signed transactions (CASP/MiCA Red Line #2). Returns tx hashes and recovered amounts. Returns an empty transfers list when nothing is stranded. Each transfer carries confirmation: "confirmed" (a receipt was seen \u2014 the funds are in the Safe) or "unconfirmed" (broadcast but not confirmed within 90 seconds \u2014 still in the mempool, may still land). The top-level unconfirmed flag is true when any transfer is unconfirmed.`,
+    nextActionGuidance: 'If transfers is non-empty, confirm the amounts with the user. Report a transfer as recovered ONLY when its confirmation is "confirmed". For an "unconfirmed" transfer, tell the user it was submitted but not yet confirmed, give them its txHash and explorerUrl to check, and do not re-run the sweep immediately \u2014 a re-run after it lands will simply find nothing stranded.'
+  },
+  send: {
+    summary: "Send ETH or USDC directly from the agent's Haven wallet to a recipient address.",
+    selectionGuidance: "Use this for plain transfers \u2014 refunding a user, paying a freelancer, topping up a co-agent's wallet, or moving funds between addresses. Do NOT use for x402 paid endpoints \u2014 use haven_pay_x402 instead. Do NOT use for read-only allowance, budget, or what-can-I-spend questions \u2014 use haven_get_allowances.",
+    behavior: "Sends the requested amount by redeeming the agent's on-chain budget delegation, account to recipient with no funding leg. Budget, recipient and expiry are enforced on-chain while the transfer is prepared, so a request outside them is declined before any money moves and before the agent is asked to sign \u2014 it is never queued for a human to approve later. The agent's signing key signs the account's typed data; Haven never receives the key.",
+    nextActionGuidance: "On a decline, report the reason to the user and ask them to grant or raise the budget in Haven \u2014 there is nothing to poll and no approval will arrive. After a successful send, poll haven_get_payment_status until nextAction=none."
+  }
+};
+
+// src/tools.ts
+var makePaymentSchema = {
+  type: "object",
+  properties: {
+    token: {
+      type: "string",
+      description: "Token to send. Gnosis Chain: EURe, USDC.e, xDAI. Base: USDC, ETH."
+    },
+    amount: {
+      type: "string",
+      description: 'Amount to send as a decimal string, e.g. "5.00"'
+    },
+    to: {
+      type: "string",
+      description: "Recipient Ethereum address (0x...)"
+    },
+    reason: {
+      type: "string",
+      description: "Brief reason for this payment (for audit trail)"
+    }
+  },
+  required: ["token", "amount", "to", "reason"]
+};
+var getPaymentStatusSchema = {
+  type: "object",
+  properties: {
+    payment_id: {
+      type: "string",
+      description: "The payment ID returned from make_payment"
+    }
+  },
+  required: ["payment_id"]
+};
+var getAllowancesSchema = {
+  type: "object",
+  properties: {},
+  required: []
+};
+var authorizeX402Schema = {
+  type: "object",
+  properties: {
+    url: {
+      type: "string",
+      description: "The URL that returned HTTP 402"
+    },
+    payTo: {
+      type: "string",
+      description: "Payment recipient address from the 402 response"
+    },
+    amount: {
+      type: "string",
+      description: 'Payment amount in atomic units (e.g. "1000000" for 1 USDC)'
+    },
+    asset: {
+      type: "string",
+      description: "Token contract address from the 402 response"
+    },
+    network: {
+      type: "string",
+      description: 'CAIP-2 chain ID. "eip155:100" for Gnosis Chain, "eip155:8453" for Base.'
+    },
+    description: {
+      type: "string",
+      description: "Description of the resource being paid for"
+    },
+    idempotencyKey: {
+      type: "string",
+      description: "Stable caller-supplied key for this user intent. Reuse it when resuming the same payment."
+    }
+  },
+  required: ["url", "payTo", "amount", "asset", "network"]
+};
+var resumeX402Schema = {
+  type: "object",
+  properties: {
+    payment_id: {
+      type: "string",
+      description: "The payment ID returned by authorize_x402_payment."
+    },
+    url: {
+      type: "string",
+      description: "The original URL that returned HTTP 402."
+    },
+    payTo: {
+      type: "string",
+      description: "Payment recipient address from the original 402 response."
+    },
+    amount: {
+      type: "string",
+      description: "Payment amount in atomic units from the original 402 response."
+    },
+    asset: {
+      type: "string",
+      description: "Token contract address from the original 402 response."
+    },
+    network: {
+      type: "string",
+      description: "CAIP-2 chain ID or x402 network from the original 402 response."
+    },
+    description: {
+      type: "string",
+      description: "Description of the resource being paid for."
+    },
+    idempotencyKey: {
+      type: "string",
+      description: "Stable caller-supplied key used for the original authorization."
+    }
+  },
+  required: ["payment_id", "url", "payTo", "amount", "asset", "network"]
+};
+var MAKE_PAYMENT_DESCRIPTION = "Request and sign a payment from the user-controlled account within its on-chain budget. For read-only allowance, budget, spend-limit, remaining-amount, or reset-period questions, use get_allowances instead of making a payment. Haven authenticates the agent and relays the signed transaction that redeems the agent budget delegation; it does not hold keys or control funds. Gnosis Chain tokens: EURe, USDC.e, xDAI. Base tokens: USDC, ETH.";
+var GET_STATUS_DESCRIPTION = toolDescriptions.getPaymentStatus.summary + " Accepts payment intent IDs. Returns the current status, phase, next_action, transaction hash if available, and payment details.";
+var GET_ALLOWANCES_DESCRIPTION = composeDescription(toolDescriptions.getAllowances);
+var AUTHORIZE_X402_DESCRIPTION = composeDescription(toolDescriptions.payX402) + " In this SDK tool set, the allowance lookup tool is get_allowances. When a paid API returns x402 payment requirements, use this tool to sign with the agent-owned delegate key; funding, when the scheme needs it, is redeemed from the agent budget delegation and is bounded by it. Haven relays signed transactions only; the agent key authorizes payment and on-chain limits enforce spend. A payment outside the on-chain budget is declined before any money moves \u2014 report the decline and ask the user to raise the budget in Haven; do not loop retries and do not wait for an approval, because none is queued. Preserve the original merchant/MCP session and x402 details. On a manual HTTP retry always set PAYMENT-SIGNATURE (x402 v2) to the returned payment_header; a strict v2 merchant reads only that name. Also set X-PAYMENT (v1) on the EIP-3009 funding path for legacy merchants, but NEVER on erc7710 \u2014 that header carries a delegation chain and duplicating it is refused with HTTP 431.";
+var RESUME_X402_DESCRIPTION = toolDescriptions.resumeX402.summary + " Only call this after get_payment_status reports nextAction=retry_original_x402_request \u2014 that means Haven's funding leg confirmed but no merchant response was ever recorded (typically a crash between funding and the merchant retry). Any other nextAction reports a conflict instead of retrying \u2014 do not call this speculatively, and do not pay again.";
+var SWEEP_DELEGATE_DESCRIPTION = composeDescription(toolDescriptions.sweep_delegate);
+var sweepDelegateSchema = {
+  type: "object",
+  properties: {},
+  required: []
+};
+function claudeTools() {
+  return [
+    {
+      name: "make_payment",
+      description: MAKE_PAYMENT_DESCRIPTION,
+      input_schema: makePaymentSchema
+    },
+    {
+      name: "get_payment_status",
+      description: GET_STATUS_DESCRIPTION,
+      input_schema: getPaymentStatusSchema
+    },
+    {
+      name: "get_allowances",
+      description: GET_ALLOWANCES_DESCRIPTION,
+      input_schema: getAllowancesSchema
+    },
+    {
+      name: "authorize_x402_payment",
+      description: AUTHORIZE_X402_DESCRIPTION,
+      input_schema: authorizeX402Schema
+    },
+    {
+      name: "resume_x402_payment",
+      description: RESUME_X402_DESCRIPTION,
+      input_schema: resumeX402Schema
+    },
+    {
+      name: "haven_sweep_delegate",
+      description: SWEEP_DELEGATE_DESCRIPTION,
+      input_schema: sweepDelegateSchema
+    }
+  ];
+}
+function openaiTools() {
+  return [
+    {
+      type: "function",
+      function: {
+        name: "make_payment",
+        description: MAKE_PAYMENT_DESCRIPTION,
+        parameters: makePaymentSchema
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "get_payment_status",
+        description: GET_STATUS_DESCRIPTION,
+        parameters: getPaymentStatusSchema
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "get_allowances",
+        description: GET_ALLOWANCES_DESCRIPTION,
+        parameters: getAllowancesSchema
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "authorize_x402_payment",
+        description: AUTHORIZE_X402_DESCRIPTION,
+        parameters: authorizeX402Schema
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "resume_x402_payment",
+        description: RESUME_X402_DESCRIPTION,
+        parameters: resumeX402Schema
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "haven_sweep_delegate",
+        description: SWEEP_DELEGATE_DESCRIPTION,
+        parameters: sweepDelegateSchema
+      }
+    }
+  ];
+}
+var havenTools = {
+  /** Tool definitions in Anthropic/Claude format */
+  claude: claudeTools,
+  /** Tool definitions in OpenAI function-calling format */
+  openai: openaiTools
+};
+
+// src/skill-content.ts
+var HAVEN_SKILL_MD = `---
+name: haven-pay
+description: Pay for things from the user's Haven wallet within their agent rules. Use when the user asks to send, pay, tip, or transfer crypto \u2014 or when a request hits an HTTP 402 (x402) paywall.
+---
+
+# Haven: pay from a Haven wallet
+
+This skill lets the agent make payments from the user's Haven wallet through
+the Haven MCP tools. Every payment is checked against the agent's on-chain
+budget before money moves; a payment above the remaining budget is declined \u2014
+nothing is paid past the rules the user set.
+
+Hosted tools run in the \`mcp__haven__\` namespace. Local signing tools run in
+the \`mcp__haven-signer__\` namespace and keep the delegate key on this machine.
+That namespacing is Claude-family; other runtimes name the servers by their
+own config keys (Codex: \`haven\`, \`haven_signer\`). Tool results carry the
+exact next step (\`next_action\`, \`next_tool\`, \`next_arguments\`, plus the
+runtime-neutral \`next_tool_server\` + \`next_tool_name\` \u2014 the bare tool name
+on that logical server, whatever your runtime calls it).
+Follow those fields first; the prose below is fallback and orientation, not
+the source of truth.
+
+## When to use this skill
+
+- The user asks to send money, pay someone, tip, donate, or transfer tokens.
+- A request returns HTTP 402 (x402): use the Haven pay tools to settle it,
+  then retry the original request.
+
+## Identity and budget
+
+Do not guess the wallet address, network, or budget.
+
+For instant orientation at the start of a session, read the non-secret
+\`agent.json\` the connector wrote to your Haven credential directory (typically
+\`~/.haven/agents/<agent-id>/agent.json\` \u2014 if you don't know the agent id, list
+\`~/.haven/agents/\` to find the folder). It
+holds your agent id, Haven wallet address, network, and *configured* per-token
+budget, and contains no keys \u2014 the fastest way to answer "who am I and what may
+I spend" with no round trip. If that file is absent (some setups don't write
+it), use the tools below instead.
+
+Before any payment, confirm the *live remaining* budget with the tools \u2014
+\`agent.json\` shows the configured budget, not what is left after recent
+spending:
+
+- \`mcp__haven__haven_get_agent\` \u2014 the recommended first call: identity
+  (wallet, network) plus \`spend_authority_readiness\` (\`ready\` / \`needs_approval\` /
+  \`revoked\`) and live remaining per-token allowance, in one shot. That signal
+  covers hosted identity and on-chain spend authority only \u2014 it cannot see the
+  local signer; the signer is verified by calling any signer tool.
+- \`mcp__haven__haven_get_allowances\` \u2014 detailed per-token breakdown
+  (configured, spent, reset window) when you need more than the summary.
+
+Budgets reset on a period the user chose. If a payment exceeds the remaining
+budget it is declined before any money moves \u2014 tell the user; they can raise
+the budget in the Haven dashboard, or wait for the period reset.
+
+## Paying
+
+**Catalog purchases \u2014 the primary path for MCP merchants:**
+
+1. \`mcp__haven__haven_discover_tools\` to find a payable service and its
+   \`catalog_id\`.
+2. If the user needs the live price before authorizing a cap, call
+   \`mcp__haven__haven_quote_catalog_purchase\` with \`catalog_id\`. It is
+   read-only and informational only: it never reserves a price or creates a
+   payment. Tell the user its \`amount\` / \`amount_atomic\`, then choose a cap.
+3. \`mcp__haven__haven_prepare_catalog_purchase\` with \`catalog_id\` and a
+   spending cap. A cap is REQUIRED on this tool and is best practice on every
+   paid call below too \u2014 it caps what the LIVE merchant quote may charge,
+   checked before any funding intent is created. Write it the way the user
+   said it: \`max_amount_human\` is whole tokens, so "no more than 1 USDC" is
+   \`max_amount_human: "1"\`. (\`max_amount\` is the atomic-unit form, where
+   "1" means 0.000001 USDC \u2014 do not convert by hand, and never send both.)
+4. Then FOLLOW THE RESPONSE'S GUIDANCE FIELDS: \`next_action\`, \`next_tool\`,
+   and \`next_arguments\` name the exact next call \u2014 act on those first; the
+   prose in this section is fallback and debugging detail. If the catalog
+   entry is missing or degraded, the response instead names
+   \`mcp__haven__haven_pay_mcp_tool\` (merchant URL, tool name, arguments) as
+   the manual fallback.
+
+**Signing:** \`mcp__haven-signer__haven_sign_x402\` with \`payment_id\` ONLY \u2014
+the local signer fetches the exact signing bytes AND \`payment_required\`
+itself, so never relay \`typed_data\` or the 402 blob yourself. If the signer
+reports its fetched context carried no \`payment_required\` (older backend),
+re-call with \`payment_required\` added verbatim. Fallback for an older signer
+or backend: re-run the quote/prepare tool with the SAME \`idempotency_key\`
+plus \`include_signing_payload=true\`, then pass \`payload_hash\`,
+\`x402_expected\` (the nested \`x402.expected\` object), and
+\`typed_data\`/\`typed_data_b64\` through unchanged.
+
+**Settle:** \`mcp__haven__haven_settle_mcp_tool\` with \`payment_id\`,
+\`signature\`, and \`payment_header\` ONLY \u2014 Haven rehydrates the merchant call
+context (\`merchant_url\`, \`tool_name\`, \`arguments\`, \`mcp_transport\`)
+server-side from \`payment_id\`. Pass those four fields explicitly only as a
+version-skew fallback when Haven has no stored context for the id \u2014 both or
+none together, never just one. If the settle result carries \`settled: false\`,
+funding has not confirmed \u2014 follow the result's guidance fields and check
+status later, do not re-pay.
+
+Step-by-step alternative (also key-safe; for an older signer or backend, or
+when you already have a merchant URL and tool name instead of a
+\`catalog_id\`): if the user needs the live price before choosing a cap, first
+call \`mcp__haven__haven_quote_mcp_tool\` with that merchant URL, tool name,
+and arguments. It is informational only; then call
+\`mcp__haven__haven_pay_mcp_tool\` with the same inputs and the explicit cap.
+The paid call always obtains a fresh quote before it creates any intent. Then
+continue \`mcp__haven__haven_pay_mcp_tool\` \u2192
+\`mcp__haven-signer__haven_sign\` \u2192 \`mcp__haven__haven_submit\` \u2192
+\`mcp__haven-signer__haven_x402_sign_header\` \u2192
+\`mcp__haven__haven_complete_mcp_tool\`. Call that last step with
+\`payment_id\` and the signer's \`payment_header\` ONLY. It does not take
+\`payment_required\`: Haven rehydrates the merchant call context
+(\`merchant_url\`, \`tool_name\`, \`arguments\`, \`mcp_transport\`) and the
+402 server-side from \`payment_id\`, exactly as at settle. Pass that context
+explicitly only as a version-skew fallback when Haven has no stored context
+for the id \u2014 \`merchant_url\` and \`tool_name\` both or none together, never
+just one.
+The returned \`expires_at\` is the signing window; if a tool returns
+\`PAYMENT_WINDOW_EXPIRED\`, re-run the same quote/prepare tool with the same
+\`idempotency_key\`. Do not call the merchant yourself \u2014 Haven completes the
+merchant leg for you.
+
+**Direct transfer / non-MCP paywall:** \`mcp__haven__haven_pay\` with
+\`to\`, \`amount\`, and \`token\` for a plain transfer. For an arbitrary,
+non-MCP x402 paywall: \`mcp__haven__haven_quote_x402\` to get a quote, then
+\`mcp__haven__haven_pay_x402_quote\` \u2014 follow the result's guidance fields
+first and sign in the local Haven signer. On THIS path Haven does not talk to
+the merchant: \`mcp__haven-signer__haven_sign_x402\` returns both
+\`signature\` and \`payment_header\`; relay \`signature\` with
+\`mcp__haven__haven_submit\`, then retry the paywalled URL yourself with
+\`payment_header\`. Do not pass that call's \`x402_binding\` to
+\`mcp__haven-signer__haven_x402_sign_header\` \u2014 the one-shot already spent it
+building the header, so the call can only refuse. Then tell Haven what the
+merchant answered: \`mcp__haven__haven_report_x402_outcome\` with the
+\`payment_id\`, \`outcome\` (\`"accepted"\` for a 2xx, else \`"rejected"\`)
+and the \`merchant_status\` you got. Because Haven never contacted that
+merchant, this is the only way it can learn the purchase failed \u2014 without it a
+failed purchase reads as complete for fifteen minutes. (The SDK's own
+\`haven_pay_x402\` tool does perform the merchant retry itself; that tool is
+not part of the hosted MCP surface.) If the process
+crashes after payment, a later \`mcp__haven__haven_get_payment_status\` call
+may report \`nextAction: 'retry_original_x402_request'\` \u2014 only then call
+\`mcp__haven__haven_resume_x402_payment\` with the preserved resume state or
+payment id, instead of paying again.
+
+**Catalog tool arguments:** when \`haven_discover_tools\` returns
+\`tool_arguments\`, pass that object unchanged as the pay tool's
+\`arguments\` field (for example
+\`tool_arguments: { "tier": "50gb" }\` -> \`arguments: { "tier": "50gb" }\`).
+
+**Prices:** show the user the live price from a read-only quote or the pay-tool
+result, never a catalog price. \`haven_discover_tools\` prices are indicative
+(\`price_is_indicative\`) and can be stale. A read-only quote is informational
+only and does not reserve a price; the later paid call re-quotes and enforces
+the cap. The pay-tool result's \`amount\` / \`amount_atomic\` is the merchant's
+own quoted price for that call \u2014 a ceiling the merchant settles at or below \u2014
+so present it as the most the user will pay. It is a price, not an approval:
+the payment goes through only if it also fits the cap you set and the on-chain
+budget the user signed, which is enforced on-chain rather than by Haven.
+
+**Status:** \`mcp__haven__haven_get_payment_status\` with a \`payment_id\` to
+check on in-flight payments. Do not poll in a tight loop.
+
+## Declines and stop signals
+
+- A payment outside the agent's rules \u2014 above the remaining budget, wrong
+  recipient, or expired budget \u2014 is declined before any money moves. Nothing
+  is queued; tell the user, who can raise the budget in Haven.
+- \`safe_to_continue: false\` on a guidance block is a stop signal in
+  machine-readable form: stop and involve the user before calling anything
+  else for this payment.
+- Never ask the user for private keys. Signing happens only in the local Haven
+  signer; the hosted Haven tools never receive the signing key. If a tool
+  reports a missing or invalid credential, tell the user to re-run the Haven
+  setup command.
+
+## Failure handling
+
+Haven tool failures are shaped like \`{ success: false, code, message, ... }\`
+or older \`{ error, status, details? }\` responses. Branch on \`code\` when
+present and surface \`message\` or \`error\` verbatim. Common cases:
+
+- \`insufficient_funds\`: the Haven wallet doesn't hold enough of that token.
+  Suggest the user add funds in the Haven dashboard.
+- \`PRICE_EXCEEDS_MAX\`: the live merchant price exceeded your cap. No funds
+  moved; ask the user before retrying with a higher one.
+- \`AMBIGUOUS_MAX_AMOUNT\`: you sent both \`max_amount\` and
+  \`max_amount_human\`. Nothing was contacted or spent \u2014 re-send with exactly
+  one (\`max_amount_human\` for a cap the user stated in tokens).
+- \`MAX_AMOUNT_UNCONVERTIBLE\`: \`max_amount_human\` does not fit this quote's
+  asset \u2014 unknown decimals, or more decimal places than the asset supports.
+  Round the cap, or send an exact atomic \`max_amount\`.
+- \`PAYMENT_WINDOW_EXPIRED\`: re-run the quote/prepare tool with the same
+  \`idempotency_key\`, then sign the fresh payload.
+- \`MERCHANT_REJECTED_AFTER_FUNDING\`: the merchant refused the paid retry.
+  Stop-and-sweep \u2014 stop retrying the merchant and use
+  \`mcp__haven__haven_sweep_delegate\` to recover stranded delegate funds.
+- \`MERCHANT_UNRESPONSIVE_AFTER_FUNDING\`: funding confirmed on-chain, but the
+  merchant never answered the paid retry. This is NOT proof of rejection \u2014 the
+  merchant may still settle late. Verify-then-sweep, never a blind sweep:
+  check \`mcp__haven__haven_get_payment_status\`, retry
+  \`mcp__haven__haven_complete_mcp_tool\` ONCE, and only sweep with
+  \`mcp__haven__haven_sweep_delegate\` if no settlement appears.
+- Budget exceeded: tell the user how much remains (from
+  \`mcp__haven__haven_get_allowances\`) and that they can raise the budget in
+  Haven.
+
+## Reporting after a purchase
+
+A settled \`mcp__haven__haven_settle_mcp_tool\` response carries
+\`agent_summary.purchase_summary\` and the remaining post-purchase allowance
+in \`allowance\` \u2014 report the product, Haven-derived payment/transaction
+fields, and what is left from those fields directly. \`result\` is optional
+raw merchant evidence; never use it to decide whether the purchase was paid.
+Do not call \`haven_get_agent\` or \`haven_get_allowances\` again just to
+report a purchase you already made.
+
+## Revoke
+
+If this agent's credential may have leaked, tell the user to pause or revoke
+the agent in the Haven dashboard under Agents. New requests stop immediately
+for that credential.
+`;
+var SKILL_FOLDER_NAME = "haven-pay";
+var HAVEN_SKILL_BODY_MD = HAVEN_SKILL_MD.replace(/^---\n[\s\S]*?\n---\n+/, "");
+
+// src/node-version.ts
+var HAVEN_MINIMUM_NODE_VERSION = "22.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/merchant-discovery.ts
+var MERCHANT_DISCOVERY_PATHS = ["/.well-known/haven-demo-merchant", "/"];
+var DISCOVERY_MAX_BYTES = 64 * 1024;
+async function discoverMerchantMcpUrl(inputUrl) {
+  let input;
+  try {
+    input = new URL(inputUrl);
+  } catch {
+    return null;
+  }
+  for (const path of MERCHANT_DISCOVERY_PATHS) {
+    try {
+      const res = await globalThis.fetch(`${input.origin}${path}`, {
+        method: "GET",
+        headers: { accept: "application/json" },
+        redirect: "error",
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) continue;
+      const contentLength = Number(res.headers.get("content-length") ?? 0);
+      if (contentLength > DISCOVERY_MAX_BYTES) continue;
+      const text = await res.text();
+      if (text.length > DISCOVERY_MAX_BYTES) continue;
+      const doc = JSON.parse(text);
+      if (typeof doc.mcp_url !== "string") continue;
+      const resolved = new URL(doc.mcp_url);
+      if (resolved.origin !== input.origin) continue;
+      return resolved.toString();
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function sameUrl(a, b) {
+  try {
+    const ua = new URL(a);
+    const ub = new URL(b);
+    return ua.origin === ub.origin && ua.pathname.replace(/\/+$/, "") === ub.pathname.replace(/\/+$/, "");
+  } catch {
+    return false;
+  }
+}
+
+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, AgentPaymentWarningCode, CONNECTOR_PACKAGE_NAME, DEFAULT_CONFIRMATION_TIMEOUT_MS, DISCOVERY_MAX_BYTES, ERC7710_ASSET_TRANSFER_METHOD, HAVEN_CONNECTOR_CHANNEL, HAVEN_MINIMUM_NODE_VERSION, HAVEN_SKILL_BODY_MD, HAVEN_SKILL_MD, HavenApiError, HavenClient, HavenError, HavenPaymentStateError, HavenSigningError, HavenTimeoutError, HavenUnsupportedSignerVersionError, MERCHANT_DISCOVERY_PATHS, MerchantTimeoutError, RECEIPT_VERSION, SIGNER_UPDATE_FALLBACK, SKILL_FOLDER_NAME, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_SEPOLIA_CHAIN_ID, SWEEP_BASE_SEPOLIA_USDC_ADDRESS, SWEEP_BASE_USDC_ADDRESS, SignerRefusalCode, TRANSFER_WITH_AUTHORIZATION_TYPES, X402AlreadySettledError, X402PaymentHeaderValidationError, X402UnexpectedStatusError, X402_LEGACY_PAYMENT_HEADER_NAME, X402_MAX_AUTHORIZATION_WINDOW_SECONDS, X402_PAYMENT_HEADER_NAME, X402_PAYMENT_HEADER_NAMES_SENT, X402_PAYMENT_REQUIRED_HEADER_NAME, X402_PAYMENT_RESPONSE_HEADER_NAME, X402_SETTLEMENT_FORWARD_MARGIN_SECONDS, addressFromKey, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, compareNodeVersions, composeDescription, connectorRerunCommand, connectorSpec, decodeBase64Json, decodeBase64Utf8, discoverMerchantMcpUrl, encodeBase64Json, encodeBase64Utf8, encodePaymentProof, havenTools, isConnectorChannel, isErc7710Option, isSupportedNodeVersion, isSweepableChain, normalizePaymentRequired, parsePaymentRequired, parsePaymentRequiredResponse, resolveConnectorChannel, resolveTokenFromAddress, sameUrl, selectErc7710PaymentOption, selectPaymentOption, selectStandardPaymentOption, selectX402SettlementScheme, signHash, signUserOpTypedDataForDelegation, signerUpdateFallback, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, toolDescriptions, unsupportedNodeVersionMessage, validateStandardX402PaymentHeader, verifyPaymentReceipt, verifySignature, x402AssetTransferMethod, x402AuthorizationAmount, x402FacilitatorAddresses, x402V2PaymentEnvelope };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map