@tomo-inc/inject-providers 0.0.13 → 0.0.15

package/src/evm/interface.ts

@@ -0,0 +1,189 @@
+import { EventEmitter } from "events";
+import { JsonRpcRequest, JsonRpcResponse } from "json-rpc-engine";
+import { ChainTypes } from "types";
+import { RequestArguments, SendSyncJsonRpcRequest } from "./type";
+import { Maybe } from "./utils";
+
+/**
+ * Connect event data interface
+ */
+export interface IConnectEvent {
+  chainId?: string;
+}
+
+/**
+ * Disconnect event data interface
+ */
+export interface IDisconnectEvent {
+  code: number;
+  message: string;
+  data?: unknown;
+}
+
+/**
+ * Provider message interface
+ */
+export interface IProviderMessage {
+  type: string;
+  data: unknown;
+}
+
+/**
+ * Main interface for EvmProvider
+ * Extends EventEmitter to support event handling
+ * Implements EIP-1193 standard
+ */
+export interface IEvmProvider extends EventEmitter {
+  type: ChainTypes.EVM;
+  // Public properties
+  /**
+   * 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;
+
+  // Connection methods
+  /**
+   * 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[]>;
+
+  // Legacy send methods (deprecated)
+  /**
+   * 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;
+
+  // Event types
+  /**
+   * 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;
+}

package/src/evm/metamask.ts

@@ -25,6 +25,7 @@ import {
 } from "./utils";
 
 import { ChainTypes, IProductInfo } from "../types";
+import { IEvmProvider } from "./interface";
 import {
   InitializeProviderOptions,
   InpageProviderOptions,
@@ -35,9 +36,8 @@ import {
   WarningEventName,
 } from "./type";
 
-const chainType = ChainTypes.EVM;
-
-export class EvmProvider extends EventEmitter {
+export class EvmProvider extends EventEmitter implements IEvmProvider {
+  type: ChainTypes.EVM = ChainTypes.EVM;
   private readonly _log: ConsoleLike;
 
   private _state: InternalState;
@@ -298,7 +298,7 @@ export class EvmProvider extends EventEmitter {
     args = { ...args, ...{ dappInfo } };
     // }
 
-    this.sendRequest(chainType, args);
+    this.sendRequest(this.type, args);
 
     return this.onResponse(args).then((res: any) => {
       const { data, method } = res || {};
@@ -345,7 +345,7 @@ export class EvmProvider extends EventEmitter {
     return super.addListener(eventName, listener);
   }
 
-  on(eventName: string, listener: (...args: unknown[]) => void) {
+  on(eventName: string, listener: (...args: any[]) => void) {
     this._warnOfDeprecation(eventName);
     return super.on(eventName, listener);
   }
@@ -415,13 +415,13 @@ export class EvmProvider extends EventEmitter {
 
   private subscribeWalletEventsCallback = ({ method, data }: { method: string; data: any }) => {
     if (method === "accountsChanged") {
-      const addresses = data?.[chainType] || [];
+      const addresses = data?.[this.type] || [];
       const accounts = addresses.map(({ address }: { address: string }) => address);
       this._handleAccountsChanged(accounts, true);
     }
     if (method === "chainChanged") {
       const { chainId, type }: { chainId: string; type: string } = data;
-      if (type.indexOf(`${chainType}:`) === 0) {
+      if (type.indexOf(`${this.type}:`) === 0) {
         const chainIdHex = toHex(parseInt(chainId));
         this._handleChainChanged({ chainId: chainIdHex, isConnected: true });
       }

package/src/index.ts

@@ -1,7 +1,11 @@
-import { BtcProvider } from "./btc";
+import { BitcoinProvider } from "./btc";
 import { DogecoinProvider } from "./dogecoin";
+import { IDogecoinProvider } from "./dogecoin/interface";
 import { EvmProvider } from "./evm";
+import { IEvmProvider } from "./evm/interface";
 import { SolanaProvider } from "./solana";
 import { TronProvider } from "./tron";
 
-export { BtcProvider, DogecoinProvider, EvmProvider, SolanaProvider, TronProvider };
+export { BitcoinProvider, DogecoinProvider, EvmProvider, SolanaProvider, TronProvider };
+
+export type WalletProvider = IDogecoinProvider | IEvmProvider;

package/src/solana/phantom.ts

@@ -9,8 +9,6 @@ import { hexToTx, txToHex } from "./utils";
 
 import { ChainTypes, IConnectors, IProductInfo } from "../types";
 import { OriginTransaction, SignInInput } from "./types";
-const chainType = ChainTypes.SOL;
-
 interface StateProvider {
   accounts: any[] | null;
   isConnected: boolean;
@@ -20,6 +18,7 @@ interface StateProvider {
 }
 
 export class PhantomProvider extends EventEmitter {
+  chainType = ChainTypes.SOLANA;
   _isUnlocked = false;
   name = "";
   icon = "";
@@ -92,7 +91,7 @@ export class PhantomProvider extends EventEmitter {
 
   subscribeWalletEventsCallback = ({ method, data }: { method: string; data: any }) => {
     if (method === "accountsChanged") {
-      const accounts = data?.[chainType];
+      const accounts = data?.[this.chainType];
       this._handleAccountsChanged(accounts);
     }
   };
@@ -153,7 +152,7 @@ export class PhantomProvider extends EventEmitter {
 
     const dappInfo = await getDappInfo();
 
-    this.sendRequest(chainType, { ...data, dappInfo });
+    this.sendRequest(this.chainType, { ...data, dappInfo });
 
     return this.onResponse(data).then((res: any) => {
       let { data } = res || {};

package/src/tron/tronLink.ts

@@ -5,8 +5,7 @@ import type { Transaction } from "tronweb/lib/esm/types/Transaction";
 
 import { ChainTypes, IConnectors, IProductInfo } from "../types";
 import { ReadyPromise, domReadyCall, getDappInfo } from "../utils/index";
-
-const chainType = ChainTypes.TRON;
+import { ITomoTronProvider } from "./types";
 
 interface StateProvider {
   accounts: any[] | null;
@@ -16,12 +15,15 @@ interface StateProvider {
   isPermanentlyDisconnected: boolean;
 }
 
-export class TomoTronProvider extends EventEmitter {
+const _fullHost = "https://api.trongrid.io";
+export class TomoTronProvider extends EventEmitter implements ITomoTronProvider {
+  type: ChainTypes.TRON = ChainTypes.TRON;
   _isUnlocked = false;
   name = "";
   icon = "";
   ready = false;
-  tronWeb: TronWeb | null = null;
+  tronWeb: TronWeb = new TronWeb({ fullHost: _fullHost });
+  address: string = "";
   sendRequest: (chainType: string, data: any) => void;
   onResponse: any;
   events = {
@@ -73,7 +75,7 @@ export class TomoTronProvider extends EventEmitter {
     this.on("disconnect", (result: any) => {
       this._state.isConnected = false;
 
-      this.tronWeb = null;
+      this.tronWeb = new TronWeb({ fullHost: _fullHost });
 
       window.postMessage(
         {
@@ -100,11 +102,12 @@ export class TomoTronProvider extends EventEmitter {
       );
     });
   }
+  switchChain?: ((chainId: string) => Promise<void>) | undefined;
 
   private _initTronWeb = async (res: any) => {
-    const { fullHost = "https://api.trongrid.io", address } = res || {};
+    const { fullHost, address } = res || {};
     this.tronWeb = new TronWeb({
-      fullHost,
+      fullHost: fullHost || _fullHost,
     });
 
     this.tronWeb.defaultAddress.base58 = address;
@@ -183,7 +186,7 @@ export class TomoTronProvider extends EventEmitter {
 
   subscribeWalletEventsCallback = ({ method, data }: { method: string; data: any }) => {
     if (method === "accountsChanged") {
-      const accounts = data?.[chainType];
+      const accounts = data?.[this.type];
       this._handleAccountsChanged(accounts);
     }
   };
@@ -222,7 +225,7 @@ export class TomoTronProvider extends EventEmitter {
 
     const dappInfo = await getDappInfo();
 
-    this.sendRequest(chainType, { ...data, dappInfo });
+    this.sendRequest(this.type, { ...data, dappInfo });
 
     return this.onResponse(data).then((res: any) => {
       const { data, method } = res || {};

package/src/tron/types.ts

@@ -1,7 +1,10 @@
-import type { Transaction, SignedTransaction } from "tronweb/lib/esm/types/Transaction";
-import type { TronLinkWallet } from "@tronweb3/tronwallet-adapter-tronlink"; // Import TronLink wallet class
+import type { TronLinkWallet, TronWeb } from "@tronweb3/tronwallet-adapter-tronlink"; // Import TronLink wallet class
+import type { SignedTransaction, Transaction } from "tronweb/lib/esm/types/Transaction";
+import { ChainTypes } from "types";
 
 export interface ITomoTronProvider extends TronLinkWallet {
+  type: ChainTypes.TRON;
+  tronWeb: TronWeb;
   address: string | null;
   connect(options?: Record<string, unknown>): Promise<void | any>;
   disconnect(): Promise<void | any>;

package/src/types/index.ts

@@ -1,5 +1,6 @@
-export * from "./dapp";
+export { ChainTypeEnum as ChainTypes } from "@tomo-inc/wallet-utils";
 
+export * from "./dapp";
 export interface IProductInfo {
   name: string;
   rdns: string;
@@ -20,15 +21,3 @@ export interface IConnectors {
   sendRequest: (chainType: string, data: any) => void;
   onResponse: (data: any) => void;
 }
-
-export enum ChainTypes {
-  BTC = "btc",
-  DOGE = "doge",
-  EVM = "evm",
-  SOL = "sol",
-  SUI = "sui",
-  TON = "ton",
-  TRON = "tron",
-  COSMOS = "cosmos",
-  APTOS = "aptos",
-}