@aastar/sdk 0.16.6 → 0.16.11

package/packages/sdk/src/clients/operator.ts

@@ -6,31 +6,24 @@ import {
     RegistryABI,
     superPaymasterActions,
 
-    paymasterV4Actions,
+    paymasterActions,
     PaymasterFactoryABI,
-    tokenActions,
     type StakingActions, 
     type RegistryActions,
     type SuperPaymasterActions,
-    type PaymasterV4Actions,
-    type TokenActions,
+    type PaymasterActions,
     CORE_ADDRESSES,
     TEST_TOKEN_ADDRESSES,
-    TEST_ACCOUNT_ADDRESSES,
-    validateAddress,
-    validateAmount,
-    validateHex,
-    SuperPaymasterABI
+    TEST_ACCOUNT_ADDRESSES
 } from '@aastar/core';
 import { RoleDataFactory } from '../utils/roleData.js';
-import { AAStarError, AAStarErrorCode as AAStarErrorType, createError } from '../errors/AAStarError.js';
-import { decodeContractEvents, logDecodedEvents, type DecodedEvent } from '../utils/eventDecoder.js';
+import { decodeContractError } from '../errors/decoder.js';
 
-export type OperatorClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SuperPaymasterActions & PaymasterV4Actions & StakingActions & TokenActions & {
+export type OperatorClient = Client<Transport, Chain, Account | undefined> & PublicActions<Transport, Chain, Account | undefined> & WalletActions<Chain, Account | undefined> & RegistryActions & SuperPaymasterActions & PaymasterActions & StakingActions & {
     /**
      * High-level API: Setup operator with automatic funding and onboarding
      */
-    setup: (args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) => Promise<{ txs: { hash: Hash, events: DecodedEvent[] }[] }>;
+    setup: (args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) => Promise<{ txs: Hash[] }>;
     deployPaymasterV4: (args?: { version?: string, initData?: Hex }) => Promise<Hash>;
     /**
      * Orchestrates the full onboarding flow:
@@ -39,22 +32,10 @@ export type OperatorClient = Client<Transport, Chain, Account | undefined> & Pub
      * 3. Approve aPNTs (Deposit)
      * 4. Deposit aPNTs (SuperPaymaster)
      */
-    onboardFully: (args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex, gasTokens?: Address[] }) => Promise<{ hash: Hash, events: DecodedEvent[] }[]>;
-    /** @deprecated Use onboardFully */
-    onboardOperator: (args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) => Promise<{ hash: Hash, events: DecodedEvent[] }[]>;
-    configureOperator: (args: { xPNTsToken: Address, treasury: Address, exchangeRate: bigint, account?: Account | Address }) => Promise<Hash>;
-    
-    /**
-     * 🧙 Wisdom: Check if operator is ready and compliant.
-     */
-    checkReadiness: () => Promise<{
-        isRegistered: boolean;
-        isConfigured: boolean;
-        collateralBalance: bigint;
-        isPaused: boolean;
-        roleStatus: boolean;
-    }>;
-
+    onboardOperator: (args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) => Promise<Hash[]>;
+    /** @deprecated Use onboardOperator */
+    onboardToSuperPaymaster: (args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex }) => Promise<Hash[]>
+    configureOperator: (args: { xPNTsToken: Address, treasury: Address, exchangeRate: bigint, account?: Account | Address }) => Promise<Hash>
     getOperatorStatus: (accountAddress: Address) => Promise<{
         type: 'super' | 'v4' | null;
         superPaymaster: {
@@ -68,12 +49,7 @@ export type OperatorClient = Client<Transport, Chain, Account | undefined> & Pub
             address: Address;
             balance: bigint;
         } | null;
-    }>;
-    isOperator: (operator: Address) => Promise<boolean>;
-    getDepositDetails: () => Promise<{ deposit: bigint }>;
-    
-    // 🎨 Simplified Aliases (High-level)
-    deposit: (args: { amount: bigint, account?: Account | Address }) => Promise<Hash>;
+    }>
 };
 
 
@@ -101,45 +77,43 @@ export function createOperatorClient({
     const spActions = superPaymasterActions(usedAddresses.superPaymaster)(client as any);
     const regActions = registryActions(usedAddresses.registry)(client as any);
     const stkActions = stakingActions(usedAddresses.gTokenStaking)(client as any);
-    const p4Actions = paymasterV4Actions(usedAddresses.paymasterV4)(client as any);
-    const tokActions = tokenActions()(client as any);
+    const pmV4Actions = paymasterActions(usedAddresses.paymasterV4)(client as any);
 
     const actions = {
-        ...client,
-        ...publicActions(client),
-        ...walletActions(client),
-        ...regActions,
-        ...spActions,
-        ...p4Actions,
         ...stkActions,
-        ...tokActions,
+        ...spActions,
+        ...pmV4Actions,
+        ...regActions,
 
         async setup(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) {
             console.log('⚙️ Setting up operator...');
-            const txs = await this.onboardFully(args);
+            const txs = await (this as any)._onboardOperator(args);
             console.log(`✅ Operator setup complete! Transactions: ${txs.length}`);
             return { txs };
         },
-
         async onboardOperator(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) {
             return this.onboardFully(args);
         },
-
-        async onboardToSuperPaymaster(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex }) {
-            return this.onboardFully(args);
+        async onboardFully(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) {
+            return (this as any)._onboardOperator(args);
         },
-
-        async onboardFully(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex, gasTokens?: Address[] }) {
-            validateAmount(args.stakeAmount, 'Stake Amount');
-            validateAmount(args.depositAmount, 'Deposit Amount');
-            validateHex(args.roleId, 'Role ID');
-            if (args.gasTokens) {
-                args.gasTokens.forEach((token, index) => validateAddress(token, `Gas Token [${index}]`));
-            }
-
-            const results: { hash: Hash, events: DecodedEvent[] }[] = [];
+        async deployPaymasterV4({ version = 'v4.1', initData = '0x' }: { version?: string, initData?: Hex } = {}) {
+            console.log(`   SDK: Deploying Paymaster V4 (${version})...`);
+            const tx = await (client as any).writeContract({
+                address: usedAddresses.paymasterFactory,
+                abi: PaymasterFactoryABI,
+                functionName: 'deployPaymaster',
+                args: [version, initData],
+                account,
+                chain
+            });
+            await (client as any).waitForTransactionReceipt({ hash: tx });
+            return tx;
+        },
+        async _onboardOperator({ stakeAmount, depositAmount, roleId, roleData }: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex, roleData?: Hex }) {
+            const txs: Hash[] = [];
             const accountToUse = account; 
-            if (!accountToUse) throw createError.validation("Account", "Account required for onboarding");
+            if (!accountToUse) throw new Error("Account required for onboarding");
 
             try {
                 // 1. Fetch Entry Burn & Approve GToken
@@ -148,35 +122,35 @@ export function createOperatorClient({
                     address: usedAddresses.registry,
                     abi: RegistryABI,
                     functionName: 'roleConfigs',
-                    args: [args.roleId]
+                    args: [roleId]
                 }) as any; 
 
                 const entryBurn = roleConfig[1]; 
-                const totalStakeNeeded = args.stakeAmount + entryBurn;
-
-                console.log(`   SDK: Approving GToken (Stake: ${args.stakeAmount}, Burn: ${entryBurn})...`);
-                const approveStkTx = await tokActions.tokenApprove({
-                    token: usedAddresses.gToken,
-                    spender: usedAddresses.gTokenStaking,
-                    amount: totalStakeNeeded,
-                    account: accountToUse
+                const totalStakeNeeded = stakeAmount + entryBurn;
+
+                console.log(`   SDK: Approving GToken (Stake: ${stakeAmount}, Burn: ${entryBurn})...`);
+                const approveGToken = await (client as any).writeContract({
+                    address: usedAddresses.gToken,
+                    abi: erc20Abi,
+                    functionName: 'approve',
+                    args: [usedAddresses.gTokenStaking, totalStakeNeeded],
+                    account: accountToUse,
+                    chain
                 });
-                let receipt = await (client as any).waitForTransactionReceipt({ hash: approveStkTx });
-                let events = decodeContractEvents(receipt.logs);
-                logDecodedEvents(events);
-                results.push({ hash: approveStkTx, events });
+                await (client as any).waitForTransactionReceipt({ hash: approveGToken });
+                txs.push(approveGToken);
 
                 // 2. Register Role
                 let data: Hex;
-                if (args.roleData && args.roleData !== '0x') {
-                    data = args.roleData;
+                if (roleData && roleData !== '0x') {
+                    data = roleData;
                 } else {
-                    console.log(`   SDK: Auto-generating roleData for roleId ${args.roleId}...`);
-                    if (args.roleId === keccak256(stringToBytes('COMMUNITY'))) {
+                    console.log(`   SDK: Auto-generating roleData for roleId ${roleId}...`);
+                    if (roleId === keccak256(stringToBytes('COMMUNITY'))) {
                         data = RoleDataFactory.community();
-                    } else if (args.roleId === keccak256(stringToBytes('ENDUSER'))) {
+                    } else if (roleId === keccak256(stringToBytes('ENDUSER'))) {
                         data = RoleDataFactory.endUser();
-                    } else if (args.roleId === keccak256(stringToBytes('PAYMASTER_SUPER'))) {
+                    } else if (roleId === keccak256(stringToBytes('PAYMASTER_SUPER'))) {
                         data = RoleDataFactory.paymasterSuper();
                     } else {
                         data = RoleDataFactory.paymasterSuper();
@@ -184,96 +158,59 @@ export function createOperatorClient({
                 }
                 
                 console.log(`   SDK: Checking if role already granted...`);
-                const hasRoleResult = await regActions.registryHasRole({ 
-                    user: accountToUse!.address,
-                    roleId: args.roleId 
-                });
+                const hasRoleResult = await (client as any).readContract({
+                    address: usedAddresses.registry,
+                    abi: RegistryABI,
+                    functionName: 'hasRole',
+                    args: [roleId, accountToUse!.address]
+                }) as boolean;
 
                 if (hasRoleResult) {
                     console.log(`   ℹ️  Role already granted, skipping registration`);
                 } else {
-                    console.log(`   SDK: Registering role ${args.roleId}...`);
-                    const registerTx = await regActions.registryRegisterRoleSelf({
-                        roleId: args.roleId,
+                    console.log(`   SDK: Registering role ${roleId}...`);
+                    const registerTx = await actions.registerRoleSelf({
+                        roleId,
                         data, 
                         account: accountToUse
                     });
-                    const receipt = await (client as any).waitForTransactionReceipt({ hash: registerTx });
-                    const events = decodeContractEvents(receipt.logs);
-                    logDecodedEvents(events);
-                    results.push({ hash: registerTx, events });
+                    await (client as any).waitForTransactionReceipt({ hash: registerTx });
+                    txs.push(registerTx);
                 }
 
-                // 3. Deposit aPNTs
-                if (args.depositAmount > 0n) {
-                    console.log('   SDK: Depositing aPNTs via superPaymasterDepositFor...');
-                    const depositTx = await spActions.superPaymasterDepositFor({
-                        operator: accountToUse.address, 
-                        amount: args.depositAmount,
-                        account: accountToUse
+                if (depositAmount > 0n) {
+                    console.log('   SDK: Depositing aPNTs via depositFor...');
+                    const depositTx = await (client as any).writeContract({
+                        address: usedAddresses.superPaymaster,
+                        abi: parseAbi(['function depositFor(address targetOperator, uint256 amount) external']),
+                        functionName: 'depositFor',
+                        args: [accountToUse.address, depositAmount],
+                        account: accountToUse,
+                        chain
                     });
-                    const receipt = await (client as any).waitForTransactionReceipt({ hash: depositTx });
-                    const events = decodeContractEvents(receipt.logs);
-                    logDecodedEvents(events);
-                    results.push({ hash: depositTx, events });
+                    await (client as any).waitForTransactionReceipt({ hash: depositTx });
+                    txs.push(depositTx);
                 }
 
-                return results;
+                return txs;
             } catch (error) {
-                // const decodedMsg = decodeContractError(error);
-                // throw decodedMsg ? new Error(`Onboarding Failed: ${decodedMsg}`) : error;
-                throw error;
+                const decodedMsg = decodeContractError(error);
+                throw decodedMsg ? new Error(`Onboarding Failed: ${decodedMsg}`) : error;
             }
         },
-
-        async deployPaymasterV4({ version = 'v4.1', initData = '0x' }: { version?: string, initData?: Hex } = {}) {
-            console.log(`   SDK: Deploying Paymaster V4 (${version})...`);
-            const tx = await (client as any).writeContract({
-                address: usedAddresses.paymasterFactory,
-                abi: PaymasterFactoryABI,
-                functionName: 'deployPaymaster',
-                args: [version, initData],
-                account,
-                chain
-            });
-            await (client as any).waitForTransactionReceipt({ hash: tx });
-            return tx;
+        async onboardToSuperPaymaster(args: { stakeAmount: bigint, depositAmount: bigint, roleId: Hex }) {
+            return this.onboardOperator(args);
         },
-
         async configureOperator({ xPNTsToken, treasury, exchangeRate, account: accountOverride }: { xPNTsToken: Address, treasury: Address, exchangeRate: bigint, account?: Account | Address }) {
-            validateAddress(xPNTsToken, 'xPNTs Token');
-            validateAddress(treasury, 'Treasury');
-            validateAmount(exchangeRate, 'Exchange Rate');
-
-            const tx = await spActions.superPaymasterConfigureOperator({ 
+            const tx = await spActions.configureOperator({ 
                 xPNTsToken, 
-                treasury, 
+                opTreasury: treasury, 
                 exchangeRate,
                 account: accountOverride || account
             });
             await (client as any).waitForTransactionReceipt({ hash: tx });
             return tx;
         },
-
-        async checkReadiness() {
-            if (!account) throw createError.validation("Account", "Account required for readiness check");
-            const addr = account.address;
-            
-            const roleId = keccak256(stringToBytes('PAYMASTER_SUPER'));
-            const roleStatus = await regActions.registryHasRole({ user: addr, roleId });
-            
-            const operatorData = await spActions.superPaymasterOperators({ operator: addr });
-            // operators(address) returns (uint128 aPNTsBalance, uint96 exchangeRate, bool isConfigured, bool isPaused, ...)
-            
-            return {
-                isRegistered: roleStatus,
-                isConfigured: operatorData[2],
-                collateralBalance: operatorData[0],
-                isPaused: operatorData[3],
-                roleStatus
-            };
-        },
-
         async getOperatorStatus(accountAddress: Address) {
             try {
                 const hasRole = await client.readContract({
@@ -288,9 +225,10 @@ export function createOperatorClient({
                 let paymasterV4Info = null;
 
                 if (hasRole && usedAddresses.superPaymaster) {
+                    const pmAbi = parseAbi(['function operators(address) view returns (uint128 balance, uint96 exchangeRate, bool isConfigured, bool isPaused, address token, uint32 reputation, address treasury, uint256 spent, uint256 txSponsored)']);
                     const operatorData = await client.readContract({
                         address: usedAddresses.superPaymaster!,
-                        abi: SuperPaymasterABI,
+                        abi: pmAbi,
                         functionName: 'operators',
                         args: [accountAddress]
                     }) as any;
@@ -310,9 +248,10 @@ export function createOperatorClient({
                 // 检查 Paymaster V4 (Direct)
                 if (usedAddresses.paymasterFactory && usedAddresses.paymasterFactory !== '0x0000000000000000000000000000000000000000') {
                     try {
+                        const factoryAbi = parseAbi(['function getPaymasterByOperator(address) view returns (address)']);
                         const pmAddr = await client.readContract({
                             address: usedAddresses.paymasterFactory,
-                            abi: PaymasterFactoryABI,
+                            abi: factoryAbi,
                             functionName: 'getPaymasterByOperator',
                             args: [accountAddress]
                         }) as Address;
@@ -334,22 +273,8 @@ export function createOperatorClient({
                 console.error('Error in getOperatorStatus:', error);
                 return { type: null, superPaymaster: null, paymasterV4: null };
             }
-        },
-
-        async isOperator(operator: Address): Promise<boolean> {
-            const data = await spActions.superPaymasterOperators({ operator });
-            return data[2]; // isConfigured
-        },
-
-        async getDepositDetails(): Promise<{ deposit: bigint }> {
-            const deposit = await spActions.superPaymasterGetDeposit();
-            return { deposit };
-        },
-
-        async deposit(args: { amount: bigint, account?: Account | Address }) {
-            return this.superPaymasterDeposit(args);
         }
     };
 
-    return Object.assign(client, actions) as OperatorClient;
+    return Object.assign(client, actions) as unknown as OperatorClient;
 }

package/packages/sdk/src/errors/decoder.ts

@@ -1,91 +1,48 @@
-import { decodeErrorResult, type Hex } from 'viem';
-import { RegistryABI, SuperPaymasterABI, GTokenStakingABI, MySBTABI, xPNTsTokenABI } from '../index.js';
+import { decodeErrorResult, type Hex, type ContractFunctionExecutionError } from 'viem';
+import { RegistryABI } from '../index.js'; // Assuming RegistryABI is exported
 
-const ABIS_TO_TRY = [
-    { name: 'Registry', abi: RegistryABI },
-    { name: 'SuperPaymaster', abi: SuperPaymasterABI },
-    { name: 'GTokenStaking', abi: GTokenStakingABI },
-    { name: 'MySBT', abi: MySBTABI },
-    { name: 'xPNTsToken', abi: xPNTsTokenABI }
-];
+export const CustomErrors = {
+    RoleNotConfigured: 'RoleNotConfigured(bytes32,bool)',
+    RoleAlreadyGranted: 'RoleAlreadyGranted(bytes32,address)',
+    InsufficientStake: 'InsufficientStake(uint256,uint256)',
+} as const;
 
 export function decodeContractError(error: any): string | null {
-    if (!error) return null;
-
-    // 1. Try to extract data from various error structures (viem, common RPC)
-    let data: Hex | undefined;
-    
-    if (typeof error === 'object') {
-        // Walk for internal data (viem pattern)
-        if (error.walk) {
-            const internalError = error.walk((e: any) => e.data);
-            data = internalError?.data;
-        }
-        
-        // Fallback to direct properties
-        if (!data) {
-            data = error.data || (error.error && error.error.data) || (error.cause && error.cause.data);
-        }
-
-        // Handle nested data objects (common in some RPCs or viem errors)
-        if (data && typeof data === 'object') {
-            if ('data' in data && typeof (data as any).data === 'string') {
-                data = (data as any).data;
-            } else if ('object' in data && typeof (data as any).object === 'string') {
-                 // specific edge case
-                 data = (data as any).object as Hex;
-            }
-        }
-    }
-
-    if (!data) {
-        // Handle "contract reverted" or similar string errors
-        const msg = error.message || String(error);
-        if (msg.includes('reverted')) return msg;
-        return null;
-    }
-
-    // 2. Iterate through known ABIs to decode
-    for (const { name, abi } of ABIS_TO_TRY) {
-        try {
-            const decoded = decodeErrorResult({
-                abi: abi as any,
-                data: data as Hex
-            });
-
-            if (decoded) {
-                return formatDecodedError(name, decoded);
+    if (!error || typeof error !== 'object') return null;
+
+    // Check if it's a viem ContractFunctionExecutionError
+    if (error.name === 'ContractFunctionExecutionError' || error.walk) {
+        // Try to extract internal error data
+        const internalError = error.walk ? error.walk((e: any) => e.data) : error;
+        const data = internalError?.data;
+
+        if (data) {
+             try {
+                const decoded = decodeErrorResult({
+                    abi: RegistryABI,
+                    data: data as Hex
+                });
+                
+                if (decoded.errorName === 'RoleNotConfigured') {
+                    const [roleId, isActive] = decoded.args as [Hex, boolean];
+                    return `RoleNotConfigured: Role ${roleId} is ${isActive ? 'ACTIVE' : 'INACTIVE'} in Registry.`;
+                }
+                if (decoded.errorName === 'RoleAlreadyGranted') {
+                    const [roleId, user] = decoded.args as [Hex, string];
+                    return `RoleAlreadyGranted: User ${user} already has role ${roleId}.`;
+                }
+                if (decoded.errorName === 'InsufficientStake') {
+                     const [stake, minStake] = decoded.args as [bigint, bigint];
+                     // Viem returns bigints, format them?
+                     return `InsufficientStake: Provided ${stake}, Required ${minStake}.`;
+                }
+                
+                return `${decoded.errorName}: ${decoded.args}`;
+            } catch (e) {
+                // ABI mismatch or unknown error
+                return null;
             }
-        } catch (e) {
-            // Mismatch, continue to next ABI
         }
     }
-
-    return typeof data === 'string' 
-        ? `Unknown Error (data: ${data.slice(0, 10)}...)`
-        : `Unknown Error (non-string data: ${JSON.stringify(data, (_, v) => typeof v === 'bigint' ? v.toString() : v)})`;
-}
-
-function formatDecodedError(contractName: string, decoded: any): string {
-    const { errorName, args } = decoded;
-
-    // Specialized formatting for common errors
-    switch (errorName) {
-        case 'RoleNotConfigured':
-            return `[${contractName}] RoleNotConfigured: Role ${args[0]} is ${args[1] ? 'ACTIVE' : 'INACTIVE'}.`;
-        case 'RoleAlreadyGranted':
-            return `[${contractName}] RoleAlreadyGranted: User ${args[1]} already has role ${args[0]}.`;
-        case 'InsufficientStake':
-            return `[${contractName}] InsufficientStake: Provided ${args[0].toString()}, Required ${args[1].toString()}.`;
-        case 'InsufficientBalance':
-            return `[${contractName}] InsufficientBalance: Available ${args[0].toString()}, Required ${args[1].toString()}.`;
-        case 'InvalidParameter':
-            return `[${contractName}] InvalidParameter: ${args[0]}`;
-        case 'Unauthorized':
-            return `[${contractName}] Unauthorized: Caller does not have permission.`;
-        case 'RoleNotGranted':
-            return `[${contractName}] RoleNotGranted: User ${args[1]} does not have role ${args[0]}.`;
-        default:
-            return `[${contractName}] ${errorName}${args && args.length > 0 ? ': ' + JSON.stringify(args, (_, v) => typeof v === 'bigint' ? v.toString() : v) : ''}`;
-    }
+    return null;
 }

package/packages/sdk/src/index.ts

@@ -3,21 +3,22 @@ export * from '@aastar/account';
 export * from '@aastar/paymaster';
 export * from '@aastar/identity';
 export * from '@aastar/tokens';
+export * from '@aastar/tokens';
 export * from '@aastar/dapp';
+// export * from '@aastar/enduser'; // Commented to avoid CommunityClient conflict with clients/community.js
 
 // Export Role-Based Clients
-// Export Role-Based Clients
-export { createEndUserClient } from './clients/endUser.js';
-export { createOperatorClient } from './clients/operator.js';
-export { createCommunityClient } from './clients/community.js';
-export { createAdminClient } from './clients/admin.js';
+export * from './clients/endUser.js';
+export * from './clients/operator.js';
+export * from './clients/community.js';
+export * from './clients/admin.js';
 export * from './clients/ExperimentClient.js';
 
 // Export Utils & Errors
-export { AAStarError, AAStarErrorCode, createError } from './errors/AAStarError.js';
 export * from './utils/roleData.js';
+export * from './utils/keys.js';
+export * from './utils/funding.js';
 export * from './utils/userOp.js';
-export * from './utils/eventDecoder.js';
+export * from './utils/testScenarios.js';
+export * from './errors/decoder.js';
 
-// Export Types
-export * from './types/result.js';

package/packages/sdk/src/utils/keys.ts

@@ -3,13 +3,6 @@ import type { Hex, Address } from 'viem';
 import * as fs from 'fs';
 import * as path from 'path';
 
-/**
- * ⚠️ WARNING: TESTING & NODE.JS UTILITY ONLY ⚠️
- * 
- * This file uses Node.js 'fs' module and is NOT compatible with browsers.
- * It is intended for use in test scripts, CLI tools, and backend environments only.
- * DO NOT import this file in frontend/browser code.
- */
 /**
  * 密钥对接口
  */
@@ -164,11 +157,3 @@ export class KeyManager {
         console.log('─'.repeat(80));
     }
 }
-
-/**
- * 解析私钥，确保其带有 0x 前缀
- * @param key - 私钥字符串
- */
-export function parseKey(key: string): Hex {
-    return (key.startsWith('0x') ? key : `0x${key}`) as Hex;
-}

package/packages/sdk/src/utils/roleData.ts

@@ -104,14 +104,20 @@ export const RoleDataFactory = {
             data
         );
         const result = decoded[0] as any;
-        return { 
-            name: result.name, 
-            ensName: result.ensName, 
-            website: result.website, 
-            description: result.description, 
-            logoURI: result.logoURI, 
-            stakeAmount: result.stakeAmount 
-        };
+        // Check if result is array (iterable) or object
+        if (Array.isArray(result)) {
+             const [n, e, w, d, l, s] = result;
+             return { name: n, ensName: e, website: w, description: d, logoURI: l, stakeAmount: s };
+        } else {
+             return { 
+                name: result.name, 
+                ensName: result.ensName, 
+                website: result.website, 
+                description: result.description, 
+                logoURI: result.logoURI, 
+                stakeAmount: result.stakeAmount 
+            };
+        }
     },
 
     decodeEndUser: (data: Hex) => {
@@ -129,12 +135,17 @@ export const RoleDataFactory = {
             data
         );
         const result = decoded[0] as any;
-        return {
-            account: result.account,
-            community: result.community,
-            avatarURI: result.avatarURI,
-            ensName: result.ensName,
-            stakeAmount: result.stakeAmount
-        };
+        if (Array.isArray(result)) {
+            const [a, c, av, en, s] = result;
+            return { account: a, community: c, avatarURI: av, ensName: en, stakeAmount: s };
+        } else {
+            return {
+                account: result.account,
+                community: result.community,
+                avatarURI: result.avatarURI,
+                ensName: result.ensName,
+                stakeAmount: result.stakeAmount
+            };
+        }
     }
 };

package/packages/sdk/src/utils/testScenarios.ts

@@ -38,8 +38,8 @@ export class UserOpScenarioBuilder {
         const { 
             sender, ownerAccount, recipient, tokenAddress, amount, 
             entryPoint, chainId, publicClient, paymaster, operator,
-            paymasterGasLimit = 300000n,
-            paymasterPostOpGasLimit = 50000n,
+            paymasterGasLimit = 100000n,
+            paymasterPostOpGasLimit = 40000n,
             nonceKey = 0n,
             gasToken
         } = params;