@charterlabs/rhinestone-sdk 0.3.0 → 0.3.2

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

@@ -1,36 +1,85 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = exports.SMART_SESSIONS_FALLBACK_TARGET_FLAG = exports.SMART_SESSIONS_VALIDATOR_ADDRESS = exports.SMART_SESSION_MODE_ENABLE = exports.SMART_SESSION_MODE_USE = void 0;
-exports.getSmartSessionData = getSmartSessionData;
-exports.getSmartSessionValidator = getSmartSessionValidator;
+exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = exports.SMART_SESSIONS_FALLBACK_TARGET_FLAG = exports.SMART_SESSION_EMISSARY_ADDRESS = void 0;
+exports.packSignature = packSignature;
+exports.getSessionData = getSessionData;
 exports.getEnableSessionCall = getEnableSessionCall;
-exports.encodeSmartSessionSignature = encodeSmartSessionSignature;
 exports.getPermissionId = getPermissionId;
+exports.getSmartSessionValidator = getSmartSessionValidator;
+exports.getSessionDetails = getSessionDetails;
 exports.isSessionEnabled = isSessionEnabled;
+exports.signEnableSession = signEnableSession;
 const solady_1 = require("solady");
 const viem_1 = require("viem");
-const smart_sessions_1 = require("../abi/smart-sessions");
+const chains_1 = require("viem/chains");
+const utils_1 = require("../../accounts/utils");
+const compact_1 = require("../../execution/compact");
+const utils_2 = require("../../execution/utils");
+const smart_session_emissary_1 = __importDefault(require("../abi/smart-session-emissary"));
 const common_1 = require("../common");
 const core_1 = require("./core");
-const SMART_SESSIONS_VALIDATOR_ADDRESS = '0x00000000008bdaba73cd9815d79069c247eb4bda';
-exports.SMART_SESSIONS_VALIDATOR_ADDRESS = SMART_SESSIONS_VALIDATOR_ADDRESS;
+Object.defineProperty(exports, "SMART_SESSION_EMISSARY_ADDRESS", { enumerable: true, get: function () { return core_1.SMART_SESSION_EMISSARY_ADDRESS; } });
+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';
-exports.SMART_SESSION_MODE_USE = SMART_SESSION_MODE_USE;
 const SMART_SESSION_MODE_ENABLE = '0x01';
-exports.SMART_SESSION_MODE_ENABLE = SMART_SESSION_MODE_ENABLE;
-const SMART_SESSION_MODE_UNSAFE_ENABLE = '0x02';
-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 SMART_SESSIONS_FALLBACK_TARGET_FLAG = '0x0000000000000000000000000000000000000001';
 exports.SMART_SESSIONS_FALLBACK_TARGET_FLAG = SMART_SESSIONS_FALLBACK_TARGET_FLAG;
 const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = '0x00000001';
 exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG;
 const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = '0x00000002';
 exports.SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION = SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION;
+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 ACTION_CONDITION_EQUAL = 0;
 const ACTION_CONDITION_GREATER_THAN = 1;
 const ACTION_CONDITION_LESS_THAN = 2;
@@ -38,80 +87,365 @@ 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;
-async function getEnableSessionCall(session) {
-    const sessionData = getSmartSessionData(session);
-    return {
-        to: SMART_SESSIONS_VALIDATOR_ADDRESS,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: smart_sessions_1.enableSessionsAbi,
-            functionName: 'enableSessions',
-            args: [[sessionData]],
+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
+            ? solady_1.LibZip.flzCompress((0, viem_1.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: viem_1.zeroHash,
+                    userSig: signers.enableData.userSignature,
+                    expires: viem_1.maxUint256,
+                    enableSession: {
+                        chainDigestIndex: signers.enableData.sessionToEnableIndex,
+                        hashesAndChainIds: signers.enableData.hashesAndChainIds,
+                        session: sessionData,
+                    },
+                },
+                {
+                    scope: compact_1.SCOPE_MULTICHAIN,
+                    resetPeriod: compact_1.RESET_PERIOD_ONE_WEEK,
+                    allocator: viem_1.zeroAddress,
+                    permissionId: getPermissionId(signers.session),
+                },
+                validatorSignature,
+            ]))
+            : validatorSignature;
+        return signers.enableData
+            ? (0, viem_1.encodePacked)(['bytes1', 'bytes'], [smartSessionMode, packedSignature])
+            : (0, viem_1.encodePacked)(['bytes1', 'bytes32', 'bytes'], [smartSessionMode, permissionId, packedSignature]);
+    }
+    else {
+        const SIGNATURE_IS_VALID_SIG_1271 = '0x00';
+        const policyDataOffset = BigInt(64 + (0, viem_1.size)(validatorSignature));
+        const mode = SIGNATURE_IS_VALID_SIG_1271;
+        const policySpecificData = '0x';
+        const signature = (0, viem_1.encodePacked)(['bytes1', 'bytes32', 'uint256', 'bytes', 'bytes'], [
+            mode,
+            permissionId,
+            policyDataOffset,
+            validatorSignature,
+            policySpecificData,
+        ]);
+        return signature;
+    }
+}
+async function getSessionDetails(account, sessions) {
+    const lockTag = '0x000000000000000000000000';
+    const sessionNonces = await Promise.all(sessions.map((session) => getSessionNonce(account, session, lockTag)));
+    const sessionDatas = sessions.map((session) => getSessionData(session));
+    const signedSessions = sessionDatas.map((session, index) => getSignedSession(account, lockTag, session, sessionNonces[index]));
+    const chains = sessions.map((session) => session.chain);
+    const hashesAndChainIds = signedSessions.map((session, index) => ({
+        chainId: BigInt(chains[index].id),
+        sessionDigest: (0, viem_1.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,
     };
 }
-function getSmartSessionData(session) {
-    const sessionValidator = (0, core_1.getValidator)(session.owners);
-    const userOpPolicies = (session.policies || [
-        {
-            type: 'sudo',
-        },
-    ]).map((policy) => {
-        return getPolicyData(policy);
+async function isSessionEnabled(account, provider, session) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: session.chain,
+        transport: (0, utils_1.createTransport)(session.chain, provider),
     });
-    return {
-        sessionValidator: sessionValidator.address,
-        sessionValidatorInitData: sessionValidator.initData,
-        salt: session.salt ?? viem_1.zeroHash,
-        userOpPolicies,
-        // Using the fallback action by default (any transaction will pass)
-        actions: (session.actions || [
+    const isEnabled = await publicClient.readContract({
+        address: core_1.SMART_SESSION_EMISSARY_ADDRESS,
+        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) {
+    return (0, utils_2.signTypedData)(config, details.data, chains_1.mainnet, undefined, {
+        skipErc6492: true,
+    });
+}
+async function getSessionNonce(account, session, lockTag) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: session.chain,
+        transport: (0, viem_1.http)(),
+    });
+    const nonce = await publicClient.readContract({
+        address: core_1.SMART_SESSION_EMISSARY_ADDRESS,
+        abi: [
             {
-                target: SMART_SESSIONS_FALLBACK_TARGET_FLAG,
-                selector: SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
+                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',
             },
-        ]).map((action) => {
-            const actionPolicies = (action.policies || [
+        ],
+        functionName: 'getNonce',
+        args: [account, lockTag],
+    });
+    return nonce;
+}
+function getSignedSession(account, lockTag, session, nonce) {
+    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: core_1.SMART_SESSION_EMISSARY_ADDRESS,
+        expires: viem_1.maxUint256,
+        nonce,
+    };
+}
+async function getEnableSessionCall(account, session, enableSessionSignature, hashesAndChainIds, sessionToEnableIndex) {
+    const sessionData = getSessionData(session);
+    const permissionId = getPermissionId(session);
+    return {
+        to: core_1.SMART_SESSION_EMISSARY_ADDRESS,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: smart_session_emissary_1.default,
+            functionName: 'setConfig',
+            args: [
+                account,
                 {
-                    type: 'sudo',
+                    scope: compact_1.SCOPE_MULTICHAIN,
+                    resetPeriod: compact_1.RESET_PERIOD_ONE_WEEK,
+                    allocator: viem_1.zeroAddress,
+                    permissionId,
                 },
-            ]).map((policy) => getPolicyData(policy));
-            return {
-                actionTargetSelector: action.selector,
-                actionTarget: action.target,
-                actionPolicies,
-            };
-        }),
-        erc7739Policies: session.signing
-            ? {
-                allowedERC7739Content: session.signing.allowedContent.map((content) => ({
-                    appDomainSeparator: content.domainSeparator,
-                    contentName: content.contentName,
-                })),
-                erc1271Policies: (session.signing.policies || [
-                    {
-                        type: 'sudo',
+                {
+                    allocatorSig: viem_1.zeroHash,
+                    userSig: enableSessionSignature,
+                    expires: viem_1.maxUint256,
+                    session: {
+                        chainDigestIndex: sessionToEnableIndex,
+                        hashesAndChainIds,
+                        sessionToEnable: sessionData,
                     },
-                ]).map((policy) => getPolicyData(policy)),
-            }
-            : {
-                allowedERC7739Content: [],
-                erc1271Policies: [],
-            },
-        permitERC4337Paymaster: true,
+                },
+            ],
+        }),
     };
 }
-function getSmartSessionValidator(config) {
-    if (!config.sessions) {
-        return null;
-    }
+function getSessionData(session) {
+    const validator = (0, core_1.getValidator)(session.owners);
+    const allowedContent = [
+        {
+            contentNames: [''],
+            appDomainSeparator: viem_1.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 actions = session.actions
+        ? session.actions.map((action) => ({
+            actionTargetSelector: action.selector ?? SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
+            actionTarget: action.target ?? SMART_SESSIONS_FALLBACK_TARGET_FLAG,
+            actionPolicies: action.policies?.map((policy) => getPolicyData(policy)) ?? [
+                {
+                    policy: SUDO_POLICY_ADDRESS,
+                    initData: '0x',
+                },
+            ],
+        }))
+        : [sudoAction];
     return {
-        address: SMART_SESSIONS_VALIDATOR_ADDRESS,
-        initData: '0x',
-        deInitData: '0x',
-        additionalContext: '0x',
-        type: common_1.MODULE_TYPE_ID_VALIDATOR,
+        sessionValidator: validator.address,
+        salt: viem_1.zeroHash,
+        sessionValidatorInitData: validator.initData,
+        erc7739Policies: erc7739Data,
+        actions,
+        claimPolicies: [],
     };
 }
+function getPermissionId(session) {
+    const sessionData = getSessionData(session);
+    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+        {
+            type: 'address',
+            name: 'sessionValidator',
+        },
+        {
+            type: 'bytes',
+            name: 'sessionValidatorInitData',
+        },
+        {
+            type: 'bytes32',
+            name: 'salt',
+        },
+    ], [
+        sessionData.sessionValidator,
+        sessionData.sessionValidatorInitData,
+        sessionData.salt,
+    ]));
+}
 function getPolicyData(policy) {
     switch (policy.type) {
         case 'sudo':
@@ -263,231 +597,22 @@ function getPolicyData(policy) {
         }
     }
 }
-function createFixedArray(length, getValue) {
-    return Array.from({ length }, (_, i) => getValue(i));
-}
-async function isSessionEnabled(client, address, permissionId) {
-    return await client.readContract({
-        address: SMART_SESSIONS_VALIDATOR_ADDRESS,
-        abi: [
-            {
-                inputs: [
-                    {
-                        internalType: 'PermissionId',
-                        name: 'permissionId',
-                        type: 'bytes32',
-                    },
-                    {
-                        internalType: 'address',
-                        name: 'account',
-                        type: 'address',
-                    },
-                ],
-                name: 'isPermissionEnabled',
-                outputs: [
-                    {
-                        internalType: 'bool',
-                        name: '',
-                        type: 'bool',
-                    },
-                ],
-                stateMutability: 'view',
-                type: 'function',
-            },
-        ],
-        functionName: 'isPermissionEnabled',
-        args: [permissionId, address],
-    });
-}
-function encodeSmartSessionSignature(mode, permissionId, signature, enableSessionData) {
-    switch (mode) {
-        case SMART_SESSION_MODE_USE:
-            return (0, viem_1.encodePacked)(['bytes1', 'bytes32', 'bytes'], [mode, permissionId, signature]);
-        case SMART_SESSION_MODE_ENABLE:
-        case SMART_SESSION_MODE_UNSAFE_ENABLE:
-            if (!enableSessionData) {
-                throw new Error('enableSession is required for ENABLE mode');
-            }
-            return (0, viem_1.encodePacked)(['bytes1', 'bytes'], [
-                mode,
-                solady_1.LibZip.flzCompress(encodeEnableSessionSignature(enableSessionData, signature)),
-            ]);
-        default:
-            throw new Error(`Unknown mode ${mode}`);
+function getSmartSessionValidator(config) {
+    if (!config.experimental_sessions) {
+        return null;
     }
+    const { enabled, module } = config.experimental_sessions;
+    if (!enabled) {
+        return null;
+    }
+    return {
+        address: module ?? core_1.SMART_SESSION_EMISSARY_ADDRESS,
+        initData: '0x',
+        deInitData: '0x',
+        additionalContext: '0x',
+        type: common_1.MODULE_TYPE_ID_VALIDATOR,
+    };
 }
-function encodeEnableSessionSignature(enableSessionData, signature) {
-    return (0, viem_1.encodeAbiParameters)([
-        {
-            components: [
-                {
-                    type: 'uint8',
-                    name: 'chainDigestIndex',
-                },
-                {
-                    type: 'tuple[]',
-                    components: [
-                        {
-                            internalType: 'uint64',
-                            name: 'chainId',
-                            type: 'uint64',
-                        },
-                        {
-                            internalType: 'bytes32',
-                            name: 'sessionDigest',
-                            type: 'bytes32',
-                        },
-                    ],
-                    name: 'hashesAndChainIds',
-                },
-                {
-                    components: [
-                        {
-                            internalType: 'contract ISessionValidator',
-                            name: 'sessionValidator',
-                            type: 'address',
-                        },
-                        {
-                            internalType: 'bytes',
-                            name: 'sessionValidatorInitData',
-                            type: 'bytes',
-                        },
-                        { internalType: 'bytes32', name: 'salt', type: 'bytes32' },
-                        {
-                            components: [
-                                { internalType: 'address', name: 'policy', type: 'address' },
-                                { internalType: 'bytes', name: 'initData', type: 'bytes' },
-                            ],
-                            internalType: 'struct PolicyData[]',
-                            name: 'userOpPolicies',
-                            type: 'tuple[]',
-                        },
-                        {
-                            components: [
-                                {
-                                    components: [
-                                        {
-                                            internalType: 'bytes32',
-                                            name: 'appDomainSeparator',
-                                            type: 'bytes32',
-                                        },
-                                        {
-                                            internalType: 'string[]',
-                                            name: 'contentName',
-                                            type: 'string[]',
-                                        },
-                                    ],
-                                    internalType: 'struct ERC7739Context[]',
-                                    name: 'allowedERC7739Content',
-                                    type: 'tuple[]',
-                                },
-                                {
-                                    components: [
-                                        {
-                                            internalType: 'address',
-                                            name: 'policy',
-                                            type: 'address',
-                                        },
-                                        {
-                                            internalType: 'bytes',
-                                            name: 'initData',
-                                            type: 'bytes',
-                                        },
-                                    ],
-                                    internalType: 'struct PolicyData[]',
-                                    name: 'erc1271Policies',
-                                    type: 'tuple[]',
-                                },
-                            ],
-                            internalType: 'struct ERC7739Data',
-                            name: 'erc7739Policies',
-                            type: 'tuple',
-                        },
-                        {
-                            components: [
-                                {
-                                    internalType: 'bytes4',
-                                    name: 'actionTargetSelector',
-                                    type: 'bytes4',
-                                },
-                                {
-                                    internalType: 'address',
-                                    name: 'actionTarget',
-                                    type: 'address',
-                                },
-                                {
-                                    components: [
-                                        {
-                                            internalType: 'address',
-                                            name: 'policy',
-                                            type: 'address',
-                                        },
-                                        {
-                                            internalType: 'bytes',
-                                            name: 'initData',
-                                            type: 'bytes',
-                                        },
-                                    ],
-                                    internalType: 'struct PolicyData[]',
-                                    name: 'actionPolicies',
-                                    type: 'tuple[]',
-                                },
-                            ],
-                            internalType: 'struct ActionData[]',
-                            name: 'actions',
-                            type: 'tuple[]',
-                        },
-                        {
-                            internalType: 'bool',
-                            name: 'permitERC4337Paymaster',
-                            type: 'bool',
-                        },
-                    ],
-                    internalType: 'struct Session',
-                    name: 'sessionToEnable',
-                    type: 'tuple',
-                },
-                {
-                    type: 'bytes',
-                    name: 'permissionEnableSig',
-                },
-            ],
-            internalType: 'struct EnableSession',
-            name: 'enableSession',
-            type: 'tuple',
-        },
-        {
-            type: 'bytes',
-            name: 'signature',
-        },
-    ], [
-        {
-            chainDigestIndex: enableSessionData.chainDigestIndex,
-            hashesAndChainIds: enableSessionData.hashesAndChainIds,
-            sessionToEnable: enableSessionData.sessionToEnable,
-            permissionEnableSig: enableSessionData.signature,
-        },
-        signature,
-    ]);
-}
-function getPermissionId(session) {
-    const sessionValidator = (0, core_1.getValidator)(session.owners);
-    return (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
-        {
-            type: 'address',
-            name: 'sessionValidator',
-        },
-        {
-            type: 'bytes',
-            name: 'sessionValidatorInitData',
-        },
-        {
-            type: 'bytes32',
-            name: 'salt',
-        },
-    ], [
-        sessionValidator.address,
-        sessionValidator.initData,
-        session.salt ?? viem_1.zeroHash,
-    ]));
+function createFixedArray(length, getValue) {
+    return Array.from({ length }, (_, i) => getValue(i));
 }