@rhinestone/sdk 0.7.8 → 0.7.9

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

@@ -0,0 +1,426 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMART_SESSIONS_VALIDATOR_ADDRESS = exports.SMART_SESSION_MODE_ENABLE = exports.SMART_SESSION_MODE_USE = void 0;
+exports.getSmartSessionValidator = getSmartSessionValidator;
+exports.getEnableSessionCall = getEnableSessionCall;
+exports.encodeSmartSessionSignature = encodeSmartSessionSignature;
+exports.getPermissionId = getPermissionId;
+exports.getAccountEIP712Domain = getAccountEIP712Domain;
+exports.isSessionEnabled = isSessionEnabled;
+exports.getSessionAllowedERC7739Content = getSessionAllowedERC7739Content;
+const viem_1 = require("viem");
+const orchestrator_1 = require("../../orchestrator");
+const smart_sessions_1 = require("../abi/smart-sessions");
+const common_1 = require("../common");
+const omni_account_1 = require("../omni-account");
+const core_1 = require("./core");
+const SMART_SESSIONS_VALIDATOR_ADDRESS = '0x00000000002b0ecfbd0496ee71e01257da0e37de';
+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';
+const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = '0x00000001';
+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(chain, session) {
+    const { appDomainSeparator, contentsType } = await getSessionAllowedERC7739Content(chain);
+    const allowedERC7739Content = [
+        {
+            appDomainSeparator,
+            contentName: [contentsType],
+        },
+    ];
+    const sessionData = await getSmartSessionData(chain, session, allowedERC7739Content);
+    return {
+        to: SMART_SESSIONS_VALIDATOR_ADDRESS,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: smart_sessions_1.enableSessionsAbi,
+            functionName: 'enableSessions',
+            args: [[sessionData]],
+        }),
+    };
+}
+function getOmniAccountActions(chain) {
+    const wethAddress = (0, orchestrator_1.getWethAddress)(chain);
+    const omniActions = [
+        {
+            actionTarget: orchestrator_1.RHINESTONE_SPOKE_POOL_ADDRESS,
+            actionTargetSelector: '0xa2418864', // injected execution
+            actionPolicies: [getPolicyData({ type: 'sudo' })],
+        },
+        {
+            actionTarget: omni_account_1.HOOK_ADDRESS,
+            actionTargetSelector: '0x27c777a9', // injected execution
+            actionPolicies: [getPolicyData({ type: 'sudo' })],
+        },
+        {
+            actionTarget: wethAddress,
+            actionTargetSelector: '0xd0e30db0', // deposit
+            actionPolicies: [getPolicyData({ type: 'sudo' })],
+        },
+        {
+            actionTarget: wethAddress,
+            actionTargetSelector: '0x2e1a7d4d', // widthdraw
+            actionPolicies: [getPolicyData({ type: 'sudo' })],
+        },
+    ];
+    return omniActions;
+}
+async function getSessionAllowedERC7739Content(chain) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, viem_1.http)(),
+    });
+    const appDomainSeparator = await publicClient.readContract({
+        address: omni_account_1.HOOK_ADDRESS,
+        abi: (0, viem_1.parseAbi)(['function DOMAIN_SEPARATOR() view returns (bytes32)']),
+        functionName: 'DOMAIN_SEPARATOR',
+    });
+    const contentsType = 'MultichainCompact(address sponsor,uint256 nonce,uint256 expires,Segment[] segments)Segment(address arbiter,uint256 chainId,uint256[2][] idsAndAmounts,Witness witness)Witness(address recipient,uint256[2][] tokenOut,uint256 depositId,uint256 targetChain,uint32 fillDeadline,XchainExec[] execs,bytes32 userOpHash,uint32 maxFeeBps)XchainExec(address to,uint256 value,bytes data)';
+    return {
+        appDomainSeparator,
+        contentsType,
+    };
+}
+async function getSmartSessionData(chain, session, allowedERC7739Content) {
+    const omniActions = getOmniAccountActions(chain);
+    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) => {
+                return getPolicyData(policy);
+            });
+            return {
+                actionTargetSelector: action.selector,
+                actionTarget: action.target,
+                actionPolicies,
+            };
+        })
+            .concat(omniActions),
+        erc7739Policies: {
+            allowedERC7739Content,
+            erc1271Policies: [getPolicyData({ type: 'sudo' })],
+        },
+        permitERC4337Paymaster: true,
+    };
+}
+function getSmartSessionValidator(config) {
+    if (!config.sessions) {
+        return null;
+    }
+    return {
+        address: 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)(['uint128', 'uint128'], [
+                    BigInt(policy.validUntil) / 1000n,
+                    BigInt(policy.validAfter) / 1000n,
+                ]),
+            };
+        }
+        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) {
+    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:
+            throw new Error('Enable mode not implemented');
+        default:
+            throw new Error(`Unknown mode ${mode}`);
+    }
+}
+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,
+    ]));
+}
+async function getAccountEIP712Domain(client, account) {
+    const data = await client.readContract({
+        address: account,
+        abi: [
+            {
+                type: 'function',
+                name: 'eip712Domain',
+                inputs: [],
+                outputs: [
+                    {
+                        type: 'bytes1',
+                        name: 'fields,',
+                    },
+                    {
+                        type: 'string',
+                        name: 'name',
+                    },
+                    {
+                        type: 'string',
+                        name: 'version',
+                    },
+                    {
+                        type: 'uint256',
+                        name: 'chainId',
+                    },
+                    {
+                        type: 'address',
+                        name: 'verifyingContract',
+                    },
+                    {
+                        type: 'bytes32',
+                        name: 'salt',
+                    },
+                    {
+                        type: 'uint256[]',
+                        name: 'extensions',
+                    },
+                ],
+                stateMutability: 'view',
+                constant: true,
+            },
+        ],
+        functionName: 'eip712Domain',
+        args: [],
+    });
+    return {
+        name: data[1],
+        version: data[2],
+        chainId: data[3],
+        verifyingContract: data[4],
+        salt: data[5],
+    };
+}

package/dist/cjs/orchestrator/client.d.ts

@@ -0,0 +1,29 @@
+import { type Address, type Hex } from 'viem';
+import type { UserOperation } from 'viem/account-abstraction';
+import type { BundleEvent, BundleResult, MetaIntent, OrderCostResult, OrderFeeInput, OrderPath, PostOrderBundleResult, SignedMultiChainCompact, UserTokenBalance } from './types';
+export declare class Orchestrator {
+    private serverUrl;
+    private apiKey;
+    constructor(serverUrl: string, apiKey: string);
+    getPortfolio(userAddress: Address, filter?: {
+        chainIds?: number[];
+        tokens?: {
+            [chainId: number]: Address[];
+        };
+    }): Promise<UserTokenBalance[]>;
+    getMaxTokenAmount(userAddress: Address, targetChainId: number, targetTokenAddress: Address, targetGasUnits: bigint): Promise<bigint>;
+    getIntentCost(intent: OrderFeeInput, userAddress: Address): Promise<OrderCostResult>;
+    getOrderPath(intent: MetaIntent, userAddress: Address): Promise<OrderPath>;
+    postSignedOrderBundle(signedOrderBundles: {
+        signedOrderBundle: SignedMultiChainCompact;
+        initCode?: Hex;
+        userOp?: UserOperation;
+    }[]): Promise<PostOrderBundleResult>;
+    getBundleStatus(bundleId: bigint): Promise<BundleResult>;
+    getPendingBundles(count?: number, offset?: number): Promise<{
+        pendingBundles: BundleEvent[];
+        nextOffset?: number;
+    }>;
+    private parseError;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/cjs/orchestrator/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../orchestrator/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAU,KAAK,GAAG,EAAE,MAAM,MAAM,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAG7D,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,aAAa,EACb,SAAS,EACT,qBAAqB,EACrB,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAShB,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAAQ;gBAEV,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAKvC,YAAY,CAChB,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;QACnB,MAAM,CAAC,EAAE;YACP,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;SAC7B,CAAA;KACF,GACA,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAwCxB,iBAAiB,CACrB,WAAW,EAAE,OAAO,EACpB,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,OAAO,EAC3B,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC;IAgCZ,aAAa,CACjB,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,eAAe,CAAC;IAqBrB,YAAY,CAChB,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,SAAS,CAAC;IAgCf,qBAAqB,CACzB,kBAAkB,EAAE;QAClB,iBAAiB,EAAE,uBAAuB,CAAA;QAC1C,QAAQ,CAAC,EAAE,GAAG,CAAA;QACd,MAAM,CAAC,EAAE,aAAa,CAAA;KACvB,EAAE,GACF,OAAO,CAAC,qBAAqB,CAAC;IA2C3B,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAyBxD,iBAAiB,CACrB,KAAK,GAAE,MAAW,EAClB,MAAM,GAAE,MAAU,GACjB,OAAO,CAAC;QAAE,cAAc,EAAE,WAAW,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAuBlE,OAAO,CAAC,UAAU;CA6DnB"}