@rhinestone/sdk 1.4.2 → 2.0.0-beta.0

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

@@ -1,519 +0,0 @@
-"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/smart-sessions.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=smart-sessions.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"smart-sessions.test.d.ts","sourceRoot":"","sources":["../../../../modules/validators/smart-sessions.test.ts"],"names":[],"mappings":""}