@rhinestone/sdk 1.4.1 → 1.4.2

package/dist/src/modules/validators/policies/claim/permit2.test.js

@@ -0,0 +1,519 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const vitest_1 = require("vitest");
+const permit2_1 = require("./permit2");
+const types_1 = require("./types");
+// ---------------------------------------------------------------------------
+// Shared fixtures
+// ---------------------------------------------------------------------------
+const TOKEN_A = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'; // USDC
+const TOKEN_B = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'; // WETH
+const ARBITER = '0x1234567890123456789012345678901234567890';
+/** Zero-value Op struct (vt is bytes32, empty ops) */
+const EMPTY_OP = {
+    vt: viem_1.zeroHash,
+    ops: [],
+};
+/** A simple message with one permitted token and no mandate ops */
+const baseMessage = {
+    permitted: [{ token: TOKEN_A, amount: 1000n }],
+    spender: ARBITER,
+    nonce: 42n,
+    deadline: 9999999n,
+    mandate: {
+        target: {
+            recipient: ARBITER,
+            tokenOut: [{ token: TOKEN_B, amount: 500n }],
+            targetChain: 8453n,
+            fillExpiry: 888888n,
+        },
+        minGas: 100000n,
+        originOps: EMPTY_OP,
+        destOps: EMPTY_OP,
+        q: (0, viem_1.keccak256)('0x'),
+    },
+};
+// ---------------------------------------------------------------------------
+// Hash helpers (mirror of the private functions in permit2.ts)
+// ---------------------------------------------------------------------------
+const TYPEHASH_PERMIT2_TOKEN = '0x618358ac3db8dc274f0cd8829da7e234bd48cd73c4a740aede1adec9846d06a1';
+const TYPEHASH_TOKENOUT = '0x55550a068ac7a6c7ce02eac46ebe7c7b964dd10d7800455df1c5bc5a6685a42c';
+const TYPEHASH_TARGET = '0xf72802bb5695954ab337feb3d113d61f4206cfaef3987552df2b2b47477db74b';
+const TYPEHASH_OPS = '0x09b0a32e9842b65559835c235891737e06927d59e48a6f0e0512e136a513a9e4';
+const TYPEHASH_OP = '0xdbc520cb50a8aaf3fa06ea43dc3d59d248e52ae638476e3268a1e6e36bffe196';
+const TYPEHASH_MANDATE = '0xc988b4da10503879cf4b893fed09620229f5ade301ef5e4af6124b22823627dc';
+function hashArray(hashes) {
+    return (0, viem_1.keccak256)(hashes.length > 0 ? (0, viem_1.concat)(hashes) : '0x');
+}
+function hashToken(token, amount, typehash) {
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'bytes32' }, { type: 'address' }, { type: 'uint256' }], [typehash, token, amount]));
+}
+function hashOp(op) {
+    const execHashes = Array.from(op.ops).map((e) => (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { type: 'bytes32' },
+        { type: 'address' },
+        { type: 'uint256' },
+        { type: 'bytes32' },
+    ], [TYPEHASH_OPS, e.to, e.value, (0, viem_1.keccak256)(e.data)])));
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'bytes32' }, { type: 'bytes32' }, { type: 'bytes32' }], [TYPEHASH_OP, op.vt, hashArray(execHashes)]));
+}
+function hashTarget(recipient, tokenOutHash, targetChain, fillExpiry) {
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { type: 'bytes32' },
+        { type: 'address' },
+        { type: 'bytes32' },
+        { type: 'uint256' },
+        { type: 'uint256' },
+    ], [TYPEHASH_TARGET, recipient, tokenOutHash, targetChain, fillExpiry]));
+}
+function hashMandate(targetHash, minGas, originOpsHash, destOpsHash, q) {
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        { type: 'bytes32' },
+        { type: 'bytes32' },
+        { type: 'uint128' },
+        { type: 'bytes32' },
+        { type: 'bytes32' },
+        { type: 'bytes32' },
+    ], [TYPEHASH_MANDATE, targetHash, minGas, originOpsHash, destOpsHash, q]));
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('buildPermit2ClaimPolicyCalldata', () => {
+    (0, vitest_1.describe)('header', () => {
+        (0, vitest_1.test)('always starts with [spender:20][nonce:32][deadline:32]', () => {
+            const policy = { type: 'permit2-claim' };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            const expectedHeader = (0, viem_1.encodePacked)(['address', 'uint256', 'uint256'], [baseMessage.spender, baseMessage.nonce, baseMessage.deadline]);
+            // Header is 84 bytes (20 + 32 + 32)
+            (0, vitest_1.expect)(result.slice(0, 2 + 84 * 2)).toBe(expectedHeader);
+        });
+    });
+    (0, vitest_1.describe)('tokenIn — hash-only mode (no tokensIn policy)', () => {
+        (0, vitest_1.test)('inserts keccak256 of token permissions array', () => {
+            const policy = { type: 'permit2-claim' };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            const tokenHash = hashArray(baseMessage.permitted.map(({ token, amount }) => hashToken(token, amount, TYPEHASH_PERMIT2_TOKEN)));
+            // Header = 84 bytes, then 32 bytes of tokenPermissionsHash
+            const tokenHashInResult = `0x${result.slice(2 + 84 * 2, 2 + 84 * 2 + 64)}`;
+            (0, vitest_1.expect)(tokenHashInResult).toBe(tokenHash);
+        });
+    });
+    (0, vitest_1.describe)('tokenIn — expanded mode (tokensIn policy set)', () => {
+        (0, vitest_1.test)('writes [count:1][token_uint256:32][amount:32] per permitted token', () => {
+            const policy = {
+                type: 'permit2-claim',
+                tokensIn: [{ chainId: 1, token: TOKEN_A }],
+            };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            const headerLen = 84;
+            const offset = 2 + headerLen * 2;
+            // count byte
+            (0, vitest_1.expect)(result.slice(offset, offset + 2)).toBe((0, viem_1.toHex)(baseMessage.permitted.length, { size: 1 }).slice(2));
+            // token entry: address abi-encoded as uint256 (left-padded) + amount
+            const { token, amount } = baseMessage.permitted[0];
+            const expectedEntry = (0, viem_1.encodeAbiParameters)([{ type: 'address' }, { type: 'uint256' }], [token, amount]);
+            (0, vitest_1.expect)(result.slice(offset + 2, offset + 2 + 128)).toBe(expectedEntry.slice(2));
+        });
+        (0, vitest_1.test)('length increases with each permitted token', () => {
+            const policy = {
+                type: 'permit2-claim',
+                tokensIn: [{ chainId: 1, token: TOKEN_A }],
+            };
+            const msg2 = {
+                ...baseMessage,
+                permitted: [
+                    { token: TOKEN_A, amount: 1000n },
+                    { token: TOKEN_B, amount: 2000n },
+                ],
+            };
+            const r1 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            const r2 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msg2);
+            // r2 should be 64 bytes (one extra token entry) longer than r1
+            (0, vitest_1.expect)((r2.length - r1.length) / 2).toBe(64);
+        });
+    });
+    (0, vitest_1.describe)('mandate — hash-only mode (no target checks)', () => {
+        (0, vitest_1.test)('inserts pre-computed mandateHash when no target checks enabled', () => {
+            const policy = { type: 'permit2-claim' };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            const m = baseMessage.mandate;
+            const tokenOutHash = hashArray(m.target.tokenOut.map(({ token, amount }) => hashToken(token, amount, TYPEHASH_TOKENOUT)));
+            const targetHash = hashTarget(m.target.recipient, tokenOutHash, m.target.targetChain, m.target.fillExpiry);
+            const expectedMandateHash = hashMandate(targetHash, m.minGas, hashOp(m.originOps), hashOp(m.destOps), m.q);
+            // Hash-only: header(84) + tokenPermissionsHash(32) + mandateHash(32) = 148 bytes
+            (0, vitest_1.expect)((result.length - 2) / 2).toBe(148);
+            const mandateHashInResult = `0x${result.slice(2 + (84 + 32) * 2)}`;
+            (0, vitest_1.expect)(mandateHashInResult).toBe(expectedMandateHash);
+        });
+    });
+    (0, vitest_1.describe)('mandate — expanded mode (target checks enabled)', () => {
+        (0, vitest_1.test)('tokenOut policy: expands target with [count:1][token:32][amount:32]...', () => {
+            const policy = {
+                type: 'permit2-claim',
+                tokensOut: [{ chainId: 8453, token: TOKEN_B }],
+            };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            // Expanded: header(84) + tokenPermissionsHash(32) + target[recipient:20,targetChain:32,fillExpiry:32]
+            //           + tokenOut[count:1, entry:64] + minGas(16) + originOpsHash(32) + destOpsHash(32) + q(32)
+            // = 84 + 32 + 84 + 1 + 64 + 16 + 32 + 32 + 32 = 377 bytes
+            (0, vitest_1.expect)((result.length - 2) / 2).toBe(377);
+        });
+        (0, vitest_1.test)('recipient policy: expands target, tokenOut is hashed', () => {
+            const policy = {
+                type: 'permit2-claim',
+                recipients: [{ chainId: 8453, recipient: ARBITER }],
+            };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            // Expanded: header(84) + tokenPermissionsHash(32) + target header(84)
+            //           + tokenOutHash(32) + minGas(16) + originOpsHash(32) + destOpsHash(32) + q(32) = 344 bytes
+            (0, vitest_1.expect)((result.length - 2) / 2).toBe(344);
+        });
+        (0, vitest_1.test)('fillExpiry policy: expands target, tokenOut is hashed', () => {
+            const policy = {
+                type: 'permit2-claim',
+                fillExpiryBounds: [{ chainId: 8453 }],
+            };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            (0, vitest_1.expect)((result.length - 2) / 2).toBe(344);
+        });
+        (0, vitest_1.test)('recipientIsSponsor: expands target, tokenOut is hashed', () => {
+            const policy = {
+                type: 'permit2-claim',
+                recipientIsSponsor: true,
+            };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            (0, vitest_1.expect)((result.length - 2) / 2).toBe(344);
+        });
+        (0, vitest_1.test)('expanded target starts with [recipient:20][targetChain:32][fillExpiry:32]', () => {
+            const policy = {
+                type: 'permit2-claim',
+                recipients: [{ chainId: 8453, recipient: ARBITER }],
+            };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            const { target } = baseMessage.mandate;
+            const expectedTargetHeader = (0, viem_1.encodePacked)(['address', 'uint256', 'uint256'], [target.recipient, target.targetChain, target.fillExpiry]);
+            // tokenPermissionsHash ends at offset 84+32=116 bytes from start
+            const targetStart = 2 + (84 + 32) * 2;
+            (0, vitest_1.expect)(result.slice(targetStart, targetStart + expectedTargetHeader.length - 2)).toBe(expectedTargetHeader.slice(2));
+        });
+        (0, vitest_1.test)('q is appended verbatim at the end', () => {
+            const policy = {
+                type: 'permit2-claim',
+                recipients: [{ chainId: 8453, recipient: ARBITER }],
+            };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            // q is always the last 32 bytes
+            const qInResult = `0x${result.slice(result.length - 64)}`;
+            (0, vitest_1.expect)(qInResult).toBe(baseMessage.mandate.q);
+        });
+    });
+    (0, vitest_1.describe)('determinism', () => {
+        (0, vitest_1.test)('same inputs always produce same output', () => {
+            const policy = {
+                type: 'permit2-claim',
+                tokensIn: [{ chainId: 1, token: TOKEN_A }],
+                tokensOut: [{ chainId: 8453, token: TOKEN_B }],
+            };
+            const r1 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            const r2 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, baseMessage);
+            (0, vitest_1.expect)(r1).toBe(r2);
+        });
+        (0, vitest_1.test)('hash-only and expanded modes produce different output', () => {
+            const hashOnlyPolicy = { type: 'permit2-claim' };
+            const expandedPolicy = {
+                type: 'permit2-claim',
+                tokensOut: [{ chainId: 8453, token: TOKEN_B }],
+            };
+            const r1 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(hashOnlyPolicy, baseMessage);
+            const r2 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(expandedPolicy, baseMessage);
+            (0, vitest_1.expect)(r1).not.toBe(r2);
+            (0, vitest_1.expect)(r1.length).toBeLessThan(r2.length);
+        });
+    });
+    (0, vitest_1.describe)('empty arrays', () => {
+        (0, vitest_1.test)('empty permitted array hashes to keccak256 of empty bytes', () => {
+            const policy = { type: 'permit2-claim' };
+            const msgEmpty = { ...baseMessage, permitted: [] };
+            const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msgEmpty);
+            const emptyHash = (0, viem_1.keccak256)('0x');
+            const tokenHashInResult = `0x${result.slice(2 + 84 * 2, 2 + 84 * 2 + 64)}`;
+            (0, vitest_1.expect)(tokenHashInResult).toBe(emptyHash);
+        });
+        (0, vitest_1.test)('empty tokenOut array hashes to keccak256 of empty bytes in hash-only mode', () => {
+            const policy = { type: 'permit2-claim' };
+            const msgNoOut = {
+                ...baseMessage,
+                mandate: {
+                    ...baseMessage.mandate,
+                    target: { ...baseMessage.mandate.target, tokenOut: [] },
+                },
+            };
+            const r1 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msgNoOut);
+            // Should succeed without errors and be deterministic
+            const r2 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msgNoOut);
+            (0, vitest_1.expect)(r1).toBe(r2);
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// Op hashing — non-empty ops and non-zero vt (as the orchestrator sends them)
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('Op hashing with real orchestrator data shapes', () => {
+    const policy = { type: 'permit2-claim' };
+    // vt as the orchestrator produces it: bytes32(bytes2([execType, sigMode]))
+    // e.g. execType=0x04 (ERC7579), sigMode=0x01 (EMISSARY) → 0x0401 in first 2 bytes
+    const REAL_VT = `0x0401${'00'.repeat(30)}`;
+    const EXEC_A = {
+        to: TOKEN_A,
+        value: 0n,
+        data: '0xdeadbeef',
+    };
+    const EXEC_B = {
+        to: TOKEN_B,
+        value: 1000n,
+        data: '0x',
+    };
+    (0, vitest_1.test)('non-zero vt produces different hash than zero vt', () => {
+        const opZeroVt = { vt: viem_1.zeroHash, ops: [EXEC_A] };
+        const opRealVt = { vt: REAL_VT, ops: [EXEC_A] };
+        // Use hash-only mandate mode so ops hash is visible in output
+        const msgZeroVt = {
+            ...baseMessage,
+            mandate: { ...baseMessage.mandate, originOps: opZeroVt },
+        };
+        const msgRealVt = {
+            ...baseMessage,
+            mandate: { ...baseMessage.mandate, originOps: opRealVt },
+        };
+        const r1 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msgZeroVt);
+        const r2 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msgRealVt);
+        (0, vitest_1.expect)(r1).not.toBe(r2);
+    });
+    (0, vitest_1.test)('non-empty ops array produces different hash than empty ops', () => {
+        const opEmpty = { vt: REAL_VT, ops: [] };
+        const opWithExec = { vt: REAL_VT, ops: [EXEC_A] };
+        const msgEmpty = {
+            ...baseMessage,
+            mandate: { ...baseMessage.mandate, originOps: opEmpty },
+        };
+        const msgWithExec = {
+            ...baseMessage,
+            mandate: { ...baseMessage.mandate, originOps: opWithExec },
+        };
+        const r1 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msgEmpty);
+        const r2 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msgWithExec);
+        (0, vitest_1.expect)(r1).not.toBe(r2);
+    });
+    (0, vitest_1.test)('ops order matters — different order produces different hash', () => {
+        const opAB = { vt: REAL_VT, ops: [EXEC_A, EXEC_B] };
+        const opBA = { vt: REAL_VT, ops: [EXEC_B, EXEC_A] };
+        const msgAB = {
+            ...baseMessage,
+            mandate: { ...baseMessage.mandate, originOps: opAB },
+        };
+        const msgBA = {
+            ...baseMessage,
+            mandate: { ...baseMessage.mandate, originOps: opBA },
+        };
+        const r1 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msgAB);
+        const r2 = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msgBA);
+        (0, vitest_1.expect)(r1).not.toBe(r2);
+    });
+    (0, vitest_1.test)('ops hash matches manual computation (bytes32 vt encoding)', () => {
+        const op = { vt: REAL_VT, ops: [EXEC_A, EXEC_B] };
+        const msg = {
+            ...baseMessage,
+            mandate: { ...baseMessage.mandate, originOps: op, destOps: EMPTY_OP },
+        };
+        const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)(policy, msg);
+        // Manually compute expected mandate hash
+        const execHashA = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+            { type: 'bytes32' },
+            { type: 'address' },
+            { type: 'uint256' },
+            { type: 'bytes32' },
+        ], [TYPEHASH_OPS, EXEC_A.to, EXEC_A.value, (0, viem_1.keccak256)(EXEC_A.data)]));
+        const execHashB = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+            { type: 'bytes32' },
+            { type: 'address' },
+            { type: 'uint256' },
+            { type: 'bytes32' },
+        ], [TYPEHASH_OPS, EXEC_B.to, EXEC_B.value, (0, viem_1.keccak256)(EXEC_B.data)]));
+        const opsArrayHash = (0, viem_1.keccak256)((0, viem_1.concat)([execHashA, execHashB]));
+        const expectedOriginOpsHash = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'bytes32' }, { type: 'bytes32' }, { type: 'bytes32' }], [TYPEHASH_OP, REAL_VT, opsArrayHash]));
+        const tokenOutHash = hashArray(msg.mandate.target.tokenOut.map(({ token, amount }) => hashToken(token, amount, TYPEHASH_TOKENOUT)));
+        const targetHash = hashTarget(msg.mandate.target.recipient, tokenOutHash, msg.mandate.target.targetChain, msg.mandate.target.fillExpiry);
+        const expectedMandateHash = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+            { type: 'bytes32' },
+            { type: 'bytes32' },
+            { type: 'uint128' },
+            { type: 'bytes32' },
+            { type: 'bytes32' },
+            { type: 'bytes32' },
+        ], [
+            TYPEHASH_MANDATE,
+            targetHash,
+            msg.mandate.minGas,
+            expectedOriginOpsHash,
+            hashOp(EMPTY_OP),
+            msg.mandate.q,
+        ]));
+        // mandate hash is the last 32 bytes in hash-only mode
+        const mandateHashInResult = `0x${result.slice(result.length - 64)}`;
+        (0, vitest_1.expect)(mandateHashInResult).toBe(expectedMandateHash);
+    });
+    (0, vitest_1.test)('message shape matching getTypedData output: vt as 32-byte hex from orchestrator', () => {
+        // Simulates what getTypedData in execution/permit2.ts produces:
+        // mandate.preClaimOps = { vt: <32-byte hex>, ops: Execution[] }
+        const orchestratorStyleMessage = {
+            permitted: [{ token: TOKEN_A, amount: 500000n }],
+            spender: ARBITER,
+            nonce: 1n,
+            deadline: 2000000000n,
+            mandate: {
+                target: {
+                    recipient: ARBITER,
+                    tokenOut: [{ token: TOKEN_B, amount: 250000n }],
+                    targetChain: 8453n,
+                    fillExpiry: 1999999999n,
+                },
+                minGas: 200000n,
+                // vt as bytes32 with execType=0x04 (ERC7579), sigMode=0x01 (EMISSARY)
+                originOps: { vt: `0x0401${'00'.repeat(30)}`, ops: [] },
+                destOps: { vt: `0x0401${'00'.repeat(30)}`, ops: [] },
+                q: (0, viem_1.keccak256)('0xabcdef'),
+            },
+        };
+        const result = (0, permit2_1.buildPermit2ClaimPolicyCalldata)({ type: 'permit2-claim' }, orchestratorStyleMessage);
+        // Should produce a deterministic 148-byte output (all hash-only mode)
+        (0, vitest_1.expect)((result.length - 2) / 2).toBe(148);
+        // Should be deterministic
+        (0, vitest_1.expect)((0, permit2_1.buildPermit2ClaimPolicyCalldata)({ type: 'permit2-claim' }, orchestratorStyleMessage)).toBe(result);
+    });
+});
+// ---------------------------------------------------------------------------
+// encodePermit2ClaimPolicyInitData
+// ---------------------------------------------------------------------------
+(0, vitest_1.describe)('encodePermit2ClaimPolicyInitData', () => {
+    function modeConfigBit(fieldId) {
+        return types_1.MODE_CHECK_STORAGE << (fieldId * 2);
+    }
+    function readModeConfig(initData) {
+        return Number(BigInt(`0x${initData.slice(2, 10)}`));
+    }
+    (0, vitest_1.test)('empty policy: modeConfig=0, only 4-byte header', () => {
+        const result = (0, permit2_1.encodePermit2ClaimPolicyInitData)({ type: 'permit2-claim' });
+        // 4 bytes = 8 hex chars + '0x'
+        (0, vitest_1.expect)(result).toBe('0x00000000');
+    });
+    (0, vitest_1.test)('arbiters: sets FIELD_ARBITER mode bit and encodes [count:1][address...]', () => {
+        const policy = {
+            type: 'permit2-claim',
+            arbiters: [ARBITER],
+        };
+        const result = (0, permit2_1.encodePermit2ClaimPolicyInitData)(policy);
+        (0, vitest_1.expect)(readModeConfig(result) & modeConfigBit(types_1.FIELD_ARBITER)).toBeTruthy();
+        // After 4-byte modeConfig: count(1) + address(20) = 21 bytes
+        const expected = (0, viem_1.concat)([
+            (0, viem_1.toHex)(modeConfigBit(types_1.FIELD_ARBITER), { size: 4 }),
+            (0, viem_1.encodePacked)(['uint8', 'address'], [1, ARBITER]),
+        ]);
+        (0, vitest_1.expect)(result).toBe(expected);
+    });
+    (0, vitest_1.test)('expiryBounds: sets FIELD_EXPIRY bit and encodes max<<128|min as uint256', () => {
+        const min = 1000n;
+        const max = 9999999n;
+        const policy = {
+            type: 'permit2-claim',
+            expiryBounds: { min, max },
+        };
+        const result = (0, permit2_1.encodePermit2ClaimPolicyInitData)(policy);
+        (0, vitest_1.expect)(readModeConfig(result) & modeConfigBit(types_1.FIELD_EXPIRY)).toBeTruthy();
+        const packed = (min & ((1n << 128n) - 1n)) | (max << 128n);
+        const expected = (0, viem_1.concat)([
+            (0, viem_1.toHex)(modeConfigBit(types_1.FIELD_EXPIRY), { size: 4 }),
+            (0, viem_1.toHex)(packed, { size: 32 }),
+        ]);
+        (0, vitest_1.expect)(result).toBe(expected);
+    });
+    (0, vitest_1.test)('tokensIn: sets FIELD_TOKEN_IN bit and encodes [count:1][chainId:32][token:20]...', () => {
+        const policy = {
+            type: 'permit2-claim',
+            tokensIn: [{ chainId: 1, token: TOKEN_A }],
+        };
+        const result = (0, permit2_1.encodePermit2ClaimPolicyInitData)(policy);
+        (0, vitest_1.expect)(readModeConfig(result) & modeConfigBit(types_1.FIELD_TOKEN_IN)).toBeTruthy();
+        const expected = (0, viem_1.concat)([
+            (0, viem_1.toHex)(modeConfigBit(types_1.FIELD_TOKEN_IN), { size: 4 }),
+            (0, viem_1.toHex)(1, { size: 1 }),
+            (0, viem_1.encodePacked)(['uint256', 'address'], [1n, TOKEN_A]),
+        ]);
+        (0, vitest_1.expect)(result).toBe(expected);
+    });
+    (0, vitest_1.test)('recipients: uses ANY_ADDRESS sentinel for "any"', () => {
+        const policy = {
+            type: 'permit2-claim',
+            recipients: [
+                { chainId: 8453, recipient: 'any' },
+                { chainId: 1, recipient: ARBITER },
+            ],
+        };
+        const result = (0, permit2_1.encodePermit2ClaimPolicyInitData)(policy);
+        (0, vitest_1.expect)(readModeConfig(result) & modeConfigBit(types_1.FIELD_RECIPIENT)).toBeTruthy();
+        const expected = (0, viem_1.concat)([
+            (0, viem_1.toHex)(modeConfigBit(types_1.FIELD_RECIPIENT), { size: 4 }),
+            (0, viem_1.toHex)(2, { size: 1 }),
+            (0, viem_1.encodePacked)(['uint256', 'address'], [8453n, types_1.ANY_ADDRESS]),
+            (0, viem_1.encodePacked)(['uint256', 'address'], [1n, ARBITER]),
+        ]);
+        (0, vitest_1.expect)(result).toBe(expected);
+    });
+    (0, vitest_1.test)('fillExpiryBounds: sets FIELD_FILL_EXPIRY bit and encodes [count:1][chainId:32][packed:32]...', () => {
+        const policy = {
+            type: 'permit2-claim',
+            fillExpiryBounds: [{ chainId: 8453, min: 100n, max: 9000n }],
+        };
+        const result = (0, permit2_1.encodePermit2ClaimPolicyInitData)(policy);
+        (0, vitest_1.expect)(readModeConfig(result) & modeConfigBit(types_1.FIELD_FILL_EXPIRY)).toBeTruthy();
+        const packed = (100n & ((1n << 128n) - 1n)) | (9000n << 128n);
+        const expected = (0, viem_1.concat)([
+            (0, viem_1.toHex)(modeConfigBit(types_1.FIELD_FILL_EXPIRY), { size: 4 }),
+            (0, viem_1.toHex)(1, { size: 1 }),
+            (0, viem_1.encodePacked)(['uint256', 'uint256'], [8453n, packed]),
+        ]);
+        (0, vitest_1.expect)(result).toBe(expected);
+    });
+    (0, vitest_1.test)('tokensOut: sets FIELD_TOKEN_OUT bit', () => {
+        const policy = {
+            type: 'permit2-claim',
+            tokensOut: [{ chainId: 8453, token: TOKEN_B }],
+        };
+        const result = (0, permit2_1.encodePermit2ClaimPolicyInitData)(policy);
+        (0, vitest_1.expect)(readModeConfig(result) & modeConfigBit(types_1.FIELD_TOKEN_OUT)).toBeTruthy();
+    });
+    (0, vitest_1.test)('recipientIsSponsor: sets FIELD_RECIPIENT_IS_SPONSOR bit, no extra bytes', () => {
+        const policy = {
+            type: 'permit2-claim',
+            recipientIsSponsor: true,
+        };
+        const result = (0, permit2_1.encodePermit2ClaimPolicyInitData)(policy);
+        (0, vitest_1.expect)(readModeConfig(result) & modeConfigBit(types_1.FIELD_RECIPIENT_IS_SPONSOR)).toBeTruthy();
+        // Only modeConfig bytes — no additional payload
+        (0, vitest_1.expect)(result).toBe((0, viem_1.toHex)(modeConfigBit(types_1.FIELD_RECIPIENT_IS_SPONSOR), { size: 4 }));
+    });
+    (0, vitest_1.test)('multiple fields: all mode bits are combined correctly', () => {
+        const policy = {
+            type: 'permit2-claim',
+            arbiters: [ARBITER],
+            tokensIn: [{ chainId: 1, token: TOKEN_A }],
+            tokensOut: [{ chainId: 8453, token: TOKEN_B }],
+        };
+        const result = (0, permit2_1.encodePermit2ClaimPolicyInitData)(policy);
+        const expectedMode = modeConfigBit(types_1.FIELD_ARBITER) |
+            modeConfigBit(types_1.FIELD_TOKEN_IN) |
+            modeConfigBit(types_1.FIELD_TOKEN_OUT);
+        (0, vitest_1.expect)(readModeConfig(result)).toBe(expectedMode);
+    });
+});

package/dist/src/modules/validators/policies/claim/types.d.ts

@@ -0,0 +1,12 @@
+export declare const FIELD_ARBITER = 0;
+export declare const FIELD_EXPIRY = 1;
+export declare const FIELD_TOKEN_IN = 2;
+export declare const FIELD_RECIPIENT = 3;
+export declare const FIELD_FILL_EXPIRY = 4;
+export declare const FIELD_TOKEN_OUT = 5;
+export declare const FIELD_ORIGIN_OPS = 6;
+export declare const FIELD_DEST_OPS = 7;
+export declare const FIELD_RECIPIENT_IS_SPONSOR = 9;
+export declare const MODE_CHECK_STORAGE = 1;
+export declare const ANY_ADDRESS: "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF";
+//# sourceMappingURL=types.d.ts.map

package/dist/src/modules/validators/policies/claim/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../modules/validators/policies/claim/types.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa,IAAI,CAAA;AAC9B,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,eAAO,MAAM,cAAc,IAAI,CAAA;AAC/B,eAAO,MAAM,eAAe,IAAI,CAAA;AAChC,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,eAAe,IAAI,CAAA;AAChC,eAAO,MAAM,gBAAgB,IAAI,CAAA;AACjC,eAAO,MAAM,cAAc,IAAI,CAAA;AAE/B,eAAO,MAAM,0BAA0B,IAAI,CAAA;AAG3C,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAGnC,eAAO,MAAM,WAAW,EAAG,4CAAqD,CAAA"}

package/dist/src/modules/validators/policies/claim/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANY_ADDRESS = exports.MODE_CHECK_STORAGE = exports.FIELD_RECIPIENT_IS_SPONSOR = exports.FIELD_DEST_OPS = exports.FIELD_ORIGIN_OPS = exports.FIELD_TOKEN_OUT = exports.FIELD_FILL_EXPIRY = exports.FIELD_RECIPIENT = exports.FIELD_TOKEN_IN = exports.FIELD_EXPIRY = exports.FIELD_ARBITER = void 0;
+// Field IDs matching BaseDataTypes.sol
+exports.FIELD_ARBITER = 0;
+exports.FIELD_EXPIRY = 1;
+exports.FIELD_TOKEN_IN = 2;
+exports.FIELD_RECIPIENT = 3;
+exports.FIELD_FILL_EXPIRY = 4;
+exports.FIELD_TOKEN_OUT = 5;
+exports.FIELD_ORIGIN_OPS = 6;
+exports.FIELD_DEST_OPS = 7;
+// Field 8 is reserved in BaseDataTypes.sol
+exports.FIELD_RECIPIENT_IS_SPONSOR = 9;
+// Mode values
+exports.MODE_CHECK_STORAGE = 1;
+// Sentinel: allows any recipient address
+exports.ANY_ADDRESS = '0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF';

package/dist/src/modules/validators/smart-sessions.d.ts

@@ -1,5 +1,5 @@
 import { type Address, type Hex, type TypedDataDefinition } from 'viem';
-import type { ProviderConfig, RhinestoneAccountConfig, RhinestoneConfig, Session, SessionEnableData } from '../../types';
+import type { Policy, ProviderConfig, RhinestoneAccountConfig, RhinestoneConfig, Session, SessionEnableData } from '../../types';
 import { type Module } from '../common';
 import { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV } from './core';
 interface SessionData {
@@ -164,11 +164,21 @@ declare const SMART_SESSION_MODE_ENABLE = "0x01";
 declare const SMART_SESSIONS_FALLBACK_TARGET_FLAG: Address;
 declare const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG: Hex;
 declare const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION: Hex;
+declare const DUMMY_PRECLAIMOP_TARGET: Address;
+declare const DUMMY_PRECLAIMOP_SELECTOR: Hex;
+declare const SPENDING_LIMITS_POLICY_ADDRESS: Address;
+declare const TIME_FRAME_POLICY_ADDRESS: Address;
+declare const SUDO_POLICY_ADDRESS: Address;
+declare const UNIVERSAL_ACTION_POLICY_ADDRESS: Address;
+declare const USAGE_LIMIT_POLICY_ADDRESS: Address;
+declare const VALUE_LIMIT_POLICY_ADDRESS: Address;
+declare const INTENT_EXECUTION_POLICY_ADDRESS: Address;
 interface ResolvedSessionSignerSet {
     type: 'experimental_session';
     session: Session;
     enableData?: SessionEnableData;
     verifyExecutions: boolean;
+    claimPolicyData?: Hex;
 }
 declare function packSignature(signers: ResolvedSessionSignerSet, validatorSignature: Hex): Hex;
 declare function getSessionDetails(account: Address, sessions: Session[], provider: ProviderConfig | undefined, useDevContracts?: boolean): Promise<SessionDetails>;
@@ -181,8 +191,9 @@ declare function getEnableSessionCall(account: Address, session: Session, enable
     to: `0x${string}`;
     data: `0x${string}`;
 }>;
-declare function getSessionData(session: Session): SessionData;
+declare function getSessionData(session: Session, useDevContracts?: boolean): SessionData;
 declare function getPermissionId(session: Session): `0x${string}`;
+declare function getPolicyData(policy: Policy, useDevContracts?: boolean): PolicyData;
 declare function getSmartSessionValidator(config: RhinestoneConfig): Module | null;
 /**
  * Builds a mockSignature for SSX validation gas estimation.
@@ -193,6 +204,6 @@ declare function getSmartSessionValidator(config: RhinestoneConfig): Module | nu
  * simulates verifyExecution with the mock emissary to estimate gas before the user signs.
  */
 declare function buildMockSignature(session: Session, useDevContracts?: boolean, chainCount?: number): Hex;
-export { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, SMART_SESSIONS_FALLBACK_TARGET_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION, packSignature, getSessionData, getEnableSessionCall, getPermissionId, getSmartSessionValidator, getSessionDetails, isSessionEnabled, signEnableSession, buildMockSignature, };
+export { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, SMART_SESSIONS_FALLBACK_TARGET_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION, DUMMY_PRECLAIMOP_TARGET, DUMMY_PRECLAIMOP_SELECTOR, SPENDING_LIMITS_POLICY_ADDRESS, TIME_FRAME_POLICY_ADDRESS, SUDO_POLICY_ADDRESS, UNIVERSAL_ACTION_POLICY_ADDRESS, USAGE_LIMIT_POLICY_ADDRESS, VALUE_LIMIT_POLICY_ADDRESS, INTENT_EXECUTION_POLICY_ADDRESS, packSignature, getSessionData, getPolicyData, getEnableSessionCall, getPermissionId, getSmartSessionValidator, getSessionDetails, isSessionEnabled, signEnableSession, buildMockSignature, };
 export type { ChainSession, ChainDigest, ResolvedSessionSignerSet, SessionData, SmartSessionModeType, SessionDetails, };
 //# sourceMappingURL=smart-sessions.d.ts.map

package/dist/src/modules/validators/smart-sessions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../../modules/validators/smart-sessions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../../modules/validators/smart-sessions.ts"],"names":[],"mappings":"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"}