@deserialize/multi-vm-wallet 1.4.12 → 1.5.0

package/dist/evm/aa-service/services/account-abstraction.js

@@ -1,19 +1,4 @@
 "use strict";
-/**
- * Account Abstraction Service (Singleton)
- *
- * Centralized service for managing Kernel accounts, bundlers, and transactions.
- * Use this singleton across your application for consistent AA operations.
- *
- * Usage:
- *   const aaService = AccountAbstractionService.getInstance({
- *     bundlerProvider: 'pimlico',
- *     apiKey: env.pimlicoApiKey
- *   });
- *
- *   const account = await aaService.createAccount(sepolia, owner);
- *   const txHash = await aaService.sendTransaction({ account, to, value });
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccountAbstractionService = void 0;
 const viem_1 = require("viem");
@@ -21,17 +6,11 @@ const bundler_1 = require("./bundler");
 const kernel_account_1 = require("../lib/kernel-account");
 const kernel_modules_1 = require("../lib/kernel-modules");
 const session_keys_1 = require("../lib/session-keys");
-// ============================================
-// Singleton Service
-// ============================================
 class AccountAbstractionService {
     static instance = null;
     bundlerManager;
     aaConfig;
     publicClientCache = new Map();
-    /**
-     * Private constructor (singleton pattern)
-     */
     constructor(config) {
         const bundlerConfig = {
             provider: config.bundlerProvider,
@@ -42,9 +21,6 @@ class AccountAbstractionService {
         this.bundlerManager = (0, bundler_1.createBundlerManager)(bundlerConfig);
         this.aaConfig = config.aaConfig;
     }
-    /**
-     * Get singleton instance
-     */
     static getInstance(config) {
         if (!AccountAbstractionService.instance) {
             if (!config) {
@@ -54,23 +30,12 @@ class AccountAbstractionService {
         }
         return AccountAbstractionService.instance;
     }
-    /**
-     * Reset singleton instance (useful for testing or reconfiguration)
-     */
     static reset() {
         AccountAbstractionService.instance = null;
     }
-    // ============================================
-    // Account Management
-    // ============================================
-    /**
-     * Create a Kernel 7702 account
-     */
     async createAccount(options) {
         const { chain, owner, entryPointVersion = '0.7', aaConfig } = options;
-        // Use aaConfig from options or fallback to service-level config
         const config = aaConfig || this.aaConfig;
-        // Create new account
         const account = await (0, kernel_account_1.createKernel7702Account)({
             chain,
             owner,
@@ -79,22 +44,12 @@ class AccountAbstractionService {
         });
         return account;
     }
-    /**
-     * Check if account is already delegated to Kernel
-     */
     async isAccountDelegated(owner, chain) {
         const authorization = await this.createAuthorization({ owner, chain });
         return authorization === undefined;
     }
-    // ============================================
-    // Authorization Management
-    // ============================================
-    /**
-     * Create EIP-7702 authorization (if needed)
-     */
     async createAuthorization(options) {
         const { owner, chain } = options;
-        // Create authorization
         const authorization = await (0, kernel_account_1.createKernelAuthorization)({
             owner,
             chain,
@@ -102,24 +57,6 @@ class AccountAbstractionService {
         });
         return authorization;
     }
-    // ============================================
-    // Transaction Management
-    // ============================================
-    /**
-     * Prepare a call (for batching)
-     *
-     * Returns a Call object that can be included in a batch transaction.
-     * Use this to prepare any transfer or contract interaction for batching.
-     *
-     * @example
-     * // Prepare multiple calls
-     * const calls = [
-     *     aaService.prepareCall({ to: recipient1, value: parseEther('0.1') }),
-     *     aaService.prepareCall({ to: recipient2, value: parseEther('0.2') }),
-     *     aaService.prepareCall({ to: contractAddress, data: encodedData })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     */
     prepareCall(options) {
         return {
             to: options.to,
@@ -127,23 +64,6 @@ class AccountAbstractionService {
             data: options.data ?? '0x'
         };
     }
-    /**
-     * Prepare a contract call (for batching)
-     *
-     * Helper for preparing contract interactions with type-safe encoding.
-     *
-     * @example
-     * import { parseAbi, encodeFunctionData } from 'viem';
-     *
-     * const call = aaService.prepareContractCall({
-     *     to: USDC_ADDRESS,
-     *     data: encodeFunctionData({
-     *         abi: parseAbi(['function transfer(address to, uint256 amount)']),
-     *         functionName: 'transfer',
-     *         args: [recipient, parseUnits('100', 6)]
-     *     })
-     * });
-     */
     prepareContractCall(options) {
         return {
             to: options.to,
@@ -151,29 +71,8 @@ class AccountAbstractionService {
             value: options.value ?? 0n
         };
     }
-    /**
-     * Send a transaction using Kernel account (execute immediately)
-     *
-     * For batching multiple operations, use prepareCall() + sendBatchTransaction() instead.
-     *
-     * @example
-     * // Single transaction
-     * await aaService.sendTransaction({
-     *     account,
-     *     to: recipient,
-     *     value: parseEther('0.1')
-     * });
-     *
-     * // For batching, use prepareCall instead:
-     * const calls = [
-     *     aaService.prepareCall({ to: recipient1, value: parseEther('0.1') }),
-     *     aaService.prepareCall({ to: recipient2, value: parseEther('0.2') })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     */
     async sendTransaction(options) {
         const { account, to, value = 0n, data = '0x', authorization } = options;
-        // If no authorization provided, try to create one
         let auth = authorization;
         if (!auth) {
             auth = await this.createAuthorization({
@@ -181,7 +80,6 @@ class AccountAbstractionService {
                 chain: account.chain
             });
         }
-        // Send transaction
         const userOpHash = await (0, kernel_account_1.sendKernelTransaction)({
             kernelAccount: account,
             bundlerManager: this.bundlerManager,
@@ -192,9 +90,6 @@ class AccountAbstractionService {
         });
         return userOpHash;
     }
-    /**
-     * Wait for transaction receipt
-     */
     async waitForReceipt(options) {
         const { userOpHash, chain } = options;
         return await (0, kernel_account_1.waitForKernelReceipt)({
@@ -203,9 +98,6 @@ class AccountAbstractionService {
             bundlerManager: this.bundlerManager
         });
     }
-    /**
-     * Send transaction and wait for receipt (convenience method)
-     */
     async sendTransactionAndWait(options) {
         const userOpHash = await this.sendTransaction(options);
         const receipt = await this.waitForReceipt({
@@ -214,52 +106,11 @@ class AccountAbstractionService {
         });
         return { userOpHash, receipt };
     }
-    /**
-     * Send batch transaction (RECOMMENDED for smart accounts)
-     *
-     * Sends multiple calls in a single UserOperation, paying gas ONLY ONCE.
-     * This is one of the main advantages of smart accounts over EOAs.
-     *
-     * Use prepare*() methods to create Call objects for batching:
-     * - prepareCall() - for transfers and contract interactions
-     * - prepareInstallModule() - for module installations
-     * - prepareInstallSessionKey() - for session keys
-     * - prepareInstallMultiSigValidator() - for multi-sig
-     * - etc.
-     *
-     * @example
-     * // Send ETH to 3 recipients in one transaction
-     * const calls = [
-     *     aaService.prepareCall({ to: '0xRecipient1', value: parseEther('0.01') }),
-     *     aaService.prepareCall({ to: '0xRecipient2', value: parseEther('0.02') }),
-     *     aaService.prepareCall({ to: '0xRecipient3', value: parseEther('0.03') })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     *
-     * @example
-     * // Mix transfers, contract calls, and module installations
-     * const calls = [
-     *     aaService.prepareCall({ to: recipient, value: parseEther('0.1') }),
-     *     aaService.prepareContractCall({ to: USDC, data: transferData }),
-     *     aaService.prepareInstallSessionKey({ account, sessionKeyAddress, permissions })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     *
-     * @example
-     * // Install multiple modules at once
-     * const calls = [
-     *     aaService.prepareInstallSessionKey({ account, ... }),
-     *     aaService.prepareInstallMultiSigValidator({ account, ... }),
-     *     aaService.prepareInstallModule({ account, moduleType: 'hook', ... })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     */
     async sendBatchTransaction(options) {
         const { account, calls, authorization } = options;
         if (calls.length === 0) {
             throw new Error('Batch transaction must have at least one call');
         }
-        // If no authorization provided, try to create one
         let auth = authorization;
         if (!auth) {
             auth = await this.createAuthorization({
@@ -267,7 +118,6 @@ class AccountAbstractionService {
                 chain: account.chain
             });
         }
-        // Send batch transaction
         const userOpHash = await (0, kernel_account_1.sendBatchTransaction)({
             kernelAccount: account,
             bundlerManager: this.bundlerManager,
@@ -276,11 +126,6 @@ class AccountAbstractionService {
         });
         return userOpHash;
     }
-    /**
-     * Send batch transaction and wait for receipt (convenience method)
-     *
-     * Same as sendBatchTransaction but waits for confirmation.
-     */
     async sendBatchTransactionAndWait(options) {
         const userOpHash = await this.sendBatchTransaction(options);
         const receipt = await this.waitForReceipt({
@@ -289,20 +134,10 @@ class AccountAbstractionService {
         });
         return { userOpHash, receipt };
     }
-    // ============================================
-    // Utility Methods
-    // ============================================
-    /**
-     * Get account balance
-     */
     async getBalance(account) {
         const publicClient = this.getPublicClient(account.chain);
         return await publicClient.getBalance({ address: account.address });
     }
-    /**
-     * Get or create public client for standard RPC calls
-     * (bundler clients don't support standard eth_* methods)
-     */
     getPublicClient(chain) {
         if (!this.publicClientCache.has(chain.id)) {
             const client = (0, viem_1.createPublicClient)({
@@ -313,376 +148,84 @@ class AccountAbstractionService {
         }
         return this.publicClientCache.get(chain.id);
     }
-    /**
-     * Get bundler information
-     */
     getBundlerInfo(chain) {
         return {
             provider: this.bundlerManager.getProvider(),
             url: this.bundlerManager.getBundlerUrl(chain)
         };
     }
-    /**
-     * Get bundler client directly (advanced usage)
-     */
     getBundlerClient(chain) {
         return this.bundlerManager.getClient(chain);
     }
-    /**
-     * Get bundler manager (advanced usage)
-     */
     getBundlerManager(chain) {
         return this.bundlerManager;
     }
-    // ============================================
-    // Module Management (ERC-7579)
-    // ============================================
-    /**
-     * Prepare module installation call (for batching)
-     *
-     * Returns a Call object that can be included in a batch transaction.
-     * This allows you to install multiple modules in a single UserOperation.
-     *
-     * @example
-     * // Batch install multiple modules
-     * const calls = [
-     *     aaService.prepareInstallModule({
-     *         account,
-     *         moduleType: 'validator',
-     *         moduleAddress: SESSION_KEY_VALIDATOR
-     *     }),
-     *     aaService.prepareInstallModule({
-     *         account,
-     *         moduleType: 'hook',
-     *         moduleAddress: SPENDING_LIMIT_HOOK
-     *     })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     */
     prepareInstallModule(options) {
         return (0, kernel_modules_1.prepareInstallModule)(options);
     }
-    /**
-     * Install a module on an account (execute immediately)
-     *
-     * For batching multiple modules, use prepareInstallModule instead.
-     *
-     * @example
-     * // Install a single module
-     * await aaService.installModule({
-     *     account,
-     *     moduleType: 'validator',
-     *     moduleAddress: SESSION_KEY_VALIDATOR_ADDRESS,
-     *     initData: encodedPermissions
-     * });
-     */
     async installModule(options) {
         return (0, kernel_modules_1.installModule)({
             ...options,
             bundlerManager: this.bundlerManager
         });
     }
-    /**
-     * Prepare module uninstallation call (for batching)
-     *
-     * Returns a Call object that can be included in a batch transaction.
-     *
-     * @example
-     * // Batch uninstall multiple modules
-     * const calls = [
-     *     aaService.prepareUninstallModule({ account, moduleType: 'validator', moduleAddress: '0x...' }),
-     *     aaService.prepareUninstallModule({ account, moduleType: 'hook', moduleAddress: '0x...' })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     */
     prepareUninstallModule(options) {
         return (0, kernel_modules_1.prepareUninstallModule)(options);
     }
-    /**
-     * Uninstall a module from an account (execute immediately)
-     *
-     * For batching, use prepareUninstallModule instead.
-     *
-     * @example
-     * await aaService.uninstallModule({
-     *     account,
-     *     moduleType: 'validator',
-     *     moduleAddress: SESSION_KEY_VALIDATOR_ADDRESS
-     * });
-     */
     async uninstallModule(options) {
         return (0, kernel_modules_1.uninstallModule)({
             ...options,
             bundlerManager: this.bundlerManager
         });
     }
-    /**
-     * Check if a module is installed
-     *
-     * @example
-     * const isInstalled = await aaService.isModuleInstalled({
-     *     account,
-     *     moduleType: 'validator',
-     *     moduleAddress: SESSION_KEY_VALIDATOR_ADDRESS
-     * });
-     */
     async isModuleInstalled(options) {
         return (0, kernel_modules_1.isModuleInstalled)({
             ...options,
             bundlerManager: this.bundlerManager
         });
     }
-    /**
-     * Prepare session key installation call (for batching)
-     *
-     * Returns a Call object that can be batched with other operations.
-     *
-     * @example
-     * // Batch install session key with multi-sig
-     * const calls = [
-     *     aaService.prepareInstallSessionKey({ account, sessionKeyAddress, permissions }),
-     *     aaService.prepareInstallMultiSigValidator({ account, owners, threshold: 2 })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     */
     prepareInstallSessionKey(options) {
         return (0, kernel_modules_1.prepareInstallSessionKey)(options);
     }
-    /**
-     * Create and install a session key for automated operations (execute immediately)
-     *
-     * Perfect for use cases like:
-     * - Recurring payments
-     * - Automated savings
-     * - Subscription management
-     * - DCA (Dollar Cost Averaging)
-     *
-     * For batching with other operations, use prepareInstallSessionKey instead.
-     *
-     * @example
-     * // Create session key for monthly savings
-     * const sessionKey = privateKeyToAccount('0x...');
-     *
-     * await aaService.createSessionKey({
-     *     account,
-     *     sessionKeyAddress: sessionKey.address,
-     *     permissions: [{
-     *         target: USDC_ADDRESS,
-     *         functionSelector: '0xa9059cbb', // transfer(address,uint256)
-     *         maxValuePerUse: parseUnits('100', 6), // Max 100 USDC
-     *         validUntil: Date.now() + 30 * 24 * 60 * 60 * 1000, // 30 days
-     *         maxUses: 1 // Once per month
-     *     }]
-     * });
-     */
     async createSessionKey(options) {
         return (0, kernel_modules_1.createSessionKey)({
             ...options,
             bundlerManager: this.bundlerManager
         });
     }
-    /**
-     * Prepare session key revocation call (for batching)
-     *
-     * Returns a Call object that can be batched with other operations.
-     *
-     * @example
-     * // Batch revoke multiple session keys
-     * const calls = [
-     *     aaService.prepareRevokeSessionKey({ account, sessionKeyAddress: key1 }),
-     *     aaService.prepareRevokeSessionKey({ account, sessionKeyAddress: key2 })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     */
     prepareRevokeSessionKey(options) {
         return (0, kernel_modules_1.prepareRevokeSessionKey)(options);
     }
-    /**
-     * Revoke a session key (execute immediately)
-     *
-     * For batching, use prepareRevokeSessionKey instead.
-     *
-     * @example
-     * await aaService.revokeSessionKey({
-     *     account,
-     *     sessionKeyAddress: sessionKey.address
-     * });
-     */
     async revokeSessionKey(options) {
         return (0, kernel_modules_1.revokeSessionKey)(options.account, this.bundlerManager, options.sessionKeyAddress);
     }
-    /**
-     * Prepare multi-sig validator installation call (for batching)
-     *
-     * Returns a Call object that can be batched with other operations.
-     *
-     * @example
-     * // Batch install multi-sig with session key
-     * const calls = [
-     *     aaService.prepareInstallMultiSigValidator({ account, owners, threshold: 2 }),
-     *     aaService.prepareInstallSessionKey({ account, sessionKeyAddress, permissions })
-     * ];
-     * await aaService.sendBatchTransaction({ account, calls });
-     */
     prepareInstallMultiSigValidator(options) {
         return (0, kernel_modules_1.prepareInstallMultiSigValidator)(options);
     }
-    /**
-     * Install a multi-signature validator (execute immediately)
-     *
-     * For batching, use prepareInstallMultiSigValidator instead.
-     *
-     * @example
-     * await aaService.installMultiSigValidator({
-     *     account,
-     *     owners: [owner1, owner2, owner3],
-     *     threshold: 2 // 2 of 3 required
-     * });
-     */
     async installMultiSigValidator(options) {
         return (0, kernel_modules_1.installMultiSigValidator)({
             ...options,
             bundlerManager: this.bundlerManager
         });
     }
-    // ============================================
-    // EIP-7702 Session Keys (NEW Pattern)
-    // ============================================
-    /**
-     * Generate a new session key
-     *
-     * Creates a new keypair for use as a session key with EIP-7702 accounts.
-     * The private key should be stored securely and shared with the agent.
-     * The address should be shared with the owner for approval.
-     *
-     * This uses the NEW EIP-7702 pattern, not the legacy module-based pattern.
-     *
-     * @returns Session key info including private key, address, and signer
-     *
-     * @example
-     * // Agent generates session key
-     * const sessionKey = await aaService.generateSessionKey();
-     * console.log("Share this address with owner:", sessionKey.address);
-     * console.log("Keep this private key secure:", sessionKey.privateKey);
-     * // Store sessionKey.privateKey securely for later use
-     */
     async generateSessionKey() {
         return await (0, session_keys_1.generateSessionKey)();
     }
-    /**
-     * Create session key approval (Owner side)
-     *
-     * The owner calls this to create an approval for a session key address.
-     * This uses the NEW EIP-7702 pattern with addressToEmptyAccount.
-     *
-     * @param options - Configuration options
-     * @returns Serialized approval string to share with the agent
-     *
-     * @example
-     * // Owner approves session key with USDC transfer restrictions
-     * const approval = await aaService.createSessionKeyApproval({
-     *     sessionKeyAddress: '0x...', // Agent's session key address
-     *     owner: ownerAccount,
-     *     chain: sepolia,
-     *     permissions: [
-     *         aaService.createUSDCTransferPermission(USDC_ADDRESS, '10') // Max 10 USDC
-     *     ]
-     * });
-     * // Share approval with agent
-     *
-     * @example
-     * // Owner approves session key with sudo (unrestricted) access
-     * const approval = await aaService.createSessionKeyApproval({
-     *     sessionKeyAddress: agentSessionKey.address,
-     *     owner: ownerAccount,
-     *     chain: sepolia,
-     *     useSudoPolicy: true
-     * });
-     */
     async createSessionKeyApproval(options) {
         return await (0, session_keys_1.createSessionKeyApproval)(options);
     }
-    /**
-     * Deserialize session key account (Agent side)
-     *
-     * The agent calls this to reconstruct the session key account from the approval.
-     * This requires BOTH the approval AND the session key signer.
-     *
-     * @param options - Deserialization options
-     * @returns Deserialized session key account
-     *
-     * @example
-     * // Agent deserializes with private key
-     * const sessionKey = await aaService.recreateSessionKey(storedPrivateKey);
-     * const account = await aaService.deserializeSessionKey({
-     *     approval,
-     *     sessionKeySigner: sessionKey.signer,
-     *     chain: sepolia
-     * });
-     */
     async deserializeSessionKey(options) {
         return await (0, session_keys_1.deserializeSessionKey)(options);
     }
-    /**
-     * Create kernel client for session key
-     *
-     * Creates a client for sending transactions with the session key.
-     *
-     * @param options - Client options
-     * @returns Kernel account client
-     *
-     * @example
-     * // Agent creates client for session key
-     * const sessionKey = await aaService.recreateSessionKey(storedPrivateKey);
-     * const account = await aaService.deserializeSessionKey({
-     *     approval,
-     *     sessionKeySigner: sessionKey.signer,
-     *     chain: sepolia
-     * });
-     * const client = aaService.createSessionKeyClient({
-     *     account,
-     *     chain: sepolia,
-     *     bundlerUrl: 'https://api.pimlico.io/...'
-     * });
-     */
     createSessionKeyClient(options) {
         return (0, session_keys_1.createSessionKeyClient)(options);
     }
-    /**
-     * Create USDC transfer permission rule
-     *
-     * Helper to create a permission rule for USDC transfers with a maximum amount.
-     *
-     * @param usdcAddress - USDC contract address
-     * @param maxAmount - Maximum USDC amount (in USDC units, e.g., "10" for 10 USDC)
-     * @returns Permission rule
-     *
-     * @example
-     * const rule = aaService.createUSDCTransferPermission(
-     *     '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238', // Sepolia USDC
-     *     '10' // Max 10 USDC
-     * );
-     */
     createUSDCTransferPermission(usdcAddress, maxAmount, destinationAddress) {
         return (0, session_keys_1.createUSDCTransferPermission)(usdcAddress, maxAmount, destinationAddress);
     }
-    /**
-     * Create ETH transfer permission rule
-     *
-     * Helper to create a permission rule for ETH transfers with a maximum value.
-     *
-     * @param maxValue - Maximum ETH value (in ether units, e.g., "0.1" for 0.1 ETH)
-     * @returns Permission rule
-     *
-     * @example
-     * const rule = aaService.createETHTransferPermission('0.1'); // Max 0.1 ETH
-     */
     createETHTransferPermission(maxValue) {
         return (0, session_keys_1.createETHTransferPermission)(maxValue);
     }
-    // ============================================
-    // Private Helpers
-    // ============================================
     getAccountCacheKey(chain, owner, entryPointVersion) {
         return `${chain.id}-${owner.address}-${entryPointVersion}`;
     }
@@ -691,8 +234,4 @@ class AccountAbstractionService {
     }
 }
 exports.AccountAbstractionService = AccountAbstractionService;
-// ============================================
-// Convenience Exports
-// ============================================
 exports.default = AccountAbstractionService;
-//# sourceMappingURL=account-abstraction.js.map

package/dist/evm/aa-service/services/bundler.d.ts

@@ -1,9 +1,3 @@
-/**
- * Bundler Manager
- *
- * Manages multiple bundler providers (Pimlico, Etherspot, custom)
- * and provides unified interface for bundler operations.
- */
 import { Chain } from 'viem';
 import { BundlerClient } from 'viem/account-abstraction';
 export type BundlerProvider = 'pimlico' | 'etherspot' | 'custom';