@rhinestone/sdk 1.0.40 → 1.0.41-alpha.0

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

@@ -1,497 +0,0 @@
-"use strict";
-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.getEnableSessionCall = getEnableSessionCall;
-exports.encodeSmartSessionSignature = encodeSmartSessionSignature;
-exports.getPermissionId = getPermissionId;
-exports.isSessionEnabled = isSessionEnabled;
-const solady_1 = require("solady");
-const viem_1 = require("viem");
-const smart_sessions_1 = require("../abi/smart-sessions");
-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;
-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 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;
-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 getSmartSessionData(session) {
-    const sessionValidator = (0, core_1.getValidator)(session.owners);
-    const userOpPolicies = (session.policies || [
-        {
-            type: 'sudo',
-        },
-    ]).map((policy) => {
-        return getPolicyData(policy);
-    });
-    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 || [
-            {
-                target: SMART_SESSIONS_FALLBACK_TARGET_FLAG,
-                selector: SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
-            },
-        ]).map((action) => {
-            const actionPolicies = (action.policies || [
-                {
-                    type: 'sudo',
-                },
-            ]).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',
-                    },
-                ]).map((policy) => getPolicyData(policy)),
-            }
-            : {
-                allowedERC7739Content: [],
-                erc1271Policies: [],
-            },
-        permitERC4337Paymaster: true,
-    };
-}
-function getSmartSessionValidator(config) {
-    if (!config.experimental_sessions) {
-        return null;
-    }
-    const { enabled, module } = config.experimental_sessions;
-    if (!enabled) {
-        return null;
-    }
-    return {
-        address: module ?? SMART_SESSIONS_VALIDATOR_ADDRESS,
-        initData: '0x',
-        deInitData: '0x',
-        additionalContext: '0x',
-        type: common_1.MODULE_TYPE_ID_VALIDATOR,
-    };
-}
-function getPolicyData(policy) {
-    switch (policy.type) {
-        case 'sudo':
-            return {
-                policy: SUDO_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: viem_1.zeroHash,
-                usage: { limit: 0n, used: 0n },
-            }));
-            for (let i = 0; i < policy.rules.length; i++) {
-                const rule = policy.rules[i];
-                const ref = (0, viem_1.isHex)(rule.referenceValue)
-                    ? (0, viem_1.padHex)(rule.referenceValue)
-                    : (0, viem_1.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: (0, viem_1.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: (0, viem_1.encodeAbiParameters)([{ type: 'address[]' }, { type: 'uint256[]' }], [tokens, limits]),
-            };
-        }
-        case 'time-frame': {
-            return {
-                policy: TIME_FRAME_POLICY_ADDRESS,
-                initData: (0, viem_1.encodePacked)(['uint48', 'uint48'], [
-                    Math.floor(policy.validUntil / 1000),
-                    Math.floor(policy.validAfter / 1000),
-                ]),
-            };
-        }
-        case 'usage-limit': {
-            return {
-                policy: USAGE_LIMIT_POLICY_ADDRESS,
-                initData: (0, viem_1.encodePacked)(['uint128'], [policy.limit]),
-            };
-        }
-        case 'value-limit': {
-            return {
-                policy: VALUE_LIMIT_POLICY_ADDRESS,
-                initData: (0, viem_1.encodeAbiParameters)([{ type: 'uint256' }], [policy.limit]),
-            };
-        }
-    }
-}
-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 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,
-    ]));
-}

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":""}