@enclave-hq/wallet-sdk 1.0.0

package/dist/react/index.js

@@ -0,0 +1,1782 @@
+'use strict';
+
+var React = require('react');
+var EventEmitter = require('eventemitter3');
+var viem = require('viem');
+var accounts = require('viem/accounts');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+
+// src/react/WalletContext.tsx
+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/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 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";
+  }
+};
+
+// 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 formatEVMAddress(address) {
+  if (!viem.isAddress(address)) {
+    throw new Error(`Invalid EVM address: ${address}`);
+  }
+  return viem.getAddress(address);
+}
+
+// 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];
+}
+
+// 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/react/WalletContext.tsx
+var WalletContext = React.createContext(null);
+function WalletProvider({ children, walletManager: externalWalletManager }) {
+  const [walletManager] = React.useState(() => externalWalletManager || new WalletManager());
+  const [account, setAccount] = React.useState(null);
+  const [connectedWallets, setConnectedWallets] = React.useState([]);
+  const updateConnectedWallets = React.useCallback(() => {
+    setConnectedWallets(walletManager.getConnectedWallets());
+  }, [walletManager]);
+  const connect = React.useCallback(async (type, chainId) => {
+    const account2 = await walletManager.connect(type, chainId);
+    setAccount(account2);
+    updateConnectedWallets();
+    return account2;
+  }, [walletManager, updateConnectedWallets]);
+  const connectAdditional = React.useCallback(async (type, chainId) => {
+    const account2 = await walletManager.connectAdditional(type, chainId);
+    updateConnectedWallets();
+    return account2;
+  }, [walletManager, updateConnectedWallets]);
+  const disconnect = React.useCallback(async () => {
+    await walletManager.disconnect();
+    setAccount(null);
+    updateConnectedWallets();
+  }, [walletManager, updateConnectedWallets]);
+  const switchPrimaryWallet = React.useCallback(async (chainType) => {
+    const account2 = await walletManager.switchPrimaryWallet(chainType);
+    setAccount(account2);
+    updateConnectedWallets();
+    return account2;
+  }, [walletManager, updateConnectedWallets]);
+  const signMessage = React.useCallback(async (message) => {
+    return walletManager.signMessage(message);
+  }, [walletManager]);
+  React.useEffect(() => {
+    const handleAccountChanged = (newAccount) => {
+      setAccount(newAccount);
+      updateConnectedWallets();
+    };
+    const handleChainChanged = (_chainId, newAccount) => {
+      setAccount(newAccount);
+      updateConnectedWallets();
+    };
+    const handleDisconnected = () => {
+      setAccount(null);
+      updateConnectedWallets();
+    };
+    const handlePrimaryWalletSwitched = (newPrimary) => {
+      setAccount(newPrimary);
+      updateConnectedWallets();
+    };
+    walletManager.on("accountChanged", handleAccountChanged);
+    walletManager.on("chainChanged", handleChainChanged);
+    walletManager.on("disconnected", handleDisconnected);
+    walletManager.on("primaryWalletSwitched", handlePrimaryWalletSwitched);
+    setAccount(walletManager.getPrimaryAccount());
+    updateConnectedWallets();
+    return () => {
+      walletManager.off("accountChanged", handleAccountChanged);
+      walletManager.off("chainChanged", handleChainChanged);
+      walletManager.off("disconnected", handleDisconnected);
+      walletManager.off("primaryWalletSwitched", handlePrimaryWalletSwitched);
+    };
+  }, [walletManager, updateConnectedWallets]);
+  const value = {
+    walletManager,
+    account,
+    isConnected: account !== null,
+    connectedWallets,
+    connect,
+    connectAdditional,
+    disconnect,
+    switchPrimaryWallet,
+    signMessage
+  };
+  return /* @__PURE__ */ React__default.default.createElement(WalletContext.Provider, { value }, children);
+}
+function useWallet() {
+  const context = React.useContext(WalletContext);
+  if (!context) {
+    throw new Error("useWallet must be used within a WalletProvider");
+  }
+  return context;
+}
+
+// src/react/hooks/useAccount.ts
+function useAccount() {
+  const { account, isConnected } = useWallet();
+  return {
+    account,
+    isConnected,
+    address: account?.nativeAddress || null,
+    chainId: account?.chainId || null,
+    universalAddress: account?.universalAddress || null
+  };
+}
+function useConnect() {
+  const { connect: contextConnect, connectAdditional: contextConnectAdditional } = useWallet();
+  const [isConnecting, setIsConnecting] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const connect = async (type, chainId) => {
+    setIsConnecting(true);
+    setError(null);
+    try {
+      const account = await contextConnect(type, chainId);
+      return account;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsConnecting(false);
+    }
+  };
+  const connectAdditional = async (type, chainId) => {
+    setIsConnecting(true);
+    setError(null);
+    try {
+      const account = await contextConnectAdditional(type, chainId);
+      return account;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsConnecting(false);
+    }
+  };
+  return {
+    connect,
+    connectAdditional,
+    isConnecting,
+    error
+  };
+}
+function useDisconnect() {
+  const { disconnect: contextDisconnect } = useWallet();
+  const [isDisconnecting, setIsDisconnecting] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const disconnect = async () => {
+    setIsDisconnecting(true);
+    setError(null);
+    try {
+      await contextDisconnect();
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsDisconnecting(false);
+    }
+  };
+  return {
+    disconnect,
+    isDisconnecting,
+    error
+  };
+}
+function useSignMessage() {
+  const { signMessage: contextSignMessage } = useWallet();
+  const [isSigning, setIsSigning] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const signMessage = async (message) => {
+    setIsSigning(true);
+    setError(null);
+    try {
+      const signature = await contextSignMessage(message);
+      return signature;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsSigning(false);
+    }
+  };
+  return {
+    signMessage,
+    isSigning,
+    error
+  };
+}
+
+exports.WalletProvider = WalletProvider;
+exports.useAccount = useAccount;
+exports.useConnect = useConnect;
+exports.useDisconnect = useDisconnect;
+exports.useSignMessage = useSignMessage;
+exports.useWallet = useWallet;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map