@cfxdevkit/core 0.1.0

package/dist/config-BMtaWM0X.d.ts

@@ -0,0 +1,165 @@
+interface NodeConfig {
+    readonly chainId?: number;
+    readonly evmChainId?: number;
+    readonly jsonrpcHttpPort?: number;
+    readonly jsonrpcHttpEthPort?: number;
+    readonly jsonrpcWsPort?: number;
+    readonly jsonrpcWsEthPort?: number;
+    readonly confluxDataDir?: string;
+    readonly log?: boolean;
+    readonly logConf?: string;
+    readonly genesisSecrets?: readonly string[];
+    readonly genesisEvmSecrets?: readonly string[];
+    readonly miningAuthor?: string;
+    readonly nodeType?: 'full' | 'archive' | 'light';
+    readonly blockDbType?: 'rocksdb' | 'sqlite';
+}
+interface ExtendedNodeConfig extends NodeConfig {
+    readonly accountCount?: number;
+    readonly silent?: boolean;
+    readonly fundAccounts?: boolean;
+    readonly enabledChains?: readonly ('core' | 'evm')[];
+    readonly derivationPaths?: {
+        readonly core: string;
+        readonly evm: string;
+    };
+}
+type Address = string;
+type CoreAddress = string;
+type EvmAddress = string;
+type Hash = string;
+type ChainType = 'core' | 'evm';
+interface UnifiedAccount {
+    readonly id: string;
+    readonly name: string;
+    readonly index: number;
+    readonly privateKey: string;
+    readonly derivationPath: string;
+    readonly coreAddress: CoreAddress;
+    readonly evmAddress: EvmAddress;
+    readonly coreBalance: bigint;
+    readonly evmBalance: bigint;
+    readonly coreNonce: number;
+    readonly evmNonce: number;
+    readonly isActive: boolean;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}
+interface ChainStatus {
+    readonly isRunning: boolean;
+    readonly chainId: number;
+    readonly blockNumber: bigint;
+    readonly gasPrice: bigint;
+    readonly peerCount: number;
+    readonly syncStatus: 'syncing' | 'synced';
+    readonly latestBlockHash: string;
+    readonly mining: boolean;
+    readonly pendingTransactions: number;
+    readonly rpcEndpoint: string;
+    readonly wsEndpoint?: string;
+}
+interface NodeStatus {
+    readonly isRunning: boolean;
+    readonly uptime: number;
+    readonly startTime: Date | null;
+    readonly core: ChainStatus;
+    readonly evm: ChainStatus;
+    readonly dataDir: string;
+    readonly config: NodeConfig;
+    readonly mining: MiningStatus;
+}
+interface MiningStatus {
+    readonly isRunning: boolean;
+    readonly interval: number;
+    readonly blocksMined: number;
+    readonly startTime: Date | null;
+    readonly lastBlockTime: Date | null;
+}
+interface BaseTransaction {
+    readonly to?: string;
+    readonly value?: bigint;
+    readonly data?: string;
+    readonly gasLimit?: bigint;
+    readonly gasPrice?: bigint;
+    readonly nonce?: number;
+}
+interface TransactionReceipt {
+    readonly hash: string;
+    readonly blockNumber: bigint;
+    readonly blockHash: string;
+    readonly transactionIndex: number;
+    readonly status: 'success' | 'reverted';
+    readonly gasUsed: bigint;
+    readonly contractAddress?: string;
+    readonly logs: readonly Log[];
+}
+interface Log {
+    readonly address: string;
+    readonly topics: readonly string[];
+    readonly data: string;
+    readonly blockNumber: bigint;
+    readonly transactionHash: string;
+    readonly logIndex: number;
+}
+interface ConfluxNodeError extends Error {
+    readonly code: string;
+    readonly chain?: ChainType;
+    readonly context?: Record<string, unknown>;
+}
+declare class NodeError extends Error implements ConfluxNodeError {
+    readonly code: string;
+    readonly chain?: ChainType;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, code: string, chain?: ChainType, context?: Record<string, unknown>);
+}
+interface BlockEvent {
+    readonly chainType: ChainType;
+    readonly blockNumber: bigint;
+    readonly blockHash: string;
+    readonly timestamp: number;
+    readonly transactionCount: number;
+}
+interface TransactionEvent {
+    readonly chainType: ChainType;
+    readonly hash: string;
+    readonly from: string;
+    readonly to?: string;
+    readonly value: bigint;
+    readonly blockNumber: bigint;
+}
+type EventCallback<T> = (event: T) => void;
+type UnwatchFunction = () => void;
+type ServerStatus = 'stopped' | 'starting' | 'running' | 'stopping' | 'error';
+interface ServerConfig {
+    readonly coreRpcPort?: number;
+    readonly evmRpcPort?: number;
+    readonly wsPort?: number;
+    readonly chainId?: number;
+    readonly evmChainId?: number;
+    readonly accounts?: number;
+    readonly balance?: string;
+    readonly mnemonic?: string;
+    readonly logging?: boolean;
+    readonly detached?: boolean;
+    readonly mining?: MiningConfig;
+    readonly devBlockIntervalMs?: number;
+    readonly devPackTxImmediately?: boolean;
+    readonly dataDir?: string;
+}
+interface MiningConfig {
+    readonly enabled: boolean;
+    readonly interval: number;
+    readonly autoStart: boolean;
+}
+interface AccountInfo {
+    readonly index: number;
+    readonly privateKey: string;
+    readonly coreAddress: string;
+    readonly evmAddress: string;
+    readonly mnemonic: string;
+    readonly path: string;
+    readonly evmPrivateKey?: string;
+    readonly evmPath?: string;
+}
+
+export { type Address as A, type BaseTransaction as B, type ChainType as C, type EventCallback as E, type Hash as H, type Log as L, type MiningConfig as M, type NodeConfig as N, type ServerConfig as S, type TransactionReceipt as T, type UnwatchFunction as U, type BlockEvent as a, type TransactionEvent as b, type AccountInfo as c, type ConfluxNodeError as d, type CoreAddress as e, type EvmAddress as f, type ExtendedNodeConfig as g, NodeError as h, type NodeStatus as i, type ServerStatus as j, type UnifiedAccount as k };

package/dist/core-C5qe16RS.d.ts

@@ -0,0 +1,352 @@
+import './config/index.js';
+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.js';
+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 };