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

package/dist/test-support.cjs

@@ -0,0 +1,215 @@
+'use strict';
+
+var chunkS42QSWJY_cjs = require('./chunk-S42QSWJY.cjs');
+var viem = require('viem');
+
+var ZERO_BYTES32 = `0x${"00".repeat(32)}`;
+var ROOT_AUTHORITY = `0x${"ff".repeat(32)}`;
+var DEFAULT_DELEGATOR = "0x98989898989898989898989898989898989898De";
+var DELEGATION_ARRAY_PARAM = [
+  { type: "tuple[]", components: chunkS42QSWJY_cjs.DELEGATION_TUPLE_COMPONENTS }
+];
+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"
+  }
+];
+var TRANSFER_ABI = [
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "nonpayable"
+  }
+];
+function buildDelegation(overrides) {
+  return {
+    delegate: overrides.delegate,
+    delegator: overrides.delegator ?? DEFAULT_DELEGATOR,
+    authority: overrides.authority ?? ROOT_AUTHORITY,
+    caveats: overrides.caveats ?? [
+      // A real-shaped (if inert for test purposes) TimestampEnforcer term —
+      // real budget delegations always carry at least one caveat.
+      { enforcer: "0x1046bb45C8d673d4ea75321280DB34899413c069", terms: `0x${"00".repeat(32)}`, args: "0x" }
+    ],
+    salt: overrides.salt ?? 1n,
+    signature: overrides.signature ?? `0x${"ab".repeat(65)}`
+  };
+}
+function buildPermissionContext(delegation) {
+  return viem.encodeAbiParameters(DELEGATION_ARRAY_PARAM, [[delegation]]);
+}
+function buildChainPermissionContext(chain) {
+  return viem.encodeAbiParameters(DELEGATION_ARRAY_PARAM, [chain]);
+}
+function buildEmptyPermissionContext() {
+  return viem.encodeAbiParameters(DELEGATION_ARRAY_PARAM, [[]]);
+}
+function buildSingleExecutionCallData(target, value, innerCallData) {
+  return viem.encodePacked(["address", "uint256", "bytes"], [target, value, innerCallData]);
+}
+function buildTransferExecutionCallData(token, to, amount) {
+  return buildSingleExecutionCallData(
+    token,
+    0n,
+    viem.encodeFunctionData({ abi: TRANSFER_ABI, functionName: "transfer", args: [to, amount] })
+  );
+}
+function buildBoundRedeemDelegationsCallData(options) {
+  const delegation = buildDelegation({ delegate: options.delegate, delegator: options.delegator, caveats: options.caveats });
+  const permissionContext = buildPermissionContext(delegation);
+  const executionCallData = options.executionCallData ?? buildTransferExecutionCallData(
+    "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    // Base Sepolia USDC, matches the real captured fixture
+    "0x98ffBf30459a98FD80fAce18f519967769641F76",
+    10000n
+  );
+  return viem.encodeFunctionData({
+    abi: chunkS42QSWJY_cjs.REDEEM_DELEGATIONS_ABI,
+    functionName: "redeemDelegations",
+    args: [[permissionContext], [chunkS42QSWJY_cjs.SINGLE_DEFAULT_MODE], [executionCallData]]
+  });
+}
+function buildEmptyPermissionContextRedemption(selfCallCallData) {
+  return viem.encodeFunctionData({
+    abi: chunkS42QSWJY_cjs.REDEEM_DELEGATIONS_ABI,
+    functionName: "redeemDelegations",
+    args: [[buildEmptyPermissionContext()], [chunkS42QSWJY_cjs.SINGLE_DEFAULT_MODE], [selfCallCallData]]
+  });
+}
+function buildExecuteCallData(target, value, innerCallData) {
+  return viem.encodeFunctionData({
+    abi: EXECUTE_ABI,
+    functionName: "execute",
+    args: [{ target, value, callData: innerCallData }]
+  });
+}
+function buildBoundDirectUserOp(options) {
+  const chainId = options.chainId ?? 84532;
+  const sender = options.sender ?? chunkS42QSWJY_cjs.deriveDelegateAccountAddress(options.delegate);
+  const callData = options.callData ?? buildExecuteCallData(
+    options.target ?? chunkS42QSWJY_cjs.DELEGATION_MANAGER,
+    options.value ?? 0n,
+    buildBoundRedeemDelegationsCallData({ delegate: sender, delegator: options.delegator })
+  );
+  const typedData = {
+    domain: {
+      name: chunkS42QSWJY_cjs.HYBRID_DELEGATOR_DOMAIN_NAME,
+      version: chunkS42QSWJY_cjs.HYBRID_DELEGATOR_DOMAIN_VERSION,
+      chainId,
+      verifyingContract: sender
+    },
+    types: { PackedUserOperation: chunkS42QSWJY_cjs.PACKED_USER_OPERATION_FIELDS.map((field) => ({ ...field })) },
+    primaryType: "PackedUserOperation",
+    message: {
+      sender,
+      nonce: "0",
+      initCode: "0x",
+      callData,
+      accountGasLimits: ZERO_BYTES32,
+      preVerificationGas: "0",
+      gasFees: ZERO_BYTES32,
+      paymasterAndData: "0x",
+      entryPoint: chunkS42QSWJY_cjs.ENTRY_POINT_V07
+    }
+  };
+  const payloadHash = chunkS42QSWJY_cjs.packedUserOperationHash(typedData);
+  return { typedData, payloadHash, sender };
+}
+function buildSelfCallCallData(sender) {
+  const TRANSFER_OWNERSHIP_ABI = [
+    { type: "function", name: "transferOwnership", inputs: [{ name: "newOwner", type: "address" }], outputs: [], stateMutability: "nonpayable" }
+  ];
+  const inner = viem.encodeFunctionData({
+    abi: TRANSFER_OWNERSHIP_ABI,
+    functionName: "transferOwnership",
+    args: ["0x000000000000000000000000000000000000dEaD"]
+  });
+  return buildExecuteCallData(sender, 0n, inner);
+}
+function rebuildDirectUserOpForSender(fixtureTypedData, newSender) {
+  const originalCallData = fixtureTypedData.message.callData;
+  const { args: executeArgs } = viem.decodeFunctionData({ abi: EXECUTE_ABI, data: originalCallData });
+  const execution = executeArgs[0];
+  const { args: redeemArgs } = viem.decodeFunctionData({ abi: chunkS42QSWJY_cjs.REDEEM_DELEGATIONS_ABI, data: execution.callData });
+  const [permissionContexts, modes, executionCallDatas] = redeemArgs;
+  const [delegations] = viem.decodeAbiParameters(DELEGATION_ARRAY_PARAM, permissionContexts[0]);
+  const adjustedDelegations = delegations.map(
+    (d, i) => i === 0 ? { ...d, delegate: newSender } : d
+  );
+  const adjustedPermissionContext = viem.encodeAbiParameters(DELEGATION_ARRAY_PARAM, [adjustedDelegations]);
+  const adjustedRedeemCallData = viem.encodeFunctionData({
+    abi: chunkS42QSWJY_cjs.REDEEM_DELEGATIONS_ABI,
+    functionName: "redeemDelegations",
+    args: [[adjustedPermissionContext], modes, executionCallDatas]
+  });
+  const adjustedCallData = viem.encodeFunctionData({
+    abi: EXECUTE_ABI,
+    functionName: "execute",
+    args: [{ target: execution.target, value: execution.value, callData: adjustedRedeemCallData }]
+  });
+  const typedData = {
+    ...fixtureTypedData,
+    domain: { ...fixtureTypedData.domain, verifyingContract: newSender },
+    message: { ...fixtureTypedData.message, sender: newSender, callData: adjustedCallData }
+  };
+  const payloadHash = chunkS42QSWJY_cjs.packedUserOperationHash(typedData);
+  return { typedData, payloadHash };
+}
+function buildFundingLegUserOp(options) {
+  const sender = chunkS42QSWJY_cjs.deriveDelegateAccountAddress(options.delegate);
+  const callData = buildExecuteCallData(
+    chunkS42QSWJY_cjs.DELEGATION_MANAGER,
+    0n,
+    buildBoundRedeemDelegationsCallData({
+      delegate: sender,
+      caveats: options.caveats,
+      executionCallData: buildTransferExecutionCallData(
+        options.asset,
+        options.recipient ?? options.delegate,
+        BigInt(options.amount)
+      )
+    })
+  );
+  const { typedData, payloadHash } = buildBoundDirectUserOp({
+    delegate: options.delegate,
+    chainId: options.chainId ?? 84532,
+    callData
+  });
+  return { typedData, payloadHash, digest: viem.hashTypedData(typedData) };
+}
+
+exports.DEFAULT_DELEGATOR = DEFAULT_DELEGATOR;
+exports.buildBoundDirectUserOp = buildBoundDirectUserOp;
+exports.buildBoundRedeemDelegationsCallData = buildBoundRedeemDelegationsCallData;
+exports.buildChainPermissionContext = buildChainPermissionContext;
+exports.buildDelegation = buildDelegation;
+exports.buildEmptyPermissionContext = buildEmptyPermissionContext;
+exports.buildEmptyPermissionContextRedemption = buildEmptyPermissionContextRedemption;
+exports.buildExecuteCallData = buildExecuteCallData;
+exports.buildFundingLegUserOp = buildFundingLegUserOp;
+exports.buildPermissionContext = buildPermissionContext;
+exports.buildSelfCallCallData = buildSelfCallCallData;
+exports.buildSingleExecutionCallData = buildSingleExecutionCallData;
+exports.buildTransferExecutionCallData = buildTransferExecutionCallData;
+exports.rebuildDirectUserOpForSender = rebuildDirectUserOpForSender;
+//# sourceMappingURL=test-support.cjs.map
+//# sourceMappingURL=test-support.cjs.map

package/dist/test-support.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/test-support/direct-userop.ts"],"names":["DELEGATION_TUPLE_COMPONENTS","encodeAbiParameters","encodePacked","encodeFunctionData","REDEEM_DELEGATIONS_ABI","SINGLE_DEFAULT_MODE","deriveDelegateAccountAddress","DELEGATION_MANAGER","HYBRID_DELEGATOR_DOMAIN_NAME","HYBRID_DELEGATOR_DOMAIN_VERSION","PACKED_USER_OPERATION_FIELDS","ENTRY_POINT_V07","packedUserOperationHash","decodeFunctionData","decodeAbiParameters","hashTypedData"],"mappings":"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","file":"test-support.cjs","sourcesContent":["/**\n * #3272 — a real-shaped, BOUND direct-payment `PackedUserOperation` for\n * signer tests: `sender` is the counterfactual delegate account for a given\n * owner EOA, and `callData` is `execute(DelegationManager, 0,\n * redeemDelegations(...))` with a REAL redemption shape — one non-empty\n * `Delegation`, `delegate` = the signer's own account, `delegator` = a\n * distinct treasury address, `ExecutionMode.SingleDefault`, an\n * `encodePacked(target,value,callData)` execution — mirroring\n * `packages/backend/src/rails/delegation-rail.ts`'s `prepareRedemption`.\n * Replaces the toy 2-field / empty-callData / empty-arrays fixtures the\n * allowlist correctly refuses (including the B1 empty-permission-context\n * bypass, `buildEmptyPermissionContextRedemption` below, kept ONLY to\n * reproduce that exact refusal in a test).\n *\n * Moved here from `@haven_ai/signer` by #3283 so the SDK, the signer,\n * `@haven_ai/mcp` and `mcp-server` share ONE guard-valid builder. Published\n * as the `@haven_ai/sdk/test-support` subpath only because a sibling\n * package's tests cannot import this file by relative path (each package's\n * `tsc` `rootDir` is its own `src`). Test fixtures, not a signing API:\n * nothing here signs, and nothing the SDK or signer runs imports it.\n */\nimport {\n  decodeAbiParameters,\n  decodeFunctionData,\n  encodeAbiParameters,\n  encodeFunctionData,\n  encodePacked,\n  hashTypedData,\n  type Address,\n  type Hex,\n} from 'viem'\nimport {\n  ENTRY_POINT_V07,\n  HYBRID_DELEGATOR_DOMAIN_NAME,\n  HYBRID_DELEGATOR_DOMAIN_VERSION,\n  PACKED_USER_OPERATION_FIELDS,\n  packedUserOperationHash,\n} from '../userop-binding.js'\nimport { DELEGATION_MANAGER } from '../settlement-child.js'\nimport { deriveDelegateAccountAddress } from '../delegate-account.js'\nimport { DELEGATION_TUPLE_COMPONENTS, REDEEM_DELEGATIONS_ABI, SINGLE_DEFAULT_MODE } from '../redemption-guard.js'\n\nconst ZERO_BYTES32 = `0x${'00'.repeat(32)}` as const\n\n/** `Delegation.authority` sentinel for a root (unchained) delegation — `@metamask/delegation-core`'s `ROOT_AUTHORITY`. */\nconst ROOT_AUTHORITY: Hex = `0x${'ff'.repeat(32)}`\n\n/** Stand-in treasury address — distinct from any derived signer account, matching the real fixture's `delegator`. */\nexport const DEFAULT_DELEGATOR: Address = '0x98989898989898989898989898989898989898De' as Address\n\nconst DELEGATION_ARRAY_PARAM = [\n  { type: 'tuple[]', components: DELEGATION_TUPLE_COMPONENTS },\n] as const\n\nconst EXECUTE_ABI = [\n  {\n    type: 'function',\n    name: 'execute',\n    inputs: [\n      {\n        name: '_execution',\n        type: 'tuple',\n        components: [\n          { name: 'target', type: 'address' },\n          { name: 'value', type: 'uint256' },\n          { name: 'callData', type: 'bytes' },\n        ],\n      },\n    ],\n    outputs: [],\n    stateMutability: 'payable',\n  },\n] as const\n\nconst TRANSFER_ABI = [\n  {\n    type: 'function',\n    name: 'transfer',\n    inputs: [\n      { name: 'to', type: 'address' },\n      { name: 'amount', type: 'uint256' },\n    ],\n    outputs: [{ type: 'bool' }],\n    stateMutability: 'nonpayable',\n  },\n] as const\n\nexport interface DelegationOverrides {\n  /** The redeemer this delegation authorises — normally the signer's own derived account. */\n  delegate: Address\n  /** Who granted it — must differ from `delegate` for a real (non-self) delegation. */\n  delegator?: Address\n  authority?: Hex\n  caveats?: Array<{ enforcer: Address; terms: Hex; args: Hex }>\n  salt?: bigint\n  signature?: Hex\n}\n\n/** A single, well-formed `Delegation` tuple — the ONE-link chain Haven's backend redeems (`delegations: [[delegation]]`). */\nexport function buildDelegation(overrides: DelegationOverrides) {\n  return {\n    delegate: overrides.delegate,\n    delegator: overrides.delegator ?? DEFAULT_DELEGATOR,\n    authority: overrides.authority ?? ROOT_AUTHORITY,\n    caveats: overrides.caveats ?? [\n      // A real-shaped (if inert for test purposes) TimestampEnforcer term —\n      // real budget delegations always carry at least one caveat.\n      { enforcer: '0x1046bb45C8d673d4ea75321280DB34899413c069' as Address, terms: `0x${'00'.repeat(32)}` as Hex, args: '0x' as Hex },\n    ],\n    salt: overrides.salt ?? 1n,\n    signature: overrides.signature ?? (`0x${'ab'.repeat(65)}` as Hex),\n  }\n}\n\n/** `abi.encode(Delegation[])` for a ONE-delegation chain — a Haven-shaped permission context. */\nexport function buildPermissionContext(delegation: ReturnType<typeof buildDelegation>): Hex {\n  return encodeAbiParameters(DELEGATION_ARRAY_PARAM, [[delegation]])\n}\n\n/** `abi.encode(Delegation[])` for a MULTI-link chain (leaf first) — never emitted by Haven. */\nexport function buildChainPermissionContext(chain: ReturnType<typeof buildDelegation>[]): Hex {\n  return encodeAbiParameters(DELEGATION_ARRAY_PARAM, [chain])\n}\n\n/** `abi.encode(Delegation[])` for an EMPTY chain — the exact B1 bypass shape MetaMask's DelegationManager treats as self-authorised. */\nexport function buildEmptyPermissionContext(): Hex {\n  return encodeAbiParameters(DELEGATION_ARRAY_PARAM, [[]])\n}\n\n/** `encodePacked(address,uint256,bytes)` — the single-execution calldata `ExecutionMode.SingleDefault` expects. */\nexport function buildSingleExecutionCallData(target: Address, value: bigint, innerCallData: Hex): Hex {\n  return encodePacked(['address', 'uint256', 'bytes'], [target, value, innerCallData])\n}\n\n/** A real-shaped ERC-20 `transfer(to, amount)` execution — what a budget redemption actually spends. */\nexport function buildTransferExecutionCallData(token: Address, to: Address, amount: bigint): Hex {\n  return buildSingleExecutionCallData(\n    token,\n    0n,\n    encodeFunctionData({ abi: TRANSFER_ABI, functionName: 'transfer', args: [to, amount] }),\n  )\n}\n\nexport interface BoundRedeemDelegationsOptions {\n  /** The redeemer — normally the signer's own derived account (matches the UserOp's `sender`). */\n  delegate: Address\n  delegator?: Address\n  caveats?: DelegationOverrides['caveats']\n  /** Override the single execution's calldata entirely (default: a real-shaped ERC-20 transfer). */\n  executionCallData?: Hex\n}\n\n/** `redeemDelegations([permissionContext], [SingleDefault], [executionCallData])` — the REAL, bound shape. */\nexport function buildBoundRedeemDelegationsCallData(options: BoundRedeemDelegationsOptions): Hex {\n  const delegation = buildDelegation({ delegate: options.delegate, delegator: options.delegator, caveats: options.caveats })\n  const permissionContext = buildPermissionContext(delegation)\n  const executionCallData =\n    options.executionCallData ??\n    buildTransferExecutionCallData(\n      '0x036CbD53842c5426634e7929541eC2318f3dCF7e' as Address, // Base Sepolia USDC, matches the real captured fixture\n      '0x98ffBf30459a98FD80fAce18f519967769641F76' as Address,\n      10000n,\n    )\n  return encodeFunctionData({\n    abi: REDEEM_DELEGATIONS_ABI,\n    functionName: 'redeemDelegations',\n    args: [[permissionContext], [SINGLE_DEFAULT_MODE], [executionCallData]],\n  })\n}\n\n/**\n * #3272 (B1 regression): `redeemDelegations([emptyPermissionContext],\n * [SingleDefault], [selfCallCallData])` — one permission context whose\n * `Delegation[]` decodes EMPTY, paired with a self-call execution. This is\n * the exact live bypass: MetaMask's DelegationManager treats an empty chain\n * as self-authorised and runs `selfCallCallData` AS the account. Exists only\n * so a test can assert this is refused, never to build a shape any code path\n * signs.\n */\nexport function buildEmptyPermissionContextRedemption(selfCallCallData: Hex): Hex {\n  return encodeFunctionData({\n    abi: REDEEM_DELEGATIONS_ABI,\n    functionName: 'redeemDelegations',\n    args: [[buildEmptyPermissionContext()], [SINGLE_DEFAULT_MODE], [selfCallCallData]],\n  })\n}\n\n/** `execute((address,uint256,bytes))` — selector `0x5c1c6dcd`. */\nexport function buildExecuteCallData(target: Address, value: bigint, innerCallData: Hex): Hex {\n  return encodeFunctionData({\n    abi: EXECUTE_ABI,\n    functionName: 'execute',\n    args: [{ target, value, callData: innerCallData }],\n  })\n}\n\nexport interface BoundDirectUserOpOptions {\n  /** The delegate EOA (`signer.delegateAddress`) that owns the account `sender` derives from. */\n  delegate: Address\n  chainId?: number | bigint | string\n  /** Override the execute() target — default DELEGATION_MANAGER (the bound shape). */\n  target?: Address\n  /** Override the execute() value — default 0n. */\n  value?: bigint\n  /** Override the full message.callData (bypasses target/value/redeemDelegations construction). */\n  callData?: Hex\n  /** Override sender/verifyingContract directly instead of deriving it from `delegate`. */\n  sender?: Address\n  /** Override the redemption's delegator (default: a distinct treasury address). */\n  delegator?: Address\n}\n\nexport interface BoundDirectUserOp {\n  typedData: {\n    domain: { name: string; version: string; chainId: number | bigint | string; verifyingContract: Address }\n    types: { PackedUserOperation: Array<{ name: string; type: string }> }\n    primaryType: 'PackedUserOperation'\n    message: Record<string, unknown>\n  }\n  payloadHash: Hex\n  sender: Address\n}\n\n/**\n * A real-shaped, self-consistent (correct v0.7 hash) `PackedUserOperation`.\n * By default it is fully BOUND per #3272's allowlist: `sender` is the\n * counterfactual account for `delegate`, and `callData` redeems ONE real\n * delegation (delegate = `sender`, delegator = a distinct treasury address)\n * through the DelegationManager. Override `target` / `callData` / `sender` /\n * `delegator` to build the negative-test shapes the allowlist must refuse.\n */\nexport function buildBoundDirectUserOp(options: BoundDirectUserOpOptions): BoundDirectUserOp {\n  const chainId = options.chainId ?? 84532\n  const sender = options.sender ?? deriveDelegateAccountAddress(options.delegate)\n  const callData =\n    options.callData ??\n    buildExecuteCallData(\n      options.target ?? (DELEGATION_MANAGER as Address),\n      options.value ?? 0n,\n      buildBoundRedeemDelegationsCallData({ delegate: sender, delegator: options.delegator }),\n    )\n  const typedData = {\n    domain: {\n      name: HYBRID_DELEGATOR_DOMAIN_NAME,\n      version: HYBRID_DELEGATOR_DOMAIN_VERSION,\n      chainId,\n      verifyingContract: sender,\n    },\n    types: { PackedUserOperation: PACKED_USER_OPERATION_FIELDS.map((field) => ({ ...field })) },\n    primaryType: 'PackedUserOperation' as const,\n    message: {\n      sender,\n      nonce: '0',\n      initCode: '0x',\n      callData,\n      accountGasLimits: ZERO_BYTES32,\n      preVerificationGas: '0',\n      gasFees: ZERO_BYTES32,\n      paymasterAndData: '0x',\n      entryPoint: ENTRY_POINT_V07,\n    },\n  }\n  const payloadHash = packedUserOperationHash(typedData)\n  return { typedData, payloadHash, sender }\n}\n\n/** A well-formed `execute()` self-call — `target === sender` — for the (d)/self-call negative tests. */\nexport function buildSelfCallCallData(sender: Address): Hex {\n  const TRANSFER_OWNERSHIP_ABI = [\n    { type: 'function', name: 'transferOwnership', inputs: [{ name: 'newOwner', type: 'address' }], outputs: [], stateMutability: 'nonpayable' },\n  ] as const\n  const inner = encodeFunctionData({\n    abi: TRANSFER_OWNERSHIP_ABI,\n    functionName: 'transferOwnership',\n    args: ['0x000000000000000000000000000000000000dEaD' as Address],\n  })\n  return buildExecuteCallData(sender, 0n, inner)\n}\n\n/**\n * Re-target a REAL captured direct-payment UserOp (for example\n * `__fixtures__/direct-payment-userop.json`) at `newSender`: the UserOp's\n * `sender` / `verifyingContract` and the redeemed delegation's `delegate`\n * become `newSender`; the delegator, caveats, mode and execution stay the\n * production bytes. The captured fixture is bound to a delegate whose key is\n * not in the repository, so a test signs this rebuilt copy with a test key\n * whose derived account is `newSender` — proving the guard accepts the actual\n * production shape, not only this file's synthetic one.\n */\nexport function rebuildDirectUserOpForSender(\n  fixtureTypedData: {\n    domain: Record<string, unknown>\n    types: Record<string, unknown>\n    primaryType: string\n    message: Record<string, unknown>\n  },\n  newSender: Address,\n) {\n  const originalCallData = fixtureTypedData.message.callData as Hex\n  const { args: executeArgs } = decodeFunctionData({ abi: EXECUTE_ABI, data: originalCallData })\n  const execution = executeArgs[0] as { target: Address; value: bigint; callData: Hex }\n  const { args: redeemArgs } = decodeFunctionData({ abi: REDEEM_DELEGATIONS_ABI, data: execution.callData })\n  const [permissionContexts, modes, executionCallDatas] = redeemArgs as unknown as [\n    readonly Hex[],\n    readonly Hex[],\n    readonly Hex[],\n  ]\n  const [delegations] = decodeAbiParameters(DELEGATION_ARRAY_PARAM, permissionContexts[0])\n  const adjustedDelegations = (delegations as unknown as Array<Record<string, unknown>>).map((d, i) =>\n    i === 0 ? { ...d, delegate: newSender } : d,\n  )\n  const adjustedPermissionContext = encodeAbiParameters(DELEGATION_ARRAY_PARAM, [adjustedDelegations as never])\n  const adjustedRedeemCallData = encodeFunctionData({\n    abi: REDEEM_DELEGATIONS_ABI,\n    functionName: 'redeemDelegations',\n    args: [[adjustedPermissionContext], modes as Hex[], executionCallDatas as Hex[]],\n  })\n  const adjustedCallData = encodeFunctionData({\n    abi: EXECUTE_ABI,\n    functionName: 'execute',\n    args: [{ target: execution.target, value: execution.value, callData: adjustedRedeemCallData }],\n  })\n  const typedData = {\n    ...fixtureTypedData,\n    domain: { ...fixtureTypedData.domain, verifyingContract: newSender },\n    message: { ...fixtureTypedData.message, sender: newSender, callData: adjustedCallData },\n  }\n  const payloadHash = packedUserOperationHash(typedData as never) as Hex\n  return { typedData, payloadHash }\n}\n\nexport interface FundingLegUserOpOptions {\n  /** The delegate EOA (`signer.delegateAddress`): the account is derived from it AND it is the transfer's recipient. */\n  delegate: Address\n  /** The quoted token (the expected context's `asset`). */\n  asset: Address\n  /** The quoted atomic amount (the expected context's `amount`). */\n  amount: bigint | string\n  chainId?: number\n  /** Override the transfer recipient (default: `delegate`) — for the recipient-pin negative test. */\n  recipient?: Address\n  /** Override the budget delegation's caveats (e.g. a multi-KB term, for relay-size tests). */\n  caveats?: DelegationOverrides['caveats']\n}\n\n/**\n * #3281: an x402 EIP-3009 bridge FUNDING LEG exactly as the backend builds it\n * (`delegation-authorize.ts` → `prepareDelegationPayment(agent, token,\n * payTo = the delegate EOA, amountRaw)` → `prepareRedemption`): the\n * direct-payment shape, whose single execution is\n * `transfer(<delegate EOA>, <amount>)` on the quoted token. Returns the typed\n * data, its v0.7 UserOp hash (the expected context's `payloadHash`) and its\n * EIP-712 digest (the expected context's `typedDataHash`).\n */\nexport function buildFundingLegUserOp(options: FundingLegUserOpOptions) {\n  const sender = deriveDelegateAccountAddress(options.delegate)\n  const callData = buildExecuteCallData(\n    DELEGATION_MANAGER as Address,\n    0n,\n    buildBoundRedeemDelegationsCallData({\n      delegate: sender,\n      caveats: options.caveats,\n      executionCallData: buildTransferExecutionCallData(\n        options.asset,\n        options.recipient ?? options.delegate,\n        BigInt(options.amount),\n      ),\n    }),\n  )\n  const { typedData, payloadHash } = buildBoundDirectUserOp({\n    delegate: options.delegate,\n    chainId: options.chainId ?? 84532,\n    callData,\n  })\n  return { typedData, payloadHash, digest: hashTypedData(typedData as never) }\n}\n"]}

package/dist/test-support.d.cts

@@ -0,0 +1,204 @@
+import { Address, Hex } from 'viem';
+
+/**
+ * #3272 — a real-shaped, BOUND direct-payment `PackedUserOperation` for
+ * signer tests: `sender` is the counterfactual delegate account for a given
+ * owner EOA, and `callData` is `execute(DelegationManager, 0,
+ * redeemDelegations(...))` with a REAL redemption shape — one non-empty
+ * `Delegation`, `delegate` = the signer's own account, `delegator` = a
+ * distinct treasury address, `ExecutionMode.SingleDefault`, an
+ * `encodePacked(target,value,callData)` execution — mirroring
+ * `packages/backend/src/rails/delegation-rail.ts`'s `prepareRedemption`.
+ * Replaces the toy 2-field / empty-callData / empty-arrays fixtures the
+ * allowlist correctly refuses (including the B1 empty-permission-context
+ * bypass, `buildEmptyPermissionContextRedemption` below, kept ONLY to
+ * reproduce that exact refusal in a test).
+ *
+ * Moved here from `@haven_ai/signer` by #3283 so the SDK, the signer,
+ * `@haven_ai/mcp` and `mcp-server` share ONE guard-valid builder. Published
+ * as the `@haven_ai/sdk/test-support` subpath only because a sibling
+ * package's tests cannot import this file by relative path (each package's
+ * `tsc` `rootDir` is its own `src`). Test fixtures, not a signing API:
+ * nothing here signs, and nothing the SDK or signer runs imports it.
+ */
+
+/** Stand-in treasury address — distinct from any derived signer account, matching the real fixture's `delegator`. */
+declare const DEFAULT_DELEGATOR: Address;
+interface DelegationOverrides {
+    /** The redeemer this delegation authorises — normally the signer's own derived account. */
+    delegate: Address;
+    /** Who granted it — must differ from `delegate` for a real (non-self) delegation. */
+    delegator?: Address;
+    authority?: Hex;
+    caveats?: Array<{
+        enforcer: Address;
+        terms: Hex;
+        args: Hex;
+    }>;
+    salt?: bigint;
+    signature?: Hex;
+}
+/** A single, well-formed `Delegation` tuple — the ONE-link chain Haven's backend redeems (`delegations: [[delegation]]`). */
+declare function buildDelegation(overrides: DelegationOverrides): {
+    delegate: `0x${string}`;
+    delegator: `0x${string}`;
+    authority: `0x${string}`;
+    caveats: {
+        enforcer: Address;
+        terms: Hex;
+        args: Hex;
+    }[];
+    salt: bigint;
+    signature: `0x${string}`;
+};
+/** `abi.encode(Delegation[])` for a ONE-delegation chain — a Haven-shaped permission context. */
+declare function buildPermissionContext(delegation: ReturnType<typeof buildDelegation>): Hex;
+/** `abi.encode(Delegation[])` for a MULTI-link chain (leaf first) — never emitted by Haven. */
+declare function buildChainPermissionContext(chain: ReturnType<typeof buildDelegation>[]): Hex;
+/** `abi.encode(Delegation[])` for an EMPTY chain — the exact B1 bypass shape MetaMask's DelegationManager treats as self-authorised. */
+declare function buildEmptyPermissionContext(): Hex;
+/** `encodePacked(address,uint256,bytes)` — the single-execution calldata `ExecutionMode.SingleDefault` expects. */
+declare function buildSingleExecutionCallData(target: Address, value: bigint, innerCallData: Hex): Hex;
+/** A real-shaped ERC-20 `transfer(to, amount)` execution — what a budget redemption actually spends. */
+declare function buildTransferExecutionCallData(token: Address, to: Address, amount: bigint): Hex;
+interface BoundRedeemDelegationsOptions {
+    /** The redeemer — normally the signer's own derived account (matches the UserOp's `sender`). */
+    delegate: Address;
+    delegator?: Address;
+    caveats?: DelegationOverrides['caveats'];
+    /** Override the single execution's calldata entirely (default: a real-shaped ERC-20 transfer). */
+    executionCallData?: Hex;
+}
+/** `redeemDelegations([permissionContext], [SingleDefault], [executionCallData])` — the REAL, bound shape. */
+declare function buildBoundRedeemDelegationsCallData(options: BoundRedeemDelegationsOptions): Hex;
+/**
+ * #3272 (B1 regression): `redeemDelegations([emptyPermissionContext],
+ * [SingleDefault], [selfCallCallData])` — one permission context whose
+ * `Delegation[]` decodes EMPTY, paired with a self-call execution. This is
+ * the exact live bypass: MetaMask's DelegationManager treats an empty chain
+ * as self-authorised and runs `selfCallCallData` AS the account. Exists only
+ * so a test can assert this is refused, never to build a shape any code path
+ * signs.
+ */
+declare function buildEmptyPermissionContextRedemption(selfCallCallData: Hex): Hex;
+/** `execute((address,uint256,bytes))` — selector `0x5c1c6dcd`. */
+declare function buildExecuteCallData(target: Address, value: bigint, innerCallData: Hex): Hex;
+interface BoundDirectUserOpOptions {
+    /** The delegate EOA (`signer.delegateAddress`) that owns the account `sender` derives from. */
+    delegate: Address;
+    chainId?: number | bigint | string;
+    /** Override the execute() target — default DELEGATION_MANAGER (the bound shape). */
+    target?: Address;
+    /** Override the execute() value — default 0n. */
+    value?: bigint;
+    /** Override the full message.callData (bypasses target/value/redeemDelegations construction). */
+    callData?: Hex;
+    /** Override sender/verifyingContract directly instead of deriving it from `delegate`. */
+    sender?: Address;
+    /** Override the redemption's delegator (default: a distinct treasury address). */
+    delegator?: Address;
+}
+interface BoundDirectUserOp {
+    typedData: {
+        domain: {
+            name: string;
+            version: string;
+            chainId: number | bigint | string;
+            verifyingContract: Address;
+        };
+        types: {
+            PackedUserOperation: Array<{
+                name: string;
+                type: string;
+            }>;
+        };
+        primaryType: 'PackedUserOperation';
+        message: Record<string, unknown>;
+    };
+    payloadHash: Hex;
+    sender: Address;
+}
+/**
+ * A real-shaped, self-consistent (correct v0.7 hash) `PackedUserOperation`.
+ * By default it is fully BOUND per #3272's allowlist: `sender` is the
+ * counterfactual account for `delegate`, and `callData` redeems ONE real
+ * delegation (delegate = `sender`, delegator = a distinct treasury address)
+ * through the DelegationManager. Override `target` / `callData` / `sender` /
+ * `delegator` to build the negative-test shapes the allowlist must refuse.
+ */
+declare function buildBoundDirectUserOp(options: BoundDirectUserOpOptions): BoundDirectUserOp;
+/** A well-formed `execute()` self-call — `target === sender` — for the (d)/self-call negative tests. */
+declare function buildSelfCallCallData(sender: Address): Hex;
+/**
+ * Re-target a REAL captured direct-payment UserOp (for example
+ * `__fixtures__/direct-payment-userop.json`) at `newSender`: the UserOp's
+ * `sender` / `verifyingContract` and the redeemed delegation's `delegate`
+ * become `newSender`; the delegator, caveats, mode and execution stay the
+ * production bytes. The captured fixture is bound to a delegate whose key is
+ * not in the repository, so a test signs this rebuilt copy with a test key
+ * whose derived account is `newSender` — proving the guard accepts the actual
+ * production shape, not only this file's synthetic one.
+ */
+declare function rebuildDirectUserOpForSender(fixtureTypedData: {
+    domain: Record<string, unknown>;
+    types: Record<string, unknown>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}, newSender: Address): {
+    typedData: {
+        domain: {
+            verifyingContract: `0x${string}`;
+        };
+        message: {
+            sender: `0x${string}`;
+            callData: `0x${string}`;
+        };
+        types: Record<string, unknown>;
+        primaryType: string;
+    };
+    payloadHash: `0x${string}`;
+};
+interface FundingLegUserOpOptions {
+    /** The delegate EOA (`signer.delegateAddress`): the account is derived from it AND it is the transfer's recipient. */
+    delegate: Address;
+    /** The quoted token (the expected context's `asset`). */
+    asset: Address;
+    /** The quoted atomic amount (the expected context's `amount`). */
+    amount: bigint | string;
+    chainId?: number;
+    /** Override the transfer recipient (default: `delegate`) — for the recipient-pin negative test. */
+    recipient?: Address;
+    /** Override the budget delegation's caveats (e.g. a multi-KB term, for relay-size tests). */
+    caveats?: DelegationOverrides['caveats'];
+}
+/**
+ * #3281: an x402 EIP-3009 bridge FUNDING LEG exactly as the backend builds it
+ * (`delegation-authorize.ts` → `prepareDelegationPayment(agent, token,
+ * payTo = the delegate EOA, amountRaw)` → `prepareRedemption`): the
+ * direct-payment shape, whose single execution is
+ * `transfer(<delegate EOA>, <amount>)` on the quoted token. Returns the typed
+ * data, its v0.7 UserOp hash (the expected context's `payloadHash`) and its
+ * EIP-712 digest (the expected context's `typedDataHash`).
+ */
+declare function buildFundingLegUserOp(options: FundingLegUserOpOptions): {
+    typedData: {
+        domain: {
+            name: string;
+            version: string;
+            chainId: number | bigint | string;
+            verifyingContract: Address;
+        };
+        types: {
+            PackedUserOperation: Array<{
+                name: string;
+                type: string;
+            }>;
+        };
+        primaryType: "PackedUserOperation";
+        message: Record<string, unknown>;
+    };
+    payloadHash: `0x${string}`;
+    digest: `0x${string}`;
+};
+
+export { type BoundDirectUserOp, type BoundDirectUserOpOptions, type BoundRedeemDelegationsOptions, DEFAULT_DELEGATOR, type DelegationOverrides, type FundingLegUserOpOptions, buildBoundDirectUserOp, buildBoundRedeemDelegationsCallData, buildChainPermissionContext, buildDelegation, buildEmptyPermissionContext, buildEmptyPermissionContextRedemption, buildExecuteCallData, buildFundingLegUserOp, buildPermissionContext, buildSelfCallCallData, buildSingleExecutionCallData, buildTransferExecutionCallData, rebuildDirectUserOpForSender };