@tomo-inc/inject-providers 0.0.13 → 0.0.15

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import { EventEmitter } from 'events';
+import { ChainTypeEnum } from '@tomo-inc/wallet-utils';
 import { JsonRpcRequest, JsonRpcResponse } from 'json-rpc-engine';
 import { Cluster, PublicKey, VersionedTransaction, Transaction } from '@solana/web3.js';
-import { TronWeb } from 'tronweb';
-import { Transaction as Transaction$1 } from 'tronweb/lib/esm/types/Transaction';
+import { TronWeb as TronWeb$1 } from 'tronweb';
+import { Transaction as Transaction$1, SignedTransaction } from 'tronweb/lib/esm/types/Transaction';
+import { TronLinkWallet, TronWeb } from '@tronweb3/tronwallet-adapter-tronlink';
 
 interface IProductInfo {
     name: string;
@@ -21,6 +23,32 @@ type Balance = {
     unconfirmed: number;
     total: number;
 };
+type SignMessageType = "ecdsa" | "bip322-simple";
+interface IBitcoinProvider {
+    type: ChainTypeEnum.BITCOIN;
+    connect: () => Promise<any>;
+    disconnect: () => Promise<any>;
+    requestAccounts: () => Promise<any>;
+    getAccounts: () => Promise<any>;
+    getPublicKey: () => Promise<any>;
+    getBalance: () => Promise<any>;
+    getTransactionStatus: (params: {
+        txId: string;
+    }) => Promise<any>;
+    signMessage: (text: string, type: SignMessageType) => Promise<any>;
+    getNetwork: () => Promise<any>;
+    switchNetwork: (network: Network) => Promise<any>;
+    getChain: () => Promise<any>;
+    switchChain: (chainId: any) => Promise<any>;
+    networkChanged?: (network: Network) => Promise<any>;
+    chainChanged?: (chainId: ChainId) => Promise<any>;
+    signPsbt: (psbtHex: string, options?: any) => Promise<any>;
+    signPsbts?: (psbtHexs: string[], options?: any[]) => Promise<any>;
+    signTx: (rawtx: string) => Promise<any>;
+    pushTx: (rawtx: string) => Promise<any>;
+    sendTransaction: (params: any) => Promise<any>;
+    sendBitcoin: (rawtx: string) => Promise<any>;
+}
 
 interface StateProvider$3 {
     accounts: string[] | null;
@@ -29,7 +57,8 @@ interface StateProvider$3 {
     initialized: boolean;
     isPermanentlyDisconnected: boolean;
 }
-declare class BtcProvider extends EventEmitter {
+declare class BitcoinProvider extends EventEmitter implements IBitcoinProvider {
+    type: ChainTypeEnum.BITCOIN;
     _selectedAddress: string | null;
     _isConnected: boolean;
     _initialized: boolean;
@@ -70,7 +99,7 @@ declare class BtcProvider extends EventEmitter {
     getTransactionStatus: ({ txId }: {
         txId: string;
     }) => Promise<any>;
-    signMessage: (text: string, type?: "ecdsa" | "bip322-simple") => Promise<string>;
+    signMessage: (text: string, type?: SignMessageType) => Promise<string>;
     getNetwork: () => Promise<any>;
     switchNetwork: (network: Network) => Promise<any>;
     getChain: () => Promise<any>;
@@ -83,6 +112,311 @@ declare class BtcProvider extends EventEmitter {
     }) => Promise<string>;
     signTx: (rawtx: string) => Promise<any>;
     pushTx: (rawtx: string) => Promise<string>;
+    sendTransaction: (params: any) => Promise<any>;
+}
+
+/**
+ * Balance response interface
+ */
+interface IDogecoinBalance {
+    confirmed: number;
+    unconfirmed: number;
+    total: number;
+}
+/**
+ * Transaction status response interface
+ */
+interface ITransactionStatus {
+    status: string;
+    confirmations: number;
+}
+/**
+ * Signed message response interface
+ */
+interface ISignedMessage {
+    signedMessage: string;
+}
+/**
+ * Decrypted message response interface
+ */
+interface IDecryptedMessage {
+    decryptedMessage: string;
+}
+/**
+ * PSBT request parameters interface
+ */
+interface IRequestPsbtParams {
+    rawTx: string;
+    indexes?: [];
+    feeOnly?: boolean;
+    signOnly?: boolean;
+    partial?: boolean;
+    sighashType?: string;
+}
+/**
+ * PSBT response interface
+ */
+interface IPsbtResponse {
+    signedRawTx?: string;
+    txId?: string;
+}
+/**
+ * Send options interface
+ */
+interface ISendOptions {
+    feeRate?: number;
+    memo?: string;
+}
+/**
+ * Connection status response interface
+ */
+interface IConnectionStatus {
+    connected: boolean;
+    address: string;
+    selectedWalletAddress: string;
+}
+/**
+ * DRC20 balance response interface
+ */
+interface IDRC20Balance {
+    availableBalance: number;
+    transferableBalance: number;
+    ticker: string;
+    address: string;
+}
+/**
+ * Transferable DRC20 response interface
+ */
+interface ITransferableDRC20 {
+    inscriptions: any[];
+    ticker: string;
+    address: string;
+}
+/**
+ * DRC20 transaction response interface
+ */
+interface IDRC20Transaction {
+    txId: string;
+    ticker: string;
+    amount: number;
+}
+/**
+ * Dunes balance response interface
+ */
+interface IDunesBalance {
+    balance: number;
+    ticker: string;
+}
+/**
+ * Main interface for DogecoinProvider
+ * Extends EventEmitter to support event handling
+ */
+interface IDogecoinProvider extends EventEmitter {
+    type: ChainTypeEnum.DOGECOIN;
+    rdns: string;
+    name: string;
+    /**
+     * Connect to the wallet
+     * @returns Promise resolving to connection result with address, approved, balance, publicKey
+     */
+    connect(): Promise<any>;
+    /**
+     * Disconnect from the wallet
+     * @returns Promise resolving to disconnect result with disconnected status
+     */
+    disconnect(): Promise<any>;
+    /**
+     * Get connection status
+     * @returns Promise resolving to connection status with connected, address, selectedWalletAddress
+     */
+    getConnectionStatus(): Promise<IConnectionStatus>;
+    /**
+     * Request accounts from the wallet
+     * @returns Promise resolving to array of account addresses
+     */
+    requestAccounts(): Promise<string[]>;
+    /**
+     * Get current accounts
+     * @returns Promise resolving to array of account addresses
+     */
+    getAccounts(): Promise<string[]>;
+    /**
+     * Get public key
+     * @returns Promise resolving to public key string
+     */
+    getPublicKey(): Promise<string>;
+    /**
+     * Get balance
+     * @returns Promise resolving to balance object with confirmed, unconfirmed, and total
+     */
+    getBalance(): Promise<IDogecoinBalance>;
+    /**
+     * Get transaction status
+     * @param params - Transaction status parameters
+     * @param params.txId - Transaction ID
+     * @returns Promise resolving to transaction status
+     */
+    getTransactionStatus(params: {
+        txId: string;
+    }): Promise<ITransactionStatus>;
+    /**
+     * Request a transaction
+     * @param params - Transaction parameters
+     * @param params.recipientAddress - Recipient address
+     * @param params.dogeAmount - Amount in DOGE
+     * @returns Promise resolving to transaction result with txId
+     */
+    requestTransaction(params: {
+        recipientAddress: string;
+        dogeAmount: number;
+    }): Promise<{
+        txId: string;
+    }>;
+    /**
+     * Send DOGE
+     * @param toAddress - Recipient address
+     * @param satoshis - Amount in satoshis (optional)
+     * @param options - Send options (optional)
+     * @returns Promise resolving to transaction ID
+     */
+    send(toAddress: string, satoshis?: number, options?: ISendOptions): Promise<string>;
+    /**
+     * Send DOGE (alias for send)
+     * @param toAddress - Recipient address
+     * @param satoshis - Amount in satoshis (optional)
+     * @param options - Send options (optional)
+     * @returns Promise resolving to transaction ID
+     */
+    sendDogecoin(toAddress: string, satoshis?: number, options?: ISendOptions): Promise<string>;
+    /**
+     * Request signed message
+     * @param params - Sign message parameters
+     * @param params.message - Message to sign
+     * @param params.type - Message type (optional)
+     * @returns Promise resolving to signed message result
+     */
+    requestSignedMessage(params: {
+        message: string;
+        type?: string;
+    }): Promise<ISignedMessage>;
+    /**
+     * Sign message
+     * @param message - Message to sign
+     * @param type - Message type (optional)
+     * @returns Promise resolving to signed message string
+     */
+    signMessage(message: string, type?: string): Promise<string>;
+    /**
+     * Request decrypted message
+     * @param params - Decrypt message parameters
+     * @param params.message - Message to decrypt
+     * @returns Promise resolving to decrypted message result
+     */
+    requestDecryptedMessage(params: {
+        message: string;
+    }): Promise<IDecryptedMessage>;
+    /**
+     * Request PSBT
+     * @param params - PSBT request parameters
+     * @returns Promise resolving to PSBT result with signedRawTx and/or txId
+     */
+    requestPsbt(params: IRequestPsbtParams): Promise<IPsbtResponse>;
+    /**
+     * Sign PSBT
+     * @param psbtHex - PSBT hex string
+     * @param options - Sign options (optional)
+     * @returns Promise resolving to signed PSBT hex string
+     */
+    signPsbt(psbtHex: string, options?: any): Promise<string>;
+    /**
+     * Sign multiple PSBTs
+     * @param psbtHexs - Array of PSBT hex strings
+     * @param options - Sign options (optional)
+     * @returns Promise resolving to signed PSBTs
+     */
+    signPsbts(psbtHexs: string[], options?: any): Promise<any>;
+    /**
+     * Get DRC20 balances
+     * @param address - Address to query
+     * @param ticker - Token ticker (optional)
+     * @returns Promise resolving to DRC20 balances
+     */
+    getDRC20Balances(address: string, ticker?: string): Promise<any>;
+    /**
+     * Get DRC20 balance
+     * @param params - Balance query parameters
+     * @param params.ticker - Token ticker (optional)
+     * @returns Promise resolving to DRC20 balance
+     */
+    getDRC20Balance(params: {
+        ticker?: string;
+    }): Promise<IDRC20Balance>;
+    /**
+     * Get transferable DRC20
+     * @param params - Transferable query parameters
+     * @param params.ticker - Token ticker (optional)
+     * @returns Promise resolving to transferable DRC20
+     */
+    getTransferableDRC20(params: {
+        ticker?: string;
+    }): Promise<ITransferableDRC20>;
+    /**
+     * Request available DRC20 transaction
+     * @param params - Transaction parameters
+     * @param params.ticker - Token ticker
+     * @param params.amount - Amount to transfer
+     * @returns Promise resolving to DRC20 transaction result
+     */
+    requestAvailableDRC20Transaction(params: {
+        ticker: string;
+        amount: number;
+    }): Promise<IDRC20Transaction>;
+    /**
+     * Request inscription transaction
+     * @param params - Inscription transaction parameters
+     * @param params.location - Inscription location
+     * @param params.recipientAddress - Recipient address
+     * @returns Promise resolving to transaction result with txId
+     */
+    requestInscriptionTransaction(params: {
+        location: string;
+        recipientAddress: string;
+    }): Promise<{
+        txId: string;
+    }>;
+    /**
+     * Get Dunes balance
+     * @param params - Balance query parameters
+     * @param params.ticker - Token ticker
+     * @returns Promise resolving to Dunes balance
+     */
+    getDunesBalance(params: {
+        ticker: string;
+    }): Promise<IDunesBalance>;
+    /**
+     * Request Dunes transaction
+     * @param params - Transaction parameters
+     * @param params.ticker - Token ticker
+     * @param params.amount - Amount to transfer
+     * @param params.recipientAddress - Recipient address
+     * @returns Promise resolving to transaction result
+     */
+    requestDunesTransaction(params: {
+        ticker: string;
+        amount: number;
+        recipientAddress: string;
+    }): Promise<any>;
+    /**
+     * Generic request method
+     * @param params - Request parameters
+     * @param params.method - RPC method name
+     * @param params.params - Method parameters
+     * @returns Promise resolving to request result
+     */
+    request(params: {
+        method: string;
+        params: any;
+    }): Promise<any>;
 }
 
 interface StateProvider$2 {
@@ -92,7 +426,8 @@ interface StateProvider$2 {
     initialized: boolean;
     isPermanentlyDisconnected: boolean;
 }
-declare class DogecoinProvider extends EventEmitter {
+declare class DogecoinProvider extends EventEmitter implements IDogecoinProvider {
+    type: ChainTypeEnum.DOGECOIN;
     _selectedAddress: string | null;
     _network: string | null;
     _isConnected: boolean;
@@ -217,7 +552,158 @@ interface SendSyncJsonRpcRequest extends JsonRpcRequest<unknown> {
     method: "eth_accounts" | "eth_coinbase" | "eth_uninstallFilter" | "net_version";
 }
 
-declare class EvmProvider extends EventEmitter {
+/**
+ * Connect event data interface
+ */
+interface IConnectEvent {
+    chainId?: string;
+}
+/**
+ * Disconnect event data interface
+ */
+interface IDisconnectEvent {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/**
+ * Main interface for EvmProvider
+ * Extends EventEmitter to support event handling
+ * Implements EIP-1193 standard
+ */
+interface IEvmProvider extends EventEmitter {
+    type: ChainTypeEnum.EVM;
+    /**
+     * The chain ID of the currently connected Ethereum chain.
+     * See https://chainid.network for more information.
+     */
+    chainId: string | null;
+    /**
+     * The user's currently selected Ethereum address.
+     * If null, wallet is either locked or the user has not permitted any
+     * addresses to be viewed.
+     */
+    selectedAddress: string | null;
+    /**
+     * Provider name
+     */
+    name: string;
+    /**
+     * Provider icon
+     */
+    icon: string;
+    /**
+     * Returns whether the provider can process RPC requests.
+     * @returns true if connected, false otherwise
+     */
+    isConnected(): boolean;
+    /**
+     * Submits an RPC request for the given method, with the given params.
+     * Resolves with the result of the method call, or rejects on error.
+     *
+     * @param args - The RPC request arguments.
+     * @param args.method - The RPC method name.
+     * @param args.params - The parameters for the RPC method.
+     * @returns A Promise that resolves with the result of the RPC method,
+     * or rejects if an error is encountered.
+     */
+    request<T = unknown>(args: RequestArguments): Promise<Maybe<T>>;
+    /**
+     * Connect to the wallet
+     * Equivalent to: ethereum.request('eth_requestAccounts')
+     * @returns Promise resolving to array of account addresses
+     */
+    connect(): Promise<string[]>;
+    /**
+     * Disconnect from the wallet
+     * @returns Promise resolving to boolean indicating disconnect status
+     */
+    disconnect(): Promise<boolean>;
+    /**
+     * Equivalent to: ethereum.request('eth_requestAccounts')
+     * @deprecated Use request({ method: 'eth_requestAccounts' }) instead.
+     * @returns Promise resolving to array of addresses
+     */
+    enable(): Promise<string[]>;
+    /**
+     * Submits an RPC request for the given method, with the given params.
+     * @deprecated Use request() instead.
+     * @param method - The method to request.
+     * @param params - Any params for the method.
+     * @returns A Promise that resolves with the JSON-RPC response object for the request.
+     */
+    send<T>(method: string, params?: T[]): Promise<JsonRpcResponse<T>>;
+    /**
+     * Submits an RPC request per the given JSON-RPC request object.
+     * @deprecated Use request() instead.
+     * @param payload - A JSON-RPC request object.
+     * @param callback - An error-first callback that will receive the JSON-RPC response object.
+     */
+    send<T>(payload: JsonRpcRequest<unknown>, callback: (error: Error | null, result?: JsonRpcResponse<T>) => void): void;
+    /**
+     * Accepts a JSON-RPC request object, and synchronously returns the cached result
+     * for the given method. Only supports 4 specific RPC methods.
+     * @deprecated Use request() instead.
+     * @param payload - A JSON-RPC request object.
+     * @returns A JSON-RPC response object.
+     */
+    send<T>(payload: SendSyncJsonRpcRequest): JsonRpcResponse<T>;
+    /**
+     * Adds a listener for the specified event.
+     * @param eventName - Event name
+     * @param listener - Event listener function
+     * @returns This instance for chaining
+     */
+    on(eventName: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Adds a one-time listener for the specified event.
+     * @param eventName - Event name
+     * @param listener - Event listener function
+     * @returns This instance for chaining
+     */
+    once(eventName: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Emitted when the provider connects to a chain.
+     * @event
+     */
+    on(event: "connect", listener: (connectInfo: IConnectEvent) => void): this;
+    /**
+     * Emitted when the provider disconnects from a chain.
+     * @event
+     */
+    on(event: "disconnect", listener: (error: IDisconnectEvent) => void): this;
+    /**
+     * Emitted when the chain ID changes.
+     * @event
+     */
+    on(event: "chainChanged", listener: (chainId: string) => void): this;
+    /**
+     * Emitted when accounts change.
+     * @event
+     */
+    on(event: "accountsChanged", listener: (accounts: string[]) => void): this;
+    /**
+     * Emitted when the connection closes (deprecated).
+     * @event
+     * @deprecated
+     */
+    on(event: "close", listener: (error: IDisconnectEvent) => void): this;
+    /**
+     * Emitted when data is received (deprecated).
+     * @event
+     * @deprecated
+     */
+    on(event: "data", listener: (payload: unknown) => void): this;
+    /**
+     * Emitted when the network changes (deprecated).
+     * @event
+     * @deprecated
+     */
+    on(event: "networkChanged", listener: (networkId: string) => void): this;
+}
+
+declare class EvmProvider extends EventEmitter implements IEvmProvider {
+    type: ChainTypeEnum.EVM;
     private readonly _log;
     private _state;
     private _rpcEngine;
@@ -282,7 +768,7 @@ declare class EvmProvider extends EventEmitter {
      *   addListener, on, once, prependListener, prependOnceListener
      */
     addListener(eventName: string, listener: (...args: unknown[]) => void): this;
-    on(eventName: string, listener: (...args: unknown[]) => void): this;
+    on(eventName: string, listener: (...args: any[]) => void): this;
     once(eventName: string, listener: (...args: unknown[]) => void): this;
     prependListener(eventName: string, listener: (...args: unknown[]) => void): this;
     prependOnceListener(eventName: string, listener: (...args: unknown[]) => void): this;
@@ -443,6 +929,7 @@ interface StateProvider$1 {
     isPermanentlyDisconnected: boolean;
 }
 declare class PhantomProvider extends EventEmitter {
+    chainType: ChainTypeEnum;
     _isUnlocked: boolean;
     name: string;
     icon: string;
@@ -488,6 +975,17 @@ declare class PhantomProvider extends EventEmitter {
     sendToken: (tx: OriginTransaction) => Promise<any>;
 }
 
+interface ITomoTronProvider extends TronLinkWallet {
+    type: ChainTypeEnum.TRON;
+    tronWeb: TronWeb;
+    address: string | null;
+    connect(options?: Record<string, unknown>): Promise<void | any>;
+    disconnect(): Promise<void | any>;
+    signMessage(message: string, privateKey?: string): Promise<any>;
+    signTransaction(transaction: Transaction$1, privateKey?: string): Promise<SignedTransaction>;
+    switchChain?: (chainId: string) => Promise<void>;
+}
+
 interface StateProvider {
     accounts: any[] | null;
     isConnected: boolean;
@@ -495,12 +993,14 @@ interface StateProvider {
     initialized: boolean;
     isPermanentlyDisconnected: boolean;
 }
-declare class TomoTronProvider extends EventEmitter {
+declare class TomoTronProvider extends EventEmitter implements ITomoTronProvider {
+    type: ChainTypeEnum.TRON;
     _isUnlocked: boolean;
     name: string;
     icon: string;
     ready: boolean;
-    tronWeb: TronWeb | null;
+    tronWeb: TronWeb$1;
+    address: string;
     sendRequest: (chainType: string, data: any) => void;
     onResponse: any;
     events: {
@@ -511,6 +1011,7 @@ declare class TomoTronProvider extends EventEmitter {
     _state: StateProvider;
     private _requestPromise;
     constructor(productInfo: IProductInfo, { sendRequest, onResponse }: IConnectors);
+    switchChain?: ((chainId: string) => Promise<void>) | undefined;
     private _initTronWeb;
     initialize: () => Promise<void>;
     subscribeWalletEventsCallback: ({ method, data }: {
@@ -533,4 +1034,6 @@ declare class TomoTronProvider extends EventEmitter {
     sendToken: (params: any) => Promise<any>;
 }
 
-export { BtcProvider, DogecoinProvider, EvmProvider, PhantomProvider as SolanaProvider, TomoTronProvider as TronProvider };
+type WalletProvider = IDogecoinProvider | IEvmProvider;
+
+export { BitcoinProvider, DogecoinProvider, EvmProvider, PhantomProvider as SolanaProvider, TomoTronProvider as TronProvider, type WalletProvider };