@toruslabs/ethereum-controllers 4.1.0

package/dist/types/Account/AccountTrackerController.d.ts

@@ -0,0 +1,35 @@
+import { AccountTrackerConfig, AccountTrackerState, BaseController, IAccountTrackerController, PreferencesState } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import NetworkController from "../Network/NetworkController";
+import { EthereumBlock, ExtendedAddressPreferences } from "../utils/interfaces";
+interface AccountTrackerControllerOptions {
+    config: AccountTrackerConfig<EthereumBlock>;
+    state: Partial<AccountTrackerState>;
+    provider: SafeEventEmitterProvider;
+    blockTracker?: PollingBlockTracker;
+    getIdentities: () => PreferencesState<ExtendedAddressPreferences>["identities"];
+    onPreferencesStateChange: (listener: (preferencesState: PreferencesState<ExtendedAddressPreferences>) => void) => void;
+    getCurrentChainId: NetworkController["getNetworkIdentifier"];
+}
+/**
+ * Tracks accounts based on blocks.
+ * If block tracker provides latest block, we query accounts from it.
+ * Preferences state changes also retrigger accounts update.
+ * Network state changes also retrigger accounts update.
+ */
+declare class AccountTrackerController extends BaseController<AccountTrackerConfig<EthereumBlock>, AccountTrackerState> implements IAccountTrackerController<AccountTrackerConfig<EthereumBlock>, AccountTrackerState> {
+    private provider;
+    private blockTracker;
+    private mutex;
+    private ethersProvider;
+    private getIdentities;
+    private getCurrentChainId;
+    constructor({ config, state, provider, blockTracker, getIdentities, onPreferencesStateChange, getCurrentChainId, }: AccountTrackerControllerOptions);
+    syncAccounts(): boolean;
+    refresh(): Promise<void>;
+    private _updateAccounts;
+    private _updateAccount;
+    private _updateAccountsViaBalanceChecker;
+}
+export default AccountTrackerController;

package/dist/types/Block/PollingBlockTracker.d.ts

@@ -0,0 +1,14 @@
+import { BaseBlockTracker, PollingBlockTrackerConfig } from "@toruslabs/base-controllers";
+import { EthereumBlock, PollingBlockTrackerState } from "../utils/interfaces";
+declare class PollingBlockTracker extends BaseBlockTracker<EthereumBlock, PollingBlockTrackerConfig, PollingBlockTrackerState> {
+    constructor({ config, state }: {
+        config: Partial<PollingBlockTrackerConfig>;
+        state: Partial<PollingBlockTrackerState>;
+    });
+    checkForLatestBlock(): Promise<EthereumBlock>;
+    protected _start(): void;
+    private _synchronize;
+    private _updateLatestBlock;
+    private _fetchLatestBlock;
+}
+export default PollingBlockTracker;

package/dist/types/Currency/CurrencyController.d.ts

@@ -0,0 +1,30 @@
+import { BaseCurrencyController, BaseCurrencyControllerConfig, BaseCurrencyControllerState } from "@toruslabs/base-controllers";
+import { EthereumNetworkState } from "../utils/interfaces";
+export interface IEthereumCurrencyControllerState extends BaseCurrencyControllerState {
+    commonDenomination: string;
+    commonDenominatorPrice: number;
+}
+export default class CurrencyController extends BaseCurrencyController<BaseCurrencyControllerConfig, IEthereumCurrencyControllerState> {
+    private conversionInterval;
+    constructor({ config, state, onNetworkChanged, }: {
+        config: Partial<BaseCurrencyControllerConfig>;
+        state: Partial<IEthereumCurrencyControllerState>;
+        onNetworkChanged: (listener: (networkState: EthereumNetworkState) => void) => void;
+    });
+    setCommonDenomination(commonDenomination: string): void;
+    getCommonDenomination(): string;
+    setCommonDenominatorPrice(commonDenominatorPrice: number): void;
+    getCommonDenominatorPrice(): number;
+    /**
+     * Creates a new poll, using setInterval, to periodically call updateConversionRate. The id of the interval is
+     * stored at the controller's conversionInterval property. If it is called and such an id already exists, the
+     * previous interval is clear and a new one is created.
+     */
+    scheduleConversionInterval(): void;
+    /**
+     * Updates the conversionRate and conversionDate properties associated with the currentCurrency. Updated info is
+     * fetched from an external API
+     */
+    updateConversionRate(): Promise<void>;
+    private retrieveConversionRate;
+}

package/dist/types/Gas/GasFeeController.d.ts

@@ -0,0 +1,64 @@
+import { BaseController } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import NetworkController from "../Network/NetworkController";
+import { EthereumNetworkState } from "../utils/interfaces";
+import { EthereumGasConfig, EthereumGasFeeEstimates, EthereumGasState, EthereumLegacyGasFeeEstimates } from "./IGasFeeController";
+interface IGasFeeControllerOptions {
+    config?: Partial<EthereumGasConfig>;
+    state?: Partial<EthereumGasState>;
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    getProvider: NetworkController["getProvider"];
+    getCurrentNetworkEIP1559Compatibility: NetworkController["getEIP1559Compatibility"];
+    getCurrentAccountEIP1559Compatibility: (address: string) => boolean;
+    getCurrentNetworkLegacyGasAPICompatibility: () => boolean;
+    fetchGasEstimates?: (url: string) => Promise<EthereumGasFeeEstimates>;
+    fetchEthGasPriceEstimate?: (provider: SafeEventEmitterProvider) => Promise<{
+        gasPrice: string;
+    }>;
+    fetchLegacyGasPriceEstimates?: (url: string) => Promise<EthereumLegacyGasFeeEstimates>;
+    fetchGasEstimatesViaEthFeeHistory?: (provider: SafeEventEmitterProvider) => Promise<EthereumGasFeeEstimates>;
+    onNetworkStateChange: (listener: (networkState: EthereumNetworkState) => void) => void;
+}
+/**
+ * Returns gas prices in dec gwei
+ */
+export default class GasFeeController extends BaseController<EthereumGasConfig, EthereumGasState> {
+    name: string;
+    private intervalId;
+    private provider;
+    private currentChainId;
+    private getNetworkIdentifier;
+    private getProvider;
+    private fetchGasEstimates;
+    private fetchGasEstimatesViaEthFeeHistory;
+    private fetchEthGasPriceEstimate;
+    private fetchLegacyGasPriceEstimates;
+    private getCurrentNetworkEIP1559Compatibility;
+    private getCurrentAccountEIP1559Compatibility;
+    private getCurrentNetworkLegacyGasAPICompatibility;
+    constructor({ config, state, getNetworkIdentifier, getProvider, fetchGasEstimates, fetchEthGasPriceEstimate, fetchLegacyGasPriceEstimates, fetchGasEstimatesViaEthFeeHistory, getCurrentNetworkLegacyGasAPICompatibility, getCurrentNetworkEIP1559Compatibility, getCurrentAccountEIP1559Compatibility, onNetworkStateChange, }: IGasFeeControllerOptions);
+    onNetworkStateChange(): Promise<void>;
+    resetPolling(): Promise<void>;
+    fetchGasFeeEstimates(): Promise<EthereumGasState>;
+    getGasFeeEstimatesAndStartPolling(): Promise<void>;
+    disconnectPoller(): void;
+    /**
+     * Prepare to discard this controller.
+     *
+     * This stops any active polling.
+     */
+    destroy(): void;
+    stopPolling(): void;
+    /**
+     * Gets and sets gasFeeEstimates in state
+     *
+     * @returns GasFeeEstimates
+     */
+    private _fetchGasFeeEstimateData;
+    private _startPolling;
+    private _poll;
+    private resetState;
+    private getEIP1559Compatibility;
+    private getTimeEstimate;
+}
+export {};

package/dist/types/Gas/IGasFeeController.d.ts

@@ -0,0 +1,49 @@
+import { BaseConfig, BaseState } from "@toruslabs/base-controllers";
+import { GAS_ESTIMATE_TYPES } from "../utils/constants";
+export type GasFeeTimeBounds = {
+    lowerTimeBound?: null | number;
+    upperTimeBound?: string | number;
+};
+export type GasFeeEstimates = {
+    minWaitTimeEstimate: number;
+    maxWaitTimeEstimate: number;
+    suggestedMaxPriorityFeePerGas: string;
+    suggestedMaxFeePerGas: string;
+};
+export type EthereumGasFeeEstimates = {
+    estimatedBaseFee: string;
+    low: GasFeeEstimates;
+    medium: GasFeeEstimates;
+    high: GasFeeEstimates;
+};
+export type EthereumLegacyGasFeeEstimates = {
+    low: string;
+    medium: string;
+    high: string;
+};
+export interface GasEstimatesAPIResponse extends EthereumGasFeeEstimates {
+    estimatedBaseFee: string;
+    networkCongestion: number;
+    latestPriorityFeeRange: string[];
+    historicalPriorityFeeRange: string[];
+    historicalBaseFeeRange: string[];
+    priorityFeeTrend: "up" | "down" | "level";
+    baseFeeTrend: "up" | "down" | "level";
+}
+export interface GasEstimatesLegacyAPIResponse {
+    SafeGasPrice: string;
+    ProposeGasPrice: string;
+    FastGasPrice: string;
+}
+export interface EthereumGasConfig extends BaseConfig {
+    interval: number;
+    legacyAPIEndpoint: string;
+    EIP1559APIEndpoint: string;
+}
+export interface EthereumGasState extends BaseState {
+    gasFeeEstimates: EthereumGasFeeEstimates | EthereumLegacyGasFeeEstimates | {
+        gasPrice?: string;
+    };
+    estimatedGasFeeTimeBounds: GasFeeTimeBounds;
+    gasEstimateType: (typeof GAS_ESTIMATE_TYPES)[keyof typeof GAS_ESTIMATE_TYPES];
+}

package/dist/types/Gas/gasUtil.d.ts

@@ -0,0 +1,21 @@
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import BigNumber from "bignumber.js";
+import { EthereumGasFeeEstimates, EthereumLegacyGasFeeEstimates, GasFeeTimeBounds } from "./IGasFeeController";
+export declare function normalizeGWEIDecimalNumbers(n: string | number): number | BigNumber;
+export declare function fetchGasEstimates(url: string): Promise<EthereumGasFeeEstimates>;
+export interface FeeHistoryResponse {
+    baseFeePerGas: string[];
+    gasUsedRatio: string[];
+    oldestBlock: string;
+    reward: string[][];
+}
+export declare function fetchGasEstimatesViaEthFeeHistory(provider: SafeEventEmitterProvider): Promise<EthereumGasFeeEstimates>;
+/**
+ * Hit the legacy MetaSwaps gasPrices estimate api and return the low, medium
+ * high values from that API.
+ */
+export declare function fetchLegacyGasPriceEstimates(url: string): Promise<EthereumLegacyGasFeeEstimates>;
+export declare function fetchEthGasPriceEstimate(provider: SafeEventEmitterProvider): Promise<{
+    gasPrice: string;
+}>;
+export declare function calculateTimeEstimate(maxPriorityFeePerGas: string, maxFeePerGas: string, gasFeeEstimates: EthereumGasFeeEstimates): GasFeeTimeBounds;

package/dist/types/Keyring/KeyringController.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { EthEncryptedData, MessageTypes, SignTypedDataVersion, TypedDataV1, TypedMessage } from "@metamask/eth-sig-util";
+import { BaseConfig, BaseKeyringController, IKeyringController, KeyringControllerState } from "@toruslabs/base-controllers";
+export default class KeyringController extends BaseKeyringController<Partial<BaseConfig>, KeyringControllerState> implements IKeyringController {
+    constructor({ config, state }: {
+        config: Partial<BaseConfig>;
+        state: Partial<KeyringControllerState>;
+    });
+    signTransaction<T, U>(tx: T, address: string): Promise<U>;
+    getAccounts(): string[];
+    importAccount(accountPrivateKey: string): string;
+    removeAccount(address: string): void;
+    getBufferPrivateKey(privateKey: string): Buffer;
+    signMessage(data: string, address: string): string;
+    signPersonalMessage(data: string, address: string): Promise<string>;
+    signTypedData<V extends SignTypedDataVersion, T extends MessageTypes>(typedData: V extends "V1" ? TypedDataV1 : TypedMessage<T>, address: string, version: V): Promise<string>;
+    signEncryptionPublicKey(address: string): string;
+    decryptMessage(data: EthEncryptedData, address: string): string;
+    private _getWalletForAccount;
+}

package/dist/types/Message/AbstractMessageController.d.ts

@@ -0,0 +1,36 @@
+import { SignTypedDataVersion } from "@metamask/eth-sig-util";
+import { BaseConfig, BaseController, BaseState } from "@toruslabs/base-controllers";
+import { JRPCRequest, Json } from "@toruslabs/openlogin-jrpc";
+import NetworkController from "../Network/NetworkController";
+import { AbstractMessage, BaseRequestParams, MessageStatusType, UserRequestApprovalParams } from "../utils/interfaces";
+export interface MessageControllerState<M extends AbstractMessage> extends BaseState {
+    unapprovedMessages: Record<string, M>;
+    unapprovedMessagesCount: number;
+}
+export default abstract class AbstractMessageController<M extends AbstractMessage, P extends BaseRequestParams> extends BaseController<BaseConfig, MessageControllerState<M>> {
+    protected messages: M[];
+    protected getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    /**
+     * Controller in charge of managing - storing, adding, removing, updating - Messages.
+     *
+     */
+    constructor({ config, state, getNetworkIdentifier, }: {
+        config?: Partial<BaseConfig>;
+        state?: Partial<MessageControllerState<M>>;
+        getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    });
+    getMessage(messageId: string): M;
+    getAllMessages(): M[];
+    setMetadata(messageId: string, metadata: Json): void;
+    getUnapprovedMessages(): {
+        [key: string]: M;
+    };
+    addMessage(message: M): Promise<void>;
+    approveMessage(messageParams: P): Promise<P>;
+    setMessageStatus(messageId: string, status: MessageStatusType): void;
+    waitForFinishStatus(msgParams: P, messageName: string): Promise<string>;
+    protected updateMessage(message: M): void;
+    protected saveMessageList(): void;
+    abstract prepMessageForSigning(messageParams: P): Promise<P>;
+    abstract addUnapprovedMessage(messageParams: P, request: JRPCRequest<P> & UserRequestApprovalParams, version?: SignTypedDataVersion): Promise<string>;
+}

package/dist/types/Message/DecryptMessageController.d.ts

@@ -0,0 +1,20 @@
+import { BaseConfig } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import { DecryptMessage, DecryptMessageParams, Message, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+export declare class DecryptMessageController extends AbstractMessageController<DecryptMessage, DecryptMessageParams> {
+    name: string;
+    protected decryptMessage: KeyringController["decryptMessage"];
+    constructor({ config, state, decryptMessage, getNetworkIdentifier, }: {
+        config: Partial<BaseConfig>;
+        state: Partial<MessageControllerState<Message>>;
+        decryptMessage: KeyringController["decryptMessage"];
+        getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    });
+    processDecryptMessage(messageId: string): Promise<string>;
+    addNewUnapprovedMessage(messageParams: DecryptMessageParams, req: JRPCRequest<DecryptMessageParams> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: DecryptMessageParams, req?: JRPCRequest<DecryptMessageParams> & UserRequestApprovalParams): Promise<string>;
+    prepMessageForSigning(messageParams: DecryptMessageParams): Promise<DecryptMessageParams>;
+}

package/dist/types/Message/EncryptionPublicKeyController.d.ts

@@ -0,0 +1,20 @@
+import { BaseConfig } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import { EncryptionPublicKey, EncryptionPublicKeyParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+export declare class EncryptionPublicKeyController extends AbstractMessageController<EncryptionPublicKey, EncryptionPublicKeyParams> {
+    name: string;
+    protected signEncryptionPublicKey: KeyringController["signEncryptionPublicKey"];
+    constructor({ config, state, signEncryptionPublicKey, getNetworkIdentifier, }: {
+        config: Partial<BaseConfig>;
+        state: Partial<MessageControllerState<EncryptionPublicKey>>;
+        signEncryptionPublicKey: KeyringController["signEncryptionPublicKey"];
+        getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    });
+    processGetEncryptionPublicKey(messageId: string): Promise<string>;
+    addNewUnapprovedMessage(messageParams: EncryptionPublicKeyParams, req: JRPCRequest<EncryptionPublicKeyParams> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: EncryptionPublicKeyParams, req?: JRPCRequest<EncryptionPublicKeyParams> & UserRequestApprovalParams): Promise<string>;
+    prepMessageForSigning(messageParams: EncryptionPublicKeyParams): Promise<EncryptionPublicKeyParams>;
+}

package/dist/types/Message/MessageController.d.ts

@@ -0,0 +1,20 @@
+import { BaseConfig } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import { Message, MessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+export declare class MessageController extends AbstractMessageController<Message, MessageParams> {
+    name: string;
+    protected signMessage: KeyringController["signMessage"];
+    constructor({ config, state, signMessage, getNetworkIdentifier, }: {
+        config: Partial<BaseConfig>;
+        state: Partial<MessageControllerState<Message>>;
+        signMessage: KeyringController["signMessage"];
+        getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    });
+    processSignMessage(messageId: string): Promise<string>;
+    addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string>;
+    prepMessageForSigning(messageParams: MessageParams): Promise<MessageParams>;
+}

package/dist/types/Message/PersonalMessageController.d.ts

@@ -0,0 +1,20 @@
+import { BaseConfig } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import { Message, MessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+export declare class PersonalMessageController extends AbstractMessageController<Message, MessageParams> {
+    name: string;
+    protected signPersonalMessage: KeyringController["signPersonalMessage"];
+    constructor({ config, state, signPersonalMessage, getNetworkIdentifier, }: {
+        config: Partial<BaseConfig>;
+        state: Partial<MessageControllerState<Message>>;
+        signPersonalMessage: KeyringController["signPersonalMessage"];
+        getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    });
+    processPersonalSignMessage(messageId: string): Promise<string>;
+    addNewUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string>;
+    addUnapprovedMessage(messageParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams): Promise<string>;
+    prepMessageForSigning(messageParams: MessageParams): Promise<MessageParams>;
+}

package/dist/types/Message/TypedMessageController.d.ts

@@ -0,0 +1,21 @@
+import { SignTypedDataVersion } from "@metamask/eth-sig-util";
+import { BaseConfig } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@toruslabs/openlogin-jrpc";
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import { TypedMessage, TypedMessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+import AbstractMessageController, { MessageControllerState } from "./AbstractMessageController";
+export declare class TypedMessageController extends AbstractMessageController<TypedMessage, TypedMessageParams> {
+    name: string;
+    protected signTypedData: KeyringController["signTypedData"];
+    constructor({ config, state, signTypedData, getNetworkIdentifier, }: {
+        config: Partial<BaseConfig>;
+        state: Partial<MessageControllerState<TypedMessage>>;
+        signTypedData: KeyringController["signTypedData"];
+        getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    });
+    processPersonalSignMessage(messageId: string): Promise<string>;
+    addNewUnapprovedMessage(messageParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams, version: SignTypedDataVersion): Promise<string>;
+    addUnapprovedMessage(messageParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams, version: SignTypedDataVersion): Promise<string>;
+    prepMessageForSigning(messageParams: TypedMessageParams): Promise<TypedMessageParams>;
+}

package/dist/types/Message/utils.d.ts

@@ -0,0 +1,10 @@
+import { EthEncryptedData } from "@metamask/eth-sig-util";
+import { DecryptMessageParams, EncryptionPublicKeyParams, MessageParams, TypedMessageParams } from "../utils/interfaces";
+export declare function validateAddress(address: string, propertyName: string): void;
+export declare function validateSignMessageData(messageData: MessageParams): void;
+export declare function normalizeMessageData(data: string): string;
+export declare function validateTypedSignMessageDataV1(messageData: TypedMessageParams): void;
+export declare function validateTypedSignMessageDataV3V4(messageData: TypedMessageParams, currentChainId: string): void;
+export declare function validateEncryptionPublicKeyMessageData(messageData: EncryptionPublicKeyParams): void;
+export declare function validateDecryptedMessageData(messageData: DecryptMessageParams): void;
+export declare function parseDecryptMessageData(data: string): EthEncryptedData;

package/dist/types/Network/NetworkController.d.ts

@@ -0,0 +1,40 @@
+import { BaseController, INetworkController } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import { EthereumNetworkConfig, EthereumNetworkState, EthereumProviderConfig } from "../utils/interfaces";
+import { IProviderHandlers } from "./createEthereumMiddleware";
+export default class NetworkController extends BaseController<EthereumNetworkConfig, EthereumNetworkState> implements INetworkController<EthereumNetworkConfig, EthereumNetworkState> {
+    name: string;
+    providerProxy: SafeEventEmitterProvider;
+    blockTrackerProxy: PollingBlockTracker;
+    private mutex;
+    private provider?;
+    private blockTracker?;
+    private baseProviderHandlers;
+    constructor({ config, state }: {
+        config?: Partial<EthereumNetworkConfig>;
+        state?: Partial<EthereumNetworkState>;
+    });
+    getNetworkIdentifier(): string;
+    getNetworkRPCUrl(): string;
+    /**
+     * Called by orchestrator once while initializing the class
+     * @param providerHandlers - JRPC handlers for provider
+     * @returns - provider - Returns the providerProxy
+     */
+    initializeProvider(providerHandlers: IProviderHandlers): SafeEventEmitterProvider;
+    getProvider(): SafeEventEmitterProvider;
+    getBlockTracker(): PollingBlockTracker;
+    getProviderConfig(): EthereumProviderConfig;
+    setProviderConfig(config: EthereumProviderConfig): void;
+    getEIP1559Compatibility(): Promise<boolean>;
+    /**
+     * Refreshes the current network code
+     */
+    lookupNetwork(): Promise<void>;
+    private configureProvider;
+    private setNetworkClient;
+    private setProvider;
+    private configureStandardProvider;
+    private refreshNetwork;
+}

package/dist/types/Network/createEthereumMiddleware.d.ts

@@ -0,0 +1,66 @@
+import { InPageWalletProviderState } from "@toruslabs/base-controllers";
+import { JRPCEngineEndCallback, JRPCEngineNextCallback, JRPCMiddleware, JRPCRequest, JRPCResponse } from "@toruslabs/openlogin-jrpc";
+import { BlockParams, EthereumTransactionMeta, MessageParams, TransactionParams, TransactionRPCMeta, TypedMessageParams, UserRequestApprovalParams } from "../utils/interfaces";
+export interface IProviderHandlers {
+    version: string;
+    requestAccounts?: (req: JRPCRequest<string[]>) => Promise<string[]>;
+    getAccounts: (req: JRPCRequest<string[]>) => Promise<string[]>;
+    processTransaction?: (txParams: TransactionParams, req: JRPCRequest<TransactionParams> & UserRequestApprovalParams) => Promise<string>;
+    processEthSignMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
+    processTypedMessage?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
+    processTypedMessageV3?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
+    processTypedMessageV4?: (msgParams: TypedMessageParams, req: JRPCRequest<TypedMessageParams> & UserRequestApprovalParams) => Promise<string>;
+    processPersonalMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
+    processEncryptionPublicKey?: (address: string, req: JRPCRequest<string> & UserRequestApprovalParams) => Promise<string>;
+    processDecryptMessage?: (msgParams: MessageParams, req: JRPCRequest<MessageParams> & UserRequestApprovalParams) => Promise<string>;
+    getPendingNonce?: (nonceParams: {
+        address: string;
+        blockReference: string;
+    }, req: JRPCRequest<{
+        address: string;
+        blockReference: string;
+    }>) => Promise<string>;
+    getPendingTransactionByHash?: (hash: string, req: JRPCRequest<string>) => Promise<EthereumTransactionMeta>;
+    getProviderState: (req: JRPCRequest<[]>, res: JRPCResponse<InPageWalletProviderState>, next: JRPCEngineNextCallback, end: JRPCEngineEndCallback) => void;
+}
+export declare function createGetAccountsMiddleware({ getAccounts }: {
+    getAccounts: IProviderHandlers["getAccounts"];
+}): JRPCMiddleware<never, string[]>;
+export declare function createProcessTransactionMiddleware({ processTransaction, }: {
+    processTransaction: IProviderHandlers["processTransaction"];
+}): JRPCMiddleware<TransactionParams, string>;
+export declare function createProcessEthSignMessage({ processEthSignMessage, }: {
+    processEthSignMessage: IProviderHandlers["processEthSignMessage"];
+}): JRPCMiddleware<MessageParams, string>;
+export declare function createProcessTypedMessage({ processTypedMessage, }: {
+    processTypedMessage: IProviderHandlers["processTypedMessage"];
+}): JRPCMiddleware<MessageParams, string>;
+export declare function createProcessTypedMessageV3({ processTypedMessageV3, }: {
+    processTypedMessageV3: IProviderHandlers["processTypedMessageV3"];
+}): JRPCMiddleware<TypedMessageParams, string>;
+export declare function createProcessTypedMessageV4({ processTypedMessageV4, }: {
+    processTypedMessageV4: IProviderHandlers["processTypedMessageV4"];
+}): JRPCMiddleware<TypedMessageParams, string>;
+export declare function createProcessPersonalMessage({ processPersonalMessage, }: {
+    processPersonalMessage: IProviderHandlers["processPersonalMessage"];
+}): JRPCMiddleware<MessageParams, string>;
+export declare function createPendingNonceMiddleware({ getPendingNonce, }: {
+    getPendingNonce: IProviderHandlers["getPendingNonce"];
+}): JRPCMiddleware<{
+    address: string;
+    blockReference: BlockParams;
+}, string>;
+export declare function formatTxMetaForRpcResult(txMeta: EthereumTransactionMeta): TransactionRPCMeta;
+export declare function createPendingTxMiddleware({ getPendingTransactionByHash, }: {
+    getPendingTransactionByHash: IProviderHandlers["getPendingTransactionByHash"];
+}): JRPCMiddleware<string, TransactionRPCMeta>;
+export declare function createProcessEncryptionPublicKeyMiddleware({ processEncryptionPublicKey, }: {
+    processEncryptionPublicKey: IProviderHandlers["processEncryptionPublicKey"];
+}): JRPCMiddleware<string, string>;
+export declare function createProcessDecryptMessageMiddleware({ processDecryptMessage, }: {
+    processDecryptMessage: IProviderHandlers["processDecryptMessage"];
+}): JRPCMiddleware<MessageParams, string>;
+export declare function createRequestAccountsMiddleware({ requestAccounts, }: {
+    requestAccounts: IProviderHandlers["requestAccounts"];
+}): JRPCMiddleware<string[], unknown>;
+export declare function createEthereumMiddleware(providerHandlers: IProviderHandlers): JRPCMiddleware<unknown, unknown>;

package/dist/types/Network/createJsonRpcClient.d.ts

@@ -0,0 +1,9 @@
+import { ProviderConfig } from "@toruslabs/base-controllers";
+import { JRPCMiddleware } from "@toruslabs/openlogin-jrpc";
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+export declare function createChainIdMiddleware(chainId: string): JRPCMiddleware<unknown, string>;
+export declare function createProviderConfigMiddleware(providerConfig: ProviderConfig): JRPCMiddleware<unknown, ProviderConfig>;
+export declare function createJsonRpcClient(providerConfig: ProviderConfig): {
+    networkMiddleware: JRPCMiddleware<unknown, unknown>;
+    blockTracker: PollingBlockTracker;
+};

package/dist/types/Nfts/INftsController.d.ts

@@ -0,0 +1,10 @@
+import { BaseConfig, BaseState } from "@toruslabs/base-controllers";
+import { CustomNftInfo } from "../utils/interfaces";
+export interface NftsControllerConfig extends BaseConfig {
+    interval?: number;
+    selectedAddress: string;
+    chainId: string;
+}
+export interface NftsControllerState extends BaseState {
+    nfts: Record<string, CustomNftInfo[]>;
+}

package/dist/types/Nfts/NftHandler.d.ts

@@ -0,0 +1,35 @@
+import { BrowserProvider } from "ethers";
+import { CustomNftInfo, CustomNftItemInfo } from "../utils/interfaces";
+interface INftOptions {
+    contractAddress: string;
+    contractName?: string;
+    contractSymbol?: string;
+    contractImage?: string;
+    contractSupply?: string;
+    contractFallbackLogo?: string;
+    nftStandard?: "erc721" | "erc1155";
+    contractDescription?: string;
+    chainId: string;
+    provider: BrowserProvider;
+}
+export declare class NftHandler {
+    contractAddress: string;
+    contractName: string;
+    contractSymbol: string;
+    contractImage: string;
+    contractSupply?: string;
+    contractFallbackLogo?: string;
+    nftStandard: "erc721" | "erc1155";
+    contractDescription?: string;
+    chainId: string;
+    provider: BrowserProvider;
+    isSpecial?: boolean;
+    constructor({ chainId, contractAddress, contractImage, contractName, contractSymbol, nftStandard, provider, contractDescription, contractFallbackLogo, contractSupply, }: INftOptions);
+    getNftMetadata(userAddress: string, tokenInfo: Partial<CustomNftItemInfo>): Promise<CustomNftItemInfo>;
+    getContractMetadata(): Promise<Omit<CustomNftInfo, "assets">>;
+    fetchNftBalance(userAddress: string, tokenId: string): Promise<string>;
+    private checkNftStandard;
+    private contractSupportsInterface;
+    private getCollectibleTokenURI;
+}
+export {};

package/dist/types/Nfts/NftsController.d.ts

@@ -0,0 +1,40 @@
+import { BaseController, PreferencesState } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import NetworkController from "../Network/NetworkController";
+import PreferencesController from "../Preferences/PreferencesController";
+import { CustomNftInfo, EthereumNetworkState, ExtendedAddressPreferences } from "../utils/interfaces";
+import { NftsControllerConfig, NftsControllerState } from "./INftsController";
+export interface INftsControllerOptions {
+    config?: Partial<NftsControllerConfig>;
+    state?: Partial<NftsControllerState>;
+    provider: SafeEventEmitterProvider;
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    getCustomNfts?: PreferencesController["getCustomNfts"];
+    getSimpleHashNfts: PreferencesController["getSimpleHashNfts"];
+    onPreferencesStateChange: (listener: (preferencesState: PreferencesState<ExtendedAddressPreferences>) => void) => void;
+    onNetworkStateChange: (listener: (networkState: EthereumNetworkState) => void) => void;
+}
+export declare class NftsController extends BaseController<NftsControllerConfig, NftsControllerState> {
+    name: string;
+    private provider;
+    private ethersProvider;
+    private _timer;
+    private getNetworkIdentifier;
+    private getCustomNfts;
+    private getSimpleHashNfts;
+    constructor({ config, state, provider, getNetworkIdentifier, getCustomNfts, getSimpleHashNfts, onPreferencesStateChange, onNetworkStateChange, }: INftsControllerOptions);
+    get userSelectedAddress(): string;
+    get userNfts(): CustomNftInfo[];
+    get interval(): number;
+    set interval(interval: number);
+    startNftDetection(selectedAddress: string): void;
+    /**
+     * Restart nft detection polling period and call detectNewNfts
+     * in case of address change or user session initialization.
+     *
+     */
+    restartNftDetection(): void;
+    detectNewNfts(): void;
+    refreshNftBalances(): Promise<void>;
+    getNftBalancesUsingHandler(customNfts: CustomNftInfo[]): Promise<void>;
+}