@toruslabs/ethereum-controllers 4.1.0

package/dist/types/Preferences/PreferencesController.d.ts

@@ -0,0 +1,53 @@
+import { BasePreferencesController, CustomNft, CustomToken, IPreferencesController, PreferencesConfig, PreferencesState, UserInfo } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import type { CustomNetworkPayload, CustomNftInfo, CustomTokenInfo, ExtendedAddressPreferences, TransactionPayload } from "../utils/interfaces";
+interface IPreferencesControllerOptions {
+    config?: Partial<PreferencesConfig> & Pick<PreferencesConfig, "api" | "commonApiHost" | "signInPrefix">;
+    state?: Partial<PreferencesState<ExtendedAddressPreferences>>;
+    provider: SafeEventEmitterProvider;
+    blockTracker?: PollingBlockTracker;
+    signAuthMessage?: KeyringController["signAuthMessage"];
+    getProviderConfig?: NetworkController["getProviderConfig"];
+}
+export default class PreferencesController extends BasePreferencesController<ExtendedAddressPreferences, PreferencesConfig, PreferencesState<ExtendedAddressPreferences>> implements IPreferencesController<ExtendedAddressPreferences, PreferencesConfig, PreferencesState<ExtendedAddressPreferences>> {
+    private _handle?;
+    private _mutex;
+    private getProviderConfig;
+    private provider;
+    private blockTracker;
+    constructor({ config, state, provider, blockTracker, signAuthMessage, getProviderConfig }: IPreferencesControllerOptions);
+    poll(interval?: number): Promise<void>;
+    initPreferences(params: {
+        address: string;
+        jwtToken?: string;
+        calledFromEmbed?: boolean;
+        userInfo?: UserInfo;
+        rehydrate?: boolean;
+        locale?: string;
+    }): Promise<void>;
+    getSelectedAddress(): string;
+    sync(address: string): Promise<boolean>;
+    patchNewTx(tx: TransactionPayload, address: string): Promise<void>;
+    recalculatePastTx(address?: string): void;
+    refetchEtherscanTx(address?: string): Promise<void>;
+    getEtherScanTokens(address: string, chainId: string): Promise<CustomTokenInfo[]>;
+    getSimpleHashNfts(address: string, chainId: string): Promise<CustomNftInfo[]>;
+    getCustomTokens(address?: string): CustomToken[];
+    getCustomNfts(address?: string): CustomNft[];
+    addCustomNetwork({ type, network }: {
+        type: string;
+        network: CustomNetworkPayload;
+    }): Promise<number>;
+    deleteCustomNetwork(id: number): Promise<boolean>;
+    editCustomNetwork({ network, id }: {
+        network: CustomNetworkPayload;
+        id: number | null;
+    }): Promise<boolean>;
+    private calculatePaymentTx;
+    private calculatePastTx;
+    private cancelTxCalculate;
+}
+export {};

package/dist/types/Tokens/ITokensController.d.ts

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

package/dist/types/Tokens/TokenHandler.d.ts

@@ -0,0 +1,20 @@
+import { BrowserProvider, Contract } from "ethers";
+export interface ITokenOptions {
+    address: string;
+    symbol: string;
+    decimals: number;
+    name: string;
+    provider: BrowserProvider;
+}
+export declare class TokenHandler {
+    address: string;
+    symbol: string;
+    decimals: number;
+    name: string;
+    contract: Contract;
+    constructor({ address, symbol, decimals, name, provider }: ITokenOptions);
+    getSymbol(): Promise<string>;
+    getDecimals(): Promise<number>;
+    getName(): Promise<string>;
+    getUserBalance(userAddress: string): Promise<string>;
+}

package/dist/types/Tokens/TokenRatesController.d.ts

@@ -0,0 +1,42 @@
+import { BaseConfig, BaseController, BaseState, PreferencesState } from "@toruslabs/base-controllers";
+import { CustomTokenInfo, EthereumNetworkState, ExtendedAddressPreferences } from "../utils/interfaces";
+import { TokensControllerState } from "./ITokensController";
+export interface CoinGeckoResponse {
+    [address: string]: {
+        [currency: string]: number;
+    };
+}
+type ContractExchangeRates = Record<string, number | undefined>;
+export declare const DEFAULT_CURRENCY = "eth";
+export interface ITokenRatesControllerState extends BaseState {
+    contractExchangeRates: ContractExchangeRates;
+}
+export interface ITokenRatesControllerConfig extends BaseConfig {
+    pollInterval: number;
+    api: string;
+    currencyApi: string;
+    chainId: string;
+    selectedAddress: string;
+    nativeCurrency: string;
+    tokens: CustomTokenInfo[];
+}
+export interface TokenRatesControllerOptions {
+    config: Partial<ITokenRatesControllerConfig>;
+    state: Partial<ITokenRatesControllerState>;
+    onPreferencesStateChange: (listener: (preferencesState: PreferencesState<ExtendedAddressPreferences>) => void) => void;
+    onTokensStateChange: (listener: (tokensState: TokensControllerState) => void) => void;
+    onNetworkStateChange: (listener: (networkState: EthereumNetworkState) => void) => void;
+}
+export declare class TokenRatesController extends BaseController<ITokenRatesControllerConfig, ITokenRatesControllerState> {
+    private conversionInterval;
+    constructor({ config, state, onPreferencesStateChange, onNetworkStateChange, onTokensStateChange }: TokenRatesControllerOptions);
+    /**
+     * 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;
+    updateExchangeRates(): Promise<void>;
+    private fetchExchangeRates;
+}
+export {};

package/dist/types/Tokens/TokensController.d.ts

@@ -0,0 +1,42 @@
+import { BaseController, PreferencesState } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import NetworkController from "../Network/NetworkController";
+import PreferencesController from "../Preferences/PreferencesController";
+import { CustomTokenInfo, EthereumNetworkState, ExtendedAddressPreferences } from "../utils/interfaces";
+import { TokensControllerConfig, TokensControllerState } from "./ITokensController";
+export interface ITokensControllerOptions {
+    config?: Partial<TokensControllerConfig>;
+    state?: Partial<TokensControllerState>;
+    provider: SafeEventEmitterProvider;
+    getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+    getCustomTokens?: PreferencesController["getCustomTokens"];
+    getEtherScanTokens: PreferencesController["getEtherScanTokens"];
+    getProviderConfig: NetworkController["getProviderConfig"];
+    onPreferencesStateChange: (listener: (preferencesState: PreferencesState<ExtendedAddressPreferences>) => void) => void;
+    onNetworkStateChange: (listener: (networkState: EthereumNetworkState) => void) => void;
+}
+export declare class TokensController extends BaseController<TokensControllerConfig, TokensControllerState> {
+    name: string;
+    private provider;
+    private ethersProvider;
+    private _timer;
+    private getNetworkIdentifier;
+    private getProviderConfig;
+    private getCustomTokens;
+    private getEtherScanTokens;
+    constructor({ config, state, provider, getNetworkIdentifier, getCustomTokens, getEtherScanTokens, getProviderConfig, onPreferencesStateChange, onNetworkStateChange, }: ITokensControllerOptions);
+    get userSelectedAddress(): string;
+    get userTokens(): CustomTokenInfo[];
+    get interval(): number;
+    set interval(interval: number);
+    startTokenDetection(selectedAddress: string): void;
+    /**
+     * Restart token detection polling period and call detectNewTokens
+     * in case of address change or user session initialization.
+     *
+     */
+    restartTokenDetection(): void;
+    detectNewTokens(): void;
+    refreshTokenBalances(): Promise<void>;
+    getTokenBalancesUsingHandler(customTokens: CustomTokenInfo[]): Promise<void>;
+}

package/dist/types/Transaction/NonceTracker.d.ts

@@ -0,0 +1,37 @@
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { MutexInterface } from "async-mutex";
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import { NonceLockRes } from "../utils/interfaces";
+import TransactionStateManager from "./TransactionStateManager";
+interface INonceTrackerOptions {
+    provider: SafeEventEmitterProvider;
+    blockTracker: PollingBlockTracker;
+    getPendingTransactions: TransactionStateManager["getPendingTransactions"];
+    getConfirmedTransactions: TransactionStateManager["getConfirmedTransactions"];
+}
+declare class NonceTracker {
+    private provider;
+    private blockTracker;
+    private getPendingTransactions;
+    private getConfirmedTransactions;
+    private lockMap;
+    constructor({ provider, blockTracker, getPendingTransactions, getConfirmedTransactions }: INonceTrackerOptions);
+    getGlobalLock(): Promise<{
+        releaseLock: MutexInterface.Releaser;
+    }>;
+    /**
+      this will return an object with the `nextNonce`
+      `nonceDetails`, and the releaseLock.
+      Note: releaseLock must be called after adding a signed tx
+      to pending transactions (or discarding).
+    */
+    getNonceLock(address: string): Promise<NonceLockRes>;
+    private _globalMutexFree;
+    private _takeMutex;
+    private _lookupMutex;
+    private _getNetworkNextNonce;
+    private _getHighestLocallyConfirmed;
+    private _getHighestNonce;
+    private _getHighestContinuousFrom;
+}
+export default NonceTracker;

package/dist/types/Transaction/PendingTransactionTracker.d.ts

@@ -0,0 +1,32 @@
+import { ITransactionController } from "@toruslabs/base-controllers";
+import { SafeEventEmitter, SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { EthereumBlock, EthereumTransactionMeta } from "../utils/interfaces";
+import NonceTracker from "./NonceTracker";
+import TransactionStateManager from "./TransactionStateManager";
+export default class PendingTransactionTracker extends SafeEventEmitter {
+    DROPPED_BUFFER_COUNT: number;
+    private nonceTracker;
+    private provider;
+    private approveTransaction;
+    private droppedBlocksBufferByHash;
+    private getConfirmedTransactions;
+    private getPendingTransactions;
+    private publishTransaction;
+    constructor({ provider, nonceTracker, approveTransaction, publishTransaction, getPendingTransactions, getConfirmedTransactions, }: {
+        provider: SafeEventEmitterProvider;
+        nonceTracker: NonceTracker;
+        approveTransaction: ITransactionController<EthereumTransactionMeta>["approveTransaction"];
+        publishTransaction: (rawTx: string) => Promise<string>;
+        getPendingTransactions: TransactionStateManager["getPendingTransactions"];
+        getConfirmedTransactions: TransactionStateManager["getConfirmedTransactions"];
+    });
+    /**
+      checks the network for signed txs and releases the nonce global lock if it is
+    */
+    updatePendingTxs(): Promise<void>;
+    resubmitPendingTxs(block: EthereumBlock): Promise<void>;
+    _resubmitTx(txMeta: EthereumTransactionMeta, latestBlockNumber?: string): Promise<string | void>;
+    _checkPendingTx(foundTx: EthereumTransactionMeta): Promise<void>;
+    _checkIfTxWasDropped(txMeta: EthereumTransactionMeta): Promise<boolean>;
+    _checkIfNonceIsTaken(txMeta: EthereumTransactionMeta): boolean;
+}

package/dist/types/Transaction/TransactionController.d.ts

@@ -0,0 +1,67 @@
+import { ITransactionController, TransactionConfig, TransactionState, TX_CONFIRMED_EVENT_TYPE } from "@toruslabs/base-controllers";
+import { JRPCRequest, SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import GasFeeController from "../Gas/GasFeeController";
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import PreferencesController from "../Preferences/PreferencesController";
+import { EthereumTransactionMeta, TransactionParams, UserRequestApprovalParams } from "../utils/interfaces";
+import NonceTracker from "./NonceTracker";
+import PendingTransactionTracker from "./PendingTransactionTracker";
+import TransactionGasUtil from "./TransactionGasUtil";
+import TransactionStateManager from "./TransactionStateManager";
+export default class TransactionController extends TransactionStateManager implements ITransactionController<TransactionParams> {
+    getSelectedAddress: PreferencesController["getSelectedAddress"];
+    getEIP1559GasFeeEstimates: GasFeeController["fetchGasFeeEstimates"];
+    nonceTracker: NonceTracker;
+    pendingTxTracker: PendingTransactionTracker;
+    txGasUtil: TransactionGasUtil;
+    private _getCurrentNetworkEIP1559Compatibility;
+    private _getCurrentAccountEIP1559Compatibility;
+    private getProviderConfig;
+    private signEthTx;
+    private provider;
+    private blockTracker;
+    private inProcessOfSigning;
+    constructor({ config, state, provider, blockTracker, signEthTx, getCurrentChainId, getCurrentNetworkEIP1559Compatibility, getProviderConfig, getCurrentAccountEIP1559Compatibility, getSelectedAddress, getEIP1559GasFeeEstimates, }: {
+        config?: Partial<TransactionConfig>;
+        state?: Partial<TransactionState<TransactionParams, EthereumTransactionMeta>>;
+        provider: SafeEventEmitterProvider;
+        blockTracker: PollingBlockTracker;
+        signEthTx: KeyringController["signTransaction"];
+        getCurrentChainId: NetworkController["getNetworkIdentifier"];
+        getProviderConfig: NetworkController["getProviderConfig"];
+        getCurrentNetworkEIP1559Compatibility: NetworkController["getEIP1559Compatibility"];
+        getCurrentAccountEIP1559Compatibility: (address?: string) => Promise<boolean>;
+        getSelectedAddress: PreferencesController["getSelectedAddress"];
+        getEIP1559GasFeeEstimates: GasFeeController["fetchGasFeeEstimates"];
+    });
+    addTransactionUnapproved(txMeta: EthereumTransactionMeta): void;
+    addNewUnapprovedTransaction(txParams: TransactionParams, req: JRPCRequest<TransactionParams> & UserRequestApprovalParams & {
+        origin: string;
+    }): Promise<string>;
+    processApproval(txMeta: EthereumTransactionMeta): Promise<string>;
+    approveTransaction(transactionID: string): Promise<void>;
+    signTransaction(txId: string): Promise<string>;
+    publishTransaction(txId: string, rawTx: string): Promise<void>;
+    confirmTransaction(params: TX_CONFIRMED_EVENT_TYPE): Promise<void>;
+    cancelTransaction?(transactionID: string): Promise<void>;
+    getEIP1559Compatibility(fromAddress?: string): Promise<boolean>;
+    addTransactionGasDefaults(txMeta: EthereumTransactionMeta): Promise<EthereumTransactionMeta>;
+    addTxGasDefaults(txMeta: EthereumTransactionMeta): Promise<EthereumTransactionMeta>;
+    setTxHash(txId: string, txHash: string): void;
+    getUnapprovedTxCount: () => number;
+    getPendingTxCount: (account?: string) => number;
+    getDefaultGasFees(txMeta: EthereumTransactionMeta, eip1559Compatibility: boolean): Promise<{
+        maxFeePerGas?: string;
+        maxPriorityFeePerGas?: string;
+        gasPrice?: string;
+    }>;
+    private getDefaultGasLimit;
+    private createTransaction;
+    private _setupListeners;
+    private setupBlockTrackerListener;
+    private onLatestBlock;
+    private getCommonConfiguration;
+    private markNonceDuplicatesDropped;
+}

package/dist/types/Transaction/TransactionGasUtil.d.ts

@@ -0,0 +1,21 @@
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import { EthereumTransactionMeta } from "../utils/interfaces";
+export default class TransactionGasUtil {
+    provider: SafeEventEmitterProvider;
+    blockTracker: PollingBlockTracker;
+    constructor(provider: SafeEventEmitterProvider, blockTracker: PollingBlockTracker);
+    analyzeGasUsage(txMeta: EthereumTransactionMeta): Promise<{
+        blockGasLimit: string;
+        estimatedGasHex: string;
+        simulationFails: Record<string, unknown>;
+    }>;
+    /**
+      Adds a gas buffer with out exceeding the block gas limit
+    */
+    addGasBuffer(initialGasLimitHex: string, blockGasLimitHex: string, multiplier?: number): string;
+    /**
+      Estimates the tx's gas usage
+    */
+    private estimateTxGas;
+}

package/dist/types/Transaction/TransactionStateHistoryHelper.d.ts

@@ -0,0 +1,16 @@
+import { EthereumTransactionMeta } from "../utils/interfaces";
+/**
+  Generates an array of history objects sense the previous state.
+  The object has the keys
+    op (the operation performed),
+    path (the key and if a nested object then each key will be seperated with a `/`)
+    value
+  with the first entry having the note and a timestamp when the change took place
+*/
+declare function generateHistoryEntry(previousState: Record<string, unknown>, newState: Record<string, unknown>, note?: string): Record<string, unknown>[];
+/**
+  Recovers previous txMeta state obj
+*/
+declare function replayHistory(_shortHistory: Record<string, unknown>[]): Record<string, unknown>;
+declare function snapshotFromTxMeta(txMeta: EthereumTransactionMeta): EthereumTransactionMeta;
+export { generateHistoryEntry, replayHistory, snapshotFromTxMeta };

package/dist/types/Transaction/TransactionStateManager.d.ts

@@ -0,0 +1,30 @@
+import { BaseTransactionStateManager, ITransactionStateManager, TransactionConfig, TransactionState, TransactionStatus } from "@toruslabs/base-controllers";
+import NetworkController from "../Network/NetworkController";
+import { EthereumTransactionMeta, TransactionParams } from "../utils/interfaces";
+export default class TransactionStateManager extends BaseTransactionStateManager<TransactionParams, EthereumTransactionMeta> implements ITransactionStateManager<TransactionParams> {
+    constructor({ config, state, getCurrentChainId, }: {
+        config?: Partial<TransactionConfig>;
+        state?: Partial<TransactionState<TransactionParams, EthereumTransactionMeta>>;
+        getCurrentChainId: NetworkController["getNetworkIdentifier"];
+    });
+    generateTxMeta(opts?: Partial<EthereumTransactionMeta>): EthereumTransactionMeta;
+    addTransactionToState(txMeta: EthereumTransactionMeta): EthereumTransactionMeta;
+    /**
+      Removes transaction from the given address for the current network
+      from the txList
+    */
+    wipeTransactions(address: string): void;
+    getTransactions({ searchCriteria, initialList, filterToCurrentNetwork, limit, }?: {
+        searchCriteria?: Record<string, (val: unknown) => boolean> | Record<string, unknown>;
+        initialList?: EthereumTransactionMeta[];
+        filterToCurrentNetwork?: boolean;
+        limit?: number;
+    }): EthereumTransactionMeta[];
+    getApprovedTransactions(address?: string): EthereumTransactionMeta[];
+    getSubmittedTransactions(address?: string): EthereumTransactionMeta[];
+    getPendingTransactions(address?: string): EthereumTransactionMeta[];
+    getConfirmedTransactions(address?: string): EthereumTransactionMeta[];
+    getUnapprovedTxList(): Record<string, EthereumTransactionMeta>;
+    updateTransactionInState(txMeta: EthereumTransactionMeta, note?: string): void;
+    protected _setTransactionStatus(txId: string, status: TransactionStatus, isFinalStep?: boolean): void;
+}

package/dist/types/Transaction/TransactionUtils.d.ts

@@ -0,0 +1,70 @@
+import { TransactionStatus } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { EthereumTransactionMeta, TransactionParams } from "../utils/interfaces";
+type NormalizableTransactionParams = keyof Omit<TransactionParams, "accessList">;
+/**
+ * normalizes txParams
+ */
+export declare function normalizeTxParameters(txParameters: TransactionParams, lowerCase?: boolean): TransactionParams;
+export declare function transactionMatchesNetwork(transaction: EthereumTransactionMeta, chainId: string): boolean;
+/**
+ * Determines if the maxFeePerGas and maxPriorityFeePerGas fields are supplied
+ * and valid inputs. This will return false for non hex string inputs.
+ *  the transaction to check
+ * @returns true if transaction uses valid EIP1559 fields
+ */
+export declare function isEIP1559Transaction(transaction: Partial<EthereumTransactionMeta>): boolean;
+/**
+ * Determine if the maxFeePerGas and maxPriorityFeePerGas fields are not
+ * supplied and that the gasPrice field is valid if it is provided. This will
+ * return false if gasPrice is a non hex string.
+ * transaction -
+ *  the transaction to check
+ * @returns true if transaction uses valid Legacy fields OR lacks
+ *  EIP1559 fields
+ */
+export declare function isLegacyTransaction(transaction: EthereumTransactionMeta): boolean;
+/**
+ * Given two fields, ensure that the second field is not included in txParams,
+ * and if it is throw an invalidParams error.
+ */
+export declare function ensureMutuallyExclusiveFieldsNotProvided(txParams: TransactionParams, fieldBeingValidated: NormalizableTransactionParams, mutuallyExclusiveField: NormalizableTransactionParams): void;
+/**
+ * Ensures that the provided value for field is a string, throws an
+ * invalidParams error if field is not a string.
+ */
+export declare function ensureFieldIsString(txParams: TransactionParams, field: NormalizableTransactionParams): void;
+/**
+ * validates the from field in  txParams
+ */
+export declare function validateFrom(txParams: TransactionParams): void;
+/**
+ * validates the to field in  txParams
+ */
+export declare function validateRecipient(txParameters: TransactionParams): TransactionParams;
+/**
+ * Validates the given tx parameters
+ * @throws if the tx params contains invalid fields
+ */
+export declare function validateTxParameters(txParams: TransactionParams, eip1559Compatibility?: boolean): void;
+export declare function normalizeAndValidateTxParams(txParams: TransactionParams, lowerCase?: boolean): TransactionParams;
+/**
+ * @returns an array of states that can be considered final
+ */
+export declare function getFinalStates(): TransactionStatus[];
+export declare function parseStandardTokenTransactionData(data: string): {
+    name: string;
+    methodParams: any[];
+    type: string;
+};
+export declare const readAddressAsContract: (provider: SafeEventEmitterProvider, address: string) => Promise<{
+    contractCode: string;
+    isContractAddress: boolean;
+}>;
+export declare function determineTransactionType(txParams: TransactionParams, provider: SafeEventEmitterProvider): Promise<{
+    type: string;
+    category: string;
+    methodParams: any[];
+    getCodeResponse: string;
+}>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,43 @@
+export { default as AccountTrackerController } from "./Account/AccountTrackerController";
+export { default as PollingBlockTracker } from "./Block/PollingBlockTracker";
+export { default as CurrencyController } from "./Currency/CurrencyController";
+export { default as GasFeeController } from "./Gas/GasFeeController";
+export * from "./Gas/IGasFeeController";
+export { default as KeyringController } from "./Keyring/KeyringController";
+export * from "./Message/AbstractMessageController";
+export * from "./Message/DecryptMessageController";
+export * from "./Message/EncryptionPublicKeyController";
+export * from "./Message/MessageController";
+export * from "./Message/PersonalMessageController";
+export * from "./Message/TypedMessageController";
+export * from "./Message/utils";
+export * from "./Network/createEthereumMiddleware";
+export * from "./Network/createJsonRpcClient";
+export { default as NetworkController } from "./Network/NetworkController";
+export * from "./Nfts/INftsController";
+export * from "./Nfts/NftHandler";
+export * from "./Nfts/NftsController";
+export { default as PreferencesController } from "./Preferences/PreferencesController";
+export * from "./Tokens/ITokensController";
+export * from "./Tokens/TokenHandler";
+export * from "./Tokens/TokenRatesController";
+export * from "./Tokens/TokensController";
+export { default as NonceTracker } from "./Transaction/NonceTracker";
+export { default as PendingTransactionTracker } from "./Transaction/PendingTransactionTracker";
+export { default as TransactionController } from "./Transaction/TransactionController";
+export { default as TransactionGasUtil } from "./Transaction/TransactionGasUtil";
+export * from "./Transaction/TransactionStateHistoryHelper";
+export { default as TransactionStateManager } from "./Transaction/TransactionStateManager";
+export * from "./Transaction/TransactionUtils";
+export * from "./utils/constants";
+export * from "./utils/helpers";
+export * from "./utils/interfaces";
+/**
+ * Pending controllers
+ * - Transaction Controllers
+//  * - AA Controller
+ */
+/**
+ * Backend apis
+ * - Preferences Controller
+ */

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

@@ -0,0 +1,17 @@
+declare class AbiDecoder {
+    state: {
+        savedABIs: any[];
+        methodIDs: Record<string, any>;
+    };
+    constructor(abi: any);
+    getABIs(): any[];
+    addABI(abiArray: any): void;
+    removeABI(abiArray: any): void;
+    getMethodIDs(): Record<string, any>;
+    decodeMethod(data: any): {
+        name: any;
+        params: any[];
+    };
+    decodeLogs(logs: any): any;
+}
+export default AbiDecoder;

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

@@ -0,0 +1,84 @@
+export declare const ecr20Abi: ({
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    type: string;
+} | {
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    type: string;
+    constant?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+} | {
+    payable: boolean;
+    type: string;
+    constant?: undefined;
+    inputs?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+})[];
+export declare const erc721Abi: {
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+}[];
+export declare const erc1155Abi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+export declare const singleBalanceCheckerAbi: ({
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    constant?: undefined;
+    inputs?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+} | {
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+})[];