@enclave-hq/wallet-sdk 1.2.3 → 1.2.5

package/dist/index.d.mts

@@ -1,6 +1,9 @@
-import { ChainType as ChainType$2, ChainInfo as ChainInfo$1 } from '@enclave-hq/chain-utils';
-import EventEmitter from 'eventemitter3';
+import { W as WalletManagerEvents, a as WalletManagerConfig, b as WalletType, A as Account, C as ChainType$1, c as ConnectedWallet, I as IWalletAdapter, d as AddChainParams, T as TransactionReceipt, e as WalletAdapter, f as ContractReadParams, g as ContractWriteParams, h as WalletAvailability, U as UniversalAddress } from './wallet-adapter-DRd0xm3N.mjs';
+export { E as EVMTransaction, i as ISigner, S as StorageData, l as Transaction, k as TronTransaction, j as WalletHistoryRecord, m as WalletState } from './wallet-adapter-DRd0xm3N.mjs';
 import { WalletClient } from 'viem';
+import * as _enclave_hq_chain_utils from '@enclave-hq/chain-utils';
+import { ChainInfo as ChainInfo$1, ChainType as ChainType$2 } from '@enclave-hq/chain-utils';
+import 'eventemitter3';
 
 declare class TypedEventEmitter<TEvents extends Record<string, (...args: any[]) => void>> {
     private emitter;
@@ -11,161 +14,52 @@ declare class TypedEventEmitter<TEvents extends Record<string, (...args: any[])
     removeAllListeners<K extends keyof TEvents>(event?: K): this;
 }
 
-declare const ChainType$1: typeof ChainType$2;
-type ChainType$1 = ChainType$2;
-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$1;
-    isActive: boolean;
-    balance?: string;
-    name?: string;
-}
-interface ISigner {
-    signMessage(message: string): Promise<string>;
-    getAddress(): Promise<string>;
-}
-interface IWalletAdapter extends ISigner {
-    readonly type: WalletType;
-    readonly chainType: ChainType$1;
-    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: Transaction): 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;
-    maxFeePerGas?: string;
-    maxPriorityFeePerGas?: string;
-}
-interface EVMTransaction {
-    to: string;
-    value?: string | bigint;
-    data?: string;
-    gas?: string | bigint;
-    gasPrice?: string | bigint;
-    maxFeePerGas?: string | bigint;
-    maxPriorityFeePerGas?: string | bigint;
-    nonce?: number;
-    chainId?: number;
-}
-interface TronTransaction {
-    txID?: string;
-    raw_data?: any;
-    raw_data_hex?: string;
-    visible?: boolean;
-}
-type Transaction = EVMTransaction | TronTransaction;
-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$1;
-    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$1, account: Account | null, isPrimary: boolean) => void;
-    walletChainChanged: (chainType: ChainType$1, chainId: number, account: Account, isPrimary: boolean) => void;
-    walletDisconnected: (chainType: ChainType$1, isPrimary: boolean) => void;
-    primaryWalletSwitched: (newPrimary: Account, oldPrimary: Account | null, chainType: ChainType$1) => void;
-    error: (error: Error) => void;
-}
-interface WalletHistoryRecord {
-    universalAddress: UniversalAddress;
-    nativeAddress: string;
-    chainId: number;
-    chainType: ChainType$1;
-    walletType: WalletType;
-    lastConnected: number;
-    name?: string;
-}
-interface StorageData {
-    current: UniversalAddress | null;
-    primaryWalletType?: WalletType;
-    primaryChainId?: number;
-    history: WalletHistoryRecord[];
-}
-interface WalletAvailability {
-    walletType: WalletType;
-    chainType: ChainType$1;
-    isAvailable: boolean;
-    downloadUrl?: string;
-    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> {
@@ -174,8 +68,9 @@ declare class WalletManager extends TypedEventEmitter<WalletManagerEvents> {
     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 +80,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>;
@@ -192,6 +91,8 @@ declare class WalletManager extends TypedEventEmitter<WalletManagerEvents> {
         addChainIfNotExists?: boolean;
         chainConfig?: AddChainParams;
     }): Promise<Account>;
+    requestSwitchAccount(targetAddress?: string): Promise<Account>;
+    ensureAccount(targetAddress: string): Promise<Account>;
     readContract<T = any>(address: string, abi: any[], functionName: string, args?: any[], chainType?: ChainType$1): Promise<T>;
     writeContract(address: string, abi: any[], functionName: string, args?: any[], options?: {
         value?: string;
@@ -216,7 +117,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;
@@ -258,37 +160,6 @@ 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$1;
-    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>;
-    getAddress(): 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>;
@@ -306,12 +177,13 @@ 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>;
     switchChain(chainId: number): Promise<void>;
     addChain(chainConfig: AddChainParams): Promise<void>;
+    requestSwitchAccount(targetAddress?: string): Promise<Account>;
     readContract<T = any>(params: ContractReadParams): Promise<T>;
     writeContract(params: ContractWriteParams): Promise<string>;
     estimateGas(params: ContractWriteParams): Promise<bigint>;
@@ -328,13 +200,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>;
@@ -361,7 +275,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 +291,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 +659,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 { Account, AdapterRegistry, AddChainParams, AuthMessageGenerator, type AuthMessageParams, BrowserWalletAdapter, CHAIN_INFO, type ChainInfo, ChainNotSupportedError, ChainType$1 as ChainType, ConfigurationError, ConnectedWallet, ConnectionRejectedError, ContractReadParams, ContractWriteParams, DeepLinkAdapter, DeepLinkProviderType, DeepLinkWalletType, EVMPrivateKeyAdapter, type IDeepLinkProvider, IWalletAdapter, ImTokenDeepLinkProvider, MetaMaskAdapter, MetaMaskDeepLinkProvider, MethodNotSupportedError, NetworkError, OKXDeepLinkProvider, type QRCodeSignResult, QRCodeSignStatus, QRCodeSigner, type QRCodeSignerConfig, SUPPORTED_WALLETS, SignatureRejectedError, SignatureVerifier, TokenPocketDeepLinkProvider, TransactionFailedError, TransactionReceipt, TronDeepLinkAdapter, TronLinkAdapter, TronLinkDeepLinkProvider, UniversalAddress, WalletAdapter, WalletAvailability, WalletConnectAdapter, WalletDetector, WalletManager, WalletManagerConfig, WalletManagerEvents, type WalletMetadata, WalletNotAvailableError, WalletNotConnectedError, WalletSDKError, 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 };