@enclave-hq/wallet-sdk 1.0.0

package/README.md

@@ -0,0 +1,203 @@
+# @enclave-hq/wallet-sdk
+
+> Multi-chain wallet adapter for Enclave - supports EVM and Tron ecosystems
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## 📋 Overview
+
+**@enclave-hq/wallet-sdk** is a powerful, extensible wallet adapter library that provides a unified interface for connecting to multiple blockchain wallets across different ecosystems (EVM and Tron).
+
+### Key Features
+
+- **🔗 Multi-Chain Support**: Unified interface for EVM (Ethereum, BSC, Polygon, etc.) and Tron
+- **🔌 Multiple Wallets**: MetaMask, TronLink, WalletConnect, and private key support
+- **⚡️ Easy Integration**: Simple API with React hooks
+- **🎯 Type-Safe**: Full TypeScript support with comprehensive type definitions
+- **🔐 Secure**: Standard-compliant signing (EIP-191, TIP-191, EIP-712)
+- **📦 Tree-Shakeable**: Modern build system with ESM and CJS support
+- **🎨 Extensible**: Plugin-based architecture for adding new wallets and chains
+
+## 📦 Installation
+
+```bash
+npm install @enclave-hq/wallet-sdk
+# or
+yarn add @enclave-hq/wallet-sdk
+# or
+pnpm add @enclave-hq/wallet-sdk
+```
+
+## 🚀 Quick Start
+
+### Basic Usage (Vanilla JS/TS)
+
+```typescript
+import { WalletManager, WalletType } from '@enclave-hq/wallet-sdk'
+
+// Create wallet manager
+const walletManager = new WalletManager()
+
+// Connect to MetaMask
+const account = await walletManager.connect(WalletType.METAMASK, 1) // Ethereum Mainnet
+
+console.log('Connected:', account.universalAddress)
+// Output: "1:0x1234567890123456789012345678901234567890"
+
+// Sign a message
+const signature = await walletManager.signMessage('Hello World')
+
+// Disconnect
+await walletManager.disconnect()
+```
+
+### React Integration
+
+```tsx
+import React from 'react'
+import { WalletProvider, useWallet, useAccount, useConnect } from '@enclave-hq/wallet-sdk/react'
+import { WalletType } from '@enclave-hq/wallet-sdk'
+
+// 1. Wrap your app with WalletProvider
+function App() {
+  return (
+    <WalletProvider>
+      <YourApp />
+    </WalletProvider>
+  )
+}
+
+// 2. Use wallet hooks in your components
+function YourApp() {
+  const { account, isConnected } = useAccount()
+  const { connect, isConnecting } = useConnect()
+  const { disconnect } = useWallet()
+
+  const handleConnect = async () => {
+    try {
+      await connect(WalletType.METAMASK)
+    } catch (error) {
+      console.error('Connection failed:', error)
+    }
+  }
+
+  if (!isConnected) {
+    return (
+      <button onClick={handleConnect} disabled={isConnecting}>
+        {isConnecting ? 'Connecting...' : 'Connect MetaMask'}
+      </button>
+    )
+  }
+
+  return (
+    <div>
+      <p>Connected: {account?.nativeAddress}</p>
+      <button onClick={disconnect}>Disconnect</button>
+    </div>
+  )
+}
+```
+
+## 🎯 Core Concepts
+
+### Universal Address
+
+A chain-agnostic address format: `chainId:address`
+
+```typescript
+// Example:
+"1:0x1234..." // Ethereum Mainnet
+"56:0x5678..." // BSC Mainnet
+"195:TJmm..." // Tron Mainnet
+```
+
+### Primary Wallet + Connected Wallets Pool
+
+The SDK uses a hybrid architecture where you can:
+- Connect multiple wallets simultaneously (EVM + Tron)
+- Designate one as the "primary wallet" for default operations
+- Switch the primary wallet dynamically
+
+```typescript
+// Connect MetaMask as primary wallet
+await walletManager.connect(WalletType.METAMASK)
+
+// Connect TronLink as additional wallet
+await walletManager.connectAdditional(WalletType.TRONLINK)
+
+// Switch primary wallet to TronLink
+await walletManager.switchPrimaryWallet(ChainType.TRON)
+
+// Get all connected wallets
+const wallets = walletManager.getConnectedWallets()
+```
+
+## 📚 Supported Wallets
+
+| Wallet | Chain Type | Status |
+|--------|------------|--------|
+| MetaMask | EVM | ✅ Supported |
+| TronLink | Tron | ✅ Supported |
+| WalletConnect | EVM | 🚧 Coming Soon |
+| Coinbase Wallet | EVM | 🚧 Coming Soon |
+| Private Key | EVM/Tron | ✅ Dev Only |
+
+## 📖 Documentation
+
+Full documentation is available in the `/docs` folder:
+
+- [Architecture Design](../docs/wallet-sdk/ARCHITECTURE.md)
+- [Design Goals](../docs/wallet-sdk/DESIGN.md)
+- [API Reference](../docs/wallet-sdk/API接口.md)
+- [Integration Guide](../docs/wallet-sdk/INTEGRATION.md)
+- [State Management](../docs/wallet-sdk/STATE_AND_ACCOUNT.md)
+- [Standards & Signing](../docs/wallet-sdk/STANDARDS.md)
+
+## 🧪 Running the Example
+
+A fully functional example application is included:
+
+```bash
+cd example
+npm install
+npm run dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) to see the demo.
+
+## 🛠️ Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the SDK
+npm run build
+
+# Watch mode (for development)
+npm run dev
+
+# Run linter
+npm run lint
+
+# Type check
+npm run type-check
+```
+
+## 📄 License
+
+MIT © Enclave Team
+
+## 🤝 Contributing
+
+Contributions are welcome! Please read our [Contributing Guide](../CONTRIBUTING.md) for details.
+
+## 🔗 Links
+
+- [Enclave Documentation](../README.md)
+- [GitHub Repository](https://github.com/enclave-hq/enclave)
+- [Report Issues](https://github.com/enclave-hq/enclave/issues)
+
+---
+
+**Built with ❤️ by the Enclave Team**

package/dist/index.d.mts

@@ -0,0 +1,441 @@
+import EventEmitter from 'eventemitter3';
+import { WalletClient } from 'viem';
+
+declare class TypedEventEmitter<TEvents extends Record<string, (...args: any[]) => void>> {
+    private emitter;
+    on<K extends keyof TEvents>(event: K, handler: TEvents[K]): this;
+    once<K extends keyof TEvents>(event: K, handler: TEvents[K]): this;
+    off<K extends keyof TEvents>(event: K, handler: TEvents[K]): this;
+    emit<K extends keyof TEvents>(event: K, ...args: Parameters<TEvents[K]>): boolean;
+    removeAllListeners<K extends keyof TEvents>(event?: K): this;
+}
+
+declare enum ChainType {
+    EVM = "evm",
+    TRON = "tron",
+    SOLANA = "solana",
+    COSMOS = "cosmos"
+}
+declare enum WalletType {
+    METAMASK = "metamask",
+    WALLETCONNECT = "walletconnect",
+    COINBASE_WALLET = "coinbase-wallet",
+    TRONLINK = "tronlink",
+    WALLETCONNECT_TRON = "walletconnect-tron",
+    PRIVATE_KEY = "private-key"
+}
+declare enum WalletState {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    ERROR = "error"
+}
+type UniversalAddress = string;
+interface Account {
+    universalAddress: UniversalAddress;
+    nativeAddress: string;
+    chainId: number;
+    chainType: ChainType;
+    isActive: boolean;
+    balance?: string;
+    name?: string;
+}
+interface IWalletAdapter {
+    readonly type: WalletType;
+    readonly chainType: ChainType;
+    readonly name: string;
+    readonly icon?: string;
+    state: WalletState;
+    currentAccount: Account | null;
+    connect(chainId?: number): Promise<Account>;
+    disconnect(): Promise<void>;
+    isAvailable(): Promise<boolean>;
+    signMessage(message: string): Promise<string>;
+    signTransaction?(transaction: any): Promise<string>;
+    signTypedData?(typedData: any): Promise<string>;
+    switchChain?(chainId: number): Promise<void>;
+    addChain?(chainConfig: AddChainParams): Promise<void>;
+    readContract?<T = any>(params: ContractReadParams): Promise<T>;
+    writeContract?(params: ContractWriteParams): Promise<string>;
+    estimateGas?(params: ContractWriteParams): Promise<bigint>;
+    waitForTransaction?(txHash: string, confirmations?: number): Promise<TransactionReceipt>;
+    getProvider(): any;
+    getSigner?(): any;
+    on(event: string, handler: (...args: any[]) => void): void;
+    off(event: string, handler: (...args: any[]) => void): void;
+    removeAllListeners(event?: string): void;
+}
+interface ContractReadParams {
+    address: string;
+    abi: any[];
+    functionName: string;
+    args?: any[];
+}
+interface ContractWriteParams extends ContractReadParams {
+    value?: string;
+    gas?: number;
+    gasPrice?: string;
+}
+interface TransactionReceipt {
+    transactionHash: string;
+    blockNumber: number;
+    blockHash: string;
+    from: string;
+    to?: string;
+    status: 'success' | 'failed';
+    gasUsed: string;
+    effectiveGasPrice?: string;
+    logs?: any[];
+}
+interface AddChainParams {
+    chainId: number;
+    chainName: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    rpcUrls: string[];
+    blockExplorerUrls?: string[];
+    iconUrls?: string[];
+}
+interface WalletManagerConfig {
+    enableStorage?: boolean;
+    storagePrefix?: string;
+    defaultChainId?: number;
+    defaultTronChainId?: number;
+    walletConnectProjectId?: string;
+}
+interface ConnectedWallet {
+    account: Account;
+    walletType: WalletType;
+    chainType: ChainType;
+    isPrimary: boolean;
+    canSwitchChain: boolean;
+    adapter: IWalletAdapter;
+}
+interface WalletManagerEvents extends Record<string, (...args: any[]) => void> {
+    accountChanged: (account: Account | null) => void;
+    chainChanged: (chainId: number, account: Account) => void;
+    disconnected: () => void;
+    walletAccountChanged: (chainType: ChainType, account: Account | null, isPrimary: boolean) => void;
+    walletChainChanged: (chainType: ChainType, chainId: number, account: Account, isPrimary: boolean) => void;
+    walletDisconnected: (chainType: ChainType, isPrimary: boolean) => void;
+    primaryWalletSwitched: (newPrimary: Account, oldPrimary: Account | null, chainType: ChainType) => void;
+    error: (error: Error) => void;
+}
+interface WalletHistoryRecord {
+    universalAddress: UniversalAddress;
+    nativeAddress: string;
+    chainId: number;
+    chainType: ChainType;
+    walletType: WalletType;
+    lastConnected: number;
+    name?: string;
+}
+interface StorageData {
+    current: UniversalAddress | null;
+    history: WalletHistoryRecord[];
+}
+interface WalletAvailability {
+    walletType: WalletType;
+    chainType: ChainType;
+    isAvailable: boolean;
+    downloadUrl?: string;
+    detected: boolean;
+}
+
+declare class WalletManager extends TypedEventEmitter<WalletManagerEvents> {
+    private config;
+    private registry;
+    private primaryWallet;
+    private connectedWallets;
+    constructor(config?: WalletManagerConfig);
+    connect(type: WalletType, chainId?: number): Promise<Account>;
+    connectAdditional(type: WalletType, chainId?: number): Promise<Account>;
+    connectWithPrivateKey(privateKey: string, chainId?: number): Promise<Account>;
+    disconnect(): Promise<void>;
+    disconnectAll(): Promise<void>;
+    switchPrimaryWallet(chainType: ChainType): Promise<Account>;
+    getPrimaryAccount(): Account | null;
+    getConnectedWallets(): ConnectedWallet[];
+    getWalletByChainType(chainType: ChainType): IWalletAdapter | null;
+    signMessage(message: string): Promise<string>;
+    signMessageWithChainType(message: string, chainType?: ChainType): Promise<string>;
+    signTypedData(typedData: any, chainType?: ChainType): Promise<string>;
+    requestSwitchChain(chainId: number, options?: {
+        addChainIfNotExists?: boolean;
+        chainConfig?: AddChainParams;
+    }): Promise<Account>;
+    readContract<T = any>(address: string, abi: any[], functionName: string, args?: any[], chainType?: ChainType): Promise<T>;
+    writeContract(address: string, abi: any[], functionName: string, args?: any[], options?: {
+        value?: string;
+        gas?: number;
+        gasPrice?: string;
+    }, chainType?: ChainType): Promise<string>;
+    estimateGas(address: string, abi: any[], functionName: string, args?: any[], chainType?: ChainType): Promise<bigint>;
+    waitForTransaction(txHash: string, confirmations?: number, chainType?: ChainType): Promise<TransactionReceipt>;
+    getProvider(): any;
+    getProviderByChainType(chainType: ChainType): any;
+    private setPrimaryWallet;
+    private canSwitchChain;
+    private setupAdapterListeners;
+    private removeAdapterListeners;
+    private saveToStorage;
+    private restoreFromStorage;
+    private clearStorage;
+    private getHistoryRecords;
+}
+
+declare class AdapterRegistry {
+    private adapters;
+    constructor();
+    private registerDefaultAdapters;
+    register(type: WalletType, factory: () => IWalletAdapter): void;
+    getAdapter(type: WalletType): IWalletAdapter | null;
+    has(type: WalletType): boolean;
+    getRegisteredTypes(): WalletType[];
+    getAdapterTypesByChainType(chainType: ChainType): WalletType[];
+}
+
+declare class WalletSDKError extends Error {
+    readonly code: string;
+    readonly details?: any | undefined;
+    constructor(message: string, code: string, details?: any | undefined);
+}
+declare class WalletNotConnectedError extends WalletSDKError {
+    constructor(walletType?: string);
+}
+declare class WalletNotAvailableError extends WalletSDKError {
+    constructor(walletType: string, downloadUrl?: string);
+}
+declare class ConnectionRejectedError extends WalletSDKError {
+    constructor(walletType: string);
+}
+declare class ChainNotSupportedError extends WalletSDKError {
+    constructor(chainId: number, walletType: string);
+}
+declare class SignatureRejectedError extends WalletSDKError {
+    constructor(message?: string);
+}
+declare class TransactionFailedError extends WalletSDKError {
+    constructor(txHash: string, reason?: string);
+}
+declare class MethodNotSupportedError extends WalletSDKError {
+    constructor(method: string, walletType: string);
+}
+declare class ConfigurationError extends WalletSDKError {
+    constructor(message: string, details?: any);
+}
+declare class NetworkError extends WalletSDKError {
+    constructor(message: string, details?: any);
+}
+
+declare abstract class WalletAdapter extends EventEmitter implements IWalletAdapter {
+    abstract readonly type: WalletType;
+    abstract readonly chainType: ChainType;
+    abstract readonly name: string;
+    readonly icon?: string;
+    state: WalletState;
+    currentAccount: Account | null;
+    abstract connect(chainId?: number): Promise<Account>;
+    abstract disconnect(): Promise<void>;
+    abstract isAvailable(): Promise<boolean>;
+    abstract signMessage(message: string): Promise<string>;
+    signTransaction?(_transaction: any): Promise<string>;
+    signTypedData?(_typedData: any): Promise<string>;
+    switchChain?(_chainId: number): Promise<void>;
+    addChain?(_chainConfig: any): Promise<void>;
+    readContract<T = any>(_params: ContractReadParams): Promise<T>;
+    writeContract(_params: ContractWriteParams): Promise<string>;
+    estimateGas(_params: ContractWriteParams): Promise<bigint>;
+    waitForTransaction(_txHash: string, _confirmations?: number): Promise<TransactionReceipt>;
+    abstract getProvider(): any;
+    getSigner?(): any;
+    protected ensureConnected(): void;
+    protected setState(state: WalletState): void;
+    protected setAccount(account: Account | null): void;
+    protected emitAccountChanged(account: Account | null): void;
+    protected emitChainChanged(chainId: number): void;
+    protected emitDisconnected(): void;
+    protected emitError(error: Error): void;
+}
+
+declare abstract class BrowserWalletAdapter extends WalletAdapter {
+    protected abstract getBrowserProvider(): any | undefined;
+    isAvailable(): Promise<boolean>;
+    protected ensureAvailable(): Promise<void>;
+    protected abstract getDownloadUrl(): string;
+    protected abstract setupEventListeners(): void;
+    protected abstract removeEventListeners(): void;
+    disconnect(): Promise<void>;
+}
+
+declare class MetaMaskAdapter extends BrowserWalletAdapter {
+    readonly type = WalletType.METAMASK;
+    readonly chainType = ChainType.EVM;
+    readonly name = "MetaMask";
+    readonly icon = "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg";
+    private walletClient;
+    private publicClient;
+    connect(chainId?: number): Promise<Account>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(typedData: any): Promise<string>;
+    switchChain(chainId: number): Promise<void>;
+    addChain(chainConfig: AddChainParams): Promise<void>;
+    readContract<T = any>(params: ContractReadParams): Promise<T>;
+    writeContract(params: ContractWriteParams): Promise<string>;
+    estimateGas(params: ContractWriteParams): Promise<bigint>;
+    waitForTransaction(txHash: string, confirmations?: number): Promise<TransactionReceipt>;
+    getProvider(): any;
+    getSigner(): WalletClient | null;
+    protected getBrowserProvider(): any | undefined;
+    protected getDownloadUrl(): string;
+    protected setupEventListeners(): void;
+    protected removeEventListeners(): void;
+    private handleAccountsChanged;
+    private handleChainChanged;
+    private handleDisconnect;
+    private getViemChain;
+}
+
+declare class TronLinkAdapter extends BrowserWalletAdapter {
+    readonly type = WalletType.TRONLINK;
+    readonly chainType = ChainType.TRON;
+    readonly name = "TronLink";
+    readonly icon = "https://www.tronlink.org/static/logoIcon.svg";
+    private static readonly TRON_MAINNET_CHAIN_ID;
+    connect(chainId?: number): Promise<Account>;
+    signMessage(message: string): Promise<string>;
+    getProvider(): any;
+    protected getBrowserProvider(): any | undefined;
+    private getTronWeb;
+    protected getDownloadUrl(): string;
+    protected setupEventListeners(): void;
+    protected removeEventListeners(): void;
+    private handleAccountsChanged;
+    private handleDisconnect;
+}
+
+declare class EVMPrivateKeyAdapter extends WalletAdapter {
+    readonly type = WalletType.PRIVATE_KEY;
+    readonly chainType = ChainType.EVM;
+    readonly name = "Private Key (EVM)";
+    private privateKey;
+    private walletClient;
+    private publicClient;
+    connect(chainId?: number): Promise<Account>;
+    disconnect(): Promise<void>;
+    isAvailable(): Promise<boolean>;
+    setPrivateKey(privateKey: string): void;
+    signMessage(message: string): Promise<string>;
+    signTypedData(typedData: any): Promise<string>;
+    switchChain(chainId: number): Promise<void>;
+    readContract<T = any>(params: ContractReadParams): Promise<T>;
+    writeContract(params: ContractWriteParams): Promise<string>;
+    estimateGas(params: ContractWriteParams): Promise<bigint>;
+    waitForTransaction(txHash: string, confirmations?: number): Promise<TransactionReceipt>;
+    getProvider(): any;
+    getSigner(): WalletClient | null;
+    private getViemChain;
+}
+
+interface AuthMessageParams {
+    domain: string;
+    nonce: string;
+    chainId: number;
+    timestamp: number;
+    statement?: string;
+}
+declare class AuthMessageGenerator {
+    private readonly domain;
+    constructor(domain: string);
+    generateAuthMessage(chainType: ChainType, nonce: string, chainId: number, timestamp?: number, statement?: string): string;
+    private generateEIP191Message;
+    private generateTIP191Message;
+    static generateNonce(): string;
+}
+
+declare class SignatureVerifier {
+    verifySignature(message: string, signature: string, expectedAddress: string, chainType: ChainType): Promise<boolean>;
+    private verifyEIP191Signature;
+    private verifyTIP191Signature;
+}
+
+declare class WalletDetector {
+    detectAllWallets(): Promise<WalletAvailability[]>;
+    detectWallet(walletType: WalletType): Promise<WalletAvailability>;
+    private isWalletAvailable;
+    private isMetaMaskAvailable;
+    private isTronLinkAvailable;
+    private isCoinbaseWalletAvailable;
+    waitForWallet(walletType: WalletType, timeout?: number): Promise<boolean>;
+}
+
+interface WalletMetadata {
+    type: WalletType;
+    name: string;
+    chainType: ChainType;
+    icon?: string;
+    downloadUrl?: string;
+    description?: string;
+}
+declare const SUPPORTED_WALLETS: Record<WalletType, WalletMetadata>;
+declare function getWalletMetadata(type: WalletType): WalletMetadata | undefined;
+declare function getEVMWallets(): WalletMetadata[];
+declare function getTronWallets(): WalletMetadata[];
+
+declare function createUniversalAddress(chainId: number, address: string): UniversalAddress;
+declare function parseUniversalAddress(universalAddress: UniversalAddress): {
+    chainId: number;
+    address: string;
+} | null;
+declare function isValidUniversalAddress(universalAddress: string): boolean;
+declare function getChainIdFromUniversalAddress(universalAddress: UniversalAddress): number | null;
+declare function getAddressFromUniversalAddress(universalAddress: UniversalAddress): string | null;
+declare function compareUniversalAddresses(a: UniversalAddress, b: UniversalAddress): boolean;
+
+declare function isValidEVMAddress(address: string): boolean;
+declare function formatEVMAddress(address: string): string;
+declare function compareEVMAddresses(a: string, b: string): boolean;
+declare function shortenAddress(address: string, chars?: number): string;
+
+declare function isValidTronAddress(address: string): boolean;
+declare function isValidTronHexAddress(address: string): boolean;
+declare function compareTronAddresses(a: string, b: string): boolean;
+declare function shortenTronAddress(address: string, chars?: number): string;
+
+interface ChainInfo {
+    id: number;
+    name: string;
+    chainType: ChainType;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    rpcUrls: string[];
+    blockExplorerUrls?: string[];
+    iconUrls?: string[];
+}
+declare const CHAIN_INFO: Record<number, ChainInfo>;
+declare function getChainInfo(chainId: number): ChainInfo | undefined;
+declare function getChainType(chainId: number): ChainType | undefined;
+declare function isEVMChain(chainId: number): boolean;
+declare function isTronChain(chainId: number): boolean;
+
+declare function validateAddress(address: string, chainType: ChainType): boolean;
+declare function validateAddressForChain(address: string, chainId: number): boolean;
+declare function isValidChainId(chainId: number): boolean;
+declare function isValidSignature(signature: string): boolean;
+declare function isValidTransactionHash(txHash: string, chainType: ChainType): boolean;
+
+declare function isHex(value: string): boolean;
+declare function toHex(value: string): string;
+declare function fromHex(hex: string): string;
+declare function numberToHex(value: number | bigint): string;
+declare function hexToNumber(hex: string): number;
+declare function ensureHexPrefix(value: string): string;
+declare function removeHexPrefix(value: string): string;
+
+export { type Account, AdapterRegistry, type AddChainParams, AuthMessageGenerator, type AuthMessageParams, BrowserWalletAdapter, CHAIN_INFO, type ChainInfo, ChainNotSupportedError, ChainType, ConfigurationError, type ConnectedWallet, ConnectionRejectedError, type ContractReadParams, type ContractWriteParams, EVMPrivateKeyAdapter, type IWalletAdapter, MetaMaskAdapter, MethodNotSupportedError, NetworkError, SUPPORTED_WALLETS, SignatureRejectedError, SignatureVerifier, type StorageData, TransactionFailedError, type TransactionReceipt, TronLinkAdapter, type UniversalAddress, WalletAdapter, type WalletAvailability, WalletDetector, type WalletHistoryRecord, WalletManager, type WalletManagerConfig, type WalletManagerEvents, type WalletMetadata, WalletNotAvailableError, WalletNotConnectedError, WalletSDKError, WalletState, WalletType, compareEVMAddresses, compareTronAddresses, compareUniversalAddresses, createUniversalAddress, WalletManager as default, ensureHexPrefix, formatEVMAddress, fromHex, getAddressFromUniversalAddress, getChainIdFromUniversalAddress, getChainInfo, getChainType, getEVMWallets, getTronWallets, getWalletMetadata, hexToNumber, isEVMChain, isHex, isTronChain, isValidChainId, isValidEVMAddress, isValidSignature, isValidTransactionHash, isValidTronAddress, isValidTronHexAddress, isValidUniversalAddress, numberToHex, parseUniversalAddress, removeHexPrefix, shortenAddress, shortenTronAddress, toHex, validateAddress, validateAddressForChain };