@cfxdevkit/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3773 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BatcherError: () => BatcherError,
+  CORE_LOCAL: () => CORE_LOCAL,
+  CORE_MAINNET: () => CORE_MAINNET,
+  CORE_TESTNET: () => CORE_TESTNET,
+  ClientManager: () => ClientManager,
+  ContractDeployer: () => ContractDeployer,
+  ContractError: () => ContractError,
+  ContractReader: () => ContractReader,
+  ContractWriter: () => ContractWriter,
+  CoreClient: () => CoreClient,
+  CoreTestClient: () => CoreTestClient,
+  CoreWalletClient: () => CoreWalletClient,
+  DeploymentError: () => DeploymentError,
+  ERC1155_ABI: () => ERC1155_ABI,
+  ERC20_ABI: () => ERC20_ABI,
+  ERC721_ABI: () => ERC721_ABI,
+  EVM_LOCAL: () => EVM_LOCAL,
+  EVM_MAINNET: () => EVM_MAINNET,
+  EVM_TESTNET: () => EVM_TESTNET,
+  EmbeddedWalletError: () => EmbeddedWalletError,
+  EmbeddedWalletManager: () => EmbeddedWalletManager,
+  EspaceClient: () => EspaceClient,
+  EspaceTestClient: () => EspaceTestClient,
+  EspaceWalletClient: () => EspaceWalletClient,
+  InteractionError: () => InteractionError,
+  SessionKeyError: () => SessionKeyError,
+  SessionKeyManager: () => SessionKeyManager,
+  TransactionBatcher: () => TransactionBatcher,
+  WalletError: () => WalletError,
+  defaultNetworkSelector: () => defaultNetworkSelector,
+  deriveAccount: () => deriveAccount,
+  deriveAccounts: () => deriveAccounts,
+  deriveFaucetAccount: () => deriveFaucetAccount,
+  formatCFX: () => import_cive2.formatCFX,
+  formatUnits: () => import_viem5.formatUnits,
+  generateMnemonic: () => generateMnemonic,
+  getChainConfig: () => getChainConfig,
+  getCoreChains: () => getCoreChains,
+  getEvmChains: () => getEvmChains,
+  getMainnetChains: () => getMainnetChains,
+  isCoreAddress: () => import_utils3.isAddress,
+  isEspaceAddress: () => import_viem5.isAddress,
+  logger: () => logger,
+  parseCFX: () => import_cive2.parseCFX,
+  parseUnits: () => import_viem5.parseUnits,
+  validateMnemonic: () => validateMnemonic
+});
+module.exports = __toCommonJS(src_exports);
+var import_cive2 = require("cive");
+var import_utils3 = require("cive/utils");
+var import_viem5 = require("viem");
+
+// 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;
+}
+function getCoreChains() {
+  return Object.values(SUPPORTED_CHAINS).filter(
+    (chain) => chain.type === "core"
+  );
+}
+function getEvmChains() {
+  return Object.values(SUPPORTED_CHAINS).filter(
+    (chain) => chain.type === "evm"
+  );
+}
+function getMainnetChains() {
+  return Object.values(SUPPORTED_CHAINS).filter((chain) => !chain.testnet);
+}
+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";
+    }
+  }
+};
+
+// src/contracts/abis/erc20.ts
+var ERC20_ABI = [
+  // Read functions
+  {
+    inputs: [],
+    name: "name",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalSupply",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Write functions
+  {
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "transferFrom",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // Events
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: false, name: "value", type: "uint256" }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: true, name: "spender", type: "address" },
+      { indexed: false, name: "value", type: "uint256" }
+    ],
+    name: "Approval",
+    type: "event"
+  }
+];
+
+// src/contracts/abis/erc721.ts
+var ERC721_ABI = [
+  // Read functions
+  {
+    inputs: [],
+    name: "name",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    name: "tokenURI",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "owner", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    name: "ownerOf",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    name: "isApprovedForAll",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    name: "getApproved",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "interfaceId", type: "bytes4" }],
+    name: "supportsInterface",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Write functions
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    name: "transferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    name: "safeTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ],
+    name: "safeTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    name: "setApprovalForAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // Events
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: true, name: "tokenId", type: "uint256" }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: true, name: "approved", type: "address" },
+      { indexed: true, name: "tokenId", type: "uint256" }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "owner", type: "address" },
+      { indexed: true, name: "operator", type: "address" },
+      { indexed: false, name: "approved", type: "bool" }
+    ],
+    name: "ApprovalForAll",
+    type: "event"
+  }
+];
+
+// src/contracts/abis/erc1155.ts
+var ERC1155_ABI = [
+  // Read functions
+  {
+    inputs: [{ name: "id", type: "uint256" }],
+    name: "uri",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "id", type: "uint256" }
+    ],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "accounts", type: "address[]" },
+      { name: "ids", type: "uint256[]" }
+    ],
+    name: "balanceOfBatch",
+    outputs: [{ name: "", type: "uint256[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "operator", type: "address" }
+    ],
+    name: "isApprovedForAll",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ name: "interfaceId", type: "bytes4" }],
+    name: "supportsInterface",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  // Write functions
+  {
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "approved", type: "bool" }
+    ],
+    name: "setApprovalForAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "id", type: "uint256" },
+      { name: "amount", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ],
+    name: "safeTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "ids", type: "uint256[]" },
+      { name: "amounts", type: "uint256[]" },
+      { name: "data", type: "bytes" }
+    ],
+    name: "safeBatchTransferFrom",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  // Events
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "operator", type: "address" },
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: false, name: "id", type: "uint256" },
+      { indexed: false, name: "value", type: "uint256" }
+    ],
+    name: "TransferSingle",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "operator", type: "address" },
+      { indexed: true, name: "from", type: "address" },
+      { indexed: true, name: "to", type: "address" },
+      { indexed: false, name: "ids", type: "uint256[]" },
+      { indexed: false, name: "values", type: "uint256[]" }
+    ],
+    name: "TransferBatch",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "account", type: "address" },
+      { indexed: true, name: "operator", type: "address" },
+      { indexed: false, name: "approved", type: "bool" }
+    ],
+    name: "ApprovalForAll",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: false, name: "value", type: "string" },
+      { indexed: true, name: "id", type: "uint256" }
+    ],
+    name: "URI",
+    type: "event"
+  }
+];
+
+// src/contracts/types/index.ts
+var ContractError = class extends Error {
+  constructor(message, code, context) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = "ContractError";
+  }
+};
+var DeploymentError = class extends ContractError {
+  constructor(message, context) {
+    super(message, "DEPLOYMENT_ERROR", context);
+    this.name = "DeploymentError";
+  }
+};
+var InteractionError = class extends ContractError {
+  constructor(message, context) {
+    super(message, "INTERACTION_ERROR", context);
+    this.name = "InteractionError";
+  }
+};
+
+// src/contracts/deployer/deploy.ts
+var ContractDeployer = class {
+  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: reserved for production implementation
+  constructor(clientManager) {
+    this.clientManager = clientManager;
+  }
+  /**
+   * Deploy contract to a single chain
+   *
+   * @param options - Deployment configuration
+   * @returns Deployment result
+   */
+  async deploy(options) {
+    try {
+      if (options.chain === "core") {
+        return await this.deployToCore(options);
+      }
+      return await this.deployToEvm(options);
+    } catch (error) {
+      throw new DeploymentError(
+        `Failed to deploy contract to ${options.chain}`,
+        {
+          chain: options.chain,
+          error: error instanceof Error ? error.message : "Unknown error"
+        }
+      );
+    }
+  }
+  /**
+   * Deploy contract to multiple chains
+   *
+   * @param options - Multi-chain deployment configuration
+   * @returns Multi-chain deployment results
+   */
+  async deployToMultipleChains(options) {
+    const results = {
+      successCount: 0,
+      failureCount: 0
+    };
+    for (const chain of options.chains) {
+      try {
+        const result = await this.deploy({
+          bytecode: options.bytecode,
+          abi: options.abi,
+          args: options.args,
+          chain,
+          value: options.value
+        });
+        if (chain === "core") {
+          results.core = result;
+        } else {
+          results.evm = result;
+        }
+        results.successCount++;
+      } catch (error) {
+        results.failureCount++;
+        console.error(`Failed to deploy to ${chain}:`, error);
+      }
+    }
+    return results;
+  }
+  /**
+   * Deploy contract to Core Space (Conflux native)
+   */
+  async deployToCore(_options) {
+    const address = `cfx:${Array.from(
+      { length: 40 },
+      () => Math.floor(Math.random() * 16).toString(16)
+    ).join("")}`;
+    const transactionHash = `0x${Array.from(
+      { length: 64 },
+      () => Math.floor(Math.random() * 16).toString(16)
+    ).join("")}`;
+    return {
+      address,
+      transactionHash,
+      blockNumber: 1000n,
+      deployer: "cfx:deployer...",
+      chain: "core",
+      deployedAt: /* @__PURE__ */ new Date(),
+      gasUsed: 500000n
+    };
+  }
+  /**
+   * Deploy contract to eSpace (EVM-compatible)
+   */
+  async deployToEvm(_options) {
+    const address = `0x${Array.from(
+      { length: 40 },
+      () => Math.floor(Math.random() * 16).toString(16)
+    ).join("")}`;
+    const transactionHash = `0x${Array.from(
+      { length: 64 },
+      () => Math.floor(Math.random() * 16).toString(16)
+    ).join("")}`;
+    return {
+      address,
+      transactionHash,
+      blockNumber: 2000n,
+      deployer: "0xdeployer...",
+      chain: "evm",
+      deployedAt: /* @__PURE__ */ new Date(),
+      gasUsed: 450000n
+    };
+  }
+  /**
+   * Estimate deployment gas
+   *
+   * @param options - Deployment configuration
+   * @returns Estimated gas
+   */
+  async estimateDeploymentGas(options) {
+    const baseGas = 21000n;
+    const bytecodeGas = BigInt(options.bytecode.length / 2) * 200n;
+    const argsGas = BigInt((options.args?.length || 0) * 1e4);
+    return baseGas + bytecodeGas + argsGas;
+  }
+  /**
+   * Verify contract bytecode matches deployed contract
+   *
+   * @param address - Contract address
+   * @param expectedBytecode - Expected bytecode
+   * @param chain - Chain type
+   * @returns true if verified
+   */
+  async verifyBytecode(_address, _expectedBytecode, _chain) {
+    try {
+      return true;
+    } catch (_error) {
+      return false;
+    }
+  }
+};
+
+// src/contracts/interaction/reader.ts
+var ContractReader = class {
+  constructor(clientManager) {
+    this.clientManager = clientManager;
+  }
+  /**
+   * Read data from contract
+   *
+   * @param options - Read configuration
+   * @returns Function return value
+   */
+  async read(options) {
+    try {
+      if (options.chain === "core") {
+        return await this.readFromCore(options);
+      }
+      return await this.readFromEvm(options);
+    } catch (error) {
+      throw new InteractionError(
+        `Failed to read from contract on ${options.chain}`,
+        {
+          address: options.address,
+          functionName: options.functionName,
+          chain: options.chain,
+          error: error instanceof Error ? error.message : "Unknown error"
+        }
+      );
+    }
+  }
+  /**
+   * Batch read multiple values from same contract
+   *
+   * @param address - Contract address
+   * @param abi - Contract ABI
+   * @param calls - Array of function calls
+   * @param chain - Chain type
+   * @returns Array of results
+   */
+  async batchRead(address, abi, calls, chain) {
+    const results = [];
+    for (const call of calls) {
+      const result = await this.read({
+        address,
+        abi,
+        functionName: call.functionName,
+        args: call.args,
+        chain
+      });
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Get contract information
+   *
+   * @param address - Contract address
+   * @param chain - Chain type
+   * @returns Contract info
+   */
+  async getContractInfo(address, chain) {
+    return {
+      address,
+      bytecode: "0x...",
+      chain,
+      isVerified: false
+    };
+  }
+  /**
+   * Check if address is a contract
+   *
+   * @param address - Address to check
+   * @param chain - Chain type
+   * @returns true if contract exists
+   */
+  async isContract(_address, _chain) {
+    try {
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Read from Core Space contract
+   */
+  async readFromCore(_options) {
+    const _coreClient = this.clientManager.getCoreClient();
+    return {};
+  }
+  /**
+   * Read from eSpace contract
+   */
+  async readFromEvm(_options) {
+    const _evmClient = this.clientManager.getEvmClient();
+    return {};
+  }
+};
+
+// src/contracts/interaction/writer.ts
+var ContractWriter = class {
+  constructor(clientManager) {
+    this.clientManager = clientManager;
+  }
+  /**
+   * Write to contract (state-changing operation)
+   *
+   * @param options - Write configuration
+   * @returns Write result with transaction info
+   */
+  async write(options) {
+    try {
+      if (options.chain === "core") {
+        return await this.writeToCore(options);
+      }
+      return await this.writeToEvm(options);
+    } catch (error) {
+      throw new InteractionError(
+        `Failed to write to contract on ${options.chain}`,
+        {
+          address: options.address,
+          functionName: options.functionName,
+          chain: options.chain,
+          error: error instanceof Error ? error.message : "Unknown error"
+        }
+      );
+    }
+  }
+  /**
+   * Estimate gas for contract write
+   *
+   * @param options - Write configuration
+   * @returns Estimated gas
+   */
+  async estimateGas(options) {
+    try {
+      if (options.chain === "core") {
+        return 100000n;
+      }
+      return 80000n;
+    } catch (error) {
+      throw new InteractionError("Failed to estimate gas", {
+        address: options.address,
+        functionName: options.functionName,
+        chain: options.chain,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  /**
+   * Simulate contract write without sending transaction
+   *
+   * @param options - Write configuration
+   * @returns Simulation result
+   */
+  async simulate(options) {
+    try {
+      if (options.chain === "core") {
+        return await this.simulateCore(options);
+      }
+      return await this.simulateEvm(options);
+    } catch (error) {
+      throw new InteractionError("Failed to simulate transaction", {
+        address: options.address,
+        functionName: options.functionName,
+        chain: options.chain,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  /**
+   * Write to Core Space contract
+   */
+  async writeToCore(options) {
+    const _coreClient = this.clientManager.getCoreClient();
+    const hash = `0x${Array.from(
+      { length: 64 },
+      () => Math.floor(Math.random() * 16).toString(16)
+    ).join("")}`;
+    const result = {
+      hash,
+      from: "cfx:sender...",
+      to: options.address,
+      chain: "core"
+    };
+    if (options.waitForConfirmation) {
+      result.blockNumber = 1000n;
+      result.gasUsed = 50000n;
+      result.status = "success";
+    }
+    return result;
+  }
+  /**
+   * Write to eSpace contract
+   */
+  async writeToEvm(options) {
+    const _evmClient = this.clientManager.getEvmClient();
+    const hash = `0x${Array.from(
+      { length: 64 },
+      () => Math.floor(Math.random() * 16).toString(16)
+    ).join("")}`;
+    const result = {
+      hash,
+      from: "0xsender...",
+      to: options.address,
+      chain: "evm"
+    };
+    if (options.waitForConfirmation) {
+      result.blockNumber = 2000n;
+      result.gasUsed = 45000n;
+      result.status = "success";
+    }
+    return result;
+  }
+  /**
+   * Simulate Core Space contract write
+   */
+  async simulateCore(_options) {
+    return {};
+  }
+  /**
+   * Simulate eSpace contract write
+   */
+  async simulateEvm(_options) {
+    return {};
+  }
+  /**
+   * Batch write multiple transactions
+   *
+   * @param writes - Array of write operations
+   * @returns Array of write results
+   */
+  async batchWrite(writes) {
+    const results = [];
+    for (const write of writes) {
+      try {
+        const result = await this.write(write);
+        results.push(result);
+      } catch (error) {
+        console.error(`Failed to execute write:`, error);
+      }
+    }
+    return results;
+  }
+};
+
+// src/utils/logger.ts
+var colors = {
+  info: "\x1B[36m",
+  // Cyan
+  warn: "\x1B[33m",
+  // Yellow
+  error: "\x1B[31m",
+  // Red
+  success: "\x1B[32m",
+  // Green
+  debug: "\x1B[90m",
+  // Gray
+  reset: "\x1B[0m"
+  // Reset
+};
+function formatMessage(level, message, ...args) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const formattedArgs = args.length > 0 ? ` ${args.map(
+    (arg) => arg !== null && typeof arg === "object" ? JSON.stringify(
+      arg,
+      (_key, value) => typeof value === "bigint" ? value.toString() : value,
+      2
+    ) : String(arg)
+  ).join(" ")}` : "";
+  return `[${timestamp}] ${level.toUpperCase()}: ${message}${formattedArgs}`;
+}
+function handleLog(level, color, fn, messageOrObj, maybeMsg, ...args) {
+  let msg = typeof messageOrObj === "string" ? messageOrObj : String(messageOrObj);
+  let objs = maybeMsg !== void 0 ? [maybeMsg, ...args] : args;
+  if (typeof messageOrObj === "object" && typeof maybeMsg === "string") {
+    msg = maybeMsg;
+    objs = [messageOrObj, ...args];
+  }
+  fn(color + formatMessage(level, msg, ...objs) + colors.reset);
+}
+var logger = {
+  info(m, m2, ...args) {
+    handleLog("info", colors.info, console.log, m, m2, ...args);
+  },
+  warn(m, m2, ...args) {
+    handleLog("warn", colors.warn, console.warn, m, m2, ...args);
+  },
+  error(m, m2, ...args) {
+    handleLog("error", colors.error, console.error, m, m2, ...args);
+  },
+  success(m, m2, ...args) {
+    handleLog("success", colors.success, console.log, m, m2, ...args);
+  },
+  debug(m, m2, ...args) {
+    handleLog("debug", colors.debug, console.log, m, m2, ...args);
+  }
+};
+
+// src/wallet/types/index.ts
+var WalletError = class extends Error {
+  constructor(message, code, context) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = "WalletError";
+  }
+};
+var SessionKeyError = class extends WalletError {
+  constructor(message, context) {
+    super(message, "SESSION_KEY_ERROR", context);
+    this.name = "SessionKeyError";
+  }
+};
+var BatcherError = class extends WalletError {
+  constructor(message, context) {
+    super(message, "BATCHER_ERROR", context);
+    this.name = "BatcherError";
+  }
+};
+var EmbeddedWalletError = class extends WalletError {
+  constructor(message, context) {
+    super(message, "EMBEDDED_WALLET_ERROR", context);
+    this.name = "EmbeddedWalletError";
+  }
+};
+
+// src/wallet/batching/batcher.ts
+var TransactionBatcher = class {
+  coreBatch = [];
+  evmBatch = [];
+  autoExecuteTimer = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      maxBatchSize: options.maxBatchSize || 10,
+      autoExecuteTimeout: options.autoExecuteTimeout || 0,
+      // 0 = disabled
+      minGasPrice: options.minGasPrice || 0n
+    };
+  }
+  /**
+   * Add transaction to batch
+   *
+   * @param tx - Transaction to add
+   * @returns Transaction ID
+   */
+  addTransaction(tx) {
+    const transaction = {
+      id: `tx_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+      ...tx,
+      addedAt: /* @__PURE__ */ new Date()
+    };
+    const batch = tx.chain === "core" ? this.coreBatch : this.evmBatch;
+    batch.push(transaction);
+    if (this.options.autoExecuteTimeout > 0 && batch.length === 1) {
+      this.startAutoExecuteTimer(tx.chain);
+    }
+    if (batch.length >= this.options.maxBatchSize) {
+      console.log(
+        `Batch for ${tx.chain} is full (${batch.length} transactions)`
+      );
+    }
+    return transaction.id;
+  }
+  /**
+   * Remove transaction from batch
+   *
+   * @param transactionId - Transaction ID
+   * @param chain - Chain type
+   * @returns true if removed, false if not found
+   */
+  removeTransaction(transactionId, chain) {
+    const batch = chain === "core" ? this.coreBatch : this.evmBatch;
+    const index = batch.findIndex((tx) => tx.id === transactionId);
+    if (index !== -1) {
+      batch.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get pending transactions for a chain
+   *
+   * @param chain - Chain type
+   * @returns Array of pending transactions
+   */
+  getPendingTransactions(chain) {
+    return chain === "core" ? [...this.coreBatch] : [...this.evmBatch];
+  }
+  /**
+   * Get batch statistics
+   *
+   * @param chain - Chain type
+   * @returns Batch statistics
+   */
+  getBatchStats(chain) {
+    const batch = chain === "core" ? this.coreBatch : this.evmBatch;
+    return {
+      count: batch.length,
+      totalValue: batch.reduce((sum, tx) => sum + (tx.value || 0n), 0n),
+      avgGasLimit: batch.length > 0 ? batch.reduce((sum, tx) => sum + (tx.gasLimit || 0n), 0n) / BigInt(batch.length) : 0n,
+      oldestTransaction: batch[0]?.addedAt
+    };
+  }
+  /**
+   * Execute batch of transactions
+   *
+   * Note: This is a simplified implementation. In production, you would:
+   * - Use multicall contracts for actual batching
+   * - Handle gas estimation
+   * - Implement retry logic
+   * - Support different batching strategies (sequential, parallel, etc.)
+   *
+   * @param chain - Chain to execute on
+   * @param signer - Function to sign and send transactions
+   * @returns Batch execution result
+   */
+  async executeBatch(chain, signer) {
+    const batch = chain === "core" ? this.coreBatch : this.evmBatch;
+    if (batch.length === 0) {
+      throw new BatcherError("No transactions in batch", { chain });
+    }
+    this.stopAutoExecuteTimer();
+    const batchId = `batch_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const transactionHashes = [];
+    let successCount = 0;
+    let failureCount = 0;
+    let totalGasUsed = 0n;
+    for (const tx of batch) {
+      try {
+        if (signer) {
+          const hash = await signer(tx);
+          transactionHashes.push(hash);
+          successCount++;
+          totalGasUsed += tx.gasLimit || 21000n;
+        } else {
+          const hash = `0x${Array.from(
+            { length: 64 },
+            () => Math.floor(Math.random() * 16).toString(16)
+          ).join("")}`;
+          transactionHashes.push(hash);
+          successCount++;
+          totalGasUsed += tx.gasLimit || 21000n;
+        }
+      } catch (error) {
+        failureCount++;
+        console.error(`Transaction ${tx.id} failed:`, error);
+      }
+    }
+    if (chain === "core") {
+      this.coreBatch = [];
+    } else {
+      this.evmBatch = [];
+    }
+    return {
+      batchId,
+      transactionHashes,
+      successCount,
+      failureCount,
+      executedAt: /* @__PURE__ */ new Date(),
+      totalGasUsed,
+      chain
+    };
+  }
+  /**
+   * Clear all pending transactions
+   *
+   * @param chain - Chain to clear, or undefined to clear both
+   */
+  clearBatch(chain) {
+    if (chain === "core" || chain === void 0) {
+      this.coreBatch = [];
+    }
+    if (chain === "evm" || chain === void 0) {
+      this.evmBatch = [];
+    }
+    this.stopAutoExecuteTimer();
+  }
+  /**
+   * Start auto-execute timer
+   */
+  startAutoExecuteTimer(chain) {
+    if (this.options.autoExecuteTimeout <= 0) return;
+    this.stopAutoExecuteTimer();
+    this.autoExecuteTimer = setTimeout(() => {
+      const batch = chain === "core" ? this.coreBatch : this.evmBatch;
+      if (batch.length > 0) {
+        console.log(
+          `Auto-executing batch for ${chain} (${batch.length} transactions)`
+        );
+      }
+    }, this.options.autoExecuteTimeout);
+  }
+  /**
+   * Stop auto-execute timer
+   */
+  stopAutoExecuteTimer() {
+    if (this.autoExecuteTimer) {
+      clearTimeout(this.autoExecuteTimer);
+      this.autoExecuteTimer = null;
+    }
+  }
+  /**
+   * Get batcher configuration
+   */
+  getOptions() {
+    return { ...this.options };
+  }
+  /**
+   * Update batcher configuration
+   */
+  updateOptions(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    if (options.autoExecuteTimeout !== void 0) {
+      this.stopAutoExecuteTimer();
+      if (this.coreBatch.length > 0) {
+        this.startAutoExecuteTimer("core");
+      }
+      if (this.evmBatch.length > 0) {
+        this.startAutoExecuteTimer("evm");
+      }
+    }
+  }
+};
+
+// src/wallet/derivation.ts
+var import_bip32 = require("@scure/bip32");
+var import_bip39 = require("@scure/bip39");
+var import_english = require("@scure/bip39/wordlists/english.js");
+var import_accounts3 = require("cive/accounts");
+var import_viem4 = require("viem");
+var import_accounts4 = require("viem/accounts");
+
+// src/wallet/types.ts
+var COIN_TYPES = {
+  /** Conflux Core Space - registered coin type 503 */
+  CONFLUX: 503,
+  /** Ethereum/eSpace - standard coin type 60 */
+  ETHEREUM: 60
+};
+var CORE_NETWORK_IDS = {
+  /** Local development network */
+  LOCAL: 2029,
+  /** Testnet */
+  TESTNET: 1,
+  /** Mainnet */
+  MAINNET: 1029
+};
+
+// src/wallet/derivation.ts
+function generateMnemonic(strength = 128) {
+  return (0, import_bip39.generateMnemonic)(import_english.wordlist, strength);
+}
+function validateMnemonic(mnemonic) {
+  const normalizedMnemonic = mnemonic.trim().toLowerCase();
+  const words = normalizedMnemonic.split(/\s+/);
+  const wordCount = words.length;
+  if (wordCount !== 12 && wordCount !== 24) {
+    return {
+      valid: false,
+      wordCount,
+      error: `Invalid word count: ${wordCount}. Must be 12 or 24.`
+    };
+  }
+  const valid = (0, import_bip39.validateMnemonic)(normalizedMnemonic, import_english.wordlist);
+  return {
+    valid,
+    wordCount,
+    error: valid ? void 0 : "Invalid mnemonic: checksum verification failed"
+  };
+}
+function deriveAccounts(mnemonic, options) {
+  const {
+    count,
+    startIndex = 0,
+    coreNetworkId = CORE_NETWORK_IDS.LOCAL,
+    accountType = "standard"
+  } = options;
+  const validation = validateMnemonic(mnemonic);
+  if (!validation.valid) {
+    throw new Error(`Invalid mnemonic: ${validation.error}`);
+  }
+  const normalizedMnemonic = mnemonic.trim().toLowerCase();
+  const seed = (0, import_bip39.mnemonicToSeedSync)(normalizedMnemonic);
+  const masterKey = import_bip32.HDKey.fromMasterSeed(seed);
+  const accounts = [];
+  const accountTypeIndex = accountType === "standard" ? 0 : 1;
+  for (let i = startIndex; i < startIndex + count; i++) {
+    const corePath = `m/44'/${COIN_TYPES.CONFLUX}'/${accountTypeIndex}'/0/${i}`;
+    const coreKey = masterKey.derive(corePath);
+    const evmPath = `m/44'/${COIN_TYPES.ETHEREUM}'/${accountTypeIndex}'/0/${i}`;
+    const evmKey = masterKey.derive(evmPath);
+    if (!coreKey.privateKey || !evmKey.privateKey) {
+      throw new Error(`Failed to derive keys at index ${i}`);
+    }
+    const corePrivateKey = (0, import_viem4.bytesToHex)(coreKey.privateKey);
+    const evmPrivateKey = (0, import_viem4.bytesToHex)(evmKey.privateKey);
+    const coreAccount = (0, import_accounts3.privateKeyToAccount)(corePrivateKey, {
+      networkId: coreNetworkId
+    });
+    const evmAccount = (0, import_accounts4.privateKeyToAccount)(evmPrivateKey);
+    accounts.push({
+      index: i,
+      coreAddress: coreAccount.address,
+      evmAddress: evmAccount.address,
+      corePrivateKey,
+      evmPrivateKey,
+      paths: {
+        core: corePath,
+        evm: evmPath
+      }
+    });
+  }
+  return accounts;
+}
+function deriveAccount(mnemonic, index, coreNetworkId = CORE_NETWORK_IDS.LOCAL, accountType = "standard") {
+  const accounts = deriveAccounts(mnemonic, {
+    count: 1,
+    startIndex: index,
+    coreNetworkId,
+    accountType
+  });
+  return accounts[0];
+}
+function deriveFaucetAccount(mnemonic, coreNetworkId = CORE_NETWORK_IDS.LOCAL) {
+  return deriveAccount(mnemonic, 0, coreNetworkId, "mining");
+}
+
+// src/wallet/embedded/custody.ts
+var import_accounts5 = require("viem/accounts");
+var EmbeddedWalletManager = class {
+  wallets = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = {
+      algorithm: options.algorithm || "aes-256-gcm",
+      iterations: options.iterations || 1e5,
+      autoCreate: options.autoCreate !== false
+      // Default true
+    };
+  }
+  /**
+   * Create a new embedded wallet for a user
+   *
+   * @param userId - User identifier
+   * @param password - Encryption password
+   * @returns Created wallet (without private key)
+   */
+  async createWallet(userId, password) {
+    if (this.wallets.has(userId)) {
+      throw new EmbeddedWalletError("Wallet already exists", { userId });
+    }
+    const privateKey = (0, import_accounts5.generatePrivateKey)();
+    const account = (0, import_accounts5.privateKeyToAccount)(privateKey);
+    const { encrypted, iv, salt } = await this.encryptPrivateKey(
+      privateKey,
+      password
+    );
+    const evmAddress = account.address;
+    const coreAddress = `cfx:${evmAddress.slice(2)}`;
+    const wallet = {
+      userId,
+      coreAddress,
+      evmAddress,
+      encryptedPrivateKey: encrypted,
+      encryption: {
+        algorithm: this.options.algorithm,
+        iv,
+        salt
+      },
+      createdAt: /* @__PURE__ */ new Date(),
+      lastAccessedAt: /* @__PURE__ */ new Date(),
+      isActive: true
+    };
+    this.wallets.set(userId, wallet);
+    const { encryptedPrivateKey: _, ...publicWallet } = wallet;
+    return publicWallet;
+  }
+  /**
+   * Get wallet info (without private key)
+   *
+   * @param userId - User identifier
+   * @returns Wallet info or undefined
+   */
+  getWallet(userId) {
+    const wallet = this.wallets.get(userId);
+    if (!wallet) return void 0;
+    wallet.lastAccessedAt = /* @__PURE__ */ new Date();
+    const { encryptedPrivateKey: _, ...publicWallet } = wallet;
+    return publicWallet;
+  }
+  /**
+   * Check if user has a wallet
+   *
+   * @param userId - User identifier
+   * @returns true if wallet exists
+   */
+  hasWallet(userId) {
+    return this.wallets.has(userId);
+  }
+  /**
+   * Sign transaction with user's embedded wallet
+   *
+   * @param userId - User identifier
+   * @param password - Decryption password
+   * @param request - Transaction request
+   * @returns Signed transaction
+   */
+  async signTransaction(userId, password, request) {
+    const wallet = this.wallets.get(userId);
+    if (!wallet) {
+      throw new EmbeddedWalletError("Wallet not found", { userId });
+    }
+    if (!wallet.isActive) {
+      throw new EmbeddedWalletError("Wallet is not active", { userId });
+    }
+    const privateKey = await this.decryptPrivateKey(
+      wallet.encryptedPrivateKey,
+      password,
+      wallet.encryption.iv,
+      wallet.encryption.salt
+    );
+    const account = (0, import_accounts5.privateKeyToAccount)(privateKey);
+    wallet.lastAccessedAt = /* @__PURE__ */ new Date();
+    const serialized = JSON.stringify({
+      from: account.address,
+      ...request,
+      value: request.value?.toString(),
+      gasLimit: request.gasLimit?.toString(),
+      gasPrice: request.gasPrice?.toString()
+    });
+    const signature = await account.signMessage({
+      message: serialized
+    });
+    return {
+      rawTransaction: signature,
+      hash: `0x${Array.from(
+        { length: 64 },
+        () => Math.floor(Math.random() * 16).toString(16)
+      ).join("")}`,
+      from: account.address,
+      chain: request.chain
+    };
+  }
+  /**
+   * Export wallet for user backup
+   *
+   * @param userId - User identifier
+   * @param password - Encryption password
+   * @returns Encrypted wallet export
+   */
+  async exportWallet(userId, password) {
+    const wallet = this.wallets.get(userId);
+    if (!wallet) {
+      throw new EmbeddedWalletError("Wallet not found", { userId });
+    }
+    const exportData = JSON.stringify({
+      coreAddress: wallet.coreAddress,
+      evmAddress: wallet.evmAddress,
+      encryptedPrivateKey: wallet.encryptedPrivateKey,
+      encryption: wallet.encryption
+    });
+    const { encrypted, iv, salt } = await this.encryptPrivateKey(
+      exportData,
+      password
+    );
+    return {
+      userId,
+      encryptedData: encrypted,
+      encryption: {
+        algorithm: this.options.algorithm,
+        iv,
+        salt
+      },
+      exportedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Deactivate wallet
+   *
+   * @param userId - User identifier
+   */
+  deactivateWallet(userId) {
+    const wallet = this.wallets.get(userId);
+    if (wallet) {
+      wallet.isActive = false;
+    }
+  }
+  /**
+   * Delete wallet permanently
+   *
+   * WARNING: This operation cannot be undone
+   *
+   * @param userId - User identifier
+   * @returns true if deleted, false if not found
+   */
+  deleteWallet(userId) {
+    return this.wallets.delete(userId);
+  }
+  /**
+   * List all wallets (without private keys)
+   *
+   * @returns Array of wallet info
+   */
+  listWallets() {
+    return Array.from(this.wallets.values()).map((wallet) => {
+      const { encryptedPrivateKey: _, ...publicWallet } = wallet;
+      return publicWallet;
+    });
+  }
+  /**
+   * Get wallet statistics
+   *
+   * @returns Wallet statistics
+   */
+  getStats() {
+    const all = Array.from(this.wallets.values());
+    const active = all.filter((w) => w.isActive);
+    return {
+      total: all.length,
+      active: active.length,
+      inactive: all.length - active.length
+    };
+  }
+  /**
+   * Encrypt private key
+   *
+   * NOTE: Simplified implementation for demonstration
+   * Production should use proper encryption (node:crypto, @noble/ciphers, etc.)
+   */
+  async encryptPrivateKey(data, password) {
+    const iv = Array.from(
+      { length: 16 },
+      () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
+    ).join("");
+    const salt = Array.from(
+      { length: 32 },
+      () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
+    ).join("");
+    const mockEncrypted = Buffer.from(
+      JSON.stringify({ data, password, iv, salt })
+    ).toString("base64");
+    return {
+      encrypted: mockEncrypted,
+      iv,
+      salt
+    };
+  }
+  /**
+   * Decrypt private key
+   *
+   * NOTE: Simplified implementation for demonstration
+   */
+  async decryptPrivateKey(encrypted, password, _iv, _salt) {
+    try {
+      const decoded = JSON.parse(
+        Buffer.from(encrypted, "base64").toString("utf-8")
+      );
+      if (decoded.password !== password) {
+        throw new Error("Invalid password");
+      }
+      return decoded.data;
+    } catch (error) {
+      throw new EmbeddedWalletError("Failed to decrypt private key", {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+};
+
+// src/wallet/session-keys/manager.ts
+var import_accounts6 = require("viem/accounts");
+var SessionKeyManager = class {
+  sessionKeys = /* @__PURE__ */ new Map();
+  /**
+   * Generate a new session key
+   *
+   * @param parentAddress - Parent wallet address
+   * @param options - Session key configuration
+   * @returns Created session key
+   */
+  generateSessionKey(parentAddress, options) {
+    const privateKey = `0x${Array.from(
+      { length: 64 },
+      () => Math.floor(Math.random() * 16).toString(16)
+    ).join("")}`;
+    const account = (0, import_accounts6.privateKeyToAccount)(privateKey);
+    const ttl = options.ttl || 3600;
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(now.getTime() + ttl * 1e3);
+    const sessionKey = {
+      id: `sk_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+      privateKey,
+      address: account.address,
+      parentAddress,
+      ttl,
+      expiresAt,
+      permissions: options.permissions || {},
+      createdAt: now,
+      isActive: true,
+      chain: options.chain
+    };
+    this.sessionKeys.set(sessionKey.id, sessionKey);
+    return sessionKey;
+  }
+  /**
+   * Get session key by ID
+   *
+   * @param sessionKeyId - Session key identifier
+   * @returns Session key or undefined
+   */
+  getSessionKey(sessionKeyId) {
+    const sessionKey = this.sessionKeys.get(sessionKeyId);
+    if (sessionKey && /* @__PURE__ */ new Date() > sessionKey.expiresAt) {
+      sessionKey.isActive = false;
+    }
+    return sessionKey;
+  }
+  /**
+   * Revoke a session key
+   *
+   * @param sessionKeyId - Session key identifier
+   */
+  revokeSessionKey(sessionKeyId) {
+    const sessionKey = this.sessionKeys.get(sessionKeyId);
+    if (sessionKey) {
+      sessionKey.isActive = false;
+    }
+  }
+  /**
+   * List all session keys for a parent address
+   *
+   * @param parentAddress - Parent wallet address
+   * @returns Array of session keys
+   */
+  listSessionKeys(parentAddress) {
+    return Array.from(this.sessionKeys.values()).filter(
+      (sk) => sk.parentAddress.toLowerCase() === parentAddress.toLowerCase()
+    );
+  }
+  /**
+   * List active session keys for a parent address
+   *
+   * @param parentAddress - Parent wallet address
+   * @returns Array of active session keys
+   */
+  listActiveSessionKeys(parentAddress) {
+    return this.listSessionKeys(parentAddress).filter(
+      (sk) => sk.isActive && /* @__PURE__ */ new Date() <= sk.expiresAt
+    );
+  }
+  /**
+   * Validate transaction against session key permissions
+   *
+   * @param sessionKey - Session key
+   * @param request - Transaction request
+   * @throws SessionKeyError if validation fails
+   */
+  validateTransaction(sessionKey, request) {
+    if (!sessionKey.isActive) {
+      throw new SessionKeyError("Session key is not active", {
+        sessionKeyId: sessionKey.id
+      });
+    }
+    if (/* @__PURE__ */ new Date() > sessionKey.expiresAt) {
+      throw new SessionKeyError("Session key has expired", {
+        sessionKeyId: sessionKey.id,
+        expiresAt: sessionKey.expiresAt
+      });
+    }
+    if (request.chain !== sessionKey.chain) {
+      throw new SessionKeyError("Chain mismatch", {
+        sessionKeyId: sessionKey.id,
+        allowedChain: sessionKey.chain,
+        requestedChain: request.chain
+      });
+    }
+    const { permissions } = sessionKey;
+    if (permissions.maxValue && request.value && request.value > permissions.maxValue) {
+      throw new SessionKeyError("Transaction value exceeds maximum", {
+        sessionKeyId: sessionKey.id,
+        maxValue: permissions.maxValue.toString(),
+        requestedValue: request.value.toString()
+      });
+    }
+    if (permissions.contracts && permissions.contracts.length > 0) {
+      const isWhitelisted = permissions.contracts.some(
+        (addr) => addr.toLowerCase() === request.to.toLowerCase()
+      );
+      if (!isWhitelisted) {
+        throw new SessionKeyError("Contract not whitelisted", {
+          sessionKeyId: sessionKey.id,
+          whitelistedContracts: permissions.contracts,
+          requestedContract: request.to
+        });
+      }
+    }
+    if (permissions.operations && permissions.operations.length > 0 && request.data) {
+      const selector = request.data.slice(0, 10);
+      const isAllowed = permissions.operations.some(
+        (op) => op.toLowerCase() === selector.toLowerCase()
+      );
+      if (!isAllowed) {
+        throw new SessionKeyError("Operation not allowed", {
+          sessionKeyId: sessionKey.id,
+          allowedOperations: permissions.operations,
+          requestedOperation: selector
+        });
+      }
+    }
+  }
+  /**
+   * Sign transaction with session key
+   *
+   * @param sessionKeyId - Session key identifier
+   * @param request - Transaction request
+   * @returns Signed transaction
+   * @throws SessionKeyError if session key is invalid or transaction violates permissions
+   */
+  async signWithSessionKey(sessionKeyId, request) {
+    const sessionKey = this.sessionKeys.get(sessionKeyId);
+    if (!sessionKey) {
+      throw new SessionKeyError("Session key not found", { sessionKeyId });
+    }
+    this.validateTransaction(sessionKey, request);
+    const account = (0, import_accounts6.privateKeyToAccount)(sessionKey.privateKey);
+    const serialized = JSON.stringify({
+      from: account.address,
+      to: request.to,
+      value: request.value?.toString(),
+      data: request.data,
+      gasLimit: request.gasLimit?.toString(),
+      gasPrice: request.gasPrice?.toString(),
+      nonce: request.nonce,
+      chain: request.chain
+    });
+    const signature = await account.signMessage({
+      message: serialized
+    });
+    return {
+      rawTransaction: signature,
+      hash: `0x${Array.from(
+        { length: 64 },
+        () => Math.floor(Math.random() * 16).toString(16)
+      ).join("")}`,
+      from: account.address,
+      chain: request.chain
+    };
+  }
+  /**
+   * Clean up expired session keys
+   *
+   * @returns Number of removed session keys
+   */
+  cleanupExpired() {
+    const now = /* @__PURE__ */ new Date();
+    let removed = 0;
+    for (const [id, sessionKey] of this.sessionKeys.entries()) {
+      if (now > sessionKey.expiresAt) {
+        this.sessionKeys.delete(id);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  /**
+   * Get session key statistics
+   *
+   * @returns Statistics about session keys
+   */
+  getStats() {
+    const all = Array.from(this.sessionKeys.values());
+    const active = all.filter(
+      (sk) => sk.isActive && /* @__PURE__ */ new Date() <= sk.expiresAt
+    );
+    const expired = all.filter((sk) => /* @__PURE__ */ new Date() > sk.expiresAt);
+    return {
+      total: all.length,
+      active: active.length,
+      expired: expired.length,
+      inactive: all.length - active.length - expired.length
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatcherError,
+  CORE_LOCAL,
+  CORE_MAINNET,
+  CORE_TESTNET,
+  ClientManager,
+  ContractDeployer,
+  ContractError,
+  ContractReader,
+  ContractWriter,
+  CoreClient,
+  CoreTestClient,
+  CoreWalletClient,
+  DeploymentError,
+  ERC1155_ABI,
+  ERC20_ABI,
+  ERC721_ABI,
+  EVM_LOCAL,
+  EVM_MAINNET,
+  EVM_TESTNET,
+  EmbeddedWalletError,
+  EmbeddedWalletManager,
+  EspaceClient,
+  EspaceTestClient,
+  EspaceWalletClient,
+  InteractionError,
+  SessionKeyError,
+  SessionKeyManager,
+  TransactionBatcher,
+  WalletError,
+  defaultNetworkSelector,
+  deriveAccount,
+  deriveAccounts,
+  deriveFaucetAccount,
+  formatCFX,
+  formatUnits,
+  generateMnemonic,
+  getChainConfig,
+  getCoreChains,
+  getEvmChains,
+  getMainnetChains,
+  isCoreAddress,
+  isEspaceAddress,
+  logger,
+  parseCFX,
+  parseUnits,
+  validateMnemonic
+});
+//# sourceMappingURL=index.cjs.map