@deserialize/multi-vm-wallet 1.3.2 → 1.3.3

package/utils/constant.ts

@@ -32,7 +32,7 @@ export const DefaultChains: ChainWalletConfig[] = [{
 }, {
     chainId: 123456789,
     name: "Solana",
-    rpcUrl: "https://solana-mainnet.g.alchemy.com/v2/lhoyb3hc9ccT9NA_y2cfA",
+    rpcUrl: "https://solana-mainnet.g.alchemy.com/v2/TFdA4BilCnKIwaqtypk0d",
     explorerUrl: "https://explorer.solana.com",
     nativeToken: {
         name: "Solana",
@@ -46,7 +46,7 @@ export const DefaultChains: ChainWalletConfig[] = [{
     , {
     chainId: 1,
     name: "Ethereum",
-    rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/BJ3c0bm5npmsKZ6oAdHPU",
+    rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/TFdA4BilCnKIwaqtypk0d",
     explorerUrl: "https://etherscan.io",
     nativeToken: {
         name: "Ether",
@@ -69,25 +69,27 @@ export const DefaultChains: ChainWalletConfig[] = [{
     testnet: false,
     logoUrl: "https://bscscan.com/assets/bsc/images/svg/logos/token-light.svg?v=25.10.5.0",
     vmType: "EVM"
-}, {
-    chainId: 123456791,
-    name: "Eclipse",
-    rpcUrl: "https://mainnetbeta-rpc.eclipse.xyz",
-    explorerUrl: "https://explorer.eclipse.xyz/",
-    nativeToken: {
-        name: "Eclipse",
-        symbol: "ETH",
-        decimals: 9,
-    },
-    testnet: false,
-    logoUrl: "https://raw.githubusercontent.com/hyperlane-xyz/hyperlane-registry/a86c3b432b6f9ad7272ae09859f20eb3ade3bd6e/deployments/warp_routes/ES/logo.svg",
-    vmType: "SVM"
 },
 
+// {
+//     chainId: 123456791,
+//     name: "Eclipse",
+//     rpcUrl: "https://mainnetbeta-rpc.eclipse.xyz",
+//     explorerUrl: "https://explorer.eclipse.xyz/",
+//     nativeToken: {
+//         name: "Eclipse",
+//         symbol: "ETH",
+//         decimals: 9,
+//     },
+//     testnet: false,
+//     logoUrl: "https://raw.githubusercontent.com/hyperlane-xyz/hyperlane-registry/a86c3b432b6f9ad7272ae09859f20eb3ade3bd6e/deployments/warp_routes/ES/logo.svg",
+//     vmType: "SVM"
+// },
+
 {
     chainId: base.id,
     name: base.name,
-    rpcUrl: base.rpcUrls.default.http[0],
+    rpcUrl: "https://base-mainnet.g.alchemy.com/v2/TFdA4BilCnKIwaqtypk0d",
     explorerUrl: base.blockExplorers?.default.url || "",
     nativeToken: {
         name: base.nativeCurrency.name,
@@ -97,6 +99,51 @@ export const DefaultChains: ChainWalletConfig[] = [{
     testnet: base.testnet,
     logoUrl: "https://avatars.githubusercontent.com/u/108554348?s=200&v=4",
     vmType: "EVM"
+},
+
+{
+    chainId: 42161,
+    name: "Arbitrum One",
+    rpcUrl: "https://arbitrum-mainnet.g.alchemy.com/v2/TFdA4BilCnKIwaqtypk0d",
+    explorerUrl: "https://arbiscan.io",
+    nativeToken: {
+        name: "Ether",
+        symbol: "ETH",
+        decimals: 18,
+    },
+    testnet: false,
+    logoUrl: "https://arbiscan.io/images/svg/brands/arbitrum-light.svg?v=0.0.36",
+    vmType: "EVM"
+},
+{
+    chainId: 10,
+    name: "Optimism",
+    rpcUrl: "https://optimism-mainnet.g.alchemy.com/v2/TFdA4BilCnKIwaqtypk0d",
+    explorerUrl: "https://optimistic.etherscan.io",
+    nativeToken: {
+        name: "Ether",
+        symbol: "ETH",
+        decimals: 18,
+    },
+    testnet: false,
+    logoUrl: "https://optimism.io/images/optimism-logo-light.svg",
+    vmType: "EVM"
+},
+
+//add for polygon
+{
+    chainId: 137,
+    name: "Polygon",
+    rpcUrl: "https://polygon-mainnet.g.alchemy.com/v2/TFdA4BilCnKIwaqtypk0d",
+    explorerUrl: "https://polygonscan.com",
+    nativeToken: {
+        name: "MATIC",
+        symbol: "MATIC",
+        decimals: 18,
+    },
+    testnet: false,
+    logoUrl: "https://polygonscan.com/images/svg/brands/polygon-light.svg?v=0.0.36",
+    vmType: "EVM"
 }
 
 

package/utils/evm/aa-service/index.ts

@@ -63,7 +63,6 @@ export type {
 // EIP-7702 Session Keys (NEW Pattern)
 export {
     generateSessionKey,
-    recreateSessionKey,
     createSessionKeyApproval,
     deserializeSessionKey,
     createSessionKeyClient,

package/utils/evm/aa-service/lib/kernel-account.ts

@@ -45,7 +45,6 @@ export async function createKernel7702Account(
     const {
         chain,
         owner,
-        bundlerManager,
         entryPointVersion = '0.7',
         kernelVersion = '0.3.3',
         aaConfig
@@ -113,22 +112,37 @@ export async function createKernelAuthorization(
     config: {
         owner: PrivateKeyAccount;
         chain: Chain;
-        bundlerManager: BundlerManager;
         kernelVersion?: KernelVersion;
+        aaConfig?: import('./type').AA_SupportConfig;
     }
 ): Promise<SignAuthorizationReturnType | undefined> {
-    const { owner, chain, bundlerManager, kernelVersion = '0.3.3' } = config;
-
-    const bundlerClient = bundlerManager.getClient(chain);
+    const { owner, chain, kernelVersion = '0.3.3', aaConfig } = config;
 
     // Create public client for eth_getCode (bundler clients don't support it)
     const publicClient = createPublicClient({
         chain,
-        transport: http()
+        transport: http(chain.rpcUrls.default.http[0])
     });
 
-    // Get Kernel implementation address
-    const delegateAddress = KernelVersionToAddressesMap[KERNEL_V3_3].accountImplementationAddress;
+    // Get Kernel implementation address from aaConfig or fallback to default
+    let delegateAddress: Hex;
+
+    if (aaConfig && aaConfig.kernelImplementations.length > 0) {
+        // Try to find matching kernel version (currently only 0.3.3 / version 3 is supported)
+        const versionNumber = 3; // kernel version 0.3.3 maps to version 3
+        const kernelImpl = aaConfig.kernelImplementations.find(impl => impl.version === versionNumber);
+
+        if (kernelImpl) {
+            delegateAddress = kernelImpl.address as Hex;
+        } else {
+            // Fallback to first implementation if version not found
+            console.warn(`Kernel version ${kernelVersion} (v${versionNumber}) not found in aaConfig, using first available`);
+            delegateAddress = aaConfig.kernelImplementations[0].address as Hex;
+        }
+    } else {
+        // Fallback to hardcoded map if no config
+        delegateAddress = KernelVersionToAddressesMap[KERNEL_V3_3].accountImplementationAddress;
+    }
 
     // Check if already delegated
     const code = await publicClient.getCode({ address: owner.address });
@@ -194,6 +208,7 @@ export async function sendBatchTransaction(config: BatchTransactionConfig): Prom
 
     const bundlerClient = bundlerManager.getClient(kernelAccount.chain);
 
+
     // Normalize calls to ensure value and data are set
     const normalizedCalls = calls.map(call => ({
         to: call.to,

package/utils/evm/aa-service/lib/session-keys.ts

@@ -14,17 +14,20 @@
 import { Hex, Address, createPublicClient, http, parseAbi, parseUnits, parseEther } from 'viem';
 import { Chain } from 'viem/chains';
 import { PrivateKeyAccount, privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
+import { entryPoint07Address } from 'viem/account-abstraction';
 import {
     createKernelAccount,
     createKernelAccountClient,
     addressToEmptyAccount,
+    CreateKernelAccountReturnType,
     // serializePermissionAccount,
     // deserializePermissionAccount
 } from '@zerodev/sdk';
 import { toECDSASigner } from '@zerodev/permissions/signers';
-import { toPermissionValidator, ModularSigner } from '@zerodev/permissions';
-import { toSudoPolicy, toCallPolicy, CallPolicyVersion } from '@zerodev/permissions/policies';
+import { toPermissionValidator, ModularSigner, serializePermissionAccount, deserializePermissionAccount } from '@zerodev/permissions';
+import { toSudoPolicy, toCallPolicy, CallPolicyVersion, ParamCondition } from '@zerodev/permissions/policies';
 import { getEntryPoint, KERNEL_V3_3 } from '@zerodev/sdk/constants';
+import { createPimlicoClient } from 'permissionless/clients/pimlico';
 
 // ============================================
 // Types
@@ -39,6 +42,7 @@ export interface SessionKeyPermissionRule {
 
 export interface CreateSessionKeyApprovalOptions {
     sessionKeyAddress: Address;
+    sessionKeyPrivateKey: Hex;
     owner: PrivateKeyAccount;
     chain: Chain;
     entryPointVersion?: '0.6' | '0.7';
@@ -64,19 +68,22 @@ export interface DeserializedSessionKey {
 /**
  * Generate a new session key
  *
- * Creates a new keypair for use as a 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();
+ * 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 async function generateSessionKey(): Promise<SessionKeyInfo> {
-    const sessionPrivateKey = generatePrivateKey();
+export async function generateSessionKey(privateKey?: Hex): Promise<SessionKeyInfo> {
+    const sessionPrivateKey = privateKey || generatePrivateKey();
     const sessionKeyAccount = privateKeyToAccount(sessionPrivateKey);
     const sessionKeySigner = await toECDSASigner({
         signer: sessionKeyAccount as any,
@@ -89,29 +96,7 @@ export async function generateSessionKey(): Promise<SessionKeyInfo> {
     };
 }
 
-/**
- * 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
- * const sessionKey = await recreateSessionKey(storedPrivateKey);
- */
-export async function recreateSessionKey(privateKey: Hex): Promise<SessionKeyInfo> {
-    const sessionKeyAccount = privateKeyToAccount(privateKey);
-    const sessionKeySigner = await toECDSASigner({
-        signer: sessionKeyAccount as any,
-    });
 
-    return {
-        privateKey,
-        address: sessionKeyAccount.address,
-        signer: sessionKeySigner
-    };
-}
 
 // ============================================
 // Owner Side: Create Approval
@@ -146,6 +131,7 @@ export async function createSessionKeyApproval(
 ): Promise<string> {
     const {
         sessionKeyAddress,
+        sessionKeyPrivateKey,
         owner,
         chain,
         entryPointVersion = '0.7',
@@ -160,11 +146,10 @@ export async function createSessionKeyApproval(
 
     const entryPoint = getEntryPoint(entryPointVersion);
 
-    // Create "empty account" from just the session key address
-    // This is the KEY difference from legacy pattern!
-    const emptyAccount = addressToEmptyAccount(sessionKeyAddress);
-    const emptySessionKeySigner = await toECDSASigner({
-        signer: emptyAccount
+    // Create session key signer from private key (NOT addressToEmptyAccount!)
+    const sessionKeyAccount = privateKeyToAccount(sessionKeyPrivateKey);
+    const sessionKeySigner = await toECDSASigner({
+        signer: sessionKeyAccount
     });
 
     // Create permission plugin
@@ -192,26 +177,27 @@ export async function createSessionKeyApproval(
 
     const permissionPlugin = await toPermissionValidator(publicClient as any, {
         entryPoint,
-        signer: emptySessionKeySigner,
+        signer: sessionKeySigner,
         policies,
         kernelVersion: KERNEL_V3_3,
     });
 
-    // Create kernel account with eip7702Account (NOT address!)
-    const sessionKeyAccount = await createKernelAccount(publicClient as any, {
+    // Create kernel account with eip7702Account AND address
+    const kernelSessionKeyAccount = await createKernelAccount(publicClient as any, {
         entryPoint,
-        eip7702Account: owner as any,  // ← EIP-7702 pattern
+        eip7702Account: owner as any,
         plugins: {
             regular: permissionPlugin,
         },
         kernelVersion: KERNEL_V3_3,
-        // NO address parameter!
+        address: owner.address as Hex, // Include owner's address
     });
 
-    // Serialize approval (no private key in approval)
-    // TODO: serializePermissionAccount not available in @zerodev/sdk yet
-    // const approval = await serializePermissionAccount(sessionKeyAccount);
-    const approval = JSON.stringify({ sessionKeyAccount: 'placeholder' });
+    // Serialize approval WITH session key private key (critical!)
+    const approval = await serializePermissionAccount(
+        kernelSessionKeyAccount as any,
+        sessionKeyPrivateKey
+    );
 
     return approval;
 }
@@ -246,7 +232,7 @@ export async function deserializeSessionKey(options: {
     sessionKeySigner: ModularSigner;
     chain: Chain;
     entryPointVersion?: '0.6' | '0.7';
-}): Promise<any> {
+}): Promise<CreateKernelAccountReturnType<"0.6" | "0.7">> {
     const {
         approval,
         sessionKeySigner,
@@ -263,17 +249,13 @@ export async function deserializeSessionKey(options: {
 
     // Deserialize WITH the session key signer
     // This is the 5-parameter version (not 4!)
-    // TODO: deserializePermissionAccount not available in @zerodev/sdk yet
-    // const sessionKeyAccount = await deserializePermissionAccount(
-    //     publicClient,
-    //     entryPoint,
-    //     KERNEL_V3_3,
-    //     approval,
-    //     sessionKeySigner  // ← Must pass the signer!
-    // );
-
-    // Placeholder until SDK is available
-    const sessionKeyAccount = null;
+    const sessionKeyAccount = await deserializePermissionAccount(
+        publicClient,
+        entryPoint,
+        KERNEL_V3_3,
+        approval,
+        sessionKeySigner  // ← Must pass the signer!
+    );
 
     return sessionKeyAccount;
 }
@@ -301,24 +283,35 @@ export function createSessionKeyClient(options: {
     chain: Chain;
     bundlerUrl: string;
     paymasterUrl?: string;
+    entryPoint?: { address: Hex; version: '0.6' | '0.7' };
 }): any {
     const {
         account,
         chain,
         bundlerUrl,
-        paymasterUrl
+        paymasterUrl,
+        entryPoint = { address: entryPoint07Address, version: '0.7' as const }
     } = options;
 
+    // Create Pimlico client for gas estimation
+    const paymasterClient = createPimlicoClient({
+        transport: http(bundlerUrl),
+        entryPoint
+    });
+
     const clientOptions: any = {
         account,
         chain,
-        bundlerTransport: http(bundlerUrl)
+        bundlerTransport: http(bundlerUrl),
+        userOperation: {
+            estimateFeesPerGas: async () => (await paymasterClient.getUserOperationGasPrice()).fast,
+        }
     };
 
     // Add paymaster if provided
     if (paymasterUrl) {
         // Note: Paymaster client creation would go here
-        // For now, just the basic client
+        // For now using Pimlico gas estimation
     }
 
     const kernelClient = createKernelAccountClient(clientOptions);
@@ -347,16 +340,21 @@ export function createSessionKeyClient(options: {
  */
 export function createUSDCTransferPermission(
     usdcAddress: Hex,
-    maxAmount: string
+    maxAmount: string,
+    destinationAddress: Hex
 ): SessionKeyPermissionRule {
     return {
         target: usdcAddress,
         abi: parseAbi(['function transfer(address to, uint256 amount) returns (bool)']) as any,
         functionName: 'transfer',
         args: [
-            null, // Any recipient
             {
-                condition: 3, // LESS_THAN_OR_EQUAL
+                condition: ParamCondition.EQUAL,
+                value: destinationAddress,
+            }
+            , // Specific recipient
+            {
+                condition: ParamCondition.LESS_THAN_OR_EQUAL, // LESS_THAN_OR_EQUAL
                 value: parseUnits(maxAmount, 6) // USDC has 6 decimals
             }
         ]

package/utils/evm/aa-service/lib/type.ts

@@ -56,7 +56,6 @@ export interface SingleTransactionConfig {
 export interface KernelAccountConfig {
     chain: Chain;
     owner: PrivateKeyAccount;
-    bundlerManager: BundlerManager;
     entryPointVersion?: EntryPointVersion;
     kernelVersion?: KernelVersion;
     aaConfig?: AA_SupportConfig;
@@ -141,6 +140,8 @@ export interface GasEstimate {
 export interface SessionKeyApprovalOptions {
     /** Session key address to approve */
     sessionKeyAddress: Hex;
+    /** Session key private key (needed for serialization) */
+    sessionKeyPrivateKey: Hex;
     /** Permission rules for the session key */
     permissions?: SessionKeyPermissionRule[];
     /** Use unrestricted sudo policy (not recommended for production) */

package/utils/evm/aa-service/services/account-abstraction.ts

@@ -45,7 +45,6 @@ import {
 } from '../lib/kernel-modules';
 import {
     generateSessionKey,
-    recreateSessionKey,
     createSessionKeyApproval,
     deserializeSessionKey,
     createSessionKeyClient,
@@ -103,8 +102,6 @@ export class AccountAbstractionService {
     private static instance: AccountAbstractionService | null = null;
     private bundlerManager: BundlerManager;
     private aaConfig: AA_SupportConfig | undefined;
-    private accountCache: Map<string, KernelAccountInstance> = new Map();
-    private authorizationCache: Map<string, SignAuthorizationReturnType> = new Map();
     private publicClientCache: Map<number, PublicClient> = new Map();
 
     /**
@@ -142,21 +139,7 @@ export class AccountAbstractionService {
         AccountAbstractionService.instance = null;
     }
 
-    /**
-     * Update bundler configuration (creates new bundler manager)
-     */
-    updateBundlerConfig(config: AAServiceConfig): void {
-        const bundlerConfig: BundlerConfig = {
-            provider: config.bundlerProvider,
-            apiKey: config.apiKey,
-            customUrl: config.customBundlerUrl,
-            aaConfig: config.aaConfig
-        };
 
-        this.bundlerManager = createBundlerManager(bundlerConfig);
-        this.aaConfig = config.aaConfig;
-        this.clearCache();
-    }
 
     // ============================================
     // Account Management
@@ -173,12 +156,6 @@ export class AccountAbstractionService {
             aaConfig
         } = options;
 
-        const cacheKey = this.getAccountCacheKey(chain, owner, entryPointVersion);
-
-        // Return cached account if exists
-        if (this.accountCache.has(cacheKey)) {
-            return this.accountCache.get(cacheKey)!;
-        }
 
         // Use aaConfig from options or fallback to service-level config
         const config = aaConfig || this.aaConfig;
@@ -187,27 +164,13 @@ export class AccountAbstractionService {
         const account = await createKernel7702Account({
             chain,
             owner,
-            bundlerManager: this.bundlerManager,
             entryPointVersion,
             aaConfig: config
         });
-
-        // Cache and return
-        this.accountCache.set(cacheKey, account);
         return account;
     }
 
-    /**
-     * Get cached account (if exists)
-     */
-    getCachedAccount(
-        chain: Chain,
-        owner: PrivateKeyAccount,
-        entryPointVersion: EntryPointVersion = '0.7'
-    ): KernelAccountInstance | undefined {
-        const cacheKey = this.getAccountCacheKey(chain, owner, entryPointVersion);
-        return this.accountCache.get(cacheKey);
-    }
+
 
     /**
      * Check if account is already delegated to Kernel
@@ -230,24 +193,16 @@ export class AccountAbstractionService {
     }): Promise<SignAuthorizationReturnType | undefined> {
         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 createKernelAuthorization({
             owner,
             chain,
-            bundlerManager: this.bundlerManager
+            aaConfig: this.aaConfig
         });
 
-        // Cache if created (undefined means already delegated)
-        if (authorization) {
-            this.authorizationCache.set(cacheKey, authorization);
-        }
+
 
         return authorization;
     }
@@ -340,7 +295,6 @@ export class AccountAbstractionService {
             data = '0x',
             authorization
         } = options;
-
         // If no authorization provided, try to create one
         let auth = authorization;
         if (!auth) {
@@ -535,15 +489,7 @@ export class AccountAbstractionService {
         return this.bundlerManager;
     }
 
-    /**
-     * Clear all caches
-     */
-    clearCache(): void {
-        this.accountCache.clear();
-        this.authorizationCache.clear();
-        this.publicClientCache.clear();
-        this.bundlerManager.clearCache();
-    }
+
 
     // ============================================
     // Module Management (ERC-7579)
@@ -844,21 +790,7 @@ export class AccountAbstractionService {
         return await 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: Hex): Promise<SessionKeyInfo> {
-        return await recreateSessionKey(privateKey);
-    }
+
 
     /**
      * Create session key approval (Owner side)
@@ -892,6 +824,7 @@ export class AccountAbstractionService {
      */
     async createSessionKeyApproval(options: {
         sessionKeyAddress: Hex;
+        sessionKeyPrivateKey: Hex;
         owner: PrivateKeyAccount;
         chain: Chain;
         entryPointVersion?: '0.6' | '0.7';
@@ -924,7 +857,7 @@ export class AccountAbstractionService {
         sessionKeySigner: ModularSigner;
         chain: Chain;
         entryPointVersion?: '0.6' | '0.7';
-    }): Promise<any> {
+    }) {
         return await deserializeSessionKey(options);
     }
 
@@ -976,9 +909,10 @@ export class AccountAbstractionService {
      */
     createUSDCTransferPermission(
         usdcAddress: Hex,
-        maxAmount: string
+        maxAmount: string,
+        destinationAddress: Hex
     ): SessionKeyPermissionRule {
-        return createUSDCTransferPermission(usdcAddress, maxAmount);
+        return createUSDCTransferPermission(usdcAddress, maxAmount, destinationAddress);
     }
 
     /**

package/utils/evm/aa-service/services/bundler.ts

@@ -91,7 +91,8 @@ class PimlicoBundler implements BundlerService {
             chain,
             userOperation: {
                 estimateFeesPerGas: async () => (await paymasterClient.getUserOperationGasPrice()).fast,
-            }
+            },
+            // paymaster: paymasterClient,
         });
 
         this.clientCache.set(chain.id, client);