@tomo-inc/inject-providers 0.0.3 → 0.0.5

package/dist/index.d.cts

@@ -0,0 +1,518 @@
+import { EventEmitter } from 'events';
+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';
+
+interface IProductInfo {
+    name: string;
+    rdns: string;
+    icon: string;
+}
+interface IConnectors {
+    sendRequest: (chainType: string, data: any) => void;
+    onResponse: (data: any) => void;
+}
+
+type Network = "livenet" | "testnet";
+type ChainId = "BITCOIN_MAINNET" | "BITCOIN_TESTNET" | "FRACTAL_BITCOIN_MAINNET";
+type Balance = {
+    confirmed: number;
+    unconfirmed: number;
+    total: number;
+};
+
+interface StateProvider$3 {
+    accounts: string[] | null;
+    isConnected: boolean;
+    isUnlocked: boolean;
+    initialized: boolean;
+    isPermanentlyDisconnected: boolean;
+}
+declare class BtcProvider extends EventEmitter {
+    _selectedAddress: string | null;
+    _isConnected: boolean;
+    _initialized: boolean;
+    _isUnlocked: boolean;
+    rdns: string;
+    name: string;
+    chainId: string;
+    sendRequest: (chainType: string, data: any) => void;
+    onResponse: any;
+    _state: StateProvider$3;
+    private _requestPromise;
+    constructor(productInfo: IProductInfo, { sendRequest, onResponse }: IConnectors);
+    initialize: () => Promise<void>;
+    subscribeWalletEventsCallback: ({ method, data }: {
+        method: string;
+        data: any;
+    }) => void;
+    /**
+     * Sending a message to the extension to receive will keep the service worker alive.
+     */
+    private keepAlive;
+    private _handleChainChanged;
+    private _handleAccountsChanged;
+    _request: ({ method, params }: {
+        method: string;
+        params?: any;
+    }, adapter?: any) => Promise<any>;
+    request: ({ method, params }: {
+        method: string;
+        params: any;
+    }) => Promise<any>;
+    connect: () => Promise<any>;
+    disconnect: () => Promise<any>;
+    requestAccounts: () => Promise<string[]>;
+    getAccounts: () => Promise<string[]>;
+    getPublicKey: () => Promise<any>;
+    getBalance: () => Promise<Balance>;
+    getTransactionStatus: ({ txId }: {
+        txId: string;
+    }) => Promise<any>;
+    signMessage: (text: string, type?: "ecdsa" | "bip322-simple") => Promise<string>;
+    getNetwork: () => Promise<any>;
+    switchNetwork: (network: Network) => Promise<any>;
+    getChain: () => Promise<any>;
+    switchChain: (chainId: ChainId) => Promise<any>;
+    signPsbt: (psbtHex: string, options?: any) => Promise<string>;
+    signPsbts: (psbtHexs: string[], options?: any[]) => Promise<string[]>;
+    pushPsbt: (psbtHex: string) => Promise<string>;
+    sendBitcoin: (toAddress: string, satoshis?: number, options?: {
+        feeRate: number;
+    }) => Promise<string>;
+    signTx: (rawtx: string) => Promise<any>;
+    pushTx: (rawtx: string) => Promise<string>;
+}
+
+interface StateProvider$2 {
+    accounts: string[] | null;
+    isConnected: boolean;
+    isUnlocked: boolean;
+    initialized: boolean;
+    isPermanentlyDisconnected: boolean;
+}
+declare class DogecoinProvider extends EventEmitter {
+    _selectedAddress: string | null;
+    _network: string | null;
+    _isConnected: boolean;
+    _initialized: boolean;
+    _isUnlocked: boolean;
+    rdns: string;
+    name: string;
+    sendRequest: (chainType: string, data: any) => void;
+    onResponse: any;
+    _state: StateProvider$2;
+    private _requestPromise;
+    constructor(productInfo: IProductInfo, { sendRequest, onResponse }: IConnectors);
+    initialize: () => Promise<void>;
+    /**
+     * Sending a message to the extension to receive will keep the service worker alive.
+     */
+    private keepAlive;
+    _request: ({ method, params }: {
+        method: string;
+        params?: any;
+    }, adapter?: any) => Promise<any>;
+    request: ({ method, params }: {
+        method: string;
+        params: any;
+    }) => Promise<any>;
+    connect: () => Promise<any>;
+    getBalance: () => Promise<any>;
+    disconnect: () => Promise<any>;
+    getConnectionStatus: () => Promise<any>;
+    requestTransaction: ({ recipientAddress, dogeAmount }: {
+        recipientAddress: string;
+        dogeAmount: number;
+    }) => Promise<any>;
+    getTransactionStatus: ({ txId }: {
+        txId: string;
+    }) => Promise<any>;
+    requestSignedMessage: ({ message, type }: {
+        message: string;
+        type?: string;
+    }) => Promise<any>;
+    requestDecryptedMessage: ({ message }: {
+        message: string;
+    }) => Promise<any>;
+    getDRC20Balances: (address: string, ticker?: string) => Promise<any>;
+    getDRC20Balance: ({ ticker }: {
+        ticker?: string;
+    }) => Promise<any>;
+    getTransferableDRC20: ({ ticker }: {
+        ticker?: string;
+    }) => Promise<any>;
+    requestAvailableDRC20Transaction: ({ ticker, amount }: {
+        ticker: string;
+        amount: number;
+    }) => Promise<any>;
+    requestInscriptionTransaction: ({ location, recipientAddress, }: {
+        location: string;
+        recipientAddress: string;
+    }) => Promise<any>;
+    requestPsbt: ({ rawTx, indexes, feeOnly, signOnly, partial, sighashType, }: {
+        rawTx: string;
+        indexes?: [];
+        feeOnly?: boolean;
+        signOnly?: boolean;
+        partial?: boolean;
+        sighashType?: string;
+    }) => Promise<any>;
+    getDunesBalance: (params: {
+        ticker: string;
+    }) => Promise<any>;
+    requestDunesTransaction: ({ ticker, amount, recipientAddress, }: {
+        ticker: string;
+        amount: number;
+        recipientAddress: string;
+    }) => Promise<any>;
+}
+
+type Maybe<T> = Partial<T> | null | undefined;
+type ConsoleLike = Pick<Console, "log" | "warn" | "error" | "debug" | "info" | "trace">;
+
+interface InpageProviderOptions {
+    /**
+     * The logging API to use.
+     */
+    logger?: ConsoleLike;
+    jsonRpcStreamName?: any;
+    /**
+     * The maximum number of event listeners.
+     */
+    maxEventListeners?: number;
+    /**
+     * Whether the provider should send page metadata.
+     */
+    shouldSendMetadata?: boolean;
+    sendRequest: (chainType: string, data: any) => void;
+    onResponse: any;
+}
+interface RequestArguments {
+    /** The RPC method to request. */
+    method: string;
+    /** The params of the RPC method, if any. */
+    params?: unknown[] | Record<string, unknown>;
+}
+interface SendSyncJsonRpcRequest extends JsonRpcRequest<unknown> {
+    method: "eth_accounts" | "eth_coinbase" | "eth_uninstallFilter" | "net_version";
+}
+
+declare class EvmProvider extends EventEmitter {
+    private readonly _log;
+    private _state;
+    private _rpcEngine;
+    sendRequest: (chainType: string, data: any) => void;
+    onResponse: any;
+    /**
+     * The chain ID of the currently connected Ethereum chain.
+     * See [chainId.network]{@link https://chainid.network} for more information.
+     */
+    chainId: string | null;
+    /**
+     * The network ID of the currently connected Ethereum chain.
+     */
+    networkVersion: string | null;
+    /**
+     * The user's currently selected Ethereum address.
+     * If null,  is either locked or the user has not permitted any
+     * addresses to be viewed.
+     */
+    selectedAddress: string | null;
+    /**
+     * Indicating that this provider is a provider.
+     */
+    name: string;
+    icon: string;
+    /**
+     * @param connectionStream - A Node.js duplex stream
+     * @param options - An options bag
+     * @param options.jsonRpcStreamName - The name of the internal JSON-RPC stream.
+     * @param options.logger - The logging API to use. Default: console
+     * @param options.maxEventListeners - The maximum number of event
+     * listeners. Default: 100
+     * @param options.shouldSendMetadata - Whether the provider should
+     * send page metadata. Default: true
+     */
+    constructor(productInfo: IProductInfo, { logger, maxEventListeners, shouldSendMetadata, sendRequest, onResponse, }: InpageProviderOptions);
+    /**
+     * Returns whether the provider can process RPC requests.
+     */
+    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>(args: RequestArguments): Promise<Maybe<T>>;
+    /**
+     * Submits an RPC request per the given JSON-RPC request object.
+     *
+     * @param payload - The RPC request object.
+     * @param cb - The callback function.
+     */
+    sendAsync(payload: JsonRpcRequest<unknown>, callback: (error: Error | null, result?: JsonRpcResponse<unknown>) => void): void;
+    /**
+     * We override the following event methods so that we can warn consumers
+     * about deprecated events:
+     *   addListener, on, once, prependListener, prependOnceListener
+     */
+    addListener(eventName: string, listener: (...args: unknown[]) => void): this;
+    on(eventName: string, listener: (...args: unknown[]) => 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;
+    /**
+     * Constructor helper.
+     * Populates initial state by calling 'getProviderState' and emits
+     * necessary events.
+     */
+    private _initializeState;
+    private subscribeWalletEventsCallback;
+    private keepAlive;
+    /**
+     * Internal RPC method. Forwards requests to background via the RPC engine.
+     * Also remap ids inbound and outbound.
+     *
+     * @param payload - The RPC request object.
+     * @param callback - The consumer's callback.
+     */
+    private _rpcRequest;
+    /**
+     * When the provider becomes connected, updates internal state and emits
+     * required events. Idempotent.
+     *
+     * @param chainId - The ID of the newly connected chain.
+     * @emits InpageProvider#connect
+     */
+    private _handleConnect;
+    /**
+     * When the provider becomes disconnected, updates internal state and emits
+     * required events. Idempotent with respect to the isRecoverable parameter.
+     *
+     * Error codes per the CloseEvent status codes as required by EIP-1193:
+     * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+     *
+     * @param isRecoverable - Whether the disconnection is recoverable.
+     * @param errorMessage - A custom error message.
+     * @emits InpageProvider#disconnect
+     */
+    private _handleDisconnect;
+    /**
+     * Called when connection is lost to critical streams.
+     *
+     * @emits InpageProvider#disconnect
+     */
+    private _handleStreamDisconnect;
+    /**
+     * Upon receipt of a new chainId and networkVersion, emits corresponding
+     * events and sets relevant public state.
+     * Does nothing if neither the chainId nor the networkVersion are different
+     * from existing values.
+     *
+     * @emits InpageProvider#chainChanged
+     * @param networkInfo - An object with network info.
+     * @param networkInfo.chainId - The latest chain ID.
+     * @param networkInfo.networkVersion - The latest network ID.
+     */
+    private _handleChainChanged;
+    /**
+     * Called when accounts may have changed. Diffs the new accounts value with
+     * the current one, updates all state as necessary, and emits the
+     * accountsChanged event.
+     *
+     * @param accounts - The new accounts value.
+     * @param isEthAccounts - Whether the accounts value was returned by
+     * a call to eth_accounts.
+     */
+    private _handleAccountsChanged;
+    /**
+     * Upon receipt of a new isUnlocked state, sets relevant public state.
+     * Calls the accounts changed handler with the received accounts, or an empty
+     * array.
+     *
+     * Does nothing if the received value is equal to the existing value.
+     * There are no lock/unlock events.
+     *
+     * @param opts - Options bag.
+     * @param opts.accounts - The exposed accounts, if any.
+     * @param opts.isUnlocked - The latest isUnlocked value.
+     */
+    private _handleUnlockStateChanged;
+    /**
+     * Warns of deprecation for the given event, if applicable.
+     */
+    private _warnOfDeprecation;
+    /**
+     * Equivalent to: ethereum.request('eth_requestAccounts')
+     *
+     * @deprecated Use request({ method: 'eth_requestAccounts' }) instead.
+     * @returns A promise that resolves to an array of addresses.
+     */
+    enable(): Promise<string[]>;
+    setConnectedStatus({ connected, address }: {
+        connected: boolean;
+        address: string[];
+    }): void;
+    connect(): Promise<string[]>;
+    disconnect(): Promise<boolean>;
+    /**
+     * 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>;
+    /**
+     * Internal backwards compatibility method, used in send.
+     *
+     * @deprecated
+     */
+    private _sendSync;
+}
+
+type SignInInput = {
+    domain?: string;
+    statement?: string;
+    version?: string;
+    nonce?: string;
+    chainId?: Cluster;
+    issuedAt?: string;
+    resources?: `https://${string}`[];
+};
+interface OriginTransaction {
+    from: string;
+    to: string;
+    amount: number;
+    tokenAddress?: string;
+    decimals?: number;
+    priorityFee?: number;
+    chainId?: Cluster;
+}
+
+interface StateProvider$1 {
+    accounts: any[] | null;
+    isConnected: boolean;
+    isUnlocked: boolean;
+    initialized: boolean;
+    isPermanentlyDisconnected: boolean;
+}
+declare class PhantomProvider extends EventEmitter {
+    _isUnlocked: boolean;
+    name: string;
+    icon: string;
+    publicKey: PublicKey | null;
+    sendRequest: (chainType: string, data: any) => void;
+    onResponse: any;
+    events: {
+        connect: boolean;
+        disconnect: boolean;
+        accountChanged: boolean;
+    };
+    _state: StateProvider$1;
+    private _requestPromise;
+    constructor(productInfo: IProductInfo, { sendRequest, onResponse }: IConnectors);
+    initialize: () => Promise<void>;
+    subscribeWalletEventsCallback: ({ method, data }: {
+        method: string;
+        data: any;
+    }) => void;
+    /**
+     * Sending a message to the extension to receive will keep the service worker alive.
+     */
+    private keepAlive;
+    on(eventName: string, listener: (...args: unknown[]) => void): this;
+    private _handleAccountsChanged;
+    _request: (data: any, responseAdaptor?: any) => Promise<any>;
+    request: ({ method, params }: {
+        method: string;
+        params: any;
+    }, responseAdaptor: any) => Promise<any>;
+    connect: (params?: {
+        onlyIfTrusted: boolean;
+    }) => Promise<any>;
+    disconnect: () => Promise<any>;
+    getAccount: () => Promise<any>;
+    signMessage: (message: Uint8Array, display: "utf8" | "hex") => Promise<any>;
+    signIn: (params?: SignInInput) => Promise<any>;
+    signTransaction: (tx: VersionedTransaction | Transaction) => Promise<any>;
+    signAllTransactions: (txs: (VersionedTransaction | Transaction)[]) => Promise<any>;
+    signAndSendTransaction: (tx: VersionedTransaction | Transaction) => Promise<any>;
+    signAndSendAllTransactions: (txs: (VersionedTransaction | Transaction)[]) => Promise<any>;
+    sendSolana: (tx: OriginTransaction) => Promise<any>;
+    sendToken: (tx: OriginTransaction) => Promise<any>;
+}
+
+interface StateProvider {
+    accounts: any[] | null;
+    isConnected: boolean;
+    isUnlocked: boolean;
+    initialized: boolean;
+    isPermanentlyDisconnected: boolean;
+}
+declare class TomoTronProvider extends EventEmitter {
+    _isUnlocked: boolean;
+    name: string;
+    icon: string;
+    ready: boolean;
+    tronWeb: TronWeb | null;
+    sendRequest: (chainType: string, data: any) => void;
+    onResponse: any;
+    events: {
+        connect: boolean;
+        disconnect: boolean;
+        accountChanged: boolean;
+    };
+    _state: StateProvider;
+    private _requestPromise;
+    constructor(productInfo: IProductInfo, { sendRequest, onResponse }: IConnectors);
+    private _initTronWeb;
+    initialize: () => Promise<void>;
+    subscribeWalletEventsCallback: ({ method, data }: {
+        method: string;
+        data: any;
+    }) => void;
+    on(eventName: string, listener: (...args: unknown[]) => void): this;
+    private _handleAccountsChanged;
+    _request: (data: any, responseAdaptor?: any) => Promise<any>;
+    request: ({ method, params }: {
+        method: string;
+        params: any;
+    }, responseAdaptor?: any) => Promise<any>;
+    connect: () => Promise<any>;
+    disconnect: () => Promise<any>;
+    signMessage: (message: string) => Promise<any>;
+    signTransaction: (transaction: Transaction$1) => Promise<any>;
+    sendRawTransaction: (transaction: Transaction$1) => Promise<any>;
+    sendTransaction: (params: any) => Promise<any>;
+    sendToken: (params: any) => Promise<any>;
+}
+
+export { BtcProvider, DogecoinProvider, EvmProvider, PhantomProvider as SolanaProvider, TomoTronProvider as TronProvider };