@cfxdevkit/core 0.1.0

package/dist/clients/index.cjs

@@ -0,0 +1,2053 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/clients/index.ts
+var clients_exports = {};
+__export(clients_exports, {
+  ClientManager: () => ClientManager,
+  CoreClient: () => CoreClient,
+  CoreTestClient: () => CoreTestClient,
+  CoreWalletClient: () => CoreWalletClient,
+  EspaceClient: () => EspaceClient,
+  EspaceTestClient: () => EspaceTestClient,
+  EspaceWalletClient: () => EspaceWalletClient
+});
+module.exports = __toCommonJS(clients_exports);
+
+// src/clients/core.ts
+var import_cive = require("cive");
+var import_accounts = require("cive/accounts");
+var import_utils2 = require("cive/utils");
+var import_viem2 = require("viem");
+
+// src/config/chains.ts
+var import_utils = require("cive/utils");
+var import_viem = require("viem");
+var CORE_MAINNET = {
+  id: 1029,
+  name: "conflux-core",
+  type: "core",
+  testnet: false,
+  nativeCurrency: {
+    name: "Conflux",
+    symbol: "CFX",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://main.confluxrpc.com"],
+      webSocket: ["wss://main.confluxrpc.com/ws"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "ConfluxScan",
+      url: "https://confluxscan.io"
+    }
+  }
+};
+var CORE_TESTNET = {
+  id: 1,
+  name: "conflux-core-testnet",
+  type: "core",
+  testnet: true,
+  nativeCurrency: {
+    name: "Conflux",
+    symbol: "CFX",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://test.confluxrpc.com"],
+      webSocket: ["wss://test.confluxrpc.com/ws"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "ConfluxScan Testnet",
+      url: "https://testnet.confluxscan.io"
+    }
+  }
+};
+var CORE_LOCAL = {
+  id: 2029,
+  name: "conflux-core-local",
+  type: "core",
+  testnet: true,
+  nativeCurrency: {
+    name: "Conflux",
+    symbol: "CFX",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["http://localhost:12537"],
+      webSocket: ["ws://localhost:12536"]
+    }
+  }
+};
+var EVM_MAINNET = {
+  id: 1030,
+  name: "conflux-espace",
+  type: "evm",
+  testnet: false,
+  nativeCurrency: {
+    name: "Conflux",
+    symbol: "CFX",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://evm.confluxrpc.com"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "ConfluxScan eSpace",
+      url: "https://evm.confluxscan.net"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 62512243
+    }
+  }
+};
+var EVM_TESTNET = {
+  id: 71,
+  name: "conflux-espace-testnet",
+  type: "evm",
+  testnet: true,
+  nativeCurrency: {
+    name: "Conflux",
+    symbol: "CFX",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://evmtestnet.confluxrpc.com"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "ConfluxScan eSpace Testnet",
+      url: "https://evmtestnet.confluxscan.net"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 117499050
+    }
+  }
+};
+var EVM_LOCAL = {
+  id: 2030,
+  name: "conflux-espace-local",
+  type: "evm",
+  testnet: true,
+  nativeCurrency: {
+    name: "Conflux",
+    symbol: "CFX",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["http://localhost:8545"]
+    }
+  }
+};
+var SUPPORTED_CHAINS = {
+  1029: CORE_MAINNET,
+  1: CORE_TESTNET,
+  2029: CORE_LOCAL,
+  1030: EVM_MAINNET,
+  71: EVM_TESTNET,
+  2030: EVM_LOCAL
+};
+function getChainConfig(chainId) {
+  const config = SUPPORTED_CHAINS[chainId];
+  if (!config) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  return config;
+}
+function isValidChainId(chainId) {
+  return chainId in SUPPORTED_CHAINS;
+}
+var NetworkSelector = class {
+  currentChainId;
+  previousChainId = null;
+  listeners = /* @__PURE__ */ new Set();
+  nodeRunningListeners = /* @__PURE__ */ new Set();
+  isNodeRunning = false;
+  lockedToLocal = false;
+  constructor(initialChainId = 1) {
+    this.currentChainId = initialChainId;
+  }
+  getCurrentChain() {
+    return getChainConfig(this.currentChainId);
+  }
+  getCurrentChainId() {
+    return this.currentChainId;
+  }
+  /**
+   * Switch to a specific chain
+   * @param chainId - Chain ID to switch to
+   * @param force - Force switch even if node is running (for wallet operations)
+   */
+  switchChain(chainId, force = false) {
+    if (!isValidChainId(chainId)) {
+      throw new Error(`Invalid chain ID: ${chainId}`);
+    }
+    if (this.isNodeRunning && !this.isLocalChain(chainId) && !force) {
+      console.warn(
+        `Cannot switch to chain ${chainId} while local node is running. Use force=true for wallet operations.`
+      );
+      return;
+    }
+    if (this.currentChainId !== chainId) {
+      this.currentChainId = chainId;
+      this.notifyListeners();
+    }
+  }
+  /**
+   * Called when local node starts - automatically switches to local chains
+   */
+  onNodeStart(coreChainId = 2029, evmChainId = 2030) {
+    if (!this.isNodeRunning) {
+      if (!this.isLocal()) {
+        this.previousChainId = this.currentChainId;
+      }
+      this.isNodeRunning = true;
+      this.lockedToLocal = true;
+      const targetLocalChain = this.isEvm() ? evmChainId : coreChainId;
+      this.switchChain(targetLocalChain, true);
+      this.notifyNodeRunningListeners();
+    }
+  }
+  /**
+   * Called when local node stops - can restore previous chain
+   */
+  onNodeStop(restorePrevious = true) {
+    if (this.isNodeRunning) {
+      this.isNodeRunning = false;
+      this.lockedToLocal = false;
+      if (restorePrevious && this.previousChainId) {
+        this.switchChain(this.previousChainId, true);
+        this.previousChainId = null;
+      }
+      this.notifyNodeRunningListeners();
+    }
+  }
+  /**
+   * Check if node is currently running
+   */
+  getNodeRunningStatus() {
+    return this.isNodeRunning;
+  }
+  /**
+   * Check if selector is locked to local chains
+   */
+  isLockedToLocal() {
+    return this.lockedToLocal;
+  }
+  onChainChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  onNodeRunningChange(listener) {
+    this.nodeRunningListeners.add(listener);
+    return () => this.nodeRunningListeners.delete(listener);
+  }
+  notifyListeners() {
+    for (const listener of this.listeners) {
+      try {
+        listener(this.currentChainId);
+      } catch (error) {
+        console.error("Error in chain change listener:", error);
+      }
+    }
+  }
+  notifyNodeRunningListeners() {
+    for (const listener of this.nodeRunningListeners) {
+      try {
+        listener(this.isNodeRunning);
+      } catch (error) {
+        console.error("Error in node running listener:", error);
+      }
+    }
+  }
+  isLocalChain(chainId) {
+    return chainId === 2029 || chainId === 2030;
+  }
+  // Helper methods for chain type detection
+  isCore() {
+    return this.getCurrentChain().type === "core";
+  }
+  isEvm() {
+    return this.getCurrentChain().type === "evm";
+  }
+  isTestnet() {
+    return this.getCurrentChain().testnet;
+  }
+  isLocal() {
+    return this.currentChainId === 2029 || this.currentChainId === 2030;
+  }
+  // Get corresponding chain IDs
+  getCorrespondingChainId() {
+    switch (this.currentChainId) {
+      case 1029:
+        return 1030;
+      // Core mainnet -> eSpace mainnet
+      case 1030:
+        return 1029;
+      // eSpace mainnet -> Core mainnet
+      case 1:
+        return 71;
+      // Core testnet -> eSpace testnet
+      case 71:
+        return 1;
+      // eSpace testnet -> Core testnet
+      case 2029:
+        return 2030;
+      // Core local -> eSpace local
+      case 2030:
+        return 2029;
+      // eSpace local -> Core local
+      default:
+        return null;
+    }
+  }
+  /**
+   * Update local chain configurations with actual node URLs
+   * Called when ServerManager starts with specific ports
+   */
+  updateLocalChainUrls(coreRpcPort, evmRpcPort, wsPort) {
+    const coreLocal = SUPPORTED_CHAINS[2029];
+    if (coreLocal) {
+      coreLocal.rpcUrls.default.http = [`http://localhost:${coreRpcPort}`];
+      if (wsPort) {
+        coreLocal.rpcUrls.default.webSocket = [`ws://localhost:${wsPort}`];
+      }
+    }
+    const evmLocal = SUPPORTED_CHAINS[2030];
+    if (evmLocal) {
+      evmLocal.rpcUrls.default.http = [`http://localhost:${evmRpcPort}`];
+    }
+  }
+};
+var defaultNetworkSelector = new NetworkSelector();
+
+// src/types/config.ts
+var NodeError = class extends Error {
+  code;
+  chain;
+  context;
+  constructor(message, code, chain, context) {
+    super(message);
+    this.name = "NodeError";
+    this.code = code;
+    this.chain = chain;
+    this.context = context;
+  }
+};
+
+// src/clients/core.ts
+var conflux = (0, import_utils2.defineChain)({
+  id: 1029,
+  name: "Conflux Core",
+  nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
+  rpcUrls: { default: { http: ["https://main.confluxrpc.com"] } }
+});
+var confluxTestnet = (0, import_utils2.defineChain)({
+  id: 1,
+  name: "Conflux Core Testnet",
+  nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
+  rpcUrls: { default: { http: ["https://test.confluxrpc.com"] } }
+});
+var CoreClient = class {
+  chainType = "core";
+  chainId;
+  address;
+  publicClient;
+  chain;
+  constructor(config) {
+    this.chainId = config.chainId;
+    this.chain = (0, import_utils2.defineChain)({
+      id: this.chainId,
+      name: `ConfluxCore-${this.chainId}`,
+      nativeCurrency: {
+        decimals: 18,
+        name: "Conflux",
+        symbol: "CFX"
+      },
+      rpcUrls: {
+        default: {
+          http: [config.rpcUrl],
+          webSocket: config.wsUrl ? [config.wsUrl] : void 0
+        }
+      }
+    });
+    this.publicClient = (0, import_cive.createPublicClient)({
+      chain: this.chain,
+      transport: (0, import_cive.http)(config.rpcUrl),
+      pollingInterval: config.pollingInterval || 1e3
+    });
+    this.address = "";
+  }
+  async getBlockNumber() {
+    try {
+      const epochNumber = await this.publicClient.getEpochNumber();
+      return BigInt(epochNumber.toString());
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get block number: ${error instanceof Error ? error.message : String(error)}`,
+        "BLOCK_NUMBER_ERROR",
+        "core",
+        { originalError: error }
+      );
+    }
+  }
+  async getBalance(address) {
+    if (!(0, import_utils2.isAddress)(address)) {
+      throw new NodeError(
+        "Invalid Core address format",
+        "INVALID_ADDRESS",
+        "core"
+      );
+    }
+    try {
+      const balance = await this.publicClient.getBalance({ address });
+      return (0, import_cive.formatCFX)(balance);
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get balance: ${error instanceof Error ? error.message : String(error)}`,
+        "BALANCE_ERROR",
+        "core",
+        { address, originalError: error }
+      );
+    }
+  }
+  async getGasPrice() {
+    try {
+      const gasPrice = await this.publicClient.getGasPrice();
+      return gasPrice;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get gas price: ${error instanceof Error ? error.message : String(error)}`,
+        "GAS_PRICE_ERROR",
+        "core",
+        { originalError: error }
+      );
+    }
+  }
+  async estimateGas(tx) {
+    try {
+      const estimate = await this.publicClient.request({
+        method: "cfx_estimateGasAndCollateral",
+        params: [
+          {
+            to: tx.to,
+            value: tx.value ? `0x${tx.value.toString(16)}` : void 0,
+            data: tx.data
+          }
+        ]
+      });
+      return BigInt(estimate.gasLimit);
+    } catch (error) {
+      throw new NodeError(
+        `Failed to estimate gas: ${error instanceof Error ? error.message : String(error)}`,
+        "GAS_ESTIMATE_ERROR",
+        "core",
+        { transaction: tx, originalError: error }
+      );
+    }
+  }
+  async sendTransaction(_tx) {
+    throw new NodeError(
+      "Cannot send transaction from public client. Use wallet client instead.",
+      "WALLET_REQUIRED",
+      "core"
+    );
+  }
+  async waitForTransaction(hash) {
+    try {
+      const receipt = await this.publicClient.waitForTransactionReceipt({
+        hash
+      });
+      return {
+        hash: receipt.transactionHash,
+        blockNumber: BigInt(receipt.epochNumber?.toString() || "0"),
+        blockHash: receipt.blockHash || "",
+        transactionIndex: Number(receipt.index || 0),
+        status: receipt.outcomeStatus === "success" ? "success" : "reverted",
+        gasUsed: receipt.gasUsed || 0n,
+        contractAddress: receipt.contractCreated || void 0,
+        logs: receipt.log?.map((log) => ({
+          address: log.address || "",
+          topics: log.topics || [],
+          data: log.data || "0x",
+          blockNumber: BigInt(log.epochNumber?.toString() || "0"),
+          transactionHash: log.transactionHash || "",
+          logIndex: Number(log.logIndex || 0)
+        })) || []
+      };
+    } catch (error) {
+      throw new NodeError(
+        `Failed to wait for transaction: ${error instanceof Error ? error.message : String(error)}`,
+        "TRANSACTION_WAIT_ERROR",
+        "core",
+        { hash, originalError: error }
+      );
+    }
+  }
+  async getTokenBalance(tokenAddress, holderAddress) {
+    const holder = holderAddress || this.address;
+    if (!this.isValidAddress(tokenAddress)) {
+      throw new NodeError(
+        "Invalid token address format",
+        "INVALID_ADDRESS",
+        "core",
+        { tokenAddress }
+      );
+    }
+    if (!this.isValidAddress(holder)) {
+      throw new NodeError(
+        "Invalid holder address format",
+        "INVALID_ADDRESS",
+        "core",
+        { holder }
+      );
+    }
+    try {
+      const [balance, decimals] = await Promise.all([
+        this.publicClient.readContract({
+          address: tokenAddress,
+          abi: [
+            {
+              name: "balanceOf",
+              type: "function",
+              inputs: [{ name: "account", type: "address" }],
+              outputs: [{ name: "", type: "uint256" }],
+              stateMutability: "view"
+            }
+          ],
+          functionName: "balanceOf",
+          args: [holder]
+        }),
+        this.publicClient.readContract({
+          address: tokenAddress,
+          abi: [
+            {
+              name: "decimals",
+              type: "function",
+              inputs: [],
+              outputs: [{ name: "", type: "uint8" }],
+              stateMutability: "view"
+            }
+          ],
+          functionName: "decimals"
+        })
+      ]);
+      return this.formatTokenAmount(balance, Number(decimals));
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get token balance: ${error instanceof Error ? error.message : String(error)}`,
+        "TOKEN_BALANCE_ERROR",
+        "core",
+        { tokenAddress, holder, originalError: error }
+      );
+    }
+  }
+  watchBlocks(callback) {
+    return this.publicClient.watchEpochNumber({
+      emitMissed: false,
+      epochTag: "latest_mined",
+      onEpochNumber: async (epochNumber) => {
+        try {
+          const blockHashes = await this.publicClient.getBlocksByEpoch({
+            epochNumber
+          });
+          for (const hash of blockHashes) {
+            try {
+              const block = await this.publicClient.getBlock({
+                blockHash: hash
+              });
+              const blockEvent = {
+                chainType: "core",
+                blockNumber: BigInt(block.epochNumber?.toString() || "0"),
+                blockHash: block.hash || "",
+                timestamp: Number(block.timestamp || 0),
+                transactionCount: block.transactions?.length || 0
+              };
+              callback(blockEvent);
+            } catch (error) {
+              console.error(`Failed to process block ${hash}:`, error);
+            }
+          }
+        } catch (error) {
+          console.error(
+            `Failed to get blocks for epoch ${epochNumber}:`,
+            error
+          );
+        }
+      }
+    });
+  }
+  watchTransactions(callback) {
+    return this.publicClient.watchEpochNumber({
+      emitMissed: false,
+      epochTag: "latest_mined",
+      onEpochNumber: async (epochNumber) => {
+        try {
+          const blockHashes = await this.publicClient.getBlocksByEpoch({
+            epochNumber
+          });
+          for (const hash of blockHashes) {
+            try {
+              const block = await this.publicClient.getBlock({
+                blockHash: hash
+              });
+              await Promise.all(
+                (block.transactions || []).map(
+                  async (txHash) => {
+                    try {
+                      const tx = await this.publicClient.getTransaction({
+                        hash: txHash
+                      });
+                      const txEvent = {
+                        chainType: "core",
+                        hash: tx.hash,
+                        from: tx.from,
+                        to: tx.to || void 0,
+                        value: tx.value || 0n,
+                        blockNumber: BigInt(
+                          block.epochNumber?.toString() || "0"
+                        )
+                      };
+                      callback(txEvent);
+                    } catch (error) {
+                      console.error(
+                        `Failed to get transaction ${txHash}:`,
+                        error
+                      );
+                    }
+                  }
+                )
+              );
+            } catch (error) {
+              console.error(`Failed to process block ${hash}:`, error);
+            }
+          }
+        } catch (error) {
+          console.error(
+            `Failed to get blocks for epoch ${epochNumber}:`,
+            error
+          );
+        }
+      }
+    });
+  }
+  isValidAddress(address) {
+    return (0, import_utils2.isAddress)(address);
+  }
+  formatAmount(amount) {
+    return (0, import_cive.formatCFX)(amount);
+  }
+  parseAmount(amount) {
+    return (0, import_cive.parseCFX)(amount);
+  }
+  getInternalClient() {
+    return this.publicClient;
+  }
+  formatTokenAmount(amount, decimals) {
+    const formatted = (0, import_utils2.formatUnits)(amount, decimals);
+    return Number(formatted).toFixed(4);
+  }
+};
+var CoreWalletClient = class {
+  chainType = "core";
+  address;
+  chainId;
+  walletClient;
+  publicClient;
+  account;
+  chain;
+  constructor(config) {
+    this.chainId = config.chainId;
+    this.chain = (0, import_utils2.defineChain)({
+      id: config.chainId,
+      name: `ConfluxCore-${config.chainId}`,
+      nativeCurrency: {
+        decimals: 18,
+        name: "Conflux",
+        symbol: "CFX"
+      },
+      rpcUrls: {
+        default: {
+          http: [config.rpcUrl],
+          webSocket: config.wsUrl ? [config.wsUrl] : void 0
+        }
+      }
+    });
+    this.account = (0, import_accounts.privateKeyToAccount)(config.privateKey, {
+      networkId: config.chainId
+    });
+    this.address = this.account.address;
+    this.walletClient = (0, import_cive.createWalletClient)({
+      account: this.account,
+      chain: this.chain,
+      transport: (0, import_cive.http)(config.rpcUrl),
+      pollingInterval: config.pollingInterval || 1e3
+    });
+    this.publicClient = (0, import_cive.createPublicClient)({
+      chain: this.chain,
+      transport: (0, import_cive.http)(config.rpcUrl),
+      pollingInterval: config.pollingInterval || 1e3
+    });
+  }
+  async sendTransaction(tx) {
+    try {
+      return await this.walletClient.sendTransaction({
+        to: tx.to,
+        value: tx.value,
+        data: tx.data,
+        gas: tx.gasLimit,
+        gasPrice: tx.gasPrice,
+        nonce: tx.nonce,
+        account: this.account,
+        chain: this.chain
+      });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to send transaction: ${error instanceof Error ? error.message : String(error)}`,
+        "TRANSACTION_SEND_ERROR",
+        "core",
+        { transaction: tx, originalError: error }
+      );
+    }
+  }
+  async signMessage(message) {
+    try {
+      return await this.walletClient.signMessage({
+        account: this.account,
+        message
+      });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to sign message: ${error instanceof Error ? error.message : String(error)}`,
+        "MESSAGE_SIGN_ERROR",
+        "core",
+        { message, originalError: error }
+      );
+    }
+  }
+  getInternalClient() {
+    return this.walletClient;
+  }
+  async waitForTransaction(hash) {
+    try {
+      const receipt = await this.publicClient.waitForTransactionReceipt({
+        hash,
+        timeout: 5e3
+        // 5 second timeout for faster response
+      });
+      return {
+        hash: receipt.transactionHash,
+        blockNumber: BigInt(receipt.epochNumber?.toString() || "0"),
+        blockHash: receipt.blockHash || "",
+        transactionIndex: Number(receipt.index || 0),
+        status: receipt.outcomeStatus === "success" ? "success" : "reverted",
+        gasUsed: receipt.gasUsed || 0n,
+        contractAddress: receipt.contractCreated || void 0,
+        logs: receipt.log?.map((log) => ({
+          address: log.address || "",
+          topics: log.topics || [],
+          data: log.data || "0x",
+          blockNumber: BigInt(log.epochNumber?.toString() || "0"),
+          transactionHash: log.transactionHash || "",
+          logIndex: Number(log.logIndex || 0)
+        })) || []
+      };
+    } catch (error) {
+      throw new NodeError(
+        `Failed to wait for transaction: ${error instanceof Error ? error.message : String(error)}`,
+        "TRANSACTION_WAIT_ERROR",
+        "core",
+        { hash, originalError: error }
+      );
+    }
+  }
+  /**
+   * Unified faucet functionality
+   * Automatically detects address type and sends CFX accordingly:
+   * - Core address: Direct transfer
+   * - eSpace address: Cross-chain transfer via internal contract
+   */
+  async faucet(address, amount) {
+    const isCoreAddr = (0, import_utils2.isAddress)(address);
+    const isEspaceAddr = (0, import_viem2.isAddress)(address);
+    if (!isCoreAddr && !isEspaceAddr) {
+      throw new NodeError(
+        "Invalid address format (must be Core or eSpace address)",
+        "INVALID_ADDRESS",
+        "core",
+        { address }
+      );
+    }
+    try {
+      if (isCoreAddr) {
+        return await this.walletClient.sendTransaction({
+          chain: this.chain,
+          account: this.account,
+          to: address,
+          value: (0, import_cive.parseCFX)(amount)
+        });
+      } else {
+        return await this.walletClient.sendTransaction({
+          chain: this.chain,
+          account: this.account,
+          to: (0, import_utils2.hexAddressToBase32)({
+            hexAddress: "0x0888000000000000000000000000000000000006",
+            networkId: this.chain.id
+          }),
+          value: (0, import_cive.parseCFX)(amount),
+          data: (0, import_utils2.encodeFunctionData)({
+            abi: [
+              {
+                type: "function",
+                name: "transferEVM",
+                inputs: [{ name: "to", type: "bytes20" }],
+                outputs: [{ name: "output", type: "bytes" }],
+                stateMutability: "payable"
+              }
+            ],
+            functionName: "transferEVM",
+            args: [address]
+          })
+        });
+      }
+    } catch (error) {
+      throw new NodeError(
+        `Failed to send faucet transaction: ${error instanceof Error ? error.message : String(error)}`,
+        "FAUCET_ERROR",
+        "core",
+        { address, amount, originalError: error }
+      );
+    }
+  }
+  /**
+   * 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
+   */
+  async faucetToEspace(espaceAddress, amount) {
+    if (!(0, import_viem2.isAddress)(espaceAddress)) {
+      throw new NodeError(
+        "Invalid eSpace address format",
+        "INVALID_ADDRESS",
+        "core",
+        { espaceAddress }
+      );
+    }
+    try {
+      return await this.walletClient.sendTransaction({
+        chain: this.chain,
+        account: this.account,
+        to: (0, import_utils2.hexAddressToBase32)({
+          hexAddress: "0x0888000000000000000000000000000000000006",
+          networkId: this.chain.id
+        }),
+        value: (0, import_cive.parseCFX)(amount),
+        data: (0, import_utils2.encodeFunctionData)({
+          abi: [
+            {
+              type: "function",
+              name: "transferEVM",
+              inputs: [{ name: "to", type: "bytes20" }],
+              outputs: [{ name: "output", type: "bytes" }],
+              stateMutability: "payable"
+            }
+          ],
+          functionName: "transferEVM",
+          args: [espaceAddress]
+        })
+      });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to send faucet transaction to eSpace: ${error instanceof Error ? error.message : String(error)}`,
+        "FAUCET_ERROR",
+        "core",
+        { espaceAddress, amount, originalError: error }
+      );
+    }
+  }
+  /**
+   * Deploy a contract to Core Space
+   */
+  async deployContract(abi, bytecode, constructorArgs = []) {
+    try {
+      const hash = await this.walletClient.deployContract({
+        account: this.account,
+        chain: this.chain,
+        abi,
+        bytecode,
+        args: constructorArgs
+      });
+      const receipt = await this.waitForTransaction(hash);
+      if (!receipt.contractAddress) {
+        throw new Error("Contract address not found in transaction receipt");
+      }
+      return receipt.contractAddress;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to deploy contract: ${error instanceof Error ? error.message : String(error)}`,
+        "DEPLOYMENT_ERROR",
+        "core",
+        { abi, bytecode, constructorArgs, originalError: error }
+      );
+    }
+  }
+  /**
+   * Call a contract method (read-only)
+   */
+  async callContract(address, abi, functionName, args = []) {
+    try {
+      const result = await this.publicClient.readContract({
+        address,
+        abi,
+        functionName,
+        args
+      });
+      return result;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to call contract: ${error instanceof Error ? error.message : String(error)}`,
+        "CONTRACT_CALL_ERROR",
+        "core",
+        { address, functionName, args, originalError: error }
+      );
+    }
+  }
+  /**
+   * Write to a contract (transaction)
+   */
+  async writeContract(address, abi, functionName, args = [], value) {
+    try {
+      const hash = await this.walletClient.writeContract({
+        account: this.account,
+        chain: this.chain,
+        address,
+        abi,
+        functionName,
+        args,
+        value
+      });
+      return hash;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to write to contract: ${error instanceof Error ? error.message : String(error)}`,
+        "CONTRACT_WRITE_ERROR",
+        "core",
+        { address, functionName, args, value, originalError: error }
+      );
+    }
+  }
+};
+var CoreTestClient = class extends CoreClient {
+  testClient;
+  constructor(config) {
+    super(config);
+    this.testClient = (0, import_cive.createTestClient)({
+      chain: this.chainId === 1029 ? conflux : confluxTestnet,
+      transport: (0, import_cive.http)(config.rpcUrl),
+      pollingInterval: config.pollingInterval || 1e3
+    });
+  }
+  async mine(blocks = 1) {
+    try {
+      await this.testClient.mine({ blocks });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to mine blocks: ${error instanceof Error ? error.message : String(error)}`,
+        "MINE_ERROR",
+        "core",
+        { blocks, originalError: error }
+      );
+    }
+  }
+  async setNextBlockTimestamp(_timestamp) {
+    throw new NodeError(
+      "setNextBlockTimestamp not implemented for Core client",
+      "NOT_IMPLEMENTED",
+      "core"
+    );
+  }
+  async increaseTime(_seconds) {
+    throw new NodeError(
+      "increaseTime not implemented for Core client",
+      "NOT_IMPLEMENTED",
+      "core"
+    );
+  }
+  async impersonateAccount(_address) {
+    throw new NodeError(
+      "impersonateAccount not implemented for Core client",
+      "NOT_IMPLEMENTED",
+      "core"
+    );
+  }
+  async stopImpersonatingAccount(_address) {
+    throw new NodeError(
+      "stopImpersonatingAccount not implemented for Core client",
+      "NOT_IMPLEMENTED",
+      "core"
+    );
+  }
+  async setBalance(_address, _balance) {
+    throw new NodeError(
+      "setBalance not implemented for Core client",
+      "NOT_IMPLEMENTED",
+      "core"
+    );
+  }
+  async getStorageAt(_address, _slot) {
+    throw new NodeError(
+      "getStorageAt not implemented for Core client",
+      "NOT_IMPLEMENTED",
+      "core"
+    );
+  }
+  async setStorageAt(_address, _slot, _value) {
+    throw new NodeError(
+      "setStorageAt not implemented for Core client",
+      "NOT_IMPLEMENTED",
+      "core"
+    );
+  }
+  getInternalTestClient() {
+    return this.testClient;
+  }
+};
+async function createCoreClient(config) {
+  const chainConfig = getChainConfig(config.chainId);
+  if (chainConfig.type !== "core") {
+    throw new NodeError(
+      `Invalid chain type for Core client: ${chainConfig.type}`,
+      "INVALID_CHAIN_TYPE",
+      "core"
+    );
+  }
+  const clientConfig = {
+    ...config,
+    rpcUrl: config.rpcUrl || chainConfig.rpcUrls.default.http[0] || "http://localhost:12537",
+    wsUrl: config.wsUrl || chainConfig.rpcUrls.default.webSocket?.[0]
+  };
+  const publicClient = new CoreClient(clientConfig);
+  let walletClient;
+  let testClient;
+  if (config.account) {
+    let privateKey;
+    if (typeof config.account === "string") {
+      privateKey = config.account;
+    } else {
+      privateKey = config.account.privateKey;
+    }
+    const walletConfig = {
+      ...clientConfig,
+      privateKey,
+      accountIndex: typeof config.account === "object" ? config.account.accountIndex : 0
+    };
+    walletClient = new CoreWalletClient(walletConfig);
+  }
+  if (config.testMode) {
+    const testConfig = {
+      ...clientConfig,
+      enableTestMode: true
+    };
+    testClient = new CoreTestClient(testConfig);
+  }
+  return {
+    publicClient,
+    walletClient,
+    testClient
+  };
+}
+
+// src/clients/evm.ts
+var import_viem3 = require("viem");
+var import_accounts2 = require("viem/accounts");
+var espaceMainnet = (0, import_viem3.defineChain)({
+  id: 1030,
+  name: "Conflux eSpace",
+  nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
+  rpcUrls: { default: { http: ["https://evm.confluxrpc.com"] } },
+  blockExplorers: {
+    default: { name: "ConfluxScan", url: "https://evm.confluxscan.net" }
+  }
+});
+var espaceTestnet = (0, import_viem3.defineChain)({
+  id: 71,
+  name: "Conflux eSpace Testnet",
+  nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
+  rpcUrls: { default: { http: ["https://evmtestnet.confluxrpc.com"] } },
+  blockExplorers: {
+    default: { name: "ConfluxScan", url: "https://evmtestnet.confluxscan.net" }
+  }
+});
+var EspaceClient = class {
+  chainId;
+  chainType = "evm";
+  publicClient;
+  chain;
+  address;
+  constructor(config) {
+    this.chainId = config.chainId;
+    if (config.chainId === 1030) {
+      this.chain = espaceMainnet;
+    } else if (config.chainId === 71) {
+      this.chain = espaceTestnet;
+    } else {
+      this.chain = (0, import_viem3.defineChain)({
+        id: config.chainId,
+        name: `Conflux eSpace (${config.chainId})`,
+        nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
+        rpcUrls: { default: { http: [config.rpcUrl] } }
+      });
+    }
+    this.publicClient = (0, import_viem3.createPublicClient)({
+      chain: this.chain,
+      transport: (0, import_viem3.http)(config.rpcUrl),
+      pollingInterval: config.pollingInterval || 1e3
+    });
+    this.address = "";
+  }
+  async getBlockNumber() {
+    try {
+      const blockNumber = await this.publicClient.getBlockNumber();
+      return blockNumber;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get block number: ${error instanceof Error ? error.message : String(error)}`,
+        "BLOCK_NUMBER_ERROR",
+        "evm",
+        { originalError: error }
+      );
+    }
+  }
+  async getBalance(address) {
+    if (!(0, import_viem3.isAddress)(address)) {
+      throw new NodeError(
+        "Invalid EVM address format",
+        "INVALID_ADDRESS",
+        "evm"
+      );
+    }
+    try {
+      const balance = await this.publicClient.getBalance({ address });
+      return (0, import_viem3.formatEther)(balance);
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get balance: ${error instanceof Error ? error.message : String(error)}`,
+        "BALANCE_ERROR",
+        "evm",
+        { address, originalError: error }
+      );
+    }
+  }
+  async estimateGas(tx) {
+    try {
+      const gas = await this.publicClient.estimateGas({
+        to: tx.to,
+        value: tx.value,
+        data: tx.data
+      });
+      return gas;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to estimate gas: ${error instanceof Error ? error.message : String(error)}`,
+        "GAS_ESTIMATE_ERROR",
+        "evm",
+        { transaction: tx, originalError: error }
+      );
+    }
+  }
+  async waitForTransaction(hash) {
+    try {
+      const receipt = await this.publicClient.waitForTransactionReceipt({
+        hash,
+        timeout: 5e3
+        // 5 second timeout for faster response
+      });
+      return {
+        hash: receipt.transactionHash,
+        blockNumber: receipt.blockNumber,
+        blockHash: receipt.blockHash,
+        transactionIndex: receipt.transactionIndex,
+        status: receipt.status === "success" ? "success" : "reverted",
+        gasUsed: receipt.gasUsed,
+        contractAddress: receipt.contractAddress || void 0,
+        logs: receipt.logs.map((log) => ({
+          address: log.address,
+          topics: log.topics,
+          data: log.data,
+          blockNumber: log.blockNumber || 0n,
+          transactionHash: log.transactionHash || "",
+          logIndex: log.logIndex || 0
+        }))
+      };
+    } catch (error) {
+      throw new NodeError(
+        `Failed to wait for transaction: ${error instanceof Error ? error.message : String(error)}`,
+        "TRANSACTION_WAIT_ERROR",
+        "evm",
+        { hash, originalError: error }
+      );
+    }
+  }
+  async getGasPrice() {
+    try {
+      const gasPrice = await this.publicClient.getGasPrice();
+      return gasPrice;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get gas price: ${error instanceof Error ? error.message : String(error)}`,
+        "GAS_PRICE_ERROR",
+        "evm",
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Get the current chain ID from the network
+   */
+  async getChainId() {
+    try {
+      const chainId = await this.publicClient.getChainId();
+      return chainId;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get chain ID: ${error instanceof Error ? error.message : String(error)}`,
+        "CHAIN_ID_ERROR",
+        "evm",
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Check if the client is connected to the network
+   */
+  async isConnected() {
+    try {
+      await this.publicClient.getBlockNumber();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // Base implementation - should be overridden by WalletClient
+  async sendTransaction(_tx) {
+    throw new NodeError(
+      "sendTransaction not available on public client",
+      "METHOD_NOT_AVAILABLE",
+      "evm"
+    );
+  }
+  async getTokenBalance(_address, _tokenAddress) {
+    try {
+      const balance = await this.publicClient.readContract({
+        address: _tokenAddress,
+        abi: [
+          {
+            type: "function",
+            name: "balanceOf",
+            inputs: [{ name: "account", type: "address" }],
+            outputs: [{ name: "balance", type: "uint256" }],
+            stateMutability: "view"
+          }
+        ],
+        functionName: "balanceOf",
+        args: [_address]
+      });
+      return balance.toString();
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get token balance: ${error instanceof Error ? error.message : String(error)}`,
+        "TOKEN_BALANCE_ERROR",
+        "evm",
+        { address: _address, tokenAddress: _tokenAddress, originalError: error }
+      );
+    }
+  }
+  watchBlocks(callback) {
+    const unwatch = this.publicClient.watchBlocks({
+      onBlock: (block) => callback({
+        chainType: "evm",
+        blockNumber: block.number || 0n,
+        blockHash: block.hash || "",
+        timestamp: Number(block.timestamp || 0),
+        transactionCount: block.transactions?.length || 0
+      })
+    });
+    return unwatch;
+  }
+  async watchTransaction(_hash, _callback) {
+    const pollTransaction = async () => {
+      try {
+        const receipt = await this.waitForTransaction(_hash);
+        _callback(receipt);
+      } catch {
+        setTimeout(pollTransaction, 1e3);
+      }
+    };
+    setTimeout(pollTransaction, 1e3);
+    return () => {
+    };
+  }
+  getInternalClient() {
+    return this.publicClient;
+  }
+  // Base implementation - should be overridden by TestClient
+  watchTransactions(_callback) {
+    throw new NodeError(
+      "watchTransactions not available on public client",
+      "METHOD_NOT_AVAILABLE",
+      "evm"
+    );
+  }
+  isValidAddress(address) {
+    return (0, import_viem3.isAddress)(address);
+  }
+  formatAmount(amount) {
+    return (0, import_viem3.formatEther)(amount);
+  }
+  parseAmount(amount) {
+    return (0, import_viem3.parseEther)(amount);
+  }
+};
+var EspaceWalletClient = class extends EspaceClient {
+  walletClient;
+  account;
+  constructor(config) {
+    super(config);
+    this.account = (0, import_accounts2.privateKeyToAccount)(config.privateKey);
+    this.address = this.account.address;
+    this.walletClient = (0, import_viem3.createWalletClient)({
+      account: this.account,
+      chain: this.chain,
+      transport: (0, import_viem3.http)(config.rpcUrl)
+    });
+  }
+  getAddress() {
+    return this.address;
+  }
+  async sendTransaction(tx) {
+    try {
+      const hash = await this.walletClient.sendTransaction({
+        account: this.account,
+        chain: this.chain,
+        to: tx.to,
+        value: tx.value,
+        data: tx.data,
+        gas: tx.gasLimit,
+        gasPrice: tx.gasPrice,
+        nonce: tx.nonce
+      });
+      return hash;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to send transaction: ${error instanceof Error ? error.message : String(error)}`,
+        "TRANSACTION_ERROR",
+        "evm",
+        { transaction: tx, originalError: error }
+      );
+    }
+  }
+  async signMessage(message) {
+    try {
+      const signature = await this.walletClient.signMessage({
+        account: this.account,
+        message
+      });
+      return signature;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to sign message: ${error instanceof Error ? error.message : String(error)}`,
+        "SIGNING_ERROR",
+        "evm",
+        { message, originalError: error }
+      );
+    }
+  }
+  async deployContract(abi, bytecode, constructorArgs = []) {
+    try {
+      const hash = await this.walletClient.deployContract({
+        account: this.account,
+        chain: this.chain,
+        abi,
+        bytecode,
+        args: constructorArgs
+      });
+      const receipt = await this.waitForTransaction(hash);
+      if (!receipt.contractAddress) {
+        throw new Error("Contract address not found in transaction receipt");
+      }
+      return receipt.contractAddress;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to deploy contract: ${error instanceof Error ? error.message : String(error)}`,
+        "DEPLOYMENT_ERROR",
+        "evm",
+        { bytecode, constructorArgs, originalError: error }
+      );
+    }
+  }
+  async callContract(address, abi, functionName, args = []) {
+    try {
+      const result = await this.publicClient.readContract({
+        address,
+        abi,
+        functionName,
+        args
+      });
+      return result;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to call contract: ${error instanceof Error ? error.message : String(error)}`,
+        "CONTRACT_CALL_ERROR",
+        "evm",
+        { address, functionName, args, originalError: error }
+      );
+    }
+  }
+  async writeContract(address, abi, functionName, args = [], value) {
+    try {
+      const hash = await this.walletClient.writeContract({
+        account: this.account,
+        chain: this.chain,
+        address,
+        abi,
+        functionName,
+        args,
+        value
+      });
+      return hash;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to write contract: ${error instanceof Error ? error.message : String(error)}`,
+        "CONTRACT_WRITE_ERROR",
+        "evm",
+        { address, functionName, args, value, originalError: error }
+      );
+    }
+  }
+  /**
+   * Transfer CFX from eSpace to Core Space
+   * Uses the built-in withdrawal mechanism
+   */
+  async faucetToCore(coreAddress, amount) {
+    if (!coreAddress.startsWith("cfx:") || coreAddress.length < 30) {
+      throw new NodeError(
+        "Invalid Core address format",
+        "INVALID_ADDRESS",
+        "evm",
+        { coreAddress }
+      );
+    }
+    try {
+      const hash = await this.walletClient.sendTransaction({
+        account: this.account,
+        chain: this.chain,
+        to: "0x0888000000000000000000000000000000000006",
+        // CrossSpaceCall precompiled address
+        value: (0, import_viem3.parseEther)(amount),
+        data: (0, import_viem3.encodeFunctionData)({
+          abi: [
+            {
+              type: "function",
+              name: "withdrawFromMapped",
+              inputs: [{ name: "value", type: "uint256" }],
+              outputs: [],
+              stateMutability: "payable"
+            }
+          ],
+          functionName: "withdrawFromMapped",
+          args: [(0, import_viem3.parseEther)(amount)]
+        })
+      });
+      return hash;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to send faucet transaction to Core: ${error instanceof Error ? error.message : String(error)}`,
+        "FAUCET_ERROR",
+        "evm",
+        { coreAddress, amount, originalError: error }
+      );
+    }
+  }
+  getInternalClient() {
+    return this.walletClient;
+  }
+};
+var EspaceTestClient = class extends EspaceWalletClient {
+  testClient;
+  constructor(config) {
+    super(config);
+    this.testClient = (0, import_viem3.createTestClient)({
+      mode: "anvil",
+      chain: this.chainId === 1030 ? espaceMainnet : espaceTestnet,
+      transport: (0, import_viem3.http)(config.rpcUrl),
+      pollingInterval: config.pollingInterval || 1e3
+    });
+  }
+  async mine(blocks = 1) {
+    try {
+      await this.testClient.mine({ blocks });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to mine blocks: ${error instanceof Error ? error.message : String(error)}`,
+        "MINING_ERROR",
+        "evm",
+        { blocks, originalError: error }
+      );
+    }
+  }
+  async setNextBlockTimestamp(timestamp) {
+    try {
+      await this.testClient.setNextBlockTimestamp({
+        timestamp: BigInt(timestamp)
+      });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to set next block timestamp: ${error instanceof Error ? error.message : String(error)}`,
+        "TIMESTAMP_ERROR",
+        "evm",
+        { timestamp, originalError: error }
+      );
+    }
+  }
+  async increaseTime(seconds) {
+    try {
+      await this.testClient.increaseTime({ seconds });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to increase time: ${error instanceof Error ? error.message : String(error)}`,
+        "TIME_INCREASE_ERROR",
+        "evm",
+        { seconds, originalError: error }
+      );
+    }
+  }
+  async impersonateAccount(address) {
+    try {
+      await this.testClient.impersonateAccount({ address });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to impersonate account: ${error instanceof Error ? error.message : String(error)}`,
+        "IMPERSONATION_ERROR",
+        "evm",
+        { address, originalError: error }
+      );
+    }
+  }
+  async stopImpersonatingAccount(address) {
+    try {
+      await this.testClient.stopImpersonatingAccount({
+        address
+      });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to stop impersonating account: ${error instanceof Error ? error.message : String(error)}`,
+        "IMPERSONATION_STOP_ERROR",
+        "evm",
+        { address, originalError: error }
+      );
+    }
+  }
+  async setBalance(address, balance) {
+    try {
+      await this.testClient.setBalance({
+        address,
+        value: balance
+      });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to set balance: ${error instanceof Error ? error.message : String(error)}`,
+        "BALANCE_SET_ERROR",
+        "evm",
+        { address, balance, originalError: error }
+      );
+    }
+  }
+  async snapshot() {
+    try {
+      const snapshotId = await this.testClient.snapshot();
+      return snapshotId;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to create snapshot: ${error instanceof Error ? error.message : String(error)}`,
+        "SNAPSHOT_ERROR",
+        "evm",
+        { originalError: error }
+      );
+    }
+  }
+  async revert(snapshotId) {
+    try {
+      await this.testClient.revert({ id: snapshotId });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to revert to snapshot: ${error instanceof Error ? error.message : String(error)}`,
+        "REVERT_ERROR",
+        "evm",
+        { snapshotId, originalError: error }
+      );
+    }
+  }
+  async getStorageAt(address, slot) {
+    try {
+      const value = await this.publicClient.getStorageAt({
+        address,
+        slot
+      });
+      return value || "0x";
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get storage: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_GET_ERROR",
+        "evm",
+        { address, slot, originalError: error }
+      );
+    }
+  }
+  async setStorageAt(address, slot, value) {
+    try {
+      await this.testClient.setStorageAt({
+        address,
+        index: slot,
+        value
+      });
+    } catch (error) {
+      throw new NodeError(
+        `Failed to set storage: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_SET_ERROR",
+        "evm",
+        { address, slot, value, originalError: error }
+      );
+    }
+  }
+  watchTransactions(callback) {
+    const unwatch = this.publicClient.watchPendingTransactions({
+      onTransactions: (hashes) => {
+        for (const hash of hashes) {
+          callback({
+            chainType: "evm",
+            hash,
+            from: "",
+            // Would need to fetch transaction details
+            to: "",
+            // Would need to fetch transaction details
+            value: 0n,
+            // Would need to fetch transaction details
+            blockNumber: 0n
+            // Would need to fetch transaction details
+          });
+        }
+      }
+    });
+    return unwatch;
+  }
+  isValidAddress(address) {
+    return (0, import_viem3.isAddress)(address);
+  }
+  async getCurrentEpoch() {
+    return await this.getBlockNumber();
+  }
+  async generateAccounts(count) {
+    const accounts = [];
+    for (let i = 0; i < count; i++) {
+      const privateKey = `0x${"0".repeat(64 - 2)}${i.toString(16).padStart(2, "0")}${"0".repeat(60)}`;
+      const account = (0, import_accounts2.privateKeyToAccount)(privateKey);
+      accounts.push(account.address);
+    }
+    return accounts;
+  }
+};
+async function createEspaceClient(config) {
+  const chainConfig = getChainConfig(config.chainId);
+  if (chainConfig.type !== "evm") {
+    throw new NodeError(
+      `Invalid chain type for eSpace client: ${chainConfig.type}`,
+      "INVALID_CHAIN_TYPE",
+      "evm"
+    );
+  }
+  const clientConfig = {
+    ...config,
+    rpcUrl: config.rpcUrl || chainConfig.rpcUrls.default.http[0] || "http://localhost:8545"
+  };
+  const publicClient = new EspaceClient(clientConfig);
+  let walletClient;
+  let testClient;
+  if (config.account) {
+    let privateKey;
+    if (typeof config.account === "string") {
+      privateKey = config.account;
+    } else {
+      privateKey = config.account.privateKey;
+    }
+    const walletConfig = {
+      ...clientConfig,
+      privateKey,
+      accountIndex: typeof config.account === "object" ? config.account.accountIndex : 0
+    };
+    walletClient = new EspaceWalletClient(walletConfig);
+  }
+  if (config.testMode) {
+    let privateKey;
+    if (config.account) {
+      if (typeof config.account === "string") {
+        privateKey = config.account;
+      } else {
+        privateKey = config.account.privateKey;
+      }
+    } else {
+      privateKey = "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
+    }
+    const testConfig = {
+      ...clientConfig,
+      enableTestMode: true,
+      privateKey
+    };
+    testClient = new EspaceTestClient(testConfig);
+  }
+  return {
+    publicClient,
+    walletClient,
+    testClient
+  };
+}
+
+// src/clients/manager.ts
+var import_node_events = require("events");
+var HEALTH_CHECK_INTERVAL = 3e4;
+var HEALTH_CHECK_TIMEOUT = 5e3;
+var ClientManager = class extends import_node_events.EventEmitter {
+  config;
+  coreClient = null;
+  evmClient = null;
+  healthCheckInterval = null;
+  networkSelectorUnsubscribe = null;
+  nodeRunningUnsubscribe = null;
+  initialized = false;
+  constructor(config) {
+    super();
+    this.config = {
+      enableHealthMonitoring: true,
+      healthCheckInterval: HEALTH_CHECK_INTERVAL,
+      healthCheckTimeout: HEALTH_CHECK_TIMEOUT,
+      ...config
+    };
+  }
+  /**
+   * Initialize the Client Manager
+   * Sets up clients, server, and monitoring
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      this.setupNetworkListeners();
+      await this.initializeClients();
+      if (this.config.enableHealthMonitoring) {
+        this.startHealthMonitoring();
+      }
+      this.initialized = true;
+      this.emit("manager:ready");
+    } catch (error) {
+      const managerError = error instanceof Error ? error : new Error(String(error));
+      this.emit("manager:error", { error: managerError });
+      throw managerError;
+    }
+  }
+  /**
+   * Gracefully shutdown the Client Manager
+   */
+  async shutdown() {
+    if (!this.initialized) {
+      return;
+    }
+    try {
+      this.stopHealthMonitoring();
+      if (this.networkSelectorUnsubscribe) {
+        this.networkSelectorUnsubscribe();
+        this.networkSelectorUnsubscribe = null;
+      }
+      if (this.nodeRunningUnsubscribe) {
+        this.nodeRunningUnsubscribe();
+        this.nodeRunningUnsubscribe = null;
+      }
+      this.coreClient = null;
+      this.evmClient = null;
+      this.initialized = false;
+      this.removeAllListeners();
+    } catch (error) {
+      const shutdownError = error instanceof Error ? error : new Error(String(error));
+      this.emit("manager:error", { error: shutdownError });
+      throw shutdownError;
+    }
+  }
+  /**
+   * Get current Core Space client
+   */
+  getCoreClient() {
+    return this.coreClient;
+  }
+  /**
+   * Get current eSpace client
+   */
+  getEvmClient() {
+    return this.evmClient;
+  }
+  /**
+   * Get comprehensive status
+   */
+  getStatus() {
+    const currentChainId = defaultNetworkSelector.getCurrentChainId();
+    const currentChain = getChainConfig(currentChainId);
+    return {
+      initialized: this.initialized,
+      coreClient: {
+        connected: !!this.coreClient,
+        chainId: currentChain.type === "core" ? currentChainId : defaultNetworkSelector.getCorrespondingChainId() || 1,
+        health: "unknown",
+        // TODO: Implement health status tracking
+        lastHealthCheck: void 0
+      },
+      evmClient: {
+        connected: !!this.evmClient,
+        chainId: currentChain.type === "evm" ? currentChainId : defaultNetworkSelector.getCorrespondingChainId() || 71,
+        health: "unknown",
+        // TODO: Implement health status tracking
+        lastHealthCheck: void 0
+      },
+      networkSelector: {
+        currentChain: currentChainId,
+        isLocalNode: defaultNetworkSelector.getNodeRunningStatus(),
+        lockedToLocal: defaultNetworkSelector.isLockedToLocal()
+      }
+    };
+  }
+  /**
+   * Switch to a specific network
+   * @param chainId - Target chain ID
+   * @param force - Force switch even if node is running (for wallet operations)
+   */
+  async switchNetwork(chainId, force = false) {
+    if (!isValidChainId(chainId)) {
+      throw new Error(`Invalid chain ID: ${chainId}`);
+    }
+    const previousChainId = defaultNetworkSelector.getCurrentChainId();
+    if (previousChainId === chainId) {
+      return;
+    }
+    defaultNetworkSelector.switchChain(chainId, force);
+    if (defaultNetworkSelector.getCurrentChainId() === chainId) {
+      await this.initializeClients();
+      this.emit("network:switched", { from: previousChainId, to: chainId });
+    }
+  }
+  /**
+   * Initialize or reinitialize client instances based on current network
+   */
+  async initializeClients() {
+    const currentChainId = defaultNetworkSelector.getCurrentChainId();
+    const currentChain = getChainConfig(currentChainId);
+    try {
+      if (currentChain.type === "core") {
+        const evmChainId = defaultNetworkSelector.getCorrespondingChainId() || 71;
+        this.coreClient = await createCoreClient({
+          ...this.config.core,
+          chainId: currentChainId
+        });
+        this.evmClient = await createEspaceClient({
+          ...this.config.evm,
+          chainId: evmChainId
+        });
+      } else {
+        const coreChainId = defaultNetworkSelector.getCorrespondingChainId() || 1;
+        this.coreClient = await createCoreClient({
+          ...this.config.core,
+          chainId: coreChainId
+        });
+        this.evmClient = await createEspaceClient({
+          ...this.config.evm,
+          chainId: currentChainId
+        });
+      }
+      this.emit("client:ready", {
+        type: "core",
+        chainId: this.coreClient.publicClient.chainId
+      });
+      this.emit("client:ready", {
+        type: "evm",
+        chainId: this.evmClient.publicClient.chainId
+      });
+    } catch (error) {
+      const clientError = error instanceof Error ? error : new Error(String(error));
+      this.emit("manager:error", { error: clientError });
+      throw clientError;
+    }
+  }
+  /**
+   * Set up network selector event listeners
+   */
+  setupNetworkListeners() {
+    this.networkSelectorUnsubscribe = defaultNetworkSelector.onChainChange(
+      async (_chainId) => {
+        try {
+          await this.initializeClients();
+        } catch (error) {
+          const networkError = error instanceof Error ? error : new Error(String(error));
+          this.emit("manager:error", { error: networkError });
+        }
+      }
+    );
+    this.nodeRunningUnsubscribe = defaultNetworkSelector.onNodeRunningChange(
+      async (isRunning) => {
+        if (isRunning) {
+        } else {
+        }
+      }
+    );
+  }
+  /**
+   * Start health monitoring for all clients
+   */
+  startHealthMonitoring() {
+    if (this.healthCheckInterval) {
+      return;
+    }
+    this.healthCheckInterval = setInterval(async () => {
+      await this.performHealthChecks();
+    }, this.config.healthCheckInterval || HEALTH_CHECK_INTERVAL);
+    setTimeout(() => this.performHealthChecks(), 1e3);
+  }
+  /**
+   * Stop health monitoring
+   */
+  stopHealthMonitoring() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+  }
+  /**
+   * Perform health checks on all clients
+   */
+  async performHealthChecks() {
+    const timeout = this.config.healthCheckTimeout || HEALTH_CHECK_TIMEOUT;
+    if (this.coreClient) {
+      try {
+        const healthPromise = this.checkCoreClientHealth();
+        const result = await Promise.race([
+          healthPromise,
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Health check timeout")), timeout)
+          )
+        ]);
+        this.emit("client:health", {
+          type: "core",
+          chainId: this.coreClient.publicClient.chainId,
+          status: result
+        });
+      } catch (error) {
+        this.emit("client:error", {
+          type: "core",
+          chainId: this.coreClient.publicClient.chainId,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    if (this.evmClient) {
+      try {
+        const healthPromise = this.checkEvmClientHealth();
+        const result = await Promise.race([
+          healthPromise,
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Health check timeout")), timeout)
+          )
+        ]);
+        this.emit("client:health", {
+          type: "evm",
+          chainId: this.evmClient.publicClient.chainId,
+          status: result
+        });
+      } catch (error) {
+        this.emit("client:error", {
+          type: "evm",
+          chainId: this.evmClient.publicClient.chainId,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+  }
+  /**
+   * Check Core client health
+   */
+  async checkCoreClientHealth() {
+    if (!this.coreClient) {
+      return "disconnected";
+    }
+    try {
+      await this.coreClient.publicClient.getBlockNumber();
+      return "healthy";
+    } catch (_error) {
+      return "unhealthy";
+    }
+  }
+  /**
+   * Check eSpace client health
+   */
+  async checkEvmClientHealth() {
+    if (!this.evmClient) {
+      return "disconnected";
+    }
+    try {
+      await this.evmClient.publicClient.getBlockNumber();
+      return "healthy";
+    } catch (_error) {
+      return "unhealthy";
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClientManager,
+  CoreClient,
+  CoreTestClient,
+  CoreWalletClient,
+  EspaceClient,
+  EspaceTestClient,
+  EspaceWalletClient
+});
+//# sourceMappingURL=index.cjs.map