@deserialize/multi-vm-wallet 1.4.12 → 1.5.0

package/dist/evm/aa-service/lib/kernel-modules.js

@@ -1,19 +1,4 @@
 "use strict";
-/**
- * Kernel Module Management
- *
- * Handles installation and management of ERC-7579 modules for Kernel v3 accounts:
- * - Validators: Session keys, multi-sig, passkeys
- * - Executors: Additional execution logic
- * - Hooks: Pre/post execution hooks
- * - Fallbacks: Handle unknown function calls
- *
- * ERC-7579 Module Types:
- * 1 = Validator
- * 2 = Executor
- * 3 = Fallback
- * 4 = Hook
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MODULE_TYPE_IDS = void 0;
 exports.prepareInstallModule = prepareInstallModule;
@@ -34,28 +19,11 @@ exports.MODULE_TYPE_IDS = {
     fallback: 3,
     hook: 4
 };
-/**
- * Prepare installModule call (for batching)
- *
- * Returns a Call object that can be batched with other operations.
- * Use this when you want to install multiple modules in one transaction.
- *
- * @example
- * // Batch install multiple modules
- * const calls = [
- *     prepareInstallModule({ account, moduleType: 'validator', moduleAddress: '0x...' }),
- *     prepareInstallModule({ account, moduleType: 'hook', moduleAddress: '0x...' })
- * ];
- * await aaService.sendBatchTransaction({ account, calls });
- */
 function prepareInstallModule(config) {
     const { account, moduleType, moduleAddress, initData = '0x' } = config;
-    // Get the module type ID according to ERC-7579
     const moduleTypeId = exports.MODULE_TYPE_IDS[moduleType];
-    // Encode the installModule call
-    // function installModule(uint256 moduleTypeId, address module, bytes calldata initData)
     const calldata = (0, viem_1.encodePacked)(['bytes4', 'uint256', 'address', 'bytes'], [
-        '0x8f6e1e8e', // installModule selector
+        '0x8f6e1e8e',
         BigInt(moduleTypeId),
         moduleAddress,
         initData
@@ -65,34 +33,16 @@ function prepareInstallModule(config) {
         data: calldata
     };
 }
-/**
- * Install a module on a Kernel account (execute immediately)
- *
- * This uses the ERC-7579 standard installModule function.
- * For batching multiple modules, use prepareInstallModule instead.
- *
- * @example
- * // Install a single module
- * const userOpHash = await installModule({
- *     account,
- *     bundlerManager,
- *     moduleType: 'validator',
- *     moduleAddress: SESSION_KEY_VALIDATOR_ADDRESS,
- *     initData: encodedPermissions
- * });
- */
 async function installModule(config) {
     const { account, bundlerManager, moduleType, moduleAddress, initData = '0x' } = config;
     const bundlerClient = bundlerManager.getClient(account.chain);
     console.log(`Installing ${moduleType} module at ${moduleAddress}...`);
-    // Use prepareInstallModule to get the call
     const call = prepareInstallModule({
         account,
         moduleType,
         moduleAddress,
         initData
     });
-    // Execute immediately
     const userOpHash = await bundlerClient.sendUserOperation({
         account: account.account,
         calls: [call]
@@ -100,26 +50,11 @@ async function installModule(config) {
     console.log(`✅ Module installation submitted: ${userOpHash}`);
     return userOpHash;
 }
-/**
- * Prepare uninstallModule call (for batching)
- *
- * Returns a Call object that can be batched with other operations.
- *
- * @example
- * // Batch uninstall multiple modules
- * const calls = [
- *     prepareUninstallModule({ account, moduleType: 'validator', moduleAddress: '0x...' }),
- *     prepareUninstallModule({ account, moduleType: 'hook', moduleAddress: '0x...' })
- * ];
- * await aaService.sendBatchTransaction({ account, calls });
- */
 function prepareUninstallModule(config) {
     const { account, moduleType, moduleAddress, deInitData = '0x' } = config;
     const moduleTypeId = exports.MODULE_TYPE_IDS[moduleType];
-    // Encode the uninstallModule call
-    // function uninstallModule(uint256 moduleTypeId, address module, bytes calldata deInitData)
     const calldata = (0, viem_1.encodePacked)(['bytes4', 'uint256', 'address', 'bytes'], [
-        '0xbf8a8dc4', // uninstallModule selector
+        '0xbf8a8dc4',
         BigInt(moduleTypeId),
         moduleAddress,
         deInitData
@@ -129,32 +64,16 @@ function prepareUninstallModule(config) {
         data: calldata
     };
 }
-/**
- * Uninstall a module from a Kernel account (execute immediately)
- *
- * For batching multiple uninstalls, use prepareUninstallModule instead.
- *
- * @example
- * // Uninstall a single module
- * const userOpHash = await uninstallModule({
- *     account,
- *     bundlerManager,
- *     moduleType: 'validator',
- *     moduleAddress: SESSION_KEY_VALIDATOR_ADDRESS
- * });
- */
 async function uninstallModule(config) {
     const { account, bundlerManager, moduleType, moduleAddress, deInitData = '0x' } = config;
     const bundlerClient = bundlerManager.getClient(account.chain);
     console.log(`Uninstalling ${moduleType} module at ${moduleAddress}...`);
-    // Use prepareUninstallModule to get the call
     const call = prepareUninstallModule({
         account,
         moduleType,
         moduleAddress,
         deInitData
     });
-    // Execute immediately
     const userOpHash = await bundlerClient.sendUserOperation({
         account: account.account,
         calls: [call]
@@ -162,23 +81,11 @@ async function uninstallModule(config) {
     console.log(`✅ Module uninstallation submitted: ${userOpHash}`);
     return userOpHash;
 }
-/**
- * Check if a module is installed on an account
- *
- * @example
- * const isInstalled = await isModuleInstalled({
- *     account,
- *     bundlerManager,
- *     moduleType: 'validator',
- *     moduleAddress: SESSION_KEY_VALIDATOR_ADDRESS
- * });
- */
 async function isModuleInstalled(config) {
     const { account, bundlerManager, moduleType, moduleAddress } = config;
     const publicClient = bundlerManager.getClient(account.chain);
     const moduleTypeId = exports.MODULE_TYPE_IDS[moduleType];
     try {
-        // Call isModuleInstalled(uint256 moduleTypeId, address module)
         const result = await publicClient.readContract({
             address: account.address,
             abi: (0, viem_1.parseAbi)([
@@ -194,29 +101,10 @@ async function isModuleInstalled(config) {
         return false;
     }
 }
-// ============================================
-// Session Key Helpers
-// ============================================
-/**
- * Prepare session key installation call (for batching)
- *
- * Returns a Call object that can be batched with other operations.
- *
- * @example
- * // Batch install session key with other modules
- * const calls = [
- *     prepareInstallSessionKey({ account, sessionKeyAddress, permissions }),
- *     prepareInstallModule({ account, moduleType: 'hook', moduleAddress: '0x...' })
- * ];
- * await aaService.sendBatchTransaction({ account, calls });
- */
 function prepareInstallSessionKey(config) {
     const { account, sessionKeyAddress, permissions } = config;
-    // Encode session key permissions
     const initData = encodeSessionKeyPermissions(sessionKeyAddress, permissions);
-    // Get session key validator address for your chain
     const SESSION_KEY_VALIDATOR = getSessionKeyValidatorAddress(account.chain.id);
-    // Return the install module call
     return prepareInstallModule({
         account,
         moduleType: 'validator',
@@ -224,38 +112,10 @@ function prepareInstallSessionKey(config) {
         initData
     });
 }
-/**
- * Create and install a session key validator (execute immediately)
- *
- * Session keys allow delegated access with specific permissions.
- * Perfect for automated operations like recurring payments.
- *
- * For batching with other operations, use prepareInstallSessionKey instead.
- *
- * @example
- * // Install session key for monthly savings automation
- * const sessionKey = privateKeyToAccount('0x...');
- *
- * await createSessionKey({
- *     account,
- *     bundlerManager,
- *     sessionKeyAddress: sessionKey.address,
- *     permissions: [{
- *         target: USDC_ADDRESS,
- *         functionSelector: '0xa9059cbb', // transfer(address,uint256)
- *         maxValuePerUse: parseUnits('100', 6), // Max 100 USDC per tx
- *         validUntil: Date.now() + 30 * 24 * 60 * 60 * 1000, // 30 days
- *         maxUses: 1 // Once per month
- *     }]
- * });
- */
 async function createSessionKey(config) {
     const { account, bundlerManager, sessionKeyAddress, permissions } = config;
-    // Encode session key permissions
     const initData = encodeSessionKeyPermissions(sessionKeyAddress, permissions);
-    // Get session key validator address for your chain
     const SESSION_KEY_VALIDATOR = getSessionKeyValidatorAddress(account.chain.id);
-    // Install the session key validator with permissions
     return installModule({
         account,
         bundlerManager,
@@ -264,19 +124,6 @@ async function createSessionKey(config) {
         initData
     });
 }
-/**
- * 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 = [
- *     prepareRevokeSessionKey({ account, sessionKeyAddress: key1 }),
- *     prepareRevokeSessionKey({ account, sessionKeyAddress: key2 })
- * ];
- * await aaService.sendBatchTransaction({ account, calls });
- */
 function prepareRevokeSessionKey(config) {
     const { account, sessionKeyAddress } = config;
     const SESSION_KEY_VALIDATOR = getSessionKeyValidatorAddress(account.chain.id);
@@ -288,11 +135,6 @@ function prepareRevokeSessionKey(config) {
         deInitData
     });
 }
-/**
- * Revoke a session key (execute immediately)
- *
- * For batching with other operations, use prepareRevokeSessionKey instead.
- */
 async function revokeSessionKey(account, bundlerManager, sessionKeyAddress) {
     const SESSION_KEY_VALIDATOR = getSessionKeyValidatorAddress(account.chain.id);
     const deInitData = (0, viem_1.encodePacked)(['address'], [sessionKeyAddress]);
@@ -304,12 +146,7 @@ async function revokeSessionKey(account, bundlerManager, sessionKeyAddress) {
         deInitData
     });
 }
-// ============================================
-// Helper Functions
-// ============================================
 function encodeSessionKeyPermissions(sessionKeyAddress, permissions) {
-    // This encoding depends on your session key validator implementation
-    // Example encoding for a simple permission structure:
     const encodedPermissions = permissions.map(p => {
         return (0, viem_1.encodePacked)(['address', 'uint256', 'bytes4', 'uint256', 'uint48', 'uint48', 'uint48'], [
             p.target,
@@ -321,7 +158,6 @@ function encodeSessionKeyPermissions(sessionKeyAddress, permissions) {
             BigInt(p.maxUses ?? 0)
         ]);
     });
-    // Combine session key address with permissions
     return (0, viem_1.encodePacked)(['address', 'uint256', 'bytes[]'], [
         sessionKeyAddress,
         BigInt(permissions.length),
@@ -329,12 +165,9 @@ function encodeSessionKeyPermissions(sessionKeyAddress, permissions) {
     ]);
 }
 function getSessionKeyValidatorAddress(chainId) {
-    // Known session key validator addresses per chain
-    // These would be pre-deployed or use a universal address
     const addresses = {
-        1: '0x0000000000000000000000000000000000000000', // Mainnet
-        11155111: '0x0000000000000000000000000000000000000000', // Sepolia
-        // Add more chains as needed
+        1: '0x0000000000000000000000000000000000000000',
+        11155111: '0x0000000000000000000000000000000000000000',
     };
     const address = addresses[chainId];
     if (!address) {
@@ -342,22 +175,6 @@ function getSessionKeyValidatorAddress(chainId) {
     }
     return address;
 }
-// ============================================
-// Multi-Signature Module Helpers
-// ============================================
-/**
- * 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 = [
- *     prepareInstallMultiSigValidator({ account, owners, threshold: 2 }),
- *     prepareInstallSessionKey({ account, sessionKeyAddress, permissions })
- * ];
- * await aaService.sendBatchTransaction({ account, calls });
- */
 function prepareInstallMultiSigValidator(config) {
     const { account, owners, threshold } = config;
     const initData = (0, viem_1.encodePacked)(['address[]', 'uint256'], [owners, BigInt(threshold)]);
@@ -369,19 +186,6 @@ function prepareInstallMultiSigValidator(config) {
         initData
     });
 }
-/**
- * Install a multi-signature validator (execute immediately)
- *
- * For batching with other operations, use prepareInstallMultiSigValidator instead.
- *
- * @example
- * await installMultiSigValidator({
- *     account,
- *     bundlerManager,
- *     owners: [owner1, owner2, owner3],
- *     threshold: 2 // 2 of 3 signatures required
- * });
- */
 async function installMultiSigValidator(config) {
     const { account, bundlerManager, owners, threshold } = config;
     const initData = (0, viem_1.encodePacked)(['address[]', 'uint256'], [owners, BigInt(threshold)]);
@@ -395,7 +199,6 @@ async function installMultiSigValidator(config) {
     });
 }
 function getMultiSigValidatorAddress(chainId) {
-    // Known multi-sig validator addresses per chain
     const addresses = {
         1: '0x0000000000000000000000000000000000000000',
         11155111: '0x0000000000000000000000000000000000000000',
@@ -406,4 +209,3 @@ function getMultiSigValidatorAddress(chainId) {
     }
     return address;
 }
-//# sourceMappingURL=kernel-modules.js.map

package/dist/evm/aa-service/lib/session-keys.d.ts

@@ -1,15 +1,3 @@
-/**
- * EIP-7702 Session Keys Utilities
- *
- * Utilities for creating and managing session keys with ZeroDev's permission system.
- * This uses the NEW EIP-7702 pattern, not the legacy smart account pattern.
- *
- * Key differences from legacy pattern:
- * - Uses `eip7702Account` instead of `address`
- * - Uses `addressToEmptyAccount` for permission validator creation
- * - Passes `sessionKeySigner` to `deserializePermissionAccount`
- * - No sudo validator needed, only permission plugin
- */
 import { Hex, Address } from 'viem';
 import { Chain } from 'viem/chains';
 import { PrivateKeyAccount } from 'viem/accounts';
@@ -39,94 +27,14 @@ export interface DeserializedSessionKey {
     account: any;
     client: any;
 }
-/**
- * Generate a new session key
- *
- * Creates a new keypair for use as a session key or use the one that was passed if available.
- * The private key should be stored securely and shared with the agent.
- * The address should be shared with the owner for approval.
- *
- * @returns Session key info including private key, address, and signer
- *
- * @example
- * const sessionKey = await generateSessionKey(); or
- * const privateKey = '0x...'; // Existing private key
- * const sessionKey = await generateSessionKey(privateKey);
- *
- * console.log("Share this address with owner:", sessionKey.address);
- * console.log("Keep this private key secure:", sessionKey.privateKey);
- */
 export declare function generateSessionKey(privateKey?: Hex): Promise<SessionKeyInfo>;
-/**
- * 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
- * const approval = await createSessionKeyApproval({
- *     sessionKeyAddress: '0x...', // Agent's session key address
- *     owner: ownerAccount,
- *     chain: sepolia,
- *     permissions: [{
- *         target: USDC_ADDRESS,
- *         abi: parseAbi(['function transfer(address to, uint256 amount)']),
- *         functionName: 'transfer',
- *         args: [null, { condition: 3, value: parseUnits('10', 6) }]
- *     }]
- * });
- * // Share approval with agent
- */
 export declare function createSessionKeyApproval(options: CreateSessionKeyApprovalOptions): Promise<string>;
-/**
- * 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 approval - Approval string from owner
- * @param sessionKeySigner - Session key signer (created from private key)
- * @param chain - Chain to use
- * @param entryPointVersion - EntryPoint version
- * @returns Deserialized session key account
- *
- * @example
- * // Agent deserializes with private key
- * const sessionKey = await recreateSessionKey(storedPrivateKey);
- * const account = await deserializeSessionKey({
- *     approval,
- *     sessionKeySigner: sessionKey.signer,
- *     chain: sepolia
- * });
- */
 export declare function deserializeSessionKey(options: {
     approval: string;
     sessionKeySigner: ModularSigner;
     chain: Chain;
     entryPointVersion?: '0.6' | '0.7';
 }): Promise<CreateKernelAccountReturnType<"0.6" | "0.7">>;
-/**
- * Create kernel client for session key
- *
- * Creates a client for sending transactions with the session key.
- *
- * @param account - Deserialized session key account
- * @param chain - Chain to use
- * @param bundlerUrl - Bundler RPC URL
- * @param paymasterUrl - Optional paymaster URL for gas sponsorship
- * @returns Kernel account client
- *
- * @example
- * const client = createSessionKeyClient({
- *     account: sessionKeyAccount,
- *     chain: sepolia,
- *     bundlerUrl: 'https://api.pimlico.io/...'
- * });
- */
 export declare function createSessionKeyClient(options: {
     account: any;
     chain: Chain;
@@ -137,31 +45,5 @@ export declare function createSessionKeyClient(options: {
         version: '0.6' | '0.7';
     };
 }): any;
-/**
- * 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 = createUSDCTransferPermission(
- *     '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238',
- *     '10' // Max 10 USDC
- * );
- */
 export declare function createUSDCTransferPermission(usdcAddress: Hex, maxAmount: string, destinationAddress: Hex): SessionKeyPermissionRule;
-/**
- * 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 = createETHTransferPermission('0.1'); // Max 0.1 ETH
- */
 export declare function createETHTransferPermission(maxValue: string): SessionKeyPermissionRule;