@enclave-hq/wallet-sdk 1.0.0

package/dist/index.d.ts

@@ -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 };