@enclave-hq/wallet-sdk 1.0.0

package/dist/react/index.d.ts

@@ -0,0 +1,218 @@
+import React, { ReactNode } from 'react';
+
+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;
+}
+
+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;
+}
+
+interface WalletContextValue {
+    walletManager: WalletManager;
+    account: Account | null;
+    isConnected: boolean;
+    connectedWallets: ConnectedWallet[];
+    connect: (type: WalletType, chainId?: number) => Promise<Account>;
+    connectAdditional: (type: WalletType, chainId?: number) => Promise<Account>;
+    disconnect: () => Promise<void>;
+    switchPrimaryWallet: (chainType: ChainType) => Promise<Account>;
+    signMessage: (message: string) => Promise<string>;
+}
+interface WalletProviderProps {
+    children: ReactNode;
+    walletManager?: WalletManager;
+}
+declare function WalletProvider({ children, walletManager: externalWalletManager }: WalletProviderProps): React.JSX.Element;
+declare function useWallet(): WalletContextValue;
+
+interface UseAccountResult {
+    account: Account | null;
+    isConnected: boolean;
+    address: string | null;
+    chainId: number | null;
+    universalAddress: string | null;
+}
+declare function useAccount(): UseAccountResult;
+
+interface UseConnectResult {
+    connect: (type: WalletType, chainId?: number) => Promise<Account>;
+    connectAdditional: (type: WalletType, chainId?: number) => Promise<Account>;
+    isConnecting: boolean;
+    error: Error | null;
+}
+declare function useConnect(): UseConnectResult;
+
+interface UseDisconnectResult {
+    disconnect: () => Promise<void>;
+    isDisconnecting: boolean;
+    error: Error | null;
+}
+declare function useDisconnect(): UseDisconnectResult;
+
+interface UseSignMessageResult {
+    signMessage: (message: string) => Promise<string>;
+    isSigning: boolean;
+    error: Error | null;
+}
+declare function useSignMessage(): UseSignMessageResult;
+
+export { type UseAccountResult, type UseConnectResult, type UseDisconnectResult, type UseSignMessageResult, type WalletContextValue, WalletProvider, type WalletProviderProps, useAccount, useConnect, useDisconnect, useSignMessage, useWallet };