@aastar/enduser 0.16.16 → 0.16.19

package/dist/enduser/src/CommunityClient.d.ts

@@ -30,6 +30,18 @@ export declare class CommunityClient extends BaseClient {
      * 3. Linking the Token to the Community in Registry
      */
     createCommunityToken(params: CreateCommunityParams, options?: TransactionOptions): Promise<Hash>;
+    /**
+     * Get Community Details (Decodes Role Metadata)
+     * @param communityAddress - The address of the community manager (defaults to self)
+     */
+    getCommunityInfo(communityAddress?: Address): Promise<{
+        name: string;
+        ensName: string;
+        website: string;
+        description: string;
+        logoURI: string;
+        stakeAmount: bigint;
+    }>;
     /**
      * Register self as a Community Manager.
      * This method handles all necessary steps:

package/dist/enduser/src/CommunityClient.js

@@ -45,6 +45,48 @@ export class CommunityClient extends BaseClient {
             throw error;
         }
     }
+    /**
+     * Get Community Details (Decodes Role Metadata)
+     * @param communityAddress - The address of the community manager (defaults to self)
+     */
+    async getCommunityInfo(communityAddress) {
+        try {
+            const target = communityAddress || this.getAddress();
+            const registryAddr = this.requireRegistry();
+            const registry = registryActions(registryAddr);
+            const publicClient = this.getStartPublicClient();
+            // 1. Get Role ID
+            const API_ROLE_COMMUNITY = await registry(publicClient).ROLE_COMMUNITY();
+            // 2. Fetch Metadata (Hex)
+            const metadataHex = await registry(publicClient).roleMetadata({
+                roleId: API_ROLE_COMMUNITY,
+                user: target
+            });
+            if (!metadataHex || metadataHex === '0x') {
+                throw new Error('No metadata found for this community');
+            }
+            // 3. Decode
+            // struct CommunityRoleData { string name; string ensName; string website; string description; string logoURI; uint256 stakeAmount; }
+            let dataToDecode = metadataHex;
+            // Check for common 'bytes' or 'tuple' wrapper offset (0x20)
+            if (metadataHex.startsWith('0x0000000000000000000000000000000000000000000000000000000000000020')) {
+                dataToDecode = `0x${metadataHex.slice(66)}`;
+            }
+            const { decodeAbiParameters, parseAbiParameters } = await import('viem');
+            const [name, ensName, website, description, logoURI, stakeAmount] = decodeAbiParameters(parseAbiParameters('string, string, string, string, string, uint256'), dataToDecode);
+            return {
+                name,
+                ensName,
+                website,
+                description,
+                logoURI,
+                stakeAmount
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
     /**
      * Register self as a Community Manager.
      * This method handles all necessary steps:

package/dist/enduser/src/UserClient.d.ts

@@ -19,6 +19,25 @@ export declare class UserClient extends BaseClient {
     gTokenAddress?: Address;
     bundlerClient?: any;
     constructor(config: UserClientConfig);
+    /**
+     * Deploy a new Smart Account (Supports multiple factory types)
+     * Static helper to facilitate onboarding before instantiating the UserClient.
+     *
+     * @param client - WalletClient to sign the deployment transaction
+     * @param params - Deployment parameters
+     * @returns Object containing the deployed account address and transaction hash
+     */
+    static deployAccount(client: any, params: {
+        owner: Address;
+        salt?: bigint;
+        factoryAddress?: Address;
+        publicClient?: any;
+        accountType?: 'simple' | 'kernel' | 'safe' | string;
+        customAbi?: any;
+    }): Promise<{
+        accountAddress: Address;
+        hash: Hash;
+    }>;
     /**
      * Get the nonce of the account from EntryPoint (more reliable for 4337)
      */

package/dist/enduser/src/UserClient.js

@@ -20,6 +20,45 @@ export class UserClient extends BaseClient {
         this.registryAddress = config.registryAddress;
         this.gTokenAddress = config.gTokenAddress;
     }
+    /**
+     * Deploy a new Smart Account (Supports multiple factory types)
+     * Static helper to facilitate onboarding before instantiating the UserClient.
+     *
+     * @param client - WalletClient to sign the deployment transaction
+     * @param params - Deployment parameters
+     * @returns Object containing the deployed account address and transaction hash
+     */
+    static async deployAccount(client, params) {
+        const { accountFactoryActions, SimpleAccountFactoryABI } = await import('@aastar/core');
+        // 1. Determine Factory ABI (Ensure it's the raw ABI array)
+        let abi = params.customAbi || (SimpleAccountFactoryABI?.abi || SimpleAccountFactoryABI);
+        // In the future, we can add more built-in ABIs here based on accountType
+        // if (params.accountType === 'kernel') abi = KernelFactoryABI;
+        const factoryAddr = params.factoryAddress || '0x9406Cc6185a346906296840746125a0E44976454'; // Default v0.7 Factory
+        const salt = params.salt || 0n;
+        // Use publicClient for reading if provided, otherwise fallback to client (which might be a Full Client)
+        const readClient = params.publicClient || client;
+        // Use the generic actions with the selected ABI
+        const factoryRead = accountFactoryActions(factoryAddr, abi)(readClient);
+        const factoryWrite = accountFactoryActions(factoryAddr, abi)(client);
+        // 1. Predict Address
+        const accountAddress = await factoryRead.getAddress({
+            owner: params.owner,
+            salt
+        });
+        // 2. Deploy
+        try {
+            const hash = await factoryWrite.createAccount({
+                owner: params.owner,
+                salt,
+                account: client.account
+            });
+            return { accountAddress, hash };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
     // ========================================
     // 1. 账户基本操作 (基于 L1 simpleAccountActions)
     // ========================================
@@ -330,8 +369,9 @@ export class UserClient extends BaseClient {
                 args: [params.target, params.value, params.data]
             });
             // 3. Delegate to PaymasterClient for v0.7 Gasless Submission
+            // This ensures we follow the exact same logic as successful demo scripts
             // We dynamic import to avoid circular dependencies if any
-            const { PaymasterClient: SDKPaymasterClient } = await import('../../paymaster/src/V4/PaymasterClient.js');
+            const { PaymasterClient: SDKPaymasterClient } = await import('@aastar/paymaster');
             let verificationGasLimit;
             let paymasterVerificationGasLimit;
             let paymasterPostOpGasLimit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aastar/enduser",
-  "version": "0.16.16",
+  "version": "0.16.19",
   "publishConfig": {
     "access": "public"
   },
@@ -20,7 +20,8 @@
   "license": "MIT",
   "dependencies": {
     "viem": "2.43.3",
-    "@aastar/core": "0.16.16"
+    "@aastar/core": "0.16.19",
+    "@aastar/paymaster": "0.16.19"
   },
   "devDependencies": {
     "typescript": "5.7.2",

package/dist/paymaster/src/V4/BundlerCompat.d.ts

@@ -1,28 +0,0 @@
-import { type Address } from 'viem';
-/**
- * Bundler types we support
- */
-export declare enum BundlerType {
-    ALCHEMY = "alchemy",
-    PIMLICO = "pimlico",
-    STACKUP = "stackup",
-    CANDIDE = "candide",
-    UNKNOWN = "unknown"
-}
-/**
- * Detect bundler type from URL
- */
-export declare function detectBundlerType(bundlerUrl: string): BundlerType;
-/**
- * Minimal interface to satisfy basic Pimlico/Bundler needs
- * without bringing in heavy permissionless types that might conflict
- */
-export interface BundlerConfig {
-    type: BundlerType;
-    url: string;
-    entryPoint: Address;
-}
-/**
- * Create a bundler client config
- */
-export declare function createBundlerClient(bundlerUrl: string, entryPoint: Address): BundlerConfig;

package/dist/paymaster/src/V4/BundlerCompat.js

@@ -1,37 +0,0 @@
-/**
- * Bundler types we support
- */
-export var BundlerType;
-(function (BundlerType) {
-    BundlerType["ALCHEMY"] = "alchemy";
-    BundlerType["PIMLICO"] = "pimlico";
-    BundlerType["STACKUP"] = "stackup";
-    BundlerType["CANDIDE"] = "candide";
-    BundlerType["UNKNOWN"] = "unknown";
-})(BundlerType || (BundlerType = {}));
-/**
- * Detect bundler type from URL
- */
-export function detectBundlerType(bundlerUrl) {
-    const url = bundlerUrl.toLowerCase();
-    if (url.includes('alchemy.com'))
-        return BundlerType.ALCHEMY;
-    if (url.includes('pimlico.io'))
-        return BundlerType.PIMLICO;
-    if (url.includes('stackup'))
-        return BundlerType.STACKUP;
-    if (url.includes('candide.dev'))
-        return BundlerType.CANDIDE;
-    return BundlerType.UNKNOWN;
-}
-/**
- * Create a bundler client config
- */
-export function createBundlerClient(bundlerUrl, entryPoint) {
-    const bundlerType = detectBundlerType(bundlerUrl);
-    return {
-        type: bundlerType,
-        url: bundlerUrl,
-        entryPoint
-    };
-}

package/dist/paymaster/src/V4/PaymasterClient.d.ts

@@ -1,89 +0,0 @@
-import { type Address, type Hex } from 'viem';
-/**
- * PaymasterClient
- * Focus: Integration, Funding, Interaction.
- */
-export declare class PaymasterClient {
-    /**
-     * @private
-     * Static utility class, should not be instantiated.
-     */
-    private constructor();
-    /**
-     * Get user's deposited balance on the Paymaster.
-     */
-    static getDepositedBalance(publicClient: any, address: Address, user: Address, token: Address): Promise<bigint>;
-    /**
-     * Deposit tokens to Paymaster for a user (enables gasless transactions).
-     */
-    static depositFor(wallet: any, address: Address, user: Address, token: Address, amount: bigint): Promise<any>;
-    /**
-     * Approve the Paymaster (or any spender) to spend gas tokens.
-     */
-    static approveGasToken(wallet: any, token: Address, spender: Address, amount: bigint): Promise<any>;
-    /**
-     * Estimate Gas for a UserOperation.
-     */
-    static estimateUserOperationGas(client: any, wallet: any, aaAddress: Address, entryPoint: Address, paymasterAddress: Address, token: Address, bundlerUrl: string, callData: `0x${string}`, options?: {
-        validityWindow?: number;
-        operator?: Address;
-        factory?: Address;
-        factoryData?: Hex;
-    }): Promise<{
-        preVerificationGas: bigint;
-        verificationGasLimit: bigint;
-        callGasLimit: bigint;
-        paymasterVerificationGasLimit: bigint | undefined;
-        paymasterPostOpGasLimit: bigint;
-    }>;
-    /**
-     * High-level API to submit a gasless UserOperation.
-     * Automatically handles nonce fetching, gas estimation (if not provided), signing, and submission.
-     */
-    static submitGaslessUserOperation(client: any, wallet: any, aaAddress: Address, entryPoint: Address, paymasterAddress: Address, token: Address, bundlerUrl: string, callData: `0x${string}`, options?: {
-        validityWindow?: number;
-        verificationGasLimit?: bigint;
-        callGasLimit?: bigint;
-        preVerificationGas?: bigint;
-        maxFeePerGas?: bigint;
-        maxPriorityFeePerGas?: bigint;
-        autoEstimate?: boolean;
-        operator?: Address;
-        paymasterVerificationGasLimit?: bigint;
-        paymasterPostOpGasLimit?: bigint;
-        factory?: Address;
-        factoryData?: Hex;
-    }): Promise<`0x${string}`>;
-    /**
-     * Helper to extract the actual Gas Token fee from a UserOperation receipt.
-     * Looks for the 'PostOpProcessed' event emitted by the Paymaster.
-     */
-    static getFeeFromReceipt(receipt: any, paymasterAddress: Address): {
-        tokenCost: bigint;
-        actualGasCostWei: bigint;
-    } | null;
-    /**
-     * Get the fee for a specific transaction hash.
-     * Fetches the receipt (no scanning required) and decodes the log.
-     */
-    static getTransactionFee(publicClient: any, txHash: `0x${string}`, paymasterAddress: Address): Promise<{
-        tokenCost: bigint;
-        actualGasCostWei: bigint;
-    } | null>;
-    /**
-     * Helper: Encode a standardized ERC-20 Transfer.
-     * Returns the raw function data: `transfer(to, amount)`
-     */
-    static encodeTokenTransfer(recipient: Address, amount: bigint): `0x${string}`;
-    /**
-     * Helper: Encode a SimpleAccount execution.
-     * Wraps the inner call into: `execute(target, value, data)`
-     * This is the payload signed by the user.
-     */
-    static encodeExecution(target: Address, value: bigint, data: `0x${string}`): `0x${string}`;
-    /**
-     * More robust version of waitForUserOperationReceipt.
-     * Catches timeouts and returns a cleaner result.
-     */
-    static waitForUserOperation(bundlerClient: any, hash: `0x${string}`, timeout?: number): Promise<any>;
-}

package/dist/paymaster/src/V4/PaymasterClient.js

@@ -1,413 +0,0 @@
-import { parseAbi, concat, pad, toHex, encodeFunctionData } from 'viem';
-import { buildPaymasterData, buildSuperPaymasterData, formatUserOpV07, getUserOpHashV07 } from './PaymasterUtils.js';
-import { detectBundlerType } from './BundlerCompat.js';
-/**
- * PaymasterClient
- * Focus: Integration, Funding, Interaction.
- */
-export class PaymasterClient {
-    /**
-     * @private
-     * Static utility class, should not be instantiated.
-     */
-    constructor() { }
-    /**
-     * Get user's deposited balance on the Paymaster.
-     */
-    static async getDepositedBalance(publicClient, address, user, token) {
-        return publicClient.readContract({
-            address,
-            abi: [{
-                    name: 'balances',
-                    type: 'function',
-                    inputs: [
-                        { name: 'user', type: 'address' },
-                        { name: 'token', type: 'address' }
-                    ],
-                    outputs: [{ name: '', type: 'uint256' }],
-                    stateMutability: 'view'
-                }],
-            functionName: 'balances',
-            args: [user, token]
-        });
-    }
-    /**
-     * Deposit tokens to Paymaster for a user (enables gasless transactions).
-     */
-    static async depositFor(wallet, address, user, token, amount) {
-        return wallet.writeContract({
-            address,
-            abi: parseAbi(['function depositFor(address user, address token, uint256 amount) external']),
-            functionName: 'depositFor',
-            args: [user, token, amount],
-            chain: wallet.chain
-        });
-    }
-    /**
-     * Approve the Paymaster (or any spender) to spend gas tokens.
-     */
-    static async approveGasToken(wallet, token, spender, amount) {
-        return wallet.writeContract({
-            address: token,
-            abi: parseAbi(['function approve(address spender, uint256 amount) external returns (bool)']),
-            functionName: 'approve',
-            args: [spender, amount],
-            chain: wallet.chain
-        });
-    }
-    /**
-     * Estimate Gas for a UserOperation.
-     */
-    static async estimateUserOperationGas(client, wallet, aaAddress, entryPoint, paymasterAddress, token, bundlerUrl, callData, options) {
-        // 0. Check cachedPrice (Critical for Paymaster V4)
-        if (!options?.operator) { // Only for Paymaster V4, not SuperPaymaster
-            try {
-                const cache = await client.readContract({
-                    address: paymasterAddress,
-                    abi: parseAbi(['function cachedPrice() view returns (uint208 price, uint48 updatedAt)']),
-                    functionName: 'cachedPrice'
-                });
-                if (!cache || cache.price === 0n || cache[0] === 0n) {
-                    console.log('[PaymasterClient] ⚠️  cachedPrice is 0! Auto-initializing...');
-                    // Check if we're on testnet (chainId 11155111 = Sepolia, 11155420 = OP Sepolia)
-                    const chainId = client.chain?.id || await client.getChainId();
-                    const isTestnet = [11155111, 11155420, 31337].includes(chainId);
-                    if (isTestnet) {
-                        // Auto-call updatePrice on testnet
-                        const updateHash = await wallet.writeContract({
-                            address: paymasterAddress,
-                            abi: parseAbi(['function updatePrice() external']),
-                            functionName: 'updatePrice'
-                        });
-                        await client.waitForTransactionReceipt({ hash: updateHash });
-                        console.log('[PaymasterClient] ✅ cachedPrice initialized via updatePrice()');
-                    }
-                    else {
-                        // Mainnet: throw error, require Keeper
-                        throw new Error(`Paymaster cachedPrice is 0 on Mainnet (chainId: ${chainId}). ` +
-                            `This requires Keeper to call updatePrice(). Please ensure Keeper is running.`);
-                    }
-                }
-            }
-            catch (e) {
-                // If error is our mainnet check, re-throw
-                if (e.message?.includes('requires Keeper'))
-                    throw e;
-                // Otherwise log and continue (might be old Paymaster without cachedPrice)
-                console.log('[PaymasterClient] ⚠️  Failed to check cachedPrice:', e.message?.slice(0, 50));
-            }
-        }
-        // 1. Construct a dummy UserOp for estimation
-        let paymasterAndData;
-        if (options?.operator) {
-            paymasterAndData = buildSuperPaymasterData(paymasterAddress, options.operator, {
-                verificationGasLimit: 300000n,
-                postOpGasLimit: 300000n
-            });
-        }
-        else {
-            paymasterAndData = buildPaymasterData(paymasterAddress, token, {
-                validityWindow: options?.validityWindow,
-                verificationGasLimit: 250000n,
-                postOpGasLimit: 150000n
-            });
-        }
-        // 1.5. Get dynamic gas prices from network
-        let maxFeePerGas = 30000000000n; // 30 Gwei default
-        let maxPriorityFeePerGas = 1000000000n; // 1 Gwei default
-        try {
-            const feeData = await client.estimateFeesPerGas();
-            maxFeePerGas = (feeData.maxFeePerGas ?? 30000000000n) * 150n / 100n; // 1.5x buffer
-            maxPriorityFeePerGas = (feeData.maxPriorityFeePerGas ?? 1000000000n) * 150n / 100n;
-            if (maxPriorityFeePerGas < 500000000n)
-                maxPriorityFeePerGas = 500000000n; // Min 0.5 Gwei
-        }
-        catch (e) {
-            // Use defaults if estimation fails
-        }
-        const partialUserOp = {
-            sender: aaAddress,
-            nonce: 0n,
-            initCode: (options?.factory && options?.factoryData)
-                ? concat([options.factory, options.factoryData])
-                : '0x',
-            callData,
-            accountGasLimits: concat([pad(toHex(250000n), { size: 16 }), pad(toHex(500000n), { size: 16 })]),
-            preVerificationGas: 100000n,
-            gasFees: concat([pad(toHex(maxPriorityFeePerGas), { size: 16 }), pad(toHex(maxFeePerGas), { size: 16 })]),
-            paymasterAndData,
-            signature: '0x'
-        };
-        // Get actual nonce
-        try {
-            const nonce = await client.readContract({
-                address: aaAddress,
-                abi: parseAbi(['function getNonce() view returns (uint256)']),
-                functionName: 'getNonce'
-            });
-            partialUserOp.nonce = BigInt(nonce);
-        }
-        catch (e) { }
-        const userOpHash = getUserOpHashV07(partialUserOp, entryPoint, BigInt(client.chain.id));
-        partialUserOp.signature = (await wallet.account.signMessage({ message: { raw: userOpHash } }));
-        const payload = {
-            jsonrpc: '2.0',
-            id: 1,
-            method: 'eth_estimateUserOperationGas',
-            params: [formatUserOpV07(partialUserOp), entryPoint]
-        };
-        const response = await fetch(bundlerUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload, (_, v) => typeof v === 'bigint' ? '0x' + v.toString(16) : v)
-        });
-        const result = await response.json();
-        // Debug logging for Candide
-        if (bundlerUrl.includes('candide')) {
-            console.log('[PaymasterClient] Candide Request:', JSON.stringify(payload.params[0], null, 2));
-            console.log('[PaymasterClient] Candide Response:', JSON.stringify(result, null, 2));
-        }
-        const data = result.result;
-        // Debug logging for estimation
-        console.log('[PaymasterClient] Gas Estimation Result:', JSON.stringify(data, null, 2));
-        // Anvil Fallback for Estimation
-        if (result.error && (result.error.code === -32601 || result.error.message?.includes('Method not found'))) {
-            console.log('[PaymasterClient] EstimateUserOp failed (Method not found). Using Anvil defaults.');
-            return {
-                preVerificationGas: 100000n,
-                verificationGasLimit: 1000000n,
-                callGasLimit: 2000000n,
-                paymasterVerificationGasLimit: 100000n,
-                paymasterPostOpGasLimit: 100000n
-            };
-        }
-        if (result.error)
-            throw new Error(`Estimation Error: ${JSON.stringify(result.error)}`);
-        // Dynamic tuning: use estimated values directly to maintain efficiency
-        // Bundler efficiency check: actual_used / limit >= 0.4
-        return {
-            preVerificationGas: BigInt(data.preVerificationGas),
-            verificationGasLimit: BigInt(data.verificationGasLimit), // Use estimate as-is for efficiency
-            callGasLimit: (BigInt(data.callGasLimit) * 110n) / 100n, // Small 1.1x buffer
-            paymasterVerificationGasLimit: data.paymasterVerificationGasLimit ? BigInt(data.paymasterVerificationGasLimit) : undefined,
-            paymasterPostOpGasLimit: data.paymasterPostOpGasLimit ? BigInt(data.paymasterPostOpGasLimit) : 100000n
-        };
-    }
-    /**
-     * High-level API to submit a gasless UserOperation.
-     * Automatically handles nonce fetching, gas estimation (if not provided), signing, and submission.
-     */
-    static async submitGaslessUserOperation(client, wallet, aaAddress, entryPoint, paymasterAddress, token, bundlerUrl, callData, options) {
-        // 0. Auto-Estimate if requested or if limits missing
-        let gasLimits = {
-            preVerificationGas: options?.preVerificationGas,
-            verificationGasLimit: options?.verificationGasLimit,
-            callGasLimit: options?.callGasLimit,
-            paymasterVerificationGasLimit: options?.paymasterVerificationGasLimit,
-            paymasterPostOpGasLimit: options?.paymasterPostOpGasLimit ?? 150000n
-        };
-        if (options?.autoEstimate !== false && (!gasLimits.verificationGasLimit || !gasLimits.callGasLimit)) {
-            const est = await this.estimateUserOperationGas(client, wallet, aaAddress, entryPoint, paymasterAddress, token, bundlerUrl, callData, {
-                validityWindow: options?.validityWindow,
-                operator: options?.operator,
-                factory: options?.factory,
-                factoryData: options?.factoryData
-            });
-            gasLimits.preVerificationGas = options?.preVerificationGas ?? est.preVerificationGas;
-            gasLimits.verificationGasLimit = options?.verificationGasLimit ?? est.verificationGasLimit;
-            gasLimits.callGasLimit = options?.callGasLimit ?? est.callGasLimit;
-            gasLimits.paymasterVerificationGasLimit = options?.paymasterVerificationGasLimit ?? est.paymasterVerificationGasLimit;
-            gasLimits.paymasterPostOpGasLimit = options?.paymasterPostOpGasLimit ?? est.paymasterPostOpGasLimit;
-        }
-        // 1. Get Nonce
-        const nonce = await client.readContract({
-            address: aaAddress,
-            abi: parseAbi(['function getNonce() view returns (uint256)']),
-            functionName: 'getNonce'
-        });
-        // 1.5 Get Gas Prices from Network if not provided
-        let maxFeePerGas = options?.maxFeePerGas;
-        let maxPriorityFeePerGas = options?.maxPriorityFeePerGas;
-        if (!maxFeePerGas || !maxPriorityFeePerGas) {
-            try {
-                const feeData = await client.estimateFeesPerGas();
-                // Apply 1.5x buffer for network volatility
-                maxFeePerGas = maxFeePerGas ?? ((feeData.maxFeePerGas ?? 30000000000n) * 150n) / 100n;
-                maxPriorityFeePerGas = maxPriorityFeePerGas ?? ((feeData.maxPriorityFeePerGas ?? 1000000000n) * 150n) / 100n;
-                if (maxPriorityFeePerGas < 500000000n) {
-                    console.log(`[PaymasterClient] Priority Fee ${maxPriorityFeePerGas} too low, clamping to 0.5 Gwei`);
-                    maxPriorityFeePerGas = 500000000n; // Min 0.5 Gwei
-                }
-                // Ensure MaxFee >= Priority
-                if (maxFeePerGas < maxPriorityFeePerGas) {
-                    maxFeePerGas = maxPriorityFeePerGas + 1000000n; // Add small buffer
-                    console.log(`[PaymasterClient] MaxFee bumped to accommodate Priority Fee`);
-                }
-                console.log(`[PaymasterClient] Fees Set: MaxFee=${maxFeePerGas}, Priority=${maxPriorityFeePerGas}`);
-            }
-            catch (e) {
-                console.log('[PaymasterClient] Fee Estimation Failed:', e);
-                // Fallback to safer defaults if estimation fails
-                maxFeePerGas = maxFeePerGas ?? 50000000000n; // 50 Gwei
-                maxPriorityFeePerGas = maxPriorityFeePerGas ?? 2000000000n; // 2 Gwei
-            }
-        }
-        // 2. Build paymasterAndData
-        let paymasterAndData;
-        if (options?.operator) {
-            paymasterAndData = buildSuperPaymasterData(paymasterAddress, options.operator, {
-                verificationGasLimit: gasLimits.paymasterVerificationGasLimit ?? gasLimits.verificationGasLimit ?? 150000n,
-                postOpGasLimit: gasLimits.paymasterPostOpGasLimit ?? 100000n
-            });
-        }
-        else {
-            // MATH: Target Efficiency = PVG / (PVG + VGL + PMVGL) >= 0.4
-            // Since PVG is ~100k, (VGL + PMVGL) must be <= 150k.
-            // We set each to 75k to safely pass the 0.4 efficiency guard.
-            const pmVerGas = 75000n;
-            paymasterAndData = buildPaymasterData(paymasterAddress, token, {
-                validityWindow: options?.validityWindow,
-                verificationGasLimit: pmVerGas,
-                postOpGasLimit: gasLimits.paymasterPostOpGasLimit ?? 100000n
-            });
-        }
-        // 3. Construct UserOp
-        const userOp = {
-            sender: aaAddress,
-            nonce: BigInt(nonce),
-            initCode: (options?.factory && options?.factoryData)
-                ? concat([options.factory, options.factoryData])
-                : '0x',
-            callData,
-            accountGasLimits: concat([
-                pad(toHex(75000n), { size: 16 }), // Verification (Tuned for 0.4 efficiency)
-                pad(toHex(gasLimits.callGasLimit ?? 500000n), { size: 16 }) // Call
-            ]),
-            preVerificationGas: gasLimits.preVerificationGas ?? 50000n,
-            gasFees: concat([
-                pad(toHex(maxPriorityFeePerGas), { size: 16 }),
-                pad(toHex(maxFeePerGas), { size: 16 })
-            ]),
-            paymasterAndData,
-            signature: '0x'
-        };
-        // Debug logs (Commented out for production)
-        /*
-        console.log("DEBUG: UserOp Gas Limits:", {
-            accountGasLimits: userOp.accountGasLimits,
-            preVerificationGas: userOp.preVerificationGas,
-            gasFees: userOp.gasFees,
-            paymasterAndData: userOp.paymasterAndData
-        });
-        */
-        // 4. Final Hashing and Signing
-        const userOpHash = getUserOpHashV07(userOp, entryPoint, BigInt(client.chain.id));
-        const signature = (await wallet.account.signMessage({ message: { raw: userOpHash } }));
-        userOp.signature = signature;
-        // 6. Submit to Bundler (Unified JSON-RPC)
-        const bundlerType = detectBundlerType(bundlerUrl);
-        console.log(`[PaymasterClient] Using ${bundlerType} Bundler`);
-        // Use standard JSON-RPC for all bundlers (Pimlico/Alchemy/Stackup/etc)
-        const response = await fetch(bundlerUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'eth_sendUserOperation',
-                params: [formatUserOpV07(userOp), entryPoint]
-            }, (_, v) => typeof v === 'bigint' ? '0x' + v.toString(16) : v)
-        });
-        const result = await response.json();
-        if (result.error && (result.error.code === -32601 || result.error.message?.includes('Method not found'))) {
-            console.log('[PaymasterClient] SendUserOp failed (Method not found). Falling back to direct handleOps...');
-            const caller = wallet.account?.address ? wallet.account.address : wallet.account;
-            return await wallet.writeContract({
-                address: entryPoint,
-                abi: parseAbi(['function handleOps((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)[], address) external']),
-                functionName: 'handleOps',
-                args: [[userOp], caller],
-                chain: wallet.chain,
-                account: wallet.account
-            });
-        }
-        if (result.error)
-            throw new Error(`Bundler Error: ${JSON.stringify(result.error)}`);
-        console.log('[PaymasterClient] ✅ Submitted via', bundlerType, 'hash:', result.result);
-        return result.result;
-    }
-    /**
-     * Helper to extract the actual Gas Token fee from a UserOperation receipt.
-     * Looks for the 'PostOpProcessed' event emitted by the Paymaster.
-     */
-    static getFeeFromReceipt(receipt, paymasterAddress) {
-        // Event Signature: PostOpProcessed(address indexed user, address indexed token, uint256 actualGasCostWei, uint256 tokenCost, uint256 protocolRevenue)
-        // Topic0: 0x62544d7f48b11c32334310ebd306b47224fca220163218d4a7264322c52ae073
-        const TOPIC_POST_OP = '0x62544d7f48b11c32334310ebd306b47224fca220163218d4a7264322c52ae073';
-        for (const log of receipt.logs) {
-            if (log.address.toLowerCase() === paymasterAddress.toLowerCase() && log.topics[0] === TOPIC_POST_OP) {
-                // Decode Data: actualGasCostWei, tokenCost, protocolRevenue (3x uint256)
-                // We manually decode or use viem's decodeEventLog if available.
-                // Here we use a lightweight manual decode for the data part (non-indexed).
-                // Data is 3 * 32 bytes.
-                const data = log.data.replace('0x', '');
-                if (data.length >= 192) { // 3 * 64 hex chars = 192
-                    const actualGasCostWei = BigInt('0x' + data.slice(0, 64));
-                    const tokenCost = BigInt('0x' + data.slice(64, 128));
-                    // const protocolRevenue = BigInt('0x' + data.slice(128, 192));
-                    return { tokenCost, actualGasCostWei };
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Get the fee for a specific transaction hash.
-     * Fetches the receipt (no scanning required) and decodes the log.
-     */
-    static async getTransactionFee(publicClient, txHash, paymasterAddress) {
-        const receipt = await publicClient.getTransactionReceipt({ hash: txHash });
-        return this.getFeeFromReceipt(receipt, paymasterAddress);
-    }
-    // ===========================================
-    // 🛠️ Semantic CallData Builders (For DX)
-    // ===========================================
-    /**
-     * Helper: Encode a standardized ERC-20 Transfer.
-     * Returns the raw function data: `transfer(to, amount)`
-     */
-    static encodeTokenTransfer(recipient, amount) {
-        return encodeFunctionData({
-            abi: parseAbi(['function transfer(address to, uint256 amount) external returns (bool)']),
-            functionName: 'transfer',
-            args: [recipient, amount]
-        });
-    }
-    /**
-     * Helper: Encode a SimpleAccount execution.
-     * Wraps the inner call into: `execute(target, value, data)`
-     * This is the payload signed by the user.
-     */
-    static encodeExecution(target, value, data) {
-        return encodeFunctionData({
-            abi: parseAbi(['function execute(address dest, uint256 value, bytes func) external']),
-            functionName: 'execute',
-            args: [target, value, data]
-        });
-    }
-    /**
-     * More robust version of waitForUserOperationReceipt.
-     * Catches timeouts and returns a cleaner result.
-     */
-    static async waitForUserOperation(bundlerClient, hash, timeout = 60000) {
-        try {
-            return await bundlerClient.waitForUserOperationReceipt({ hash, timeout });
-        }
-        catch (error) {
-            if (error.name === 'TimeoutError' || error.message?.includes('timed out')) {
-                return { timeout: true, hash };
-            }
-            throw error;
-        }
-    }
-}