@deserialize/multi-vm-wallet 1.3.0 → 1.3.2

package/dist/types.d.ts

@@ -16,19 +16,20 @@ export interface ChainWalletConfig {
     confirmationNo?: number;
     testnet?: boolean;
     vmType: vmTypes;
-    aaSupport?: {
-        enabled: boolean;
-        entryPoints: {
-            address: string;
-            version: EntryPointVersion;
-        }[];
-        bundlerUrl: string;
-        paymasterUrl: string;
-        kernelImplementations: {
-            address: string;
-            version: number;
-        }[];
-    };
+    aaSupport?: AA_SupportConfig;
+}
+export interface AA_SupportConfig {
+    enabled: boolean;
+    entryPoints: {
+        address: string;
+        version: EntryPointVersion;
+    }[];
+    bundlerUrl: string;
+    paymasterUrl: string;
+    kernelImplementations: {
+        address: string;
+        version: number;
+    }[];
 }
 export interface TokenInfo {
     address: string;
@@ -202,9 +203,6 @@ export interface TransactionResult {
     success: boolean;
     error?: string;
 }
-export interface FeePayerOptions {
-    privateKey: string;
-}
 export interface Balance {
     balance: BN;
     formatted: number;

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../utils/types.ts"],"names":[],"mappings":";;;AACA,+BAA8B;AAC9B,+BAA8B;AAiRjB,QAAA,YAAY,GAAG;IACxB,KAAK,EAAE,WAAK;IACZ,KAAK,EAAE,WAAK;CACN,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../utils/types.ts"],"names":[],"mappings":";;;AACA,+BAA8B;AAC9B,+BAA8B;AA+QjB,QAAA,YAAY,GAAG;IACxB,KAAK,EAAE,WAAK;IACZ,KAAK,EAAE,WAAK;CACN,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deserialize/multi-vm-wallet",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "devDependencies": {
     "@types/bn.js": "^5.2.0",
     "@types/crypto-js": "^4.2.2",
@@ -16,15 +16,21 @@
     "@noble/hashes": "^1.3.3",
     "@scure/bip32": "^2.0.1",
     "@scure/bip39": "^2.0.1",
+    "@simplewebauthn/typescript-types": "^8.3.4",
     "@solana/spl-token": "^0.4.13",
     "@solana/web3.js": "^1.98.4",
+    "@zerodev/permissions": "^5.6.3",
+    "@zerodev/sdk": "^5.5.7",
+    "@zerodev/webauthn-key": "^5.5.0",
     "bignumber.js": "^9.3.1",
     "bn.js": "^5.2.2",
     "bs58": "^6.0.0",
     "crypto-js": "^4.2.0",
     "debonk-evm-sever-sdk": "^1.4.0",
     "ethers": "^6.15.0",
+    "permissionless": "^0.3.2",
     "promise-retry": "^2.0.1",
+    "tslib": "^2.8.1",
     "tweetnacl": "^1.0.3",
     "viem": "^2.43.4"
   },

package/utils/IChainWallet.ts

@@ -1,6 +1,6 @@
 import { EVMTransactionHistoryItem } from "./evm/transactionParsing";
 import { SVMTransactionHistoryItem } from "./svm/transactionParsing";
-import { Balance, ChainWalletConfig, NFTInfo, TokenInfo, TransactionResult, UserTokenBalance, NFT, FeePayerOptions } from "./types";
+import { Balance, ChainWalletConfig, NFTInfo, TokenInfo, TransactionResult, UserTokenBalance, NFT } from "./types";
 
 export abstract class ChainWallet<AddressType, PrivateKeyType, ConnectionType> {
     protected privateKey: PrivateKeyType;
@@ -20,8 +20,8 @@ export abstract class ChainWallet<AddressType, PrivateKeyType, ConnectionType> {
     abstract generateAddress(privateKey: PrivateKeyType): AddressType;
     abstract getNativeBalance(): Promise<Balance>;
     abstract getTokenBalance(tokenAddress: AddressType): Promise<Balance>;
-    abstract transferNative(to: AddressType, amount: number, feePayerOptions?: FeePayerOptions): Promise<TransactionResult>;
-    abstract transferToken(tokenAddress: TokenInfo, to: AddressType, amount: number, feePayerOptions?: FeePayerOptions): Promise<TransactionResult>;
+    abstract transferNative(to: AddressType, amount: number): Promise<TransactionResult>;
+    abstract transferToken(tokenAddress: TokenInfo, to: AddressType, amount: number): Promise<TransactionResult>;
     abstract swap(tokenAddress: TokenInfo, to: AddressType, amount: number, slippage?: number): Promise<TransactionResult>;
     abstract discoverToken(): Promise<UserTokenBalance<AddressType>[]>;
     abstract discoverNFT(): Promise<NFT[]>;

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

@@ -30,8 +30,7 @@ export {
     createKernelAuthorization,
     sendKernelTransaction,
     sendBatchTransaction,
-    waitForKernelReceipt,
-    sendSponsoredBatchTransaction
+    waitForKernelReceipt
 } from './lib/kernel-account';
 
 

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

@@ -9,7 +9,7 @@ import { Chain, Hex, parseEther, PublicClient, SignAuthorizationReturnType, crea
 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 { createBundlerClient, entryPoint07Address, entryPoint08Address } from 'viem/account-abstraction';
 import { BundlerManager, createBundlerService } from '../services/bundler';
 import { BatchTransactionConfig, EntryPointVersion, KernelAccountConfig, KernelAccountInstance, KernelVersion, SingleTransactionConfig, Call } from './type';
 
@@ -47,7 +47,8 @@ export async function createKernel7702Account(
         owner,
         bundlerManager,
         entryPointVersion = '0.7',
-        kernelVersion = '0.3.3'
+        kernelVersion = '0.3.3',
+        aaConfig
     } = config;
 
     // Create public client for standard RPC calls
@@ -57,11 +58,25 @@ export async function createKernel7702Account(
         transport: http()
     });
 
-    // Get EntryPoint address
-    const entryPointAddress = ENTRYPOINT_MAP[entryPointVersion];
-
-    if (!entryPointAddress) {
-        throw new Error(`Unsupported EntryPoint version: ${entryPointVersion}`);
+    // Get EntryPoint address from aaConfig or fallback to default
+    let entryPointAddress: Hex;
+
+    if (aaConfig && aaConfig.entryPoints.length > 0) {
+        // Find matching entry point from config
+        const entryPoint = aaConfig.entryPoints.find(ep => ep.version === entryPointVersion);
+        if (entryPoint) {
+            entryPointAddress = entryPoint.address as Hex;
+        } else {
+            // Fallback to first entry point if version not found
+            console.warn(`EntryPoint version ${entryPointVersion} not found in aaConfig, using first available`);
+            entryPointAddress = aaConfig.entryPoints[0].address as Hex;
+        }
+    } else {
+        // Fallback to hardcoded map if no config
+        entryPointAddress = ENTRYPOINT_MAP[entryPointVersion];
+        if (!entryPointAddress) {
+            throw new Error(`Unsupported EntryPoint version: ${entryPointVersion}`);
+        }
     }
 
     // Create Kernel account with EIP-7702
@@ -244,124 +259,3 @@ export async function waitForKernelReceipt(config: {
     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
-    };
-}

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

@@ -59,6 +59,7 @@ export interface KernelAccountConfig {
     bundlerManager: BundlerManager;
     entryPointVersion?: EntryPointVersion;
     kernelVersion?: KernelVersion;
+    aaConfig?: AA_SupportConfig;
 }
 
 export interface KernelAccountInstance {
@@ -79,7 +80,23 @@ export interface KernelAccountInstance {
 
 
 
+export interface AA_SupportConfig {
+    enabled: boolean;
+    entryPoints: {
+        address: string;
+        version: EntryPointVersion;
+    }[]
+    bundlerUrl: string;
+    paymasterUrl: string;
+    kernelImplementations: {
+        address: string;
+        version: number;
+    }[];
+}
+
 export interface SmartWalletOptions {
+    /** Full AA support configuration from chain config */
+    aaConfig?: AA_SupportConfig;
     /** Bundler URL for submitting UserOperations */
     bundlerUrl?: string;
     /** Paymaster URL for gas sponsorship (optional) */

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

@@ -60,16 +60,20 @@ import { ModularSigner } from '@zerodev/permissions';
 // Types
 // ============================================
 
+import { AA_SupportConfig } from '../lib/type';
+
 export interface AAServiceConfig {
     bundlerProvider: 'pimlico' | 'etherspot' | 'custom';
     apiKey?: string;
     customBundlerUrl?: string;
+    aaConfig?: AA_SupportConfig;
 }
 
 export interface CreateAccountOptions {
     chain: Chain;
     owner: PrivateKeyAccount;
     entryPointVersion?: EntryPointVersion;
+    aaConfig?: AA_SupportConfig;
 }
 
 export interface SendTransactionOptions {
@@ -98,6 +102,7 @@ export interface WaitForReceiptOptions {
 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();
@@ -109,9 +114,11 @@ export class AccountAbstractionService {
         const bundlerConfig: BundlerConfig = {
             provider: config.bundlerProvider,
             apiKey: config.apiKey,
-            customUrl: config.customBundlerUrl
+            customUrl: config.customBundlerUrl,
+            aaConfig: config.aaConfig
         };
         this.bundlerManager = createBundlerManager(bundlerConfig);
+        this.aaConfig = config.aaConfig;
     }
 
     /**
@@ -142,10 +149,12 @@ export class AccountAbstractionService {
         const bundlerConfig: BundlerConfig = {
             provider: config.bundlerProvider,
             apiKey: config.apiKey,
-            customUrl: config.customBundlerUrl
+            customUrl: config.customBundlerUrl,
+            aaConfig: config.aaConfig
         };
 
         this.bundlerManager = createBundlerManager(bundlerConfig);
+        this.aaConfig = config.aaConfig;
         this.clearCache();
     }
 
@@ -160,7 +169,8 @@ export class AccountAbstractionService {
         const {
             chain,
             owner,
-            entryPointVersion = '0.7'
+            entryPointVersion = '0.7',
+            aaConfig
         } = options;
 
         const cacheKey = this.getAccountCacheKey(chain, owner, entryPointVersion);
@@ -170,12 +180,16 @@ export class AccountAbstractionService {
             return this.accountCache.get(cacheKey)!;
         }
 
+        // Use aaConfig from options or fallback to service-level config
+        const config = aaConfig || this.aaConfig;
+
         // Create new account
         const account = await createKernel7702Account({
             chain,
             owner,
             bundlerManager: this.bundlerManager,
-            entryPointVersion
+            entryPointVersion,
+            aaConfig: config
         });
 
         // Cache and return

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

@@ -6,23 +6,26 @@
  */
 
 import { Chain, createPublicClient, http, publicActions, walletActions } from 'viem';
-import { createBundlerClient, entryPoint07Address, entryPoint08Address } from 'viem/account-abstraction';
-
+import { BundlerClient, createBundlerClient, entryPoint07Address, entryPoint08Address } from 'viem/account-abstraction';
+import { createPimlicoClient } from 'permissionless/clients/pimlico';
 // ============================================
 // Types
 // ============================================
 
 export type BundlerProvider = 'pimlico' | 'etherspot' | 'custom';
 
+import type { AA_SupportConfig } from '../lib/type';
+
 export interface BundlerConfig {
     provider: BundlerProvider;
     apiKey?: string;
     customUrl?: string;
     chain?: Chain;
+    aaConfig?: AA_SupportConfig;
 }
 
 export interface BundlerService {
-    getClient(chain: Chain): any;
+    getClient(chain: Chain): BundlerClient;
     getBundlerUrl(chain: Chain): string;
     getProvider(): string;
 }
@@ -34,26 +37,61 @@ export interface BundlerService {
 class PimlicoBundler implements BundlerService {
     private apiKey: string;
     private clientCache: Map<number, any> = new Map();
+    private url: string;
+    private aaConfig?: AA_SupportConfig;
 
-    constructor(apiKey: string) {
-        if (!apiKey) {
-            throw new Error('Pimlico API key is required');
-        }
+    constructor(apiKey: string, url: string, aaConfig?: AA_SupportConfig) {
+        this.url = url;
         this.apiKey = apiKey;
+        this.aaConfig = aaConfig;
     }
 
     getBundlerUrl(chain: Chain): string {
+        if (!this.apiKey) {
+            return this.url
+        }
         return `https://api.pimlico.io/v2/${chain.id}/rpc?apikey=${this.apiKey}`;
     }
 
-    getClient(chain: Chain): any {
+    getClient(chain: Chain): BundlerClient {
         if (this.clientCache.has(chain.id)) {
             return this.clientCache.get(chain.id);
         }
+        const bundlerUrl = this.getBundlerUrl(chain);
+
+        // Get entryPoint from aaConfig or fallback to default
+        let entryPointAddress: `0x${string}`;
+        let entryPointVersion: '0.6' | '0.7' = '0.7';
+
+        if (this.aaConfig && this.aaConfig.entryPoints.length > 0) {
+            // Use first entry point from config (could be enhanced to select by version)
+            const ep = this.aaConfig.entryPoints[0];
+            entryPointAddress = ep.address as `0x${string}`;
+            entryPointVersion = ep.version;
+        } else {
+            // Fallback to hardcoded default
+            entryPointAddress = entryPoint07Address;
+            entryPointVersion = '0.7';
+        }
 
+        // Create Pimlico client for Pimlico-specific features (gas estimation)
+        const entryPoint = {
+            address: entryPointAddress,
+            version: entryPointVersion
+        };
+
+        const paymasterClient = createPimlicoClient({
+            transport: http(bundlerUrl),
+            entryPoint
+        });
+
+        // Create bundler client with Pimlico gas estimation
         const client = createBundlerClient({
-            transport: http(this.getBundlerUrl(chain)),
-            chain
+            transport: http(bundlerUrl),
+            chain,
+            userOperation: {
+                estimateFeesPerGas: async () => (await paymasterClient.getUserOperationGasPrice()).fast,
+            }
         });
 
         this.clientCache.set(chain.id, client);
@@ -155,7 +193,11 @@ export class BundlerManager {
     constructor(config: BundlerConfig) {
         switch (config.provider) {
             case 'pimlico':
-                this.bundlerService = new PimlicoBundler(config.apiKey!);
+                this.bundlerService = new PimlicoBundler(
+                    config.apiKey ? config.apiKey : '',
+                    config.customUrl ? config.customUrl : '',
+                    config.aaConfig
+                );
                 break;
             // case 'etherspot':
             //     this.bundlerService = new EtherspotBundler();

package/utils/evm/evm.ts

@@ -6,7 +6,7 @@
 
 import { EVMDeriveChildPrivateKey } from "../walletBip32";
 import { ChainWallet } from "../IChainWallet";
-import { Balance, ChainWalletConfig, NFTInfo, UserTokenBalance, TokenInfo, TransactionResult, NFT, FeePayerOptions } from "../types";
+import { Balance, ChainWalletConfig, NFTInfo, UserTokenBalance, TokenInfo, TransactionResult, NFT } from "../types";
 import { VM } from "../vm";
 import { ethers, JsonRpcProvider, Wallet, formatUnits, Interface } from "ethers";
 import BN from "bn.js";
@@ -225,25 +225,17 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
      */
     async extend(options: SmartWalletOptions = {}): Promise<EVMSmartWallet> {
         if (!this.smartWallet) {
-            // Priority 1: Use bundlerUrl from options if provided (manual override)
-            let bundlerUrl = options.bundlerUrl;
-            let paymasterUrl = options.paymasterUrl;
-            let entryPointVersion = options.entryPointVersion;
-
-            // Priority 2: Use aaSupport config if available and no manual override
-            if (!bundlerUrl && this.config.aaSupport?.enabled) {
-                bundlerUrl = this.config.aaSupport.bundlerUrl;
-                paymasterUrl = paymasterUrl || this.config.aaSupport.paymasterUrl;
-
-                // Use the first entry point version if not specified
-                if (!entryPointVersion && this.config.aaSupport.entryPoints.length > 0) {
-                    const version = this.config.aaSupport.entryPoints[0].version;
-                    entryPointVersion = version
-                }
-            }
+            // Merge options with aaSupport config (options take priority)
+            const mergedOptions: SmartWalletOptions = {
+                ...options,
+                aaConfig: this.config.aaSupport,
+                bundlerUrl: options.bundlerUrl || this.config.aaSupport?.bundlerUrl,
+                paymasterUrl: options.paymasterUrl || this.config.aaSupport?.paymasterUrl,
+                entryPointVersion: options.entryPointVersion || this.config.aaSupport?.entryPoints?.[0]?.version
+            };
 
             // Validate bundlerUrl is available
-            if (!bundlerUrl) {
+            if (!mergedOptions.bundlerUrl) {
                 throw new Error(
                     'bundlerUrl is required to enable smart wallet features.\n' +
                     'Provide it via:\n' +
@@ -278,12 +270,7 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
             this.smartWallet = new EVMSmartWallet(
                 this.privateKey,
                 chain,
-                bundlerUrl,
-                {
-                    paymasterUrl,
-                    entryPointVersion,
-                    autoInitialize: options.autoInitialize
-                }
+                mergedOptions
             );
 
             // Auto-initialize if option is set (default: true)
@@ -329,76 +316,6 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         }
     }
 
-    // ============================================
-    // Sponsored Transaction Helpers (EIP-7702)
-    // ============================================
-
-    /**
-     * Transfer native tokens with sponsored gas (internal method)
-     * Requires smart wallet to be initialized via extend()
-     */
-    private async transferNativeSponsored(
-        to: string,
-        amount: number,
-        feePayerOptions: FeePayerOptions
-    ): Promise<TransactionResult> {
-        // Smart wallet is guaranteed to exist because validateAAAvailability() was called
-        const call: Call = {
-            to: to as Hex,
-            value: parseEther(amount.toString()),
-            data: '0x' as Hex
-        };
-
-        const result = await this.smartWallet!.sendSponsoredBatchTransaction(
-            [call],
-            feePayerOptions.privateKey as Hex
-        );
-
-        return {
-            success: result.success,
-            hash: result.transactionHash || '',
-            error: result.error
-        };
-    }
-
-    /**
-     * Transfer tokens with sponsored gas (internal method)
-     * Requires smart wallet to be initialized via extend()
-     */
-    private async transferTokenSponsored(
-        tokenAddress: TokenInfo,
-        to: string,
-        amount: number,
-        feePayerOptions: FeePayerOptions
-    ): Promise<TransactionResult> {
-        // Create ERC20 transfer call data
-        const erc20Interface = new Interface([
-            'function transfer(address to, uint256 amount) returns (bool)'
-        ]);
-
-        const data = erc20Interface.encodeFunctionData('transfer', [
-            to,
-            parseUnits(amount.toString(), tokenAddress.decimals)
-        ]);
-
-        const call: Call = {
-            to: tokenAddress.address as Hex,
-            value: 0n,
-            data: data as Hex
-        };
-
-        const result = await this.smartWallet!.sendSponsoredBatchTransaction(
-            [call],
-            feePayerOptions.privateKey as Hex
-        );
-
-        return {
-            success: result.success,
-            hash: result.transactionHash || '',
-            error: result.error
-        };
-    }
-
     // ============================================
     // Existing Wallet Methods
     // ============================================
@@ -435,26 +352,12 @@ export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider>
         return await discoverNFTs(this.address, this.config)
     }
 
-    async transferNative(to: string, amount: number, feePayerOptions?: FeePayerOptions): Promise<TransactionResult> {
-        // If feePayer is provided, use sponsored transaction (requires AA)
-        if (feePayerOptions) {
-            this.validateAAAvailability();
-            return await this.transferNativeSponsored(to, amount, feePayerOptions);
-        }
-
-        // Regular transfer (existing implementation)
+    async transferNative(to: string, amount: number): Promise<TransactionResult> {
         const wallet = this.getWallet();
         return await sendNativeToken(wallet, to, amount.toString(), undefined, this.config.confirmationNo || 5);
     }
 
-    async transferToken(tokenAddress: TokenInfo, to: string, amount: number, feePayerOptions?: FeePayerOptions): Promise<TransactionResult> {
-        // If feePayer is provided, use sponsored transaction (requires AA)
-        if (feePayerOptions) {
-            this.validateAAAvailability();
-            return await this.transferTokenSponsored(tokenAddress, to, amount, feePayerOptions);
-        }
-
-        // Regular transfer (existing implementation)
+    async transferToken(tokenAddress: TokenInfo, to: string, amount: number): Promise<TransactionResult> {
         const wallet = this.getWallet();
         return await sendERC20Token(wallet, tokenAddress.address, to, amount.toString(), undefined, this.config.confirmationNo || 5);
     }