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

package/dist/{chunk-QSSVOPWA.cjs → chunk-CK4NLLMO.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
-var chunkJKUIE45B_cjs = require('./chunk-JKUIE45B.cjs');
+var chunkS42QSWJY_cjs = require('./chunk-S42QSWJY.cjs');
 var viem = require('viem');
 var crypto = require('crypto');
 
 var TYPED_DATA_NOT_ALLOWED = "TYPED_DATA_NOT_ALLOWED";
-var HavenTypedDataRefusedError = class extends chunkJKUIE45B_cjs.HavenSigningError {
+var HavenTypedDataRefusedError = class extends chunkS42QSWJY_cjs.HavenSigningError {
   constructor(message) {
     super(message);
     this.code = TYPED_DATA_NOT_ALLOWED;
@@ -46,7 +46,7 @@ function assertBoundDirectPaymentUserOp(typedData, delegateAddress) {
       `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 = chunkJKUIE45B_cjs.deriveDelegateAccountAddress(delegateAddress);
+  const ownAccount = chunkS42QSWJY_cjs.deriveDelegateAccountAddress(delegateAddress);
   const sender = typeof message.sender === "string" ? message.sender : "";
   if (sender.toLowerCase() !== ownAccount.toLowerCase()) {
     throw new HavenTypedDataRefusedError(
@@ -76,9 +76,9 @@ function assertBoundDirectPaymentUserOp(typedData, delegateAddress) {
       "This UserOperation's execute() call does not re-encode to the exact callData bytes (trailing or non-canonical bytes). Refusing."
     );
   }
-  if (decoded.target.toLowerCase() !== chunkJKUIE45B_cjs.DELEGATION_MANAGER.toLowerCase()) {
+  if (decoded.target.toLowerCase() !== chunkS42QSWJY_cjs.DELEGATION_MANAGER.toLowerCase()) {
     throw new HavenTypedDataRefusedError(
-      `This UserOperation's execute() calls ${decoded.target}, not the DelegationManager (${chunkJKUIE45B_cjs.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.`
+      `This UserOperation's execute() calls ${decoded.target}, not the DelegationManager (${chunkS42QSWJY_cjs.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) {
@@ -87,20 +87,20 @@ function assertBoundDirectPaymentUserOp(typedData, delegateAddress) {
     );
   }
   try {
-    chunkJKUIE45B_cjs.assertRedeemsOwnBudgetDelegation(decoded.callData, ownAccount);
+    chunkS42QSWJY_cjs.assertRedeemsOwnBudgetDelegation(decoded.callData, ownAccount);
   } catch (err) {
     throw new HavenTypedDataRefusedError(err instanceof Error ? err.message : String(err));
   }
 }
 function assertOwnSettlementChild(typedData, expectation, delegateAddress) {
   try {
-    chunkJKUIE45B_cjs.verifySettlementChild(typedData, {
+    chunkS42QSWJY_cjs.verifySettlementChild(typedData, {
       ...expectation,
-      delegatorAccount: chunkJKUIE45B_cjs.deriveDelegateAccountAddress(delegateAddress)
+      delegatorAccount: chunkS42QSWJY_cjs.deriveDelegateAccountAddress(delegateAddress)
     });
   } catch (err) {
     if (err instanceof HavenTypedDataRefusedError) throw err;
-    if (err instanceof chunkJKUIE45B_cjs.HavenSigningError) throw new HavenTypedDataRefusedError(err.message);
+    if (err instanceof chunkS42QSWJY_cjs.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)}).`
     );
@@ -129,7 +129,7 @@ function assertFundingLegPaysDelegate(typedData, expected) {
   try {
     const { args: executeArgs } = viem.decodeFunctionData({ abi: EXECUTE_ABI, data: message.callData });
     const inner = executeArgs[0].callData;
-    const { args } = viem.decodeFunctionData({ abi: chunkJKUIE45B_cjs.REDEEM_DELEGATIONS_ABI, data: inner });
+    const { args } = viem.decodeFunctionData({ abi: chunkS42QSWJY_cjs.REDEEM_DELEGATIONS_ABI, data: inner });
     const executions = args[2];
     executionCallData = executions[0];
   } catch {
@@ -248,7 +248,7 @@ var TRANSFER_WITH_AUTHORIZATION_TYPES = {
 function sweepUsdcAddress(chainId) {
   const address = USDC_ADDRESS_BY_CHAIN[chainId];
   if (!address) {
-    throw new chunkJKUIE45B_cjs.HavenSigningError(
+    throw new chunkS42QSWJY_cjs.HavenSigningError(
       `Sweep is not supported on chain ${chainId}. Supported: ${SWEEPABLE_CHAIN_IDS.join(", ")}.`
     );
   }
@@ -257,7 +257,7 @@ function sweepUsdcAddress(chainId) {
 function sweepUsdcDomain(chainId) {
   const domain = USDC_EIP712_DOMAIN_BY_CHAIN[chainId];
   if (!domain) {
-    throw new chunkJKUIE45B_cjs.HavenSigningError(
+    throw new chunkS42QSWJY_cjs.HavenSigningError(
       `Sweep is not supported on chain ${chainId}. Supported: ${SWEEPABLE_CHAIN_IDS.join(", ")}.`
     );
   }
@@ -270,12 +270,12 @@ function buildSweepTypedData(auth) {
   const domain = sweepUsdcDomain(auth.chainId);
   const expectedToken = sweepUsdcAddress(auth.chainId);
   if (!sameAddress(auth.token, expectedToken)) {
-    throw new chunkJKUIE45B_cjs.HavenSigningError(
+    throw new chunkS42QSWJY_cjs.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 chunkJKUIE45B_cjs.HavenSigningError("Sweep nonce must be a 0x-prefixed 32-byte hex string.");
+    throw new chunkS42QSWJY_cjs.HavenSigningError("Sweep nonce must be a 0x-prefixed 32-byte hex string.");
   }
   return {
     domain,
@@ -779,7 +779,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}`;
@@ -898,14 +898,326 @@ 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, chunkS42QSWJY_cjs.DELEGATION_MANAGER)) {
+    refuseTaskChild(
+      "the EIP-712 domain names an unknown DelegationManager",
+      `Expected ${chunkS42QSWJY_cjs.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 = chunkS42QSWJY_cjs.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() === chunkS42QSWJY_cjs.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, chunkS42QSWJY_cjs.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, chunkS42QSWJY_cjs.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, chunkS42QSWJY_cjs.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: chunkS42QSWJY_cjs.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 = chunkS42QSWJY_cjs.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 } = viem.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 = viem.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() !== chunkS42QSWJY_cjs.DELEGATION_MANAGER.toLowerCase()) {
+    throw new HavenTypedDataRefusedError(
+      `This close UserOperation's execute() calls ${decoded.target}, not the DelegationManager (${chunkS42QSWJY_cjs.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 } = viem.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 = viem.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() === chunkS42QSWJY_cjs.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 = viem.keccak256(caveat.terms);
+  const encoded = viem.encodeAbiParameters(
+    [{ type: "bytes32" }, { type: "address" }, { type: "bytes32" }],
+    [CAVEAT_TYPEHASH, caveat.enforcer, termsHash]
+  );
+  return viem.keccak256(encoded);
+}
+function hashCaveatsArray(caveats) {
+  const concatenated = `0x${caveats.map((c) => hashCaveat(c).slice(2)).join("")}`;
+  return viem.keccak256(concatenated);
+}
+function hashDelegation(delegation) {
+  const caveatsHash = hashCaveatsArray(delegation.caveats);
+  const encoded = viem.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 viem.keccak256(encoded);
+}
 
+exports.CAVEAT_TYPEHASH = CAVEAT_TYPEHASH;
 exports.DEFAULT_NEXT_TOOL_BY_ACTION = DEFAULT_NEXT_TOOL_BY_ACTION;
+exports.DELEGATION_TYPEHASH = DELEGATION_TYPEHASH;
 exports.DIRECT_PAYMENT_CHAIN_IDS = DIRECT_PAYMENT_CHAIN_IDS;
 exports.ERC7710_ASSET_TRANSFER_METHOD = ERC7710_ASSET_TRANSFER_METHOD;
 exports.EXECUTE_ABI = EXECUTE_ABI;
 exports.HAVEN_CLIENT_HEADER = HAVEN_CLIENT_HEADER;
 exports.HAVEN_MINIMUM_NODE_VERSION = HAVEN_MINIMUM_NODE_VERSION;
 exports.HavenTypedDataRefusedError = HavenTypedDataRefusedError;
+exports.MAX_TASK_BUDGET_TTL_SECONDS = MAX_TASK_BUDGET_TTL_SECONDS;
 exports.NEXT_TOOL_SERVER_NAMES = NEXT_TOOL_SERVER_NAMES;
 exports.NEXT_TOOL_SERVER_ROLES = NEXT_TOOL_SERVER_ROLES;
 exports.SDK_CLIENT_IDENTITY = SDK_CLIENT_IDENTITY;
@@ -928,6 +1240,8 @@ exports.X402_SETTLEMENT_FORWARD_MARGIN_SECONDS = X402_SETTLEMENT_FORWARD_MARGIN_
 exports.assertBoundDirectPaymentUserOp = assertBoundDirectPaymentUserOp;
 exports.assertFundingLegPaysDelegate = assertFundingLegPaysDelegate;
 exports.assertOwnSettlementChild = assertOwnSettlementChild;
+exports.assertOwnTaskBudgetCloseUserOp = assertOwnTaskBudgetCloseUserOp;
+exports.assertOwnTaskChild = assertOwnTaskChild;
 exports.buildSweepAuthorizationMessage = buildSweepAuthorizationMessage;
 exports.buildSweepTypedData = buildSweepTypedData;
 exports.buildX402ExpectedMessage = buildX402ExpectedMessage;
@@ -940,10 +1254,12 @@ exports.defaultNextToolFor = defaultNextToolFor;
 exports.encodeBase64Json = encodeBase64Json;
 exports.encodeBase64Utf8 = encodeBase64Utf8;
 exports.encodePaymentProof = encodePaymentProof;
+exports.hashDelegation = hashDelegation;
 exports.havenClientIdentity = havenClientIdentity;
 exports.isErc7710Option = isErc7710Option;
 exports.isSupportedNodeVersion = isSupportedNodeVersion;
 exports.isSweepableChain = isSweepableChain;
+exports.isTaskChildTypedData = isTaskChildTypedData;
 exports.normalizePaymentRequired = normalizePaymentRequired;
 exports.parseNextTool = parseNextTool;
 exports.parsePaymentRequired = parsePaymentRequired;
@@ -966,5 +1282,5 @@ exports.x402FacilitatorAddresses = x402FacilitatorAddresses;
 exports.x402PaymentHeaderNamesFor = x402PaymentHeaderNamesFor;
 exports.x402PaymentHeaderNamesSent = x402PaymentHeaderNamesSent;
 exports.x402V2PaymentEnvelope = x402V2PaymentEnvelope;
-//# sourceMappingURL=chunk-QSSVOPWA.cjs.map
-//# sourceMappingURL=chunk-QSSVOPWA.cjs.map
+//# sourceMappingURL=chunk-CK4NLLMO.cjs.map
+//# sourceMappingURL=chunk-CK4NLLMO.cjs.map