@rhinestone/sdk 0.2.1 → 0.3.0

package/dist/examples/smart-sessions.js

@@ -0,0 +1,216 @@
+"use strict";
+// import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
+// import {
+//   baseSepolia,
+//   arbitrumSepolia,
+//   optimismSepolia,
+//   sepolia,
+// } from 'viem/chains'
+// import {
+//   Chain,
+//   createPublicClient,
+//   createWalletClient,
+//   encodeFunctionData,
+//   getAbiItem,
+//   Hex,
+//   http,
+//   parseEther,
+//   toFunctionSelector,
+// } from 'viem'
+// import { createRhinestoneAccount } from '../index'
+// import { abi as wethAbi } from './abi/weth'
+// import { Session } from '../types'
+// const fundingPrivateKey = process.env.FUNDING_PRIVATE_KEY
+// if (!fundingPrivateKey) {
+//   throw new Error('FUNDING_PRIVATE_KEY is not set')
+// }
+// const rhinestoneApiKey = process.env.RHINESTONE_API_KEY
+// if (!rhinestoneApiKey) {
+//   throw new Error('RHINESTONE_API_KEY is not set')
+// }
+// const pimlicoApiKey = process.env.PIMLICO_API_KEY
+// if (!pimlicoApiKey) {
+//   throw new Error('PIMLICO_API_KEY is not set')
+// }
+// const chain = optimismSepolia
+// // const targetChain = arbitrumSepolia
+// const wethAddress = getWethAddress(chain)
+// const wethAmount = 1n
+// const fundingAccount = privateKeyToAccount(fundingPrivateKey as Hex)
+// console.log('fundingAccount', fundingAccount.address)
+// const publicClient = createPublicClient({
+//   chain,
+//   transport: getTransport(chain),
+// })
+// const fundingClient = createWalletClient({
+//   account: fundingAccount,
+//   chain,
+//   transport: getTransport(chain),
+// })
+// const useNewKeys = true
+// if (!useNewKeys) {
+//   console.log('new pks', [
+//     generatePrivateKey(),
+//     generatePrivateKey(),
+//     generatePrivateKey(),
+//   ])
+// }
+// const privateKeyA = useNewKeys
+//   ? generatePrivateKey()
+//   : '0xe48befb91c9741788c829da2b9ff5b4d64dd77a170c284d7cf10e9acf9e11175'
+// const accountA = privateKeyToAccount(privateKeyA)
+// const privateKeyB = useNewKeys
+//   ? generatePrivateKey()
+//   : '0xe076077b3c53583d0eefcad6b30929cc0dfd58e9a2566cf6a059e327ec62fdbe'
+// const accountB = privateKeyToAccount(privateKeyB)
+// const privateKeyC = useNewKeys
+//   ? generatePrivateKey()
+//   : '0x34afca21087883dba533ecf1d9d705dd2ab8a1933e98db704bb7d9ff83edcaa8'
+// const accountC = privateKeyToAccount(privateKeyC)
+// const session: Session = {
+//   owners: {
+//     type: 'ecdsa',
+//     accounts: [accountA],
+//   },
+//   actions: [
+//     {
+//       target: wethAddress,
+//       selector: toFunctionSelector(
+//         getAbiItem({
+//           abi: wethAbi,
+//           name: 'deposit',
+//         }),
+//       ),
+//     },
+//     {
+//       target: wethAddress,
+//       selector: toFunctionSelector(
+//         getAbiItem({
+//           abi: wethAbi,
+//           name: 'transfer',
+//         }),
+//       ),
+//     },
+//   ],
+// }
+// const session2: Session = {
+//   owners: {
+//     type: 'ecdsa',
+//     accounts: [accountA],
+//   },
+//   actions: [
+//     {
+//       target: wethAddress,
+//       selector: toFunctionSelector(
+//         getAbiItem({
+//           abi: wethAbi,
+//           name: 'deposit',
+//         }),
+//       ),
+//     },
+//     {
+//       target: wethAddress,
+//       selector: toFunctionSelector(
+//         getAbiItem({
+//           abi: wethAbi,
+//           name: 'transfer',
+//         }),
+//       ),
+//       policies: [
+//         {
+//           type: 'universal-action',
+//           rules: [
+//             {
+//               condition: 'equal',
+//               calldataOffset: 0n,
+//               referenceValue: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
+//             },
+//           ],
+//         },
+//       ],
+//     },
+//   ],
+// }
+// const rhinestoneAccount = await createRhinestoneAccount({
+//   account: {
+//     type: 'nexus',
+//   },
+//   owners: {
+//     type: 'ecdsa',
+//     accounts: [accountA, accountB, accountC],
+//     threshold: 2,
+//   },
+//   sessions: [session],
+//   rhinestoneApiKey,
+//   deployerAccount: fundingAccount,
+//   bundler: {
+//     type: 'pimlico',
+//     apiKey: pimlicoApiKey,
+//   },
+// })
+// const address = await rhinestoneAccount.getAddress()
+// console.log(address)
+// // prefund
+// const ethBalance = await publicClient.getBalance({
+//   address,
+// })
+// if (ethBalance < parseEther('0.001')) {
+//   const txHash = await fundingClient.sendTransaction({
+//     to: address,
+//     value: parseEther('0.001'),
+//   })
+//   await publicClient.waitForTransactionReceipt({ hash: txHash })
+// }
+// const transactionResult = await rhinestoneAccount.sendTransactions({
+//   chain,
+//   calls: [
+//     {
+//       to: wethAddress,
+//       value: 10n,
+//       data: encodeFunctionData({
+//         abi: wethAbi,
+//         functionName: 'deposit',
+//       }),
+//     },
+//     {
+//       to: wethAddress,
+//       data: encodeFunctionData({
+//         abi: wethAbi,
+//         functionName: 'transfer',
+//         args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 1n],
+//       }),
+//     },
+//   ],
+//   tokenRequests: [
+//     {
+//       address: wethAddress,
+//       amount: 1n,
+//     },
+//   ],
+//   signers: {
+//     type: 'session',
+//     session: session2,
+//   },
+// })
+// const result = await rhinestoneAccount.waitForExecution(transactionResult)
+// console.log('status', result)
+// function getWethAddress(chain: Chain) {
+//   switch (chain.id) {
+//     case sepolia.id:
+//       return '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14'
+//     case baseSepolia.id:
+//       return '0x4200000000000000000000000000000000000006'
+//     case arbitrumSepolia.id:
+//       return '0x980B62Da83eFf3D4576C647993b0c1D7faf17c73'
+//     case optimismSepolia.id:
+//       return '0x4200000000000000000000000000000000000006'
+//     default:
+//       throw new Error('Unsupported chain')
+//   }
+// }
+// function getTransport(chain: Chain) {
+//   if (chain.id === sepolia.id) {
+//     return http('https://ethereum-sepolia-rpc.publicnode.com')
+//   }
+//   return http()
+// }

package/dist/execution/index.d.ts

@@ -1,6 +1,31 @@
+import { Address, Chain, Hex } from 'viem';
 import { type BundleResult } from '../orchestrator';
 import { RhinestoneAccountConfig, Transaction } from '../types';
-declare function sendTransactions(config: RhinestoneAccountConfig, transaction: Transaction): Promise<bigint>;
-declare function waitForExecution(config: RhinestoneAccountConfig, id: bigint): Promise<BundleResult>;
-export { sendTransactions, waitForExecution };
+type TransactionResult = {
+    type: 'userop';
+    hash: Hex;
+    sourceChain: Chain;
+    targetChain: Chain;
+} | {
+    type: 'bundle';
+    id: bigint;
+    sourceChain: Chain;
+    targetChain: Chain;
+};
+declare function sendTransaction(config: RhinestoneAccountConfig, transaction: Transaction): Promise<TransactionResult>;
+declare function waitForExecution(config: RhinestoneAccountConfig, result: TransactionResult): Promise<BundleResult | {
+    actualGasCost: bigint;
+    actualGasUsed: bigint;
+    entryPoint: Address;
+    logs: import("viem").Log<bigint, number, false>[];
+    nonce: bigint;
+    paymaster?: `0x${string}` | undefined;
+    reason?: string | undefined | undefined;
+    receipt: import("viem").TransactionReceipt<bigint, number, "success" | "reverted">;
+    sender: Address;
+    success: boolean;
+    userOpHash: import("viem").Hash;
+}>;
+export { sendTransaction, waitForExecution };
+export type { TransactionResult };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../execution/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,YAAY,EAQlB,MAAM,iBAAiB,CAAA;AAaxB,OAAO,EAAE,uBAAuB,EAAE,WAAW,EAAY,MAAM,UAAU,CAAA;AAIzE,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,mBA4DzB;AAED,iBAAe,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,EAAE,EAAE,MAAM,yBAe1E;AAkCD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,KAAK,EAKL,GAAG,EAKJ,MAAM,MAAM,CAAA;AAMb,OAAO,EACL,KAAK,YAAY,EASlB,MAAM,iBAAiB,CAAA;AAYxB,OAAO,EACL,uBAAuB,EACvB,WAAW,EAKZ,MAAM,UAAU,CAAA;AAajB,KAAK,iBAAiB,GAClB;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,GAAG,CAAA;IACT,WAAW,EAAE,KAAK,CAAA;IAClB,WAAW,EAAE,KAAK,CAAA;CACnB,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,EAAE,KAAK,CAAA;IAClB,WAAW,EAAE,KAAK,CAAA;CACnB,CAAA;AAEL,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BAuBzB;AA8QD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iBAAiB;;;;;;;;;;;;GAgC1B;AAED,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,CAAA;AAC5C,YAAY,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/execution/index.js

@@ -1,15 +1,151 @@
-import { concat, encodePacked } from 'viem';
-import { BUNDLE_STATUS_PENDING, BUNDLE_STATUS_FAILED, getOrchestrator, getOrderBundleHash, BUNDLE_STATUS_PARTIALLY_COMPLETED, } from '../orchestrator';
-import { getAddress, isDeployed, deploySource, deployTarget, getBundleInitCode, } from '../accounts';
-import { getValidator, getWebauthnValidatorSignature, isRip7212SupportedNetwork, } from '../modules';
+import { createPublicClient, createWalletClient, encodeAbiParameters, encodePacked, http, keccak256, pad, toHex, } from 'viem';
+import { entryPoint07Address, getUserOperationHash, } from 'viem/account-abstraction';
+import { BUNDLE_STATUS_PENDING, BUNDLE_STATUS_FAILED, getOrchestrator, getOrderBundleHash, BUNDLE_STATUS_PARTIALLY_COMPLETED, getEmptyUserOp, } from '../orchestrator';
+import { getAddress, isDeployed, deploySource, deployTarget, getBundleInitCode, sign, getSmartSessionSmartAccount, getDeployArgs, } from '../accounts';
+import { getOwnerValidator } from '../modules';
+import { getBundlerClient } from '../accounts/utils';
+import { getSmartSessionValidator } from '../modules/validators';
+import { getTokenBalanceSlot } from '../orchestrator';
+import { enableSmartSession, getSessionSignature, hashErc7739, } from './smart-session';
 const POLLING_INTERVAL = 500;
-async function sendTransactions(config, transaction) {
-    const { sourceChain, targetChain, calls, tokenRequests } = transaction;
+async function sendTransaction(config, transaction) {
+    if ('chain' in transaction) {
+        // Same-chain transaction
+        return await sendTransactionInternal(config, transaction.chain, transaction.chain, transaction.calls, transaction.tokenRequests, transaction.signers);
+    }
+    else {
+        // Cross-chain transaction
+        return await sendTransactionInternal(config, transaction.sourceChain, transaction.targetChain, transaction.calls, transaction.tokenRequests, transaction.signers);
+    }
+}
+async function sendTransactionInternal(config, sourceChain, targetChain, calls, tokenRequests, signers) {
     const isAccountDeployed = await isDeployed(sourceChain, config);
     if (!isAccountDeployed) {
-        await deploySource(config.deployerAccount, sourceChain, config);
+        await deploySource(sourceChain, config);
+    }
+    const withSession = signers?.type === 'session' ? signers.session : null;
+    if (withSession) {
+        await enableSmartSession(sourceChain, config, withSession);
     }
     const accountAddress = await getAddress(config);
+    if (withSession) {
+        // Smart sessions require a UserOp flow
+        return await sendTransactionAsUserOp(config, sourceChain, targetChain, calls, tokenRequests, accountAddress, withSession);
+    }
+    else {
+        return await sendTransactionAsIntent(config, sourceChain, targetChain, calls, tokenRequests, accountAddress);
+    }
+}
+async function sendTransactionAsUserOp(config, sourceChain, targetChain, calls, tokenRequests, accountAddress, withSession) {
+    const publicClient = createPublicClient({
+        chain: sourceChain,
+        transport: http(),
+    });
+    const sessionAccount = await getSmartSessionSmartAccount(config, publicClient, sourceChain, withSession);
+    const bundlerClient = getBundlerClient(config, publicClient);
+    const targetPublicClient = createPublicClient({
+        chain: targetChain,
+        transport: http(),
+    });
+    const targetSessionAccount = await getSmartSessionSmartAccount(config, targetPublicClient, targetChain, withSession);
+    const targetBundlerClient = getBundlerClient(config, targetPublicClient);
+    if (sourceChain.id === targetChain.id) {
+        await enableSmartSession(targetChain, config, withSession);
+        const hash = await bundlerClient.sendUserOperation({
+            account: sessionAccount,
+            calls,
+        });
+        return {
+            type: 'userop',
+            hash,
+            sourceChain,
+            targetChain,
+        };
+    }
+    const metaIntent = {
+        targetChainId: targetChain.id,
+        tokenTransfers: tokenRequests.map((tokenRequest) => ({
+            tokenAddress: tokenRequest.address,
+            amount: tokenRequest.amount,
+        })),
+        targetAccount: accountAddress,
+        userOp: getEmptyUserOp(),
+    };
+    const orchestrator = getOrchestrator(config.rhinestoneApiKey);
+    const orderPath = await orchestrator.getOrderPath(metaIntent, accountAddress);
+    // Deploy the account on the target chain
+    const { factory, factoryData } = await getDeployArgs(config);
+    const deployerAccount = config.deployerAccount;
+    const targetWalletClient = createWalletClient({
+        chain: targetChain,
+        transport: http(),
+    });
+    const targetDeployTx = await targetWalletClient.sendTransaction({
+        account: deployerAccount,
+        to: factory,
+        data: factoryData,
+    });
+    await targetPublicClient.waitForTransactionReceipt({
+        hash: targetDeployTx,
+    });
+    await enableSmartSession(targetChain, config, withSession);
+    const userOp = await targetBundlerClient.prepareUserOperation({
+        account: targetSessionAccount,
+        calls: [...orderPath[0].injectedExecutions, ...calls],
+        stateOverride: [
+            ...tokenRequests.map((request) => {
+                const rootBalanceSlot = getTokenBalanceSlot(targetChain, request.address);
+                const balanceSlot = rootBalanceSlot
+                    ? keccak256(encodeAbiParameters([{ type: 'address' }, { type: 'uint256' }], [accountAddress, rootBalanceSlot]))
+                    : '0x';
+                return {
+                    address: request.address,
+                    stateDiff: [
+                        {
+                            slot: balanceSlot,
+                            value: pad(toHex(request.amount)),
+                        },
+                    ],
+                };
+            }),
+        ],
+    });
+    userOp.signature = await targetSessionAccount.signUserOperation(userOp);
+    const userOpHash = getUserOperationHash({
+        userOperation: userOp,
+        chainId: targetChain.id,
+        entryPointAddress: entryPoint07Address,
+        entryPointVersion: '0.7',
+    });
+    orderPath[0].orderBundle.segments[0].witness.userOpHash = userOpHash;
+    const { hash, appDomainSeparator, contentsType, structHash, orderBundleHash, } = await hashErc7739(sourceChain, orderPath, accountAddress);
+    const signature = await sign(withSession.owners, targetChain, hash);
+    const sessionSignature = getSessionSignature(signature, appDomainSeparator, structHash, contentsType, withSession);
+    const smartSessionValidator = getSmartSessionValidator(config);
+    if (!smartSessionValidator) {
+        throw new Error('Smart session validator not available');
+    }
+    const packedSig = encodePacked(['address', 'bytes'], [smartSessionValidator.address, sessionSignature]);
+    const signedOrderBundle = {
+        ...orderPath[0].orderBundle,
+        originSignatures: Array(orderPath[0].orderBundle.segments.length).fill(packedSig),
+        targetSignature: packedSig,
+    };
+    await deployTarget(targetChain, config);
+    const bundleResults = await orchestrator.postSignedOrderBundle([
+        {
+            signedOrderBundle,
+            userOp,
+        },
+    ]);
+    return {
+        type: 'bundle',
+        id: bundleResults[0].bundleId,
+        sourceChain,
+        targetChain,
+    };
+}
+async function sendTransactionAsIntent(config, sourceChain, targetChain, calls, tokenRequests, accountAddress) {
     const metaIntent = {
         targetChainId: targetChain.id,
         tokenTransfers: tokenRequests.map((tokenRequest) => ({
@@ -31,7 +167,7 @@ async function sendTransactions(config, transaction) {
     ];
     const orderBundleHash = getOrderBundleHash(orderPath[0].orderBundle);
     const bundleSignature = await sign(config.owners, sourceChain, orderBundleHash);
-    const validatorModule = getValidator(config);
+    const validatorModule = getOwnerValidator(config);
     const packedSig = encodePacked(['address', 'bytes'], [validatorModule.address, bundleSignature]);
     const signedOrderBundle = {
         ...orderPath[0].orderBundle,
@@ -46,47 +182,41 @@ async function sendTransactions(config, transaction) {
             initCode,
         },
     ]);
-    return bundleResults[0].bundleId;
-}
-async function waitForExecution(config, id) {
-    let bundleResult = null;
-    while (bundleResult === null ||
-        bundleResult.status === BUNDLE_STATUS_PENDING ||
-        bundleResult.status === BUNDLE_STATUS_PARTIALLY_COMPLETED) {
-        const orchestrator = getOrchestrator(config.rhinestoneApiKey);
-        bundleResult = await orchestrator.getBundleStatus(id);
-        await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL));
-    }
-    if (bundleResult.status === BUNDLE_STATUS_FAILED) {
-        throw new Error('Bundle failed');
-    }
-    return bundleResult;
+    return {
+        type: 'bundle',
+        id: bundleResults[0].bundleId,
+        sourceChain,
+        targetChain,
+    };
 }
-async function sign(validators, chain, hash) {
-    switch (validators.type) {
-        case 'ecdsa': {
-            const signatures = await Promise.all(validators.accounts.map((account) => signEcdsa(account, hash)));
-            return concat(signatures);
+async function waitForExecution(config, result) {
+    switch (result.type) {
+        case 'bundle': {
+            let bundleResult = null;
+            while (bundleResult === null ||
+                bundleResult.status === BUNDLE_STATUS_PENDING ||
+                bundleResult.status === BUNDLE_STATUS_PARTIALLY_COMPLETED) {
+                const orchestrator = getOrchestrator(config.rhinestoneApiKey);
+                bundleResult = await orchestrator.getBundleStatus(result.id);
+                await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL));
+            }
+            if (bundleResult.status === BUNDLE_STATUS_FAILED) {
+                throw new Error('Bundle failed');
+            }
+            return bundleResult;
         }
-        case 'passkey': {
-            return await signPasskey(validators.account, chain, hash);
+        case 'userop': {
+            const publicClient = createPublicClient({
+                chain: result.sourceChain,
+                transport: http(),
+            });
+            // It's a UserOp hash
+            const bundlerClient = getBundlerClient(config, publicClient);
+            const receipt = await bundlerClient.waitForUserOperationReceipt({
+                hash: result.hash,
+            });
+            return receipt;
         }
     }
 }
-async function signEcdsa(account, hash) {
-    if (!account.signMessage) {
-        throw new Error('Signing not supported for the account');
-    }
-    return await account.signMessage({ message: { raw: hash } });
-}
-async function signPasskey(account, chain, hash) {
-    const { webauthn, signature } = await account.sign({ hash });
-    const usePrecompiled = isRip7212SupportedNetwork(chain);
-    const encodedSignature = getWebauthnValidatorSignature({
-        webauthn,
-        signature,
-        usePrecompiled,
-    });
-    return encodedSignature;
-}
-export { sendTransactions, waitForExecution };
+export { sendTransaction, waitForExecution };

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

@@ -0,0 +1,14 @@
+import { Chain, Hex, Address } from 'viem';
+import { RhinestoneAccountConfig, Session } from '../types';
+import { OrderPath } from '../orchestrator';
+declare function enableSmartSession(chain: Chain, config: RhinestoneAccountConfig, session: Session): Promise<void>;
+declare function hashErc7739(sourceChain: Chain, orderPath: OrderPath, accountAddress: Address): Promise<{
+    hash: `0x${string}`;
+    appDomainSeparator: `0x${string}`;
+    contentsType: string;
+    structHash: `0x${string}`;
+    orderBundleHash: `0x${string}`;
+}>;
+declare function getSessionSignature(signature: Hex, appDomainSeparator: Hex, structHash: Hex, contentsType: string, withSession: Session): `0x${string}`;
+export { enableSmartSession, hashErc7739, getSessionSignature };
+//# sourceMappingURL=smart-session.d.ts.map

package/dist/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,EACL,KAAK,EAIL,GAAG,EAGH,OAAO,EACR,MAAM,MAAM,CAAA;AAWb,OAAO,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAM3C,iBAAe,kBAAkB,CAC/B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,uBAAuB,EAC/B,OAAO,EAAE,OAAO,iBAyBjB;AAED,iBAAe,WAAW,CACxB,WAAW,EAAE,KAAK,EAClB,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,OAAO;;;;;;GAmExB;AAED,iBAAS,mBAAmB,CAC1B,SAAS,EAAE,GAAG,EACd,kBAAkB,EAAE,GAAG,EACvB,UAAU,EAAE,GAAG,EACf,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,OAAO,iBAkBrB;AAED,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/execution/smart-session.js

@@ -0,0 +1,83 @@
+import { http, createPublicClient, encodePacked, keccak256, encodeAbiParameters, } from 'viem';
+import { getSmartAccount, getAddress } from '../accounts';
+import { getBundlerClient } from '../accounts/utils';
+import { getPermissionId, isSessionEnabled, getSessionAllowedERC7739Content, getAccountEIP712Domain, getEnableSessionCall, } from '../modules/validators';
+import { getOrderBundleHash, hashMultichainCompactWithoutDomainSeparator, } from '../orchestrator/utils';
+async function enableSmartSession(chain, config, session) {
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(),
+    });
+    const address = await getAddress(config);
+    const isEnabled = await isSessionEnabled(publicClient, address, getPermissionId(session));
+    if (isEnabled) {
+        return;
+    }
+    const smartAccount = await getSmartAccount(config, publicClient, chain);
+    const bundlerClient = getBundlerClient(config, publicClient);
+    const enableSessionCall = await getEnableSessionCall(chain, session);
+    const opHash = await bundlerClient.sendUserOperation({
+        account: smartAccount,
+        calls: [enableSessionCall],
+    });
+    await bundlerClient.waitForUserOperationReceipt({
+        hash: opHash,
+    });
+}
+async function hashErc7739(sourceChain, orderPath, accountAddress) {
+    const publicClient = createPublicClient({
+        chain: sourceChain,
+        transport: http(),
+    });
+    const { appDomainSeparator, contentsType } = await getSessionAllowedERC7739Content(sourceChain);
+    const orderBundleHash = getOrderBundleHash(orderPath[0].orderBundle);
+    // Create hash following ERC-7739 TypedDataSign workflow
+    const typedDataSignTypehash = keccak256(encodePacked(['string'], [
+        'TypedDataSign(MultichainCompact contents,string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)'.concat(contentsType),
+    ]));
+    // Original struct hash
+    const structHash = hashMultichainCompactWithoutDomainSeparator(orderPath[0].orderBundle);
+    const { name, version, chainId, verifyingContract, salt } = await getAccountEIP712Domain(publicClient, accountAddress);
+    // Final hash according to ERC-7739
+    const hash = keccak256(encodePacked(['bytes2', 'bytes32', 'bytes32'], [
+        '0x1901',
+        appDomainSeparator,
+        keccak256(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,
+            keccak256(encodePacked(['string'], [name])),
+            keccak256(encodePacked(['string'], [version])),
+            BigInt(Number(chainId)),
+            verifyingContract,
+            salt,
+        ])),
+    ]));
+    return {
+        hash,
+        appDomainSeparator,
+        contentsType,
+        structHash,
+        orderBundleHash,
+    };
+}
+function getSessionSignature(signature, appDomainSeparator, structHash, contentsType, withSession) {
+    const erc7739Signature = encodePacked(['bytes', 'bytes32', 'bytes32', 'string', 'uint16'], [
+        signature,
+        appDomainSeparator,
+        structHash,
+        contentsType,
+        contentsType.length,
+    ]);
+    // Pack with permissionId for smart session
+    const wrappedSignature = encodePacked(['bytes32', 'bytes'], [getPermissionId(withSession), erc7739Signature]);
+    return wrappedSignature;
+}
+export { enableSmartSession, hashErc7739, getSessionSignature };

package/dist/index.d.ts

@@ -1,10 +1,21 @@
 import { RhinestoneAccountConfig, Transaction } from './types';
+import { type TransactionResult } from './execution';
 declare function createRhinestoneAccount(config: RhinestoneAccountConfig): Promise<{
     config: RhinestoneAccountConfig;
-    sendTransactions: (transaction: Transaction) => Promise<bigint>;
-    waitForExecution: ({ id }: {
-        id: bigint;
-    }) => Promise<import("./orchestrator").BundleResult>;
+    sendTransactions: (transaction: Transaction) => Promise<TransactionResult>;
+    waitForExecution: (result: TransactionResult) => Promise<import("./orchestrator").BundleResult | {
+        actualGasCost: bigint;
+        actualGasUsed: bigint;
+        entryPoint: import("abitype").Address;
+        logs: import("viem").Log<bigint, number, false>[];
+        nonce: bigint;
+        paymaster?: `0x${string}` | undefined;
+        reason?: string | undefined | undefined;
+        receipt: import("viem").TransactionReceipt<bigint, number, "success" | "reverted">;
+        sender: import("abitype").Address;
+        success: boolean;
+        userOpHash: import("viem").Hash;
+    }>;
     getAddress: () => Promise<`0x${string}`>;
 }>;
 export { createRhinestoneAccount };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAO9D,iBAAe,uBAAuB,CAAC,MAAM,EAAE,uBAAuB;;oCACvB,WAAW;+BAIhB;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE;;GAcvD;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAC9D,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,aAAa,CAAA;AAGpB,iBAAe,uBAAuB,CAAC,MAAM,EAAE,uBAAuB;;oCAC7B,WAAW;+BAIhB,iBAAiB;;;;;;;;;;;;;;GAcpD;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/index.js

@@ -1,15 +1,15 @@
-import { sendTransactions as sendTransactionsInternal, waitForExecution as waitForExecutionInternal, } from './execution';
+import { sendTransaction as sendTransactionInternal, waitForExecution as waitForExecutionInternal, } from './execution';
 import { getAddress as getAddressInternal } from './accounts';
 async function createRhinestoneAccount(config) {
-    const sendTransactions = async (transaction) => {
-        return await sendTransactionsInternal(config, transaction);
-    };
-    const waitForExecution = async ({ id }) => {
-        return await waitForExecutionInternal(config, id);
-    };
-    const getAddress = async () => {
-        return await getAddressInternal(config);
-    };
+    function sendTransactions(transaction) {
+        return sendTransactionInternal(config, transaction);
+    }
+    function waitForExecution(result) {
+        return waitForExecutionInternal(config, result);
+    }
+    function getAddress() {
+        return getAddressInternal(config);
+    }
     return {
         config,
         sendTransactions,