@tomo-inc/inject-providers 0.0.13 → 0.0.15

package/dist/index.js

@@ -1,5 +1,6 @@
 import { ethErrors, EthereumRpcError } from 'eth-rpc-errors';
 import { EventEmitter } from 'events';
+import { ChainTypeEnum } from '@tomo-inc/wallet-utils';
 import { JsonRpcEngine, createIdRemapMiddleware } from 'json-rpc-engine';
 import { createStreamMiddleware } from 'json-rpc-middleware-stream';
 import { toHex } from 'viem';
@@ -163,10 +164,10 @@ function isHexString(str) {
 }
 
 // src/btc/unisat.ts
-var chainType = "btc" /* BTC */;
-var BtcProvider = class extends EventEmitter {
+var BitcoinProvider = class extends EventEmitter {
   constructor(productInfo, { sendRequest, onResponse }) {
     super();
+    this.type = ChainTypeEnum.BITCOIN;
     this._selectedAddress = null;
     this._isConnected = false;
     this._initialized = false;
@@ -209,13 +210,13 @@ var BtcProvider = class extends EventEmitter {
     };
     this.subscribeWalletEventsCallback = ({ method, data }) => {
       if (method === "accountsChanged") {
-        const addresses = (data == null ? void 0 : data[chainType]) || [];
+        const addresses = (data == null ? void 0 : data[this.type]) || [];
         const accounts = addresses.map(({ address }) => address);
         this._handleAccountsChanged(accounts);
       }
       if (method === "chainChanged") {
         const { chainId, type } = data;
-        if (type.indexOf(`${chainType}:`) === 0) {
+        if (type.indexOf(`${this.type}:`) === 0) {
           this._handleChainChanged({ chainId, isConnected: true });
         }
       }
@@ -239,7 +240,7 @@ var BtcProvider = class extends EventEmitter {
         throw ethErrors.rpc.invalidRequest();
       }
       const dappInfo = await getDappInfo();
-      this.sendRequest(chainType, { method, params, dappInfo });
+      this.sendRequest(this.type, { method, params, dappInfo });
       const connectFuns = {
         getAccounts: true,
         requestAccounts: true
@@ -308,7 +309,7 @@ var BtcProvider = class extends EventEmitter {
         params: { txId }
       });
     };
-    this.signMessage = async (text, type) => {
+    this.signMessage = async (text, type = "ecdsa") => {
       return this._request({
         method: "signMessage",
         params: {
@@ -397,6 +398,12 @@ var BtcProvider = class extends EventEmitter {
         }
       });
     };
+    this.sendTransaction = async (params) => {
+      return this._request({
+        method: "sendTransaction",
+        params
+      });
+    };
     this.name = productInfo.name;
     this.rdns = productInfo.rdns;
     this._handleAccountsChanged = this._handleAccountsChanged.bind(this);
@@ -430,10 +437,10 @@ var BtcProvider = class extends EventEmitter {
     }
   }
 };
-var chainType2 = "doge" /* DOGE */;
 var DogecoinProvider = class extends EventEmitter {
   constructor(productInfo, { sendRequest, onResponse }) {
     super();
+    this.type = ChainTypeEnum.DOGECOIN;
     this._selectedAddress = null;
     this._network = null;
     this._isConnected = false;
@@ -487,7 +494,7 @@ var DogecoinProvider = class extends EventEmitter {
         throw ethErrors.rpc.invalidRequest();
       }
       const dappInfo = await getDappInfo();
-      this.sendRequest(chainType2, { method, params, dappInfo });
+      this.sendRequest(this.type, { method, params, dappInfo });
       return this.onResponse({ method }).then((res) => {
         const { data } = res || {};
         return adapter ? adapter(data) : data;
@@ -809,7 +816,6 @@ var EMITTED_NOTIFICATIONS = [
 ];
 
 // src/evm/metamask.ts
-var chainType3 = "evm" /* EVM */;
 var EvmProvider = class extends EventEmitter {
   /**
    * @param connectionStream - A Node.js duplex stream
@@ -833,15 +839,16 @@ var EvmProvider = class extends EventEmitter {
     }
     validateLoggerObject(logger);
     super();
+    this.type = ChainTypeEnum.EVM;
     this.subscribeWalletEventsCallback = ({ method, data }) => {
       if (method === "accountsChanged") {
-        const addresses = (data == null ? void 0 : data[chainType3]) || [];
+        const addresses = (data == null ? void 0 : data[this.type]) || [];
         const accounts = addresses.map(({ address }) => address);
         this._handleAccountsChanged(accounts, true);
       }
       if (method === "chainChanged") {
         const { chainId, type } = data;
-        if (type.indexOf(`${chainType3}:`) === 0) {
+        if (type.indexOf(`${this.type}:`) === 0) {
           const chainIdHex = toHex(parseInt(chainId));
           this._handleChainChanged({ chainId: chainIdHex, isConnected: true });
         }
@@ -1011,7 +1018,7 @@ var EvmProvider = class extends EventEmitter {
     };
     const dappInfo = await getDappInfo();
     args = __spreadValues(__spreadValues({}, args), { dappInfo });
-    this.sendRequest(chainType3, args);
+    this.sendRequest(this.type, args);
     return this.onResponse(args).then((res) => {
       const { data, method: method2 } = res || {};
       if (method2 === "_wallet_getProviderState") {
@@ -1430,10 +1437,10 @@ var hexToTx = (hexString) => {
 };
 
 // src/solana/phantom.ts
-var chainType4 = "sol" /* SOL */;
 var PhantomProvider = class extends EventEmitter {
   constructor(productInfo, { sendRequest, onResponse }) {
     super();
+    this.chainType = ChainTypeEnum.SOLANA;
     this._isUnlocked = false;
     this.name = "";
     this.icon = "";
@@ -1478,7 +1485,7 @@ var PhantomProvider = class extends EventEmitter {
     };
     this.subscribeWalletEventsCallback = ({ method, data }) => {
       if (method === "accountsChanged") {
-        const accounts = data == null ? void 0 : data[chainType4];
+        const accounts = data == null ? void 0 : data[this.chainType];
         this._handleAccountsChanged(accounts);
       }
     };
@@ -1500,7 +1507,7 @@ var PhantomProvider = class extends EventEmitter {
         throw ethErrors.rpc.invalidRequest();
       }
       const dappInfo = await getDappInfo();
-      this.sendRequest(chainType4, __spreadProps(__spreadValues({}, data), { dappInfo }));
+      this.sendRequest(this.chainType, __spreadProps(__spreadValues({}, data), { dappInfo }));
       return this.onResponse(data).then((res) => {
         let { data: data2 } = res || {};
         if (data2 && data2.publicKey) {
@@ -1765,15 +1772,17 @@ Resources:`;
     }
   }
 };
-var chainType5 = "tron" /* TRON */;
+var _fullHost = "https://api.trongrid.io";
 var TomoTronProvider = class extends EventEmitter {
   constructor(productInfo, { sendRequest, onResponse }) {
     super();
+    this.type = ChainTypeEnum.TRON;
     this._isUnlocked = false;
     this.name = "";
     this.icon = "";
     this.ready = false;
-    this.tronWeb = null;
+    this.tronWeb = new TronWeb({ fullHost: _fullHost });
+    this.address = "";
     this.events = {
       connect: true,
       disconnect: true,
@@ -1789,9 +1798,9 @@ var TomoTronProvider = class extends EventEmitter {
     // private _pushEventHandlers: PushEventHandlers;
     this._requestPromise = new ReadyPromise(0);
     this._initTronWeb = async (res) => {
-      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;
       this.tronWeb.defaultAddress.hex = TronWeb.address.toHex(address);
@@ -1860,7 +1869,7 @@ var TomoTronProvider = class extends EventEmitter {
     };
     this.subscribeWalletEventsCallback = ({ method, data }) => {
       if (method === "accountsChanged") {
-        const accounts = data == null ? void 0 : data[chainType5];
+        const accounts = data == null ? void 0 : data[this.type];
         this._handleAccountsChanged(accounts);
       }
     };
@@ -1869,7 +1878,7 @@ var TomoTronProvider = class extends EventEmitter {
         throw ethErrors.rpc.invalidRequest();
       }
       const dappInfo = await getDappInfo();
-      this.sendRequest(chainType5, __spreadProps(__spreadValues({}, data), { dappInfo }));
+      this.sendRequest(this.type, __spreadProps(__spreadValues({}, data), { dappInfo }));
       return this.onResponse(data).then((res) => {
         const { data: data2, method } = res || {};
         if (method === "tron_requestAccounts") {
@@ -1998,7 +2007,7 @@ var TomoTronProvider = class extends EventEmitter {
     });
     this.on("disconnect", (result) => {
       this._state.isConnected = false;
-      this.tronWeb = null;
+      this.tronWeb = new TronWeb({ fullHost: _fullHost });
       window.postMessage(
         {
           message: {
@@ -2045,4 +2054,4 @@ var TomoTronProvider = class extends EventEmitter {
   }
 };
 
-export { BtcProvider, DogecoinProvider, EvmProvider, PhantomProvider as SolanaProvider, TomoTronProvider as TronProvider };
+export { BitcoinProvider, DogecoinProvider, EvmProvider, PhantomProvider as SolanaProvider, TomoTronProvider as TronProvider };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomo-inc/inject-providers",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "author": "tomo.inc",
   "license": "MIT",
   "private": false,
@@ -25,7 +25,7 @@
     "json-rpc-middleware-stream": "^3.0.0",
     "tronweb": "^6.0.3",
     "viem": "^2.38.3",
-    "@tomo-inc/wallet-utils": "0.0.15"
+    "@tomo-inc/wallet-utils": "0.0.17"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/btc/index.ts

@@ -1,3 +1,3 @@
-import { BtcProvider } from "./unisat";
+import { BitcoinProvider } from "./unisat";
 
-export { BtcProvider };
+export { BitcoinProvider };

package/src/btc/types.ts

@@ -1,3 +1,5 @@
+import { ChainTypes } from "types";
+
 export enum TxType {
   SIGN_TX,
   SEND_BITCOIN,
@@ -14,7 +16,10 @@ export type Balance = {
   total: number;
 };
 
-export type IBtcProvider = {
+export type SignMessageType = "ecdsa" | "bip322-simple";
+
+export interface IBitcoinProvider {
+  type: ChainTypes.BITCOIN;
   connect: () => Promise<any>;
   disconnect: () => Promise<any>;
   requestAccounts: () => Promise<any>;
@@ -22,7 +27,7 @@ export type IBtcProvider = {
   getPublicKey: () => Promise<any>;
   getBalance: () => Promise<any>;
   getTransactionStatus: (params: { txId: string }) => Promise<any>;
-  signMessage: (params: { text: string; type: string }) => Promise<any>;
+  signMessage: (text: string, type: SignMessageType) => Promise<any>;
   getNetwork: () => Promise<any>;
   switchNetwork: (network: Network) => Promise<any>;
   getChain: () => Promise<any>;
@@ -35,4 +40,4 @@ export type IBtcProvider = {
   pushTx: (rawtx: string) => Promise<any>;
   sendTransaction: (params: any) => Promise<any>;
   sendBitcoin: (rawtx: string) => Promise<any>;
-};
+}

package/src/btc/unisat.ts

@@ -3,9 +3,7 @@ import { EventEmitter } from "events";
 
 import { ChainTypes, IConnectors, IProductInfo } from "../types";
 import { ReadyPromise, domReadyCall, getDappInfo } from "../utils/index";
-import { Balance, ChainId, Network } from "./types";
-
-const chainType = ChainTypes.BTC;
+import { Balance, ChainId, IBitcoinProvider, Network, SignMessageType } from "./types";
 
 interface StateProvider {
   accounts: string[] | null;
@@ -15,7 +13,8 @@ interface StateProvider {
   isPermanentlyDisconnected: boolean;
 }
 
-export class BtcProvider extends EventEmitter {
+export class BitcoinProvider extends EventEmitter implements IBitcoinProvider {
+  type: ChainTypes.BITCOIN = ChainTypes.BITCOIN;
   _selectedAddress: string | null = null;
   _isConnected = false;
   _initialized = false;
@@ -80,14 +79,14 @@ export class BtcProvider extends EventEmitter {
 
   subscribeWalletEventsCallback = ({ method, data }: { method: string; data: any }) => {
     if (method === "accountsChanged") {
-      const addresses = data?.[chainType] || [];
+      const addresses = data?.[this.type] || [];
       // addresses = addresses.filter((item) => item.subType === "default");
       const accounts = addresses.map(({ address }: { address: string }) => address);
       this._handleAccountsChanged(accounts);
     }
     if (method === "chainChanged") {
       const { chainId, type }: { chainId: string; type: string } = data;
-      if (type.indexOf(`${chainType}:`) === 0) {
+      if (type.indexOf(`${this.type}:`) === 0) {
         this._handleChainChanged({ chainId, isConnected: true });
       }
     }
@@ -147,7 +146,7 @@ export class BtcProvider extends EventEmitter {
 
     //api call -> ("0: dapp -> injector -> content");
     const dappInfo = await getDappInfo();
-    this.sendRequest(chainType, { method, params, dappInfo });
+    this.sendRequest(this.type, { method, params, dappInfo });
 
     const connectFuns: Record<string, boolean> = {
       getAccounts: true,
@@ -230,7 +229,7 @@ export class BtcProvider extends EventEmitter {
     });
   };
 
-  signMessage = async (text: string, type?: "ecdsa" | "bip322-simple"): Promise<string> => {
+  signMessage = async (text: string, type: SignMessageType = "ecdsa"): Promise<string> => {
     return this._request({
       method: "signMessage",
       params: {
@@ -329,4 +328,11 @@ export class BtcProvider extends EventEmitter {
       },
     });
   };
+
+  sendTransaction = async (params: any) => {
+    return this._request({
+      method: "sendTransaction",
+      params,
+    });
+  };
 }

package/src/dogecoin/dogecoin.ts

@@ -5,8 +5,7 @@ import { ReadyPromise, domReadyCall, getDappInfo } from "../utils/index";
 import { TxType } from "./types";
 
 import { ChainTypes, IConnectors, IProductInfo } from "../types";
-
-const chainType = ChainTypes.DOGE;
+import { IDogecoinProvider } from "./interface";
 
 interface StateProvider {
   accounts: string[] | null;
@@ -16,7 +15,8 @@ interface StateProvider {
   isPermanentlyDisconnected: boolean;
 }
 
-export class DogecoinProvider extends EventEmitter {
+export class DogecoinProvider extends EventEmitter implements IDogecoinProvider {
+  type: ChainTypes.DOGECOIN = ChainTypes.DOGECOIN;
   _selectedAddress: string | null = null;
   _network: string | null = null;
   _isConnected = false;
@@ -94,7 +94,7 @@ export class DogecoinProvider extends EventEmitter {
 
     //api call -> ("0: dapp -> injector -> content");
     const dappInfo = await getDappInfo();
-    this.sendRequest(chainType, { method, params, dappInfo });
+    this.sendRequest(this.type, { method, params, dappInfo });
 
     //check result by method
     return this.onResponse({ method }).then((res: any) => {

package/src/dogecoin/interface.ts

@@ -0,0 +1,331 @@
+import { EventEmitter } from "events";
+import { ChainTypes } from "types";
+
+/**
+ * State interface for DogecoinProvider
+ */
+export interface IDogecoinProviderState {
+  accounts: string[] | null;
+  isConnected: boolean;
+  isUnlocked: boolean;
+  initialized: boolean;
+  isPermanentlyDisconnected: boolean;
+}
+
+/**
+ * Balance response interface
+ */
+export interface IDogecoinBalance {
+  confirmed: number;
+  unconfirmed: number;
+  total: number;
+}
+
+/**
+ * Transaction status response interface
+ */
+export interface ITransactionStatus {
+  status: string;
+  confirmations: number;
+}
+
+/**
+ * Signed message response interface
+ */
+export interface ISignedMessage {
+  signedMessage: string;
+}
+
+/**
+ * Decrypted message response interface
+ */
+export interface IDecryptedMessage {
+  decryptedMessage: string;
+}
+
+/**
+ * PSBT request parameters interface
+ */
+export interface IRequestPsbtParams {
+  rawTx: string;
+  indexes?: [];
+  feeOnly?: boolean;
+  signOnly?: boolean;
+  partial?: boolean;
+  sighashType?: string;
+}
+
+/**
+ * PSBT response interface
+ */
+export interface IPsbtResponse {
+  signedRawTx?: string;
+  txId?: string;
+}
+
+/**
+ * Send options interface
+ */
+export interface ISendOptions {
+  feeRate?: number;
+  memo?: string;
+}
+
+/**
+ * Connection status response interface
+ */
+export interface IConnectionStatus {
+  connected: boolean;
+  address: string;
+  selectedWalletAddress: string;
+}
+
+/**
+ * DRC20 balance response interface
+ */
+export interface IDRC20Balance {
+  availableBalance: number;
+  transferableBalance: number;
+  ticker: string;
+  address: string;
+}
+
+/**
+ * Transferable DRC20 response interface
+ */
+export interface ITransferableDRC20 {
+  inscriptions: any[];
+  ticker: string;
+  address: string;
+}
+
+/**
+ * DRC20 transaction response interface
+ */
+export interface IDRC20Transaction {
+  txId: string;
+  ticker: string;
+  amount: number;
+}
+
+/**
+ * Dunes balance response interface
+ */
+export interface IDunesBalance {
+  balance: number;
+  ticker: string;
+}
+
+/**
+ * Main interface for DogecoinProvider
+ * Extends EventEmitter to support event handling
+ */
+export interface IDogecoinProvider extends EventEmitter {
+  type: ChainTypes.DOGECOIN;
+
+  rdns: string;
+  name: string;
+
+  // Connection methods
+  /**
+   * 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>;
+
+  // Account methods
+  /**
+   * 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>;
+
+  // Balance methods
+  /**
+   * Get balance
+   * @returns Promise resolving to balance object with confirmed, unconfirmed, and total
+   */
+  getBalance(): Promise<IDogecoinBalance>;
+
+  // Transaction methods
+  /**
+   * 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>;
+
+  // Message signing methods
+  /**
+   * 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>;
+
+  // PSBT methods
+  /**
+   * 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>;
+
+  // DRC20 methods
+  /**
+   * 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 }>;
+
+  // Dunes methods
+  /**
+   * 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
+  /**
+   * 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>;
+}