@haven_ai/sdk 0.4.0-alpha.0 → 0.6.0-alpha.0

package/dist/chunk-3WSEX3GW.js

@@ -0,0 +1,1211 @@
+import { HavenSigningError, deriveDelegateAccountAddress, DELEGATION_MANAGER, assertRedeemsOwnBudgetDelegation, verifySettlementChild, REDEEM_DELEGATIONS_ABI, ROOT_AUTHORITY, CAVEAT_ENFORCERS, DELEGATION_TUPLE_COMPONENTS } from './chunk-63GPTEEY.js';
+import { decodeFunctionData, encodeFunctionData, encodePacked, recoverTypedDataAddress, encodeAbiParameters, keccak256 } from 'viem';
+import { createHash } from 'crypto';
+
+var TYPED_DATA_NOT_ALLOWED = "TYPED_DATA_NOT_ALLOWED";
+var HavenTypedDataRefusedError = class extends HavenSigningError {
+  constructor(message) {
+    super(message);
+    this.code = TYPED_DATA_NOT_ALLOWED;
+    this.name = "HavenTypedDataRefusedError";
+  }
+};
+var DIRECT_PAYMENT_CHAIN_IDS = /* @__PURE__ */ new Set([8453, 84532]);
+var EXECUTE_ABI = [
+  {
+    type: "function",
+    name: "execute",
+    inputs: [
+      {
+        name: "_execution",
+        type: "tuple",
+        components: [
+          { name: "target", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "callData", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  }
+];
+function assertBoundDirectPaymentUserOp(typedData, delegateAddress) {
+  const domain = typedData.domain ?? {};
+  const message = typedData.message ?? {};
+  if (typeof domain.chainId !== "number" && typeof domain.chainId !== "bigint") {
+    throw new HavenTypedDataRefusedError(
+      `This UserOperation's domain.chainId is ${typeof domain.chainId} (${String(domain.chainId)}), not a number \u2014 refusing rather than risk signing a different EIP-712 domain than this check evaluated.`
+    );
+  }
+  const chainId = Number(domain.chainId);
+  if (!DIRECT_PAYMENT_CHAIN_IDS.has(chainId)) {
+    throw new HavenTypedDataRefusedError(
+      `This signer only signs direct payments on chains the delegation rail has pinned contracts for (${[...DIRECT_PAYMENT_CHAIN_IDS].join(", ")}); this typed data names chain ${String(domain.chainId)}. Refusing.`
+    );
+  }
+  const ownAccount = deriveDelegateAccountAddress(delegateAddress);
+  const sender = typeof message.sender === "string" ? message.sender : "";
+  if (sender.toLowerCase() !== ownAccount.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      `This UserOperation's account (${sender || "unknown"}) is not this signer's own delegate account (${ownAccount}) \u2014 signing it would authorize a DIFFERENT account's operation. Sign only your own agent's Haven-prepared payloads.`
+    );
+  }
+  const callData = message.callData;
+  let decoded;
+  try {
+    const { args } = decodeFunctionData({
+      abi: EXECUTE_ABI,
+      data: callData
+    });
+    decoded = args[0];
+  } catch {
+    throw new HavenTypedDataRefusedError(
+      "This UserOperation's callData is not a single execute((address,uint256,bytes)) call \u2014 a batch execute, executeFromExecutor, or any other selector is refused. This signer only signs direct payments."
+    );
+  }
+  const reEncodedExecute = encodeFunctionData({
+    abi: EXECUTE_ABI,
+    functionName: "execute",
+    args: [decoded]
+  });
+  if (reEncodedExecute.toLowerCase() !== callData.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      "This UserOperation's execute() call does not re-encode to the exact callData bytes (trailing or non-canonical bytes). Refusing."
+    );
+  }
+  if (decoded.target.toLowerCase() !== DELEGATION_MANAGER.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      `This UserOperation's execute() calls ${decoded.target}, not the DelegationManager (${DELEGATION_MANAGER}). A direct payment only ever redeems the agent's own budget delegation \u2014 refusing what looks like a self-call (e.g. transferOwnership, updateSigners, upgradeToAndCall) or a call to an unrelated contract.`
+    );
+  }
+  if (decoded.value !== 0n) {
+    throw new HavenTypedDataRefusedError(
+      `This UserOperation's execute() sends ${decoded.value} wei of native value alongside the DelegationManager call \u2014 a direct payment never does. Refusing.`
+    );
+  }
+  try {
+    assertRedeemsOwnBudgetDelegation(decoded.callData, ownAccount);
+  } catch (err) {
+    throw new HavenTypedDataRefusedError(err instanceof Error ? err.message : String(err));
+  }
+}
+function assertOwnSettlementChild(typedData, expectation, delegateAddress) {
+  try {
+    verifySettlementChild(typedData, {
+      ...expectation,
+      delegatorAccount: deriveDelegateAccountAddress(delegateAddress)
+    });
+  } catch (err) {
+    if (err instanceof HavenTypedDataRefusedError) throw err;
+    if (err instanceof HavenSigningError) throw new HavenTypedDataRefusedError(err.message);
+    throw new HavenTypedDataRefusedError(
+      `Refusing to sign the x402 settlement child: it is malformed (${err instanceof Error ? err.message : String(err)}).`
+    );
+  }
+}
+var ERC20_TRANSFER_ABI = [
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "nonpayable"
+  }
+];
+function assertFundingLegPaysDelegate(typedData, expected) {
+  const refuse = (detail) => {
+    throw new HavenTypedDataRefusedError(
+      `Refusing to sign this x402 funding leg: ${detail}. A funding leg only ever moves the quoted amount of the quoted token from the account to this agent's own delegate wallet.`
+    );
+  };
+  const message = typedData.message ?? {};
+  let executionCallData;
+  try {
+    const { args: executeArgs } = decodeFunctionData({ abi: EXECUTE_ABI, data: message.callData });
+    const inner = executeArgs[0].callData;
+    const { args } = decodeFunctionData({ abi: REDEEM_DELEGATIONS_ABI, data: inner });
+    const executions = args[2];
+    executionCallData = executions[0];
+  } catch {
+    return refuse("its redemption could not be decoded");
+  }
+  const body = executionCallData.slice(2);
+  if (body.length < (20 + 32) * 2) refuse("its execution is too short to be a token transfer");
+  const target = `0x${body.slice(0, 40)}`;
+  const value = BigInt(`0x${body.slice(40, 104)}`);
+  const callData = `0x${body.slice(104)}`;
+  if (target.toLowerCase() !== expected.asset.toLowerCase()) {
+    refuse(`it calls ${target}, not the quoted token ${expected.asset}`);
+  }
+  if (value !== 0n) refuse(`it sends ${value} wei of native value`);
+  let to;
+  let amount;
+  try {
+    const decoded = decodeFunctionData({ abi: ERC20_TRANSFER_ABI, data: callData });
+    [to, amount] = decoded.args;
+  } catch {
+    return refuse("its execution is not an ERC-20 transfer(address,uint256)");
+  }
+  const reEncoded = encodePacked(
+    ["address", "uint256", "bytes"],
+    [target, value, encodeFunctionData({ abi: ERC20_TRANSFER_ABI, functionName: "transfer", args: [to, amount] })]
+  );
+  if (reEncoded.toLowerCase() !== executionCallData.toLowerCase()) {
+    refuse("its execution does not re-encode to the exact bytes signed (trailing or non-canonical bytes)");
+  }
+  if (to.toLowerCase() !== expected.delegateAddress.toLowerCase()) {
+    refuse(`it pays ${to}, not this agent's own delegate wallet (${expected.delegateAddress})`);
+  }
+  if (amount !== BigInt(expected.amount)) {
+    refuse(`it moves ${amount}, not the quoted amount ${expected.amount}`);
+  }
+}
+
+// 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(",")}}`;
+}
+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,
+    // Keep the merchant offer intact for v2 `accepted` matching. Only the
+    // signing conversion may cap its authorization lifetime (#3117).
+    // Retain legacy fallback behavior for missing or unusable timeouts.
+    // Integer, because the authorize body types it `integer` and the child's
+    // timestamp caveat is built from it — the old clamp floored, so keeping a
+    // fractional value here would 400 a merchant that used to work (#3117).
+    maxTimeoutSeconds: typeof candidate.maxTimeoutSeconds === "number" && Number.isFinite(candidate.maxTimeoutSeconds) && candidate.maxTimeoutSeconds >= 1 ? Math.floor(candidate.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 isEip3009ConstructibleOption(option) {
+  const rawMethod = option.extra?.assetTransferMethod;
+  if (rawMethod !== void 0 && rawMethod !== "eip3009") return false;
+  const rawFlow = option.extra?.paymentFlow;
+  if (rawFlow !== void 0 && rawFlow !== "authorization") return false;
+  return true;
+}
+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 (!isEip3009ConstructibleOption(opt)) continue;
+    if (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;
+    if (!isEip3009ConstructibleOption(opt)) continue;
+  }
+  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}`);
+  }
+  if (!isEip3009ConstructibleOption(option)) {
+    throw new Error(
+      "Unsupported x402 payment requirements: this SDK constructs EIP-3009 authorization payments only. The merchant advertised a different extra.assetTransferMethod or an unrecognized extra.paymentFlow."
+    );
+  }
+  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,
+    // Signing-only policy (#715/#3117): parsed and directly supplied options
+    // share this cap before the library computes validBefore. Keep the offer
+    // echoed in `accepted` unchanged. The forward margin (#1256) adds time
+    // for funding/retry, but does not guarantee a merchant timeout above the
+    // total bounded lifetime can pass facilitator verification.
+    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(",")}}`;
+}
+
+// src/client-identity.ts
+var SDK_VERSION = "0.6.0-alpha.0";
+var HAVEN_CLIENT_HEADER = "X-Haven-Client";
+function havenClientIdentity(pkg, version) {
+  return `${pkg}/${version}`;
+}
+var SDK_CLIENT_IDENTITY = havenClientIdentity("@haven_ai/sdk", SDK_VERSION);
+function readClientUpdate(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const v = value;
+  if (typeof v.package !== "string" || typeof v.current !== "string" || typeof v.required !== "boolean" || typeof v.upgrade_command !== "string") {
+    return void 0;
+  }
+  return {
+    package: v.package,
+    current: v.current,
+    recommended: typeof v.recommended === "string" ? v.recommended : null,
+    min_version: typeof v.min_version === "string" ? v.min_version : null,
+    required: v.required,
+    upgrade_command: v.upgrade_command,
+    notes_url: typeof v.notes_url === "string" ? v.notes_url : null
+  };
+}
+
+// src/next-step.ts
+var NEXT_TOOL_SERVER_NAMES = {
+  hosted: "haven",
+  signer: "haven-signer"
+};
+var NEXT_TOOL_SERVER_ROLES = {
+  haven: "hosted",
+  "haven-signer": "signer"
+};
+function renderNextTool(role, name) {
+  return `mcp__${NEXT_TOOL_SERVER_NAMES[role]}__${name}`;
+}
+function parseNextTool(literal) {
+  const m = /^mcp__([a-z0-9-]+)__([a-z0-9_]+)$/.exec(literal);
+  if (!m) return null;
+  const role = NEXT_TOOL_SERVER_ROLES[m[1]];
+  return { server: m[1], name: m[2], ...role ? { role } : {} };
+}
+var DEFAULT_NEXT_TOOL_BY_ACTION = {
+  check_status_later: "haven_get_payment_status",
+  sweep_stranded_funds: "haven_sweep_delegate"
+  // `retry_original_x402_request` is NOT here: its only live emitter
+  // (state-direct-recovery.ts, erc7710) names no tool on purpose — the retry
+  // is the agent's own HTTP call — so a default would contradict the site.
+};
+function defaultNextToolFor(action) {
+  return DEFAULT_NEXT_TOOL_BY_ACTION[action];
+}
+function createNextStepBuilder(targets) {
+  return function nextStep(input) {
+    const i = input;
+    const base = {
+      next_action: input.nextAction,
+      safe_to_continue: input.safeToContinue,
+      reason: input.reason
+    };
+    if (i.nextTool === null) {
+      return { ...base, next_tool_omitted_reason: i.nextToolOmittedReason ?? "no next tool" };
+    }
+    const target = targets[i.nextTool];
+    if (!target) {
+      return { ...base, next_tool_omitted_reason: `${i.nextTool} is not a registered next-step target` };
+    }
+    const problem = target.validate(i.nextArguments);
+    if (problem) {
+      return { ...base, next_tool_omitted_reason: `next_arguments do not parse under ${i.nextTool}: ${problem}` };
+    }
+    return {
+      ...base,
+      next_tool: renderNextTool(target.role, i.nextTool),
+      next_tool_server: NEXT_TOOL_SERVER_NAMES[target.role],
+      next_tool_name: i.nextTool,
+      next_tool_server_role: target.role,
+      next_arguments: i.nextArguments
+    };
+  };
+}
+
+// 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]);
+}
+var MAX_TASK_BUDGET_TTL_SECONDS = 86400;
+var EXPECTED_DELEGATION_TYPES = {
+  Caveat: [
+    { name: "enforcer", type: "address" },
+    { name: "terms", type: "bytes" }
+  ],
+  Delegation: [
+    { name: "delegate", type: "address" },
+    { name: "delegator", type: "address" },
+    { name: "authority", type: "bytes32" },
+    { name: "caveats", type: "Caveat[]" },
+    { name: "salt", type: "uint256" }
+  ]
+};
+var DELEGATION_DOMAIN_NAME = "DelegationManager";
+var DELEGATION_DOMAIN_VERSION = "1";
+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 isTaskChildTypedData(value) {
+  const td = value;
+  if (!td || td.primaryType !== "Delegation" || typeof td.domain?.verifyingContract !== "string" || !Array.isArray(td.message?.caveats)) {
+    return false;
+  }
+  const delegate = td.message?.delegate;
+  const delegator = td.message?.delegator;
+  return typeof delegate === "string" && typeof delegator === "string" && same(delegate, delegator);
+}
+function refuseTaskChild(what, detail) {
+  throw new HavenTypedDataRefusedError(
+    `Refusing to sign the task-budget child: ${what}. ${detail} This signature opens a self-delegated slice of the agent budget, so it is verified locally against the expectation Haven declared, rather than trusted.`
+  );
+}
+function assertOwnTaskChild(typedData, expected, delegateAddress, now = Date.now()) {
+  const td = typedData;
+  if (td?.primaryType !== "Delegation") {
+    refuseTaskChild("it is not a Delegation payload", `primaryType was '${String(td?.primaryType)}'.`);
+  }
+  if (!same(td.domain?.verifyingContract, DELEGATION_MANAGER)) {
+    refuseTaskChild(
+      "the EIP-712 domain names an unknown DelegationManager",
+      `Expected ${DELEGATION_MANAGER}, got ${td.domain?.verifyingContract}.`
+    );
+  }
+  if (td.domain?.name !== DELEGATION_DOMAIN_NAME || td.domain?.version !== DELEGATION_DOMAIN_VERSION) {
+    refuseTaskChild(
+      "the EIP-712 domain name/version does not match the pinned DelegationManager domain",
+      `Expected name '${DELEGATION_DOMAIN_NAME}' version '${DELEGATION_DOMAIN_VERSION}'; got name '${String(td.domain?.name)}' version '${String(td.domain?.version)}'.`
+    );
+  }
+  if (JSON.stringify(td.types?.Caveat) !== JSON.stringify(EXPECTED_DELEGATION_TYPES.Caveat) || JSON.stringify(td.types?.Delegation) !== JSON.stringify(EXPECTED_DELEGATION_TYPES.Delegation)) {
+    refuseTaskChild(
+      "its EIP-712 type definitions do not match the pinned Delegation/Caveat shape",
+      "A renamed, reordered, or additional field on Delegation or Caveat could change what the caveats below mean without changing this check's field-by-field comparisons."
+    );
+  }
+  const domainChain = Number(td.domain?.chainId);
+  if (!Number.isFinite(domainChain) || !DIRECT_PAYMENT_CHAIN_IDS.has(domainChain)) {
+    refuseTaskChild(
+      "it is scoped to a chain the delegation rail has no pinned contracts for",
+      `Chains with pinned contracts: ${[...DIRECT_PAYMENT_CHAIN_IDS].join(", ")}; the child says ${String(td.domain?.chainId)}.`
+    );
+  }
+  if (domainChain !== expected.chainId) {
+    refuseTaskChild(
+      "it is scoped to the wrong chain",
+      `Expected chain ${expected.chainId}; the child says ${td.domain?.chainId}.`
+    );
+  }
+  const ownAccount = deriveDelegateAccountAddress(delegateAddress);
+  const delegator = td.message?.delegator;
+  if (typeof delegator !== "string" || !same(delegator, ownAccount)) {
+    refuseTaskChild(
+      "it is not delegated by this agent's own account",
+      `Expected delegator ${ownAccount}; the child names ${String(delegator)}.`
+    );
+  }
+  const delegate = td.message?.delegate;
+  if (typeof delegate !== "string" || !same(delegate, ownAccount)) {
+    refuseTaskChild(
+      "it is not self-delegated to this agent's own account",
+      `Expected delegate ${ownAccount}; the child names ${String(delegate)}.`
+    );
+  }
+  const authority = td.message?.authority;
+  if (typeof authority !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(authority)) {
+    refuseTaskChild("its authority is not a 32-byte delegation hash", `Got ${String(authority)}.`);
+  }
+  if (authority.toLowerCase() === ROOT_AUTHORITY) {
+    refuseTaskChild(
+      "it is a ROOT delegation, not a re-delegation of the agent budget",
+      "A task budget always chains under the agent budget delegation."
+    );
+  }
+  if (!same(authority, expected.parentDelegationHash)) {
+    refuseTaskChild(
+      "it chains under a different parent delegation",
+      `Expected authority ${expected.parentDelegationHash}; the child says ${authority}.`
+    );
+  }
+  const caveats = td.message?.caveats ?? [];
+  const transfer = findCaveat(caveats, CAVEAT_ENFORCERS.erc20TransferAmount);
+  if (!transfer) {
+    refuseTaskChild(
+      "it has no ERC-20 transfer-amount caveat",
+      "Without it the child is not bounded to an amount."
+    );
+  }
+  const token = `0x${slice(transfer.terms, 0, 20)}`;
+  if (!same(token, expected.tokenAddress)) {
+    refuseTaskChild("it spends a different token", `Expected ${expected.tokenAddress}, child pins ${token}.`);
+  }
+  const amount = BigInt(`0x${slice(transfer.terms, 20, 52)}`);
+  if (amount !== BigInt(expected.maxAmountAtomic)) {
+    refuseTaskChild(
+      "the amount does not match",
+      `Expected ${expected.maxAmountAtomic}; the child allows ${amount.toString()}.`
+    );
+  }
+  const timestamp = findCaveat(caveats, CAVEAT_ENFORCERS.timestamp);
+  if (!timestamp) {
+    refuseTaskChild("it never expires", "A task-budget child without a timestamp caveat is open-ended.");
+  }
+  const beforeThreshold = Number(BigInt(`0x${slice(timestamp.terms, 16, 32)}`));
+  const nowSec = Math.floor(now / 1e3);
+  if (beforeThreshold <= nowSec) {
+    refuseTaskChild("it has already expired", `Expiry ${beforeThreshold} is not in the future.`);
+  }
+  if (beforeThreshold > nowSec + MAX_TASK_BUDGET_TTL_SECONDS) {
+    refuseTaskChild(
+      "its window is longer than a task budget may live",
+      `Expiry is ${beforeThreshold - nowSec}s out; the ceiling is ${MAX_TASK_BUDGET_TTL_SECONDS}s.`
+    );
+  }
+  if (beforeThreshold !== expected.expiresAt) {
+    refuseTaskChild(
+      "its expiry does not match what Haven declared",
+      `Expected ${expected.expiresAt}; the child says ${beforeThreshold}.`
+    );
+  }
+  const calldata = findCaveat(caveats, CAVEAT_ENFORCERS.allowedCalldata);
+  if (expected.recipientAddress) {
+    if (!calldata) {
+      refuseTaskChild(
+        "it has no recipient pin",
+        "The task budget was opened with a pinned recipient, so the child must carry one."
+      );
+    }
+    const startIndex = BigInt(`0x${slice(calldata.terms, 0, 32)}`);
+    if (startIndex !== 4n) {
+      refuseTaskChild(
+        "the recipient pin points at the wrong calldata offset",
+        `Expected offset 4, got ${startIndex.toString()}.`
+      );
+    }
+    const paddedRecipient = slice(calldata.terms, 32, 64);
+    if (paddedRecipient.slice(0, 24) !== "0".repeat(24)) {
+      refuseTaskChild("the pinned recipient is not a plain address", "Its 32-byte word is not a padded address.");
+    }
+    const recipient = `0x${paddedRecipient.slice(24)}`;
+    if (!same(recipient, expected.recipientAddress)) {
+      refuseTaskChild(
+        "it pins a different recipient than Haven declared",
+        `Expected ${expected.recipientAddress}; the child pins ${recipient}.`
+      );
+    }
+  } else if (calldata) {
+    refuseTaskChild(
+      "it pins a recipient the task budget was not opened with",
+      "This task budget is open (no recipient pin); the child must not add one."
+    );
+  }
+}
+var DISABLE_DELEGATION_ABI = [
+  {
+    type: "function",
+    name: "disableDelegation",
+    inputs: [{ name: "delegation", type: "tuple", components: DELEGATION_TUPLE_COMPONENTS }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+function assertOwnTaskBudgetCloseUserOp(typedData, expected, delegateAddress) {
+  const domain = typedData.domain ?? {};
+  const message = typedData.message ?? {};
+  if (typeof domain.chainId !== "number" && typeof domain.chainId !== "bigint") {
+    throw new HavenTypedDataRefusedError(
+      `This close UserOperation's domain.chainId is ${typeof domain.chainId} (${String(domain.chainId)}), not a number \u2014 refusing rather than risk signing a different EIP-712 domain than this check evaluated.`
+    );
+  }
+  const chainId = Number(domain.chainId);
+  if (!DIRECT_PAYMENT_CHAIN_IDS.has(chainId)) {
+    throw new HavenTypedDataRefusedError(
+      `This signer only signs a task-budget close on chains the delegation rail has pinned contracts for (${[...DIRECT_PAYMENT_CHAIN_IDS].join(", ")}); this typed data names chain ${String(domain.chainId)}. Refusing.`
+    );
+  }
+  const ownAccount = deriveDelegateAccountAddress(delegateAddress);
+  const sender = typeof message.sender === "string" ? message.sender : "";
+  if (sender.toLowerCase() !== ownAccount.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      `This close UserOperation's account (${sender || "unknown"}) is not this signer's own delegate account (${ownAccount}). Sign only your own agent's Haven-prepared payloads.`
+    );
+  }
+  const callData = message.callData;
+  let decoded;
+  try {
+    const { args } = decodeFunctionData({ abi: EXECUTE_ABI, data: callData });
+    decoded = args[0];
+  } catch {
+    throw new HavenTypedDataRefusedError(
+      "This close UserOperation's callData is not a single execute((address,uint256,bytes)) call. This signer only signs a task-budget close of that exact shape."
+    );
+  }
+  const reEncodedExecute = encodeFunctionData({ abi: EXECUTE_ABI, functionName: "execute", args: [decoded] });
+  if (reEncodedExecute.toLowerCase() !== callData.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      "This close UserOperation's execute() call does not re-encode to the exact callData bytes (trailing or non-canonical bytes). Refusing."
+    );
+  }
+  if (decoded.target.toLowerCase() !== DELEGATION_MANAGER.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      `This close UserOperation's execute() calls ${decoded.target}, not the DelegationManager (${DELEGATION_MANAGER}). Refusing what looks like a self-call or a call to an unrelated contract.`
+    );
+  }
+  if (decoded.value !== 0n) {
+    throw new HavenTypedDataRefusedError(
+      `This close UserOperation's execute() sends ${decoded.value} wei of native value alongside the DelegationManager call \u2014 a task-budget close never does. Refusing.`
+    );
+  }
+  let delegation;
+  try {
+    const { args } = decodeFunctionData({ abi: DISABLE_DELEGATION_ABI, data: decoded.callData });
+    delegation = args[0];
+  } catch {
+    throw new HavenTypedDataRefusedError(
+      "This close UserOperation's execute() does not call disableDelegation(Delegation) \u2014 this signer only signs a task-budget close of that exact shape."
+    );
+  }
+  const reEncodedDisable = encodeFunctionData({
+    abi: DISABLE_DELEGATION_ABI,
+    functionName: "disableDelegation",
+    args: [delegation]
+  });
+  if (reEncodedDisable.toLowerCase() !== decoded.callData.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      "This close UserOperation's disableDelegation call does not re-encode to the exact bytes signed (trailing or non-canonical bytes). Refusing."
+    );
+  }
+  if (delegation.delegator.toLowerCase() !== ownAccount.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      `This close UserOperation disables a delegation granted by ${delegation.delegator}, not this signer's own account (${ownAccount}). Refusing.`
+    );
+  }
+  if (delegation.delegate.toLowerCase() !== ownAccount.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      `This close UserOperation disables a delegation granted to ${delegation.delegate}, not this signer's own account (${ownAccount}) \u2014 a task-budget child is always self-delegated. Refusing.`
+    );
+  }
+  if (delegation.authority.toLowerCase() === ROOT_AUTHORITY) {
+    throw new HavenTypedDataRefusedError(
+      "This close UserOperation disables a ROOT delegation, not a re-delegation of the agent budget. A task-budget child always chains under the agent budget delegation. Refusing."
+    );
+  }
+  const actualHash = hashDelegation(delegation);
+  if (actualHash.toLowerCase() !== expected.delegationHash.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      `This close UserOperation disables delegation ${actualHash}, not the task budget's own child (${expected.delegationHash}). Refusing.`
+    );
+  }
+}
+var DELEGATION_TYPEHASH = "0x88c1d2ecf185adf710588203a5f263f0ff61be0d33da39792cde19ba9aa4331e";
+var CAVEAT_TYPEHASH = "0x80ad7e1b04ee6d994a125f4714ca0720908bd80ed16063ec8aee4b88e9253e2d";
+function hashCaveat(caveat) {
+  const termsHash = keccak256(caveat.terms);
+  const encoded = encodeAbiParameters(
+    [{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }],
+    [CAVEAT_TYPEHASH, caveat.enforcer, termsHash]
+  );
+  return keccak256(encoded);
+}
+function hashCaveatsArray(caveats) {
+  const concatenated = `0x${caveats.map((c) => hashCaveat(c).slice(2)).join("")}`;
+  return keccak256(concatenated);
+}
+function hashDelegation(delegation) {
+  const caveatsHash = hashCaveatsArray(delegation.caveats);
+  const encoded = encodeAbiParameters(
+    [
+      { type: "bytes32" },
+      { type: "address" },
+      { type: "address" },
+      { type: "bytes32" },
+      { type: "bytes32" },
+      { type: "uint256" }
+    ],
+    [DELEGATION_TYPEHASH, delegation.delegate, delegation.delegator, delegation.authority, caveatsHash, delegation.salt]
+  );
+  return keccak256(encoded);
+}
+
+export { CAVEAT_TYPEHASH, DEFAULT_NEXT_TOOL_BY_ACTION, DELEGATION_TYPEHASH, DIRECT_PAYMENT_CHAIN_IDS, ERC7710_ASSET_TRANSFER_METHOD, EXECUTE_ABI, HAVEN_CLIENT_HEADER, HAVEN_MINIMUM_NODE_VERSION, HavenTypedDataRefusedError, MAX_TASK_BUDGET_TTL_SECONDS, NEXT_TOOL_SERVER_NAMES, NEXT_TOOL_SERVER_ROLES, SDK_CLIENT_IDENTITY, SDK_VERSION, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_SEPOLIA_CHAIN_ID, SWEEP_BASE_SEPOLIA_USDC_ADDRESS, SWEEP_BASE_USDC_ADDRESS, TRANSFER_WITH_AUTHORIZATION_TYPES, TYPED_DATA_NOT_ALLOWED, X402PaymentHeaderValidationError, X402_LEGACY_PAYMENT_HEADER_NAME, X402_MAX_AUTHORIZATION_WINDOW_SECONDS, X402_PAYMENT_HEADER_NAME, X402_PAYMENT_HEADER_NAMES, X402_PAYMENT_HEADER_NAMES_SENT, X402_PAYMENT_REQUIRED_HEADER_NAME, X402_PAYMENT_RESPONSE_HEADER_NAME, X402_SETTLEMENT_FORWARD_MARGIN_SECONDS, assertBoundDirectPaymentUserOp, assertFundingLegPaysDelegate, assertOwnSettlementChild, assertOwnTaskBudgetCloseUserOp, assertOwnTaskChild, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, buildX402IdempotencyKey, compareNodeVersions, createNextStepBuilder, decodeBase64Json, decodeBase64Utf8, defaultNextToolFor, encodeBase64Json, encodeBase64Utf8, encodePaymentProof, hashDelegation, havenClientIdentity, isErc7710Option, isSupportedNodeVersion, isSweepableChain, isTaskChildTypedData, normalizePaymentRequired, parseNextTool, parsePaymentRequired, parsePaymentRequiredResponse, readClientUpdate, renderNextTool, resolveTokenFromAddress, selectErc7710PaymentOption, selectPaymentOption, selectStandardPaymentOption, selectX402SettlementScheme, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, unsupportedNodeVersionMessage, validateStandardX402PaymentHeader, x402AssetTransferMethod, x402AuthorizationAmount, x402FacilitatorAddresses, x402PaymentHeaderNamesFor, x402PaymentHeaderNamesSent, x402V2PaymentEnvelope };
+//# sourceMappingURL=chunk-3WSEX3GW.js.map
+//# sourceMappingURL=chunk-3WSEX3GW.js.map