@charterlabs/rhinestone-sdk 0.1.1 → 0.1.2

package/dist/src/execution/compact.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPACT_ADDRESS = void 0;
+exports.getDepositEtherCall = getDepositEtherCall;
+exports.getDepositErc20Call = getDepositErc20Call;
+exports.getApproveErc20Call = getApproveErc20Call;
+const viem_1 = require("viem");
+const COMPACT_ADDRESS = '0xa2E6C7Ba8613E1534dCB990e7e4962216C0a5d58';
+exports.COMPACT_ADDRESS = COMPACT_ADDRESS;
+const ALLOCATOR_ADDRESS = '0x9Ef7519F90C9B6828650Ff4913d663BB1f688507';
+const DEFAULT_RESET_PERIOD = 3;
+const DEFAULT_SCOPE = 0;
+function getDepositEtherCall(account, value) {
+    return {
+        to: COMPACT_ADDRESS,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    type: 'function',
+                    name: 'depositNative',
+                    inputs: [
+                        { name: 'lockTag', type: 'bytes12', internalType: 'bytes12' },
+                        { name: 'recipient', type: 'address', internalType: 'address' },
+                    ],
+                    outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+                    stateMutability: 'payable',
+                },
+            ],
+            functionName: 'depositNative',
+            args: [lockTag(), account],
+        }),
+        value,
+    };
+}
+function getDepositErc20Call(account, tokenAddress, amount) {
+    return {
+        to: COMPACT_ADDRESS,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    type: 'function',
+                    name: 'depositERC20',
+                    inputs: [
+                        {
+                            name: 'token',
+                            type: 'address',
+                            internalType: 'address',
+                        },
+                        { name: 'lockTag', type: 'bytes12', internalType: 'bytes12' },
+                        { name: 'amount', type: 'uint256', internalType: 'uint256' },
+                        { name: 'recipient', type: 'address', internalType: 'address' },
+                    ],
+                    outputs: [{ name: 'id', type: 'uint256', internalType: 'uint256' }],
+                    stateMutability: 'nonpayable',
+                },
+            ],
+            functionName: 'depositERC20',
+            args: [tokenAddress, lockTag(), amount, account],
+        }),
+    };
+}
+function getApproveErc20Call(tokenAddress, amount) {
+    return {
+        to: tokenAddress,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: viem_1.erc20Abi,
+            functionName: 'approve',
+            args: [COMPACT_ADDRESS, amount],
+        }),
+    };
+}
+function toCompactFlag(allocator) {
+    const addrBytes = Buffer.from(allocator.slice(2), 'hex');
+    let leadingZeroNibbles = 0;
+    for (const byte of addrBytes) {
+        if (byte === 0) {
+            leadingZeroNibbles += 2;
+        }
+        else {
+            if (byte >> 4 === 0)
+                leadingZeroNibbles += 1;
+            break;
+        }
+    }
+    if (leadingZeroNibbles >= 18)
+        return 15;
+    if (leadingZeroNibbles >= 4)
+        return leadingZeroNibbles - 3;
+    return 0;
+}
+function usingAllocatorId(allocator = ALLOCATOR_ADDRESS) {
+    const compactFlag = BigInt(toCompactFlag(allocator));
+    const last88Bits = BigInt(`0x${allocator.slice(-22)}`); // Extract last 88 bits (11 bytes * 2 hex chars per byte)
+    return (compactFlag << 88n) | last88Bits;
+}
+function lockTag() {
+    const allocatorId = usingAllocatorId(ALLOCATOR_ADDRESS);
+    const tagBig = (BigInt(DEFAULT_SCOPE) << 255n) |
+        (BigInt(DEFAULT_RESET_PERIOD) << 252n) |
+        (allocatorId << 160n);
+    const hex = tagBig.toString(16).slice(0, 24);
+    return `0x${hex}`;
+}

package/dist/src/execution/error.d.ts

@@ -0,0 +1,54 @@
+declare class ExecutionError extends Error {
+    private readonly _message;
+    private readonly _context;
+    private readonly _errorType;
+    private readonly _traceId;
+    constructor(params?: {
+        message?: string;
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+    get message(): string;
+    get context(): any;
+    get errorType(): string;
+    get traceId(): string;
+}
+declare class SourceChainsNotAvailableForUserOpFlowError extends ExecutionError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class UserOperationRequiredForSmartSessionsError extends ExecutionError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class OrderPathRequiredForIntentsError extends ExecutionError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class SessionChainRequiredError extends ExecutionError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class IntentFailedError extends ExecutionError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare function isExecutionError(error: Error): error is ExecutionError;
+export { isExecutionError, ExecutionError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError, OrderPathRequiredForIntentsError, SessionChainRequiredError, IntentFailedError, };
+//# sourceMappingURL=error.d.ts.map

package/dist/src/execution/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../execution/error.ts"],"names":[],"mappings":"AAAA,cAAM,cAAe,SAAQ,KAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAK;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;IAQD,IAAI,OAAO,WAEV;IAED,IAAI,OAAO,QAEV;IAED,IAAI,SAAS,WAEZ;IAED,IAAI,OAAO,WAEV;CACF;AAED,cAAM,0CAA2C,SAAQ,cAAc;gBACzD,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,0CAA2C,SAAQ,cAAc;gBACzD,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,gCAAiC,SAAQ,cAAc;gBAC/C,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,yBAA0B,SAAQ,cAAc;gBACxC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAOF;AAED,cAAM,iBAAkB,SAAQ,cAAc;gBAChC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,iBAAS,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,cAAc,CAE/D;AAED,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,0CAA0C,EAC1C,0CAA0C,EAC1C,gCAAgC,EAChC,yBAAyB,EACzB,iBAAiB,GAClB,CAAA"}

package/dist/src/execution/error.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntentFailedError = exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.UserOperationRequiredForSmartSessionsError = exports.SourceChainsNotAvailableForUserOpFlowError = exports.ExecutionError = void 0;
+exports.isExecutionError = isExecutionError;
+class ExecutionError extends Error {
+    _message;
+    _context;
+    _errorType;
+    _traceId;
+    constructor(params) {
+        super();
+        this._message = params?.message || 'ExecutionError';
+        this._context = params?.context || {};
+        this._errorType = params?.errorType || 'Unknown';
+        this._traceId = params?.traceId || '';
+    }
+    get message() {
+        return this._message;
+    }
+    get context() {
+        return this._context;
+    }
+    get errorType() {
+        return this._errorType;
+    }
+    get traceId() {
+        return this._traceId;
+    }
+}
+exports.ExecutionError = ExecutionError;
+class SourceChainsNotAvailableForUserOpFlowError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: "Can't specify the source chains when using user operations",
+            ...params,
+        });
+    }
+}
+exports.SourceChainsNotAvailableForUserOpFlowError = SourceChainsNotAvailableForUserOpFlowError;
+class UserOperationRequiredForSmartSessionsError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: 'User operation is required when using smart sessions',
+            ...params,
+        });
+    }
+}
+exports.UserOperationRequiredForSmartSessionsError = UserOperationRequiredForSmartSessionsError;
+class OrderPathRequiredForIntentsError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: 'Order path is required when using intents',
+            ...params,
+        });
+    }
+}
+exports.OrderPathRequiredForIntentsError = OrderPathRequiredForIntentsError;
+class SessionChainRequiredError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: 'Specifying a chain is required when using multi-chain smart sessions',
+            ...params,
+        });
+    }
+}
+exports.SessionChainRequiredError = SessionChainRequiredError;
+class IntentFailedError extends ExecutionError {
+    constructor(params) {
+        super({
+            message: 'Intent failed',
+            ...params,
+        });
+    }
+}
+exports.IntentFailedError = IntentFailedError;
+function isExecutionError(error) {
+    return error instanceof ExecutionError;
+}

package/dist/{execution → src/execution}/index.d.ts

@@ -1,9 +1,10 @@
 import { type Address, type Chain } from 'viem';
-import type { BundleResult } from '../orchestrator';
+import type { IntentOpStatus } from '../orchestrator';
 import type { RhinestoneAccountConfig, Transaction } from '../types';
-import type { BundleData, TransactionResult } from './utils';
+import { ExecutionError, IntentFailedError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError } from './error';
+import type { IntentData, TransactionResult } from './utils';
 declare function sendTransaction(config: RhinestoneAccountConfig, transaction: Transaction): Promise<TransactionResult>;
-declare function waitForExecution(config: RhinestoneAccountConfig, result: TransactionResult, acceptsPreconfirmations: boolean): Promise<BundleResult | {
+declare function waitForExecution(config: RhinestoneAccountConfig, result: TransactionResult, acceptsPreconfirmations: boolean): Promise<IntentOpStatus | {
     actualGasCost: bigint;
     actualGasUsed: bigint;
     entryPoint: Address;
@@ -17,7 +18,7 @@ declare function waitForExecution(config: RhinestoneAccountConfig, result: Trans
     userOpHash: import("viem").Hash;
 }>;
 declare function getMaxSpendableAmount(config: RhinestoneAccountConfig, chain: Chain, tokenAddress: Address, gasUnits: bigint): Promise<bigint>;
-declare function getPortfolio(config: RhinestoneAccountConfig, onTestnets: boolean): Promise<import("../orchestrator").UserTokenBalance[]>;
-export { sendTransaction, waitForExecution, getMaxSpendableAmount, getPortfolio, };
-export type { BundleData, TransactionResult };
+declare function getPortfolio(config: RhinestoneAccountConfig, onTestnets: boolean): Promise<import("../orchestrator").Portfolio>;
+export { sendTransaction, waitForExecution, getMaxSpendableAmount, getPortfolio, isExecutionError, IntentFailedError, ExecutionError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError, OrderPathRequiredForIntentsError, SessionChainRequiredError, };
+export type { IntentData, TransactionResult };
 //# sourceMappingURL=index.d.ts.map

package/dist/src/execution/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAAmC,MAAM,MAAM,CAAA;AAKhF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAQrD,OAAO,KAAK,EAEV,uBAAuB,EAGvB,WAAW,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,gCAAgC,EAChC,yBAAyB,EACzB,0CAA0C,EAC1C,0CAA0C,EAC3C,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAa5D,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BA2BzB;AAqID,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iBAAiB,EACzB,uBAAuB,EAAE,OAAO;;;;;;;;;;;;GA2CjC;AAED,iBAAe,qBAAqB,CAClC,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,iBAAe,YAAY,CACzB,MAAM,EAAE,uBAAuB,EAC/B,UAAU,EAAE,OAAO,gDAMpB;AAED,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,EAEZ,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,0CAA0C,EAC1C,0CAA0C,EAC1C,gCAAgC,EAChC,yBAAyB,GAC1B,CAAA;AACD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/src/execution/index.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.UserOperationRequiredForSmartSessionsError = exports.SourceChainsNotAvailableForUserOpFlowError = exports.ExecutionError = exports.IntentFailedError = exports.isExecutionError = void 0;
+exports.sendTransaction = sendTransaction;
+exports.waitForExecution = waitForExecution;
+exports.getMaxSpendableAmount = getMaxSpendableAmount;
+exports.getPortfolio = getPortfolio;
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const accounts_1 = require("../accounts");
+const utils_1 = require("../accounts/utils");
+const orchestrator_1 = require("../orchestrator");
+const registry_1 = require("../orchestrator/registry");
+const error_1 = require("./error");
+Object.defineProperty(exports, "ExecutionError", { enumerable: true, get: function () { return error_1.ExecutionError; } });
+Object.defineProperty(exports, "IntentFailedError", { enumerable: true, get: function () { return error_1.IntentFailedError; } });
+Object.defineProperty(exports, "isExecutionError", { enumerable: true, get: function () { return error_1.isExecutionError; } });
+Object.defineProperty(exports, "OrderPathRequiredForIntentsError", { enumerable: true, get: function () { return error_1.OrderPathRequiredForIntentsError; } });
+Object.defineProperty(exports, "SessionChainRequiredError", { enumerable: true, get: function () { return error_1.SessionChainRequiredError; } });
+Object.defineProperty(exports, "SourceChainsNotAvailableForUserOpFlowError", { enumerable: true, get: function () { return error_1.SourceChainsNotAvailableForUserOpFlowError; } });
+Object.defineProperty(exports, "UserOperationRequiredForSmartSessionsError", { enumerable: true, get: function () { return error_1.UserOperationRequiredForSmartSessionsError; } });
+const smart_session_1 = require("./smart-session");
+const utils_2 = require("./utils");
+const POLLING_INTERVAL = 500;
+async function sendTransaction(config, transaction) {
+    if ('chain' in transaction) {
+        // Same-chain transaction
+        return await sendTransactionInternal(config, [transaction.chain], transaction.chain, transaction.calls, transaction.gasLimit, transaction.tokenRequests, transaction.signers, transaction.sponsored);
+    }
+    else {
+        // Cross-chain transaction
+        return await sendTransactionInternal(config, transaction.sourceChains || [], transaction.targetChain, transaction.calls, transaction.gasLimit, transaction.tokenRequests, transaction.signers, transaction.sponsored);
+    }
+}
+async function sendTransactionInternal(config, sourceChains, targetChain, callInputs, gasLimit, initialTokenRequests, signers, sponsored) {
+    const accountAddress = (0, accounts_1.getAddress)(config);
+    // Across requires passing some value to repay the solvers
+    const tokenRequests = !initialTokenRequests || initialTokenRequests.length === 0
+        ? [
+            {
+                address: viem_1.zeroAddress,
+                amount: 1n,
+            },
+        ]
+        : initialTokenRequests;
+    const asUserOp = signers?.type === 'guardians' || signers?.type === 'session';
+    if (asUserOp) {
+        const withSession = signers?.type === 'session' ? signers.session : null;
+        if (withSession) {
+            await (0, smart_session_1.enableSmartSession)(targetChain, config, withSession);
+        }
+        // Smart sessions require a UserOp flow
+        return await sendTransactionAsUserOp(config, targetChain, callInputs, signers);
+    }
+    else {
+        return await sendTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, signers, sponsored);
+    }
+}
+async function sendTransactionAsUserOp(config, chain, callInputs, signers) {
+    // Make sure the account is deployed
+    await (0, accounts_1.deploy)(config, chain);
+    const withSession = signers?.type === 'session' ? signers.session : null;
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const validatorAccount = await (0, utils_2.getValidatorAccount)(config, signers, publicClient, chain);
+    if (!validatorAccount) {
+        throw new Error('No validator account found');
+    }
+    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+    if (withSession) {
+        await (0, smart_session_1.enableSmartSession)(chain, config, withSession);
+    }
+    const calls = (0, utils_2.parseCalls)(callInputs, chain.id);
+    const hash = await bundlerClient.sendUserOperation({
+        account: validatorAccount,
+        calls,
+    });
+    return {
+        type: 'userop',
+        hash,
+        chain: chain.id,
+    };
+}
+async function sendTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, signers, sponsored) {
+    const { intentRoute, hash: intentHash } = await (0, utils_2.prepareTransactionAsIntent)(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, sponsored ?? false);
+    if (!intentRoute) {
+        throw new error_1.OrderPathRequiredForIntentsError();
+    }
+    const signature = await (0, utils_2.signIntent)(config, targetChain, intentHash, signers);
+    const authorizations = config.eoa
+        ? await (0, utils_2.signAuthorizationsInternal)(config, {
+            type: 'intent',
+            intentRoute,
+            hash: intentHash,
+        })
+        : [];
+    return await (0, utils_2.submitIntentInternal)(config, sourceChains, targetChain, intentRoute.intentOp, signature, authorizations);
+}
+async function waitForExecution(config, result, acceptsPreconfirmations) {
+    const validStatuses = new Set([
+        orchestrator_1.INTENT_STATUS_FAILED,
+        orchestrator_1.INTENT_STATUS_COMPLETED,
+        orchestrator_1.INTENT_STATUS_FILLED,
+    ]);
+    if (acceptsPreconfirmations) {
+        validStatuses.add(orchestrator_1.INTENT_STATUS_PRECONFIRMED);
+    }
+    switch (result.type) {
+        case 'intent': {
+            let intentStatus = null;
+            while (intentStatus === null || !validStatuses.has(intentStatus.status)) {
+                const orchestrator = (0, utils_2.getOrchestratorByChain)(result.targetChain, config.rhinestoneApiKey);
+                intentStatus = await orchestrator.getIntentOpStatus(result.id);
+                await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL));
+            }
+            if (intentStatus.status === orchestrator_1.INTENT_STATUS_FAILED) {
+                throw new error_1.IntentFailedError();
+            }
+            return intentStatus;
+        }
+        case 'userop': {
+            const targetChain = (0, registry_1.getChainById)(result.chain);
+            if (!targetChain) {
+                throw new Error(`Unsupported chain ID: ${result.chain}`);
+            }
+            const publicClient = (0, viem_1.createPublicClient)({
+                chain: targetChain,
+                transport: (0, utils_1.createTransport)(targetChain, config.provider),
+            });
+            const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+            const receipt = await bundlerClient.waitForUserOperationReceipt({
+                hash: result.hash,
+            });
+            return receipt;
+        }
+    }
+}
+async function getMaxSpendableAmount(config, chain, tokenAddress, gasUnits) {
+    const address = (0, accounts_1.getAddress)(config);
+    const orchestrator = (0, utils_2.getOrchestratorByChain)(chain.id, config.rhinestoneApiKey);
+    return orchestrator.getMaxTokenAmount(address, chain.id, tokenAddress, gasUnits);
+}
+async function getPortfolio(config, onTestnets) {
+    const address = (0, accounts_1.getAddress)(config);
+    const chainId = onTestnets ? chains_1.sepolia.id : chains_1.mainnet.id;
+    const orchestrator = (0, utils_2.getOrchestratorByChain)(chainId, config.rhinestoneApiKey);
+    return orchestrator.getPortfolio(address);
+}

package/dist/src/execution/smart-session.d.ts

@@ -0,0 +1,15 @@
+import { type Chain, type Hex } from 'viem';
+import { type ChainDigest, type EnableSessionData, type SmartSessionModeType } from '../modules/validators/smart-sessions';
+import type { RhinestoneAccountConfig, Session } from '../types';
+interface SessionDetails {
+    permissionEnableHash: Hex;
+    mode: SmartSessionModeType;
+    hashesAndChainIds: ChainDigest[];
+    enableSessionData: EnableSessionData;
+}
+declare function getSessionDetails(config: RhinestoneAccountConfig, sessions: Session[], sessionIndex: number, signature?: Hex): Promise<SessionDetails>;
+declare function getMultichainDigest(chainDigests: ChainDigest[]): Hex;
+declare function enableSmartSession(chain: Chain, config: RhinestoneAccountConfig, session: Session): Promise<void>;
+export { enableSmartSession, getSessionDetails, getMultichainDigest };
+export type { SessionDetails };
+//# sourceMappingURL=smart-session.d.ts.map

package/dist/src/execution/smart-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-session.d.ts","sourceRoot":"","sources":["../../../execution/smart-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,KAAK,EAIV,KAAK,GAAG,EAGT,MAAM,MAAM,CAAA;AAmBb,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,iBAAiB,EAGtB,KAAK,oBAAoB,EAC1B,MAAM,sCAAsC,CAAA;AAC7C,OAAO,KAAK,EAGV,uBAAuB,EACvB,OAAO,EACR,MAAM,UAAU,CAAA;AAGjB,UAAU,cAAc;IACtB,oBAAoB,EAAE,GAAG,CAAA;IACzB,IAAI,EAAE,oBAAoB,CAAA;IAC1B,iBAAiB,EAAE,WAAW,EAAE,CAAA;IAChC,iBAAiB,EAAE,iBAAiB,CAAA;CACrC;AAED,iBAAe,iBAAiB,CAC9B,MAAM,EAAE,uBAAuB,EAC/B,QAAQ,EAAE,OAAO,EAAE,EACnB,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,cAAc,CAAC,CA4BzB;AAgGD,iBAAS,mBAAmB,CAAC,YAAY,EAAE,WAAW,EAAE,GAAG,GAAG,CAgC7D;AAiLD,iBAAe,kBAAkB,CAC/B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,uBAAuB,EAC/B,OAAO,EAAE,OAAO,iBA+BjB;AAED,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,CAAA;AACrE,YAAY,EAAE,cAAc,EAAE,CAAA"}

package/dist/{execution → src/execution}/smart-session.js

@@ -1,24 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enableSmartSession = enableSmartSession;
-exports.hashErc7739 = hashErc7739;
-exports.getSessionSignature = getSessionSignature;
 exports.getSessionDetails = getSessionDetails;
 exports.getMultichainDigest = getMultichainDigest;
 const viem_1 = require("viem");
 const accounts_1 = require("../accounts");
 const utils_1 = require("../accounts/utils");
-const modules_1 = require("../modules");
 const validators_1 = require("../modules/validators");
 const smart_sessions_1 = require("../modules/validators/smart-sessions");
-const utils_2 = require("../orchestrator/utils");
+const error_1 = require("./error");
 async function getSessionDetails(config, sessions, sessionIndex, signature) {
     const account = (0, accounts_1.getAccountProvider)(config);
     const accountAddress = (0, accounts_1.getAddress)(config);
-    const sessionDetails = await getEnableSessionDetails(account.type, sessions, sessionIndex, accountAddress);
+    const sessionDetails = await getEnableSessionDetails(account.type, sessions, sessionIndex, accountAddress, config.provider);
     const chain = sessions[sessionIndex].chain;
     if (!chain) {
-        throw new Error('Session chain is required');
+        throw new error_1.SessionChainRequiredError();
     }
     const validator = {
         address: sessionDetails.enableSessionData.validator,
@@ -26,24 +23,24 @@ async function getSessionDetails(config, sessions, sessionIndex, signature) {
     };
     sessionDetails.enableSessionData.signature =
         signature ??
-            (await (0, accounts_1.getPackedSignature)(config, config.owners, chain, validator, sessionDetails.permissionEnableHash));
+            (await (0, accounts_1.getPackedSignature)(config, undefined, chain, validator, sessionDetails.permissionEnableHash));
     return sessionDetails;
 }
-async function getEnableSessionDetails(accountType, sessions, sessionIndex, accountAddress) {
+async function getEnableSessionDetails(accountType, sessions, sessionIndex, accountAddress, provider) {
     const chainDigests = [];
     const chainSessions = [];
     for (const session of sessions) {
         const permissionId = (0, validators_1.getPermissionId)(session);
-        const publicClient = (0, viem_1.createPublicClient)({
-            chain: session.chain,
-            transport: (0, viem_1.http)(),
-        });
         const sessionChain = session.chain;
         if (!sessionChain) {
-            throw new Error('Session chain is required');
+            throw new error_1.SessionChainRequiredError();
         }
+        const publicClient = (0, viem_1.createPublicClient)({
+            chain: sessionChain,
+            transport: (0, utils_1.createTransport)(sessionChain, provider),
+        });
         const sessionNonce = await getSessionNonce(publicClient, accountAddress, permissionId);
-        const sessionData = await (0, smart_sessions_1.getSessionData)(sessionChain, session);
+        const sessionData = await (0, smart_sessions_1.getSessionData)(sessionChain, session, provider);
         const sessionDigest = await getSessionDigest(publicClient, accountAddress, sessionData, permissionId, validators_1.SMART_SESSION_MODE_ENABLE);
         chainDigests.push({
             chainId: BigInt(sessionChain.id),
@@ -74,9 +71,9 @@ async function getEnableSessionDetails(accountType, sessions, sessionIndex, acco
     const sessionToEnable = sessions[sessionIndex || 0];
     const sessionChain = sessionToEnable.chain;
     if (!sessionChain) {
-        throw new Error('Session chain is required');
+        throw new error_1.SessionChainRequiredError();
     }
-    const sessionData = await (0, smart_sessions_1.getSessionData)(sessionChain, sessionToEnable);
+    const sessionData = await (0, smart_sessions_1.getSessionData)(sessionChain, sessionToEnable, provider);
     return {
         permissionEnableHash,
         mode: validators_1.SMART_SESSION_MODE_ENABLE,
@@ -276,79 +273,21 @@ async function getSessionDigest(client, account, session, permissionId, mode) {
 async function enableSmartSession(chain, config, session) {
     const publicClient = (0, viem_1.createPublicClient)({
         chain,
-        transport: (0, viem_1.http)(),
+        transport: (0, utils_1.createTransport)(chain, config.provider),
     });
     const address = (0, accounts_1.getAddress)(config);
     const isEnabled = await (0, validators_1.isSessionEnabled)(publicClient, address, (0, validators_1.getPermissionId)(session));
     if (isEnabled) {
         return;
     }
-    const enableSessionCall = await (0, validators_1.getEnableSessionCall)(chain, session);
-    const trustedAttesters = await (0, modules_1.getTrustedAttesters)(publicClient, address);
-    const trustAttesterCall = trustedAttesters.length === 0 ? (0, modules_1.getTrustAttesterCall)(config) : undefined;
+    const enableSessionCall = await (0, validators_1.getEnableSessionCall)(chain, session, config.provider);
     const smartAccount = await (0, accounts_1.getSmartAccount)(config, publicClient, chain);
     const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
     const opHash = await bundlerClient.sendUserOperation({
         account: smartAccount,
-        calls: trustAttesterCall
-            ? [trustAttesterCall, enableSessionCall]
-            : [enableSessionCall],
+        calls: [enableSessionCall],
     });
     await bundlerClient.waitForUserOperationReceipt({
         hash: opHash,
     });
 }
-async function hashErc7739(sourceChain, orderPath, accountAddress) {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: sourceChain,
-        transport: (0, viem_1.http)(),
-    });
-    const { appDomainSeparator, contentsType } = await (0, validators_1.getSessionAllowedERC7739Content)(sourceChain);
-    // Create hash following ERC-7739 TypedDataSign workflow
-    const typedDataSignTypehash = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string'], [
-        'TypedDataSign(MultichainCompact contents,string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)'.concat(contentsType),
-    ]));
-    // Original struct hash
-    const structHash = (0, utils_2.hashMultichainCompactWithoutDomainSeparator)(orderPath[0].orderBundle);
-    const { name, version, chainId, verifyingContract, salt } = await (0, validators_1.getAccountEIP712Domain)(publicClient, accountAddress);
-    // Final hash according to ERC-7739
-    const hash = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes2', 'bytes32', 'bytes32'], [
-        '0x1901',
-        appDomainSeparator,
-        (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
-            { name: 'typedDataSignTypehash', type: 'bytes32' },
-            { name: 'structHash', type: 'bytes32' },
-            { name: 'name', type: 'bytes32' },
-            { name: 'version', type: 'bytes32' },
-            { name: 'chainId', type: 'uint256' },
-            { name: 'verifyingContract', type: 'address' },
-            { name: 'salt', type: 'bytes32' },
-        ], [
-            typedDataSignTypehash,
-            structHash,
-            (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string'], [name])),
-            (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string'], [version])),
-            BigInt(Number(chainId)),
-            verifyingContract,
-            salt,
-        ])),
-    ]));
-    return {
-        hash,
-        appDomainSeparator,
-        contentsType,
-        structHash,
-    };
-}
-function getSessionSignature(signature, appDomainSeparator, structHash, contentsType, withSession) {
-    const erc7739Signature = (0, viem_1.encodePacked)(['bytes', 'bytes32', 'bytes32', 'string', 'uint16'], [
-        signature,
-        appDomainSeparator,
-        structHash,
-        contentsType,
-        contentsType.length,
-    ]);
-    // Pack with permissionId for smart session
-    const wrappedSignature = (0, viem_1.encodePacked)(['bytes32', 'bytes'], [(0, validators_1.getPermissionId)(withSession), erc7739Signature]);
-    return wrappedSignature;
-}

package/dist/src/execution/smart-session.test.d.ts

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

package/dist/src/execution/smart-session.test.d.ts.map

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

package/dist/src/execution/smart-session.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const smart_session_1 = require("./smart-session");
+(0, vitest_1.describe)('Smart Session', () => {
+    (0, vitest_1.describe)('Multichain Digest', () => {
+        (0, vitest_1.test)('Single', () => {
+            const digest = (0, smart_session_1.getMultichainDigest)([
+                {
+                    chainId: 421614n,
+                    sessionDigest: '0x971daa09e9deb42457fb008fce5a63987379b31fd67ec6c16ff8b52517bfb373',
+                },
+            ]);
+            (0, vitest_1.expect)(digest).toEqual('0xc0f5a263b2af5a01bc221835faf49b77459a5696f881c25fea9f8144c43f2326');
+        });
+        (0, vitest_1.test)('Multiple', () => {
+            const digest = (0, smart_session_1.getMultichainDigest)([
+                {
+                    chainId: 84532n,
+                    sessionDigest: '0xad3139c2b3ca57ba02e86ba3ad86dd18a05ba53650e3088ebd4fed71166d4bdd',
+                },
+                {
+                    chainId: 84532n,
+                    sessionDigest: '0x1e6cc59dee4aca4a0d9b1fccd6fde197c831d5bd51163746f1947b352732f3db',
+                },
+                {
+                    chainId: 11155420n,
+                    sessionDigest: '0x9b14ad37022e97faf4d9824c8d7e85b97f304839d24a3cd582575753df7d9239',
+                },
+            ]);
+            (0, vitest_1.expect)(digest).toEqual('0x02f738c7e916839b958b21cbf8bf3697ca06fcb7d5fd5eba85ad49c8f2756adb');
+        });
+    });
+});