@rhinestone/sdk 0.9.0 → 0.10.0

package/dist/src/accounts/index.d.ts

@@ -6,22 +6,23 @@ declare function getDeployArgs(config: RhinestoneAccountConfig): {
     salt: `0x${string}`;
     hashedInitcode: `0x${string}`;
     implementation: `0x${string}`;
-    initializationCallData: `0x${string}`;
+    initializationCallData: null;
 } | {
     factory: `0x${string}`;
     factoryData: `0x${string}`;
     salt: `0x${string}`;
     hashedInitcode: `0x${string}`;
     implementation: `0x${string}`;
-    initializationCallData: null;
+    initializationCallData: `0x${string}`;
 };
 declare function getAddress(config: RhinestoneAccountConfig): `0x${string}`;
 declare function isDeployed(chain: Chain, config: RhinestoneAccountConfig): Promise<boolean>;
+declare function deploy(config: RhinestoneAccountConfig, chain: Chain, session?: Session): Promise<void>;
 declare function deploySource(chain: Chain, config: RhinestoneAccountConfig): Promise<void>;
 declare function deployTarget(chain: Chain, config: RhinestoneAccountConfig, asUserOp: boolean): Promise<void>;
 declare function getBundleInitCode(config: RhinestoneAccountConfig): `0x${string}` | undefined;
 declare function getSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
 declare function getSmartSessionSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain, session: Session): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
 declare function sign(validators: OwnerSet, chain: Chain, hash: Hex): Promise<`0x${string}`>;
-export { getDeployArgs, getBundleInitCode, getAddress, isDeployed, deploySource, deployTarget, getSmartAccount, getSmartSessionSmartAccount, sign, };
+export { getDeployArgs, getBundleInitCode, getAddress, isDeployed, deploy, deploySource, deployTarget, getSmartAccount, getSmartSessionSmartAccount, sign, };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../accounts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,KAAK,EAKV,KAAK,GAAG,EAGR,KAAK,YAAY,EAIlB,MAAM,MAAM,CAAA;AAUb,OAAO,KAAK,EAEV,QAAQ,EACR,uBAAuB,EACvB,OAAO,EACR,MAAM,UAAU,CAAA;AAiBjB,iBAAS,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;;;;;;;;;EAUrD;AAED,iBAAS,UAAU,CAAC,MAAM,EAAE,uBAAuB,iBAgBlD;AAED,iBAAe,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,oBAiBtE;AAED,iBAAe,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,iBAMxE;AAED,iBAAe,YAAY,CACzB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,uBAAuB,EAC/B,QAAQ,EAAE,OAAO,iBASlB;AAUD,iBAAS,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,6BAUzD;AAgID,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,KAAK,sJA0Bb;AAED,iBAAe,2BAA2B,CACxC,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,sJA8BjB;AAED,iBAAe,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,0BAYhE;AAgED,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,2BAA2B,EAC3B,IAAI,GACL,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../accounts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,KAAK,EAKV,KAAK,GAAG,EAGR,KAAK,YAAY,EAIlB,MAAM,MAAM,CAAA;AAWb,OAAO,KAAK,EAEV,QAAQ,EACR,uBAAuB,EACvB,OAAO,EACR,MAAM,UAAU,CAAA;AAiBjB,iBAAS,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;;;;;;;;;EAUrD;AAED,iBAAS,UAAU,CAAC,MAAM,EAAE,uBAAuB,iBAgBlD;AAED,iBAAe,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,oBAiBtE;AAED,iBAAe,MAAM,CACnB,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,OAAO,iBAMlB;AAED,iBAAe,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,iBAMxE;AAED,iBAAe,YAAY,CACzB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,uBAAuB,EAC/B,QAAQ,EAAE,OAAO,iBASlB;AAUD,iBAAS,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,6BAUzD;AAgID,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,KAAK,sJA0Bb;AAED,iBAAe,2BAA2B,CACxC,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,sJA8BjB;AAED,iBAAe,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,0BAYhE;AAgED,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,MAAM,EACN,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,2BAA2B,EAC3B,IAAI,GACL,CAAA"}

package/dist/src/accounts/index.js

@@ -4,12 +4,14 @@ exports.getDeployArgs = getDeployArgs;
 exports.getBundleInitCode = getBundleInitCode;
 exports.getAddress = getAddress;
 exports.isDeployed = isDeployed;
+exports.deploy = deploy;
 exports.deploySource = deploySource;
 exports.deployTarget = deployTarget;
 exports.getSmartAccount = getSmartAccount;
 exports.getSmartSessionSmartAccount = getSmartSessionSmartAccount;
 exports.sign = sign;
 const viem_1 = require("viem");
+const smart_session_1 = require("../execution/smart-session");
 const modules_1 = require("../modules");
 const validators_1 = require("../modules/validators");
 const nexus_1 = require("./nexus");
@@ -56,6 +58,12 @@ async function isDeployed(chain, config) {
     }
     return (0, viem_1.size)(code) > 0;
 }
+async function deploy(config, chain, session) {
+    await deploySource(chain, config);
+    if (session) {
+        await (0, smart_session_1.enableSmartSession)(chain, config, session);
+    }
+}
 async function deploySource(chain, config) {
     if (is7702(config)) {
         return deploy7702Self(chain, config);

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

@@ -1,19 +1,9 @@
-import { type Address, type Chain, type Hex } from 'viem';
+import { type Address, type Chain } from 'viem';
 import type { BundleResult } from '../orchestrator';
 import type { RhinestoneAccountConfig, Transaction } from '../types';
-type TransactionResult = {
-    type: 'userop';
-    hash: Hex;
-    sourceChain: number;
-    targetChain: number;
-} | {
-    type: 'bundle';
-    id: bigint;
-    sourceChain?: number;
-    targetChain: number;
-};
+import type { BundleData, 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<{
     actualGasCost: bigint;
     actualGasUsed: bigint;
     entryPoint: Address;
@@ -25,9 +15,9 @@ declare function waitForExecution(config: RhinestoneAccountConfig, result: Trans
     sender: Address;
     success: boolean;
     userOpHash: import("viem").Hash;
-}>;
+} | BundleResult>;
 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 { TransactionResult };
+export type { BundleData, TransactionResult };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAIV,KAAK,GAAG,EAMT,MAAM,MAAM,CAAA;AAmBb,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,iBAAiB,CAAA;AAqBxB,OAAO,KAAK,EAEV,uBAAuB,EAIvB,WAAW,EACZ,MAAM,UAAU,CAAA;AASjB,KAAK,iBAAiB,GAClB;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,GAAG,CAAA;IACT,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAEL,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BAyBzB;AAsSD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iBAAiB,EACzB,uBAAuB,EAAE,OAAO;;;;;;;;;;;;GAwCjC;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,yDAMpB;AASD,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,GACb,CAAA;AACD,YAAY,EAAE,iBAAiB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAIX,MAAM,MAAM,CAAA;AAYb,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAYnD,OAAO,KAAK,EAEV,uBAAuB,EAIvB,WAAW,EACZ,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAa5D,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BAyBzB;AA0KD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iBAAiB,EACzB,uBAAuB,EAAE,OAAO;;;;;;;;;;;;kBAwCjC;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,yDAMpB;AAED,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,GACb,CAAA;AACD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/src/execution/index.js

@@ -5,16 +5,13 @@ exports.waitForExecution = waitForExecution;
 exports.getMaxSpendableAmount = getMaxSpendableAmount;
 exports.getPortfolio = getPortfolio;
 const viem_1 = require("viem");
-const account_abstraction_1 = require("viem/account-abstraction");
 const chains_1 = require("viem/chains");
 const accounts_1 = require("../accounts");
 const utils_1 = require("../accounts/utils");
-const modules_1 = require("../modules");
-const validators_1 = require("../modules/validators");
 const orchestrator_1 = require("../orchestrator");
-const consts_1 = require("../orchestrator/consts");
 const registry_1 = require("../orchestrator/registry");
 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) {
@@ -63,12 +60,6 @@ async function sendTransactionAsUserOp(config, sourceChain, targetChain, calls,
     });
     const sessionAccount = await (0, accounts_1.getSmartSessionSmartAccount)(config, publicClient, sourceChain, withSession);
     const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
-    const targetPublicClient = (0, viem_1.createPublicClient)({
-        chain: targetChain,
-        transport: (0, viem_1.http)(),
-    });
-    const targetSessionAccount = await (0, accounts_1.getSmartSessionSmartAccount)(config, targetPublicClient, targetChain, withSession);
-    const targetBundlerClient = (0, utils_1.getBundlerClient)(config, targetPublicClient);
     if (sourceChain.id === targetChain.id) {
         await (0, smart_session_1.enableSmartSession)(targetChain, config, withSession);
         const hash = await bundlerClient.sendUserOperation({
@@ -82,132 +73,18 @@ async function sendTransactionAsUserOp(config, sourceChain, targetChain, calls,
             targetChain: targetChain.id,
         };
     }
-    const accountAccessList = sourceChain
-        ? {
-            chainIds: [sourceChain.id],
-        }
-        : (0, registry_1.getDefaultAccountAccessList)();
-    const metaIntent = {
-        targetChainId: targetChain.id,
-        tokenTransfers: tokenRequests.map((tokenRequest) => ({
-            tokenAddress: tokenRequest.address,
-            amount: tokenRequest.amount,
-        })),
-        targetAccount: accountAddress,
-        targetGasUnits: gasLimit,
-        userOp: (0, orchestrator_1.getEmptyUserOp)(),
-        accountAccessList,
-    };
-    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
-    const orderPath = await orchestrator.getOrderPath(metaIntent, accountAddress);
+    const orderPath = await (0, utils_2.getUserOpOrderPath)(sourceChain, targetChain, tokenRequests, accountAddress, gasLimit, config.rhinestoneApiKey);
     // Deploy the account on the target chain
     await (0, accounts_1.deployTarget)(targetChain, config, true);
     await (0, smart_session_1.enableSmartSession)(targetChain, config, withSession);
-    const userOp = await targetBundlerClient.prepareUserOperation({
-        account: targetSessionAccount,
-        calls: [...orderPath[0].injectedExecutions, ...calls],
-        stateOverride: [
-            ...tokenRequests.map((request) => {
-                const rootBalanceSlot = (0, orchestrator_1.getTokenRootBalanceSlot)(targetChain, request.address);
-                const balanceSlot = rootBalanceSlot
-                    ? (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'address' }, { type: 'uint256' }], [accountAddress, rootBalanceSlot]))
-                    : '0x';
-                return {
-                    address: request.address,
-                    stateDiff: [
-                        {
-                            slot: balanceSlot,
-                            value: (0, viem_1.pad)((0, viem_1.toHex)(request.amount)),
-                        },
-                    ],
-                };
-            }),
-        ],
-    });
-    userOp.signature = await targetSessionAccount.signUserOperation(userOp);
-    const userOpHash = (0, account_abstraction_1.getUserOperationHash)({
-        userOperation: userOp,
-        chainId: targetChain.id,
-        entryPointAddress: account_abstraction_1.entryPoint07Address,
-        entryPointVersion: '0.7',
-    });
-    orderPath[0].orderBundle.segments[0].witness.userOpHash = userOpHash;
-    const { hash, appDomainSeparator, contentsType, structHash } = await (0, smart_session_1.hashErc7739)(sourceChain, orderPath, accountAddress);
-    const signature = await (0, accounts_1.sign)(withSession.owners, targetChain, hash);
-    const sessionSignature = (0, smart_session_1.getSessionSignature)(signature, appDomainSeparator, structHash, contentsType, withSession);
-    const smartSessionValidator = (0, validators_1.getSmartSessionValidator)(config);
-    if (!smartSessionValidator) {
-        throw new Error('Smart session validator not available');
-    }
-    const packedSig = (0, viem_1.encodePacked)(['address', 'bytes'], [smartSessionValidator.address, sessionSignature]);
-    const signedOrderBundle = {
-        ...orderPath[0].orderBundle,
-        originSignatures: Array(orderPath[0].orderBundle.segments.length).fill(packedSig),
-        targetSignature: packedSig,
-    };
-    const bundleResults = await orchestrator.postSignedOrderBundle([
-        {
-            signedOrderBundle,
-            userOp,
-        },
-    ]);
-    return {
-        type: 'bundle',
-        id: bundleResults[0].bundleId,
-        sourceChain: sourceChain.id,
-        targetChain: targetChain.id,
-    };
+    const userOp = await (0, utils_2.getUserOp)(config, targetChain, withSession, orderPath, calls, tokenRequests, accountAddress);
+    const sessionSignature = await (0, utils_2.signUserOp)(config, sourceChain, targetChain, accountAddress, withSession, userOp, orderPath);
+    return await (0, utils_2.submitUserOp)(config, sourceChain, targetChain, userOp, orderPath, sessionSignature);
 }
 async function sendTransactionAsIntent(config, sourceChain, targetChain, calls, gasLimit, tokenRequests, accountAddress) {
-    const accountAccessList = sourceChain
-        ? {
-            chainIds: [sourceChain.id],
-        }
-        : (0, registry_1.getDefaultAccountAccessList)();
-    const metaIntent = {
-        targetChainId: targetChain.id,
-        tokenTransfers: tokenRequests.map((tokenRequest) => ({
-            tokenAddress: tokenRequest.address,
-            amount: tokenRequest.amount,
-        })),
-        targetAccount: accountAddress,
-        targetExecutions: calls.map((call) => ({
-            value: call.value ?? 0n,
-            to: call.to,
-            data: call.data ?? '0x',
-        })),
-        targetGasUnits: gasLimit,
-        accountAccessList,
-    };
-    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
-    const orderPath = await orchestrator.getOrderPath(metaIntent, accountAddress);
-    orderPath[0].orderBundle.segments[0].witness.execs = [
-        ...orderPath[0].injectedExecutions,
-        ...metaIntent.targetExecutions,
-    ];
-    const orderBundleHash = (0, orchestrator_1.getOrderBundleHash)(orderPath[0].orderBundle);
+    const { orderPath, hash: orderBundleHash } = await (0, utils_2.prepareTransactionAsIntent)(config, sourceChain, targetChain, calls, gasLimit, tokenRequests, accountAddress);
     const bundleSignature = await (0, accounts_1.sign)(config.owners, sourceChain || targetChain, orderBundleHash);
-    const validatorModule = (0, modules_1.getOwnerValidator)(config);
-    const packedSig = (0, viem_1.encodePacked)(['address', 'bytes'], [validatorModule.address, bundleSignature]);
-    const signedOrderBundle = {
-        ...orderPath[0].orderBundle,
-        originSignatures: Array(orderPath[0].orderBundle.segments.length).fill(packedSig),
-        targetSignature: packedSig,
-    };
-    await (0, accounts_1.deployTarget)(targetChain, config, false);
-    const initCode = (0, accounts_1.getBundleInitCode)(config);
-    const bundleResults = await orchestrator.postSignedOrderBundle([
-        {
-            signedOrderBundle,
-            initCode,
-        },
-    ]);
-    return {
-        type: 'bundle',
-        id: bundleResults[0].bundleId,
-        sourceChain: sourceChain?.id,
-        targetChain: targetChain.id,
-    };
+    return await (0, utils_2.submitIntentInternal)(config, sourceChain, targetChain, orderPath, bundleSignature, true);
 }
 async function waitForExecution(config, result, acceptsPreconfirmations) {
     const validStatuses = new Set([
@@ -222,7 +99,7 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
         case 'bundle': {
             let bundleResult = null;
             while (bundleResult === null || !validStatuses.has(bundleResult.status)) {
-                const orchestrator = getOrchestratorByChain(result.targetChain, config.rhinestoneApiKey);
+                const orchestrator = (0, utils_2.getOrchestratorByChain)(result.targetChain, config.rhinestoneApiKey);
                 bundleResult = await orchestrator.getBundleStatus(result.id);
                 await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL));
             }
@@ -247,18 +124,12 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
 }
 async function getMaxSpendableAmount(config, chain, tokenAddress, gasUnits) {
     const address = (0, accounts_1.getAddress)(config);
-    const orchestrator = getOrchestratorByChain(chain.id, config.rhinestoneApiKey);
+    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 = getOrchestratorByChain(chainId, config.rhinestoneApiKey);
+    const orchestrator = (0, utils_2.getOrchestratorByChain)(chainId, config.rhinestoneApiKey);
     return orchestrator.getPortfolio(address, (0, registry_1.getDefaultAccountAccessList)());
 }
-function getOrchestratorByChain(chainId, apiKey) {
-    const orchestratorUrl = (0, registry_1.isTestnet)(chainId)
-        ? consts_1.DEV_ORCHESTRATOR_URL
-        : consts_1.PROD_ORCHESTRATOR_URL;
-    return (0, orchestrator_1.getOrchestrator)(apiKey, orchestratorUrl);
-}

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

@@ -0,0 +1,66 @@
+import { Address, Chain, Hex } from 'viem';
+import { UserOperation } from 'viem/account-abstraction';
+import { OrderPath } from '../orchestrator/types';
+import { Call, RhinestoneAccountConfig, Session, TokenRequest, Transaction } from '../types';
+type TransactionResult = {
+    type: 'userop';
+    hash: Hex;
+    sourceChain: number;
+    targetChain: number;
+} | {
+    type: 'bundle';
+    id: bigint;
+    sourceChain?: number;
+    targetChain: number;
+};
+interface BundleData {
+    hash: Hex;
+    orderPath: OrderPath;
+    userOp?: UserOperation;
+}
+interface PreparedTransactionData {
+    bundleData: BundleData;
+    transaction: Transaction;
+}
+interface SignedTransactionData extends PreparedTransactionData {
+    signature: Hex;
+}
+declare function prepareTransaction(config: RhinestoneAccountConfig, transaction: Transaction): Promise<PreparedTransactionData>;
+declare function signTransaction(config: RhinestoneAccountConfig, preparedTransaction: PreparedTransactionData): Promise<SignedTransactionData>;
+declare function submitTransaction(config: RhinestoneAccountConfig, signedTransaction: SignedTransactionData): Promise<TransactionResult>;
+declare function prepareTransactionAsIntent(config: RhinestoneAccountConfig, sourceChain: Chain | undefined, targetChain: Chain, calls: Call[], gasLimit: bigint | undefined, tokenRequests: TokenRequest[], accountAddress: Address): Promise<BundleData>;
+declare function signUserOp(config: RhinestoneAccountConfig, sourceChain: Chain, targetChain: Chain, accountAddress: Address, withSession: Session, userOp: UserOperation, orderPath: OrderPath): Promise<`0x${string}`>;
+declare function submitUserOp(config: RhinestoneAccountConfig, sourceChain: Chain, targetChain: Chain, userOp: UserOperation, orderPath: OrderPath, sessionSignature: Hex): Promise<TransactionResult>;
+declare function getOrchestratorByChain(chainId: number, apiKey: string): import("../orchestrator").Orchestrator;
+declare function getUserOpOrderPath(sourceChain: Chain, targetChain: Chain, tokenRequests: TokenRequest[], accountAddress: Address, gasLimit: bigint | undefined, rhinestoneApiKey: string): Promise<OrderPath>;
+declare function getUserOp(config: RhinestoneAccountConfig, targetChain: Chain, withSession: Session, orderPath: OrderPath, calls: Call[], tokenRequests: TokenRequest[], accountAddress: Address): Promise<{
+    readonly account: import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>;
+    readonly stateOverride: {
+        address: `0x${string}`;
+        stateDiff: {
+            slot: `0x${string}`;
+            value: `0x${string}`;
+        }[];
+    }[];
+    callData: Hex;
+    paymasterAndData: undefined;
+    sender: UserOperation["sender"];
+    authorization: UserOperation["authorization"];
+    factory: UserOperation["factory"];
+    factoryData: UserOperation["factoryData"];
+    nonce: UserOperation["nonce"];
+    maxFeePerGas: UserOperation["maxFeePerGas"];
+    maxPriorityFeePerGas: UserOperation["maxPriorityFeePerGas"];
+    callGasLimit: UserOperation["callGasLimit"];
+    preVerificationGas: UserOperation["preVerificationGas"];
+    verificationGasLimit: UserOperation["verificationGasLimit"];
+    paymasterPostOpGasLimit: UserOperation["paymasterPostOpGasLimit"];
+    paymasterVerificationGasLimit: UserOperation["paymasterVerificationGasLimit"];
+    paymaster: UserOperation["paymaster"];
+    paymasterData: UserOperation["paymasterData"];
+    signature: UserOperation["signature"];
+}>;
+declare function submitIntentInternal(config: RhinestoneAccountConfig, sourceChain: Chain | undefined, targetChain: Chain, orderPath: OrderPath, bundleSignature: Hex, deploy: boolean): Promise<TransactionResult>;
+export { prepareTransaction, signTransaction, submitTransaction, getOrchestratorByChain, getUserOpOrderPath, getUserOp, signUserOp, submitUserOp, prepareTransactionAsIntent, submitIntentInternal, };
+export type { BundleData, TransactionResult, PreparedTransactionData, SignedTransactionData, };
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../execution/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,KAAK,EAIL,GAAG,EAMJ,MAAM,MAAM,CAAA;AACb,OAAO,EAGL,aAAa,EACd,MAAM,0BAA0B,CAAA;AA2BjC,OAAO,EAEL,SAAS,EAGV,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,IAAI,EACJ,uBAAuB,EACvB,OAAO,EACP,YAAY,EACZ,WAAW,EACZ,MAAM,UAAU,CAAA;AAIjB,KAAK,iBAAiB,GAClB;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,GAAG,CAAA;IACT,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAEL,UAAU,UAAU;IAClB,IAAI,EAAE,GAAG,CAAA;IACT,SAAS,EAAE,SAAS,CAAA;IACpB,MAAM,CAAC,EAAE,aAAa,CAAA;CACvB;AAED,UAAU,uBAAuB;IAC/B,UAAU,EAAE,UAAU,CAAA;IACtB,WAAW,EAAE,WAAW,CAAA;CACzB;AAED,UAAU,qBAAsB,SAAQ,uBAAuB;IAC7D,SAAS,EAAE,GAAG,CAAA;CACf;AAED,iBAAe,kBAAkB,CAC/B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC,uBAAuB,CAAC,CAwClC;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,mBAAmB,EAAE,uBAAuB,GAC3C,OAAO,CAAC,qBAAqB,CAAC,CA2ChC;AAED,iBAAe,iBAAiB,CAC9B,MAAM,EAAE,uBAAuB,EAC/B,iBAAiB,EAAE,qBAAqB,GACvC,OAAO,CAAC,iBAAiB,CAAC,CAiC5B;AA8ED,iBAAe,0BAA0B,CACvC,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,KAAK,GAAG,SAAS,EAC9B,WAAW,EAAE,KAAK,EAClB,KAAK,EAAE,IAAI,EAAE,EACb,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,aAAa,EAAE,YAAY,EAAE,EAC7B,cAAc,EAAE,OAAO,uBAwCxB;AAiBD,iBAAe,UAAU,CACvB,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,KAAK,EAClB,WAAW,EAAE,KAAK,EAClB,cAAc,EAAE,OAAO,EACvB,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,SAAS,0BAiCrB;AAED,iBAAe,YAAY,CACzB,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,KAAK,EAClB,WAAW,EAAE,KAAK,EAClB,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,SAAS,EACpB,gBAAgB,EAAE,GAAG,8BAiCtB;AAwCD,iBAAS,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,0CAK9D;AAED,iBAAe,kBAAkB,CAC/B,WAAW,EAAE,KAAK,EAClB,WAAW,EAAE,KAAK,EAClB,aAAa,EAAE,YAAY,EAAE,EAC7B,cAAc,EAAE,OAAO,EACvB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,gBAAgB,EAAE,MAAM,sBAuBzB;AAED,iBAAe,SAAS,CACtB,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,KAAK,EAClB,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,IAAI,EAAE,EACb,aAAa,EAAE,YAAY,EAAE,EAC7B,cAAc,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CxB;AAED,iBAAe,oBAAoB,CACjC,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,KAAK,GAAG,SAAS,EAC9B,WAAW,EAAE,KAAK,EAClB,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,GAAG,EACpB,MAAM,EAAE,OAAO,8BAkChB;AAED,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACtB,kBAAkB,EAClB,SAAS,EACT,UAAU,EACV,YAAY,EACZ,0BAA0B,EAC1B,oBAAoB,GACrB,CAAA;AACD,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,GACtB,CAAA"}

package/dist/src/execution/utils.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareTransaction = prepareTransaction;
+exports.signTransaction = signTransaction;
+exports.submitTransaction = submitTransaction;
+exports.getOrchestratorByChain = getOrchestratorByChain;
+exports.getUserOpOrderPath = getUserOpOrderPath;
+exports.getUserOp = getUserOp;
+exports.signUserOp = signUserOp;
+exports.submitUserOp = submitUserOp;
+exports.prepareTransactionAsIntent = prepareTransactionAsIntent;
+exports.submitIntentInternal = submitIntentInternal;
+const viem_1 = require("viem");
+const account_abstraction_1 = require("viem/account-abstraction");
+const accounts_1 = require("../accounts");
+const utils_1 = require("../accounts/utils");
+const validators_1 = require("../modules/validators");
+const orchestrator_1 = require("../orchestrator");
+const consts_1 = require("../orchestrator/consts");
+const registry_1 = require("../orchestrator/registry");
+const smart_session_1 = require("./smart-session");
+async function prepareTransaction(config, transaction) {
+    const { sourceChain, targetChain, tokenRequests, withSession } = getTransactionParams(transaction);
+    const accountAddress = (0, accounts_1.getAddress)(config);
+    let bundleData;
+    if (withSession) {
+        if (!sourceChain) {
+            throw new Error(`Specifying source chain is required when using smart sessions`);
+        }
+        // Smart sessions require a UserOp flow
+        bundleData = await prepareTransactionAsUserOp(config, sourceChain, targetChain, transaction.calls, transaction.gasLimit, tokenRequests, accountAddress, withSession);
+    }
+    else {
+        bundleData = await prepareTransactionAsIntent(config, sourceChain, targetChain, transaction.calls, transaction.gasLimit, tokenRequests, accountAddress);
+    }
+    return {
+        bundleData,
+        transaction,
+    };
+}
+async function signTransaction(config, preparedTransaction) {
+    const { sourceChain, targetChain, withSession } = getTransactionParams(preparedTransaction.transaction);
+    const bundleData = preparedTransaction.bundleData;
+    const accountAddress = (0, accounts_1.getAddress)(config);
+    let signature;
+    if (withSession) {
+        if (!sourceChain) {
+            throw new Error(`Specifying source chain is required when using smart sessions`);
+        }
+        const userOp = bundleData.userOp;
+        if (!userOp) {
+            throw new Error(`User operation is required when using smart sessions`);
+        }
+        // Smart sessions require a UserOp flow
+        signature = await signUserOp(config, sourceChain, targetChain, accountAddress, withSession, userOp, bundleData.orderPath);
+    }
+    else {
+        signature = await signIntent(config, sourceChain, targetChain, bundleData.hash);
+    }
+    return {
+        bundleData,
+        transaction: preparedTransaction.transaction,
+        signature,
+    };
+}
+async function submitTransaction(config, signedTransaction) {
+    const { bundleData, transaction, signature } = signedTransaction;
+    const { sourceChain, targetChain, withSession } = getTransactionParams(transaction);
+    if (withSession) {
+        if (!sourceChain) {
+            throw new Error(`Specifying source chain is required when using smart sessions`);
+        }
+        const userOp = bundleData.userOp;
+        if (!userOp) {
+            throw new Error(`User operation is required when using smart sessions`);
+        }
+        // Smart sessions require a UserOp flow
+        return await submitUserOp(config, sourceChain, targetChain, userOp, bundleData.orderPath, signature);
+    }
+    else {
+        return await submitIntent(config, sourceChain, targetChain, bundleData.orderPath, signature);
+    }
+}
+function getTransactionParams(transaction) {
+    const sourceChain = 'chain' in transaction ? transaction.chain : transaction.sourceChain;
+    const targetChain = 'chain' in transaction ? transaction.chain : transaction.targetChain;
+    const initialTokenRequests = transaction.tokenRequests;
+    const withSession = transaction.signers?.type === 'session' ? transaction.signers.session : null;
+    // Across requires passing some value to repay the solvers
+    const tokenRequests = initialTokenRequests.length === 0
+        ? [
+            {
+                address: viem_1.zeroAddress,
+                amount: 1n,
+            },
+        ]
+        : initialTokenRequests;
+    return {
+        sourceChain,
+        targetChain,
+        tokenRequests,
+        withSession,
+    };
+}
+async function prepareTransactionAsUserOp(config, sourceChain, targetChain, calls, gasLimit, tokenRequests, accountAddress, withSession) {
+    if (sourceChain.id === targetChain.id) {
+        throw new Error('Source and target chains cannot be the same when using user operations');
+    }
+    const orderPath = await getUserOpOrderPath(sourceChain, targetChain, tokenRequests, accountAddress, gasLimit, config.rhinestoneApiKey);
+    const userOp = await getUserOp(config, targetChain, withSession, orderPath, calls, tokenRequests, accountAddress);
+    const hash = (0, account_abstraction_1.getUserOperationHash)({
+        userOperation: userOp,
+        entryPointAddress: account_abstraction_1.entryPoint07Address,
+        entryPointVersion: '0.7',
+        chainId: targetChain.id,
+    });
+    return {
+        orderPath,
+        userOp,
+        hash,
+    };
+}
+async function prepareTransactionAsIntent(config, sourceChain, targetChain, calls, gasLimit, tokenRequests, accountAddress) {
+    const accountAccessList = sourceChain
+        ? {
+            chainIds: [sourceChain.id],
+        }
+        : (0, registry_1.getDefaultAccountAccessList)();
+    const metaIntent = {
+        targetChainId: targetChain.id,
+        tokenTransfers: tokenRequests.map((tokenRequest) => ({
+            tokenAddress: tokenRequest.address,
+            amount: tokenRequest.amount,
+        })),
+        targetAccount: accountAddress,
+        targetExecutions: calls.map((call) => ({
+            value: call.value ?? 0n,
+            to: call.to,
+            data: call.data ?? '0x',
+        })),
+        targetGasUnits: gasLimit,
+        accountAccessList,
+    };
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
+    const orderPath = await orchestrator.getOrderPath(metaIntent, accountAddress);
+    orderPath[0].orderBundle.segments[0].witness.execs = [
+        ...orderPath[0].injectedExecutions,
+        ...metaIntent.targetExecutions,
+    ];
+    const orderBundleHash = (0, orchestrator_1.getOrderBundleHash)(orderPath[0].orderBundle);
+    return {
+        orderPath,
+        hash: orderBundleHash,
+    };
+}
+async function signIntent(config, sourceChain, targetChain, bundleHash) {
+    const signature = await (0, accounts_1.sign)(config.owners, sourceChain || targetChain, bundleHash);
+    return signature;
+}
+async function signUserOp(config, sourceChain, targetChain, accountAddress, withSession, userOp, orderPath) {
+    const targetPublicClient = (0, viem_1.createPublicClient)({
+        chain: targetChain,
+        transport: (0, viem_1.http)(),
+    });
+    const targetSessionAccount = await (0, accounts_1.getSmartSessionSmartAccount)(config, targetPublicClient, targetChain, withSession);
+    userOp.signature = await targetSessionAccount.signUserOperation(userOp);
+    const userOpHash = (0, account_abstraction_1.getUserOperationHash)({
+        userOperation: userOp,
+        chainId: targetChain.id,
+        entryPointAddress: account_abstraction_1.entryPoint07Address,
+        entryPointVersion: '0.7',
+    });
+    orderPath[0].orderBundle.segments[0].witness.userOpHash = userOpHash;
+    const { hash, appDomainSeparator, contentsType, structHash } = await (0, smart_session_1.hashErc7739)(sourceChain, orderPath, accountAddress);
+    const signature = await (0, accounts_1.sign)(withSession.owners, targetChain, hash);
+    const sessionSignature = (0, smart_session_1.getSessionSignature)(signature, appDomainSeparator, structHash, contentsType, withSession);
+    return sessionSignature;
+}
+async function submitUserOp(config, sourceChain, targetChain, userOp, orderPath, sessionSignature) {
+    const smartSessionValidator = (0, validators_1.getSmartSessionValidator)(config);
+    if (!smartSessionValidator) {
+        throw new Error('Smart session validator not available');
+    }
+    const packedSig = (0, viem_1.encodePacked)(['address', 'bytes'], [smartSessionValidator.address, sessionSignature]);
+    const signedOrderBundle = {
+        ...orderPath[0].orderBundle,
+        originSignatures: Array(orderPath[0].orderBundle.segments.length).fill(packedSig),
+        targetSignature: packedSig,
+    };
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
+    const bundleResults = await orchestrator.postSignedOrderBundle([
+        {
+            signedOrderBundle,
+            userOp,
+        },
+    ]);
+    return {
+        type: 'bundle',
+        id: bundleResults[0].bundleId,
+        sourceChain: sourceChain.id,
+        targetChain: targetChain.id,
+    };
+}
+async function submitIntent(config, sourceChain, targetChain, orderPath, bundleSignature) {
+    const validatorModule = (0, validators_1.getOwnerValidator)(config);
+    const packedSig = (0, viem_1.encodePacked)(['address', 'bytes'], [validatorModule.address, bundleSignature]);
+    const signedOrderBundle = {
+        ...orderPath[0].orderBundle,
+        originSignatures: Array(orderPath[0].orderBundle.segments.length).fill(packedSig),
+        targetSignature: packedSig,
+    };
+    const initCode = (0, accounts_1.getBundleInitCode)(config);
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
+    const bundleResults = await orchestrator.postSignedOrderBundle([
+        {
+            signedOrderBundle,
+            initCode,
+        },
+    ]);
+    return {
+        type: 'bundle',
+        id: bundleResults[0].bundleId,
+        sourceChain: sourceChain?.id,
+        targetChain: targetChain.id,
+    };
+}
+function getOrchestratorByChain(chainId, apiKey) {
+    const orchestratorUrl = (0, registry_1.isTestnet)(chainId)
+        ? consts_1.DEV_ORCHESTRATOR_URL
+        : consts_1.PROD_ORCHESTRATOR_URL;
+    return (0, orchestrator_1.getOrchestrator)(apiKey, orchestratorUrl);
+}
+async function getUserOpOrderPath(sourceChain, targetChain, tokenRequests, accountAddress, gasLimit, rhinestoneApiKey) {
+    const accountAccessList = sourceChain
+        ? {
+            chainIds: [sourceChain.id],
+        }
+        : (0, registry_1.getDefaultAccountAccessList)();
+    const metaIntent = {
+        targetChainId: targetChain.id,
+        tokenTransfers: tokenRequests.map((tokenRequest) => ({
+            tokenAddress: tokenRequest.address,
+            amount: tokenRequest.amount,
+        })),
+        targetAccount: accountAddress,
+        targetGasUnits: gasLimit,
+        userOp: (0, orchestrator_1.getEmptyUserOp)(),
+        accountAccessList,
+    };
+    const orchestrator = getOrchestratorByChain(targetChain.id, rhinestoneApiKey);
+    const orderPath = await orchestrator.getOrderPath(metaIntent, accountAddress);
+    return orderPath;
+}
+async function getUserOp(config, targetChain, withSession, orderPath, calls, tokenRequests, accountAddress) {
+    const targetPublicClient = (0, viem_1.createPublicClient)({
+        chain: targetChain,
+        transport: (0, viem_1.http)(),
+    });
+    const targetSessionAccount = await (0, accounts_1.getSmartSessionSmartAccount)(config, targetPublicClient, targetChain, withSession);
+    const targetBundlerClient = (0, utils_1.getBundlerClient)(config, targetPublicClient);
+    return await targetBundlerClient.prepareUserOperation({
+        account: targetSessionAccount,
+        calls: [...orderPath[0].injectedExecutions, ...calls],
+        stateOverride: [
+            ...tokenRequests.map((request) => {
+                const rootBalanceSlot = (0, registry_1.getTokenRootBalanceSlot)(targetChain, request.address);
+                const balanceSlot = rootBalanceSlot
+                    ? (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'address' }, { type: 'uint256' }], [accountAddress, rootBalanceSlot]))
+                    : '0x';
+                return {
+                    address: request.address,
+                    stateDiff: [
+                        {
+                            slot: balanceSlot,
+                            value: (0, viem_1.pad)((0, viem_1.toHex)(request.amount)),
+                        },
+                    ],
+                };
+            }),
+        ],
+    });
+}
+async function submitIntentInternal(config, sourceChain, targetChain, orderPath, bundleSignature, deploy) {
+    const validatorModule = (0, validators_1.getOwnerValidator)(config);
+    const packedSig = (0, viem_1.encodePacked)(['address', 'bytes'], [validatorModule.address, bundleSignature]);
+    const signedOrderBundle = {
+        ...orderPath[0].orderBundle,
+        originSignatures: Array(orderPath[0].orderBundle.segments.length).fill(packedSig),
+        targetSignature: packedSig,
+    };
+    if (deploy) {
+        await (0, accounts_1.deployTarget)(targetChain, config, false);
+    }
+    const initCode = (0, accounts_1.getBundleInitCode)(config);
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
+    const bundleResults = await orchestrator.postSignedOrderBundle([
+        {
+            signedOrderBundle,
+            initCode,
+        },
+    ]);
+    return {
+        type: 'bundle',
+        id: bundleResults[0].bundleId,
+        sourceChain: sourceChain?.id,
+        targetChain: targetChain.id,
+    };
+}

package/dist/src/index.d.ts

@@ -1,5 +1,6 @@
 import type { Address, Chain } from 'viem';
 import type { TransactionResult } from './execution';
+import { BundleData, PreparedTransactionData, SignedTransactionData } from './execution/utils';
 import type { BundleStatus, MetaIntent, MultiChainCompact, PostOrderBundleResult, SignedMultiChainCompact } from './orchestrator';
 import type { Call, Execution, RhinestoneAccountConfig, Session, Transaction } from './types';
 /**
@@ -10,8 +11,12 @@ import type { Call, Execution, RhinestoneAccountConfig, Session, Transaction } f
  */
 declare function createRhinestoneAccount(config: RhinestoneAccountConfig): Promise<{
     config: RhinestoneAccountConfig;
+    deploy: (chain: Chain, session?: Session) => Promise<void>;
+    prepareTransaction: (transaction: Transaction) => Promise<PreparedTransactionData>;
+    signTransaction: (preparedTransaction: PreparedTransactionData) => Promise<SignedTransactionData>;
+    submitTransaction: (signedTransaction: SignedTransactionData) => Promise<TransactionResult>;
     sendTransaction: (transaction: Transaction) => Promise<TransactionResult>;
-    waitForExecution: (result: TransactionResult, acceptsPreconfirmations?: boolean) => Promise<import("./orchestrator").BundleResult | {
+    waitForExecution: (result: TransactionResult, acceptsPreconfirmations?: boolean) => Promise<{
         actualGasCost: bigint;
         actualGasUsed: bigint;
         entryPoint: Address;
@@ -23,11 +28,11 @@ declare function createRhinestoneAccount(config: RhinestoneAccountConfig): Promi
         sender: Address;
         success: boolean;
         userOpHash: import("viem").Hash;
-    }>;
+    } | import("./orchestrator").BundleResult>;
     getAddress: () => `0x${string}`;
     getPortfolio: (onTestnets?: boolean) => Promise<import("./orchestrator").UserTokenBalance[]>;
     getMaxSpendableAmount: (chain: Chain, tokenAddress: Address, gasUnits: bigint) => Promise<bigint>;
 }>;
 export { createRhinestoneAccount };
-export type { BundleStatus, Session, Call, Execution, MetaIntent, MultiChainCompact, PostOrderBundleResult, SignedMultiChainCompact, };
+export type { BundleStatus, Session, Call, Execution, MetaIntent, MultiChainCompact, PostOrderBundleResult, SignedMultiChainCompact, BundleData, PreparedTransactionData, SignedTransactionData, TransactionResult, };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAA;AAE1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAOpD,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EACV,IAAI,EACJ,SAAS,EACT,uBAAuB,EACvB,OAAO,EACP,WAAW,EACZ,MAAM,SAAS,CAAA;AAEhB;;;;;GAKG;AACH,iBAAe,uBAAuB,CAAC,MAAM,EAAE,uBAAuB;;mCAM9B,WAAW;+BAWvC,iBAAiB;;;;;;;;;;;;;;;mCA+BlB,KAAK,gBACE,OAAO,YACX,MAAM;GAanB;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA;AAClC,YAAY,EACV,YAAY,EACZ,OAAO,EACP,IAAI,EACJ,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,GACxB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAA;AAK1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAOpD,OAAO,EACL,UAAU,EACV,uBAAuB,EAEvB,qBAAqB,EAGtB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EACV,IAAI,EACJ,SAAS,EACT,uBAAuB,EACvB,OAAO,EACP,WAAW,EACZ,MAAM,SAAS,CAAA;AAEhB;;;;;GAKG;AACH,iBAAe,uBAAuB,CAAC,MAAM,EAAE,uBAAuB;;oBAC7C,KAAK,YAAY,OAAO;sCAIN,WAAW;2CAIN,uBAAuB;2CAIvB,qBAAqB;mCAS7B,WAAW;+BAWvC,iBAAiB;;;;;;;;;;;;;;;mCA+BlB,KAAK,gBACE,OAAO,YACX,MAAM;GAiBnB;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA;AAClC,YAAY,EACV,YAAY,EACZ,OAAO,EACP,IAAI,EACJ,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACvB,UAAU,EACV,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,GAClB,CAAA"}

package/dist/src/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRhinestoneAccount = createRhinestoneAccount;
 const accounts_1 = require("./accounts");
 const execution_1 = require("./execution");
+const utils_1 = require("./execution/utils");
 /**
  * Initialize a Rhinestone account
  * Note: accounts are deployed onchain only when the first transaction is sent.
@@ -10,6 +11,18 @@ const execution_1 = require("./execution");
  * @returns account
  */
 async function createRhinestoneAccount(config) {
+    function deploy(chain, session) {
+        return (0, accounts_1.deploy)(config, chain, session);
+    }
+    function prepareTransaction(transaction) {
+        return (0, utils_1.prepareTransaction)(config, transaction);
+    }
+    function signTransaction(preparedTransaction) {
+        return (0, utils_1.signTransaction)(config, preparedTransaction);
+    }
+    function submitTransaction(signedTransaction) {
+        return (0, utils_1.submitTransaction)(config, signedTransaction);
+    }
     /**
      * Sign and send a transaction
      * @param transaction Transaction to send
@@ -54,6 +67,10 @@ async function createRhinestoneAccount(config) {
     }
     return {
         config,
+        deploy,
+        prepareTransaction,
+        signTransaction,
+        submitTransaction,
         sendTransaction,
         waitForExecution,
         getAddress,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinestone/sdk",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "End-to-end chain abstraction and modularity toolkit",
   "author": {
     "name": "Rhinestone",