@aastar/sdk 0.16.6 → 0.16.8

package/{packages/sdk/src/utils/errorHandler.ts → dist/sdk/src/utils/errorHandler.js}

@@ -1,97 +1,60 @@
 /**
  * SDK Error Handling Utilities
- * 
+ *
  * 提供统一的错误处理和上下文化错误消息
  */
-
-import type { Hex } from 'viem';
-
-/**
- * 合约错误类型
- */
-export interface ContractError extends Error {
-    data?: {
-        errorName?: string;
-        args?: any[];
-    };
-    cause?: any;
-    shortMessage?: string;
-    details?: string;
-}
-
-/**
- * SDK 错误上下文
- */
-export interface ErrorContext {
-    operation: string;      // 操作名称，如 "launch community", "setup operator"
-    account?: string;       // 相关账户地址
-    contract?: string;      // 相关合约地址
-    roleId?: Hex;          // 相关角色 ID
-    additionalInfo?: Record<string, any>;  // 其他上下文信息
-}
-
 /**
  * 已知的合约错误及其友好消息
  */
-const KNOWN_CONTRACT_ERRORS: Record<string, (context: ErrorContext, args?: any[]) => string> = {
+const KNOWN_CONTRACT_ERRORS = {
     'RoleAlreadyGranted': (ctx, args) => {
         const roleId = args?.[0] || ctx.roleId || 'unknown';
         const user = args?.[1] || ctx.account || 'unknown';
         return `Account ${user} already has this role (${roleId}). Please use a different account or exit the role first.`;
     },
-    
     'RoleNotConfigured': (ctx, args) => {
         const roleId = args?.[0] || ctx.roleId || 'unknown';
         return `Role ${roleId} is not configured in the Registry contract. Please configure the role first.`;
     },
-    
     'RoleNotGranted': (ctx, args) => {
         const roleId = args?.[0] || ctx.roleId || 'unknown';
         const user = args?.[1] || ctx.account || 'unknown';
         return `Account ${user} does not have role ${roleId}. Please register for this role first.`;
     },
-    
     'InsufficientStake': (ctx, args) => {
         const required = args?.[0] ? `Required: ${args[0]}` : '';
         const actual = args?.[1] ? `Actual: ${args[1]}` : '';
         return `Insufficient stake for this operation. ${required} ${actual}`.trim();
     },
-    
     'InsufficientBalance': (ctx, args) => {
         return `Insufficient balance. Please ensure you have enough tokens.`;
     },
-    
     'InvalidParameter': (ctx, args) => {
         const param = args?.[0] || 'unknown';
         return `Invalid parameter: ${param}. Please check your input.`;
     },
-    
     'Unauthorized': (ctx) => {
         return `Unauthorized operation. Account ${ctx.account || 'unknown'} does not have permission.`;
     },
-    
     'OwnableUnauthorizedAccount': (ctx, args) => {
         const account = args?.[0] || ctx.account || 'unknown';
         return `Account ${account} is not authorized to perform this operation. Only the contract owner can do this.`;
     }
 };
-
 /**
  * 从错误对象中提取错误名称
  */
-function extractErrorName(error: ContractError): string | null {
+function extractErrorName(error) {
     // 检查 error.data.errorName
     if (error.data?.errorName) {
         return error.data.errorName;
     }
-    
     // 检查 error.message 中的错误名称
     const message = error.message || '';
     const errorMatch = message.match(/Error: (\w+)\(/);
     if (errorMatch) {
         return errorMatch[1];
     }
-    
     // 检查序列化后的错误
     try {
         const errorString = JSON.stringify(error);
@@ -100,66 +63,50 @@ function extractErrorName(error: ContractError): string | null {
                 return knownError;
             }
         }
-    } catch {
+    }
+    catch {
         // Ignore serialization errors
     }
-    
     return null;
 }
-
 /**
  * 处理合约错误并返回友好的错误消息
- * 
+ *
  * @param error - 原始错误对象
  * @param context - 错误上下文
  * @returns 友好的错误消息
  */
-export function handleContractError(error: any, context: ErrorContext): Error {
-    const contractError = error as ContractError;
-    
+export function handleContractError(error, context) {
+    const contractError = error;
     // 提取错误名称
     const errorName = extractErrorName(contractError);
-    
     // 如果是已知错误，返回友好消息
     if (errorName && KNOWN_CONTRACT_ERRORS[errorName]) {
         const args = contractError.data?.args;
         const friendlyMessage = KNOWN_CONTRACT_ERRORS[errorName](context, args);
-        
         // 创建新错误，保留原始错误作为 cause
-        const enhancedError = new Error(
-            `Failed to ${context.operation}: ${friendlyMessage}`
-        );
-        (enhancedError as any).cause = error;
-        (enhancedError as any).originalError = error;
-        (enhancedError as any).errorName = errorName;
-        (enhancedError as any).context = context;
-        
+        const enhancedError = new Error(`Failed to ${context.operation}: ${friendlyMessage}`);
+        enhancedError.cause = error;
+        enhancedError.originalError = error;
+        enhancedError.errorName = errorName;
+        enhancedError.context = context;
         return enhancedError;
     }
-    
     // 未知错误，返回带上下文的原始错误消息
-    const originalMessage = contractError.message || 
-                           contractError.shortMessage || 
-                           contractError.details || 
-                           'Unknown error';
-    
-    const enhancedError = new Error(
-        `Failed to ${context.operation}: ${originalMessage}`
-    );
-    (enhancedError as any).cause = error;
-    (enhancedError as any).originalError = error;
-    (enhancedError as any).context = context;
-    
+    const originalMessage = contractError.message ||
+        contractError.shortMessage ||
+        contractError.details ||
+        'Unknown error';
+    const enhancedError = new Error(`Failed to ${context.operation}: ${originalMessage}`);
+    enhancedError.cause = error;
+    enhancedError.originalError = error;
+    enhancedError.context = context;
     return enhancedError;
 }
-
 /**
  * 创建错误上下文的辅助函数
  */
-export function createErrorContext(
-    operation: string,
-    options?: Partial<ErrorContext>
-): ErrorContext {
+export function createErrorContext(operation, options) {
     return {
         operation,
         ...options

package/dist/sdk/src/utils/errorHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{packages/sdk/src/utils/errorHandler.test.ts → dist/sdk/src/utils/errorHandler.test.js}

@@ -1,26 +1,22 @@
 import { describe, it, expect } from 'vitest';
 import { handleContractError } from './errorHandler.js';
-
 describe('ErrorHandler', () => {
     const MOCK_CTX = {
         operation: 'test operation',
-        roleId: '0xRole' as const,
+        roleId: '0xRole',
         account: '0xUser'
     };
-
     it('should enhance known contract errors', () => {
         const error = new Error('Execution reverted: Error: RoleNotGranted(0xabc, 0xdef)');
         const enhanced = handleContractError(error, MOCK_CTX);
         expect(enhanced.message).toContain('does not have role');
         expect(enhanced.message).toContain('Please register for this role first');
     });
-
     it('should use context if args missing', () => {
         const error = new Error('Execution reverted: Error: RoleNotGranted()');
         const enhanced = handleContractError(error, MOCK_CTX);
         expect(enhanced.message).toContain('0xUser does not have role 0xRole');
     });
-
     it('should extract error from message if data.errorName is missing', () => {
         // Simulate an error where data.errorName is missing but message contains relevant info
         const error = {
@@ -29,7 +25,6 @@ describe('ErrorHandler', () => {
         const enhanced = handleContractError(error, MOCK_CTX);
         expect(enhanced.message).toContain('is not configured in the Registry');
     });
-
     it('should handle all known contract errors', () => {
         const errors = [
             { name: 'RoleNotGranted', args: ['0xRole', '0xUser'], match: 'does not have role' },
@@ -39,7 +34,6 @@ describe('ErrorHandler', () => {
             { name: 'OwnableUnauthorizedAccount', args: ['0xUser'], match: 'not authorized' },
             { name: 'RoleNotConfigured', args: ['0xRole'], match: 'not configured' }
         ];
-
         for (const { name, args, match } of errors) {
             const error = {
                 data: { errorName: name, args },
@@ -49,7 +43,6 @@ describe('ErrorHandler', () => {
             expect(enhanced.message).toContain(match);
         }
     });
-
     it('should fallback to stringify matching', () => {
         // The implementation checks if JSON.stringify(error) includes known keys
         const weirdError = {
@@ -58,32 +51,27 @@ describe('ErrorHandler', () => {
         const enhanced = handleContractError(weirdError, MOCK_CTX);
         expect(enhanced.message).toContain('not configured');
     });
-
     it('should fallback for unknown error', () => {
         const error = new Error('Random connection failed');
         const enhanced = handleContractError(error, MOCK_CTX);
         expect(enhanced.message).toContain('Random connection failed');
     });
-
     it('should handle empty error object', () => {
         const enhanced = handleContractError({}, MOCK_CTX);
         expect(enhanced.message).toBe('Failed to test operation: Unknown error');
     });
-
     it('should prioritize args over context for RoleAlreadyGranted', () => {
         const enhanced = handleContractError({
             data: { errorName: 'RoleAlreadyGranted', args: ['0xArgRole', '0xArgUser'] }
         }, MOCK_CTX);
         expect(enhanced.message).toContain('Account 0xArgUser already has this role (0xArgRole)');
     });
-
     it('should use context if args missing for RoleAlreadyGranted', () => {
         const enhanced = handleContractError({
             data: { errorName: 'RoleAlreadyGranted', args: [] }
         }, MOCK_CTX);
         expect(enhanced.message).toContain(`Account ${MOCK_CTX.account} already has this role (${MOCK_CTX.roleId})`);
     });
-
     it('should prioritize args for InsufficientStake', () => {
         const enhanced = handleContractError({
             data: { errorName: 'InsufficientStake', args: [100n, 200n] }
@@ -91,7 +79,6 @@ describe('ErrorHandler', () => {
         expect(enhanced.message).toContain('Required: 100');
         expect(enhanced.message).toContain('Actual: 200');
     });
-
     it('should handle missing args for InsufficientStake', () => {
         const enhanced = handleContractError({
             data: { errorName: 'InsufficientStake', args: [] } // Missing args

package/dist/sdk/src/utils/eventDecoder.d.ts

@@ -0,0 +1,7 @@
+export interface DecodedEvent {
+    contractName: string;
+    eventName: string;
+    args: any;
+}
+export declare function decodeContractEvents(logs: any[]): DecodedEvent[];
+export declare function logDecodedEvents(events: DecodedEvent[]): void;

package/{packages/sdk/src/utils/eventDecoder.ts → dist/sdk/src/utils/eventDecoder.js}

@@ -1,6 +1,5 @@
-import { decodeEventLog, type Hex, type Abi } from 'viem';
+import { decodeEventLog } from 'viem';
 import { RegistryABI, SuperPaymasterABI, GTokenStakingABI, MySBTABI, xPNTsTokenABI, PaymasterFactoryABI } from '../index.js';
-
 const ABIS_TO_TRY = [
     { name: 'Registry', abi: RegistryABI },
     { name: 'SuperPaymaster', abi: SuperPaymasterABI },
@@ -9,30 +8,20 @@ const ABIS_TO_TRY = [
     { name: 'xPNTsToken', abi: xPNTsTokenABI },
     { name: 'PaymasterFactory', abi: PaymasterFactoryABI }
 ];
-
-export interface DecodedEvent {
-    contractName: string;
-    eventName: string;
-    args: any;
-}
-
-export function decodeContractEvents(logs: any[]): DecodedEvent[] {
-    const decodedEvents: DecodedEvent[] = [];
-
+export function decodeContractEvents(logs) {
+    const decodedEvents = [];
     for (const log of logs) {
         if (typeof log.data !== 'string' || !log.data.startsWith('0x')) {
             console.warn('   ⚠️ Skipping log with invalid data:', log);
-            continue; 
+            continue;
         }
-
         for (const { name, abi } of ABIS_TO_TRY) {
             try {
                 const decoded = decodeEventLog({
-                    abi: abi as Abi,
-                    data: log.data as Hex,
-                    topics: log.topics as any
+                    abi: abi,
+                    data: log.data,
+                    topics: log.topics
                 });
-
                 if (decoded && decoded.eventName) {
                     decodedEvents.push({
                         contractName: name,
@@ -41,19 +30,18 @@ export function decodeContractEvents(logs: any[]): DecodedEvent[] {
                     });
                     break; // Found the right ABI for this log
                 }
-            } catch (e: any) {
-               // Ignore mismatch errors, but log weird ones
-               if (e.message && Object.values(e.message).some((m: any) => m?.includes?.('slice'))) {
-                   console.warn(`   ⚠️ decodeEventLog failed (slice error) for ${name}:`, e.message);
-               }
+            }
+            catch (e) {
+                // Ignore mismatch errors, but log weird ones
+                if (e.message && Object.values(e.message).some((m) => m?.includes?.('slice'))) {
+                    console.warn(`   ⚠️ decodeEventLog failed (slice error) for ${name}:`, e.message);
+                }
             }
         }
     }
-
     return decodedEvents;
 }
-
-export function logDecodedEvents(events: DecodedEvent[]) {
+export function logDecodedEvents(events) {
     for (const event of events) {
         console.log(`📡 [${event.contractName}] Event: ${event.eventName}`);
         if (event.args) {

package/dist/sdk/src/utils/eventDecoder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{packages/sdk/src/utils/eventDecoder.test.ts → dist/sdk/src/utils/eventDecoder.test.js}

@@ -1,7 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { decodeContractEvents, logDecodedEvents } from './eventDecoder.js';
-import { keccak256, encodeAbiParameters, stringToBytes, type Hex, type Address } from 'viem';
-
+import { keccak256, encodeAbiParameters, stringToBytes } from 'viem';
 describe('eventDecoder', () => {
     it('should decode known events', () => {
         // Manual topic construction for RoleGranted(bytes32,address,address)
@@ -9,45 +8,38 @@ describe('eventDecoder', () => {
         const roleId = keccak256(stringToBytes('COMMUNITY'));
         const account = '0x0000000000000000000000000000000000000001';
         const sender = '0x0000000000000000000000000000000000000002';
-
         const topics = [
             ROLE_GRANTED_SIG,
             roleId,
-            encodeAbiParameters([{ type: 'address' }], [account as Address]),
-            encodeAbiParameters([{ type: 'address' }], [sender as Address])
+            encodeAbiParameters([{ type: 'address' }], [account]),
+            encodeAbiParameters([{ type: 'address' }], [sender])
         ];
-
         const logs = [{
-            data: '0x' as Hex,
-            topics: topics as any
-        }];
-
+                data: '0x',
+                topics: topics
+            }];
         const decoded = decodeContractEvents(logs);
         expect(decoded).toHaveLength(1);
         expect(decoded[0].contractName).toBe('Registry');
         expect(decoded[0].eventName).toBe('RoleGranted');
     });
-
     it('should skip invalid logs', () => {
         const logs = [{ data: 'invalid', topics: [] }];
         const decoded = decodeContractEvents(logs);
         expect(decoded).toHaveLength(0);
     });
-
     it('should handle decoding errors gracefully', () => {
         const logs = [{ data: '0x123', topics: ['0x0000000000000000000000000000000000000000000000000000000000000000'] }];
         const decoded = decodeContractEvents(logs);
         expect(decoded).toHaveLength(0);
     });
-
     it('should log decoded events', () => {
         const consoleSpy = vi.spyOn(console, 'log');
         const events = [{
-            contractName: 'Test',
-            eventName: 'Event',
-            args: { amount: 100n, user: '0x0000000000000000000000000000000000000001' }
-        }];
-
+                contractName: 'Test',
+                eventName: 'Event',
+                args: { amount: 100n, user: '0x0000000000000000000000000000000000000001' }
+            }];
         logDecodedEvents(events);
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[Test] Event: Event'));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('amount: 100'));

package/dist/sdk/src/utils/funding.d.ts

@@ -0,0 +1,115 @@
+import { type Hex, type Address, type Chain } from 'viem';
+/**
+ * 资金管理参数
+ */
+export interface FundingParams {
+    /** RPC URL */
+    rpcUrl: string;
+    /** 链配置 */
+    chain: Chain;
+    /** 资金提供者私钥 */
+    supplierKey: Hex;
+    /** 目标地址 */
+    targetAddress: Address;
+}
+/**
+ * ETH 充值参数
+ */
+export interface FundETHParams extends FundingParams {
+    /** 充值金额（ETH，如 '0.1'） */
+    amount: string;
+}
+/**
+ * ERC20 充值参数
+ */
+export interface FundTokenParams extends FundingParams {
+    /** Token 合约地址 */
+    tokenAddress: Address;
+    /** 充值金额（Token，如 '100'） */
+    amount: string;
+}
+/**
+ * 智能充值参数
+ */
+export interface EnsureFundingParams extends FundingParams {
+    /** 最小 ETH 余额阈值 */
+    minETH?: string;
+    /** 目标 ETH 充值金额 */
+    targetETH?: string;
+    /** Token 配置（可选） */
+    token?: {
+        address: Address;
+        minBalance?: string;
+        targetAmount?: string;
+    };
+}
+/**
+ * 充值结果
+ */
+export interface FundingResult {
+    success: boolean;
+    txHash?: Hex;
+    error?: string;
+}
+/**
+ * 资金管理器
+ * 提供 ETH 和 ERC20 Token 的充值、验证等工具函数
+ */
+export declare class FundingManager {
+    /**
+     * 创建 PublicClient 和 WalletClient
+     */
+    private static createClients;
+    /**
+     * 充值 ETH 到目标地址
+     * @param params - 充值参数
+     * @returns 充值结果
+     */
+    static fundWithETH(params: FundETHParams): Promise<FundingResult>;
+    /**
+     * 充值 ERC20 Token 到目标地址
+     * @param params - 充值参数
+     * @returns 充值结果
+     */
+    static fundWithToken(params: FundTokenParams): Promise<FundingResult>;
+    /**
+     * 检查 ETH 余额
+     * @param params - 基础参数
+     * @returns ETH 余额（wei）
+     */
+    static getETHBalance(params: FundingParams): Promise<bigint>;
+    /**
+     * 检查 ERC20 Token 余额
+     * @param params - 基础参数
+     * @param tokenAddress - Token 合约地址
+     * @returns Token 余额
+     */
+    static getTokenBalance(params: FundingParams, tokenAddress: Address): Promise<bigint>;
+    /**
+     * 智能充值：检查余额，不足时自动充值
+     * @param params - 充值参数
+     * @returns 充值结果数组
+     */
+    static ensureFunding(params: EnsureFundingParams): Promise<FundingResult[]>;
+    /**
+     * 批量充值 ETH
+     * @param params - 基础参数
+     * @param targets - 目标地址和金额数组
+     * @returns 充值结果数组
+     */
+    static batchFundETH(params: Omit<FundingParams, 'targetAddress'>, targets: Array<{
+        address: Address;
+        amount: string;
+    }>): Promise<FundingResult[]>;
+    /**
+     * 批量充值 Token
+     * @param params - 基础参数
+     * @param tokenAddress - Token 合约地址
+     * @param targets - 目标地址和金额数组
+     * @returns 充值结果数组
+     */
+    static batchFundToken(params: Omit<FundingParams, 'targetAddress'>, tokenAddress: Address, targets: Array<{
+        address: Address;
+        amount: string;
+    }>): Promise<FundingResult[]>;
+}