@cfxdevkit/core 0.1.0

package/dist/core-RZA4aKwj.d.cts

@@ -0,0 +1,352 @@
+import './config/index.cjs';
+import { C as ChainType, A as Address, B as BaseTransaction, T as TransactionReceipt, E as EventCallback, a as BlockEvent, U as UnwatchFunction, b as TransactionEvent } from './config-BMtaWM0X.cjs';
+import { Address as Address$2, PublicClient as PublicClient$1, WalletClient as WalletClient$2, TestClient as TestClient$1 } from 'cive';
+import { PublicClient, Chain, Address as Address$1, WalletClient as WalletClient$1 } from 'viem';
+
+/**
+ * Unified interface for both Core and EVM clients
+ * Abstracts away the differences between cive and viem
+ */
+interface ChainClient {
+    readonly chainType: ChainType;
+    readonly chainId: number;
+    readonly address: Address;
+    getBlockNumber(): Promise<bigint>;
+    getBalance(address: Address): Promise<string>;
+    getGasPrice(): Promise<bigint>;
+    estimateGas(tx: BaseTransaction): Promise<bigint>;
+    sendTransaction(tx: BaseTransaction): Promise<string>;
+    waitForTransaction(hash: string): Promise<TransactionReceipt>;
+    getTokenBalance(tokenAddress: Address, holderAddress?: Address): Promise<string>;
+    watchBlocks(callback: EventCallback<BlockEvent>): UnwatchFunction;
+    watchTransactions(callback: EventCallback<TransactionEvent>): UnwatchFunction;
+    isValidAddress(address: string): boolean;
+    formatAmount(amount: bigint): string;
+    parseAmount(amount: string): bigint;
+    getInternalClient(): unknown;
+}
+/**
+ * Wallet client interface for signing transactions
+ */
+interface WalletClient {
+    readonly address: Address;
+    readonly chainType: ChainType;
+    sendTransaction(tx: BaseTransaction): Promise<string>;
+    signMessage(message: string): Promise<string>;
+    getInternalClient(): unknown;
+}
+/**
+ * Test client interface for development operations
+ */
+interface TestClient extends ChainClient {
+    mine(blocks?: number): Promise<void>;
+    setNextBlockTimestamp(timestamp: number): Promise<void>;
+    increaseTime(seconds: number): Promise<void>;
+    impersonateAccount(address: Address): Promise<void>;
+    stopImpersonatingAccount(address: Address): Promise<void>;
+    setBalance(address: Address, balance: bigint): Promise<void>;
+    getStorageAt(address: Address, slot: string): Promise<string>;
+    setStorageAt(address: Address, slot: string, value: string): Promise<void>;
+}
+/**
+ * Client factory interface
+ */
+interface ClientFactory {
+    createPublicClient(chainType: ChainType, config: ClientConfig): ChainClient;
+    createWalletClient(chainType: ChainType, config: WalletConfig): WalletClient;
+    createTestClient(chainType: ChainType, config: TestConfig): TestClient;
+}
+/**
+ * Configuration interfaces for client creation
+ */
+interface ClientConfig {
+    readonly rpcUrl: string;
+    readonly wsUrl?: string;
+    readonly chainId: number;
+    readonly pollingInterval?: number;
+    readonly account?: string | {
+        privateKey: string;
+        accountIndex?: number;
+    };
+    readonly testMode?: boolean;
+}
+interface WalletConfig extends ClientConfig {
+    readonly privateKey: string;
+    readonly accountIndex?: number;
+}
+interface TestConfig extends ClientConfig {
+    readonly enableTestMode: boolean;
+}
+/**
+ * Client manager interface
+ * Manages lifecycle of both Core and EVM clients
+ */
+interface ClientManager {
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    getCoreClient(): ChainClient;
+    getEvmClient(): ChainClient;
+    getCoreWalletClient(accountIndex?: number): WalletClient;
+    getEvmWalletClient(accountIndex?: number): WalletClient;
+    getCoreTestClient(): TestClient;
+    getEvmTestClient(): TestClient;
+    isInitialized(): boolean;
+    getStatus(): {
+        core: {
+            isConnected: boolean;
+            blockNumber: bigint;
+        };
+        evm: {
+            isConnected: boolean;
+            blockNumber: bigint;
+        };
+    };
+    checkHealth(): Promise<boolean>;
+    on(event: 'block', callback: EventCallback<BlockEvent>): void;
+    on(event: 'transaction', callback: EventCallback<TransactionEvent>): void;
+    on(event: 'error', callback: EventCallback<Error>): void;
+    off(event: 'block', callback: EventCallback<BlockEvent>): void;
+    off(event: 'transaction', callback: EventCallback<TransactionEvent>): void;
+    off(event: 'error', callback: EventCallback<Error>): void;
+}
+
+/**
+ * EVM Space (eSpace) Client Implementation
+ * Provides unified interface for Ethereum-compatible operations on Conflux eSpace
+ */
+declare class EspaceClient implements ChainClient {
+    readonly chainId: number;
+    readonly chainType: "evm";
+    readonly publicClient: PublicClient;
+    protected readonly chain: Chain;
+    address: Address$1;
+    constructor(config: ClientConfig);
+    getBlockNumber(): Promise<bigint>;
+    getBalance(address: Address$1): Promise<string>;
+    estimateGas(tx: BaseTransaction): Promise<bigint>;
+    waitForTransaction(hash: string): Promise<TransactionReceipt>;
+    getGasPrice(): Promise<bigint>;
+    /**
+     * Get the current chain ID from the network
+     */
+    getChainId(): Promise<number>;
+    /**
+     * Check if the client is connected to the network
+     */
+    isConnected(): Promise<boolean>;
+    sendTransaction(_tx: BaseTransaction): Promise<string>;
+    getTokenBalance(_address: string, _tokenAddress: string): Promise<string>;
+    watchBlocks(callback: EventCallback<BlockEvent>): () => void;
+    watchTransaction(_hash: string, _callback: (receipt: TransactionReceipt) => void): Promise<() => void>;
+    getInternalClient(): PublicClient | WalletClient$1;
+    watchTransactions(_callback: EventCallback<TransactionEvent>): () => void;
+    isValidAddress(address: string): boolean;
+    formatAmount(amount: bigint): string;
+    parseAmount(amount: string): bigint;
+}
+/**
+ * EVM Space Wallet Client
+ * Extends EspaceClient with transaction and account functionality
+ */
+declare class EspaceWalletClient extends EspaceClient implements WalletClient {
+    private readonly walletClient;
+    private readonly account;
+    constructor(config: ClientConfig & {
+        privateKey: string;
+    });
+    getAddress(): Address$1;
+    sendTransaction(tx: BaseTransaction): Promise<string>;
+    signMessage(message: string): Promise<string>;
+    deployContract(abi: unknown[], bytecode: string, constructorArgs?: unknown[]): Promise<string>;
+    callContract<T = unknown>(address: string, abi: unknown[], functionName: string, args?: unknown[]): Promise<T>;
+    writeContract(address: string, abi: unknown[], functionName: string, args?: unknown[], value?: bigint): Promise<string>;
+    /**
+     * Transfer CFX from eSpace to Core Space
+     * Uses the built-in withdrawal mechanism
+     */
+    faucetToCore(coreAddress: string, amount: string): Promise<string>;
+    getInternalClient(): PublicClient | WalletClient$1;
+}
+/**
+ * EVM Space Test Client
+ * Extends EspaceWalletClient with additional testing utilities
+ */
+declare class EspaceTestClient extends EspaceWalletClient implements TestClient {
+    private readonly testClient;
+    constructor(config: TestConfig & {
+        privateKey: string;
+    });
+    mine(blocks?: number): Promise<void>;
+    setNextBlockTimestamp(timestamp: number): Promise<void>;
+    increaseTime(seconds: number): Promise<void>;
+    impersonateAccount(address: string): Promise<void>;
+    stopImpersonatingAccount(address: string): Promise<void>;
+    setBalance(address: string, balance: bigint): Promise<void>;
+    snapshot(): Promise<string>;
+    revert(snapshotId: string): Promise<void>;
+    getStorageAt(address: string, slot: string): Promise<string>;
+    setStorageAt(address: string, slot: string, value: string): Promise<void>;
+    watchTransactions(callback: EventCallback<TransactionEvent>): () => void;
+    isValidAddress(address: string): boolean;
+    getCurrentEpoch(): Promise<bigint>;
+    generateAccounts(count: number): Promise<string[]>;
+}
+
+type HealthStatus = 'healthy' | 'unhealthy' | 'disconnected' | 'unknown';
+
+interface CoreClientInstance {
+    publicClient: CoreClient;
+    walletClient?: CoreWalletClient;
+    testClient?: CoreTestClient;
+}
+interface EspaceClientInstance {
+    publicClient: EspaceClient;
+    walletClient?: EspaceWalletClient;
+    testClient?: EspaceTestClient;
+}
+interface StartOptions {
+    mining?: boolean;
+    waitForBlocks?: number;
+    fundingAmount?: string;
+}
+interface DeployOptions {
+    abi: unknown[];
+    bytecode: string;
+    args?: unknown[];
+    account: number;
+    chain?: 'core' | 'evm';
+    chains?: ('core' | 'evm')[];
+    value?: bigint;
+}
+interface ReadOptions {
+    address: string;
+    abi: unknown[];
+    functionName: string;
+    args?: unknown[];
+    chain: 'core' | 'evm';
+}
+interface WriteOptions {
+    address: string;
+    abi: unknown[];
+    functionName: string;
+    args?: unknown[];
+    account: number;
+    chain: 'core' | 'evm';
+    value?: bigint;
+    waitForConfirmation?: boolean;
+}
+interface ContractResult {
+    core?: string;
+    evm?: string;
+}
+interface ChainStatus {
+    core: {
+        connected: boolean;
+        status: string;
+    };
+    evm: {
+        connected: boolean;
+        status: string;
+    };
+}
+interface FaucetBalances {
+    coreBalance: string;
+    evmBalance: string;
+}
+interface MiningStatus {
+    isRunning: boolean;
+    interval: number;
+    blocksMined: number;
+    startTime?: Date;
+}
+interface ChainBalances {
+    core: string;
+    evm: string;
+}
+
+/**
+ * Core Space Client Implementation
+ * Wraps cive client with unified interface
+ */
+declare class CoreClient implements ChainClient {
+    readonly chainType: "core";
+    readonly chainId: number;
+    readonly address: Address$2;
+    private readonly publicClient;
+    private readonly chain;
+    constructor(config: ClientConfig);
+    getBlockNumber(): Promise<bigint>;
+    getBalance(address: Address$2): Promise<string>;
+    getGasPrice(): Promise<bigint>;
+    estimateGas(tx: BaseTransaction): Promise<bigint>;
+    sendTransaction(_tx: BaseTransaction): Promise<string>;
+    waitForTransaction(hash: string): Promise<TransactionReceipt>;
+    getTokenBalance(tokenAddress: Address$2, holderAddress?: Address$2): Promise<string>;
+    watchBlocks(callback: EventCallback<BlockEvent>): UnwatchFunction;
+    watchTransactions(callback: EventCallback<TransactionEvent>): UnwatchFunction;
+    isValidAddress(address: string): boolean;
+    formatAmount(amount: bigint): string;
+    parseAmount(amount: string): bigint;
+    getInternalClient(): PublicClient$1;
+    private formatTokenAmount;
+}
+/**
+ * Core Space Wallet Client Implementation
+ */
+declare class CoreWalletClient implements WalletClient {
+    readonly chainType: "core";
+    readonly address: Address$2;
+    readonly chainId: number;
+    private readonly walletClient;
+    private readonly publicClient;
+    private readonly account;
+    private readonly chain;
+    constructor(config: WalletConfig);
+    sendTransaction(tx: BaseTransaction): Promise<string>;
+    signMessage(message: string): Promise<string>;
+    getInternalClient(): WalletClient$2;
+    waitForTransaction(hash: string): Promise<TransactionReceipt>;
+    /**
+     * Unified faucet functionality
+     * Automatically detects address type and sends CFX accordingly:
+     * - Core address: Direct transfer
+     * - eSpace address: Cross-chain transfer via internal contract
+     */
+    faucet(address: string, amount: string): Promise<string>;
+    /**
+     * Cross-chain faucet functionality (Core → eSpace)
+     * Sends CFX from Core space to eSpace address via internal contract
+     * @deprecated Use faucet() instead which auto-detects address type
+     */
+    faucetToEspace(espaceAddress: string, amount: string): Promise<string>;
+    /**
+     * Deploy a contract to Core Space
+     */
+    deployContract(abi: unknown[], bytecode: string, constructorArgs?: unknown[]): Promise<string>;
+    /**
+     * Call a contract method (read-only)
+     */
+    callContract<T = unknown>(address: string, abi: unknown[], functionName: string, args?: unknown[]): Promise<T>;
+    /**
+     * Write to a contract (transaction)
+     */
+    writeContract(address: string, abi: unknown[], functionName: string, args?: unknown[], value?: bigint): Promise<string>;
+}
+/**
+ * Core Space Test Client Implementation
+ */
+declare class CoreTestClient extends CoreClient implements TestClient {
+    private readonly testClient;
+    constructor(config: TestConfig);
+    mine(blocks?: number): Promise<void>;
+    setNextBlockTimestamp(_timestamp: number): Promise<void>;
+    increaseTime(_seconds: number): Promise<void>;
+    impersonateAccount(_address: Address$2): Promise<void>;
+    stopImpersonatingAccount(_address: Address$2): Promise<void>;
+    setBalance(_address: Address$2, _balance: bigint): Promise<void>;
+    getStorageAt(_address: Address$2, _slot: string): Promise<string>;
+    setStorageAt(_address: Address$2, _slot: string, _value: string): Promise<void>;
+    getInternalTestClient(): TestClient$1;
+}
+
+export { CoreClient as C, type DeployOptions as D, EspaceClient as E, type FaucetBalances as F, type HealthStatus as H, type MiningStatus as M, type ReadOptions as R, type StartOptions as S, type TestClient as T, type WalletClient as W, CoreTestClient as a, CoreWalletClient as b, EspaceTestClient as c, EspaceWalletClient as d, type ClientConfig as e, type CoreClientInstance as f, type EspaceClientInstance as g, type ChainBalances as h, type ChainClient as i, type ChainStatus as j, type ClientFactory as k, type ClientManager as l, type ContractResult as m, type TestConfig as n, type WalletConfig as o, type WriteOptions as p };

package/dist/index-BhCpy6Fz.d.cts

@@ -0,0 +1,165 @@
+import { H as HealthStatus, e as ClientConfig, f as CoreClientInstance, g as EspaceClientInstance } from './core-RZA4aKwj.cjs';
+import { EventEmitter } from 'node:events';
+import { C as ChainType } from './config-BMtaWM0X.cjs';
+import { SupportedChainId } from './config/index.cjs';
+
+/**
+ * Client Manager Events
+ */
+interface ClientManagerEvents {
+    'client:ready': [{
+        type: ChainType;
+        chainId: SupportedChainId;
+    }];
+    'client:error': [
+        {
+            type: ChainType;
+            chainId: SupportedChainId;
+            error: Error;
+        }
+    ];
+    'client:health': [
+        {
+            type: ChainType;
+            chainId: SupportedChainId;
+            status: HealthStatus;
+        }
+    ];
+    'server:started': [
+        {
+            coreChainId: SupportedChainId;
+            evmChainId: SupportedChainId;
+        }
+    ];
+    'server:stopped': [];
+    'network:switched': [{
+        from: SupportedChainId;
+        to: SupportedChainId;
+    }];
+    'manager:ready': [];
+    'manager:error': [{
+        error: Error;
+    }];
+}
+/**
+ * Client Manager Configuration
+ */
+interface ClientManagerConfig {
+    /** Core Space client configuration */
+    core: ClientConfig;
+    /** eSpace client configuration */
+    evm: ClientConfig;
+    /** Enable automatic health monitoring */
+    enableHealthMonitoring?: boolean;
+    /** Health check interval in milliseconds */
+    healthCheckInterval?: number;
+    /** Health check timeout in milliseconds */
+    healthCheckTimeout?: number;
+}
+/**
+ * Client Manager Status
+ */
+interface ClientManagerStatus {
+    initialized: boolean;
+    coreClient: {
+        connected: boolean;
+        chainId: SupportedChainId;
+        health: HealthStatus;
+        lastHealthCheck?: Date;
+    };
+    evmClient: {
+        connected: boolean;
+        chainId: SupportedChainId;
+        health: HealthStatus;
+        lastHealthCheck?: Date;
+    };
+    networkSelector: {
+        currentChain: SupportedChainId;
+        isLocalNode: boolean;
+        lockedToLocal: boolean;
+    };
+}
+/**
+ * Unified Client Manager
+ *
+ * This is the main orchestration layer that manages:
+ * - Core Space and eSpace client instances
+ * - Local development server lifecycle
+ * - Network switching and chain coordination
+ * - Health monitoring and error recovery
+ * - Event coordination between components
+ *
+ * Key Design Principles:
+ * 1. **Dual Chain Support**: Manages both Core and eSpace clients simultaneously
+ * 2. **Network Awareness**: Automatically switches to local chains when dev server runs
+ * 3. **Health Monitoring**: Continuous health checks with automatic recovery
+ * 4. **Event Coordination**: Unified event system for all components
+ * 5. **Type Safety**: Full TypeScript support with proper error handling
+ */
+declare class ClientManager extends EventEmitter<ClientManagerEvents> {
+    private config;
+    private coreClient;
+    private evmClient;
+    private healthCheckInterval;
+    private networkSelectorUnsubscribe;
+    private nodeRunningUnsubscribe;
+    private initialized;
+    constructor(config: ClientManagerConfig);
+    /**
+     * Initialize the Client Manager
+     * Sets up clients, server, and monitoring
+     */
+    initialize(): Promise<void>;
+    /**
+     * Gracefully shutdown the Client Manager
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get current Core Space client
+     */
+    getCoreClient(): CoreClientInstance | null;
+    /**
+     * Get current eSpace client
+     */
+    getEvmClient(): EspaceClientInstance | null;
+    /**
+     * Get comprehensive status
+     */
+    getStatus(): ClientManagerStatus;
+    /**
+     * Switch to a specific network
+     * @param chainId - Target chain ID
+     * @param force - Force switch even if node is running (for wallet operations)
+     */
+    switchNetwork(chainId: SupportedChainId, force?: boolean): Promise<void>;
+    /**
+     * Initialize or reinitialize client instances based on current network
+     */
+    private initializeClients;
+    /**
+     * Set up network selector event listeners
+     */
+    private setupNetworkListeners;
+    /**
+     * Start health monitoring for all clients
+     */
+    private startHealthMonitoring;
+    /**
+     * Stop health monitoring
+     */
+    private stopHealthMonitoring;
+    /**
+     * Perform health checks on all clients
+     */
+    private performHealthChecks;
+    /**
+     * Check Core client health
+     */
+    private checkCoreClientHealth;
+    /**
+     * Check eSpace client health
+     */
+    private checkEvmClientHealth;
+}
+
+export { ClientManager as C, type ClientManagerConfig as a, type ClientManagerEvents as b, type ClientManagerStatus as c };

package/dist/index-Qz84U9Oq.d.ts

@@ -0,0 +1,165 @@
+import { H as HealthStatus, e as ClientConfig, f as CoreClientInstance, g as EspaceClientInstance } from './core-C5qe16RS.js';
+import { EventEmitter } from 'node:events';
+import { C as ChainType } from './config-BMtaWM0X.js';
+import { SupportedChainId } from './config/index.js';
+
+/**
+ * Client Manager Events
+ */
+interface ClientManagerEvents {
+    'client:ready': [{
+        type: ChainType;
+        chainId: SupportedChainId;
+    }];
+    'client:error': [
+        {
+            type: ChainType;
+            chainId: SupportedChainId;
+            error: Error;
+        }
+    ];
+    'client:health': [
+        {
+            type: ChainType;
+            chainId: SupportedChainId;
+            status: HealthStatus;
+        }
+    ];
+    'server:started': [
+        {
+            coreChainId: SupportedChainId;
+            evmChainId: SupportedChainId;
+        }
+    ];
+    'server:stopped': [];
+    'network:switched': [{
+        from: SupportedChainId;
+        to: SupportedChainId;
+    }];
+    'manager:ready': [];
+    'manager:error': [{
+        error: Error;
+    }];
+}
+/**
+ * Client Manager Configuration
+ */
+interface ClientManagerConfig {
+    /** Core Space client configuration */
+    core: ClientConfig;
+    /** eSpace client configuration */
+    evm: ClientConfig;
+    /** Enable automatic health monitoring */
+    enableHealthMonitoring?: boolean;
+    /** Health check interval in milliseconds */
+    healthCheckInterval?: number;
+    /** Health check timeout in milliseconds */
+    healthCheckTimeout?: number;
+}
+/**
+ * Client Manager Status
+ */
+interface ClientManagerStatus {
+    initialized: boolean;
+    coreClient: {
+        connected: boolean;
+        chainId: SupportedChainId;
+        health: HealthStatus;
+        lastHealthCheck?: Date;
+    };
+    evmClient: {
+        connected: boolean;
+        chainId: SupportedChainId;
+        health: HealthStatus;
+        lastHealthCheck?: Date;
+    };
+    networkSelector: {
+        currentChain: SupportedChainId;
+        isLocalNode: boolean;
+        lockedToLocal: boolean;
+    };
+}
+/**
+ * Unified Client Manager
+ *
+ * This is the main orchestration layer that manages:
+ * - Core Space and eSpace client instances
+ * - Local development server lifecycle
+ * - Network switching and chain coordination
+ * - Health monitoring and error recovery
+ * - Event coordination between components
+ *
+ * Key Design Principles:
+ * 1. **Dual Chain Support**: Manages both Core and eSpace clients simultaneously
+ * 2. **Network Awareness**: Automatically switches to local chains when dev server runs
+ * 3. **Health Monitoring**: Continuous health checks with automatic recovery
+ * 4. **Event Coordination**: Unified event system for all components
+ * 5. **Type Safety**: Full TypeScript support with proper error handling
+ */
+declare class ClientManager extends EventEmitter<ClientManagerEvents> {
+    private config;
+    private coreClient;
+    private evmClient;
+    private healthCheckInterval;
+    private networkSelectorUnsubscribe;
+    private nodeRunningUnsubscribe;
+    private initialized;
+    constructor(config: ClientManagerConfig);
+    /**
+     * Initialize the Client Manager
+     * Sets up clients, server, and monitoring
+     */
+    initialize(): Promise<void>;
+    /**
+     * Gracefully shutdown the Client Manager
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get current Core Space client
+     */
+    getCoreClient(): CoreClientInstance | null;
+    /**
+     * Get current eSpace client
+     */
+    getEvmClient(): EspaceClientInstance | null;
+    /**
+     * Get comprehensive status
+     */
+    getStatus(): ClientManagerStatus;
+    /**
+     * Switch to a specific network
+     * @param chainId - Target chain ID
+     * @param force - Force switch even if node is running (for wallet operations)
+     */
+    switchNetwork(chainId: SupportedChainId, force?: boolean): Promise<void>;
+    /**
+     * Initialize or reinitialize client instances based on current network
+     */
+    private initializeClients;
+    /**
+     * Set up network selector event listeners
+     */
+    private setupNetworkListeners;
+    /**
+     * Start health monitoring for all clients
+     */
+    private startHealthMonitoring;
+    /**
+     * Stop health monitoring
+     */
+    private stopHealthMonitoring;
+    /**
+     * Perform health checks on all clients
+     */
+    private performHealthChecks;
+    /**
+     * Check Core client health
+     */
+    private checkCoreClientHealth;
+    /**
+     * Check eSpace client health
+     */
+    private checkEvmClientHealth;
+}
+
+export { ClientManager as C, type ClientManagerConfig as a, type ClientManagerEvents as b, type ClientManagerStatus as c };