@enclave-hq/wallet-sdk 1.2.2 → 1.2.4

package/README.md

@@ -98,6 +98,52 @@ function YourApp() {
 }
 ```
 
+### QR Code Signing (扫码签名)
+
+```tsx
+import React, { useState } from 'react'
+import { useQRCodeSigner, QRCodeModal } from '@enclave-hq/wallet-sdk/react'
+
+function SignButton() {
+  const [showModal, setShowModal] = useState(false)
+  
+  const { qrCodeDataUrl, status, startSign, cancel, error } = useQRCodeSigner({
+    requestId: `sign-${Date.now()}`,
+    requestUrl: `https://example.com/sign?requestId=sign-${Date.now()}`,
+    pollUrl: 'https://api.example.com/sign/status',
+  })
+
+  const handleSign = async () => {
+    setShowModal(true)
+    try {
+      const signature = await startSign()
+      console.log('Signature:', signature)
+      setShowModal(false)
+    } catch (error) {
+      console.error('Sign failed:', error)
+    }
+  }
+
+  return (
+    <>
+      <button onClick={handleSign}>扫码签名</button>
+      
+      <QRCodeModal
+        isOpen={showModal}
+        onClose={() => {
+          cancel()
+          setShowModal(false)
+        }}
+        qrCodeDataUrl={qrCodeDataUrl}
+        status={status}
+        error={error}
+        title="使用钱包扫码签名"
+      />
+    </>
+  )
+}
+```
+
 ## 🎯 Core Concepts
 
 ### Universal Address
@@ -138,9 +184,11 @@ const wallets = walletManager.getConnectedWallets()
 |--------|------------|--------|
 | MetaMask | EVM | ✅ Supported |
 | TronLink | Tron | ✅ Supported |
-| WalletConnect | EVM | 🚧 Coming Soon |
+| WalletConnect | EVM | ✅ Supported |
+| WalletConnect Tron | Tron | ✅ Supported |
 | Coinbase Wallet | EVM | 🚧 Coming Soon |
 | Private Key | EVM/Tron | ✅ Dev Only |
+| QR Code Signing | EVM/Tron | ✅ Supported |
 
 ## 📖 Documentation
 
@@ -152,6 +200,8 @@ Full documentation is available in the `/docs` folder:
 - [Integration Guide](../docs/wallet-sdk/INTEGRATION.md)
 - [State Management](../docs/wallet-sdk/STATE_AND_ACCOUNT.md)
 - [Standards & Signing](../docs/wallet-sdk/STANDARDS.md)
+- [QR Code Signing](./docs/QR_CODE_SIGNING.md) - 二维码签名功能
+- [TRON Wallet Signing](./docs/TRON_WALLET_SIGNING.md) - TRON 钱包签名支持
 
 ## 🧪 Running the Example
 

package/dist/index.d.mts

@@ -1,6 +1,8 @@
+import * as _enclave_hq_chain_utils from '@enclave-hq/chain-utils';
 import { ChainType as ChainType$2, ChainInfo as ChainInfo$1 } from '@enclave-hq/chain-utils';
 import EventEmitter from 'eventemitter3';
 import { WalletClient } from 'viem';
+import { WalletConnectWallet } from '@tronweb3/walletconnect-tron';
 
 declare class TypedEventEmitter<TEvents extends Record<string, (...args: any[]) => void>> {
     private emitter;
@@ -19,7 +21,9 @@ declare enum WalletType {
     COINBASE_WALLET = "coinbase-wallet",
     TRONLINK = "tronlink",
     WALLETCONNECT_TRON = "walletconnect-tron",
-    PRIVATE_KEY = "private-key"
+    PRIVATE_KEY = "private-key",
+    DEEP_LINK_EVM = "deep-link-evm",
+    DEEP_LINK_TRON = "deep-link-tron"
 }
 declare enum WalletState {
     DISCONNECTED = "disconnected",
@@ -48,9 +52,10 @@ interface IWalletAdapter extends ISigner {
     readonly icon?: string;
     state: WalletState;
     currentAccount: Account | null;
-    connect(chainId?: number): Promise<Account>;
+    connect(chainId?: number | number[]): Promise<Account>;
     disconnect(): Promise<void>;
     isAvailable(): Promise<boolean>;
+    isConnected(): boolean;
     signMessage(message: string): Promise<string>;
     signTransaction?(transaction: Transaction): Promise<string>;
     signTypedData?(typedData: any): Promise<string>;
@@ -168,14 +173,63 @@ interface WalletAvailability {
     detected: boolean;
 }
 
+interface QRCodeSignerConfig {
+    requestId: string;
+    requestUrl: string;
+    pollUrl?: string;
+    pollInterval?: number;
+    timeout?: number;
+    pollFn?: (requestId: string) => Promise<QRCodeSignResult | null>;
+}
+interface QRCodeSignResult {
+    completed: boolean;
+    signature?: string;
+    error?: string;
+    signer?: string;
+}
+declare enum QRCodeSignStatus {
+    WAITING = "waiting",
+    PENDING = "pending",
+    SUCCESS = "success",
+    FAILED = "failed",
+    TIMEOUT = "timeout",
+    CANCELLED = "cancelled"
+}
+declare class QRCodeSigner {
+    private config;
+    private pollTimer;
+    private timeoutTimer;
+    private status;
+    private qrCodeDataUrl;
+    private result;
+    constructor(config: QRCodeSignerConfig);
+    generateQRCode(options?: {
+        width?: number;
+        margin?: number;
+        color?: {
+            dark?: string;
+            light?: string;
+        };
+    }): Promise<string>;
+    startPolling(onStatusChange?: (status: QRCodeSignStatus) => void, onResult?: (result: QRCodeSignResult) => void): Promise<string>;
+    private defaultPoll;
+    stopPolling(): void;
+    cancel(): void;
+    getStatus(): QRCodeSignStatus;
+    getQRCodeUrl(): string;
+    getResult(): QRCodeSignResult | null;
+    cleanup(): void;
+}
+
 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>;
+    hasAdapter(type: WalletType): boolean;
+    connect(type: WalletType, chainId?: number | number[]): Promise<Account>;
+    connectAdditional(type: WalletType, chainId?: number | number[]): Promise<Account>;
     connectWithPrivateKey(privateKey: string, chainId?: number): Promise<Account>;
     disconnect(): Promise<void>;
     disconnectAll(): Promise<void>;
@@ -185,6 +239,10 @@ declare class WalletManager extends TypedEventEmitter<WalletManagerEvents> {
     getWalletByChainType(chainType: ChainType$1): IWalletAdapter | null;
     signMessage(message: string): Promise<string>;
     signMessageWithChainType(message: string, chainType?: ChainType$1): Promise<string>;
+    createQRCodeSigner(message: string, config: Omit<QRCodeSignerConfig, 'requestId' | 'requestUrl'> & {
+        requestId: string;
+        requestUrl: string;
+    }): QRCodeSigner;
     signTypedData(typedData: any, chainType?: ChainType$1): Promise<string>;
     signTransaction(transaction: any): Promise<string>;
     signTransactionWithChainType(transaction: any, chainType?: ChainType$1): Promise<string>;
@@ -216,7 +274,8 @@ declare class WalletManager extends TypedEventEmitter<WalletManagerEvents> {
 
 declare class AdapterRegistry {
     private adapters;
-    constructor();
+    private config;
+    constructor(config?: WalletManagerConfig);
     private registerDefaultAdapters;
     register(type: WalletType, factory: () => IWalletAdapter): void;
     getAdapter(type: WalletType): IWalletAdapter | null;
@@ -265,9 +324,10 @@ declare abstract class WalletAdapter extends EventEmitter implements IWalletAdap
     readonly icon?: string;
     state: WalletState;
     currentAccount: Account | null;
-    abstract connect(chainId?: number): Promise<Account>;
+    abstract connect(chainId?: number | number[]): Promise<Account>;
     abstract disconnect(): Promise<void>;
     abstract isAvailable(): Promise<boolean>;
+    isConnected(): boolean;
     abstract signMessage(message: string): Promise<string>;
     getAddress(): Promise<string>;
     signTransaction?(_transaction: any): Promise<string>;
@@ -306,7 +366,7 @@ declare class MetaMaskAdapter extends BrowserWalletAdapter {
     readonly icon = "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg";
     private walletClient;
     private publicClient;
-    connect(chainId?: number): Promise<Account>;
+    connect(chainId?: number | number[]): Promise<Account>;
     signMessage(message: string): Promise<string>;
     signTypedData(typedData: any): Promise<string>;
     signTransaction(transaction: any): Promise<string>;
@@ -328,13 +388,55 @@ declare class MetaMaskAdapter extends BrowserWalletAdapter {
     private getViemChain;
 }
 
+declare class WalletConnectAdapter extends WalletAdapter {
+    readonly type = WalletType.WALLETCONNECT;
+    readonly chainType = ChainType.EVM;
+    readonly name = "WalletConnect";
+    readonly icon = "https://avatars.githubusercontent.com/u/37784886";
+    private provider;
+    private walletClient;
+    private publicClient;
+    private projectId;
+    private supportedChains;
+    private static providerInstance;
+    private static providerProjectId;
+    private static providerChains;
+    private static isInitializing;
+    private static initPromise;
+    constructor(projectId: string);
+    isAvailable(): Promise<boolean>;
+    private isTelegramMiniApp;
+    private getTelegramWebApp;
+    private closeTelegramDeepLinkPopup;
+    connect(chainId?: number | number[]): Promise<Account>;
+    disconnect(): Promise<void>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(typedData: any): Promise<string>;
+    signTransaction(transaction: any): Promise<string>;
+    getSupportedChains(): number[];
+    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 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 = "TronWeb";
     readonly icon = "https://www.tronlink.org/static/logoIcon.svg";
     private static readonly TRON_MAINNET_CHAIN_ID;
-    connect(chainId?: number): Promise<Account>;
+    connect(chainId?: number | number[]): Promise<Account>;
     signMessage(message: string): Promise<string>;
     signTransaction(transaction: any): Promise<string>;
     readContract<T = any>(params: ContractReadParams): Promise<T>;
@@ -354,6 +456,36 @@ declare class TronLinkAdapter extends BrowserWalletAdapter {
     private handleDisconnect;
 }
 
+declare class WalletConnectTronAdapter extends WalletAdapter {
+    readonly type = WalletType.WALLETCONNECT_TRON;
+    readonly chainType = ChainType.TRON;
+    readonly name = "WalletConnect (Tron)";
+    readonly icon = "https://avatars.githubusercontent.com/u/37784886";
+    private wallet;
+    private projectId;
+    private currentAddress;
+    private static readonly TRON_MAINNET_CHAIN_ID;
+    private static walletInstance;
+    private static walletProjectId;
+    constructor(projectId: string);
+    isAvailable(): Promise<boolean>;
+    private isTelegramMiniApp;
+    restoreSession(chainId?: number | number[]): Promise<Account | null>;
+    private initializeWallet;
+    connect(chainId?: number | number[]): Promise<Account>;
+    disconnect(): Promise<void>;
+    signMessage(message: string): Promise<string>;
+    signTransaction(transaction: any): Promise<string>;
+    readContract<T = any>(_params: ContractReadParams): Promise<T>;
+    writeContract(_params: ContractWriteParams): Promise<string>;
+    estimateGas(_params: ContractWriteParams): Promise<bigint>;
+    waitForTransaction(_txHash: string, _confirmations?: number): Promise<TransactionReceipt>;
+    private setupEventListeners;
+    private removeEventListeners;
+    getProvider(): WalletConnectWallet | null;
+    static clearWalletInstance(): void;
+}
+
 declare class EVMPrivateKeyAdapter extends WalletAdapter {
     readonly type = WalletType.PRIVATE_KEY;
     readonly chainType = ChainType.EVM;
@@ -361,7 +493,7 @@ declare class EVMPrivateKeyAdapter extends WalletAdapter {
     private privateKey;
     private walletClient;
     private publicClient;
-    connect(chainId?: number): Promise<Account>;
+    connect(chainId?: number | number[]): Promise<Account>;
     disconnect(): Promise<void>;
     isAvailable(): Promise<boolean>;
     setPrivateKey(privateKey: string): void;
@@ -377,6 +509,277 @@ declare class EVMPrivateKeyAdapter extends WalletAdapter {
     private getViemChain;
 }
 
+declare enum DeepLinkProviderType {
+    TOKENPOCKET = "tokenpocket",
+    TRONLINK = "tronlink",
+    IMTOKEN = "imtoken",
+    METAMASK = "metamask",
+    OKX = "okx"
+}
+interface DeepLinkAdapterConfig {
+    providerType: DeepLinkProviderType;
+    callbackUrl?: string;
+    callbackSchema?: string;
+}
+declare class DeepLinkAdapter extends WalletAdapter {
+    readonly type: WalletType;
+    readonly chainType: ChainType$1;
+    readonly name: string;
+    readonly icon: string;
+    private provider;
+    private currentChainId;
+    private currentChainType;
+    private static pendingActions;
+    constructor(config: DeepLinkAdapterConfig);
+    private createProvider;
+    private setupCallbackHandler;
+    isAvailable(): Promise<boolean>;
+    connect(chainId?: number | number[]): Promise<Account>;
+    disconnect(): Promise<void>;
+    signMessage(message: string): Promise<string>;
+    signTransaction(transaction: any): Promise<string>;
+    getProvider(): any;
+    static handleCallback(): void;
+    protected setAccount(account: Account | null): void;
+    protected emitDisconnected(): void;
+}
+
+interface DeepLinkSignMessageParams {
+    message: string;
+    chainId: number;
+    chainType: ChainType$1;
+}
+interface DeepLinkSignTransactionParams {
+    transaction: any;
+    chainId: number;
+    chainType: ChainType$1;
+}
+interface DeepLinkConnectParams {
+    chainId: number;
+    chainType: ChainType$1;
+}
+interface IDeepLinkProvider {
+    readonly name: string;
+    readonly icon: string;
+    readonly supportedChainTypes: ChainType$1[];
+    isAvailable(): Promise<boolean>;
+    buildSignMessageLink(params: DeepLinkSignMessageParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildSignTransactionLink(params: DeepLinkSignTransactionParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildConnectLink?(params: DeepLinkConnectParams): {
+        url: string;
+        actionId?: string;
+    };
+    parseCallbackResult(urlParams: URLSearchParams): {
+        actionId: string | null;
+        result: any | null;
+        error: string | null;
+    };
+    getDefaultCallbackSchema?(): string;
+}
+
+declare class TokenPocketDeepLinkProvider implements IDeepLinkProvider {
+    readonly name = "TokenPocket";
+    readonly icon = "https://tokenpocket.pro/icon.png";
+    readonly supportedChainTypes: _enclave_hq_chain_utils.ChainType[];
+    private callbackUrl?;
+    private callbackSchema?;
+    constructor(options?: {
+        callbackUrl?: string;
+        callbackSchema?: string;
+    });
+    isAvailable(): Promise<boolean>;
+    private generateActionId;
+    private getCallbackConfig;
+    private getBlockchainConfig;
+    buildSignMessageLink(params: DeepLinkSignMessageParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildSignTransactionLink(params: DeepLinkSignTransactionParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildConnectLink(params: DeepLinkConnectParams): {
+        url: string;
+        actionId?: string;
+    };
+    parseCallbackResult(urlParams: URLSearchParams): {
+        actionId: string | null;
+        result: any | null;
+        error: string | null;
+    };
+    getDefaultCallbackSchema(): string;
+}
+
+declare class TronLinkDeepLinkProvider implements IDeepLinkProvider {
+    readonly name = "TronLink";
+    readonly icon = "https://www.tronlink.org/static/logoIcon.svg";
+    readonly supportedChainTypes: _enclave_hq_chain_utils.ChainType[];
+    isAvailable(): Promise<boolean>;
+    buildSignMessageLink(params: DeepLinkSignMessageParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildSignTransactionLink(params: DeepLinkSignTransactionParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildConnectLink(params: DeepLinkConnectParams): {
+        url: string;
+        actionId?: string;
+    };
+    parseCallbackResult(_urlParams: URLSearchParams): {
+        actionId: string | null;
+        result: any | null;
+        error: string | null;
+    };
+}
+
+declare class ImTokenDeepLinkProvider implements IDeepLinkProvider {
+    readonly name = "ImToken";
+    readonly icon = "https://token.im/static/img/logo.png";
+    readonly supportedChainTypes: _enclave_hq_chain_utils.ChainType[];
+    private callbackUrl?;
+    private callbackSchema?;
+    constructor(options?: {
+        callbackUrl?: string;
+        callbackSchema?: string;
+    });
+    isAvailable(): Promise<boolean>;
+    private generateActionId;
+    private getCallbackConfig;
+    buildSignMessageLink(params: DeepLinkSignMessageParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildSignTransactionLink(params: DeepLinkSignTransactionParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildConnectLink(params: DeepLinkConnectParams): {
+        url: string;
+        actionId?: string;
+    };
+    parseCallbackResult(urlParams: URLSearchParams): {
+        actionId: string | null;
+        result: any | null;
+        error: string | null;
+    };
+    getDefaultCallbackSchema(): string;
+}
+
+declare class MetaMaskDeepLinkProvider implements IDeepLinkProvider {
+    readonly name = "MetaMask";
+    readonly icon = "https://upload.wikimedia.org/wikipedia/commons/3/36/MetaMask_Fox.svg";
+    readonly supportedChainTypes: _enclave_hq_chain_utils.ChainType[];
+    isAvailable(): Promise<boolean>;
+    buildSignMessageLink(params: DeepLinkSignMessageParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildSignTransactionLink(params: DeepLinkSignTransactionParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildConnectLink(params: DeepLinkConnectParams): {
+        url: string;
+        actionId?: string;
+    };
+    parseCallbackResult(urlParams: URLSearchParams): {
+        actionId: string | null;
+        result: any | null;
+        error: string | null;
+    };
+    getDefaultCallbackSchema(): string;
+}
+
+declare class OKXDeepLinkProvider implements IDeepLinkProvider {
+    readonly name = "OKX";
+    readonly icon = "https://www.okx.com/favicon.ico";
+    readonly supportedChainTypes: _enclave_hq_chain_utils.ChainType[];
+    isAvailable(): Promise<boolean>;
+    buildSignMessageLink(params: DeepLinkSignMessageParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildSignTransactionLink(params: DeepLinkSignTransactionParams): {
+        url: string;
+        actionId: string;
+        callbackSchema?: string;
+        callbackUrl?: string;
+    };
+    buildConnectLink(params: DeepLinkConnectParams): {
+        url: string;
+        actionId?: string;
+    };
+    parseCallbackResult(urlParams: URLSearchParams): {
+        actionId: string | null;
+        result: any | null;
+        error: string | null;
+    };
+    getDefaultCallbackSchema(): string;
+}
+
+declare enum DeepLinkWalletType {
+    TOKENPOCKET = "tokenpocket",
+    TRONLINK = "tronlink"
+}
+declare class TronDeepLinkAdapter extends WalletAdapter {
+    readonly type = WalletType.TRONLINK;
+    readonly chainType = ChainType.TRON;
+    readonly name: string;
+    readonly icon: string;
+    private walletType;
+    private callbackUrl?;
+    private callbackSchema?;
+    private pendingActions;
+    private static readonly TRON_MAINNET_CHAIN_ID;
+    constructor(walletType?: DeepLinkWalletType, options?: {
+        callbackUrl?: string;
+        callbackSchema?: string;
+    });
+    private setupCallbackHandler;
+    private checkCallbackFromUrl;
+    isAvailable(): Promise<boolean>;
+    connect(chainId?: number | number[]): Promise<Account>;
+    disconnect(): Promise<void>;
+    signMessage(message: string): Promise<string>;
+    signTransaction(transaction: any): Promise<string>;
+    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;
+}
+
 interface AuthMessageParams {
     domain: string;
     nonce: string;
@@ -474,4 +877,4 @@ 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$1 as ChainType, ConfigurationError, type ConnectedWallet, ConnectionRejectedError, type ContractReadParams, type ContractWriteParams, EVMPrivateKeyAdapter, type EVMTransaction, type ISigner, type IWalletAdapter, MetaMaskAdapter, MethodNotSupportedError, NetworkError, SUPPORTED_WALLETS, SignatureRejectedError, SignatureVerifier, type StorageData, type Transaction, TransactionFailedError, type TransactionReceipt, TronLinkAdapter, type TronTransaction, 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 };
+export { type Account, AdapterRegistry, type AddChainParams, AuthMessageGenerator, type AuthMessageParams, BrowserWalletAdapter, CHAIN_INFO, type ChainInfo, ChainNotSupportedError, ChainType$1 as ChainType, ConfigurationError, type ConnectedWallet, ConnectionRejectedError, type ContractReadParams, type ContractWriteParams, DeepLinkAdapter, DeepLinkProviderType, DeepLinkWalletType, EVMPrivateKeyAdapter, type EVMTransaction, type IDeepLinkProvider, type ISigner, type IWalletAdapter, ImTokenDeepLinkProvider, MetaMaskAdapter, MetaMaskDeepLinkProvider, MethodNotSupportedError, NetworkError, OKXDeepLinkProvider, type QRCodeSignResult, QRCodeSignStatus, QRCodeSigner, type QRCodeSignerConfig, SUPPORTED_WALLETS, SignatureRejectedError, SignatureVerifier, type StorageData, TokenPocketDeepLinkProvider, type Transaction, TransactionFailedError, type TransactionReceipt, TronDeepLinkAdapter, TronLinkAdapter, TronLinkDeepLinkProvider, type TronTransaction, type UniversalAddress, WalletAdapter, type WalletAvailability, WalletConnectAdapter, WalletConnectTronAdapter, 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 };