@charterlabs/rhinestone-sdk 0.3.1 → 0.3.2

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

@@ -1,6 +1,7 @@
 import { type Address, type Hex, type TypedDataDefinition } from 'viem';
-import type { RhinestoneAccountConfig, Session } from '../../types';
+import type { ProviderConfig, RhinestoneAccountConfig, Session, SignerSet } from '../../types';
 import { type Module } from '../common';
+import { SMART_SESSION_EMISSARY_ADDRESS } from './core';
 interface SessionData {
     sessionValidator: Address;
     sessionValidatorInitData: Hex;
@@ -29,7 +30,7 @@ interface PolicyData {
     policy: Address;
     initData: Hex;
 }
-type SmartSessionModeType = typeof SMART_SESSION_MODE_USE | typeof SMART_SESSION_MODE_ENABLE | typeof SMART_SESSION_MODE_UNSAFE_ENABLE;
+type SmartSessionModeType = typeof SMART_SESSION_MODE_USE | typeof SMART_SESSION_MODE_ENABLE;
 interface ChainDigest {
     chainId: bigint;
     sessionDigest: Hex;
@@ -158,14 +159,17 @@ declare const types: {
         readonly type: "ChainSession[]";
     }];
 };
-declare const SMART_SESSION_EMISSARY_ADDRESS: Address;
 declare const SMART_SESSION_MODE_USE = "0x00";
 declare const SMART_SESSION_MODE_ENABLE = "0x01";
-declare const SMART_SESSION_MODE_UNSAFE_ENABLE = "0x02";
 declare const SMART_SESSIONS_FALLBACK_TARGET_FLAG: Address;
 declare const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG: Hex;
 declare const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION: Hex;
+declare function packSignature(signers: SignerSet & {
+    type: 'experimental_session';
+}, validatorSignature: Hex): Hex;
 declare function getSessionDetails(account: Address, sessions: Session[]): Promise<SessionDetails>;
+declare function isSessionEnabled(account: Address, provider: ProviderConfig | undefined, session: Session): Promise<boolean>;
+declare function signEnableSession(config: RhinestoneAccountConfig, details: SessionDetails): Promise<Hex>;
 declare function getEnableSessionCall(account: Address, session: Session, enableSessionSignature: Hex, hashesAndChainIds: {
     chainId: bigint;
     sessionDigest: Hex;
@@ -176,6 +180,6 @@ declare function getEnableSessionCall(account: Address, session: Session, enable
 declare function getSessionData(session: Session): SessionData;
 declare function getPermissionId(session: Session): `0x${string}`;
 declare function getSmartSessionValidator(config: RhinestoneAccountConfig): Module | null;
-export { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSIONS_FALLBACK_TARGET_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION, getSessionData, getEnableSessionCall, getPermissionId, getSmartSessionValidator, getSessionDetails, };
+export { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSIONS_FALLBACK_TARGET_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION, packSignature, getSessionData, getEnableSessionCall, getPermissionId, getSmartSessionValidator, getSessionDetails, isSessionEnabled, signEnableSession, };
 export type { ChainSession, ChainDigest, SessionData, SmartSessionModeType, SessionDetails, };
 //# sourceMappingURL=smart-sessions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../../modules/validators/smart-sessions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../../modules/validators/smart-sessions.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EAKZ,KAAK,GAAG,EAQR,KAAK,mBAAmB,EAIzB,MAAM,MAAM,CAAA;AAQb,OAAO,KAAK,EAEV,cAAc,EACd,uBAAuB,EACvB,OAAO,EACP,SAAS,EAEV,MAAM,aAAa,CAAA;AAEpB,OAAO,EAA4B,KAAK,MAAM,EAAE,MAAM,WAAW,CAAA;AACjE,OAAO,EAAgB,8BAA8B,EAAE,MAAM,QAAQ,CAAA;AAQrE,UAAU,WAAW;IACnB,gBAAgB,EAAE,OAAO,CAAA;IACzB,wBAAwB,EAAE,GAAG,CAAA;IAC7B,IAAI,EAAE,GAAG,CAAA;IACT,eAAe,EAAE;QACf,qBAAqB,EAAE,SAAS,qBAAqB,EAAE,CAAA;QACvD,eAAe,EAAE,SAAS,aAAa,EAAE,CAAA;KAC1C,CAAA;IACD,OAAO,EAAE,SAAS,UAAU,EAAE,CAAA;IAC9B,aAAa,EAAE,SAAS,UAAU,EAAE,CAAA;CACrC;AAED,UAAU,aAAa;IACrB,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,GAAG,CAAA;CACd;AAED,UAAU,qBAAqB;IAC7B,kBAAkB,EAAE,GAAG,CAAA;IACvB,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;CAChC;AAED,UAAU,UAAU;IAClB,oBAAoB,EAAE,GAAG,CAAA;IACzB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,SAAS,UAAU,EAAE,CAAA;CACtC;AAED,UAAU,UAAU;IAClB,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,GAAG,CAAA;CACd;AAaD,KAAK,oBAAoB,GACrB,OAAO,sBAAsB,GAC7B,OAAO,yBAAyB,CAAA;AAEpC,UAAU,WAAW;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,GAAG,CAAA;CACnB;AAED,UAAU,iBAAiB;IACzB,mBAAmB,EAAE,OAAO,CAAA;IAC5B,iBAAiB,EAAE,OAAO,CAAA;IAC1B,0BAA0B,EAAE,OAAO,CAAA;IACnC,sBAAsB,EAAE,OAAO,CAAA;IAC/B,cAAc,EAAE,SAAS,UAAU,EAAE,CAAA;IACrC,eAAe,EAAE,WAAW,CAAA;IAC5B,OAAO,EAAE,SAAS,UAAU,EAAE,CAAA;CAC/B;AAED,UAAU,aAAa;IACrB,OAAO,EAAE,OAAO,CAAA;IAChB,WAAW,EAAE,iBAAiB,CAAA;IAC9B,gBAAgB,EAAE,OAAO,CAAA;IACzB,wBAAwB,EAAE,GAAG,CAAA;IAC7B,IAAI,EAAE,GAAG,CAAA;IACT,YAAY,EAAE,OAAO,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,UAAU,YAAY;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,aAAa,CAAA;CACvB;AAED,UAAU,WAAW;IACnB,qBAAqB,EAAE,SAAS,cAAc,EAAE,CAAA;IAChD,eAAe,EAAE,SAAS,UAAU,EAAE,CAAA;CACvC;AAED,UAAU,cAAc;IACtB,kBAAkB,EAAE,GAAG,CAAA;IACvB,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B;AAED,UAAU,cAAc;IACtB,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,iBAAiB,EAAE,WAAW,EAAE,CAAA;IAChC,IAAI,EAAE,mBAAmB,CAAC,OAAO,KAAK,EAAE,mBAAmB,CAAC,CAAA;CAC7D;AAED,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CD,CAAA;AAEV,QAAA,MAAM,sBAAsB,SAAS,CAAA;AACrC,QAAA,MAAM,yBAAyB,SAAS,CAAA;AACxC,QAAA,MAAM,mCAAmC,EAAE,OACG,CAAA;AAC9C,QAAA,MAAM,4CAA4C,EAAE,GAAkB,CAAA;AACtE,QAAA,MAAM,2EAA2E,EAAE,GACrE,CAAA;AAuBd,iBAAS,aAAa,CACpB,OAAO,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,sBAAsB,CAAA;CAAE,EACrD,kBAAkB,EAAE,GAAG,GACtB,GAAG,CA4JL;AAED,iBAAe,iBAAiB,CAC9B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,CAAC,cAAc,CAAC,CAuCzB;AAED,iBAAe,gBAAgB,CAC7B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,cAAc,GAAG,SAAS,EACpC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,OAAO,CAAC,CAuBlB;AAED,iBAAe,iBAAiB,CAC9B,MAAM,EAAE,uBAAuB,EAC/B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,GAAG,CAAC,CAId;AAqED,iBAAe,oBAAoB,CACjC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,sBAAsB,EAAE,GAAG,EAC3B,iBAAiB,EAAE;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,GAAG,CAAA;CACnB,EAAE,EACH,oBAAoB,EAAE,MAAM;;;GA8B7B;AAED,iBAAS,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAkDrD;AAED,iBAAS,eAAe,CAAC,OAAO,EAAE,OAAO,iBAyBxC;AAuKD,iBAAS,wBAAwB,CAC/B,MAAM,EAAE,uBAAuB,GAC9B,MAAM,GAAG,IAAI,CAef;AASD,OAAO,EACL,8BAA8B,EAC9B,mCAAmC,EACnC,4CAA4C,EAC5C,2EAA2E,EAC3E,aAAa,EACb,cAAc,EACd,oBAAoB,EACpB,eAAe,EACf,wBAAwB,EACxB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,GAClB,CAAA;AACD,YAAY,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,oBAAoB,EACpB,cAAc,GACf,CAAA"}

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

@@ -4,16 +4,24 @@ var __importDefault = (this && this.__importDefault) || function (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_SESSION_EMISSARY_ADDRESS = void 0;
+exports.packSignature = packSignature;
 exports.getSessionData = getSessionData;
 exports.getEnableSessionCall = getEnableSessionCall;
 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 compact_1 = require("../../actions/compact");
+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");
+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' },
@@ -58,42 +66,190 @@ const types = {
     ],
     MultiChainSession: [{ name: 'sessionsAndChainIds', type: 'ChainSession[]' }],
 };
-const SMART_SESSION_EMISSARY_ADDRESS = '0x4411abbbede0215626284d0385dd55b4303012b7';
-exports.SMART_SESSION_EMISSARY_ADDRESS = SMART_SESSION_EMISSARY_ADDRESS;
 const SMART_SESSION_MODE_USE = '0x00';
 const SMART_SESSION_MODE_ENABLE = '0x01';
-const SMART_SESSION_MODE_UNSAFE_ENABLE = '0x02';
-const SUDO_POLICY_ADDRESS = '0x0000003111cD8e92337C100F22B7A9dbf8DEE301';
 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 SCOPE_MULTICHAIN = 0;
-const RESET_PERIOD_ONE_WEEK = 6;
+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;
+const ACTION_CONDITION_GREATER_THAN_OR_EQUAL = 3;
+const ACTION_CONDITION_LESS_THAN_OR_EQUAL = 4;
+const ACTION_CONDITION_NOT_EQUAL = 5;
+const ACTION_CONDITION_IN_RANGE = 6;
+function packSignature(signers, validatorSignature) {
+    const session = signers.session;
+    const permissionId = getPermissionId(session);
+    if (signers.verifyExecutions) {
+        const smartSessionMode = signers.enableData
+            ? SMART_SESSION_MODE_ENABLE
+            : SMART_SESSION_MODE_USE;
+        const sessionData = getSessionData(signers.session);
+        const packedSignature = signers.enableData
+            ? 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 = (0, compact_1.lockTag)();
+    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 chainDigests = signedSessions.map((session, index) => ({
+    const hashesAndChainIds = signedSessions.map((session, index) => ({
         chainId: BigInt(chains[index].id),
         sessionDigest: (0, viem_1.hashStruct)({
-            types: types,
+            types,
             primaryType: 'SignedSession',
             data: session,
         }),
     }));
-    const hashesAndChainIds = chainDigests.map((chainDigest) => ({
-        chainId: BigInt(chainDigest.chainId),
-        sessionDigest: chainDigest.sessionDigest,
-    }));
     const data = {
         domain: {
             name: 'SmartSessionEmissary',
-            version: '1.0.0',
+            version: '1',
         },
         types: types,
         primaryType: 'MultiChainSession',
@@ -110,13 +266,42 @@ async function getSessionDetails(account, sessions) {
         data,
     };
 }
+async function isSessionEnabled(account, provider, session) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: session.chain,
+        transport: (0, utils_1.createTransport)(session.chain, provider),
+    });
+    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: SMART_SESSION_EMISSARY_ADDRESS,
+        address: core_1.SMART_SESSION_EMISSARY_ADDRESS,
         abi: [
             {
                 type: 'function',
@@ -157,7 +342,7 @@ function getSignedSession(account, lockTag, session, nonce) {
         sessionValidator: session.sessionValidator,
         sessionValidatorInitData: session.sessionValidatorInitData,
         salt: session.salt,
-        smartSessionEmissary: SMART_SESSION_EMISSARY_ADDRESS,
+        smartSessionEmissary: core_1.SMART_SESSION_EMISSARY_ADDRESS,
         expires: viem_1.maxUint256,
         nonce,
     };
@@ -166,15 +351,15 @@ async function getEnableSessionCall(account, session, enableSessionSignature, ha
     const sessionData = getSessionData(session);
     const permissionId = getPermissionId(session);
     return {
-        to: SMART_SESSION_EMISSARY_ADDRESS,
+        to: core_1.SMART_SESSION_EMISSARY_ADDRESS,
         data: (0, viem_1.encodeFunctionData)({
             abi: smart_session_emissary_1.default,
             functionName: 'setConfig',
             args: [
                 account,
                 {
-                    scope: SCOPE_MULTICHAIN,
-                    resetPeriod: RESET_PERIOD_ONE_WEEK,
+                    scope: compact_1.SCOPE_MULTICHAIN,
+                    resetPeriod: compact_1.RESET_PERIOD_ONE_WEEK,
                     allocator: viem_1.zeroAddress,
                     permissionId,
                 },
@@ -209,12 +394,34 @@ function getSessionData(session) {
             },
         ],
     };
+    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 {
         sessionValidator: validator.address,
         salt: viem_1.zeroHash,
         sessionValidatorInitData: validator.initData,
         erc7739Policies: erc7739Data,
-        actions: [],
+        actions,
         claimPolicies: [],
     };
 }
@@ -239,6 +446,157 @@ function getPermissionId(session) {
         sessionData.salt,
     ]));
 }
+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 getSmartSessionValidator(config) {
     if (!config.experimental_sessions) {
         return null;
@@ -248,10 +606,13 @@ function getSmartSessionValidator(config) {
         return null;
     }
     return {
-        address: module ?? SMART_SESSION_EMISSARY_ADDRESS,
+        address: module ?? core_1.SMART_SESSION_EMISSARY_ADDRESS,
         initData: '0x',
         deInitData: '0x',
         additionalContext: '0x',
         type: common_1.MODULE_TYPE_ID_VALIDATOR,
     };
 }
+function createFixedArray(length, getValue) {
+    return Array.from({ length }, (_, i) => getValue(i));
+}

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

@@ -1,5 +1,5 @@
 import type { Address } from 'viem';
-import type { AccountType, Execution, IntentCost, IntentInput, IntentOpStatus, IntentResult, IntentRoute, Portfolio, SignedIntentOp } from './types';
+import type { IntentInput, IntentOpStatus, IntentResult, IntentRoute, Portfolio, SignedIntentOp, SplitIntentsInput, SplitIntentsResult } from './types';
 export declare class Orchestrator {
     private serverUrl;
     private apiKey?;
@@ -10,13 +10,8 @@ export declare class Orchestrator {
             [chainId: number]: Address[];
         };
     }): Promise<Portfolio>;
-    getMaxTokenAmount(account: {
-        address: Address;
-        accountType: AccountType;
-        setupOps: Pick<Execution, 'to' | 'data'>[];
-    }, destinationChainId: number, destinationTokenAddress: Address, destinationGasUnits: bigint, sponsored: boolean): Promise<bigint>;
-    getIntentCost(input: IntentInput): Promise<IntentCost>;
     getIntentRoute(input: IntentInput): Promise<IntentRoute>;
+    splitIntents(input: SplitIntentsInput): Promise<SplitIntentsResult>;
     submitIntent(signedIntentOpUnformatted: SignedIntentOp, dryRun: boolean): Promise<IntentResult>;
     getIntentOpStatus(intentId: bigint): Promise<IntentOpStatus>;
     private getHeaders;

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../orchestrator/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAyBnC,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,WAAW,EACX,SAAS,EAET,cAAc,EACf,MAAM,SAAS,CAAA;AAGhB,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAAC,CAAQ;gBAEX,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAKxC,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,SAAS,CAAC;IA+Cf,iBAAiB,CACrB,OAAO,EAAE;QACP,OAAO,EAAE,OAAO,CAAA;QAChB,WAAW,EAAE,WAAW,CAAA;QACxB,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC,EAAE,CAAA;KAC3C,EACD,kBAAkB,EAAE,MAAM,EAC1B,uBAAuB,EAAE,OAAO,EAChC,mBAAmB,EAAE,MAAM,EAC3B,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,MAAM,CAAC;IA0CZ,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAQtD,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAQxD,YAAY,CAChB,yBAAyB,EAAE,cAAc,EACzC,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,YAAY,CAAC;IAgBlB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IASlE,OAAO,CAAC,UAAU;YAUJ,KAAK;IA4BnB,OAAO,CAAC,UAAU;IA6GlB,OAAO,CAAC,iBAAiB;CAmG1B"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../orchestrator/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AA0BnC,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,WAAW,EACX,SAAS,EAET,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,SAAS,CAAA;AAchB,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAAC,CAAQ;gBAEX,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAKxC,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,SAAS,CAAC;IA+Cf,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAQxD,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAwDnE,YAAY,CAChB,yBAAyB,EAAE,cAAc,EACzC,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,YAAY,CAAC;IAgBlB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IASlE,OAAO,CAAC,UAAU;YAUJ,KAAK;IA4BnB,OAAO,CAAC,UAAU;IA6GlB,OAAO,CAAC,iBAAiB;CAmG1B"}