@rhinestone/sdk 1.0.41-alpha.0 → 1.0.41

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

@@ -0,0 +1,497 @@
+"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

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

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

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