@rhinestone/sdk 0.2.1 → 0.4.0

package/dist/examples/omni-account.js

@@ -0,0 +1,169 @@
+"use strict";
+// import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
+// import {
+//   baseSepolia,
+//   arbitrumSepolia,
+//   optimismSepolia,
+//   arbitrum,
+//   base,
+//   optimism,
+//   sepolia,
+// } from 'viem/chains'
+// import {
+//   Chain,
+//   createPublicClient,
+//   createWalletClient,
+//   encodeFunctionData,
+//   erc20Abi,
+//   Hex,
+//   http,
+//   parseEther,
+//   parseUnits,
+// } from 'viem'
+// import { createRhinestoneAccount } from '../index'
+// 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 sourceChain = baseSepolia
+// const targetChain = arbitrumSepolia
+// const usdcSource = getTokenAddress(sourceChain)
+// const usdcTarget = getTokenAddress(targetChain)
+// const usdcAmount = 1n
+// const fundingAccount = privateKeyToAccount(fundingPrivateKey as Hex)
+// const publicClient = createPublicClient({
+//   chain: sourceChain,
+//   transport: getTransport(sourceChain),
+// })
+// const publicTargetClient = createPublicClient({
+//   chain: targetChain,
+//   transport: getTransport(targetChain),
+// })
+// const fundingClient = createWalletClient({
+//   account: fundingAccount,
+//   chain: sourceChain,
+//   transport: getTransport(sourceChain),
+// })
+// const fundingTargetClient = createWalletClient({
+//   account: fundingAccount,
+//   chain: targetChain,
+//   transport: getTransport(targetChain),
+// })
+// const useNewKeys = true
+// if (!useNewKeys) {
+//   console.log('new pks', [
+//     generatePrivateKey(),
+//     generatePrivateKey(),
+//     generatePrivateKey(),
+//   ])
+// }
+// const privateKeyA = useNewKeys
+//   ? generatePrivateKey()
+//   : '0xe4b8f59fa0999924cf05c7c81fe436de905c43d8c2ba1cb50b8695d6e830cb7a'
+// const accountA = privateKeyToAccount(privateKeyA)
+// const privateKeyB = useNewKeys
+//   ? generatePrivateKey()
+//   : '0x0b6d1278f1dce8419f99c72a0354f10a52dfe5bc65008f72b59c2fdb2731fae5'
+// const accountB = privateKeyToAccount(privateKeyB)
+// const privateKeyC = useNewKeys
+//   ? generatePrivateKey()
+//   : '0xc1a32b6410d65a2faf779dd809c3b91c35436c89f51ff7b5335e57ebf4c50dc5'
+// const accountC = privateKeyToAccount(privateKeyC)
+// const rhinestoneAccount = await createRhinestoneAccount({
+//   account: {
+//     type: 'nexus',
+//   },
+//   owners: {
+//     type: 'ecdsa',
+//     accounts: [accountA, accountB, accountC],
+//     threshold: 2,
+//   },
+//   rhinestoneApiKey,
+//   deployerAccount: fundingAccount,
+// })
+// 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 txHash2 = await fundingTargetClient.sendTransaction({
+//   //   to: usdcTarget,
+//   //   data: encodeFunctionData({
+//   //     abi: erc20Abi,
+//   //     functionName: 'transfer',
+//   //     args: [address, parseUnits('0.2', 6)],
+//   //   }),
+//   // })
+//   // console.log('txHash2', txHash2)
+//   // await publicTargetClient.waitForTransactionReceipt({ hash: txHash2 })
+//   const txHash2 = await fundingClient.sendTransaction({
+//     to: usdcSource,
+//     data: encodeFunctionData({
+//       abi: erc20Abi,
+//       functionName: 'transfer',
+//       args: [address, parseUnits('0.5', 6)],
+//     }),
+//   })
+//   await publicClient.waitForTransactionReceipt({ hash: txHash2 })
+// }
+// const transactionResult = await rhinestoneAccount.sendTransactions({
+//   sourceChain,
+//   targetChain,
+//   calls: [
+//     {
+//       to: usdcTarget,
+//       value: 0n,
+//       data: encodeFunctionData({
+//         abi: erc20Abi,
+//         functionName: 'transfer',
+//         args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', usdcAmount],
+//       }),
+//     },
+//   ],
+//   tokenRequests: [
+//     {
+//       address: usdcTarget,
+//       amount: usdcAmount,
+//     },
+//   ],
+// })
+// console.log('result', transactionResult)
+// const result = await rhinestoneAccount.waitForExecution(transactionResult)
+// console.log('status', result)
+// function getTokenAddress(chain: Chain) {
+//   switch (chain.id) {
+//     case sepolia.id:
+//       return '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238'
+//     case baseSepolia.id:
+//       return '0x036cbd53842c5426634e7929541ec2318f3dcf7e'
+//     case arbitrumSepolia.id:
+//       return '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d'
+//     case optimismSepolia.id:
+//       return '0x5fd84259d66Cd46123540766Be93DFE6D43130D7'
+//     case base.id:
+//       return '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
+//     case arbitrum.id:
+//       return '0xaf88d065e77c8cC2239327C5EDb3A432268e5831'
+//     case optimism.id:
+//       return '0x0b2c639c533813f4aa9d7837caf62653d097ff85'
+//     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/examples/smart-sessions.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=smart-sessions.d.ts.map

package/dist/examples/smart-sessions.d.ts.map

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

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 };