@deserialize/multi-vm-wallet 1.2.293 → 1.3.0

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

@@ -0,0 +1,60 @@
+/**
+ * Account Adapter
+ *
+ * Adapts ZeroDev's account objects to work with our service layer.
+ * Normalizes the interface to match KernelAccountInstance.
+ */
+
+import { Chain, Hex } from 'viem';
+import { entryPoint07Address } from 'viem/account-abstraction';
+import { KernelAccountInstance } from './kernel-account';
+
+/**
+ * Adapt a ZeroDev account to our KernelAccountInstance interface
+ *
+ * ZeroDev's createKernelAccount returns a different structure than what
+ * our service expects. This adapter normalizes it.
+ *
+ * @param account - The account from createKernelAccount
+ * @param chain - The chain the account is on
+ * @returns Normalized account that works with our service
+ */
+export function adaptZeroDevAccount(
+    account: any,
+    chain: Chain
+): KernelAccountInstance {
+    return {
+        ...account,
+        chain,
+        entryPoint: account.entryPoint || {
+            address: entryPoint07Address,
+            version: '0.7'
+        }
+    } as KernelAccountInstance;
+}
+
+/**
+ * Adapt a session key account specifically
+ *
+ * Session key accounts need special handling to ensure all properties
+ * are properly set for transaction execution.
+ */
+export function adaptSessionKeyAccount(
+    sessionKeyAccount: any,
+    masterAccount: KernelAccountInstance
+): KernelAccountInstance {
+    // Ensure entryPoint is properly defined
+    const entryPoint = sessionKeyAccount.entryPoint || masterAccount.entryPoint || {
+        address: entryPoint07Address,
+        version: '0.7'
+    };
+
+    return {
+        ...sessionKeyAccount,
+        chain: masterAccount.chain,
+        entryPoint: {
+            address: entryPoint.address || entryPoint07Address,
+            version: entryPoint.version || '0.7'
+        }
+    } as KernelAccountInstance;
+}

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

@@ -0,0 +1,367 @@
+/**
+ * Kernel Account Factory
+ *
+ * Modular factory for creating Kernel smart accounts with EIP-7702.
+ * Supports multiple bundlers, chains, and EntryPoint versions.
+ */
+
+import { Chain, Hex, parseEther, PublicClient, SignAuthorizationReturnType, createPublicClient, http } from 'viem';
+import { PrivateKeyAccount, privateKeyToAccount } from 'viem/accounts';
+import { createKernelAccount } from '@zerodev/sdk';
+import { KERNEL_V3_3, KernelVersionToAddressesMap } from '@zerodev/sdk/constants';
+import { entryPoint07Address, entryPoint08Address } from 'viem/account-abstraction';
+import { BundlerManager, createBundlerService } from '../services/bundler';
+import { BatchTransactionConfig, EntryPointVersion, KernelAccountConfig, KernelAccountInstance, KernelVersion, SingleTransactionConfig, Call } from './type';
+
+// Re-export types so other files can import from this module
+export type {
+    Call,
+    KernelAccountInstance,
+    EntryPointVersion,
+    KernelVersion,
+    KernelAccountConfig,
+    BatchTransactionConfig,
+    SingleTransactionConfig
+} from './type';
+
+
+
+// ============================================
+// EntryPoint Mapping
+// ============================================
+
+const ENTRYPOINT_MAP: Record<EntryPointVersion, Hex> = {
+    '0.6': entryPoint07Address, // Fallback to 0.7 for 0.6 requests
+    '0.7': entryPoint07Address
+};
+
+// ============================================
+// Kernel Account Factory
+// ============================================
+
+export async function createKernel7702Account(
+    config: KernelAccountConfig
+): Promise<KernelAccountInstance> {
+    const {
+        chain,
+        owner,
+        bundlerManager,
+        entryPointVersion = '0.7',
+        kernelVersion = '0.3.3'
+    } = config;
+
+    // Create public client for standard RPC calls
+    // (Bundler clients don't support standard eth_* methods)
+    const publicClient = createPublicClient({
+        chain,
+        transport: http()
+    });
+
+    // Get EntryPoint address
+    const entryPointAddress = ENTRYPOINT_MAP[entryPointVersion];
+
+    if (!entryPointAddress) {
+        throw new Error(`Unsupported EntryPoint version: ${entryPointVersion}`);
+    }
+
+    // Create Kernel account with EIP-7702
+    // Use public client for account creation (needs eth_call, eth_getCode, etc.)
+    const kernelAccount = await createKernelAccount(
+        publicClient as any,
+        {
+            entryPoint: {
+                address: entryPointAddress,
+                version: entryPointVersion
+            },
+            kernelVersion: KERNEL_V3_3,
+            eip7702Account: owner as any
+        }
+    );
+
+    return {
+        account: kernelAccount,
+        address: kernelAccount.address,
+        owner,
+        chain,
+        entryPoint: {
+            address: entryPointAddress,
+            version: entryPointVersion
+        }
+    };
+}
+
+// ============================================
+// EIP-7702 Authorization Helper
+// ============================================
+
+export async function createKernelAuthorization(
+    config: {
+        owner: PrivateKeyAccount;
+        chain: Chain;
+        bundlerManager: BundlerManager;
+        kernelVersion?: KernelVersion;
+    }
+): Promise<SignAuthorizationReturnType | undefined> {
+    const { owner, chain, bundlerManager, kernelVersion = '0.3.3' } = config;
+
+    const bundlerClient = bundlerManager.getClient(chain);
+
+    // Create public client for eth_getCode (bundler clients don't support it)
+    const publicClient = createPublicClient({
+        chain,
+        transport: http()
+    });
+
+    // Get Kernel implementation address
+    const delegateAddress = KernelVersionToAddressesMap[KERNEL_V3_3].accountImplementationAddress;
+
+    // Check if already delegated
+    const code = await publicClient.getCode({ address: owner.address });
+    const expectedCode = `0xef0100${delegateAddress.toLowerCase().substring(2)}`;
+
+    if (code === expectedCode) {
+        console.log('Already delegated to Kernel, no authorization needed');
+        return undefined;
+    }
+
+    // Create authorization
+    console.log('Creating EIP-7702 authorization for Kernel...');
+
+    // Get nonce for authorization
+    const nonce = await publicClient.getTransactionCount({
+        address: owner.address,
+        blockTag: 'pending'
+    });
+
+    // Sign authorization using the account's signAuthorization method
+    const authorization = await owner.signAuthorization({
+        contractAddress: delegateAddress,
+        chainId: chain.id,
+        nonce: nonce
+    });
+
+    return authorization;
+}
+
+// ============================================
+// Transaction Helpers
+// ============================================
+
+/**
+ * Send batch transaction (RECOMMENDED for smart accounts)
+ *
+ * Sends multiple calls in a single UserOperation, paying gas only once.
+ * This is one of the main benefits of smart accounts over EOAs.
+ *
+ * @example
+ * // Send ETH to 3 recipients in one transaction
+ * await sendBatchTransaction({
+ *   kernelAccount: account,
+ *   bundlerManager,
+ *   calls: [
+ *     { to: '0xRecipient1', value: parseEther('0.01') },
+ *     { to: '0xRecipient2', value: parseEther('0.02') },
+ *     { to: '0xRecipient3', value: parseEther('0.03') }
+ *   ]
+ * });
+ */
+export async function sendBatchTransaction(config: BatchTransactionConfig): Promise<Hex> {
+    const {
+        kernelAccount,
+        bundlerManager,
+        authorization,
+        calls
+    } = config;
+
+    if (calls.length === 0) {
+        throw new Error('Batch transaction must have at least one call');
+    }
+
+    const bundlerClient = bundlerManager.getClient(kernelAccount.chain);
+
+    // Normalize calls to ensure value and data are set
+    const normalizedCalls = calls.map(call => ({
+        to: call.to,
+        value: call.value ?? 0n,
+        data: call.data ?? '0x' as Hex
+    }));
+
+    const userOpHash = await bundlerClient.sendUserOperation({
+        account: kernelAccount.account,
+        authorization,
+        calls: normalizedCalls
+    });
+
+    return userOpHash as Hex;
+}
+
+/**
+ * Send single transaction (convenience wrapper around sendBatchTransaction)
+ *
+ * For single operations, you can use this instead of sendBatchTransaction.
+ * Under the hood, it creates a batch with one call.
+ */
+export async function sendKernelTransaction(config: SingleTransactionConfig): Promise<Hex> {
+    const {
+        kernelAccount,
+        bundlerManager,
+        authorization,
+        to,
+        value = 0n,
+        data = '0x'
+    } = config;
+
+    // Use batch transaction with single call
+    return sendBatchTransaction({
+        kernelAccount,
+        bundlerManager,
+        authorization,
+        calls: [{
+            to,
+            value,
+            data
+        }]
+    });
+}
+
+// ============================================
+// Wait for Receipt Helper
+// ============================================
+
+export async function waitForKernelReceipt(config: {
+    userOpHash: Hex;
+    chain: Chain;
+    bundlerManager: BundlerManager;
+}): Promise<any> {
+    const { userOpHash, chain, bundlerManager } = config;
+
+    const bundlerClient = bundlerManager.getClient(chain);
+
+    const receipt = await bundlerClient.waitForUserOperationReceipt({
+        hash: userOpHash
+    });
+
+    return receipt;
+}
+
+// ============================================
+// Sponsored Transactions (EIP-7702)
+// ============================================
+
+/**
+ * Configuration for sponsored batch transaction
+ */
+export interface SponsoredBatchTransactionConfig {
+    ownerAuthorization: SignAuthorizationReturnType;
+    calls: Call[];
+    feePayerPrivateKey: Hex;
+    bundlerUrl: string;
+    paymasterUrl?: string;
+    chain: Chain;
+    entryPointVersion?: EntryPointVersion;
+}
+
+/**
+ * Send sponsored batch transaction using EIP-7702
+ *
+ * Allows a feePayer wallet to pay gas fees for another wallet's transaction.
+ * The transaction executes from the owner's address, but gas is paid by the feePayer.
+ *
+ * @param config - Sponsored transaction configuration
+ * @returns UserOperation hash and transaction hash
+ *
+ * @example
+ * // Owner creates authorization
+ * const authorization = await createKernelAuthorization({
+ *   owner: ownerAccount,
+ *   chain,
+ *   bundlerManager
+ * });
+ *
+ * // FeePayer sends transaction
+ * const result = await sendSponsoredBatchTransaction({
+ *   ownerAuthorization: authorization,
+ *   calls: [{ to: recipient, value: parseEther('0.1') }],
+ *   feePayerPrivateKey: sponsorPrivateKey,
+ *   bundlerUrl,
+ *   chain
+ * });
+ */
+export async function sendSponsoredBatchTransaction(
+    config: SponsoredBatchTransactionConfig
+): Promise<{ userOpHash: Hex; transactionHash?: string }> {
+    const {
+        ownerAuthorization,
+        calls,
+        feePayerPrivateKey,
+        bundlerUrl,
+        paymasterUrl,
+        chain,
+        entryPointVersion = '0.7'
+    } = config;
+
+    if (calls.length === 0) {
+        throw new Error('Sponsored transaction must have at least one call');
+    }
+
+    // Create feePayer account
+    const feePayerAccount = privateKeyToAccount(feePayerPrivateKey);
+
+    // Create bundler service for feePayer
+    const feePayerBundlerService = createBundlerService({
+        provider: "custom",
+        customUrl: bundlerUrl,
+        chain
+    });
+
+    // Get bundler client (uses feePayer account internally)
+    const bundlerClient = feePayerBundlerService.getClient(chain);
+
+    // Create kernel account for feePayer (needed for sendUserOperation)
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(chain.rpcUrls.default.http[0])
+    });
+
+    const entryPointAddress = ENTRYPOINT_MAP[entryPointVersion];
+    if (!entryPointAddress) {
+        throw new Error(`Unsupported EntryPoint version: ${entryPointVersion}`);
+    }
+
+    const feePayerKernelAccount = await createKernelAccount(
+        publicClient as any,
+        {
+            entryPoint: {
+                address: entryPointAddress,
+                version: entryPointVersion
+            },
+            kernelVersion: KERNEL_V3_3,
+            eip7702Account: feePayerAccount as any
+        }
+    );
+
+    // Normalize calls
+    const normalizedCalls = calls.map(call => ({
+        to: call.to,
+        value: call.value ?? 0n,
+        data: call.data ?? '0x' as Hex
+    }));
+
+    // Send UserOperation with owner's authorization
+    // The transaction executes from owner's address, but feePayer pays gas
+    const userOpHash = await bundlerClient.sendUserOperation({
+        account: feePayerKernelAccount,
+        authorization: ownerAuthorization,
+        calls: normalizedCalls
+    });
+
+    // Wait for receipt
+    const receipt = await bundlerClient.waitForUserOperationReceipt({
+        hash: userOpHash
+    });
+
+    return {
+        userOpHash: userOpHash as Hex,
+        transactionHash: receipt?.receipt?.transactionHash
+    };
+}