@cfxdevkit/devnode 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1033 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DevKitWithDevNode: () => DevKitWithDevNode,
+  ServerManager: () => ServerManager,
+  VERSION: () => VERSION,
+  devNodePlugin: () => devNodePlugin
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/server-manager.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_config = require("@cfxdevkit/core/config");
+var import_wallet = require("@cfxdevkit/core/wallet");
+var import_node = require("@xcfx/node");
+var import_accounts = require("cive/accounts");
+var import_accounts2 = require("viem/accounts");
+
+// src/types.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/server-manager.ts
+var DEFAULT_CORE_RPC_PORT = 12537;
+var DEFAULT_EVM_RPC_PORT = 8545;
+var DEFAULT_WS_PORT = 12536;
+var DEFAULT_EVM_WS_PORT = 8546;
+var ServerManager = class {
+  nodeProcess = null;
+  server = null;
+  config;
+  status = "stopped";
+  accounts = [];
+  mnemonic = "";
+  miningAccount = null;
+  miningStatus;
+  miningTimer = null;
+  testClient = null;
+  /** True while packMine() is running — auto-miner skips its tick to avoid concurrent mining RPCs. */
+  _packMining = false;
+  constructor(config) {
+    this.config = {
+      ...config,
+      coreRpcPort: config.coreRpcPort || DEFAULT_CORE_RPC_PORT,
+      evmRpcPort: config.evmRpcPort || DEFAULT_EVM_RPC_PORT,
+      wsPort: config.wsPort || DEFAULT_WS_PORT,
+      evmWsPort: config.evmWsPort || DEFAULT_EVM_WS_PORT,
+      chainId: config.chainId || 2029,
+      // Local Core chain ID
+      evmChainId: config.evmChainId || 2030,
+      // Local eSpace chain ID
+      accounts: config.accounts || 10,
+      balance: config.balance || "1000000",
+      mnemonic: config.mnemonic,
+      // Following xcfx-node test pattern: devPackTxImmediately should be false
+      // All mining is managed via testClient.mine() calls
+      devPackTxImmediately: false
+    };
+    this.miningStatus = {
+      isRunning: false,
+      interval: 1e3,
+      blocksMined: 0,
+      startTime: void 0
+    };
+    this.mnemonic = this.config.mnemonic || (0, import_wallet.generateMnemonic)(128);
+    this.generateAccountsSync();
+    this.generateMiningAccountSync();
+  }
+  /**
+   * Return a sanitized copy of the server config with sensitive fields redacted.
+   */
+  redactConfig(config) {
+    const safe = { ...config };
+    if (safe.mnemonic) safe.mnemonic = "[REDACTED]";
+    if (safe.accounts) delete safe.accounts;
+    return safe;
+  }
+  /**
+   * Start the Conflux development node
+   */
+  async start() {
+    if (this.status === "running") {
+      throw new NodeError(
+        "Server is already running",
+        "SERVER_ALREADY_RUNNING"
+      );
+    }
+    try {
+      this.status = "starting";
+      const dataDir = this.config.dataDir || (0, import_node_path.join)((0, import_node_os.homedir)(), ".conflux-devkit", "data");
+      try {
+        await import_node_fs.promises.mkdir(dataDir, { recursive: true, mode: 493 });
+      } catch (error) {
+        console.warn("Failed to create data directory:", error);
+      }
+      const serverConfig = {
+        // Correct property names according to @xcfx/node API
+        jsonrpcHttpPort: this.config.coreRpcPort,
+        jsonrpcHttpEthPort: this.config.evmRpcPort,
+        jsonrpcWsPort: this.config.wsPort,
+        jsonrpcWsEthPort: this.config.evmWsPort,
+        chainId: this.config.chainId,
+        evmChainId: this.config.evmChainId,
+        // Specify data directory to avoid permission issues
+        confluxDataDir: dataDir,
+        // Genesis accounts configuration - include mining account for initial funding
+        genesisSecrets: [
+          ...this.accounts.map((acc) => acc.privateKey),
+          this.requireMiningAccount().privateKey
+          // Add mining account to get initial funds
+        ],
+        genesisEvmSecrets: [
+          ...this.accounts.map((acc) => acc.evmPrivateKey || acc.privateKey),
+          this.requireMiningAccount().evmPrivateKey || this.requireMiningAccount().privateKey
+          // Add mining account EVM key
+        ],
+        // Mining configuration - use config value or default to mining account address
+        // 'auto' is a sentinel value meaning "use the derived mining account address"
+        miningAuthor: this.config.miningAuthor && this.config.miningAuthor !== "auto" ? this.config.miningAuthor : this.miningAccount?.coreAddress,
+        // Following the reference test (xcfx-node/evmManualBlockGeneration.test.ts):
+        // devPackTxImmediately: false — eSpace txs are ONLY packed by mine({ numTxs }),
+        // never by mine({ blocks }).  This flag only affects Core space.
+        devPackTxImmediately: false,
+        log: this.config.logging || false,
+        // Genesis block initialization can take time; pass a generous timeout so
+        // the native binary doesn't abort the startup handshake prematurely.
+        timeout: 6e4,
+        retryInterval: 300
+      };
+      this.server = await (0, import_node.createServer)(serverConfig);
+      await this.server.start();
+      this.status = "running";
+      import_config.defaultNetworkSelector.updateLocalChainUrls(
+        this.config.coreRpcPort || DEFAULT_CORE_RPC_PORT,
+        this.config.evmRpcPort || DEFAULT_EVM_RPC_PORT,
+        this.config.wsPort || DEFAULT_WS_PORT
+      );
+      import_config.defaultNetworkSelector.onNodeStart(2029, 2030);
+      this.setupCleanupHandlers();
+      await this.startMining(2e3);
+    } catch (error) {
+      this.status = "error";
+      throw new NodeError(
+        `Failed to start server: ${error instanceof Error ? error.message : String(error)}`,
+        "SERVER_START_ERROR",
+        void 0,
+        {
+          config: this.redactConfig(this.config),
+          originalError: error
+        }
+      );
+    }
+  }
+  /**
+   * Stop the Conflux development node
+   */
+  async stop() {
+    if (this.status === "stopped") {
+      return;
+    }
+    try {
+      this.status = "stopping";
+      if (this.miningStatus.isRunning) {
+        try {
+          await this.stopMining();
+        } catch (error) {
+          console.warn("Failed to stop mining during server shutdown:", error);
+        }
+      }
+      if (this.server) {
+        await this.server.stop();
+        this.server = null;
+      }
+      if (this.nodeProcess) {
+        this.nodeProcess.kill("SIGTERM");
+        this.nodeProcess = null;
+      }
+      this.testClient = null;
+      this.status = "stopped";
+      import_config.defaultNetworkSelector.onNodeStop();
+    } catch (error) {
+      this.status = "error";
+      throw new NodeError(
+        `Failed to stop server: ${error instanceof Error ? error.message : String(error)}`,
+        "SERVER_STOP_ERROR",
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Restart the Conflux development node
+   */
+  async restart() {
+    await this.stop();
+    await this.start();
+  }
+  /**
+   * Get current server status
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Get comprehensive node status including mining
+   */
+  getNodeStatus() {
+    return {
+      server: this.status,
+      mining: this.getMiningStatus(),
+      config: this.redactConfig(this.config),
+      accounts: this.accounts.length,
+      rpcUrls: this.getRpcUrls()
+    };
+  }
+  /**
+   * Check if server is running
+   */
+  isRunning() {
+    return this.status === "running";
+  }
+  /**
+   * Get server configuration
+   */
+  getConfig() {
+    return {
+      ...this.redactConfig(this.config)
+    };
+  }
+  /**
+   * Get generated accounts
+   */
+  getAccounts() {
+    return [...this.accounts];
+  }
+  /**
+   * Get the mnemonic phrase
+   */
+  getMnemonic() {
+    return this.mnemonic;
+  }
+  /**
+   * Get RPC URLs
+   */
+  getRpcUrls() {
+    const coreWs = `ws://localhost:${this.config.wsPort}`;
+    return {
+      core: `http://localhost:${this.config.coreRpcPort}`,
+      evm: `http://localhost:${this.config.evmRpcPort}`,
+      coreWs,
+      evmWs: `ws://localhost:${this.config.evmWsPort}`,
+      ws: coreWs
+      // backward-compat alias for Core WS
+    };
+  }
+  /**
+   * Add a new account to the server
+   */
+  async addAccount(privateKey) {
+    const accountPrivateKey = privateKey || `0x${(0, import_node_crypto.randomBytes)(32).toString("hex")}`;
+    const coreAccount = (0, import_accounts.privateKeyToAccount)(
+      accountPrivateKey,
+      {
+        networkId: this.config.chainId || 1
+      }
+    );
+    const evmAccount = (0, import_accounts2.privateKeyToAccount)(
+      accountPrivateKey
+    );
+    const accountInfo = {
+      index: this.accounts.length,
+      privateKey: accountPrivateKey,
+      coreAddress: coreAccount.address,
+      evmAddress: evmAccount.address,
+      mnemonic: this.mnemonic,
+      path: `m/44'/503'/0'/0/${this.accounts.length}`
+    };
+    this.accounts.push(accountInfo);
+    return accountInfo;
+  }
+  /**
+   * Fund an account with CFX
+   * Note: @xcfx/node doesn't provide direct funding methods.
+   * This would require using RPC calls to send transactions from funded genesis accounts.
+   */
+  async fundAccount(address, amount, chainType = "core") {
+    if (!this.isRunning() || !this.server) {
+      throw new NodeError("Server is not running", "SERVER_NOT_RUNNING");
+    }
+    throw new NodeError(
+      "Direct account funding not implemented. Genesis accounts are automatically funded by @xcfx/node.",
+      "NOT_IMPLEMENTED",
+      chainType,
+      { address, amount, chainType }
+    );
+  }
+  /**
+   * Set next block timestamp (for testing)
+   * Note: @xcfx/node doesn't provide direct timestamp control.
+   * Use createTestClient from 'cive' and connect to the running node's RPC.
+   */
+  async setNextBlockTimestamp(timestamp) {
+    if (!this.isRunning() || !this.server) {
+      throw new NodeError("Server is not running", "SERVER_NOT_RUNNING");
+    }
+    throw new NodeError(
+      "Direct timestamp control not implemented. Use createTestClient from cive to control block timestamps via RPC.",
+      "NOT_IMPLEMENTED",
+      "core",
+      { timestamp }
+    );
+  }
+  /**
+   * Get server logs
+   * Note: @xcfx/node doesn't provide direct log access.
+   * Logs would need to be captured during server startup or accessed via system logs.
+   */
+  async getLogs(lines = 50) {
+    if (!this.isRunning() || !this.server) {
+      throw new NodeError("Server is not running", "SERVER_NOT_RUNNING");
+    }
+    return [
+      "Log access not implemented for @xcfx/node.",
+      "Consider capturing server output during startup or checking system logs.",
+      `Requested ${lines} lines of logs.`
+    ];
+  }
+  /**
+   * Save server configuration to file
+   */
+  async saveConfig(filepath) {
+    try {
+      const configData = {
+        ...this.redactConfig(this.config),
+        mnemonic: "[REDACTED]",
+        accounts: this.accounts.map((a) => ({
+          index: a.index,
+          coreAddress: a.coreAddress,
+          evmAddress: a.evmAddress,
+          path: a.path
+        })),
+        rpcUrls: this.getRpcUrls()
+      };
+      await import_node_fs.promises.writeFile(filepath, JSON.stringify(configData, null, 2), "utf8");
+    } catch (error) {
+      throw new NodeError(
+        `Failed to save config: ${error instanceof Error ? error.message : String(error)}`,
+        "CONFIG_SAVE_ERROR",
+        "core",
+        { filepath, originalError: error }
+      );
+    }
+  }
+  /**
+   * Load server configuration from file
+   */
+  static async loadConfig(filepath) {
+    try {
+      const configData = await import_node_fs.promises.readFile(filepath, "utf8");
+      return JSON.parse(configData);
+    } catch (error) {
+      throw new NodeError(
+        `Failed to load config: ${error instanceof Error ? error.message : String(error)}`,
+        "CONFIG_LOAD_ERROR",
+        "core",
+        { filepath, originalError: error }
+      );
+    }
+  }
+  /**
+   * Generate accounts from mnemonic using core wallet module
+   * Called from constructor to ensure accounts are always available
+   */
+  generateAccountsSync() {
+    const derivedAccounts = (0, import_wallet.deriveAccounts)(this.mnemonic, {
+      count: this.config.accounts || 10,
+      coreNetworkId: this.config.chainId || 2029
+    });
+    this.accounts = derivedAccounts.map((account) => ({
+      index: account.index,
+      privateKey: account.corePrivateKey,
+      // Keep Conflux private key as primary
+      coreAddress: account.coreAddress,
+      evmAddress: account.evmAddress,
+      mnemonic: this.mnemonic,
+      path: account.paths.core,
+      // Store additional EVM-specific info
+      evmPrivateKey: account.evmPrivateKey,
+      evmPath: account.paths.evm
+    }));
+  }
+  /**
+   * Generate dedicated mining account (separate from genesis accounts)
+   * This account will receive mining rewards and serve as the faucet
+   * Called synchronously from constructor to ensure always available
+   */
+  generateMiningAccountSync() {
+    const faucetAccount = (0, import_wallet.deriveFaucetAccount)(
+      this.mnemonic,
+      this.config.chainId || 2029
+    );
+    this.miningAccount = {
+      index: -1,
+      // Special index for mining account
+      privateKey: faucetAccount.corePrivateKey,
+      // Core/Conflux private key
+      coreAddress: faucetAccount.coreAddress,
+      evmAddress: faucetAccount.evmAddress,
+      mnemonic: this.mnemonic,
+      path: faucetAccount.paths.core,
+      // Store additional EVM-specific info
+      evmPrivateKey: faucetAccount.evmPrivateKey,
+      evmPath: faucetAccount.paths.evm
+    };
+    console.log(
+      `Generated mining account: Core=${this.miningAccount.coreAddress}, eSpace=${this.miningAccount.evmAddress}`
+    );
+  }
+  /**
+   * Returns the mining account, throwing if it has not been initialized.
+   * In practice this is always set by generateMiningAccountSync() in the
+   * constructor, so the throw is a safety net for unexpected states.
+   */
+  requireMiningAccount() {
+    if (!this.miningAccount) {
+      throw new Error("Mining account has not been initialized.");
+    }
+    return this.miningAccount;
+  }
+  // ===== MINING METHODS =====
+  /**
+   * Start automatic block mining using testClient
+   * This creates an interval that mines blocks automatically
+   * @param interval Mining interval in milliseconds (default: 2000ms)
+   */
+  async startMining(interval) {
+    if (!this.isRunning()) {
+      throw new NodeError(
+        "Server must be running to start mining",
+        "SERVER_NOT_RUNNING"
+      );
+    }
+    if (this.miningStatus.isRunning) {
+      throw new NodeError(
+        "Mining is already running",
+        "MINING_ALREADY_RUNNING"
+      );
+    }
+    if (!this.testClient) {
+      const { createTestClient, http } = await import("cive");
+      this.testClient = createTestClient({
+        transport: http(`http://localhost:${this.config.coreRpcPort}`, {
+          timeout: 6e4
+        })
+      });
+    }
+    const miningInterval = interval || 2e3;
+    this.miningStatus = {
+      ...this.miningStatus,
+      isRunning: true,
+      interval: miningInterval,
+      startTime: /* @__PURE__ */ new Date()
+    };
+    this.miningTimer = setInterval(async () => {
+      try {
+        if (this.testClient && !this._packMining) {
+          await this.testClient.mine({ numTxs: 1 });
+          this.miningStatus = {
+            ...this.miningStatus,
+            blocksMined: (this.miningStatus.blocksMined || 0) + 5
+          };
+        }
+      } catch (error) {
+        console.error("Mining error:", error);
+      }
+    }, miningInterval);
+    console.log(`Mining started with ${miningInterval}ms interval`);
+  }
+  /**
+   * Stop automatic block mining
+   */
+  async stopMining() {
+    if (!this.miningStatus.isRunning) {
+      throw new NodeError("Mining is not running", "MINING_NOT_RUNNING");
+    }
+    if (this.miningTimer) {
+      clearInterval(this.miningTimer);
+      this.miningTimer = null;
+    }
+    this.miningStatus = {
+      ...this.miningStatus,
+      isRunning: false,
+      startTime: void 0
+    };
+    console.log("Mining stopped");
+  }
+  /**
+   * Change mining interval (stops and restarts mining with new interval)
+   */
+  async setMiningInterval(interval) {
+    if (interval < 100) {
+      throw new NodeError(
+        "Mining interval must be at least 100ms",
+        "INVALID_INTERVAL"
+      );
+    }
+    const wasRunning = this.miningStatus.isRunning;
+    if (wasRunning) {
+      await this.stopMining();
+    }
+    this.miningStatus = {
+      ...this.miningStatus,
+      interval
+    };
+    if (wasRunning) {
+      await this.startMining(interval);
+    }
+    console.log(`Mining interval set to ${interval}ms`);
+  }
+  /**
+   * Mine a specific number of blocks immediately
+   */
+  async mine(blocks = 1) {
+    if (!this.isRunning()) {
+      throw new NodeError(
+        "Server must be running to mine blocks",
+        "SERVER_NOT_RUNNING"
+      );
+    }
+    if (!this.testClient) {
+      const { createTestClient, http } = await import("cive");
+      this.testClient = createTestClient({
+        transport: http(`http://localhost:${this.config.coreRpcPort}`, {
+          timeout: 6e4
+        })
+      });
+    }
+    try {
+      await this.testClient.mine({ blocks });
+      this.miningStatus = {
+        ...this.miningStatus,
+        blocksMined: (this.miningStatus.blocksMined || 0) + blocks
+      };
+      console.log(`Mined ${blocks} empty block(s)`);
+    } catch (error) {
+      throw new NodeError(
+        `Failed to mine blocks: ${error instanceof Error ? error.message : String(error)}`,
+        "MINING_ERROR",
+        "core",
+        { blocks, originalError: error }
+      );
+    }
+  }
+  /**
+   * Pack and mine: calls test_generateOneBlock (mine({ numTxs:1 })) which
+   * forces pending eSpace/Core transactions into a block.  Each call
+   * internally generates deferredStateEpochCount (default 5) blocks.
+   *
+   * This is the ONLY way to include eSpace (EVM) transactions — mine({ blocks })
+   * skips the txpool for eSpace.  Uses a long timeout because
+   * test_generateOneBlock can take several seconds on slow machines.
+   */
+  async packMine() {
+    if (!this.isRunning()) {
+      throw new NodeError(
+        "Server must be running to mine blocks",
+        "SERVER_NOT_RUNNING"
+      );
+    }
+    const { createTestClient, http } = await import("cive");
+    const packClient = createTestClient({
+      transport: http(`http://localhost:${this.config.coreRpcPort}`, {
+        timeout: 12e4
+      })
+    });
+    this._packMining = true;
+    try {
+      await packClient.mine({ numTxs: 1 });
+      this.miningStatus = {
+        ...this.miningStatus,
+        blocksMined: (this.miningStatus.blocksMined || 0) + 5
+        // generates 5 blocks internally
+      };
+      console.log("Pack-mined: 5 blocks generated, pending txs included");
+    } catch (error) {
+      throw new NodeError(
+        `Failed to pack-mine: ${error instanceof Error ? error.message : String(error)}`,
+        "MINING_ERROR",
+        "core",
+        { originalError: error }
+      );
+    } finally {
+      this._packMining = false;
+    }
+  }
+  /**
+   * Get current mining status
+   */
+  getMiningStatus() {
+    return { ...this.miningStatus };
+  }
+  // ===== FAUCET METHODS =====
+  /**
+   * Get the faucet/mining account (dedicated mining account with separate derivation path)
+   * This account receives mining rewards and serves as the faucet
+   * Derivation paths: Core=m/44'/503'/1'/0/0, EVM=m/44'/60'/1'/0/0
+   */
+  getFaucetAccount() {
+    if (!this.miningAccount) {
+      throw new NodeError(
+        "Mining account not available. Server must be started first.",
+        "NO_MINING_ACCOUNT"
+      );
+    }
+    return this.miningAccount;
+  }
+  /**
+   * Fund a Core Space account using the faucet account
+   */
+  async fundCoreAccount(targetAddress, amount) {
+    if (!this.isRunning()) {
+      throw new NodeError(
+        "Server must be running to fund accounts",
+        "SERVER_NOT_RUNNING"
+      );
+    }
+    const faucetAccount = this.getFaucetAccount();
+    try {
+      const { createWalletClient, http } = await import("cive");
+      const { privateKeyToAccount: privateKeyToAccount2 } = await import("cive/accounts");
+      const account = privateKeyToAccount2(
+        faucetAccount.privateKey,
+        {
+          networkId: this.config.chainId || 1
+        }
+      );
+      const walletClient = createWalletClient({
+        account,
+        chain: (this.config.chainId || 1) === 1029 ? {
+          id: 1029,
+          name: "Conflux Core",
+          nativeCurrency: {
+            name: "Conflux",
+            symbol: "CFX",
+            decimals: 18
+          },
+          rpcUrls: {
+            default: {
+              http: [`http://localhost:${this.config.coreRpcPort}`]
+            }
+          }
+        } : {
+          id: this.config.chainId || 1,
+          name: "Conflux Core Testnet",
+          nativeCurrency: {
+            name: "Conflux",
+            symbol: "CFX",
+            decimals: 18
+          },
+          rpcUrls: {
+            default: {
+              http: [`http://localhost:${this.config.coreRpcPort}`]
+            }
+          }
+        },
+        transport: http(`http://localhost:${this.config.coreRpcPort}`)
+      });
+      const { parseCFX } = await import("cive");
+      const hash = await walletClient.sendTransaction({
+        account,
+        to: targetAddress,
+        value: parseCFX(amount)
+      });
+      console.log(
+        `Funded Core account ${targetAddress} with ${amount} CFX. TX: ${hash}`
+      );
+      return hash;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to fund Core account: ${error instanceof Error ? error.message : String(error)}`,
+        "FAUCET_ERROR",
+        "core",
+        {
+          targetAddress,
+          amount,
+          faucetAccount: faucetAccount.coreAddress,
+          originalError: error
+        }
+      );
+    }
+  }
+  /**
+   * Fund an eSpace account from the Core-Space faucet/mining account.
+   *
+   * Funds ALWAYS originate from the Core-Space faucet wallet (which accumulates
+   * mining rewards).  For eSpace (0x…) targets the transfer is routed through the
+   * Conflux internal cross-chain bridge contract (0x0888…0006 / transferEVM),
+   * which locks CFX on Core and mints it on eSpace — no separate eSpace balance is
+   * needed on the faucet account.
+   */
+  async fundEvmAccount(targetAddress, amount) {
+    if (!this.isRunning()) {
+      throw new NodeError(
+        "Server must be running to fund accounts",
+        "SERVER_NOT_RUNNING"
+      );
+    }
+    const faucetAccount = this.getFaucetAccount();
+    try {
+      const { createWalletClient, http, parseCFX } = await import("cive");
+      const { privateKeyToAccount: privateKeyToAccount2 } = await import("cive/accounts");
+      const { hexAddressToBase32, encodeFunctionData, defineChain } = await import("cive/utils");
+      const chainId = this.config.chainId || 2029;
+      const chain = defineChain({
+        id: chainId,
+        name: "Conflux Core Local",
+        nativeCurrency: { decimals: 18, name: "Conflux", symbol: "CFX" },
+        rpcUrls: {
+          default: { http: [`http://localhost:${this.config.coreRpcPort}`] }
+        }
+      });
+      const account = privateKeyToAccount2(
+        faucetAccount.privateKey,
+        { networkId: chainId }
+      );
+      const walletClient = createWalletClient({
+        account,
+        chain,
+        transport: http(`http://localhost:${this.config.coreRpcPort}`)
+      });
+      const bridgeAddress = hexAddressToBase32({
+        hexAddress: "0x0888000000000000000000000000000000000006",
+        networkId: chainId
+      });
+      const hash = await walletClient.sendTransaction({
+        account,
+        chain,
+        to: bridgeAddress,
+        value: parseCFX(amount),
+        data: encodeFunctionData({
+          abi: [
+            {
+              type: "function",
+              name: "transferEVM",
+              inputs: [{ name: "to", type: "bytes20" }],
+              outputs: [{ name: "output", type: "bytes" }],
+              stateMutability: "payable"
+            }
+          ],
+          functionName: "transferEVM",
+          args: [targetAddress]
+        })
+      });
+      console.log(
+        `Funded eSpace account ${targetAddress} with ${amount} CFX via Core\u2192eSpace bridge. TX: ${hash}`
+      );
+      return hash;
+    } catch (error) {
+      throw new NodeError(
+        `Failed to fund eSpace account: ${error instanceof Error ? error.message : String(error)}`,
+        "FAUCET_ERROR",
+        "evm",
+        {
+          targetAddress,
+          amount,
+          faucetCoreAddress: faucetAccount.coreAddress,
+          originalError: error
+        }
+      );
+    }
+  }
+  /**
+   * Fund both Core and eSpace accounts for the same private key
+   */
+  async fundDualChainAccount(privateKey, coreAmount, evmAmount) {
+    const { privateKeyToAccount: privateKeyToAccount2 } = await import("cive/accounts");
+    const { privateKeyToAccount: privateKeyToEvmAccount2 } = await import("viem/accounts");
+    const coreAccount = privateKeyToAccount2(privateKey, {
+      networkId: this.config.chainId || 1
+    });
+    const evmAccount = privateKeyToEvmAccount2(privateKey);
+    const [coreHash, evmHash] = await Promise.all([
+      this.fundCoreAccount(coreAccount.address, coreAmount),
+      this.fundEvmAccount(evmAccount.address, evmAmount)
+    ]);
+    return {
+      coreHash,
+      evmHash,
+      coreAddress: coreAccount.address,
+      evmAddress: evmAccount.address
+    };
+  }
+  /**
+   * Check faucet account balances on both chains
+   */
+  async getFaucetBalances() {
+    if (!this.isRunning()) {
+      throw new NodeError(
+        "Server must be running to check balances",
+        "SERVER_NOT_RUNNING"
+      );
+    }
+    const faucetAccount = this.getFaucetAccount();
+    try {
+      const [core, evm] = await Promise.all([
+        this.getCoreBalance(faucetAccount.coreAddress),
+        this.getEvmBalance(faucetAccount.evmAddress)
+      ]);
+      return { core, evm };
+    } catch (error) {
+      throw new NodeError(
+        `Failed to get faucet balances: ${error instanceof Error ? error.message : String(error)}`,
+        "BALANCE_CHECK_ERROR",
+        void 0,
+        { faucetAccount, originalError: error }
+      );
+    }
+  }
+  /**
+   * Check Core Space balance
+   */
+  async getCoreBalance(address) {
+    const { createPublicClient, http, formatCFX } = await import("cive");
+    const publicClient = createPublicClient({
+      chain: this.config.chainId === 1029 ? {
+        id: 1029,
+        name: "Conflux Core",
+        nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
+        rpcUrls: {
+          default: {
+            http: [`http://localhost:${this.config.coreRpcPort}`]
+          }
+        }
+      } : {
+        id: 1,
+        name: "Conflux Core Testnet",
+        nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
+        rpcUrls: {
+          default: {
+            http: [`http://localhost:${this.config.coreRpcPort}`]
+          }
+        }
+      },
+      transport: http(`http://localhost:${this.config.coreRpcPort}`)
+    });
+    const balance = await publicClient.getBalance({
+      address
+    });
+    return formatCFX(balance);
+  }
+  /**
+   * Check eSpace balance
+   */
+  async getEvmBalance(address) {
+    const { createPublicClient, http, formatEther } = await import("viem");
+    const publicClient = createPublicClient({
+      chain: {
+        id: this.config.evmChainId || 71,
+        name: "Conflux eSpace Local",
+        nativeCurrency: { name: "Conflux", symbol: "CFX", decimals: 18 },
+        rpcUrls: {
+          default: { http: [`http://localhost:${this.config.evmRpcPort}`] }
+        }
+      },
+      transport: http(`http://localhost:${this.config.evmRpcPort}`)
+    });
+    const balance = await publicClient.getBalance({
+      address
+    });
+    return formatEther(balance);
+  }
+  /**
+   * Get Ethereum-compatible admin address derived from mnemonic
+   * Uses the standard Ethereum derivation path: m/44'/60'/0'/0/0
+   * This address will match what MetaMask and other Ethereum wallets derive
+   */
+  getEthereumAdminAddress() {
+    const account = (0, import_wallet.deriveAccount)(
+      this.mnemonic,
+      0,
+      this.config.chainId || 2029
+    );
+    return account.evmAddress.toLowerCase();
+  }
+  /**
+   * Set up cleanup handlers for graceful shutdown
+   */
+  setupCleanupHandlers() {
+    const cleanup = async () => {
+      if (this.isRunning()) {
+        console.log("Shutting down Conflux development node...");
+        await this.stop();
+      }
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    process.on("exit", cleanup);
+  }
+};
+
+// src/plugin.ts
+var DevKitWithDevNode = class {
+  server;
+  baseDevKit;
+  constructor(baseDevKit, config) {
+    this.baseDevKit = baseDevKit;
+    this.server = new ServerManager(config);
+  }
+  // Delegate to base DevKit
+  getConfig() {
+    return this.baseDevKit.getConfig();
+  }
+  getRpcUrls() {
+    return this.baseDevKit.getRpcUrls();
+  }
+  // Node lifecycle methods
+  async startNode(options = {}) {
+    await this.server.start();
+    if (options.mining !== false) {
+      await this.server.startMining();
+    }
+  }
+  async stopNode() {
+    await this.server.stop();
+  }
+  // Mining methods
+  async startMining() {
+    await this.server.startMining();
+  }
+  async stopMining() {
+    await this.server.stopMining();
+  }
+  async mine(blocks = 1) {
+    await this.server.mine(blocks);
+  }
+  getMiningStatus() {
+    return this.server.getMiningStatus();
+  }
+  async setMiningInterval(interval) {
+    await this.server.setMiningInterval(interval);
+  }
+  // Faucet methods
+  async getFaucetBalances() {
+    return await this.server.getFaucetBalances();
+  }
+  getFaucetAccount() {
+    return this.server.getFaucetAccount();
+  }
+  async fundAccount(address, amount, chain) {
+    if (chain === "core") {
+      return await this.server.fundCoreAccount(address, amount);
+    } else {
+      return await this.server.fundEvmAccount(address, amount);
+    }
+  }
+  // Account methods
+  async addAccount() {
+    return await this.server.addAccount();
+  }
+  getAccounts() {
+    return this.server.getAccounts();
+  }
+  // Utility methods
+  getEthereumAdminAddress() {
+    return this.server.getEthereumAdminAddress();
+  }
+  getServerStatus() {
+    return this.server.getStatus();
+  }
+  isNodeRunning() {
+    return this.server.isRunning();
+  }
+};
+var devNodePlugin = {
+  name: "devnode",
+  version: "0.1.0",
+  extendDevKit(devkit, config) {
+    return new DevKitWithDevNode(devkit, config);
+  }
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevKitWithDevNode,
+  ServerManager,
+  VERSION,
+  devNodePlugin
+});
+//# sourceMappingURL=index.cjs.map