@haven_ai/sdk 0.4.0-alpha.0 → 0.5.0-alpha.1

package/dist/chunk-GLNG2GF7.js

@@ -0,0 +1,903 @@
+import { pad, keccak256, encodeAbiParameters, getAddress, encodeFunctionData, encodeDeployData, getContractAddress, decodeFunctionData, decodeAbiParameters, isAddress } from 'viem';
+
+// src/connector-channel.ts
+var CONNECTOR_PACKAGE_NAME = "@haven_ai/connect";
+var HAVEN_CONNECTOR_CHANNEL = "alpha";
+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 account 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.
+   *
+   * #2914: the account-vocabulary spelling, and the only one — the
+   * pre-#2907 `fund_safe_or_raise_allowance` wire value (and the
+   * `AgentPaymentNextActionAccountAlias` seam #2908 added to bridge it) are
+   * retired along with the rest of the #2908 compatibility window.
+   */
+  FundAccountOrRaiseAllowance: "fund_account_or_raise_allowance",
+  /**
+   * The delegate wallet may hold funds that were sent from the agent's Haven
+   * account but never settled to the merchant. The wallet owner should initiate
+   * a sweep to return those funds to that account.
+   */
+  SweepStrandedFunds: "sweep_stranded_funds",
+  /**
+   * #2970: a `submitted` erc7710 x402 intent whose settlement window has
+   * passed with no on-chain settlement evidence Haven could verify. Distinct
+   * from {@link CheckStatusLater}, which this REPLACES once the window is
+   * past — but it is not futile: Haven's settlement sweep (120s tick) scans
+   * each candidate over its own window plus a 120s clock-skew allowance, so
+   * it can still attribute the settlement for a short while after this value
+   * first appears. Poll {@link CheckStatusLater}'s tool
+   * (`haven_get_payment_status`) once more, roughly two minutes later; if it
+   * still shows no evidence, tell the user the goods were delivered but
+   * Haven holds no verified settlement evidence for this payment. If the
+   * agent holds the merchant's real settlement transaction hash (from
+   * `PAYMENT-RESPONSE`'s `transaction` field, or a prior settle/complete
+   * result's `settlement_tx_hash`), report it with the hosted
+   * `haven_report_settlement_evidence` tool instead of waiting —
+   * `haven_report_x402_outcome` takes no hash and refuses a non-`confirmed`
+   * intent.
+   */
+  AwaitingSettlementEvidence: "awaiting_settlement_evidence"
+};
+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 merchant rejected the paid retry. On eip3009 the funding leg had succeeded (sweep);
+   *  on erc7710 there is no funding leg — nothing to sweep, follow the message (#2983). */
+  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
+   *  may still settle late, so the guidance is verify-then-act. On eip3009
+   *  the funding leg had succeeded (verify-then-sweep); on erc7710 there is
+   *  no funding leg — nothing to sweep, follow the message (#3000). */
+  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",
+  /**
+   * #2979: the merchant answered a `tools/call` probe with its own
+   * machine-readable "cannot settle right now" refusal (HTTP 503,
+   * `{ error: 'merchant_not_ready', reason_code, ... }`) instead of a 402
+   * challenge — e.g. its settlement wallet is out of gas. No 402 was ever
+   * issued and no payment was created; this is honest and (per
+   * `retry_after_s`, when present) usually transient, unlike a permanent
+   * endpoint miss.
+   */
+  MerchantNotReady: "MERCHANT_NOT_READY"
+};
+var AgentPaymentRail = {
+  /** Standard Haven payment from the user's account, redeemed through the agent's budget delegation. */
+  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.FundAccountOrRaiseAllowance]: "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.",
+  [AgentPaymentNextAction.AwaitingSettlementEvidence]: "The settlement window passed with no verified on-chain evidence yet. If you hold the merchant's real settlement transaction hash, report it with haven_report_settlement_evidence. Otherwise, Haven's settlement sweep may still attribute it within about two minutes \u2014 poll getPaymentStatus once more, then tell the user the goods were delivered but unverified if it still shows nothing."
+};
+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 merchant rejected the paid retry. eip3009: the funding leg succeeded \u2014 stop retrying the merchant and reconcile stranded delegate funds with haven_sweep_delegate. erc7710: no funding leg, nothing to sweep \u2014 follow the message (re-quote later, or check haven_get_payment_status after the window first).",
+  [AgentPaymentFailureCode.MerchantUnresponsiveAfterFunding]: "The merchant did not answer the paid retry before the timeout. The merchant may still settle late. eip3009: the funding leg succeeded \u2014 check haven_get_payment_status, retry haven_complete_mcp_tool once, sweep only if no settlement appears. erc7710: no funding leg, nothing to sweep, and haven_complete_mcp_tool has no erc7710 branch \u2014 do not retry it; check haven_get_payment_status after the payment window and re-quote only if it shows no settlement.",
+  [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.",
+  [AgentPaymentFailureCode.MerchantNotReady]: 'The merchant refused the probe with its own "cannot settle right now" signal instead of a 402 challenge. No payment was created. Often transient \u2014 retry later (see retry_after_s in the message, if given) rather than treating this as a broken or wrong endpoint.'
+};
+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",
+  /**
+   * #2991: the quote tools' `expected_settlement_scheme` prediction of what
+   * `haven_prepare_catalog_purchase` / `haven_pay_mcp_tool` will actually
+   * select could not be computed — the agent's execution rail could not be
+   * read from Haven, so `expected_settlement_scheme` is `null` rather than a
+   * guess. `accepted_scheme` (the merchant's offer) is unaffected.
+   */
+  X402SchemeUnknown: "X402_SCHEME_UNKNOWN",
+  /**
+   * #2968: the merchant answered 200 and handed over goods, but Haven holds NO
+   * on-chain evidence that the payment moved. `settled: false` beside this code
+   * is not a failure — it is the absence of proof, and the two must travel
+   * together so an agent can tell "the user has the goods" apart from "the
+   * money moved". Carries the intent's `expires_at`: after that instant the
+   * settlement can no longer land at all.
+   */
+  SettlementUnconfirmed: "SETTLEMENT_UNCONFIRMED"
+};
+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";
+  /**
+   * #2979: `body` is the merchant's own JSON, when the non-402 response
+   * carried one — e.g. the demo merchant's `/mcp` readiness gate answers
+   * `503 { error: 'merchant_not_ready', reason_code, ... }`. Optional and
+   * best-effort: a non-JSON or unreadable body leaves this `undefined`, same
+   * as before this field existed. Consumers key on it (not on the message
+   * string) to distinguish an honest, machine-readable merchant refusal from
+   * a genuine "this is not the x402 endpoint" miss, which otherwise look
+   * identical — both are just "some non-402 status".
+   */
+  constructor(message, statusCode, body) {
+    super(message, statusCode, body);
+    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 HavenZeroSettlementHashError = class extends HavenError {
+  constructor(paymentId) {
+    super(
+      "settlement_tx_hash is the zero hash (0x00\u202600), which is never a real settlement transaction \u2014 refused before any report was sent.",
+      "ZERO_SETTLEMENT_HASH",
+      400,
+      paymentId
+    );
+    this.name = "HavenZeroSettlementHashError";
+  }
+};
+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";
+  }
+};
+var DIRECT_SIGN_CONTEXT_VERSION = 1;
+var EIP712_DOMAIN_FIELDS = [
+  { name: "name", type: "string" },
+  { name: "version", type: "string" },
+  { name: "chainId", type: "uint256" },
+  { name: "verifyingContract", type: "address" }
+];
+var ENTRY_POINT_V07 = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+var HYBRID_DELEGATOR_DOMAIN_NAME = "HybridDeleGator";
+var HYBRID_DELEGATOR_DOMAIN_VERSION = "1";
+var PACKED_USER_OPERATION_FIELDS = [
+  { name: "sender", type: "address" },
+  { name: "nonce", type: "uint256" },
+  { name: "initCode", type: "bytes" },
+  { name: "callData", type: "bytes" },
+  { name: "accountGasLimits", type: "bytes32" },
+  { name: "preVerificationGas", type: "uint256" },
+  { name: "gasFees", type: "bytes32" },
+  { name: "paymasterAndData", type: "bytes" },
+  { name: "entryPoint", type: "address" }
+];
+var HavenUserOpBindingError = class extends HavenError {
+  constructor(message) {
+    super(message, "USEROP_BINDING_MISMATCH");
+    this.name = "HavenUserOpBindingError";
+  }
+};
+function isPackedUserOperationTypedData(value) {
+  return typeof value === "object" && value !== null && value.primaryType === "PackedUserOperation";
+}
+var HEX = /^0x[0-9a-fA-F]*$/;
+var BYTES32 = /^0x[0-9a-fA-F]{64}$/;
+function refuse(detail) {
+  throw new HavenUserOpBindingError(
+    `Refusing to sign: this UserOperation typed data does not match its payload_hash (${detail}). The payload was altered between the Haven result and this call \u2014 sign by payment_id so the signer fetches the exact bytes, or pass typed_data_b64 from the result unchanged.`
+  );
+}
+function hexField(message, key, pattern) {
+  const value = message[key];
+  if (typeof value !== "string" || !pattern.test(value)) refuse(`message.${key} is not well-formed`);
+  return value;
+}
+function uintField(message, key) {
+  const value = message[key];
+  try {
+    if (typeof value === "bigint") return value;
+    if (typeof value === "string" && /^(0x[0-9a-fA-F]+|[0-9]+)$/.test(value) || typeof value === "number") {
+      const n = BigInt(value);
+      if (n >= 0n) return n;
+    }
+  } catch {
+  }
+  return refuse(`message.${key} is not an unsigned integer`);
+}
+function addressField(value, where) {
+  if (typeof value !== "string" || !isAddress(value, { strict: false })) refuse(`${where} is not an address`);
+  return getAddress(value);
+}
+function packedUserOperationHash(typedData) {
+  if (!isPackedUserOperationTypedData(typedData)) refuse("primaryType is not PackedUserOperation");
+  const td = typedData;
+  const message = td.message;
+  if (!message || typeof message !== "object") refuse("message is missing");
+  const chainId = uintField({ chainId: td.domain?.chainId }, "chainId");
+  const inner = keccak256(
+    encodeAbiParameters(
+      [
+        { type: "address" },
+        { type: "uint256" },
+        { type: "bytes32" },
+        { type: "bytes32" },
+        { type: "bytes32" },
+        { type: "uint256" },
+        { type: "bytes32" },
+        { type: "bytes32" }
+      ],
+      [
+        addressField(message.sender, "message.sender"),
+        uintField(message, "nonce"),
+        keccak256(hexField(message, "initCode", HEX)),
+        keccak256(hexField(message, "callData", HEX)),
+        hexField(message, "accountGasLimits", BYTES32),
+        uintField(message, "preVerificationGas"),
+        hexField(message, "gasFees", BYTES32),
+        keccak256(hexField(message, "paymasterAndData", HEX))
+      ]
+    )
+  );
+  return keccak256(
+    encodeAbiParameters(
+      [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
+      [inner, addressField(message.entryPoint, "message.entryPoint"), chainId]
+    )
+  );
+}
+function assertUserOpTypedDataBinding(typedData, payloadHash) {
+  if (typeof payloadHash !== "string" || !BYTES32.test(payloadHash)) refuse("payload_hash is not a 32-byte hex string");
+  if (!isPackedUserOperationTypedData(typedData)) refuse("primaryType is not PackedUserOperation");
+  const td = typedData;
+  const domain = td.domain ?? {};
+  const message = td.message ?? {};
+  if (domain.name !== HYBRID_DELEGATOR_DOMAIN_NAME) refuse("domain.name is not HybridDeleGator");
+  if (domain.version !== HYBRID_DELEGATOR_DOMAIN_VERSION) refuse("domain.version is not 1");
+  if (addressField(domain.verifyingContract, "domain.verifyingContract") !== addressField(message.sender, "message.sender")) {
+    refuse("domain.verifyingContract is not message.sender");
+  }
+  if (addressField(message.entryPoint, "message.entryPoint") !== getAddress(ENTRY_POINT_V07)) {
+    refuse("message.entryPoint is not the v0.7 EntryPoint");
+  }
+  const fields = (td.types ?? {}).PackedUserOperation;
+  if (!Array.isArray(fields) || fields.length !== PACKED_USER_OPERATION_FIELDS.length || fields.some(
+    (f, i) => !f || f.name !== PACKED_USER_OPERATION_FIELDS[i].name || f.type !== PACKED_USER_OPERATION_FIELDS[i].type
+  )) {
+    refuse("types.PackedUserOperation is not the HybridDeleGator field list");
+  }
+  const extraTypes = Object.keys(td.types ?? {}).filter((k) => k !== "PackedUserOperation" && k !== "EIP712Domain");
+  if (extraTypes.length > 0) refuse(`unexpected types: ${extraTypes.join(", ")}`);
+  const domainKeys = Object.keys(domain).sort();
+  if (domainKeys.join(",") !== [...EIP712_DOMAIN_FIELDS.map((f) => f.name)].sort().join(",")) {
+    refuse(`domain keys are not exactly ${EIP712_DOMAIN_FIELDS.map((f) => f.name).join(", ")}`);
+  }
+  const declaredDomain = (td.types ?? {}).EIP712Domain;
+  if (declaredDomain !== void 0 && (!Array.isArray(declaredDomain) || declaredDomain.length !== EIP712_DOMAIN_FIELDS.length || declaredDomain.some(
+    (f, i) => !f || f.name !== EIP712_DOMAIN_FIELDS[i].name || f.type !== EIP712_DOMAIN_FIELDS[i].type
+  ))) {
+    refuse("types.EIP712Domain is not the canonical name/version/chainId/verifyingContract list");
+  }
+  const recomputed = packedUserOperationHash(typedData);
+  if (recomputed.toLowerCase() !== payloadHash.toLowerCase()) refuse("recomputed UserOperation hash differs");
+  return recomputed;
+}
+
+// src/settlement-child.ts
+var DELEGATION_MANAGER = "0xdb9B1e94B5b69Df7e401DDbedE43491141047dB3";
+var CAVEAT_ENFORCERS = {
+  erc20TransferAmount: "0xf100b0819427117EcF76Ed94B358B1A5b5C6D2Fc",
+  allowedCalldata: "0xc2b0d624c1c4319760C96503BA27C347F3260f55",
+  timestamp: "0x1046bb45C8d673d4ea75321280DB34899413c069",
+  redeemer: "0xE144b0b2618071B4E56f746313528a669c7E65c5"
+};
+var MAX_SETTLEMENT_WINDOW_SECONDS = 600;
+function isSettlementChildTypedData(value) {
+  const td = value;
+  return !!td && td.primaryType === "Delegation" && typeof td.domain?.verifyingContract === "string" && Array.isArray(td.message?.caveats);
+}
+function same(a, b) {
+  return !!a && !!b && a.toLowerCase() === b.toLowerCase();
+}
+function hex(value) {
+  return value.startsWith("0x") ? value.slice(2).toLowerCase() : value.toLowerCase();
+}
+function slice(terms, start, end) {
+  const body = hex(terms);
+  return end === void 0 ? body.slice(start * 2) : body.slice(start * 2, end * 2);
+}
+function findCaveat(caveats, enforcer) {
+  return caveats.find((c) => same(c.enforcer, enforcer));
+}
+function refuse2(what, detail) {
+  throw new HavenSigningError(
+    `Refusing to sign the x402 settlement child: ${what}. ${detail} The signature on this child is what lets a merchant pull from the treasury, so it is verified locally against an expectation Haven cannot rewrite, rather than trusted.`
+  );
+}
+function chainIdForNetwork(network) {
+  if (!network) return void 0;
+  const caip = /^eip155:(\d+)$/.exec(network);
+  if (caip) return Number(caip[1]);
+  if (network === "base") return 8453;
+  if (network === "base-sepolia") return 84532;
+  return void 0;
+}
+var ROOT_AUTHORITY = `0x${"ff".repeat(32)}`;
+function verifySettlementChild(typedData, expected, now = Date.now()) {
+  if (typedData.primaryType !== "Delegation") {
+    refuse2("it is not a Delegation payload", `primaryType was '${typedData.primaryType}'.`);
+  }
+  if (!same(typedData.domain?.verifyingContract, DELEGATION_MANAGER)) {
+    refuse2(
+      "the EIP-712 domain names an unknown DelegationManager",
+      `Expected ${DELEGATION_MANAGER}, got ${typedData.domain?.verifyingContract}.`
+    );
+  }
+  const domainChain = Number(typedData.domain?.chainId);
+  if (!Number.isFinite(domainChain) || domainChain !== expected.chainId) {
+    refuse2(
+      "it is scoped to the wrong chain",
+      `The expected context says chain ${expected.chainId}; the child says ${typedData.domain?.chainId}.`
+    );
+  }
+  const authority = typedData.message?.authority;
+  if (typeof authority !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(authority)) {
+    refuse2("its authority is not a 32-byte delegation hash", `Got ${String(authority)}.`);
+  }
+  if (authority.toLowerCase() === ROOT_AUTHORITY) {
+    refuse2(
+      "it is a ROOT delegation, not a re-delegation of the agent budget",
+      "A root child would grant its redeemer authority over the agent's own account instead of spending through the budget delegation's enforcers."
+    );
+  }
+  if (expected.delegatorAccount !== void 0) {
+    const delegator = typedData.message?.delegator;
+    if (typeof delegator !== "string" || !same(delegator, expected.delegatorAccount)) {
+      refuse2(
+        "it is delegated by an account other than this agent's own",
+        `Expected delegator ${expected.delegatorAccount}; the child names ${String(delegator)}.`
+      );
+    }
+  }
+  const caveats = typedData.message?.caveats ?? [];
+  if (caveats.length === 0) {
+    refuse2("it carries no caveats at all", "An unconstrained delegation is not a payment.");
+  }
+  const transfer = findCaveat(caveats, CAVEAT_ENFORCERS.erc20TransferAmount);
+  if (!transfer) {
+    refuse2(
+      "it has no ERC-20 transfer-amount caveat",
+      "Without it the delegation is not bounded to an amount."
+    );
+  }
+  const token = `0x${slice(transfer.terms, 0, 20)}`;
+  if (!same(token, expected.asset)) {
+    refuse2("it spends a different token", `Expected ${expected.asset}, child pins ${token}.`);
+  }
+  const amount = BigInt(`0x${slice(transfer.terms, 20, 52)}`);
+  if (amount !== BigInt(expected.amount)) {
+    refuse2(
+      "the amount does not match",
+      `The expected context says ${expected.amount}; the child allows ${amount.toString()}.`
+    );
+  }
+  const calldata = findCaveat(caveats, CAVEAT_ENFORCERS.allowedCalldata);
+  if (!calldata) {
+    refuse2(
+      "it has no payee pin",
+      "Without an allowed-calldata caveat the merchant could redeem it to any address."
+    );
+  }
+  const startIndex = BigInt(`0x${slice(calldata.terms, 0, 32)}`);
+  if (startIndex !== 4n) {
+    refuse2(
+      "the payee pin points at the wrong calldata offset",
+      `Expected offset 4 (the transfer's \`to\` word), got ${startIndex.toString()}.`
+    );
+  }
+  const paddedPayee = slice(calldata.terms, 32, 64);
+  if (paddedPayee.slice(0, 24) !== "0".repeat(24)) {
+    refuse2("the pinned payee is not a plain address", "Its 32-byte word is not a padded address.");
+  }
+  const payee = `0x${paddedPayee.slice(24)}`;
+  if (!same(payee, expected.merchantTo)) {
+    refuse2(
+      "it pays a different address than Haven declared",
+      `The expected context says ${expected.merchantTo}; the child pins ${payee}.`
+    );
+  }
+  const timestamp = findCaveat(caveats, CAVEAT_ENFORCERS.timestamp);
+  if (!timestamp) {
+    refuse2("it never expires", "A settlement child without a timestamp caveat is open-ended.");
+  }
+  const beforeThreshold = Number(BigInt(`0x${slice(timestamp.terms, 16, 32)}`));
+  if (beforeThreshold <= 0) {
+    refuse2("its expiry is unset", "The timestamp caveat has no upper bound.");
+  }
+  const nowSec = Math.floor(now / 1e3);
+  if (beforeThreshold <= nowSec) {
+    refuse2("it has already expired", `Expiry ${beforeThreshold} is not in the future.`);
+  }
+  if (beforeThreshold > nowSec + MAX_SETTLEMENT_WINDOW_SECONDS) {
+    refuse2(
+      "its window is longer than a settlement may live",
+      `Expiry is ${beforeThreshold - nowSec}s out; the ceiling is ${MAX_SETTLEMENT_WINDOW_SECONDS}s.`
+    );
+  }
+  if (expected.redeemers && expected.redeemers.length > 0) {
+    const redeemer = findCaveat(caveats, CAVEAT_ENFORCERS.redeemer);
+    if (!redeemer) {
+      refuse2(
+        "it has no facilitator pin",
+        "The merchant advertised facilitators, so the child must be redeemable only by them."
+      );
+    }
+    const body = hex(redeemer.terms);
+    if (body.length === 0 || body.length % 40 !== 0) {
+      refuse2("its facilitator pin is malformed", "The redeemer terms are not a list of addresses.");
+    }
+    const pinned = /* @__PURE__ */ new Set();
+    for (let i = 0; i < body.length; i += 40) pinned.add(body.slice(i, i + 40));
+    const wanted = new Set(expected.redeemers.map((a) => hex(a)));
+    if (pinned.size !== wanted.size || [...wanted].some((a) => !pinned.has(a))) {
+      refuse2(
+        "it is redeemable by different facilitators than the merchant advertised",
+        `Expected ${[...wanted].map((a) => `0x${a}`).join(", ")}; the child pins ${[...pinned].map((a) => `0x${a}`).join(", ")}.`
+      );
+    }
+  }
+  if (expected.expiresAt) {
+    const declared = Math.floor(Date.parse(expected.expiresAt) / 1e3);
+    if (Number.isFinite(declared) && beforeThreshold > declared) {
+      refuse2(
+        "it outlives the payment window Haven declared",
+        `The expected context expires at ${expected.expiresAt}; the child lives to ${beforeThreshold}.`
+      );
+    }
+  }
+}
+var SIMPLE_FACTORY_ADDRESS = "0x69Aa2f9fe1572F1B640E1bbc512f5c3a734fc77c";
+var HYBRID_DELEGATOR_IMPLEMENTATION = "0x48dBe696A4D990079e039489bA2053B36E8FFEC4";
+var ERC1967_PROXY_BYTECODE = "0x60806040526040516103f03803806103f08339810160408190526100229161025e565b61002c8282610033565b5050610341565b61003c82610091565b6040516001600160a01b038316907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b905f90a280511561008557610080828261010c565b505050565b61008d61017f565b5050565b806001600160a01b03163b5f036100cb57604051634c9c8ce360e01b81526001600160a01b03821660048201526024015b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b0319166001600160a01b0392909216919091179055565b60605f80846001600160a01b0316846040516101289190610326565b5f60405180830381855af49150503d805f8114610160576040519150601f19603f3d011682016040523d82523d5f602084013e610165565b606091505b5090925090506101768583836101a0565b95945050505050565b341561019e5760405163b398979f60e01b815260040160405180910390fd5b565b6060826101b5576101b0826101ff565b6101f8565b81511580156101cc57506001600160a01b0384163b155b156101f557604051639996b31560e01b81526001600160a01b03851660048201526024016100c2565b50805b9392505050565b80511561020f5780518082602001fd5b604051630a12f52160e11b815260040160405180910390fd5b634e487b7160e01b5f52604160045260245ffd5b5f5b8381101561025657818101518382015260200161023e565b50505f910152565b5f806040838503121561026f575f80fd5b82516001600160a01b0381168114610285575f80fd5b60208401519092506001600160401b03808211156102a1575f80fd5b818501915085601f8301126102b4575f80fd5b8151818111156102c6576102c6610228565b604051601f8201601f19908116603f011681019083821181831017156102ee576102ee610228565b81604052828152886020848701011115610306575f80fd5b61031783602083016020880161023c565b80955050505050509250929050565b5f825161033781846020870161023c565b9190910192915050565b60a38061034d5f395ff3fe6080604052600a600c565b005b60186014601a565b6050565b565b5f604b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b031690565b905090565b365f80375f80365f845af43d5f803e8080156069573d5ff35b3d5ffdfea2646970667358221220fd2cc92935c943d341edacaf5318a0b9ab0185ce62ef72e95ab393ef358730c464736f6c63430008170033";
+var ERC1967_PROXY_ABI = [
+  {
+    type: "constructor",
+    inputs: [
+      { name: "implementation", type: "address" },
+      { name: "_data", type: "bytes" }
+    ],
+    stateMutability: "payable"
+  }
+];
+var HYBRID_DELEGATOR_INITIALIZE_ABI = [
+  {
+    type: "function",
+    name: "initialize",
+    inputs: [
+      { name: "_owner", type: "address" },
+      { name: "_keyIds", type: "string[]" },
+      { name: "_xValues", type: "uint256[]" },
+      { name: "_yValues", type: "uint256[]" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+var DEPLOY_SALT = pad("0x", { size: 32 });
+function deriveDelegateAccountAddress(owner) {
+  const initData = encodeFunctionData({
+    abi: HYBRID_DELEGATOR_INITIALIZE_ABI,
+    functionName: "initialize",
+    args: [owner, [], [], []]
+  });
+  const proxyCreationCode = encodeDeployData({
+    abi: ERC1967_PROXY_ABI,
+    args: [HYBRID_DELEGATOR_IMPLEMENTATION, initData],
+    bytecode: ERC1967_PROXY_BYTECODE
+  });
+  return getContractAddress({
+    bytecode: proxyCreationCode,
+    from: SIMPLE_FACTORY_ADDRESS,
+    opcode: "CREATE2",
+    salt: DEPLOY_SALT
+  });
+}
+var CAVEAT_COMPONENTS = [
+  { name: "enforcer", type: "address" },
+  { name: "terms", type: "bytes" },
+  { name: "args", type: "bytes" }
+];
+var DELEGATION_TUPLE_COMPONENTS = [
+  { name: "delegate", type: "address" },
+  { name: "delegator", type: "address" },
+  { name: "authority", type: "bytes32" },
+  { name: "caveats", type: "tuple[]", components: CAVEAT_COMPONENTS },
+  { name: "salt", type: "uint256" },
+  { name: "signature", type: "bytes" }
+];
+var DELEGATION_ARRAY_PARAM = [
+  { type: "tuple[]", components: DELEGATION_TUPLE_COMPONENTS }
+];
+var REDEEM_DELEGATIONS_ABI = [
+  {
+    type: "function",
+    name: "redeemDelegations",
+    inputs: [
+      { name: "_permissionContexts", type: "bytes[]" },
+      { name: "_modes", type: "bytes32[]" },
+      { name: "_executionCallDatas", type: "bytes[]" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+var SINGLE_DEFAULT_MODE = `0x${"00".repeat(32)}`;
+function refuse3(detail) {
+  throw new HavenSigningError(
+    `Refusing to sign: this UserOperation's redeemDelegations call ${detail}. This signer only signs a redemption of a single delegation granted to the agent's own account.`
+  );
+}
+function assertRedeemsOwnBudgetDelegation(redeemCalldata, ownAccount) {
+  let permissionContexts;
+  let modes;
+  let executionCallDatas;
+  try {
+    const { args } = decodeFunctionData({ abi: REDEEM_DELEGATIONS_ABI, data: redeemCalldata });
+    [permissionContexts, modes, executionCallDatas] = args;
+  } catch {
+    refuse3("is not a well-formed redeemDelegations(bytes[],bytes32[],bytes[]) call");
+  }
+  const reEncoded = encodeFunctionData({
+    abi: REDEEM_DELEGATIONS_ABI,
+    functionName: "redeemDelegations",
+    args: [permissionContexts, modes, executionCallDatas]
+  });
+  if (reEncoded.toLowerCase() !== redeemCalldata.toLowerCase()) {
+    refuse3("does not re-encode to the exact bytes signed (trailing or non-canonical bytes)");
+  }
+  if (permissionContexts.length === 0 || permissionContexts.length !== modes.length || permissionContexts.length !== executionCallDatas.length) {
+    refuse3(
+      `has mismatched or empty argument arrays (permissionContexts=${permissionContexts.length}, modes=${modes.length}, executionCallDatas=${executionCallDatas.length})`
+    );
+  }
+  if (permissionContexts.length !== 1) {
+    refuse3(`redeems ${permissionContexts.length} delegation chains at once, not exactly one`);
+  }
+  if (modes[0].toLowerCase() !== SINGLE_DEFAULT_MODE.toLowerCase()) {
+    refuse3(`uses execution mode ${modes[0]}, not ExecutionMode.SingleDefault`);
+  }
+  let delegations;
+  try {
+    const [decoded] = decodeAbiParameters(DELEGATION_ARRAY_PARAM, permissionContexts[0]);
+    delegations = decoded;
+  } catch {
+    refuse3("carries a permission context that does not decode as an ABI-encoded Delegation[]");
+  }
+  if (delegations.length === 0) {
+    refuse3(
+      "carries an EMPTY delegation chain \u2014 DelegationManager treats this as self-authorised and runs the paired execution as the account, with no caveat, budget or recipient pin"
+    );
+  }
+  if (delegations.length !== 1) {
+    refuse3(`carries a ${delegations.length}-link delegation chain, not the single budget grant Haven emits`);
+  }
+  const reEncodedContext = encodeAbiParameters(DELEGATION_ARRAY_PARAM, [delegations]);
+  if (reEncodedContext.toLowerCase() !== permissionContexts[0].toLowerCase()) {
+    refuse3("carries a permission context with trailing or non-canonical bytes");
+  }
+  const leaf = delegations[0];
+  if (leaf.delegate.toLowerCase() !== ownAccount.toLowerCase()) {
+    refuse3(
+      `is redeemed for delegate ${leaf.delegate}, not this signer's own account (${ownAccount})`
+    );
+  }
+  const root = delegations[delegations.length - 1];
+  if (root.delegator.toLowerCase() === ownAccount.toLowerCase()) {
+    refuse3(
+      "carries a root delegation granted by this signer's OWN account \u2014 a real budget delegation always comes from elsewhere"
+    );
+  }
+}
+
+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, CAVEAT_ENFORCERS, CONNECTOR_PACKAGE_NAME, DEFAULT_CONFIRMATION_TIMEOUT_MS, DELEGATION_MANAGER, DELEGATION_TUPLE_COMPONENTS, DIRECT_SIGN_CONTEXT_VERSION, ENTRY_POINT_V07, HAVEN_CONNECTOR_CHANNEL, HYBRID_DELEGATOR_DOMAIN_NAME, HYBRID_DELEGATOR_DOMAIN_VERSION, HYBRID_DELEGATOR_IMPLEMENTATION, HavenApiError, HavenError, HavenPaymentStateError, HavenSigningError, HavenTimeoutError, HavenUnsupportedSignerVersionError, HavenUserOpBindingError, HavenZeroSettlementHashError, MAX_SETTLEMENT_WINDOW_SECONDS, MerchantTimeoutError, PACKED_USER_OPERATION_FIELDS, REDEEM_DELEGATIONS_ABI, ROOT_AUTHORITY, SIGNER_UPDATE_FALLBACK, SIMPLE_FACTORY_ADDRESS, SINGLE_DEFAULT_MODE, SignerRefusalCode, X402AlreadySettledError, X402UnexpectedStatusError, assertRedeemsOwnBudgetDelegation, assertUserOpTypedDataBinding, chainIdForNetwork, connectorRerunCommand, connectorSpec, deriveDelegateAccountAddress, isConnectorChannel, isPackedUserOperationTypedData, isSettlementChildTypedData, packedUserOperationHash, resolveConnectorChannel, signerUpdateFallback, verifySettlementChild };
+//# sourceMappingURL=chunk-GLNG2GF7.js.map
+//# sourceMappingURL=chunk-GLNG2GF7.js.map