@enclave-hq/wallet-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,2130 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var EventEmitter = require('eventemitter3');
+var viem = require('viem');
+var accounts = require('viem/accounts');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+// src/core/events.ts
+var TypedEventEmitter = class {
+  constructor() {
+    this.emitter = new EventEmitter__default.default();
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+    return this;
+  }
+  once(event, handler) {
+    this.emitter.once(event, handler);
+    return this;
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+    return this;
+  }
+  emit(event, ...args) {
+    return this.emitter.emit(event, ...args);
+  }
+  removeAllListeners(event) {
+    if (event !== void 0) {
+      this.emitter.removeAllListeners(event);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+    return this;
+  }
+};
+
+// src/core/types.ts
+var ChainType = /* @__PURE__ */ ((ChainType4) => {
+  ChainType4["EVM"] = "evm";
+  ChainType4["TRON"] = "tron";
+  ChainType4["SOLANA"] = "solana";
+  ChainType4["COSMOS"] = "cosmos";
+  return ChainType4;
+})(ChainType || {});
+var WalletType = /* @__PURE__ */ ((WalletType3) => {
+  WalletType3["METAMASK"] = "metamask";
+  WalletType3["WALLETCONNECT"] = "walletconnect";
+  WalletType3["COINBASE_WALLET"] = "coinbase-wallet";
+  WalletType3["TRONLINK"] = "tronlink";
+  WalletType3["WALLETCONNECT_TRON"] = "walletconnect-tron";
+  WalletType3["PRIVATE_KEY"] = "private-key";
+  return WalletType3;
+})(WalletType || {});
+var WalletState = /* @__PURE__ */ ((WalletState2) => {
+  WalletState2["DISCONNECTED"] = "disconnected";
+  WalletState2["CONNECTING"] = "connecting";
+  WalletState2["CONNECTED"] = "connected";
+  WalletState2["ERROR"] = "error";
+  return WalletState2;
+})(WalletState || {});
+
+// src/core/errors.ts
+var WalletSDKError = class _WalletSDKError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "WalletSDKError";
+    Object.setPrototypeOf(this, _WalletSDKError.prototype);
+  }
+};
+var WalletNotConnectedError = class extends WalletSDKError {
+  constructor(walletType) {
+    super(
+      walletType ? `Wallet ${walletType} is not connected` : "No wallet is connected",
+      "WALLET_NOT_CONNECTED",
+      { walletType }
+    );
+    this.name = "WalletNotConnectedError";
+  }
+};
+var WalletNotAvailableError = class extends WalletSDKError {
+  constructor(walletType, downloadUrl) {
+    super(
+      `Wallet ${walletType} is not available. Please install it first.`,
+      "WALLET_NOT_AVAILABLE",
+      { walletType, downloadUrl }
+    );
+    this.name = "WalletNotAvailableError";
+  }
+};
+var ConnectionRejectedError = class extends WalletSDKError {
+  constructor(walletType) {
+    super(
+      `Connection to ${walletType} was rejected by user`,
+      "CONNECTION_REJECTED",
+      { walletType }
+    );
+    this.name = "ConnectionRejectedError";
+  }
+};
+var ChainNotSupportedError = class extends WalletSDKError {
+  constructor(chainId, walletType) {
+    super(
+      `Chain ${chainId} is not supported by ${walletType}`,
+      "CHAIN_NOT_SUPPORTED",
+      { chainId, walletType }
+    );
+    this.name = "ChainNotSupportedError";
+  }
+};
+var SignatureRejectedError = class extends WalletSDKError {
+  constructor(message) {
+    super(
+      message || "Signature was rejected by user",
+      "SIGNATURE_REJECTED"
+    );
+    this.name = "SignatureRejectedError";
+  }
+};
+var TransactionFailedError = class extends WalletSDKError {
+  constructor(txHash, reason) {
+    super(
+      `Transaction ${txHash} failed${reason ? `: ${reason}` : ""}`,
+      "TRANSACTION_FAILED",
+      { txHash, reason }
+    );
+    this.name = "TransactionFailedError";
+  }
+};
+var MethodNotSupportedError = class extends WalletSDKError {
+  constructor(method, walletType) {
+    super(
+      `Method ${method} is not supported by ${walletType}`,
+      "METHOD_NOT_SUPPORTED",
+      { method, walletType }
+    );
+    this.name = "MethodNotSupportedError";
+  }
+};
+var ConfigurationError = class extends WalletSDKError {
+  constructor(message, details) {
+    super(message, "CONFIGURATION_ERROR", details);
+    this.name = "ConfigurationError";
+  }
+};
+var NetworkError = class extends WalletSDKError {
+  constructor(message, details) {
+    super(message, "NETWORK_ERROR", details);
+    this.name = "NetworkError";
+  }
+};
+
+// src/adapters/base/wallet-adapter.ts
+var WalletAdapter = class extends EventEmitter__default.default {
+  constructor() {
+    super(...arguments);
+    // 状态
+    this.state = "disconnected" /* DISCONNECTED */;
+    this.currentAccount = null;
+  }
+  signTransaction(_transaction) {
+    throw new MethodNotSupportedError("signTransaction", this.type);
+  }
+  signTypedData(_typedData) {
+    throw new MethodNotSupportedError("signTypedData", this.type);
+  }
+  // 链切换（默认不支持）
+  switchChain(_chainId) {
+    throw new MethodNotSupportedError("switchChain", this.type);
+  }
+  addChain(_chainConfig) {
+    throw new MethodNotSupportedError("addChain", this.type);
+  }
+  // 合约调用（默认不支持）
+  async readContract(_params) {
+    throw new MethodNotSupportedError("readContract", this.type);
+  }
+  async writeContract(_params) {
+    throw new MethodNotSupportedError("writeContract", this.type);
+  }
+  async estimateGas(_params) {
+    throw new MethodNotSupportedError("estimateGas", this.type);
+  }
+  async waitForTransaction(_txHash, _confirmations) {
+    throw new MethodNotSupportedError("waitForTransaction", this.type);
+  }
+  getSigner() {
+    throw new MethodNotSupportedError("getSigner", this.type);
+  }
+  // 工具方法
+  ensureConnected() {
+    if (this.state !== "connected" /* CONNECTED */ || !this.currentAccount) {
+      throw new WalletNotConnectedError(this.type);
+    }
+  }
+  setState(state) {
+    this.state = state;
+  }
+  setAccount(account) {
+    this.currentAccount = account;
+  }
+  emitAccountChanged(account) {
+    this.emit("accountChanged", account);
+  }
+  emitChainChanged(chainId) {
+    this.emit("chainChanged", chainId);
+  }
+  emitDisconnected() {
+    this.emit("disconnected");
+  }
+  emitError(error) {
+    this.emit("error", error);
+  }
+  // EventEmitter 方法（从 EventEmitter3 继承）
+  // removeAllListeners 已经由 EventEmitter 提供
+};
+
+// src/adapters/base/browser-wallet-adapter.ts
+var BrowserWalletAdapter = class extends WalletAdapter {
+  /**
+   * 检查钱包是否可用
+   */
+  async isAvailable() {
+    if (typeof window === "undefined") {
+      return false;
+    }
+    return this.getBrowserProvider() !== void 0;
+  }
+  /**
+   * 确保钱包已安装
+   */
+  async ensureAvailable() {
+    const isAvailable = await this.isAvailable();
+    if (!isAvailable) {
+      throw new WalletNotAvailableError(
+        this.type,
+        this.getDownloadUrl()
+      );
+    }
+  }
+  /**
+   * 断开连接时清理
+   */
+  async disconnect() {
+    this.removeEventListeners();
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+    this.emitDisconnected();
+  }
+};
+
+// src/utils/address/universal-address.ts
+function createUniversalAddress(chainId, address) {
+  return `${chainId}:${address}`;
+}
+function parseUniversalAddress(universalAddress) {
+  const parts = universalAddress.split(":");
+  if (parts.length !== 2) {
+    return null;
+  }
+  const chainId = parseInt(parts[0], 10);
+  if (isNaN(chainId)) {
+    return null;
+  }
+  return {
+    chainId,
+    address: parts[1]
+  };
+}
+function isValidUniversalAddress(universalAddress) {
+  return parseUniversalAddress(universalAddress) !== null;
+}
+function getChainIdFromUniversalAddress(universalAddress) {
+  const parsed = parseUniversalAddress(universalAddress);
+  return parsed ? parsed.chainId : null;
+}
+function getAddressFromUniversalAddress(universalAddress) {
+  const parsed = parseUniversalAddress(universalAddress);
+  return parsed ? parsed.address : null;
+}
+function compareUniversalAddresses(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function isValidEVMAddress(address) {
+  return viem.isAddress(address);
+}
+function formatEVMAddress(address) {
+  if (!viem.isAddress(address)) {
+    throw new Error(`Invalid EVM address: ${address}`);
+  }
+  return viem.getAddress(address);
+}
+function compareEVMAddresses(a, b) {
+  try {
+    return viem.getAddress(a) === viem.getAddress(b);
+  } catch {
+    return false;
+  }
+}
+function shortenAddress(address, chars = 4) {
+  if (!viem.isAddress(address)) {
+    return address;
+  }
+  const formatted = viem.getAddress(address);
+  return `${formatted.substring(0, chars + 2)}...${formatted.substring(42 - chars)}`;
+}
+
+// src/utils/chain-info.ts
+var CHAIN_INFO = {
+  // EVM Mainnet
+  1: {
+    id: 1,
+    name: "Ethereum Mainnet",
+    chainType: "evm" /* EVM */,
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    rpcUrls: ["https://eth.llamarpc.com"],
+    blockExplorerUrls: ["https://etherscan.io"]
+  },
+  // EVM Testnets
+  11155111: {
+    id: 11155111,
+    name: "Sepolia Testnet",
+    chainType: "evm" /* EVM */,
+    nativeCurrency: {
+      name: "Sepolia Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    rpcUrls: ["https://rpc.sepolia.org"],
+    blockExplorerUrls: ["https://sepolia.etherscan.io"]
+  },
+  // Binance Smart Chain
+  56: {
+    id: 56,
+    name: "BNB Smart Chain",
+    chainType: "evm" /* EVM */,
+    nativeCurrency: {
+      name: "BNB",
+      symbol: "BNB",
+      decimals: 18
+    },
+    rpcUrls: ["https://bsc-dataseed.binance.org"],
+    blockExplorerUrls: ["https://bscscan.com"]
+  },
+  97: {
+    id: 97,
+    name: "BNB Smart Chain Testnet",
+    chainType: "evm" /* EVM */,
+    nativeCurrency: {
+      name: "BNB",
+      symbol: "BNB",
+      decimals: 18
+    },
+    rpcUrls: ["https://data-seed-prebsc-1-s1.binance.org:8545"],
+    blockExplorerUrls: ["https://testnet.bscscan.com"]
+  },
+  // Polygon
+  137: {
+    id: 137,
+    name: "Polygon Mainnet",
+    chainType: "evm" /* EVM */,
+    nativeCurrency: {
+      name: "MATIC",
+      symbol: "MATIC",
+      decimals: 18
+    },
+    rpcUrls: ["https://polygon-rpc.com"],
+    blockExplorerUrls: ["https://polygonscan.com"]
+  },
+  80002: {
+    id: 80002,
+    name: "Polygon Amoy Testnet",
+    chainType: "evm" /* EVM */,
+    nativeCurrency: {
+      name: "MATIC",
+      symbol: "MATIC",
+      decimals: 18
+    },
+    rpcUrls: ["https://rpc-amoy.polygon.technology"],
+    blockExplorerUrls: ["https://www.oklink.com/amoy"]
+  },
+  // Tron
+  195: {
+    id: 195,
+    name: "Tron Mainnet",
+    chainType: "tron" /* TRON */,
+    nativeCurrency: {
+      name: "TRX",
+      symbol: "TRX",
+      decimals: 6
+    },
+    rpcUrls: ["https://api.trongrid.io"],
+    blockExplorerUrls: ["https://tronscan.org"]
+  },
+  // Arbitrum
+  42161: {
+    id: 42161,
+    name: "Arbitrum One",
+    chainType: "evm" /* EVM */,
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    rpcUrls: ["https://arb1.arbitrum.io/rpc"],
+    blockExplorerUrls: ["https://arbiscan.io"]
+  },
+  // Optimism
+  10: {
+    id: 10,
+    name: "Optimism",
+    chainType: "evm" /* EVM */,
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    rpcUrls: ["https://mainnet.optimism.io"],
+    blockExplorerUrls: ["https://optimistic.etherscan.io"]
+  },
+  // Avalanche
+  43114: {
+    id: 43114,
+    name: "Avalanche C-Chain",
+    chainType: "evm" /* EVM */,
+    nativeCurrency: {
+      name: "AVAX",
+      symbol: "AVAX",
+      decimals: 18
+    },
+    rpcUrls: ["https://api.avax.network/ext/bc/C/rpc"],
+    blockExplorerUrls: ["https://snowtrace.io"]
+  }
+};
+function getChainInfo(chainId) {
+  return CHAIN_INFO[chainId];
+}
+function getChainType(chainId) {
+  return CHAIN_INFO[chainId]?.chainType;
+}
+function isEVMChain(chainId) {
+  return getChainType(chainId) === "evm" /* EVM */;
+}
+function isTronChain(chainId) {
+  return getChainType(chainId) === "tron" /* TRON */;
+}
+
+// src/adapters/evm/metamask.ts
+var MetaMaskAdapter = class extends BrowserWalletAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "metamask" /* METAMASK */;
+    this.chainType = "evm" /* EVM */;
+    this.name = "MetaMask";
+    this.icon = "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg";
+    this.walletClient = null;
+    this.publicClient = null;
+    /**
+     * 处理账户变化
+     */
+    this.handleAccountsChanged = (accounts) => {
+      if (accounts.length === 0) {
+        this.setState("disconnected" /* DISCONNECTED */);
+        this.setAccount(null);
+        this.emitAccountChanged(null);
+      } else {
+        const address = formatEVMAddress(accounts[0]);
+        const account = {
+          universalAddress: createUniversalAddress(this.currentAccount.chainId, address),
+          nativeAddress: address,
+          chainId: this.currentAccount.chainId,
+          chainType: "evm" /* EVM */,
+          isActive: true
+        };
+        this.setAccount(account);
+        this.emitAccountChanged(account);
+      }
+    };
+    /**
+     * 处理链变化
+     */
+    this.handleChainChanged = (chainIdHex) => {
+      const chainId = parseInt(chainIdHex, 16);
+      if (this.currentAccount) {
+        const account = {
+          ...this.currentAccount,
+          chainId,
+          universalAddress: createUniversalAddress(chainId, this.currentAccount.nativeAddress)
+        };
+        this.setAccount(account);
+        this.emitChainChanged(chainId);
+      }
+    };
+    /**
+     * 处理断开连接
+     */
+    this.handleDisconnect = () => {
+      this.setState("disconnected" /* DISCONNECTED */);
+      this.setAccount(null);
+      this.emitDisconnected();
+    };
+  }
+  /**
+   * 连接钱包
+   */
+  async connect(chainId) {
+    await this.ensureAvailable();
+    try {
+      this.setState("connecting" /* CONNECTING */);
+      const provider = this.getBrowserProvider();
+      const accounts = await provider.request({
+        method: "eth_requestAccounts"
+      });
+      if (!accounts || accounts.length === 0) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      const currentChainId = await provider.request({
+        method: "eth_chainId"
+      });
+      const parsedChainId = parseInt(currentChainId, 16);
+      if (chainId && chainId !== parsedChainId) {
+        await this.switchChain(chainId);
+      }
+      this.walletClient = viem.createWalletClient({
+        account: accounts[0],
+        transport: viem.custom(provider)
+      });
+      const finalChainId = chainId || parsedChainId;
+      this.publicClient = viem.createPublicClient({
+        chain: this.getViemChain(finalChainId),
+        transport: viem.http()
+      });
+      const address = formatEVMAddress(accounts[0]);
+      const account = {
+        universalAddress: createUniversalAddress(finalChainId, address),
+        nativeAddress: address,
+        chainId: finalChainId,
+        chainType: "evm" /* EVM */,
+        isActive: true
+      };
+      this.setState("connected" /* CONNECTED */);
+      this.setAccount(account);
+      this.setupEventListeners();
+      return account;
+    } catch (error) {
+      this.setState("error" /* ERROR */);
+      this.setAccount(null);
+      if (error.code === 4001) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      throw error;
+    }
+  }
+  /**
+   * 签名消息
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    try {
+      const provider = this.getBrowserProvider();
+      const signature = await provider.request({
+        method: "personal_sign",
+        params: [message, this.currentAccount.nativeAddress]
+      });
+      return signature;
+    } catch (error) {
+      if (error.code === 4001) {
+        throw new SignatureRejectedError();
+      }
+      throw error;
+    }
+  }
+  /**
+   * 签名 TypedData (EIP-712)
+   */
+  async signTypedData(typedData) {
+    this.ensureConnected();
+    try {
+      const provider = this.getBrowserProvider();
+      const signature = await provider.request({
+        method: "eth_signTypedData_v4",
+        params: [this.currentAccount.nativeAddress, JSON.stringify(typedData)]
+      });
+      return signature;
+    } catch (error) {
+      if (error.code === 4001) {
+        throw new SignatureRejectedError();
+      }
+      throw error;
+    }
+  }
+  /**
+   * 切换链
+   */
+  async switchChain(chainId) {
+    this.ensureConnected();
+    const provider = this.getBrowserProvider();
+    try {
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: `0x${chainId.toString(16)}` }]
+      });
+      if (this.currentAccount) {
+        const updatedAccount = {
+          ...this.currentAccount,
+          chainId,
+          universalAddress: createUniversalAddress(chainId, this.currentAccount.nativeAddress)
+        };
+        this.setAccount(updatedAccount);
+        this.emitChainChanged(chainId);
+      }
+    } catch (error) {
+      if (error.code === 4902) {
+        const chainInfo = getChainInfo(chainId);
+        if (chainInfo) {
+          await this.addChain({
+            chainId: chainInfo.id,
+            chainName: chainInfo.name,
+            nativeCurrency: chainInfo.nativeCurrency,
+            rpcUrls: chainInfo.rpcUrls,
+            blockExplorerUrls: chainInfo.blockExplorerUrls
+          });
+          await this.switchChain(chainId);
+        } else {
+          throw new Error(`Chain ${chainId} not supported`);
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * 添加链
+   */
+  async addChain(chainConfig) {
+    const provider = this.getBrowserProvider();
+    await provider.request({
+      method: "wallet_addEthereumChain",
+      params: [{
+        chainId: `0x${chainConfig.chainId.toString(16)}`,
+        chainName: chainConfig.chainName,
+        nativeCurrency: chainConfig.nativeCurrency,
+        rpcUrls: chainConfig.rpcUrls,
+        blockExplorerUrls: chainConfig.blockExplorerUrls
+      }]
+    });
+  }
+  /**
+   * 读取合约
+   */
+  async readContract(params) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const result = await this.publicClient.readContract({
+      address: params.address,
+      abi: params.abi,
+      functionName: params.functionName,
+      ...params.args ? { args: params.args } : {}
+    });
+    return result;
+  }
+  /**
+   * 写入合约
+   */
+  async writeContract(params) {
+    this.ensureConnected();
+    if (!this.walletClient) {
+      throw new Error("Wallet client not initialized");
+    }
+    try {
+      const txHash = await this.walletClient.writeContract({
+        address: params.address,
+        abi: params.abi,
+        functionName: params.functionName,
+        ...params.args ? { args: params.args } : {},
+        value: params.value ? BigInt(params.value) : void 0,
+        gas: params.gas ? BigInt(params.gas) : void 0,
+        gasPrice: params.gasPrice ? BigInt(params.gasPrice) : void 0
+      });
+      return txHash;
+    } catch (error) {
+      if (error.code === 4001) {
+        throw new SignatureRejectedError("Transaction was rejected by user");
+      }
+      throw error;
+    }
+  }
+  /**
+   * 估算 gas
+   */
+  async estimateGas(params) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const gas = await this.publicClient.estimateContractGas({
+      address: params.address,
+      abi: params.abi,
+      functionName: params.functionName,
+      ...params.args ? { args: params.args } : {},
+      value: params.value ? BigInt(params.value) : void 0,
+      account: this.currentAccount.nativeAddress
+    });
+    return gas;
+  }
+  /**
+   * 等待交易确认
+   */
+  async waitForTransaction(txHash, confirmations = 1) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const receipt = await this.publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      confirmations
+    });
+    if (receipt.status === "reverted") {
+      throw new TransactionFailedError(txHash, "Transaction reverted");
+    }
+    return {
+      transactionHash: receipt.transactionHash,
+      blockNumber: Number(receipt.blockNumber),
+      blockHash: receipt.blockHash,
+      from: receipt.from,
+      to: receipt.to || void 0,
+      status: receipt.status === "success" ? "success" : "failed",
+      gasUsed: receipt.gasUsed.toString(),
+      effectiveGasPrice: receipt.effectiveGasPrice?.toString(),
+      logs: receipt.logs
+    };
+  }
+  /**
+   * 获取 Provider
+   */
+  getProvider() {
+    return this.getBrowserProvider();
+  }
+  /**
+   * 获取 Signer
+   */
+  getSigner() {
+    return this.walletClient;
+  }
+  /**
+   * 获取浏览器中的 MetaMask provider
+   */
+  getBrowserProvider() {
+    if (typeof window === "undefined") {
+      return void 0;
+    }
+    const w = window;
+    return w.ethereum && w.ethereum.isMetaMask ? w.ethereum : void 0;
+  }
+  /**
+   * 获取下载链接
+   */
+  getDownloadUrl() {
+    return "https://metamask.io/download/";
+  }
+  /**
+   * 设置事件监听
+   */
+  setupEventListeners() {
+    const provider = this.getBrowserProvider();
+    if (!provider) return;
+    provider.on("accountsChanged", this.handleAccountsChanged);
+    provider.on("chainChanged", this.handleChainChanged);
+    provider.on("disconnect", this.handleDisconnect);
+  }
+  /**
+   * 移除事件监听
+   */
+  removeEventListeners() {
+    const provider = this.getBrowserProvider();
+    if (!provider) return;
+    provider.removeListener("accountsChanged", this.handleAccountsChanged);
+    provider.removeListener("chainChanged", this.handleChainChanged);
+    provider.removeListener("disconnect", this.handleDisconnect);
+  }
+  /**
+   * 获取 viem chain 配置（简化版）
+   */
+  getViemChain(chainId) {
+    const chainInfo = getChainInfo(chainId);
+    if (chainInfo) {
+      return {
+        id: chainId,
+        name: chainInfo.name,
+        network: chainInfo.name.toLowerCase().replace(/\s+/g, "-"),
+        nativeCurrency: chainInfo.nativeCurrency,
+        rpcUrls: {
+          default: { http: chainInfo.rpcUrls },
+          public: { http: chainInfo.rpcUrls }
+        },
+        blockExplorers: chainInfo.blockExplorerUrls ? {
+          default: { name: "Explorer", url: chainInfo.blockExplorerUrls[0] }
+        } : void 0
+      };
+    }
+    return {
+      id: chainId,
+      name: `Chain ${chainId}`,
+      network: `chain-${chainId}`,
+      nativeCurrency: {
+        name: "ETH",
+        symbol: "ETH",
+        decimals: 18
+      },
+      rpcUrls: {
+        default: { http: [] },
+        public: { http: [] }
+      }
+    };
+  }
+};
+
+// src/adapters/tron/tronlink.ts
+var _TronLinkAdapter = class _TronLinkAdapter extends BrowserWalletAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "tronlink" /* TRONLINK */;
+    this.chainType = "tron" /* TRON */;
+    this.name = "TronLink";
+    this.icon = "https://www.tronlink.org/static/logoIcon.svg";
+    /**
+     * 处理账户变化
+     */
+    this.handleAccountsChanged = (data) => {
+      if (!data || !data.address) {
+        this.setState("disconnected" /* DISCONNECTED */);
+        this.setAccount(null);
+        this.emitAccountChanged(null);
+      } else {
+        const address = data.address.base58 || data.address;
+        const account = {
+          universalAddress: createUniversalAddress(this.currentAccount.chainId, address),
+          nativeAddress: address,
+          chainId: this.currentAccount.chainId,
+          chainType: "tron" /* TRON */,
+          isActive: true
+        };
+        this.setAccount(account);
+        this.emitAccountChanged(account);
+      }
+    };
+    /**
+     * 处理断开连接
+     */
+    this.handleDisconnect = () => {
+      this.setState("disconnected" /* DISCONNECTED */);
+      this.setAccount(null);
+      this.emitDisconnected();
+    };
+  }
+  /**
+   * 连接钱包
+   */
+  async connect(chainId) {
+    await this.ensureAvailable();
+    try {
+      this.setState("connecting" /* CONNECTING */);
+      const tronWeb = this.getTronWeb();
+      const result = await tronWeb.request({
+        method: "tron_requestAccounts"
+      });
+      if (!result || !result.code || result.code !== 200) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      const address = tronWeb.defaultAddress?.base58;
+      if (!address) {
+        throw new Error("Failed to get Tron address");
+      }
+      const tronChainId = chainId || _TronLinkAdapter.TRON_MAINNET_CHAIN_ID;
+      const account = {
+        universalAddress: createUniversalAddress(tronChainId, address),
+        nativeAddress: address,
+        chainId: tronChainId,
+        chainType: "tron" /* TRON */,
+        isActive: true
+      };
+      this.setState("connected" /* CONNECTED */);
+      this.setAccount(account);
+      this.setupEventListeners();
+      return account;
+    } catch (error) {
+      this.setState("error" /* ERROR */);
+      this.setAccount(null);
+      if (error.code === 4001 || error.message?.includes("User rejected")) {
+        throw new ConnectionRejectedError(this.type);
+      }
+      throw error;
+    }
+  }
+  /**
+   * 签名消息
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    try {
+      const tronWeb = this.getTronWeb();
+      const signature = await tronWeb.trx.sign(message);
+      return signature;
+    } catch (error) {
+      if (error.message?.includes("User rejected") || error.message?.includes("Confirmation declined")) {
+        throw new SignatureRejectedError();
+      }
+      throw error;
+    }
+  }
+  /**
+   * 获取 Provider
+   */
+  getProvider() {
+    return this.getTronWeb();
+  }
+  /**
+   * 获取浏览器中的 TronWeb
+   */
+  getBrowserProvider() {
+    if (typeof window === "undefined") {
+      return void 0;
+    }
+    const w = window;
+    return w.tronWeb || w.tronLink?.tronWeb;
+  }
+  /**
+   * 获取 TronWeb 实例
+   */
+  getTronWeb() {
+    const provider = this.getBrowserProvider();
+    if (!provider) {
+      throw new Error("TronWeb not found");
+    }
+    return provider;
+  }
+  /**
+   * 获取下载链接
+   */
+  getDownloadUrl() {
+    return "https://www.tronlink.org/";
+  }
+  /**
+   * 设置事件监听
+   */
+  setupEventListeners() {
+    if (typeof window === "undefined") return;
+    const w = window;
+    if (w.tronLink) {
+      w.tronLink.on("accountsChanged", this.handleAccountsChanged);
+      w.tronLink.on("disconnect", this.handleDisconnect);
+    }
+  }
+  /**
+   * 移除事件监听
+   */
+  removeEventListeners() {
+    if (typeof window === "undefined") return;
+    const w = window;
+    if (w.tronLink) {
+      w.tronLink.off("accountsChanged", this.handleAccountsChanged);
+      w.tronLink.off("disconnect", this.handleDisconnect);
+    }
+  }
+};
+// Tron 主网链 ID
+_TronLinkAdapter.TRON_MAINNET_CHAIN_ID = 195;
+var TronLinkAdapter = _TronLinkAdapter;
+var EVMPrivateKeyAdapter = class extends WalletAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "private-key" /* PRIVATE_KEY */;
+    this.chainType = "evm" /* EVM */;
+    this.name = "Private Key (EVM)";
+    this.privateKey = null;
+    this.walletClient = null;
+    this.publicClient = null;
+  }
+  /**
+   * 连接（导入私钥）
+   */
+  async connect(chainId = 1) {
+    if (!this.privateKey) {
+      throw new Error("Private key not set. Call setPrivateKey() first.");
+    }
+    try {
+      this.setState("connecting" /* CONNECTING */);
+      const account = accounts.privateKeyToAccount(this.privateKey);
+      this.walletClient = viem.createWalletClient({
+        account,
+        chain: this.getViemChain(chainId),
+        transport: viem.http()
+      });
+      this.publicClient = viem.createPublicClient({
+        chain: this.getViemChain(chainId),
+        transport: viem.http()
+      });
+      const address = formatEVMAddress(account.address);
+      const accountInfo = {
+        universalAddress: createUniversalAddress(chainId, address),
+        nativeAddress: address,
+        chainId,
+        chainType: "evm" /* EVM */,
+        isActive: true
+      };
+      this.setState("connected" /* CONNECTED */);
+      this.setAccount(accountInfo);
+      return accountInfo;
+    } catch (error) {
+      this.setState("error" /* ERROR */);
+      this.setAccount(null);
+      throw error;
+    }
+  }
+  /**
+   * 断开连接
+   */
+  async disconnect() {
+    this.privateKey = null;
+    this.walletClient = null;
+    this.publicClient = null;
+    this.setState("disconnected" /* DISCONNECTED */);
+    this.setAccount(null);
+    this.emitDisconnected();
+  }
+  /**
+   * 检查是否可用（私钥钱包总是可用）
+   */
+  async isAvailable() {
+    return true;
+  }
+  /**
+   * 设置私钥
+   */
+  setPrivateKey(privateKey) {
+    this.privateKey = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
+  }
+  /**
+   * 签名消息
+   */
+  async signMessage(message) {
+    this.ensureConnected();
+    if (!this.walletClient || !this.walletClient.account) {
+      throw new Error("Wallet client not initialized");
+    }
+    const signature = await this.walletClient.signMessage({
+      message,
+      account: this.walletClient.account
+    });
+    return signature;
+  }
+  /**
+   * 签名 TypedData
+   */
+  async signTypedData(typedData) {
+    this.ensureConnected();
+    if (!this.walletClient || !this.walletClient.account) {
+      throw new Error("Wallet client not initialized");
+    }
+    const signature = await this.walletClient.signTypedData({
+      ...typedData,
+      account: this.walletClient.account
+    });
+    return signature;
+  }
+  /**
+   * 切换链
+   */
+  async switchChain(chainId) {
+    this.ensureConnected();
+    const account = this.walletClient.account;
+    this.walletClient = viem.createWalletClient({
+      account,
+      chain: this.getViemChain(chainId),
+      transport: viem.http()
+    });
+    this.publicClient = viem.createPublicClient({
+      chain: this.getViemChain(chainId),
+      transport: viem.http()
+    });
+    const updatedAccount = {
+      ...this.currentAccount,
+      chainId,
+      universalAddress: createUniversalAddress(chainId, this.currentAccount.nativeAddress)
+    };
+    this.setAccount(updatedAccount);
+    this.emitChainChanged(chainId);
+  }
+  /**
+   * 读取合约
+   */
+  async readContract(params) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const result = await this.publicClient.readContract({
+      address: params.address,
+      abi: params.abi,
+      functionName: params.functionName,
+      ...params.args ? { args: params.args } : {}
+    });
+    return result;
+  }
+  /**
+   * 写入合约
+   */
+  async writeContract(params) {
+    this.ensureConnected();
+    if (!this.walletClient) {
+      throw new Error("Wallet client not initialized");
+    }
+    const txHash = await this.walletClient.writeContract({
+      address: params.address,
+      abi: params.abi,
+      functionName: params.functionName,
+      ...params.args ? { args: params.args } : {},
+      value: params.value ? BigInt(params.value) : void 0,
+      gas: params.gas ? BigInt(params.gas) : void 0,
+      gasPrice: params.gasPrice ? BigInt(params.gasPrice) : void 0
+    });
+    return txHash;
+  }
+  /**
+   * 估算 gas
+   */
+  async estimateGas(params) {
+    if (!this.publicClient || !this.currentAccount) {
+      throw new Error("Client not initialized");
+    }
+    const gas = await this.publicClient.estimateContractGas({
+      address: params.address,
+      abi: params.abi,
+      functionName: params.functionName,
+      ...params.args ? { args: params.args } : {},
+      value: params.value ? BigInt(params.value) : void 0,
+      account: this.currentAccount.nativeAddress
+    });
+    return gas;
+  }
+  /**
+   * 等待交易确认
+   */
+  async waitForTransaction(txHash, confirmations = 1) {
+    if (!this.publicClient) {
+      throw new Error("Public client not initialized");
+    }
+    const receipt = await this.publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      confirmations
+    });
+    if (receipt.status === "reverted") {
+      throw new TransactionFailedError(txHash, "Transaction reverted");
+    }
+    return {
+      transactionHash: receipt.transactionHash,
+      blockNumber: Number(receipt.blockNumber),
+      blockHash: receipt.blockHash,
+      from: receipt.from,
+      to: receipt.to || void 0,
+      status: receipt.status === "success" ? "success" : "failed",
+      gasUsed: receipt.gasUsed.toString(),
+      effectiveGasPrice: receipt.effectiveGasPrice?.toString(),
+      logs: receipt.logs
+    };
+  }
+  /**
+   * 获取 Provider
+   */
+  getProvider() {
+    return this.publicClient;
+  }
+  /**
+   * 获取 Signer
+   */
+  getSigner() {
+    return this.walletClient;
+  }
+  /**
+   * 获取 viem chain 配置
+   */
+  getViemChain(chainId) {
+    const chainInfo = getChainInfo(chainId);
+    if (chainInfo) {
+      return {
+        id: chainId,
+        name: chainInfo.name,
+        network: chainInfo.name.toLowerCase().replace(/\s+/g, "-"),
+        nativeCurrency: chainInfo.nativeCurrency,
+        rpcUrls: {
+          default: { http: chainInfo.rpcUrls },
+          public: { http: chainInfo.rpcUrls }
+        },
+        blockExplorers: chainInfo.blockExplorerUrls ? {
+          default: { name: "Explorer", url: chainInfo.blockExplorerUrls[0] }
+        } : void 0
+      };
+    }
+    return {
+      id: chainId,
+      name: `Chain ${chainId}`,
+      network: `chain-${chainId}`,
+      nativeCurrency: {
+        name: "ETH",
+        symbol: "ETH",
+        decimals: 18
+      },
+      rpcUrls: {
+        default: { http: [] },
+        public: { http: [] }
+      }
+    };
+  }
+};
+
+// src/core/adapter-registry.ts
+var AdapterRegistry = class {
+  constructor() {
+    this.adapters = /* @__PURE__ */ new Map();
+    this.registerDefaultAdapters();
+  }
+  /**
+   * 注册默认适配器
+   */
+  registerDefaultAdapters() {
+    this.register("metamask" /* METAMASK */, () => new MetaMaskAdapter());
+    this.register("private-key" /* PRIVATE_KEY */, () => new EVMPrivateKeyAdapter());
+    this.register("tronlink" /* TRONLINK */, () => new TronLinkAdapter());
+  }
+  /**
+   * 注册适配器
+   */
+  register(type, factory) {
+    this.adapters.set(type, factory);
+  }
+  /**
+   * 获取适配器
+   */
+  getAdapter(type) {
+    const factory = this.adapters.get(type);
+    if (!factory) {
+      return null;
+    }
+    return factory();
+  }
+  /**
+   * 判断适配器是否已注册
+   */
+  has(type) {
+    return this.adapters.has(type);
+  }
+  /**
+   * 获取所有已注册的适配器类型
+   */
+  getRegisteredTypes() {
+    return Array.from(this.adapters.keys());
+  }
+  /**
+   * 根据链类型获取适配器类型列表
+   */
+  getAdapterTypesByChainType(chainType) {
+    const types = [];
+    for (const type of this.adapters.keys()) {
+      const adapter = this.getAdapter(type);
+      if (adapter && adapter.chainType === chainType) {
+        types.push(type);
+      }
+    }
+    return types;
+  }
+};
+
+// src/core/wallet-manager.ts
+var WalletManager = class extends TypedEventEmitter {
+  constructor(config = {}) {
+    super();
+    // 主钱包
+    this.primaryWallet = null;
+    // 已连接钱包池
+    this.connectedWallets = /* @__PURE__ */ new Map();
+    this.config = {
+      enableStorage: config.enableStorage ?? true,
+      storagePrefix: config.storagePrefix ?? "enclave_wallet_",
+      defaultChainId: config.defaultChainId ?? 1,
+      defaultTronChainId: config.defaultTronChainId ?? 195,
+      walletConnectProjectId: config.walletConnectProjectId ?? ""
+    };
+    this.registry = new AdapterRegistry();
+    if (this.config.enableStorage) {
+      this.restoreFromStorage();
+    }
+  }
+  // ===== 连接管理 =====
+  /**
+   * 连接主钱包
+   */
+  async connect(type, chainId) {
+    const adapter = this.registry.getAdapter(type);
+    if (!adapter) {
+      throw new WalletNotAvailableError(type);
+    }
+    const isAvailable = await adapter.isAvailable();
+    if (!isAvailable) {
+      throw new WalletNotAvailableError(type);
+    }
+    const account = await adapter.connect(chainId);
+    this.setPrimaryWallet(adapter);
+    this.connectedWallets.set(adapter.chainType, adapter);
+    this.setupAdapterListeners(adapter, true);
+    if (this.config.enableStorage) {
+      this.saveToStorage();
+    }
+    return account;
+  }
+  /**
+   * 连接额外的钱包（不改变主钱包）
+   */
+  async connectAdditional(type, chainId) {
+    const adapter = this.registry.getAdapter(type);
+    if (!adapter) {
+      throw new WalletNotAvailableError(type);
+    }
+    const isAvailable = await adapter.isAvailable();
+    if (!isAvailable) {
+      throw new WalletNotAvailableError(type);
+    }
+    const account = await adapter.connect(chainId);
+    this.connectedWallets.set(adapter.chainType, adapter);
+    this.setupAdapterListeners(adapter, false);
+    if (this.config.enableStorage) {
+      this.saveToStorage();
+    }
+    return account;
+  }
+  /**
+   * 使用私钥连接（仅用于开发/测试）
+   */
+  async connectWithPrivateKey(privateKey, chainId) {
+    const adapter = new EVMPrivateKeyAdapter();
+    adapter.setPrivateKey(privateKey);
+    const account = await adapter.connect(chainId || this.config.defaultChainId);
+    this.setPrimaryWallet(adapter);
+    this.connectedWallets.set(adapter.chainType, adapter);
+    this.setupAdapterListeners(adapter, true);
+    return account;
+  }
+  /**
+   * 断开主钱包
+   */
+  async disconnect() {
+    if (!this.primaryWallet) {
+      return;
+    }
+    await this.primaryWallet.disconnect();
+    this.removeAdapterListeners(this.primaryWallet);
+    this.connectedWallets.delete(this.primaryWallet.chainType);
+    this.primaryWallet = null;
+    if (this.config.enableStorage) {
+      this.saveToStorage();
+    }
+    this.emit("disconnected");
+  }
+  /**
+   * 断开所有钱包
+   */
+  async disconnectAll() {
+    const wallets = Array.from(this.connectedWallets.values());
+    for (const wallet of wallets) {
+      await wallet.disconnect();
+      this.removeAdapterListeners(wallet);
+    }
+    this.primaryWallet = null;
+    this.connectedWallets.clear();
+    if (this.config.enableStorage) {
+      this.clearStorage();
+    }
+    this.emit("disconnected");
+  }
+  // ===== 主钱包管理 =====
+  /**
+   * 切换主钱包
+   */
+  async switchPrimaryWallet(chainType) {
+    const adapter = this.connectedWallets.get(chainType);
+    if (!adapter || !adapter.currentAccount) {
+      throw new WalletNotConnectedError(`Wallet for chain type ${chainType} not connected`);
+    }
+    const oldPrimary = this.primaryWallet?.currentAccount || null;
+    if (this.primaryWallet) {
+      this.removeAdapterListeners(this.primaryWallet);
+    }
+    this.setPrimaryWallet(adapter);
+    this.setupAdapterListeners(adapter, true);
+    if (this.config.enableStorage) {
+      this.saveToStorage();
+    }
+    this.emit("primaryWalletSwitched", adapter.currentAccount, oldPrimary, chainType);
+    return adapter.currentAccount;
+  }
+  /**
+   * 获取主钱包账户
+   */
+  getPrimaryAccount() {
+    return this.primaryWallet?.currentAccount || null;
+  }
+  /**
+   * 获取所有已连接的钱包
+   */
+  getConnectedWallets() {
+    return Array.from(this.connectedWallets.values()).map((adapter) => ({
+      account: adapter.currentAccount,
+      walletType: adapter.type,
+      chainType: adapter.chainType,
+      isPrimary: adapter === this.primaryWallet,
+      canSwitchChain: this.canSwitchChain(adapter),
+      adapter
+    }));
+  }
+  /**
+   * 根据链类型获取钱包
+   */
+  getWalletByChainType(chainType) {
+    return this.connectedWallets.get(chainType) || null;
+  }
+  // ===== 签名 =====
+  /**
+   * 使用主钱包签名
+   */
+  async signMessage(message) {
+    if (!this.primaryWallet) {
+      throw new WalletNotConnectedError();
+    }
+    return this.primaryWallet.signMessage(message);
+  }
+  /**
+   * 使用指定链类型的钱包签名
+   */
+  async signMessageWithChainType(message, chainType) {
+    if (!chainType) {
+      return this.signMessage(message);
+    }
+    const adapter = this.connectedWallets.get(chainType);
+    if (!adapter) {
+      throw new WalletNotConnectedError(`Wallet for chain type ${chainType}`);
+    }
+    return adapter.signMessage(message);
+  }
+  /**
+   * 签名 TypedData（仅 EVM）
+   */
+  async signTypedData(typedData, chainType) {
+    const adapter = chainType ? this.connectedWallets.get(chainType) : this.primaryWallet;
+    if (!adapter) {
+      throw new WalletNotConnectedError();
+    }
+    if (!adapter.signTypedData) {
+      throw new Error(`signTypedData not supported by ${adapter.type}`);
+    }
+    return adapter.signTypedData(typedData);
+  }
+  // ===== 链切换 =====
+  /**
+   * 请求切换链（仅 EVM）
+   */
+  async requestSwitchChain(chainId, options) {
+    if (!this.primaryWallet) {
+      throw new WalletNotConnectedError();
+    }
+    if (!this.primaryWallet.switchChain) {
+      throw new Error(`Chain switching not supported by ${this.primaryWallet.type}`);
+    }
+    try {
+      await this.primaryWallet.switchChain(chainId);
+      return this.primaryWallet.currentAccount;
+    } catch (error) {
+      if (options?.addChainIfNotExists && options.chainConfig && this.primaryWallet.addChain) {
+        await this.primaryWallet.addChain(options.chainConfig);
+        await this.primaryWallet.switchChain(chainId);
+        return this.primaryWallet.currentAccount;
+      }
+      throw error;
+    }
+  }
+  // ===== 合约调用 =====
+  /**
+   * 读取合约
+   */
+  async readContract(address, abi, functionName, args, chainType) {
+    const adapter = chainType ? this.connectedWallets.get(chainType) : this.primaryWallet;
+    if (!adapter) {
+      throw new WalletNotConnectedError();
+    }
+    if (!adapter.readContract) {
+      throw new Error(`readContract not supported by ${adapter.type}`);
+    }
+    return adapter.readContract({ address, abi, functionName, args });
+  }
+  /**
+   * 写入合约
+   */
+  async writeContract(address, abi, functionName, args, options, chainType) {
+    const adapter = chainType ? this.connectedWallets.get(chainType) : this.primaryWallet;
+    if (!adapter) {
+      throw new WalletNotConnectedError();
+    }
+    if (!adapter.writeContract) {
+      throw new Error(`writeContract not supported by ${adapter.type}`);
+    }
+    return adapter.writeContract({
+      address,
+      abi,
+      functionName,
+      args,
+      ...options
+    });
+  }
+  /**
+   * 估算 Gas
+   */
+  async estimateGas(address, abi, functionName, args, chainType) {
+    const adapter = chainType ? this.connectedWallets.get(chainType) : this.primaryWallet;
+    if (!adapter) {
+      throw new WalletNotConnectedError();
+    }
+    if (!adapter.estimateGas) {
+      throw new Error(`estimateGas not supported by ${adapter.type}`);
+    }
+    return adapter.estimateGas({ address, abi, functionName, args });
+  }
+  /**
+   * 等待交易确认
+   */
+  async waitForTransaction(txHash, confirmations, chainType) {
+    const adapter = chainType ? this.connectedWallets.get(chainType) : this.primaryWallet;
+    if (!adapter) {
+      throw new WalletNotConnectedError();
+    }
+    if (!adapter.waitForTransaction) {
+      throw new Error(`waitForTransaction not supported by ${adapter.type}`);
+    }
+    return adapter.waitForTransaction(txHash, confirmations);
+  }
+  // ===== Provider 访问 =====
+  /**
+   * 获取主钱包 Provider
+   */
+  getProvider() {
+    if (!this.primaryWallet) {
+      throw new WalletNotConnectedError();
+    }
+    return this.primaryWallet.getProvider();
+  }
+  /**
+   * 获取指定链类型的 Provider
+   */
+  getProviderByChainType(chainType) {
+    const adapter = this.connectedWallets.get(chainType);
+    if (!adapter) {
+      throw new WalletNotConnectedError(`Wallet for chain type ${chainType}`);
+    }
+    return adapter.getProvider();
+  }
+  // ===== 私有方法 =====
+  /**
+   * 设置主钱包
+   */
+  setPrimaryWallet(adapter) {
+    this.primaryWallet = adapter;
+  }
+  /**
+   * 判断钱包是否支持链切换
+   */
+  canSwitchChain(adapter) {
+    return !!adapter.switchChain;
+  }
+  /**
+   * 设置适配器事件监听
+   */
+  setupAdapterListeners(adapter, isPrimary) {
+    adapter.on("accountChanged", (account) => {
+      if (isPrimary) {
+        this.emit("accountChanged", account);
+      }
+      this.emit("walletAccountChanged", adapter.chainType, account, isPrimary);
+      if (this.config.enableStorage) {
+        this.saveToStorage();
+      }
+    });
+    adapter.on("chainChanged", (chainId) => {
+      if (isPrimary && adapter.currentAccount) {
+        this.emit("chainChanged", chainId, adapter.currentAccount);
+      }
+      if (adapter.currentAccount) {
+        this.emit("walletChainChanged", adapter.chainType, chainId, adapter.currentAccount, isPrimary);
+      }
+      if (this.config.enableStorage) {
+        this.saveToStorage();
+      }
+    });
+    adapter.on("disconnected", () => {
+      if (isPrimary) {
+        this.emit("disconnected");
+      }
+      this.emit("walletDisconnected", adapter.chainType, isPrimary);
+      this.connectedWallets.delete(adapter.chainType);
+      if (adapter === this.primaryWallet) {
+        this.primaryWallet = null;
+      }
+      if (this.config.enableStorage) {
+        this.saveToStorage();
+      }
+    });
+    adapter.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+  /**
+   * 移除适配器事件监听
+   */
+  removeAdapterListeners(adapter) {
+    adapter.removeAllListeners();
+  }
+  // ===== 存储 =====
+  /**
+   * 保存到存储
+   */
+  saveToStorage() {
+    if (typeof window === "undefined" || !this.config.enableStorage) {
+      return;
+    }
+    const data = {
+      current: this.primaryWallet?.currentAccount?.universalAddress || null,
+      history: this.getHistoryRecords()
+    };
+    try {
+      localStorage.setItem(
+        `${this.config.storagePrefix}data`,
+        JSON.stringify(data)
+      );
+    } catch (error) {
+      console.error("Failed to save wallet data to storage:", error);
+    }
+  }
+  /**
+   * 从存储恢复
+   */
+  restoreFromStorage() {
+  }
+  /**
+   * 清除存储
+   */
+  clearStorage() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    try {
+      localStorage.removeItem(`${this.config.storagePrefix}data`);
+    } catch (error) {
+      console.error("Failed to clear wallet data from storage:", error);
+    }
+  }
+  /**
+   * 获取历史记录
+   */
+  getHistoryRecords() {
+    const records = [];
+    for (const adapter of this.connectedWallets.values()) {
+      if (adapter.currentAccount) {
+        records.push({
+          universalAddress: adapter.currentAccount.universalAddress,
+          nativeAddress: adapter.currentAccount.nativeAddress,
+          chainId: adapter.currentAccount.chainId,
+          chainType: adapter.chainType,
+          walletType: adapter.type,
+          lastConnected: Date.now(),
+          name: adapter.currentAccount.name
+        });
+      }
+    }
+    return records;
+  }
+};
+
+// src/auth/message-generator.ts
+var AuthMessageGenerator = class {
+  constructor(domain) {
+    this.domain = domain;
+  }
+  /**
+   * 生成认证消息
+   */
+  generateAuthMessage(chainType, nonce, chainId, timestamp = Date.now(), statement) {
+    switch (chainType) {
+      case "evm" /* EVM */:
+        return this.generateEIP191Message({
+          domain: this.domain,
+          nonce,
+          chainId,
+          timestamp,
+          statement
+        });
+      case "tron" /* TRON */:
+        return this.generateTIP191Message({
+          domain: this.domain,
+          nonce,
+          chainId,
+          timestamp,
+          statement
+        });
+      default:
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }
+  }
+  /**
+   * 生成 EIP-191 格式的认证消息
+   */
+  generateEIP191Message(params) {
+    const lines = [
+      `${params.domain} wants you to sign in.`,
+      ""
+    ];
+    if (params.statement) {
+      lines.push(params.statement, "");
+    }
+    lines.push(
+      `Nonce: ${params.nonce}`,
+      `Chain ID: ${params.chainId}`,
+      `Issued At: ${new Date(params.timestamp).toISOString()}`
+    );
+    return lines.join("\n");
+  }
+  /**
+   * 生成 TIP-191 格式的认证消息
+   */
+  generateTIP191Message(params) {
+    const lines = [
+      `${params.domain} wants you to sign in with your Tron account.`,
+      ""
+    ];
+    if (params.statement) {
+      lines.push(params.statement, "");
+    }
+    lines.push(
+      `Nonce: ${params.nonce}`,
+      `Chain ID: ${params.chainId}`,
+      `Issued At: ${new Date(params.timestamp).toISOString()}`
+    );
+    return lines.join("\n");
+  }
+  /**
+   * 生成随机 nonce
+   */
+  static generateNonce() {
+    const array = new Uint8Array(16);
+    crypto.getRandomValues(array);
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+};
+var SignatureVerifier = class {
+  /**
+   * 验证签名
+   */
+  async verifySignature(message, signature, expectedAddress, chainType) {
+    switch (chainType) {
+      case "evm" /* EVM */:
+        return this.verifyEIP191Signature(message, signature, expectedAddress);
+      case "tron" /* TRON */:
+        return this.verifyTIP191Signature(message, signature, expectedAddress);
+      default:
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }
+  }
+  /**
+   * 验证 EIP-191 签名
+   */
+  async verifyEIP191Signature(message, signature, expectedAddress) {
+    try {
+      const isValid = await viem.verifyMessage({
+        address: expectedAddress,
+        message,
+        signature
+      });
+      return isValid;
+    } catch (error) {
+      console.error("EIP-191 signature verification failed:", error);
+      return false;
+    }
+  }
+  /**
+   * 验证 TIP-191 签名
+   * 注意：这里需要 TronWeb 或类似库来验证 Tron 签名
+   * 这是一个占位实现
+   */
+  async verifyTIP191Signature(_message, _signature, _expectedAddress) {
+    console.warn("TIP-191 signature verification not implemented yet");
+    return false;
+  }
+};
+
+// src/detection/supported-wallets.ts
+var SUPPORTED_WALLETS = {
+  ["metamask" /* METAMASK */]: {
+    type: "metamask" /* METAMASK */,
+    name: "MetaMask",
+    chainType: "evm" /* EVM */,
+    icon: "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg",
+    downloadUrl: "https://metamask.io/download/",
+    description: "The most popular Ethereum wallet"
+  },
+  ["walletconnect" /* WALLETCONNECT */]: {
+    type: "walletconnect" /* WALLETCONNECT */,
+    name: "WalletConnect",
+    chainType: "evm" /* EVM */,
+    icon: "https://avatars.githubusercontent.com/u/37784886",
+    downloadUrl: "https://walletconnect.com/",
+    description: "Connect to 170+ wallets"
+  },
+  ["coinbase-wallet" /* COINBASE_WALLET */]: {
+    type: "coinbase-wallet" /* COINBASE_WALLET */,
+    name: "Coinbase Wallet",
+    chainType: "evm" /* EVM */,
+    icon: "https://www.coinbase.com/img/favicon/favicon-96x96.png",
+    downloadUrl: "https://www.coinbase.com/wallet",
+    description: "Coinbase self-custody wallet"
+  },
+  ["tronlink" /* TRONLINK */]: {
+    type: "tronlink" /* TRONLINK */,
+    name: "TronLink",
+    chainType: "tron" /* TRON */,
+    icon: "https://www.tronlink.org/static/logoIcon.svg",
+    downloadUrl: "https://www.tronlink.org/",
+    description: "The official Tron wallet"
+  },
+  ["walletconnect-tron" /* WALLETCONNECT_TRON */]: {
+    type: "walletconnect-tron" /* WALLETCONNECT_TRON */,
+    name: "WalletConnect (Tron)",
+    chainType: "tron" /* TRON */,
+    downloadUrl: "https://walletconnect.com/",
+    description: "WalletConnect for Tron"
+  },
+  ["private-key" /* PRIVATE_KEY */]: {
+    type: "private-key" /* PRIVATE_KEY */,
+    name: "Private Key",
+    chainType: "evm" /* EVM */,
+    // 可以用于任何链
+    description: "Import wallet using private key (for development)"
+  }
+};
+function getWalletMetadata(type) {
+  return SUPPORTED_WALLETS[type];
+}
+function getEVMWallets() {
+  return Object.values(SUPPORTED_WALLETS).filter(
+    (wallet) => wallet.chainType === "evm" /* EVM */
+  );
+}
+function getTronWallets() {
+  return Object.values(SUPPORTED_WALLETS).filter(
+    (wallet) => wallet.chainType === "tron" /* TRON */
+  );
+}
+
+// src/detection/detector.ts
+var WalletDetector = class {
+  /**
+   * 检测所有钱包可用性
+   */
+  async detectAllWallets() {
+    const walletTypes = Object.values(WalletType).filter(
+      (type) => type !== "private-key" /* PRIVATE_KEY */
+      // 私钥钱包不需要检测
+    );
+    const results = await Promise.all(
+      walletTypes.map((type) => this.detectWallet(type))
+    );
+    return results;
+  }
+  /**
+   * 检测特定钱包
+   */
+  async detectWallet(walletType) {
+    const metadata = SUPPORTED_WALLETS[walletType];
+    if (!metadata) {
+      return {
+        walletType,
+        chainType: "evm" /* EVM */,
+        // 默认
+        isAvailable: false,
+        detected: false
+      };
+    }
+    const isAvailable = await this.isWalletAvailable(walletType);
+    return {
+      walletType,
+      chainType: metadata.chainType,
+      isAvailable,
+      downloadUrl: metadata.downloadUrl,
+      detected: isAvailable
+    };
+  }
+  /**
+   * 判断钱包是否可用
+   */
+  async isWalletAvailable(walletType) {
+    if (typeof window === "undefined") {
+      return false;
+    }
+    switch (walletType) {
+      case "metamask" /* METAMASK */:
+        return this.isMetaMaskAvailable();
+      case "tronlink" /* TRONLINK */:
+        return this.isTronLinkAvailable();
+      case "coinbase-wallet" /* COINBASE_WALLET */:
+        return this.isCoinbaseWalletAvailable();
+      case "walletconnect" /* WALLETCONNECT */:
+      case "walletconnect-tron" /* WALLETCONNECT_TRON */:
+        return true;
+      case "private-key" /* PRIVATE_KEY */:
+        return true;
+      default:
+        return false;
+    }
+  }
+  /**
+   * 检测 MetaMask
+   */
+  isMetaMaskAvailable() {
+    const w = window;
+    return !!(w.ethereum && w.ethereum.isMetaMask);
+  }
+  /**
+   * 检测 TronLink
+   */
+  isTronLinkAvailable() {
+    const w = window;
+    return !!(w.tronLink || w.tronWeb);
+  }
+  /**
+   * 检测 Coinbase Wallet
+   */
+  isCoinbaseWalletAvailable() {
+    const w = window;
+    return !!(w.ethereum && w.ethereum.isCoinbaseWallet);
+  }
+  /**
+   * 等待钱包加载（有些钱包可能延迟注入）
+   */
+  async waitForWallet(walletType, timeout = 3e3) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      if (await this.isWalletAvailable(walletType)) {
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return false;
+  }
+};
+
+// src/utils/address/tron-converter.ts
+function isValidTronAddress(address) {
+  if (!address || typeof address !== "string") {
+    return false;
+  }
+  if (address.length !== 34 || !address.startsWith("T")) {
+    return false;
+  }
+  const base58Regex = /^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/;
+  return base58Regex.test(address);
+}
+function isValidTronHexAddress(address) {
+  if (!address || typeof address !== "string") {
+    return false;
+  }
+  if (address.length !== 42 || !address.startsWith("41")) {
+    return false;
+  }
+  const hexRegex = /^[0-9a-fA-F]+$/;
+  return hexRegex.test(address.substring(2));
+}
+function compareTronAddresses(a, b) {
+  return a === b;
+}
+function shortenTronAddress(address, chars = 4) {
+  if (!isValidTronAddress(address)) {
+    return address;
+  }
+  return `${address.substring(0, chars + 1)}...${address.substring(34 - chars)}`;
+}
+
+// src/utils/validation.ts
+function validateAddress(address, chainType) {
+  switch (chainType) {
+    case "evm" /* EVM */:
+      return isValidEVMAddress(address);
+    case "tron" /* TRON */:
+      return isValidTronAddress(address);
+    default:
+      return false;
+  }
+}
+function validateAddressForChain(address, chainId) {
+  const chainType = getChainType(chainId);
+  if (!chainType) {
+    return false;
+  }
+  return validateAddress(address, chainType);
+}
+function isValidChainId(chainId) {
+  return Number.isInteger(chainId) && chainId > 0;
+}
+function isValidSignature(signature) {
+  return /^0x[0-9a-fA-F]{130}$/.test(signature);
+}
+function isValidTransactionHash(txHash, chainType) {
+  switch (chainType) {
+    case "evm" /* EVM */:
+      return /^0x[0-9a-fA-F]{64}$/.test(txHash);
+    case "tron" /* TRON */:
+      return /^[0-9a-fA-F]{64}$/.test(txHash);
+    default:
+      return false;
+  }
+}
+
+// src/utils/hex.ts
+function isHex(value) {
+  return /^0x[0-9a-fA-F]*$/.test(value);
+}
+function toHex(value) {
+  let hex = "";
+  for (let i = 0; i < value.length; i++) {
+    hex += value.charCodeAt(i).toString(16);
+  }
+  return `0x${hex}`;
+}
+function fromHex(hex) {
+  const hexString = hex.startsWith("0x") ? hex.slice(2) : hex;
+  let str = "";
+  for (let i = 0; i < hexString.length; i += 2) {
+    str += String.fromCharCode(parseInt(hexString.substr(i, 2), 16));
+  }
+  return str;
+}
+function numberToHex(value) {
+  return `0x${value.toString(16)}`;
+}
+function hexToNumber(hex) {
+  return parseInt(hex, 16);
+}
+function ensureHexPrefix(value) {
+  return value.startsWith("0x") ? value : `0x${value}`;
+}
+function removeHexPrefix(value) {
+  return value.startsWith("0x") ? value.slice(2) : value;
+}
+
+// src/index.ts
+var index_default = WalletManager;
+
+exports.AdapterRegistry = AdapterRegistry;
+exports.AuthMessageGenerator = AuthMessageGenerator;
+exports.BrowserWalletAdapter = BrowserWalletAdapter;
+exports.CHAIN_INFO = CHAIN_INFO;
+exports.ChainNotSupportedError = ChainNotSupportedError;
+exports.ChainType = ChainType;
+exports.ConfigurationError = ConfigurationError;
+exports.ConnectionRejectedError = ConnectionRejectedError;
+exports.EVMPrivateKeyAdapter = EVMPrivateKeyAdapter;
+exports.MetaMaskAdapter = MetaMaskAdapter;
+exports.MethodNotSupportedError = MethodNotSupportedError;
+exports.NetworkError = NetworkError;
+exports.SUPPORTED_WALLETS = SUPPORTED_WALLETS;
+exports.SignatureRejectedError = SignatureRejectedError;
+exports.SignatureVerifier = SignatureVerifier;
+exports.TransactionFailedError = TransactionFailedError;
+exports.TronLinkAdapter = TronLinkAdapter;
+exports.WalletAdapter = WalletAdapter;
+exports.WalletDetector = WalletDetector;
+exports.WalletManager = WalletManager;
+exports.WalletNotAvailableError = WalletNotAvailableError;
+exports.WalletNotConnectedError = WalletNotConnectedError;
+exports.WalletSDKError = WalletSDKError;
+exports.WalletState = WalletState;
+exports.WalletType = WalletType;
+exports.compareEVMAddresses = compareEVMAddresses;
+exports.compareTronAddresses = compareTronAddresses;
+exports.compareUniversalAddresses = compareUniversalAddresses;
+exports.createUniversalAddress = createUniversalAddress;
+exports.default = index_default;
+exports.ensureHexPrefix = ensureHexPrefix;
+exports.formatEVMAddress = formatEVMAddress;
+exports.fromHex = fromHex;
+exports.getAddressFromUniversalAddress = getAddressFromUniversalAddress;
+exports.getChainIdFromUniversalAddress = getChainIdFromUniversalAddress;
+exports.getChainInfo = getChainInfo;
+exports.getChainType = getChainType;
+exports.getEVMWallets = getEVMWallets;
+exports.getTronWallets = getTronWallets;
+exports.getWalletMetadata = getWalletMetadata;
+exports.hexToNumber = hexToNumber;
+exports.isEVMChain = isEVMChain;
+exports.isHex = isHex;
+exports.isTronChain = isTronChain;
+exports.isValidChainId = isValidChainId;
+exports.isValidEVMAddress = isValidEVMAddress;
+exports.isValidSignature = isValidSignature;
+exports.isValidTransactionHash = isValidTransactionHash;
+exports.isValidTronAddress = isValidTronAddress;
+exports.isValidTronHexAddress = isValidTronHexAddress;
+exports.isValidUniversalAddress = isValidUniversalAddress;
+exports.numberToHex = numberToHex;
+exports.parseUniversalAddress = parseUniversalAddress;
+exports.removeHexPrefix = removeHexPrefix;
+exports.shortenAddress = shortenAddress;
+exports.shortenTronAddress = shortenTronAddress;
+exports.toHex = toHex;
+exports.validateAddress = validateAddress;
+exports.validateAddressForChain = validateAddressForChain;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map