@aastar/sdk 0.18.0 → 0.20.1

package/dist/errors/decoder.js

@@ -1,44 +0,0 @@
-import { decodeErrorResult } from 'viem';
-import { RegistryABI } from '../index.js'; // Assuming RegistryABI is exported
-export const CustomErrors = {
-    RoleNotConfigured: 'RoleNotConfigured(bytes32,bool)',
-    RoleAlreadyGranted: 'RoleAlreadyGranted(bytes32,address)',
-    InsufficientStake: 'InsufficientStake(uint256,uint256)',
-};
-export function decodeContractError(error) {
-    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) => e.data) : error;
-        const data = internalError?.data;
-        if (data) {
-            try {
-                const decoded = decodeErrorResult({
-                    abi: RegistryABI,
-                    data: data
-                });
-                if (decoded.errorName === 'RoleNotConfigured') {
-                    const [roleId, isActive] = decoded.args;
-                    return `RoleNotConfigured: Role ${roleId} is ${isActive ? 'ACTIVE' : 'INACTIVE'} in Registry.`;
-                }
-                if (decoded.errorName === 'RoleAlreadyGranted') {
-                    const [roleId, user] = decoded.args;
-                    return `RoleAlreadyGranted: User ${user} already has role ${roleId}.`;
-                }
-                if (decoded.errorName === 'InsufficientStake') {
-                    const [stake, minStake] = decoded.args;
-                    // 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;
-            }
-        }
-    }
-    return null;
-}

package/dist/utils/errorHandler.d.ts

@@ -1,40 +0,0 @@
-/**
- * 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;
-    account?: string;
-    contract?: string;
-    roleId?: Hex;
-    additionalInfo?: Record<string, any>;
-}
-/**
- * 处理合约错误并返回友好的错误消息
- *
- * @param error - 原始错误对象
- * @param context - 错误上下文
- * @returns 友好的错误消息
- */
-export declare function handleContractError(error: any, context: ErrorContext): Error;
-/**
- * 创建错误上下文的辅助函数
- */
-export declare function createErrorContext(operation: string, options?: Partial<ErrorContext>): ErrorContext;

package/dist/utils/errorHandler.js

@@ -1,114 +0,0 @@
-/**
- * SDK Error Handling Utilities
- *
- * 提供统一的错误处理和上下文化错误消息
- */
-/**
- * 已知的合约错误及其友好消息
- */
-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) {
-    // 检查 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);
-        for (const knownError of Object.keys(KNOWN_CONTRACT_ERRORS)) {
-            if (errorString.includes(knownError)) {
-                return knownError;
-            }
-        }
-    }
-    catch {
-        // Ignore serialization errors
-    }
-    return null;
-}
-/**
- * 处理合约错误并返回友好的错误消息
- *
- * @param error - 原始错误对象
- * @param context - 错误上下文
- * @returns 友好的错误消息
- */
-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.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.cause = error;
-    enhancedError.originalError = error;
-    enhancedError.context = context;
-    return enhancedError;
-}
-/**
- * 创建错误上下文的辅助函数
- */
-export function createErrorContext(operation, options) {
-    return {
-        operation,
-        ...options
-    };
-}

package/dist/utils/funding.d.ts

@@ -1,115 +0,0 @@
-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[]>;
-}

package/dist/utils/funding.js

@@ -1,188 +0,0 @@
-import { createPublicClient, createWalletClient, http, parseEther, erc20Abi } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-/**
- * 资金管理器
- * 提供 ETH 和 ERC20 Token 的充值、验证等工具函数
- */
-export class FundingManager {
-    /**
-     * 创建 PublicClient 和 WalletClient
-     */
-    static createClients(params) {
-        const account = privateKeyToAccount(params.supplierKey);
-        const transport = http(params.rpcUrl);
-        const publicClient = createPublicClient({
-            chain: params.chain,
-            transport
-        });
-        const walletClient = createWalletClient({
-            account,
-            chain: params.chain,
-            transport
-        });
-        return { publicClient, walletClient, account };
-    }
-    /**
-     * 充值 ETH 到目标地址
-     * @param params - 充值参数
-     * @returns 充值结果
-     */
-    static async fundWithETH(params) {
-        try {
-            const { publicClient, walletClient } = this.createClients(params);
-            const amount = parseEther(params.amount);
-            console.log(`💸 Funding ${params.targetAddress} with ${params.amount} ETH...`);
-            const hash = await walletClient.sendTransaction({
-                account: walletClient.account,
-                chain: params.chain,
-                to: params.targetAddress,
-                value: amount
-            });
-            console.log(`   Transaction Sent: ${hash}`);
-            await publicClient.waitForTransactionReceipt({ hash });
-            console.log(`   ✅ ETH Funded.`);
-            return { success: true, txHash: hash };
-        }
-        catch (error) {
-            console.error(`   ❌ ETH Funding Failed:`, error);
-            return { success: false, error: error.message };
-        }
-    }
-    /**
-     * 充值 ERC20 Token 到目标地址
-     * @param params - 充值参数
-     * @returns 充值结果
-     */
-    static async fundWithToken(params) {
-        try {
-            const { publicClient, walletClient, account } = this.createClients(params);
-            const amount = parseEther(params.amount);
-            console.log(`💸 Funding ${params.targetAddress} with ${params.amount} tokens...`);
-            const { request } = await publicClient.simulateContract({
-                account,
-                address: params.tokenAddress,
-                abi: erc20Abi,
-                functionName: 'transfer',
-                args: [params.targetAddress, amount]
-            });
-            const hash = await walletClient.writeContract(request);
-            console.log(`   Transaction Sent: ${hash}`);
-            await publicClient.waitForTransactionReceipt({ hash });
-            console.log(`   ✅ Token Funded.`);
-            return { success: true, txHash: hash };
-        }
-        catch (error) {
-            console.error(`   ❌ Token Funding Failed:`, error);
-            return { success: false, error: error.message };
-        }
-    }
-    /**
-     * 检查 ETH 余额
-     * @param params - 基础参数
-     * @returns ETH 余额（wei）
-     */
-    static async getETHBalance(params) {
-        const { publicClient } = this.createClients(params);
-        return await publicClient.getBalance({ address: params.targetAddress });
-    }
-    /**
-     * 检查 ERC20 Token 余额
-     * @param params - 基础参数
-     * @param tokenAddress - Token 合约地址
-     * @returns Token 余额
-     */
-    static async getTokenBalance(params, tokenAddress) {
-        const { publicClient } = this.createClients(params);
-        return await publicClient.readContract({
-            address: tokenAddress,
-            abi: erc20Abi,
-            functionName: 'balanceOf',
-            args: [params.targetAddress]
-        });
-    }
-    /**
-     * 智能充值：检查余额，不足时自动充值
-     * @param params - 充值参数
-     * @returns 充值结果数组
-     */
-    static async ensureFunding(params) {
-        const results = [];
-        const { publicClient } = this.createClients(params);
-        // 1. 检查并充值 ETH
-        if (params.minETH && params.targetETH) {
-            const ethBalance = await publicClient.getBalance({ address: params.targetAddress });
-            const minETH = parseEther(params.minETH);
-            const targetETH = parseEther(params.targetETH);
-            if (ethBalance < minETH) {
-                console.log(`⚠️  ETH balance (${Number(ethBalance) / 1e18}) below threshold (${params.minETH})`);
-                const result = await this.fundWithETH({
-                    ...params,
-                    amount: params.targetETH
-                });
-                results.push(result);
-            }
-            else {
-                console.log(`✅ Sufficient ETH: ${Number(ethBalance) / 1e18} ETH`);
-                results.push({ success: true });
-            }
-        }
-        // 2. 检查并充值 Token
-        if (params.token) {
-            const tokenBalance = await this.getTokenBalance(params, params.token.address);
-            const minToken = params.token.minBalance ? parseEther(params.token.minBalance) : 0n;
-            const targetToken = params.token.targetAmount ? parseEther(params.token.targetAmount) : 0n;
-            if (tokenBalance < minToken && targetToken > 0n) {
-                console.log(`⚠️  Token balance (${Number(tokenBalance) / 1e18}) below threshold (${params.token.minBalance})`);
-                const result = await this.fundWithToken({
-                    ...params,
-                    tokenAddress: params.token.address,
-                    amount: params.token.targetAmount
-                });
-                results.push(result);
-            }
-            else {
-                console.log(`✅ Sufficient Token: ${Number(tokenBalance) / 1e18}`);
-                results.push({ success: true });
-            }
-        }
-        return results;
-    }
-    /**
-     * 批量充值 ETH
-     * @param params - 基础参数
-     * @param targets - 目标地址和金额数组
-     * @returns 充值结果数组
-     */
-    static async batchFundETH(params, targets) {
-        const results = [];
-        for (const target of targets) {
-            const result = await this.fundWithETH({
-                ...params,
-                targetAddress: target.address,
-                amount: target.amount
-            });
-            results.push(result);
-        }
-        return results;
-    }
-    /**
-     * 批量充值 Token
-     * @param params - 基础参数
-     * @param tokenAddress - Token 合约地址
-     * @param targets - 目标地址和金额数组
-     * @returns 充值结果数组
-     */
-    static async batchFundToken(params, tokenAddress, targets) {
-        const results = [];
-        for (const target of targets) {
-            const result = await this.fundWithToken({
-                ...params,
-                targetAddress: target.address,
-                tokenAddress,
-                amount: target.amount
-            });
-            results.push(result);
-        }
-        return results;
-    }
-}

package/dist/utils/keys.d.ts

@@ -1,61 +0,0 @@
-import type { Hex, Address } from 'viem';
-/**
- * 密钥对接口
- */
-export interface KeyPair {
-    name: string;
-    privateKey: Hex;
-    address: Address;
-}
-/**
- * 密钥管理器
- * 提供密钥生成、存储、加载等工具函数
- */
-export declare class KeyManager {
-    /**
-     * 生成单个密钥对
-     * @param name - 密钥名称（如 'Jason', 'Anni'）
-     */
-    static generateKeyPair(name: string): KeyPair;
-    /**
-     * 批量生成密钥对
-     * @param names - 密钥名称数组
-     */
-    static generateKeyPairs(names: string[]): KeyPair[];
-    /**
-     * 生成指定数量的密钥对（自动命名为 Operator_1, Operator_2, ...）
-     * @param count - 数量
-     * @param prefix - 名称前缀（默认 'Operator'）
-     */
-    static generateMultiple(count: number, prefix?: string): KeyPair[];
-    /**
-     * 保存密钥到 .env 文件
-     * @param filePath - 文件路径（绝对路径）
-     * @param keys - 密钥对数组
-     * @param overwrite - 是否覆盖已存在的文件（默认 false）
-     */
-    static saveToEnvFile(filePath: string, keys: KeyPair[], overwrite?: boolean): void;
-    /**
-     * 从 .env 文件加载密钥
-     * @param filePath - 文件路径（绝对路径）
-     * @returns 密钥对数组
-     */
-    static loadFromEnvFile(filePath: string): KeyPair[];
-    /**
-     * 保存密钥到 JSON 文件（包含地址信息）
-     * @param filePath - 文件路径（绝对路径）
-     * @param keys - 密钥对数组
-     * @param overwrite - 是否覆盖已存在的文件（默认 false）
-     */
-    static saveToJsonFile(filePath: string, keys: KeyPair[], overwrite?: boolean): void;
-    /**
-     * 从 JSON 文件加载密钥
-     * @param filePath - 文件路径（绝对路径）
-     */
-    static loadFromJsonFile(filePath: string): KeyPair[];
-    /**
-     * 打印密钥信息（隐藏私钥）
-     * @param keys - 密钥对数组
-     */
-    static printKeys(keys: KeyPair[], showPrivateKey?: boolean): void;
-}

package/dist/utils/keys.js

@@ -1,130 +0,0 @@
-import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
-import * as fs from 'fs';
-/**
- * 密钥管理器
- * 提供密钥生成、存储、加载等工具函数
- */
-export class KeyManager {
-    /**
-     * 生成单个密钥对
-     * @param name - 密钥名称（如 'Jason', 'Anni'）
-     */
-    static generateKeyPair(name) {
-        const privateKey = generatePrivateKey();
-        const account = privateKeyToAccount(privateKey);
-        return {
-            name,
-            privateKey,
-            address: account.address
-        };
-    }
-    /**
-     * 批量生成密钥对
-     * @param names - 密钥名称数组
-     */
-    static generateKeyPairs(names) {
-        return names.map(name => this.generateKeyPair(name));
-    }
-    /**
-     * 生成指定数量的密钥对（自动命名为 Operator_1, Operator_2, ...）
-     * @param count - 数量
-     * @param prefix - 名称前缀（默认 'Operator'）
-     */
-    static generateMultiple(count, prefix = 'Operator') {
-        const names = Array.from({ length: count }, (_, i) => `${prefix}_${i + 1}`);
-        return this.generateKeyPairs(names);
-    }
-    /**
-     * 保存密钥到 .env 文件
-     * @param filePath - 文件路径（绝对路径）
-     * @param keys - 密钥对数组
-     * @param overwrite - 是否覆盖已存在的文件（默认 false）
-     */
-    static saveToEnvFile(filePath, keys, overwrite = false) {
-        if (fs.existsSync(filePath) && !overwrite) {
-            throw new Error(`File already exists: ${filePath}. Set overwrite=true to replace.`);
-        }
-        const content = keys.map(k => `${k.name.toUpperCase().replace(/\s+/g, '_')}_PRIVATE_KEY=${k.privateKey}`).join('\n') + '\n';
-        fs.writeFileSync(filePath, content, { mode: 0o600 }); // 仅所有者可读写
-        console.log(`✅ Keys saved to ${filePath} (${keys.length} keys)`);
-    }
-    /**
-     * 从 .env 文件加载密钥
-     * @param filePath - 文件路径（绝对路径）
-     * @returns 密钥对数组
-     */
-    static loadFromEnvFile(filePath) {
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`File not found: ${filePath}`);
-        }
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const lines = content.split('\n').filter(line => line.trim() && !line.startsWith('#'));
-        return lines.map(line => {
-            const [key, value] = line.split('=');
-            const name = key.replace(/_PRIVATE_KEY$/, '').toLowerCase().replace(/_/g, ' ');
-            const privateKey = value.trim();
-            const account = privateKeyToAccount(privateKey);
-            return {
-                name,
-                privateKey,
-                address: account.address
-            };
-        });
-    }
-    /**
-     * 保存密钥到 JSON 文件（包含地址信息）
-     * @param filePath - 文件路径（绝对路径）
-     * @param keys - 密钥对数组
-     * @param overwrite - 是否覆盖已存在的文件（默认 false）
-     */
-    static saveToJsonFile(filePath, keys, overwrite = false) {
-        if (fs.existsSync(filePath) && !overwrite) {
-            throw new Error(`File already exists: ${filePath}. Set overwrite=true to replace.`);
-        }
-        const data = {
-            generated: new Date().toISOString(),
-            keys: keys.map(k => ({
-                name: k.name,
-                privateKey: k.privateKey,
-                address: k.address
-            }))
-        };
-        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
-        console.log(`✅ Keys saved to ${filePath} (${keys.length} keys)`);
-    }
-    /**
-     * 从 JSON 文件加载密钥
-     * @param filePath - 文件路径（绝对路径）
-     */
-    static loadFromJsonFile(filePath) {
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`File not found: ${filePath}`);
-        }
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const data = JSON.parse(content);
-        return data.keys.map((k) => ({
-            name: k.name,
-            privateKey: k.privateKey,
-            address: k.address
-        }));
-    }
-    /**
-     * 打印密钥信息（隐藏私钥）
-     * @param keys - 密钥对数组
-     */
-    static printKeys(keys, showPrivateKey = false) {
-        console.log('\n🔑 Generated Keys:');
-        console.log('─'.repeat(80));
-        keys.forEach((k, i) => {
-            console.log(`${i + 1}. ${k.name}`);
-            console.log(`   Address: ${k.address}`);
-            if (showPrivateKey) {
-                console.log(`   Private Key: ${k.privateKey}`);
-            }
-            else {
-                console.log(`   Private Key: ${k.privateKey.slice(0, 10)}...${k.privateKey.slice(-8)}`);
-            }
-        });
-        console.log('─'.repeat(80));
-    }
-}