@deserialize/multi-vm-wallet 1.2.441 → 1.3.1

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

@@ -0,0 +1,754 @@
+"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");
+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;
+    accountCache = new Map();
+    authorizationCache = new Map();
+    publicClientCache = new Map();
+    /**
+     * Private constructor (singleton pattern)
+     */
+    constructor(config) {
+        const bundlerConfig = {
+            provider: config.bundlerProvider,
+            apiKey: config.apiKey,
+            customUrl: config.customBundlerUrl
+        };
+        this.bundlerManager = (0, bundler_1.createBundlerManager)(bundlerConfig);
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance(config) {
+        if (!AccountAbstractionService.instance) {
+            if (!config) {
+                throw new Error('AccountAbstractionService must be initialized with config on first call');
+            }
+            AccountAbstractionService.instance = new AccountAbstractionService(config);
+        }
+        return AccountAbstractionService.instance;
+    }
+    /**
+     * Reset singleton instance (useful for testing or reconfiguration)
+     */
+    static reset() {
+        AccountAbstractionService.instance = null;
+    }
+    /**
+     * Update bundler configuration (creates new bundler manager)
+     */
+    updateBundlerConfig(config) {
+        const bundlerConfig = {
+            provider: config.bundlerProvider,
+            apiKey: config.apiKey,
+            customUrl: config.customBundlerUrl
+        };
+        this.bundlerManager = (0, bundler_1.createBundlerManager)(bundlerConfig);
+        this.clearCache();
+    }
+    // ============================================
+    // Account Management
+    // ============================================
+    /**
+     * Create a Kernel 7702 account
+     */
+    async createAccount(options) {
+        const { chain, owner, entryPointVersion = '0.7' } = options;
+        const cacheKey = this.getAccountCacheKey(chain, owner, entryPointVersion);
+        // Return cached account if exists
+        if (this.accountCache.has(cacheKey)) {
+            return this.accountCache.get(cacheKey);
+        }
+        // Create new account
+        const account = await (0, kernel_account_1.createKernel7702Account)({
+            chain,
+            owner,
+            bundlerManager: this.bundlerManager,
+            entryPointVersion
+        });
+        // Cache and return
+        this.accountCache.set(cacheKey, account);
+        return account;
+    }
+    /**
+     * Get cached account (if exists)
+     */
+    getCachedAccount(chain, owner, entryPointVersion = '0.7') {
+        const cacheKey = this.getAccountCacheKey(chain, owner, entryPointVersion);
+        return this.accountCache.get(cacheKey);
+    }
+    /**
+     * 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;
+        const cacheKey = this.getAuthorizationCacheKey(chain, owner);
+        // Return cached authorization if exists
+        if (this.authorizationCache.has(cacheKey)) {
+            return this.authorizationCache.get(cacheKey);
+        }
+        // Create authorization
+        const authorization = await (0, kernel_account_1.createKernelAuthorization)({
+            owner,
+            chain,
+            bundlerManager: this.bundlerManager
+        });
+        // Cache if created (undefined means already delegated)
+        if (authorization) {
+            this.authorizationCache.set(cacheKey, authorization);
+        }
+        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,
+            value: options.value ?? 0n,
+            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,
+            data: options.data,
+            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({
+                owner: account.owner,
+                chain: account.chain
+            });
+        }
+        // Send transaction
+        const userOpHash = await (0, kernel_account_1.sendKernelTransaction)({
+            kernelAccount: account,
+            bundlerManager: this.bundlerManager,
+            authorization: auth,
+            to,
+            value,
+            data
+        });
+        return userOpHash;
+    }
+    /**
+     * Wait for transaction receipt
+     */
+    async waitForReceipt(options) {
+        const { userOpHash, chain } = options;
+        return await (0, kernel_account_1.waitForKernelReceipt)({
+            userOpHash,
+            chain,
+            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({
+            userOpHash,
+            chain: options.account.chain
+        });
+        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({
+                owner: account.owner,
+                chain: account.chain
+            });
+        }
+        // Send batch transaction
+        const userOpHash = await (0, kernel_account_1.sendBatchTransaction)({
+            kernelAccount: account,
+            bundlerManager: this.bundlerManager,
+            authorization: auth,
+            calls
+        });
+        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({
+            userOpHash,
+            chain: options.account.chain
+        });
+        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)({
+                chain,
+                transport: (0, viem_1.http)()
+            });
+            this.publicClientCache.set(chain.id, client);
+        }
+        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;
+    }
+    /**
+     * Clear all caches
+     */
+    clearCache() {
+        this.accountCache.clear();
+        this.authorizationCache.clear();
+        this.publicClientCache.clear();
+        this.bundlerManager.clearCache();
+    }
+    // ============================================
+    // 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)();
+    }
+    /**
+     * Recreate session key from private key
+     *
+     * Recreates a session key signer from a stored private key.
+     *
+     * @param privateKey - The session key private key
+     * @returns Session key info
+     *
+     * @example
+     * // Agent recreates session key from storage
+     * const sessionKey = await aaService.recreateSessionKey(storedPrivateKey);
+     */
+    async recreateSessionKey(privateKey) {
+        return await (0, session_keys_1.recreateSessionKey)(privateKey);
+    }
+    /**
+     * 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) {
+        return (0, session_keys_1.createUSDCTransferPermission)(usdcAddress, maxAmount);
+    }
+    /**
+     * 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}`;
+    }
+    getAuthorizationCacheKey(chain, owner) {
+        return `${chain.id}-${owner.address}`;
+    }
+}
+exports.AccountAbstractionService = AccountAbstractionService;
+// ============================================
+// Convenience Exports
+// ============================================
+exports.default = AccountAbstractionService;
+//# sourceMappingURL=account-abstraction.js.map