@rhinestone/sdk 2.0.0-beta.9 → 2.1.0

package/dist/src/modules/validators/smart-sessions.js

@@ -1,772 +0,0 @@
-import { LibZip } from 'solady';
-import { concat, createPublicClient, encodeAbiParameters, encodeFunctionData, encodePacked, hashStruct, isHex, keccak256, maxUint256, padHex, size, toFunctionSelector, toHex, zeroAddress, zeroHash, } from 'viem';
-import { mainnet } from 'viem/chains';
-import { getAccountProvider } from '../../accounts/index.js';
-import { K1_DEFAULT_VALIDATOR_ADDRESS } from '../../accounts/startale.js';
-import { createTransport } from '../../accounts/utils.js';
-import { RESET_PERIOD_ONE_WEEK, SCOPE_MULTICHAIN, } from '../../execution/compact.js';
-import { signTypedData } from '../../execution/utils.js';
-import { getChainById, getWrappedTokenAddress, } from '../../orchestrator/registry.js';
-import smartSessionEmissaryAbi from '../abi/smart-session-emissary.js';
-import { MODULE_TYPE_ID_VALIDATOR } from '../common.js';
-import { getOwnerValidator, getValidator, SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, } from './core.js';
-import { resolvePermissions } from './permissions.js';
-import { encodePermit2ClaimPolicyInitData, PERMIT2_CLAIM_POLICY_ADDRESS, } from './policies/claim/permit2.js';
-const types = {
-    PolicyData: [
-        { name: 'policy', type: 'address' },
-        { name: 'initData', type: 'bytes' },
-    ],
-    ActionData: [
-        { name: 'actionTargetSelector', type: 'bytes4' },
-        { name: 'actionTarget', type: 'address' },
-        { name: 'actionPolicies', type: 'PolicyData[]' },
-    ],
-    ERC7739Context: [
-        { name: 'appDomainSeparator', type: 'bytes32' },
-        { name: 'contentName', type: 'string[]' },
-    ],
-    ERC7739Data: [
-        { name: 'allowedERC7739Content', type: 'ERC7739Context[]' },
-        { name: 'erc1271Policies', type: 'PolicyData[]' },
-    ],
-    LockTagData: [
-        { name: 'lockTag', type: 'bytes12' },
-        { name: 'claimPolicies', type: 'PolicyData[]' },
-    ],
-    SignedPermissions: [
-        { name: 'actions', type: 'ActionData[]' },
-        { name: 'erc7739Policies', type: 'ERC7739Data' },
-        { name: 'lockTagPolicies', type: 'LockTagData' },
-        { name: 'permitGenericPolicy', type: 'bool' },
-    ],
-    SignedSession: [
-        { name: 'account', type: 'address' },
-        { name: 'expires', type: 'uint256' },
-        { name: 'nonce', type: 'uint256' },
-        { name: 'permissions', type: 'SignedPermissions' },
-        { name: 'salt', type: 'bytes32' },
-        { name: 'sessionValidator', type: 'address' },
-        { name: 'sessionValidatorInitData', type: 'bytes' },
-        { name: 'smartSessionEmissary', type: 'address' },
-    ],
-    ChainSession: [
-        { name: 'chainId', type: 'uint64' },
-        { name: 'session', type: 'SignedSession' },
-    ],
-    MultiChainSession: [{ name: 'sessionsAndChainIds', type: 'ChainSession[]' }],
-};
-const SMART_SESSION_MODE_USE = '0x00';
-const SMART_SESSION_MODE_ENABLE = '0x01';
-const SMART_SESSIONS_FALLBACK_TARGET_FLAG = '0x0000000000000000000000000000000000000001';
-const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = '0x00000001';
-const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = '0x00000002';
-// Dummy preclaimop action injected into every session so that the filler can trigger
-// verifyExecution (ENABLE mode) using an injected dummy preclaimop when there are no
-// real preclaimops. Target 0x...0420 is the ecRecover precompile; calls to it fail
-// silently because preclaimops are failure-tolerant. Selector 0x69123456 is
-// intentionally uncommon.
-const DUMMY_PRECLAIMOP_TARGET = '0x0000000000000000000000000000000000000420';
-const DUMMY_PRECLAIMOP_SELECTOR = '0x69123456';
-const SPENDING_LIMITS_POLICY_ADDRESS = '0x00000088d48cf102a8cdb0137a9b173f957c6343';
-const TIME_FRAME_POLICY_ADDRESS = '0x8177451511de0577b911c254e9551d981c26dc72';
-const SUDO_POLICY_ADDRESS = '0x0000003111cd8e92337c100f22b7a9dbf8dee301';
-const UNIVERSAL_ACTION_POLICY_ADDRESS = '0x0000006dda6c463511c4e9b05cfc34c1247fcf1f';
-const USAGE_LIMIT_POLICY_ADDRESS = '0x1f34ef8311345a3a4a4566af321b313052f51493';
-const VALUE_LIMIT_POLICY_ADDRESS = '0x730da93267e7e513e932301b47f2ac7d062abc83';
-const INTENT_EXECUTION_POLICY_ADDRESS = '0xe9eA54d063975cDee9e06b7636d5563d95a7A23C';
-const INTENT_EXECUTION_POLICY_ADDRESS_DEV = '0xa09b47de6e510cbdc18b97e9239bedcb44fb4901';
-const ACTION_CONDITION_EQUAL = 0;
-const ACTION_CONDITION_GREATER_THAN = 1;
-const ACTION_CONDITION_LESS_THAN = 2;
-const ACTION_CONDITION_GREATER_THAN_OR_EQUAL = 3;
-const ACTION_CONDITION_LESS_THAN_OR_EQUAL = 4;
-const ACTION_CONDITION_NOT_EQUAL = 5;
-const ACTION_CONDITION_IN_RANGE = 6;
-function packSignature(signers, validatorSignature) {
-    const session = signers.session;
-    const permissionId = getPermissionId(session);
-    if (signers.verifyExecutions) {
-        const smartSessionMode = signers.enableData
-            ? SMART_SESSION_MODE_ENABLE
-            : SMART_SESSION_MODE_USE;
-        const sessionData = getSessionData(signers.session);
-        const packedSignature = signers.enableData
-            ? LibZip.flzCompress(encodeAbiParameters([
-                {
-                    type: 'tuple',
-                    name: 'enableData',
-                    components: [
-                        { type: 'bytes', name: 'allocatorSig' },
-                        { type: 'bytes', name: 'userSig' },
-                        { type: 'uint256', name: 'expires' },
-                        {
-                            type: 'tuple',
-                            name: 'enableSession',
-                            components: [
-                                {
-                                    type: 'uint8',
-                                    name: 'chainDigestIndex',
-                                },
-                                {
-                                    type: 'tuple[]',
-                                    name: 'hashesAndChainIds',
-                                    components: [
-                                        { type: 'uint64', name: 'chainId' },
-                                        { type: 'bytes32', name: 'sessionDigest' },
-                                    ],
-                                },
-                                {
-                                    type: 'tuple',
-                                    name: 'session',
-                                    components: [
-                                        { type: 'address', name: 'sessionValidator' },
-                                        { type: 'bytes', name: 'sessionValidatorInitData' },
-                                        { type: 'bytes32', name: 'salt' },
-                                        {
-                                            type: 'tuple[]',
-                                            name: 'actions',
-                                            components: [
-                                                { type: 'bytes4', name: 'actionTargetSelector' },
-                                                { type: 'address', name: 'actionTarget' },
-                                                {
-                                                    type: 'tuple[]',
-                                                    name: 'actionPolicies',
-                                                    components: [
-                                                        { type: 'address', name: 'policy' },
-                                                        { type: 'bytes', name: 'initData' },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                        {
-                                            type: 'tuple[]',
-                                            name: 'claimPolicies',
-                                            components: [
-                                                { type: 'address', name: 'policy' },
-                                                { type: 'bytes', name: 'initData' },
-                                            ],
-                                        },
-                                        {
-                                            type: 'tuple',
-                                            name: 'erc7739Policies',
-                                            components: [
-                                                {
-                                                    type: 'tuple[]',
-                                                    name: 'allowedERC7739Content',
-                                                    components: [
-                                                        {
-                                                            type: 'bytes32',
-                                                            name: 'appDomainSeparator',
-                                                        },
-                                                        { type: 'string[]', name: 'contentNames' },
-                                                    ],
-                                                },
-                                                {
-                                                    type: 'tuple[]',
-                                                    name: 'erc1271Policies',
-                                                    components: [
-                                                        { type: 'address', name: 'policy' },
-                                                        { type: 'bytes', name: 'initData' },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    ],
-                },
-                {
-                    type: 'tuple',
-                    name: 'config',
-                    components: [
-                        { type: 'uint8', name: 'scope' },
-                        { type: 'uint8', name: 'resetPeriod' },
-                        { type: 'address', name: 'allocator' },
-                        { type: 'bytes32', name: 'permissionId' },
-                    ],
-                },
-                { type: 'bytes' },
-            ], [
-                {
-                    allocatorSig: zeroHash,
-                    userSig: signers.enableData.userSignature,
-                    expires: maxUint256,
-                    enableSession: {
-                        chainDigestIndex: signers.enableData.sessionToEnableIndex,
-                        hashesAndChainIds: signers.enableData.hashesAndChainIds,
-                        session: sessionData,
-                    },
-                },
-                {
-                    scope: SCOPE_MULTICHAIN,
-                    resetPeriod: RESET_PERIOD_ONE_WEEK,
-                    allocator: zeroAddress,
-                    permissionId: getPermissionId(signers.session),
-                },
-                validatorSignature,
-            ]))
-            : validatorSignature;
-        return signers.enableData
-            ? encodePacked(['bytes1', 'bytes'], [smartSessionMode, packedSignature])
-            : encodePacked(['bytes1', 'bytes32', 'bytes'], [smartSessionMode, permissionId, packedSignature]);
-    }
-    else {
-        const SIGNATURE_IS_VALID_SIG_1271 = '0x00';
-        const policyDataOffset = BigInt(64 + size(validatorSignature));
-        const mode = SIGNATURE_IS_VALID_SIG_1271;
-        const policySpecificData = signers.claimPolicyData ?? '0x';
-        const signature = encodePacked(['bytes1', 'bytes32', 'uint256', 'bytes', 'bytes'], [
-            mode,
-            permissionId,
-            policyDataOffset,
-            validatorSignature,
-            policySpecificData,
-        ]);
-        return signature;
-    }
-}
-async function getSessionDetails(account, sessions, provider, useDevContracts) {
-    const lockTag = '0x000000000000000000000000';
-    const sessionNonces = await Promise.all(sessions.map((session) => getSessionNonce(account, session, lockTag, provider, useDevContracts)));
-    const sessionDatas = sessions.map((session) => getSessionData(session));
-    const signedSessions = sessionDatas.map((session, index) => getSignedSession(account, lockTag, session, sessionNonces[index], useDevContracts));
-    const chains = sessions.map((session) => session.chain);
-    const hashesAndChainIds = signedSessions.map((session, index) => ({
-        chainId: BigInt(chains[index].id),
-        sessionDigest: hashStruct({
-            types,
-            primaryType: 'SignedSession',
-            data: session,
-        }),
-    }));
-    const data = {
-        domain: {
-            name: 'SmartSessionEmissary',
-            version: '1',
-        },
-        types: types,
-        primaryType: 'MultiChainSession',
-        message: {
-            sessionsAndChainIds: signedSessions.map((session, index) => ({
-                chainId: BigInt(chains[index].id),
-                session,
-            })),
-        },
-    };
-    return {
-        nonces: sessionNonces,
-        hashesAndChainIds,
-        data,
-    };
-}
-async function isSessionEnabled(account, provider, session, useDevContracts) {
-    const publicClient = createPublicClient({
-        chain: session.chain,
-        transport: createTransport(session.chain, provider),
-    });
-    const isEnabled = await publicClient.readContract({
-        address: getSmartSessionEmissaryAddress(useDevContracts),
-        abi: [
-            {
-                type: 'function',
-                name: 'isPermissionEnabled',
-                inputs: [
-                    { name: 'account', type: 'address' },
-                    { name: 'permissionId', type: 'bytes32' },
-                ],
-                outputs: [{ name: 'isEnabled', type: 'bool' }],
-                stateMutability: 'view',
-            },
-        ],
-        functionName: 'isPermissionEnabled',
-        args: [account, getPermissionId(session)],
-    });
-    return isEnabled;
-}
-async function signEnableSession(config, details) {
-    const account = getAccountProvider(config);
-    const validator = getOwnerValidator(config);
-    const isStartaleK1 = account.type === 'startale' &&
-        validator.address.toLowerCase() ===
-            K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
-    if (isStartaleK1) {
-        const chainIds = details.hashesAndChainIds.map((h) => h.chainId);
-        const uniqueChainIds = [...new Set(chainIds.map((c) => c.toString()))];
-        if (uniqueChainIds.length > 1) {
-            throw new Error('Startale accounts with K1 validator do not support multi-chain session enable');
-        }
-        const chain = getChainById(Number(chainIds[0]));
-        return signTypedData(config, details.data, chain, undefined, {
-            skipErc6492: true,
-        });
-    }
-    return signTypedData(config, details.data, mainnet, undefined, {
-        skipErc6492: true,
-    });
-}
-async function getSessionNonce(account, session, lockTag, provider, useDevContracts) {
-    const publicClient = createPublicClient({
-        chain: session.chain,
-        transport: createTransport(session.chain, provider),
-    });
-    const nonce = await publicClient.readContract({
-        address: getSmartSessionEmissaryAddress(useDevContracts),
-        abi: [
-            {
-                type: 'function',
-                name: 'getNonce',
-                inputs: [
-                    { name: 'sponsor', type: 'address', internalType: 'address' },
-                    { name: 'lockTag', type: 'bytes12', internalType: 'bytes12' },
-                ],
-                outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
-                stateMutability: 'view',
-            },
-        ],
-        functionName: 'getNonce',
-        args: [account, lockTag],
-    });
-    return nonce;
-}
-function getSignedSession(account, lockTag, session, nonce, useDevContracts) {
-    return {
-        account,
-        permissions: {
-            permitGenericPolicy: session.actions.some((action) => action.actionTarget === SMART_SESSIONS_FALLBACK_TARGET_FLAG &&
-                action.actionTargetSelector ===
-                    SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG),
-            lockTagPolicies: {
-                lockTag,
-                claimPolicies: session.claimPolicies,
-            },
-            erc7739Policies: {
-                allowedERC7739Content: session.erc7739Policies.allowedERC7739Content.map((content) => ({
-                    contentName: content.contentNames,
-                    appDomainSeparator: content.appDomainSeparator,
-                })),
-                erc1271Policies: session.erc7739Policies.erc1271Policies,
-            },
-            actions: session.actions,
-        },
-        sessionValidator: session.sessionValidator,
-        sessionValidatorInitData: session.sessionValidatorInitData,
-        salt: session.salt,
-        smartSessionEmissary: getSmartSessionEmissaryAddress(useDevContracts),
-        expires: maxUint256,
-        nonce,
-    };
-}
-async function getEnableSessionCall(account, session, enableSessionSignature, hashesAndChainIds, sessionToEnableIndex, useDevContracts) {
-    const sessionData = getSessionData(session);
-    const permissionId = getPermissionId(session);
-    return {
-        to: getSmartSessionEmissaryAddress(useDevContracts),
-        data: encodeFunctionData({
-            abi: smartSessionEmissaryAbi,
-            functionName: 'setConfig',
-            args: [
-                account,
-                {
-                    scope: SCOPE_MULTICHAIN,
-                    resetPeriod: RESET_PERIOD_ONE_WEEK,
-                    allocator: zeroAddress,
-                    permissionId,
-                },
-                {
-                    allocatorSig: zeroHash,
-                    userSig: enableSessionSignature,
-                    expires: maxUint256,
-                    session: {
-                        chainDigestIndex: sessionToEnableIndex,
-                        hashesAndChainIds,
-                        sessionToEnable: sessionData,
-                    },
-                },
-            ],
-        }),
-    };
-}
-function toSession(definition, options = {}) {
-    const sessionData = resolveSessionData(definition, options.useDevContracts);
-    return {
-        chain: definition.chain,
-        owners: definition.owners,
-        hasExplicitPermissions: !!definition.permissions?.length,
-        permissionId: getPermissionIdFromData(sessionData),
-        sessionValidator: sessionData.sessionValidator,
-        sessionValidatorInitData: sessionData.sessionValidatorInitData,
-        salt: sessionData.salt,
-        erc7739Policies: sessionData.erc7739Policies,
-        actions: sessionData.actions,
-        claimPolicies: definition.claimPolicies ?? [],
-    };
-}
-function resolvePermit2ClaimPolicy(policy) {
-    return {
-        type: 'permit2-claim',
-        arbiters: policy.spenders,
-        tokensIn: policy.sourceTokens?.map(({ chain, address }) => ({
-            chainId: chain.id,
-            token: address,
-        })),
-        tokensOut: policy.destinationTokens?.map(({ chain, address }) => ({
-            chainId: chain.id,
-            token: address,
-        })),
-        recipients: policy.recipients?.map(({ chain, address }) => ({
-            chainId: chain.id,
-            recipient: address,
-        })),
-        recipientIsSponsor: policy.recipientIsAccount,
-        expiryBounds: policy.permitDeadline,
-        fillExpiryBounds: policy.fillDeadline?.map(({ chain, min, max }) => ({
-            chainId: chain.id,
-            min,
-            max,
-        })),
-    };
-}
-function resolveSessionData(session, useDevContracts) {
-    const validator = getValidator(session.owners);
-    const allowedContent = [
-        {
-            contentNames: [''],
-            appDomainSeparator: zeroHash,
-        },
-    ];
-    const erc7739Data = {
-        allowedERC7739Content: allowedContent,
-        erc1271Policies: [
-            {
-                policy: SUDO_POLICY_ADDRESS,
-                initData: '0x',
-            },
-        ],
-    };
-    const sudoAction = {
-        actionTargetSelector: SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
-        actionTarget: SMART_SESSIONS_FALLBACK_TARGET_FLAG,
-        actionPolicies: [
-            {
-                policy: SUDO_POLICY_ADDRESS,
-                initData: '0x',
-            },
-        ],
-    };
-    const userActions = session.permissions?.length
-        ? resolvePermissions(session.permissions)
-        : [];
-    const injectedActions = [
-        // Native token wrapping
-        {
-            target: getWrappedTokenAddress(session.chain),
-            selector: toFunctionSelector({
-                type: 'function',
-                name: 'deposit',
-                inputs: [],
-                outputs: [],
-                stateMutability: 'payable',
-            }),
-        },
-        // Intent-execution fallback for any non-scoped call.
-        { policies: [{ type: 'intent-execution' }] },
-        // Dummy action: allows the filler to call verifyExecution in ENABLE mode using
-        // an injected dummy preclaimop so any session can be enabled on-chain without
-        // a separate UserOp, regardless of whether it has claim or action policies.
-        {
-            target: DUMMY_PRECLAIMOP_TARGET,
-            selector: DUMMY_PRECLAIMOP_SELECTOR,
-            policies: [{ type: 'sudo' }],
-        },
-    ];
-    const allActions = [...userActions, ...injectedActions];
-    const actions = userActions.length
-        ? allActions.map((action) => ({
-            actionTargetSelector: 'selector' in action
-                ? action.selector
-                : SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
-            actionTarget: 'target' in action
-                ? action.target
-                : SMART_SESSIONS_FALLBACK_TARGET_FLAG,
-            actionPolicies: action.policies?.map((policy) => getPolicyData(policy, useDevContracts)) ?? [
-                {
-                    policy: SUDO_POLICY_ADDRESS,
-                    initData: '0x',
-                },
-            ],
-        }))
-        : [sudoAction];
-    return {
-        sessionValidator: validator.address,
-        salt: zeroHash,
-        sessionValidatorInitData: validator.initData,
-        erc7739Policies: erc7739Data,
-        actions,
-        claimPolicies: session.claimPolicies?.map((policy) => ({
-            policy: PERMIT2_CLAIM_POLICY_ADDRESS,
-            initData: encodePermit2ClaimPolicyInitData(resolvePermit2ClaimPolicy(policy)),
-        })) ?? [],
-    };
-}
-function getSessionData(session) {
-    return {
-        sessionValidator: session.sessionValidator,
-        salt: session.salt,
-        sessionValidatorInitData: session.sessionValidatorInitData,
-        erc7739Policies: session.erc7739Policies,
-        actions: session.actions,
-        claimPolicies: session.claimPolicies.map((policy) => ({
-            policy: PERMIT2_CLAIM_POLICY_ADDRESS,
-            initData: encodePermit2ClaimPolicyInitData(resolvePermit2ClaimPolicy(policy)),
-        })),
-    };
-}
-function getPermissionId(session) {
-    return session.permissionId;
-}
-function getPermissionIdFromData(sessionData) {
-    return keccak256(encodeAbiParameters([
-        {
-            type: 'address',
-            name: 'sessionValidator',
-        },
-        {
-            type: 'bytes',
-            name: 'sessionValidatorInitData',
-        },
-        {
-            type: 'bytes32',
-            name: 'salt',
-        },
-    ], [
-        sessionData.sessionValidator,
-        sessionData.sessionValidatorInitData,
-        sessionData.salt,
-    ]));
-}
-function getPolicyData(policy, useDevContracts) {
-    switch (policy.type) {
-        case 'sudo':
-            return {
-                policy: SUDO_POLICY_ADDRESS,
-                initData: '0x',
-            };
-        case 'intent-execution':
-            return {
-                policy: useDevContracts
-                    ? INTENT_EXECUTION_POLICY_ADDRESS_DEV
-                    : INTENT_EXECUTION_POLICY_ADDRESS,
-                initData: '0x',
-            };
-        case 'universal-action': {
-            function getCondition(condition) {
-                switch (condition) {
-                    case 'equal':
-                        return ACTION_CONDITION_EQUAL;
-                    case 'greaterThan':
-                        return ACTION_CONDITION_GREATER_THAN;
-                    case 'lessThan':
-                        return ACTION_CONDITION_LESS_THAN;
-                    case 'greaterThanOrEqual':
-                        return ACTION_CONDITION_GREATER_THAN_OR_EQUAL;
-                    case 'lessThanOrEqual':
-                        return ACTION_CONDITION_LESS_THAN_OR_EQUAL;
-                    case 'notEqual':
-                        return ACTION_CONDITION_NOT_EQUAL;
-                    case 'inRange':
-                        return ACTION_CONDITION_IN_RANGE;
-                }
-            }
-            const MAX_RULES = 16;
-            const rules = createFixedArray(MAX_RULES, () => ({
-                condition: ACTION_CONDITION_EQUAL,
-                offset: 0n,
-                isLimited: false,
-                ref: zeroHash,
-                usage: { limit: 0n, used: 0n },
-            }));
-            for (let i = 0; i < policy.rules.length; i++) {
-                const rule = policy.rules[i];
-                const ref = isHex(rule.referenceValue)
-                    ? padHex(rule.referenceValue)
-                    : toHex(rule.referenceValue, { size: 32 });
-                rules[i] = {
-                    condition: getCondition(rule.condition),
-                    offset: rule.calldataOffset,
-                    isLimited: rule.usageLimit !== undefined,
-                    ref,
-                    usage: {
-                        limit: rule.usageLimit ? rule.usageLimit : 0n,
-                        used: 0n,
-                    },
-                };
-            }
-            return {
-                policy: UNIVERSAL_ACTION_POLICY_ADDRESS,
-                initData: encodeAbiParameters([
-                    {
-                        components: [
-                            {
-                                name: 'valueLimitPerUse',
-                                type: 'uint256',
-                            },
-                            {
-                                components: [
-                                    {
-                                        name: 'length',
-                                        type: 'uint256',
-                                    },
-                                    {
-                                        components: [
-                                            {
-                                                name: 'condition',
-                                                type: 'uint8',
-                                            },
-                                            {
-                                                name: 'offset',
-                                                type: 'uint64',
-                                            },
-                                            {
-                                                name: 'isLimited',
-                                                type: 'bool',
-                                            },
-                                            {
-                                                name: 'ref',
-                                                type: 'bytes32',
-                                            },
-                                            {
-                                                components: [
-                                                    {
-                                                        name: 'limit',
-                                                        type: 'uint256',
-                                                    },
-                                                    {
-                                                        name: 'used',
-                                                        type: 'uint256',
-                                                    },
-                                                ],
-                                                name: 'usage',
-                                                type: 'tuple',
-                                            },
-                                        ],
-                                        name: 'rules',
-                                        type: 'tuple[16]',
-                                    },
-                                ],
-                                name: 'paramRules',
-                                type: 'tuple',
-                            },
-                        ],
-                        name: 'ActionConfig',
-                        type: 'tuple',
-                    },
-                ], [
-                    {
-                        valueLimitPerUse: policy.valueLimitPerUse ?? 0n,
-                        paramRules: {
-                            length: BigInt(policy.rules.length),
-                            rules: rules,
-                        },
-                    },
-                ]),
-            };
-        }
-        case 'spending-limits': {
-            const tokens = policy.limits.map(({ token }) => token);
-            const limits = policy.limits.map(({ amount }) => amount);
-            return {
-                policy: SPENDING_LIMITS_POLICY_ADDRESS,
-                initData: encodeAbiParameters([{ type: 'address[]' }, { type: 'uint256[]' }], [tokens, limits]),
-            };
-        }
-        case 'time-frame': {
-            return {
-                policy: TIME_FRAME_POLICY_ADDRESS,
-                initData: encodePacked(['uint48', 'uint48'], [
-                    Math.floor(policy.validUntil / 1000),
-                    Math.floor(policy.validAfter / 1000),
-                ]),
-            };
-        }
-        case 'usage-limit': {
-            return {
-                policy: USAGE_LIMIT_POLICY_ADDRESS,
-                initData: encodePacked(['uint128'], [policy.limit]),
-            };
-        }
-        case 'value-limit': {
-            return {
-                policy: VALUE_LIMIT_POLICY_ADDRESS,
-                initData: encodeAbiParameters([{ type: 'uint256' }], [policy.limit]),
-            };
-        }
-    }
-}
-function getSmartSessionValidator(config) {
-    if (!config.experimental_sessions) {
-        return null;
-    }
-    const { enabled, module } = config.experimental_sessions;
-    if (!enabled) {
-        return null;
-    }
-    return {
-        address: module ?? getSmartSessionEmissaryAddress(config.useDevContracts),
-        initData: '0x',
-        deInitData: '0x',
-        additionalContext: '0x',
-        type: MODULE_TYPE_ID_VALIDATOR,
-    };
-}
-function getSmartSessionEmissaryAddress(useDevContracts) {
-    return useDevContracts === true
-        ? SMART_SESSION_EMISSARY_ADDRESS_DEV
-        : SMART_SESSION_EMISSARY_ADDRESS;
-}
-/**
- * Builds a mockSignature for SSX validation gas estimation.
- * Format: emissaryAddress (20 bytes) + enable-mode sigData.
- * Uses real session data (policies/actions from the user's session config) with dummy
- * sigs and hashes — the mock emissary skips sig verification and only writes storage.
- * The orchestrator slices off the first 20 bytes to identify the validator, then
- * simulates verifyExecution with the mock emissary to estimate gas before the user signs.
- */
-function buildMockSignature(session, useDevContracts, chainCount = 1, targetChainId) {
-    const emissaryAddress = getSmartSessionEmissaryAddress(useDevContracts);
-    // Use targetChainId when provided (per-chain mockSignatures path) so the
-    // mock emissary's chainId check passes on the correct chain. Falls back to
-    // session.chain.id for the global mockSignature (single-chain path).
-    const primaryChainId = targetChainId ?? session.chain.id;
-    // Normalize chainCount to a finite positive integer. Guards against
-    // accidental NaN/undefined from caller (e.g. `sourceChains?.length` when
-    // sourceChains is undefined) which would otherwise make Array.from produce
-    // an empty array and silently drop the ChainId check.
-    const safeChainCount = Number.isFinite(chainCount) && chainCount > 0 ? Math.floor(chainCount) : 1;
-    // Build one entry per chain — first entry is the real chain ID (for the ChainId check),
-    // remaining entries use chainId 0 as placeholders. Hash mismatch is skipped by the
-    // mock emissary, so sessionDigest can be zeroHash throughout.
-    const hashesAndChainIds = Array.from({ length: safeChainCount }, (_, i) => ({
-        chainId: i === 0 ? BigInt(primaryChainId) : 0n,
-        sessionDigest: zeroHash,
-    }));
-    const dummySigners = {
-        type: 'experimental_session',
-        session,
-        verifyExecutions: true,
-        enableData: {
-            userSignature: `0x${'00'.repeat(65)}`,
-            hashesAndChainIds,
-            sessionToEnableIndex: 0,
-        },
-    };
-    const dummyValidatorSignature = `0x${'00'.repeat(65)}`;
-    const sigData = packSignature(dummySigners, dummyValidatorSignature);
-    return concat([emissaryAddress, sigData]);
-}
-function createFixedArray(length, getValue) {
-    return Array.from({ length }, (_, i) => getValue(i));
-}
-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, toSession, resolvePermit2ClaimPolicy, getSessionData, getPolicyData, getEnableSessionCall, getPermissionId, getSmartSessionValidator, getSessionDetails, isSessionEnabled, signEnableSession, buildMockSignature, };