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

package/dist/{chunk-KQ7JXKTV.js → chunk-3WSEX3GW.js}

@@ -1,5 +1,5 @@
-import { HavenSigningError, deriveDelegateAccountAddress, DELEGATION_MANAGER, assertRedeemsOwnBudgetDelegation, verifySettlementChild, REDEEM_DELEGATIONS_ABI } from './chunk-GLNG2GF7.js';
-import { decodeFunctionData, encodeFunctionData, encodePacked, recoverTypedDataAddress } from 'viem';
+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";
@@ -777,7 +777,7 @@ function stableStringify2(value) {
 }
 
 // src/client-identity.ts
-var SDK_VERSION = "0.5.0-alpha.1";
+var SDK_VERSION = "0.6.0-alpha.0";
 var HAVEN_CLIENT_HEADER = "X-Haven-Client";
 function havenClientIdentity(pkg, version) {
   return `${pkg}/${version}`;
@@ -896,7 +896,316 @@ function unsupportedNodeVersionMessage(options) {
 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 { DEFAULT_NEXT_TOOL_BY_ACTION, DIRECT_PAYMENT_CHAIN_IDS, ERC7710_ASSET_TRANSFER_METHOD, EXECUTE_ABI, HAVEN_CLIENT_HEADER, HAVEN_MINIMUM_NODE_VERSION, HavenTypedDataRefusedError, 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, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, buildX402IdempotencyKey, compareNodeVersions, createNextStepBuilder, decodeBase64Json, decodeBase64Utf8, defaultNextToolFor, encodeBase64Json, encodeBase64Utf8, encodePaymentProof, havenClientIdentity, isErc7710Option, isSupportedNodeVersion, isSweepableChain, normalizePaymentRequired, parseNextTool, parsePaymentRequired, parsePaymentRequiredResponse, readClientUpdate, renderNextTool, resolveTokenFromAddress, selectErc7710PaymentOption, selectPaymentOption, selectStandardPaymentOption, selectX402SettlementScheme, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, unsupportedNodeVersionMessage, validateStandardX402PaymentHeader, x402AssetTransferMethod, x402AuthorizationAmount, x402FacilitatorAddresses, x402PaymentHeaderNamesFor, x402PaymentHeaderNamesSent, x402V2PaymentEnvelope };
-//# sourceMappingURL=chunk-KQ7JXKTV.js.map
-//# sourceMappingURL=chunk-KQ7JXKTV.js.map
+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