@cfxdevkit/services 0.1.0

package/dist/services/index.cjs

@@ -0,0 +1,1097 @@
+"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/services/index.ts
+var services_exports = {};
+__export(services_exports, {
+  EncryptionService: () => EncryptionService,
+  KeystoreLockedError: () => KeystoreLockedError,
+  KeystoreService: () => KeystoreService,
+  SwapService: () => SwapService,
+  getKeystoreService: () => getKeystoreService
+});
+module.exports = __toCommonJS(services_exports);
+
+// src/services/encryption.ts
+var import_node_crypto = require("crypto");
+var EncryptionService = class _EncryptionService {
+  // Utility class — not meant to be instantiated
+  constructor() {
+  }
+  static ITERATIONS = 1e5;
+  static KEY_LENGTH = 256;
+  static SALT_LENGTH = 32;
+  static IV_LENGTH = 12;
+  /**
+   * Generate a random salt for key derivation
+   */
+  static generateSalt() {
+    return Buffer.from(
+      import_node_crypto.webcrypto.getRandomValues(new Uint8Array(_EncryptionService.SALT_LENGTH))
+    );
+  }
+  /**
+   * Derive encryption key from password using PBKDF2
+   */
+  static async deriveKey(password, salt) {
+    const encoder = new TextEncoder();
+    const passwordBuffer = encoder.encode(password);
+    const keyMaterial = await import_node_crypto.webcrypto.subtle.importKey(
+      "raw",
+      passwordBuffer,
+      "PBKDF2",
+      false,
+      ["deriveBits", "deriveKey"]
+    );
+    return await import_node_crypto.webcrypto.subtle.deriveKey(
+      {
+        name: "PBKDF2",
+        salt: new Uint8Array(salt),
+        iterations: _EncryptionService.ITERATIONS,
+        hash: "SHA-256"
+      },
+      keyMaterial,
+      { name: "AES-GCM", length: _EncryptionService.KEY_LENGTH },
+      false,
+      ["encrypt", "decrypt"]
+    );
+  }
+  /**
+   * Encrypt plaintext with password
+   *
+   * @param plaintext - String to encrypt
+   * @param password - Encryption password
+   * @param salt - Salt for key derivation
+   * @returns Base64-encoded ciphertext with prepended IV
+   */
+  static async encrypt(plaintext, password, salt) {
+    const key = await _EncryptionService.deriveKey(password, salt);
+    const iv = import_node_crypto.webcrypto.getRandomValues(
+      new Uint8Array(_EncryptionService.IV_LENGTH)
+    );
+    const encoder = new TextEncoder();
+    const plaintextBuffer = encoder.encode(plaintext);
+    const ciphertext = await import_node_crypto.webcrypto.subtle.encrypt(
+      { name: "AES-GCM", iv },
+      key,
+      plaintextBuffer
+    );
+    const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+    combined.set(iv, 0);
+    combined.set(new Uint8Array(ciphertext), iv.length);
+    return Buffer.from(combined).toString("base64");
+  }
+  /**
+   * Decrypt ciphertext with password
+   *
+   * @param ciphertext - Base64-encoded ciphertext with prepended IV
+   * @param password - Encryption password
+   * @param salt - Salt for key derivation
+   * @returns Decrypted plaintext
+   * @throws Error if decryption fails (wrong password or corrupted data)
+   */
+  static async decrypt(ciphertext, password, salt) {
+    const combined = Buffer.from(ciphertext, "base64");
+    const iv = combined.subarray(0, _EncryptionService.IV_LENGTH);
+    const encrypted = combined.subarray(_EncryptionService.IV_LENGTH);
+    const key = await _EncryptionService.deriveKey(password, salt);
+    try {
+      const decrypted = await import_node_crypto.webcrypto.subtle.decrypt(
+        { name: "AES-GCM", iv },
+        key,
+        encrypted
+      );
+      const decoder = new TextDecoder();
+      return decoder.decode(decrypted);
+    } catch (_error) {
+      throw new Error("Decryption failed - invalid password or corrupted data");
+    }
+  }
+  /**
+   * Encrypt an object (serializes to JSON first)
+   */
+  static async encryptObject(obj, password, salt) {
+    const json = JSON.stringify(obj);
+    return await _EncryptionService.encrypt(json, password, salt);
+  }
+  /**
+   * Decrypt to an object (parses JSON after decryption)
+   */
+  static async decryptObject(ciphertext, password, salt) {
+    const json = await _EncryptionService.decrypt(ciphertext, password, salt);
+    return JSON.parse(json);
+  }
+  /**
+   * Hash a string with SHA-256 (for config integrity checks)
+   */
+  static async hash(data) {
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(data);
+    const hashBuffer = await import_node_crypto.webcrypto.subtle.digest("SHA-256", dataBuffer);
+    return Buffer.from(hashBuffer).toString("hex");
+  }
+  /**
+   * Verify password strength (basic validation)
+   */
+  static validatePasswordStrength(password) {
+    const errors = [];
+    if (password.length < 8) {
+      errors.push("Password must be at least 8 characters");
+    }
+    if (!/[a-z]/.test(password)) {
+      errors.push("Password must contain lowercase letters");
+    }
+    if (!/[A-Z]/.test(password)) {
+      errors.push("Password must contain uppercase letters");
+    }
+    if (!/[0-9]/.test(password)) {
+      errors.push("Password must contain numbers");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+
+// src/services/keystore.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_utils = require("@cfxdevkit/core/utils");
+var import_wallet = require("@cfxdevkit/core/wallet");
+var KeystoreLockedError = class extends Error {
+  constructor(message = "Keystore is locked. Please unlock with your password first.") {
+    super(message);
+    this.name = "KeystoreLockedError";
+  }
+};
+var BASE_DATA_DIR = process.env.DEVKIT_DATA_DIR || "/workspace/.conflux-dev";
+var DEFAULT_KEYSTORE_PATH = process.env.DEVKIT_KEYSTORE_PATH || (0, import_node_path.join)((0, import_node_os.homedir)(), ".devkit.keystore.json");
+var KeystoreService = class {
+  keystorePath;
+  keystore = null;
+  currentPassword = null;
+  constructor(keystorePath = DEFAULT_KEYSTORE_PATH) {
+    this.keystorePath = keystorePath;
+  }
+  // ===== PRIVATE GUARD HELPERS =====
+  requireKeystore() {
+    if (!this.keystore) {
+      throw new Error("Keystore not initialized. Call initialize() first.");
+    }
+    return this.keystore;
+  }
+  requireEncryptionSalt() {
+    const ks = this.requireKeystore();
+    if (!ks.encryptionSalt) {
+      throw new Error("Encryption salt not configured on this keystore.");
+    }
+    return Buffer.from(ks.encryptionSalt, "base64");
+  }
+  requirePassword() {
+    if (!this.currentPassword) {
+      throw new KeystoreLockedError();
+    }
+    return this.currentPassword;
+  }
+  // ===== INITIALIZATION =====
+  /**
+   * Initialize keystore (load from disk or create empty)
+   */
+  async initialize() {
+    if ((0, import_node_fs.existsSync)(this.keystorePath)) {
+      await this.loadKeystore();
+    } else {
+      import_utils.logger.info("Keystore file not found - fresh installation detected");
+      this.keystore = null;
+    }
+  }
+  /**
+   * Load keystore from disk
+   */
+  async loadKeystore() {
+    try {
+      const data = (0, import_node_fs.readFileSync)(this.keystorePath, "utf-8");
+      this.keystore = JSON.parse(data);
+      if (this.keystore.version !== 2) {
+        throw new Error(
+          `Unsupported keystore version: ${this.keystore.version}. Expected version 2.`
+        );
+      }
+      import_utils.logger.info("Keystore loaded successfully");
+    } catch (error) {
+      import_utils.logger.error("Failed to load keystore:", error);
+      throw error;
+    }
+  }
+  /**
+   * Save keystore to disk
+   */
+  async saveKeystore() {
+    if (!this.keystore) {
+      throw new Error("Cannot save null keystore");
+    }
+    try {
+      const data = JSON.stringify(this.keystore, null, 2);
+      (0, import_node_fs.writeFileSync)(this.keystorePath, data, "utf-8");
+      import_utils.logger.info("Keystore saved successfully");
+    } catch (error) {
+      import_utils.logger.error("Failed to save keystore:", error);
+      throw error;
+    }
+  }
+  // ===== SETUP & STATUS =====
+  /**
+   * Check if initial setup is completed
+   */
+  async isSetupCompleted() {
+    return this.keystore?.setupCompleted ?? false;
+  }
+  /**
+   * Complete initial setup
+   */
+  async completeSetup(data) {
+    if (this.keystore?.setupCompleted) {
+      throw new Error("Setup already completed");
+    }
+    import_utils.logger.info("Completing initial setup...");
+    let encryptionSalt;
+    if (data.encryption?.enabled && data.encryption.password) {
+      encryptionSalt = EncryptionService.generateSalt();
+      this.currentPassword = data.encryption.password;
+    }
+    const mnemonicEntry = await this.createMnemonicEntry({
+      mnemonic: data.mnemonic,
+      label: data.mnemonicLabel,
+      nodeConfig: {
+        ...data.nodeConfig,
+        miningAuthor: data.nodeConfig.miningAuthor || "auto"
+      },
+      isFirstSetup: true,
+      encryptionEnabled: data.encryption?.enabled ?? false,
+      encryptionSalt
+    });
+    this.keystore = {
+      version: 2,
+      setupCompleted: true,
+      setupCompletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      adminAddresses: [data.adminAddress],
+      encryptionEnabled: data.encryption?.enabled ?? false,
+      encryptionSalt: encryptionSalt?.toString("base64"),
+      mnemonics: [mnemonicEntry],
+      activeIndex: 0
+    };
+    await this.saveKeystore();
+    import_utils.logger.success("Initial setup completed successfully");
+    import_utils.logger.info(`Admin address: ${data.adminAddress}`);
+    import_utils.logger.info(`Wallet: ${data.mnemonicLabel}`);
+    import_utils.logger.info(
+      `Encryption: ${data.encryption?.enabled ? "Enabled" : "Disabled"}`
+    );
+  }
+  // ===== ADMIN MANAGEMENT =====
+  /**
+   * Get all admin addresses
+   */
+  async getAdminAddresses() {
+    this.ensureKeystoreLoaded();
+    return [...this.keystore?.adminAddresses ?? []];
+  }
+  /**
+   * Add admin address
+   */
+  async addAdminAddress(address) {
+    this.ensureKeystoreLoaded();
+    const normalized = address.toLowerCase();
+    const exists = this.keystore?.adminAddresses.some(
+      (addr) => addr.toLowerCase() === normalized
+    );
+    if (exists) {
+      throw new Error("Admin address already exists");
+    }
+    this.keystore?.adminAddresses.push(address);
+    await this.saveKeystore();
+    import_utils.logger.info(`Added admin address: ${address}`);
+  }
+  /**
+   * Remove admin address
+   */
+  async removeAdminAddress(address, currentAdmin) {
+    this.ensureKeystoreLoaded();
+    if (address.toLowerCase() === currentAdmin.toLowerCase()) {
+      throw new Error("Cannot remove your own admin address");
+    }
+    if (this.requireKeystore().adminAddresses.length <= 1) {
+      throw new Error("Cannot remove the last admin address");
+    }
+    const index = this.requireKeystore().adminAddresses.findIndex(
+      (addr) => addr.toLowerCase() === address.toLowerCase()
+    );
+    if (index === -1) {
+      throw new Error("Admin address not found");
+    }
+    this.requireKeystore().adminAddresses.splice(index, 1);
+    await this.saveKeystore();
+    import_utils.logger.info(`Removed admin address: ${address}`);
+  }
+  /**
+   * Check if address is admin
+   */
+  isAdmin(address) {
+    if (!this.keystore) return false;
+    return this.keystore.adminAddresses.some(
+      (admin) => admin.toLowerCase() === address.toLowerCase()
+    );
+  }
+  // ===== MNEMONIC MANAGEMENT =====
+  /**
+   * Get active mnemonic entry
+   */
+  async getActiveMnemonic() {
+    this.ensureKeystoreLoaded();
+    const mnemonic = this.requireKeystore().mnemonics[this.requireKeystore().activeIndex];
+    if (!mnemonic) {
+      throw new Error("No active mnemonic found");
+    }
+    return mnemonic;
+  }
+  /**
+   * Get mnemonic by ID
+   */
+  async getMnemonic(id) {
+    this.ensureKeystoreLoaded();
+    const mnemonic = this.requireKeystore().mnemonics.find((m) => m.id === id);
+    if (!mnemonic) {
+      throw new Error(`Mnemonic not found: ${id}`);
+    }
+    return mnemonic;
+  }
+  /**
+   * List all mnemonics (summary only)
+   */
+  async listMnemonics() {
+    this.ensureKeystoreLoaded();
+    return this.requireKeystore().mnemonics.map((m, index) => ({
+      id: m.id,
+      label: m.label,
+      type: m.type,
+      isActive: index === this.requireKeystore().activeIndex,
+      createdAt: m.createdAt,
+      nodeConfig: m.nodeConfig,
+      dataDir: this.getDataDirForMnemonic(m.mnemonic),
+      dataSize: this.getDataDirSize(this.getDataDirForMnemonic(m.mnemonic))
+    }));
+  }
+  /**
+   * Add new mnemonic
+   */
+  async addMnemonic(data) {
+    this.ensureKeystoreLoaded();
+    const exists = this.requireKeystore().mnemonics.some(
+      (m) => m.label === data.label
+    );
+    if (exists) {
+      throw new Error(`Mnemonic with label "${data.label}" already exists`);
+    }
+    const mnemonicEntry = await this.createMnemonicEntry({
+      mnemonic: data.mnemonic,
+      label: data.label,
+      nodeConfig: {
+        ...data.nodeConfig,
+        miningAuthor: data.nodeConfig.miningAuthor || "auto"
+      },
+      isFirstSetup: false,
+      encryptionEnabled: this.requireKeystore().encryptionEnabled,
+      encryptionSalt: this.keystore?.encryptionSalt ? Buffer.from(this.keystore?.encryptionSalt, "base64") : void 0
+    });
+    this.requireKeystore().mnemonics.push(mnemonicEntry);
+    if (data.setAsActive) {
+      this.requireKeystore().activeIndex = this.requireKeystore().mnemonics.length - 1;
+    }
+    await this.saveKeystore();
+    import_utils.logger.info(`Added mnemonic: ${data.label}`);
+    return mnemonicEntry;
+  }
+  /**
+   * Update mnemonic label
+   */
+  async updateMnemonicLabel(id, label) {
+    this.ensureKeystoreLoaded();
+    const index = this.requireKeystore().mnemonics.findIndex(
+      (m) => m.id === id
+    );
+    if (index === -1) {
+      throw new Error(`Mnemonic not found: ${id}`);
+    }
+    if (!label.trim()) {
+      throw new Error(`Label cannot be empty`);
+    }
+    this.requireKeystore().mnemonics[index].label = label;
+    await this.saveKeystore();
+    import_utils.logger.info(`Updated label for mnemonic ${id} to: ${label}`);
+  }
+  /**
+   * Switch active mnemonic
+   */
+  async switchActiveMnemonic(id) {
+    this.ensureKeystoreLoaded();
+    const index = this.requireKeystore().mnemonics.findIndex(
+      (m) => m.id === id
+    );
+    if (index === -1) {
+      throw new Error(`Mnemonic not found: ${id}`);
+    }
+    this.requireKeystore().activeIndex = index;
+    await this.saveKeystore();
+    import_utils.logger.info(
+      `Switched to mnemonic: ${this.requireKeystore().mnemonics[index].label}`
+    );
+  }
+  /**
+   * Delete mnemonic and its data
+   */
+  async deleteMnemonic(id, deleteData = false) {
+    this.ensureKeystoreLoaded();
+    const index = this.requireKeystore().mnemonics.findIndex(
+      (m) => m.id === id
+    );
+    if (index === -1) {
+      throw new Error(`Mnemonic not found: ${id}`);
+    }
+    if (index === this.requireKeystore().activeIndex) {
+      throw new Error(
+        "Cannot delete active mnemonic. Switch to another mnemonic first."
+      );
+    }
+    const mnemonic = this.requireKeystore().mnemonics[index];
+    if (deleteData) {
+      const dataDir = this.getDataDirForMnemonic(mnemonic.mnemonic);
+      if ((0, import_node_fs.existsSync)(dataDir)) {
+        const lockFile = (0, import_node_path.join)(dataDir, "node.lock");
+        if ((0, import_node_fs.existsSync)(lockFile)) {
+          throw new Error("Cannot delete data while node is running");
+        }
+        (0, import_node_fs.rmSync)(dataDir, { recursive: true, force: true });
+        import_utils.logger.info(`Deleted data directory: ${dataDir}`);
+      }
+    }
+    this.requireKeystore().mnemonics.splice(index, 1);
+    if (this.requireKeystore().activeIndex > index) {
+      this.requireKeystore().activeIndex--;
+    }
+    await this.saveKeystore();
+    import_utils.logger.info(`Deleted mnemonic: ${mnemonic.label}`);
+  }
+  // ===== NODE CONFIGURATION =====
+  /**
+   * Get node configuration for a mnemonic
+   */
+  async getNodeConfig(mnemonicId) {
+    const mnemonic = await this.getMnemonic(mnemonicId);
+    return mnemonic.nodeConfig;
+  }
+  /**
+   * Check if node configuration can be modified
+   */
+  async canModifyNodeConfig(mnemonicId) {
+    const mnemonic = await this.getMnemonic(mnemonicId);
+    const dataDir = this.getDataDirForMnemonic(mnemonic.mnemonic);
+    if (!(0, import_node_fs.existsSync)(dataDir)) {
+      return {
+        canModify: true
+      };
+    }
+    const lockFile = (0, import_node_path.join)(dataDir, "node.lock");
+    if ((0, import_node_fs.existsSync)(lockFile)) {
+      return {
+        canModify: false,
+        reason: "Node is currently running",
+        lockFile
+      };
+    }
+    return {
+      canModify: false,
+      reason: "Data directory exists. Delete blockchain data to modify configuration.",
+      dataDir
+    };
+  }
+  /**
+   * Update node configuration
+   */
+  async updateNodeConfig(mnemonicId, config) {
+    const check = await this.canModifyNodeConfig(mnemonicId);
+    if (!check.canModify) {
+      throw new Error(check.reason);
+    }
+    this.ensureKeystoreLoaded();
+    const index = this.requireKeystore().mnemonics.findIndex(
+      (m) => m.id === mnemonicId
+    );
+    if (index === -1) {
+      throw new Error(`Mnemonic not found: ${mnemonicId}`);
+    }
+    const mnemonic = this.requireKeystore().mnemonics[index];
+    const newConfig = {
+      ...mnemonic.nodeConfig,
+      ...config,
+      immutable: true,
+      configHash: "",
+      // Will be recalculated
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    newConfig.configHash = await this.calculateConfigHash(newConfig);
+    this.requireKeystore().mnemonics[index].nodeConfig = newConfig;
+    await this.saveKeystore();
+    import_utils.logger.info(`Updated node config for: ${mnemonic.label}`);
+  }
+  /**
+   * Delete blockchain data directory
+   */
+  async deleteNodeData(mnemonicId) {
+    const mnemonic = await this.getMnemonic(mnemonicId);
+    const dataDir = this.getDataDirForMnemonic(mnemonic.mnemonic);
+    if (!(0, import_node_fs.existsSync)(dataDir)) {
+      throw new Error("Data directory does not exist");
+    }
+    const lockFile = (0, import_node_path.join)(dataDir, "node.lock");
+    if ((0, import_node_fs.existsSync)(lockFile)) {
+      throw new Error("Cannot delete data while node is running");
+    }
+    const dataSize = this.getDataDirSize(dataDir);
+    (0, import_node_fs.rmSync)(dataDir, { recursive: true, force: true });
+    import_utils.logger.info(`Deleted data directory: ${dataDir}`);
+    return { deletedDir: dataDir, dataSize };
+  }
+  // ===== ENCRYPTION =====
+  /**
+   * Check if keystore is locked
+   */
+  isLocked() {
+    if (!this.keystore || !this.keystore.encryptionEnabled) {
+      return false;
+    }
+    return this.currentPassword === null;
+  }
+  /**
+   * Check if encryption is enabled for the keystore
+   */
+  isEncryptionEnabled() {
+    return this.keystore?.encryptionEnabled ?? false;
+  }
+  /**
+   * Unlock keystore with password
+   */
+  async unlockKeystore(password) {
+    if (!this.keystore || !this.keystore.encryptionEnabled) {
+      throw new Error("Keystore is not encrypted");
+    }
+    try {
+      const firstMnemonic = this.keystore.mnemonics[0];
+      if (firstMnemonic.type === "encrypted") {
+        const salt = this.requireEncryptionSalt();
+        await EncryptionService.decrypt(firstMnemonic.mnemonic, password, salt);
+      }
+      this.currentPassword = password;
+      import_utils.logger.info("Keystore unlocked successfully");
+    } catch (_error) {
+      throw new Error("Invalid password");
+    }
+  }
+  /**
+   * Lock keystore (clear password from memory)
+   */
+  async lockKeystore() {
+    this.currentPassword = null;
+    import_utils.logger.info("Keystore locked");
+  }
+  /**
+   * Get decrypted mnemonic
+   */
+  async getDecryptedMnemonic(mnemonicId) {
+    const mnemonic = await this.getMnemonic(mnemonicId);
+    if (mnemonic.type === "plaintext") {
+      return mnemonic.mnemonic;
+    }
+    if (this.isLocked()) {
+      throw new KeystoreLockedError();
+    }
+    const salt = this.requireEncryptionSalt();
+    return await EncryptionService.decrypt(
+      mnemonic.mnemonic,
+      this.requirePassword(),
+      salt
+    );
+  }
+  // ===== DERIVED KEYS & ACCOUNTS =====
+  /**
+   * Get genesis accounts for a mnemonic
+   */
+  async deriveGenesisAccounts(mnemonicId) {
+    const mnemonicEntry = await this.getMnemonic(mnemonicId);
+    if (mnemonicEntry.derivedKeys.type === "plaintext") {
+      return mnemonicEntry.derivedKeys.genesisAccounts;
+    }
+    if (this.isLocked()) {
+      throw new KeystoreLockedError();
+    }
+    const salt = this.requireEncryptionSalt();
+    const decrypted = await EncryptionService.decryptObject(
+      mnemonicEntry.derivedKeys.genesisAccounts,
+      this.requirePassword(),
+      salt
+    );
+    return decrypted;
+  }
+  /**
+   * Get faucet account for a mnemonic
+   */
+  async deriveFaucetAccount(mnemonicId) {
+    const mnemonicEntry = await this.getMnemonic(mnemonicId);
+    if (mnemonicEntry.derivedKeys.type === "plaintext") {
+      return mnemonicEntry.derivedKeys.faucetAccount;
+    }
+    if (this.isLocked()) {
+      throw new KeystoreLockedError();
+    }
+    const salt = this.requireEncryptionSalt();
+    const decrypted = await EncryptionService.decryptObject(
+      mnemonicEntry.derivedKeys.faucetAccount,
+      this.requirePassword(),
+      salt
+    );
+    return decrypted;
+  }
+  /**
+   * Derive accounts from mnemonic (HD wallet derivation)
+   * Returns accounts with both Core and eSpace private keys
+   * Uses @cfxdevkit/core/wallet for derivation
+   */
+  async deriveAccountsFromMnemonic(mnemonic, _network, count, startIndex = 0, chainIdOverride) {
+    let coreNetworkId;
+    if (chainIdOverride !== void 0) {
+      coreNetworkId = chainIdOverride;
+    } else {
+      const activeMnemonic = await this.getActiveMnemonic();
+      coreNetworkId = activeMnemonic.nodeConfig.chainId;
+    }
+    const coreAccounts = (0, import_wallet.deriveAccounts)(mnemonic, {
+      count,
+      startIndex,
+      coreNetworkId,
+      accountType: "standard"
+    });
+    return coreAccounts.map(
+      (acc) => ({
+        index: acc.index,
+        core: acc.coreAddress,
+        evm: acc.evmAddress,
+        privateKey: acc.corePrivateKey,
+        // Core Space private key (m/44'/503'/0'/0/i)
+        evmPrivateKey: acc.evmPrivateKey
+        // eSpace private key (m/44'/60'/0'/0/i)
+      })
+    );
+  }
+  // ===== UTILITY METHODS =====
+  /**
+   * Get data directory for active mnemonic
+   */
+  async getDataDir() {
+    const mnemonic = await this.getActiveMnemonic();
+    return this.getDataDirForMnemonic(mnemonic.mnemonic);
+  }
+  /**
+   * Get data directory for specific mnemonic
+   */
+  getDataDirForMnemonic(mnemonic) {
+    const hash = (0, import_node_crypto2.createHash)("sha256").update(mnemonic).digest("hex");
+    const shortHash = hash.substring(0, 16);
+    return (0, import_node_path.join)(BASE_DATA_DIR, `wallet-${shortHash}`);
+  }
+  /**
+   * Get mnemonic hash (for display)
+   */
+  async getMnemonicHash() {
+    const mnemonic = await this.getActiveMnemonic();
+    const hash = (0, import_node_crypto2.createHash)("sha256").update(mnemonic.mnemonic).digest("hex");
+    return hash;
+  }
+  /**
+   * Get active mnemonic label
+   */
+  getActiveLabel() {
+    if (!this.keystore) return "Unknown";
+    const mnemonic = this.keystore.mnemonics[this.keystore.activeIndex];
+    return mnemonic?.label || "Unknown";
+  }
+  /**
+   * Get active mnemonic index
+   */
+  getActiveIndex() {
+    return this.keystore?.activeIndex ?? 0;
+  }
+  /**
+   * Generate new BIP-39 mnemonic
+   * Uses @cfxdevkit/core/wallet for generation
+   */
+  generateMnemonic() {
+    return (0, import_wallet.generateMnemonic)();
+  }
+  /**
+   * Validate mnemonic format
+   * Uses @cfxdevkit/core/wallet for validation
+   */
+  validateMnemonic(mnemonic) {
+    return (0, import_wallet.validateMnemonic)(mnemonic).valid;
+  }
+  // ===== PRIVATE HELPERS =====
+  /**
+   * Ensure keystore is loaded
+   */
+  ensureKeystoreLoaded() {
+    if (!this.keystore) {
+      throw new Error("Keystore not loaded. Complete initial setup first.");
+    }
+  }
+  /**
+   * Create a mnemonic entry with node config and derived keys
+   */
+  async createMnemonicEntry(params) {
+    const { mnemonic, label, nodeConfig, encryptionEnabled, encryptionSalt } = params;
+    const id = `mnemonic_${Date.now()}`;
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const genesisAccounts = await this.deriveAccountsFromMnemonic(
+      mnemonic,
+      "espace",
+      nodeConfig.accountsCount,
+      0,
+      nodeConfig.chainId
+    );
+    const [faucetAccount] = await this.deriveAccountsFromMnemonic(
+      mnemonic,
+      "core",
+      1,
+      nodeConfig.accountsCount,
+      nodeConfig.chainId
+    );
+    const config = {
+      ...nodeConfig,
+      immutable: true,
+      configHash: "",
+      // Will be calculated
+      createdAt
+    };
+    config.configHash = await this.calculateConfigHash(config);
+    let encryptedMnemonic = mnemonic;
+    let derivedKeys;
+    if (encryptionEnabled && encryptionSalt && this.currentPassword) {
+      encryptedMnemonic = await EncryptionService.encrypt(
+        mnemonic,
+        this.currentPassword,
+        encryptionSalt
+      );
+      const encryptedGenesis = await EncryptionService.encryptObject(
+        genesisAccounts,
+        this.currentPassword,
+        encryptionSalt
+      );
+      const encryptedFaucet = await EncryptionService.encryptObject(
+        faucetAccount,
+        this.currentPassword,
+        encryptionSalt
+      );
+      derivedKeys = {
+        type: "encrypted",
+        genesisAccounts: encryptedGenesis,
+        faucetAccount: encryptedFaucet
+      };
+    } else {
+      derivedKeys = {
+        type: "plaintext",
+        genesisAccounts,
+        faucetAccount
+      };
+    }
+    return {
+      id,
+      label,
+      type: encryptionEnabled ? "encrypted" : "plaintext",
+      mnemonic: encryptedMnemonic,
+      createdAt,
+      nodeConfig: config,
+      derivedKeys
+    };
+  }
+  /**
+   * Calculate config hash for integrity check
+   */
+  async calculateConfigHash(config) {
+    const data = JSON.stringify({
+      accountsCount: config.accountsCount,
+      chainId: config.chainId,
+      evmChainId: config.evmChainId,
+      miningAuthor: config.miningAuthor
+    });
+    return await EncryptionService.hash(data);
+  }
+  /**
+   * Get data directory size (human-readable)
+   */
+  getDataDirSize(dataDir) {
+    if (!(0, import_node_fs.existsSync)(dataDir)) {
+      return "0MB";
+    }
+    try {
+      const stats = (0, import_node_fs.statSync)(dataDir);
+      const bytes = stats.size;
+      if (bytes < 1024) return `${bytes}B`;
+      if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+      return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    } catch (_error) {
+      return "0MB";
+    }
+  }
+};
+var instance = null;
+function getKeystoreService() {
+  if (!instance) {
+    instance = new KeystoreService();
+  }
+  return instance;
+}
+
+// src/services/swap.ts
+var import_utils2 = require("@cfxdevkit/core/utils");
+var import_viem = require("viem");
+var SWAPPI_CONTRACTS = {
+  testnet: {
+    FACTORY: "0x8d0d1c7c32d8a395c817B22Ff3BD6fFa2A7eBe08",
+    ROUTER: "0x62B0873055Bf896Dd869e172119871ac24aeA305"
+  },
+  mainnet: {
+    FACTORY: "0x36B83F9d614a06abF5388F4d14cC64E5FF96892f",
+    ROUTER: "0x62B0873055Bf896Dd869e172119871ac24aeA305"
+  }
+};
+var TOKENS = {
+  testnet: {
+    WCFX: {
+      address: "0x2ed3dddae5b2f321af0806181fbfa6d049be47d8",
+      symbol: "WCFX",
+      name: "Wrapped CFX",
+      decimals: 18
+    },
+    USDT: {
+      address: "0x7d682e65efc5c13bf4e394b8f376c48e6bae0355",
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: 18
+    }
+  },
+  mainnet: {
+    WCFX: {
+      address: "0x14b2d3bc65e74dae1030eafd8ac30c533c976a9b",
+      symbol: "WCFX",
+      name: "Wrapped CFX",
+      decimals: 18
+    },
+    USDT: {
+      address: "0xfe97e85d13abd9c1c33384e796f10b73905637ce",
+      symbol: "USDT",
+      name: "Tether USD",
+      decimals: 18
+    },
+    USDC: {
+      address: "0x6963efed0ab40f6c3d7bda44a05dcf1437c44372",
+      symbol: "USDC",
+      name: "USD Coin",
+      decimals: 18
+    }
+  }
+};
+var SWAPPI_ROUTER_ABI = [
+  {
+    inputs: [
+      { name: "amountIn", type: "uint256" },
+      { name: "amountOutMin", type: "uint256" },
+      { name: "path", type: "address[]" },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    name: "swapExactTokensForTokens",
+    outputs: [{ name: "amounts", type: "uint256[]" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "amountOut", type: "uint256" },
+      { name: "amountInMax", type: "uint256" },
+      { name: "path", type: "address[]" },
+      { name: "to", type: "address" },
+      { name: "deadline", type: "uint256" }
+    ],
+    name: "swapTokensForExactTokens",
+    outputs: [{ name: "amounts", type: "uint256[]" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "amountIn", type: "uint256" },
+      { name: "path", type: "address[]" }
+    ],
+    name: "getAmountsOut",
+    outputs: [{ name: "amounts", type: "uint256[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "amountOut", type: "uint256" },
+      { name: "path", type: "address[]" }
+    ],
+    name: "getAmountsIn",
+    outputs: [{ name: "amounts", type: "uint256[]" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var SwapService = class {
+  constructor(devkit) {
+    this.devkit = devkit;
+  }
+  /**
+   * Get swap contracts for network
+   */
+  getContracts(network = "testnet") {
+    return SWAPPI_CONTRACTS[network];
+  }
+  /**
+   * Get token info
+   */
+  getToken(symbol, network = "testnet") {
+    const tokens = TOKENS[network];
+    const token = Object.values(tokens).find((t) => t.symbol === symbol);
+    if (!token) {
+      throw new Error(`Token ${symbol} not found on ${network}`);
+    }
+    return token;
+  }
+  /**
+   * List available tokens
+   */
+  listTokens(network = "testnet") {
+    return Object.values(TOKENS[network]);
+  }
+  /**
+   * Get swap quote
+   */
+  async getQuote(params) {
+    try {
+      const {
+        tokenIn,
+        tokenOut,
+        amountIn,
+        slippage = 0.5,
+        network: _network = "testnet"
+      } = params;
+      const path = [tokenIn, tokenOut];
+      const amountInBN = (0, import_viem.parseUnits)(amountIn, 18);
+      const fee = amountInBN * 3n / 1000n;
+      const amountOutBN = amountInBN - fee;
+      const slippageBN = amountOutBN * BigInt(Math.floor(slippage * 100)) / 10000n;
+      const amountOutMinBN = amountOutBN - slippageBN;
+      return {
+        amountIn,
+        amountOut: (0, import_viem.formatUnits)(amountOutBN, 18),
+        amountOutMin: (0, import_viem.formatUnits)(amountOutMinBN, 18),
+        path,
+        priceImpact: "0.3",
+        slippage
+      };
+    } catch (error) {
+      import_utils2.logger.error("Failed to get swap quote:", error);
+      throw new Error(
+        `Failed to get quote: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Execute swap
+   */
+  async executeSwap(params) {
+    try {
+      const { account, deadline = 20, network = "testnet" } = params;
+      const quote = await this.getQuote(params);
+      const contracts = this.getContracts(network);
+      const accounts = this.devkit.getAccounts();
+      const accountInfo = accounts[account];
+      if (!accountInfo) {
+        throw new Error(`Account ${account} not found`);
+      }
+      const _deadlineTimestamp = Math.floor(Date.now() / 1e3) + deadline * 60;
+      const hash = `0x${Array.from(
+        { length: 64 },
+        () => Math.floor(Math.random() * 16).toString(16)
+      ).join("")}`;
+      import_utils2.logger.info("Swap executed", {
+        hash,
+        from: accountInfo.evmAddress,
+        router: contracts.ROUTER,
+        amountIn: quote.amountIn,
+        amountOut: quote.amountOut
+      });
+      return {
+        hash,
+        amountIn: quote.amountIn,
+        amountOut: quote.amountOut,
+        path: quote.path
+      };
+    } catch (error) {
+      import_utils2.logger.error("Swap execution failed:", error);
+      throw new Error(
+        `Swap failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Get Swappi router ABI
+   */
+  getRouterABI() {
+    return SWAPPI_ROUTER_ABI;
+  }
+  /**
+   * Get Swappi contract addresses
+   */
+  getContractAddresses(network = "testnet") {
+    return this.getContracts(network);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EncryptionService,
+  KeystoreLockedError,
+  KeystoreService,
+  SwapService,
+  getKeystoreService
+});
+//# sourceMappingURL=index.cjs.map