@toruslabs/ethereum-controllers 4.1.0

package/src/Nfts/NftsController.ts

@@ -0,0 +1,230 @@
+import { BaseController, PreferencesState } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { BrowserProvider } from "ethers";
+import { merge } from "lodash";
+import log from "loglevel";
+
+import NetworkController from "../Network/NetworkController";
+import PreferencesController from "../Preferences/PreferencesController";
+import { SIMPLEHASH_SUPPORTED_CHAINS } from "../utils/constants";
+import { idleTimeTracker } from "../utils/helpers";
+import { CustomNftInfo, CustomNftItemInfo, EthereumNetworkState, ExtendedAddressPreferences } from "../utils/interfaces";
+import { NftsControllerConfig, NftsControllerState } from "./INftsController";
+import { NftHandler } from "./NftHandler";
+
+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;
+}
+
+const DEFAULT_INTERVAL = 180 * 1000;
+
+export class NftsController extends BaseController<NftsControllerConfig, NftsControllerState> {
+  name = "NftsController";
+
+  private provider: SafeEventEmitterProvider;
+
+  private ethersProvider: BrowserProvider;
+
+  private _timer: number;
+
+  private getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+
+  private getCustomNfts: PreferencesController["getCustomNfts"];
+
+  private getSimpleHashNfts: PreferencesController["getSimpleHashNfts"];
+
+  constructor({
+    config,
+    state,
+    provider,
+    getNetworkIdentifier,
+    getCustomNfts,
+    getSimpleHashNfts,
+    onPreferencesStateChange,
+    onNetworkStateChange,
+  }: INftsControllerOptions) {
+    super({ config, state });
+
+    this.provider = provider;
+    this.ethersProvider = new BrowserProvider(this.provider, "any");
+    this.getNetworkIdentifier = getNetworkIdentifier;
+
+    this.getCustomNfts = getCustomNfts;
+    this.getSimpleHashNfts = getSimpleHashNfts;
+
+    this.defaultConfig = {
+      interval: DEFAULT_INTERVAL,
+      selectedAddress: "",
+      chainId: "",
+    };
+
+    this.defaultState = {
+      nfts: {},
+    };
+    this.initialize();
+    onPreferencesStateChange((preferencesState) => {
+      if (preferencesState.selectedAddress !== this.config.selectedAddress) {
+        this.configure({ selectedAddress: preferencesState.selectedAddress });
+        this.restartNftDetection();
+      }
+    });
+
+    onNetworkStateChange((networkState) => {
+      const { chainId } = networkState.providerConfig;
+      if (chainId !== this.config.chainId) {
+        this.configure({ chainId });
+        this.restartNftDetection();
+      }
+    });
+  }
+
+  get userSelectedAddress(): string {
+    return this.config.selectedAddress;
+  }
+
+  get userNfts() {
+    if (!this.userSelectedAddress) return [];
+    return this.state.nfts[this.userSelectedAddress] ?? [];
+  }
+
+  get interval(): number {
+    return this.config.interval;
+  }
+
+  set interval(interval: number) {
+    if (this._timer) window.clearInterval(this._timer);
+    if (!interval) {
+      return;
+    }
+    this._timer = window.setInterval(() => {
+      if (!idleTimeTracker.checkIfIdle()) {
+        this.detectNewNfts();
+        this.refreshNftBalances();
+      }
+    }, interval);
+  }
+
+  public startNftDetection(selectedAddress: string) {
+    this.configure({ selectedAddress });
+    this.restartNftDetection();
+  }
+
+  /**
+   * Restart nft detection polling period and call detectNewNfts
+   * in case of address change or user session initialization.
+   *
+   */
+  public restartNftDetection() {
+    if (!this.userSelectedAddress) {
+      return;
+    }
+    this.detectNewNfts();
+    this.refreshNftBalances();
+    this.config.interval = DEFAULT_INTERVAL;
+  }
+
+  public detectNewNfts() {
+    const userAddress = this.userSelectedAddress;
+    if (!userAddress) return;
+    const currentChainId = this.getNetworkIdentifier();
+    const nftsToDetect: CustomNftInfo[] = []; // object[]
+    if (!currentChainId) {
+      this.update({ nfts: { [userAddress]: [...nftsToDetect] } });
+      return;
+    }
+
+    if (this.getCustomNfts) {
+      const customNfts = this.getCustomNfts(userAddress);
+
+      const reducedNfts = customNfts.reduce(
+        (acc, x) => {
+          // first aggregate by contract address
+          if (x.network === currentChainId) {
+            const newAsset: CustomNftItemInfo = {
+              description: "",
+              image: "",
+              name: "",
+              tokenBalance: "",
+              tokenId: x.nft_id,
+              customNftId: x.id.toString(),
+            };
+            if (acc[x.nft_address]) {
+              acc[x.nft_address].assets.push(newAsset);
+            } else {
+              const objToPush: CustomNftInfo = {
+                assets: [newAsset],
+                chainId: x.network,
+                contractAddress: x.nft_address,
+                contractName: "",
+                contractSymbol: "",
+                contractImage: "",
+                nftStandard: x.nft_contract_standard,
+                contractDescription: "",
+              } as CustomNftInfo;
+              acc[x.nft_address] = objToPush;
+            }
+          }
+          return acc;
+        },
+        {} as Record<string, CustomNftInfo>
+      );
+      nftsToDetect.push(...Object.values(reducedNfts));
+    }
+    this.update({ nfts: { [userAddress]: [...nftsToDetect] } });
+  }
+
+  async refreshNftBalances() {
+    const userAddress = this.userSelectedAddress;
+    if (userAddress === "") return;
+    const oldNfts = [...this.userNfts];
+    const nonZeroNfts: CustomNftInfo[] = [];
+    try {
+      const currentChainId = this.getNetworkIdentifier();
+      if (SIMPLEHASH_SUPPORTED_CHAINS.includes(currentChainId)) {
+        const simpleHashBalances = await this.getSimpleHashNfts(userAddress, currentChainId);
+        nonZeroNfts.push(...simpleHashBalances);
+        this.update({ nfts: { [userAddress]: nonZeroNfts } });
+      }
+      if (oldNfts.length > 0) {
+        this.getNftBalancesUsingHandler(oldNfts);
+      }
+    } catch (error) {
+      log.error(error, "unable to fetch nft balances");
+    }
+  }
+
+  async getNftBalancesUsingHandler(customNfts: CustomNftInfo[]) {
+    if (!this.userSelectedAddress) return;
+    const userAddress = this.userSelectedAddress;
+    const currentNetworkNfts = customNfts;
+    const promiseSettledResult = await Promise.allSettled(
+      currentNetworkNfts.map(async (x) => {
+        try {
+          const tokenInstance = new NftHandler({
+            ...x,
+            provider: this.ethersProvider,
+          });
+          const contractData = await tokenInstance.getContractMetadata();
+          const assetData = await Promise.allSettled(x.assets.map((y) => tokenInstance.getNftMetadata(userAddress, y)));
+          return {
+            ...contractData,
+            assets: assetData.filter((z) => z.status === "fulfilled").map((z) => (z as PromiseFulfilledResult<CustomNftItemInfo>).value),
+          } as CustomNftInfo;
+        } catch (error) {
+          log.warn("Invalid contract address while fetching", error);
+          return undefined;
+        }
+      })
+    );
+    const nonZeroTokens = promiseSettledResult.filter((x) => x.status === "fulfilled").map((x) => (x as PromiseFulfilledResult<CustomNftInfo>).value);
+
+    this.update({ nfts: { [userAddress]: merge(this.userNfts, nonZeroTokens) } });
+  }
+}

package/src/Preferences/PreferencesController.ts

@@ -0,0 +1,409 @@
+import {
+  ACTIVITY_ACTION_RECEIVE,
+  ACTIVITY_ACTION_SEND,
+  ACTIVITY_ACTION_TOPUP,
+  BasePreferencesController,
+  CustomNft,
+  CustomToken,
+  IPreferencesController,
+  PreferencesConfig,
+  PreferencesState,
+  TransactionStatus,
+  UserInfo,
+} from "@toruslabs/base-controllers";
+import { get, patch, post, remove } from "@toruslabs/http-helpers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { Mutex } from "async-mutex";
+import log from "loglevel";
+
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import KeyringController from "../Keyring/KeyringController";
+import NetworkController from "../Network/NetworkController";
+import { SUPPORTED_NETWORKS } from "../utils/constants";
+import { formatDate, formatPastTx, formatTime, getEthTxStatus } from "../utils/helpers";
+import type {
+  CustomNetworkPayload,
+  CustomNetworks,
+  CustomNftInfo,
+  CustomTokenInfo,
+  EthereumUser,
+  ExtendedAddressPreferences,
+  FetchCommonTransaction,
+  FetchedTransaction,
+  FormattedTransactionActivity,
+  TransactionPayload,
+} from "../utils/interfaces";
+
+interface IPreferencesControllerOptions {
+  config?: Partial<PreferencesConfig> & Pick<PreferencesConfig, "api" | "commonApiHost" | "signInPrefix">;
+  state?: Partial<PreferencesState<ExtendedAddressPreferences>>;
+  provider: SafeEventEmitterProvider;
+  // TODO: Require later
+  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?: number;
+
+  private _mutex: Mutex = new Mutex();
+
+  private getProviderConfig: NetworkController["getProviderConfig"];
+
+  private provider: SafeEventEmitterProvider;
+
+  private blockTracker: PollingBlockTracker;
+
+  constructor({ config, state, provider, blockTracker, signAuthMessage, getProviderConfig }: IPreferencesControllerOptions) {
+    super({ config, state, defaultPreferences: { formattedPastTransactions: [], fetchedPastTx: [], paymentTx: [] }, signAuthMessage });
+    this.provider = provider;
+    this.getProviderConfig = getProviderConfig;
+    this.blockTracker = blockTracker;
+    log.info(this.blockTracker);
+  }
+
+  public async poll(interval?: number): Promise<void> {
+    const releaseLock = await this._mutex.acquire();
+    if (interval) this.configure({ pollInterval: interval });
+    if (this._handle) window.clearTimeout(this._handle);
+    // call here
+    const storeSelectedAddress = this.state.selectedAddress;
+    if (!storeSelectedAddress) return;
+    if (!this.getAddressState(storeSelectedAddress)?.jwtToken) return;
+    // This should never throw
+    await this.sync(storeSelectedAddress);
+    releaseLock();
+    this._handle = window.setTimeout(() => {
+      this.poll(this.config.pollInterval);
+    }, this.config.pollInterval);
+  }
+
+  public async initPreferences(params: {
+    address: string;
+    jwtToken?: string;
+    calledFromEmbed?: boolean;
+    userInfo?: UserInfo;
+    rehydrate?: boolean;
+    locale?: string;
+  }): Promise<void> {
+    const { address, jwtToken, calledFromEmbed, userInfo, rehydrate, locale = "en-US" } = params;
+    await super.init(address, userInfo, jwtToken);
+    const { aggregateVerifier, verifier, verifierId } = userInfo || {};
+    const userExists = await this.sync(address);
+    if (!userExists) {
+      const accountState = this.getAddressState(address);
+      await this.createUser({
+        selectedCurrency: accountState.selectedCurrency,
+        theme: accountState.theme,
+        verifier: aggregateVerifier || verifier,
+        verifierId,
+        locale,
+        address,
+      });
+    }
+    if (!rehydrate)
+      await this.storeUserLogin({ verifier: aggregateVerifier || verifier, verifierId, options: { calledFromEmbed, rehydrate }, address });
+  }
+
+  public getSelectedAddress(): string {
+    return this.state.selectedAddress;
+  }
+
+  async sync(address: string): Promise<boolean> {
+    try {
+      const user = await this.getUser<EthereumUser>(address);
+      if (user) {
+        const {
+          default_currency: defaultCurrency,
+          contacts,
+          theme,
+          locale,
+          public_address: userPublicAddress,
+          default_public_address: defaultPublicAddress,
+          customNetworks,
+          customTokens,
+          customNfts,
+        } = user || {};
+
+        // update latest data in state.
+        this.updateState(
+          {
+            contacts,
+            theme,
+            selectedCurrency: defaultCurrency,
+            locale,
+            defaultPublicAddress: defaultPublicAddress || userPublicAddress,
+            customTokens,
+            customNfts,
+            customNetworks,
+          },
+          address
+        );
+        return true;
+      }
+      return false;
+    } catch (error) {
+      log.error(error);
+      return false;
+    } finally {
+      Promise.all([
+        this.getWalletOrders<FetchedTransaction>(address).catch((error) => {
+          log.error("unable to fetch wallet orders", error);
+        }),
+        this.getTopUpOrders<FetchCommonTransaction>(address).catch((error) => {
+          log.error("unable to fetch top up orders", error);
+        }),
+      ])
+        .then((data) => {
+          const [walletTx, paymentTx] = data;
+          if (paymentTx) {
+            this.calculatePaymentTx(paymentTx, address);
+          }
+          // eslint-disable-next-line promise/always-return
+          if (walletTx && walletTx.length > 0) {
+            this.updateState({ fetchedPastTx: [...walletTx] }, address);
+            this.calculatePastTx(walletTx, address);
+          }
+        })
+        .catch((error) => log.error(error));
+    }
+  }
+
+  public async patchNewTx(tx: TransactionPayload, address: string): Promise<void> {
+    const formattedTx = formatPastTx(tx);
+    const storePastTx = this.getAddressState(address)?.formattedPastTransactions;
+    const duplicateIndex = storePastTx.findIndex((x) => x.transaction_hash === tx.transaction_hash && x.networkType === tx.network);
+    if (tx.status === TransactionStatus.submitted || tx.status === TransactionStatus.confirmed) {
+      if (duplicateIndex === -1) {
+        // No duplicate found
+
+        const finalTx = this.cancelTxCalculate([...storePastTx, formattedTx]);
+        tx.is_cancel = formattedTx.is_cancel;
+        tx.to = tx.to.toLowerCase();
+        tx.from = tx.from.toLowerCase();
+
+        this.updateState({ formattedPastTransactions: finalTx }, address);
+        this.postPastTx<TransactionPayload>(tx, address);
+      } else {
+        // avoid overriding is_cancel
+        formattedTx.is_cancel = storePastTx[duplicateIndex].is_cancel;
+        storePastTx[duplicateIndex] = formattedTx;
+        this.updateState({ formattedPastTransactions: this.cancelTxCalculate([...storePastTx]) }, address);
+      }
+    }
+  }
+
+  public recalculatePastTx(address?: string) {
+    // This triggers store update which calculates past Tx status for that network
+    const selectedAddress = address || this.state.selectedAddress;
+    const state = this.getAddressState(selectedAddress);
+    if (!state?.fetchedPastTx) return;
+    this.calculatePastTx(state.fetchedPastTx, selectedAddress);
+  }
+
+  public async refetchEtherscanTx(address?: string) {
+    const selectedAddress = address || this.state.selectedAddress;
+    if (this.getAddressState(selectedAddress)?.jwtToken) {
+      // const selectedNetwork = this.getProviderConfig().rpcTarget;
+      // if (ETHERSCAN_SUPPORTED_NETWORKS.has(selectedNetwork)) {
+      //   const data = await this.fetchEtherscanTx({ selectedAddress, selectedNetwork });
+      //   if (data.length) {
+      //     this.emit("addEtherscanTransactions", data, selectedNetwork);
+      //   }
+      // }
+    }
+  }
+
+  public async getEtherScanTokens(address: string, chainId: string): Promise<CustomTokenInfo[]> {
+    const selectedAddress = address;
+    const apiUrl = new URL(this.config.api);
+    apiUrl.pathname = `/tokens`;
+    apiUrl.searchParams.append("chainId", chainId);
+    apiUrl.searchParams.append("address", selectedAddress);
+    const result = await get<{ data: CustomTokenInfo[] }>(apiUrl.href, this.headers(this.state.selectedAddress));
+    return result.data;
+  }
+
+  public async getSimpleHashNfts(address: string, chainId: string): Promise<CustomNftInfo[]> {
+    const selectedAddress = address;
+    const apiUrl = new URL(this.config.api);
+    apiUrl.pathname = `/nfts`;
+    apiUrl.searchParams.append("chainId", chainId);
+    apiUrl.searchParams.append("address", selectedAddress);
+    const result = await get<{ data: CustomNftInfo[] }>(apiUrl.href, this.headers(this.state.selectedAddress));
+    return result.data;
+  }
+
+  public getCustomTokens(address?: string): CustomToken[] {
+    return this.getAddressState(address)?.customTokens ?? [];
+  }
+
+  public getCustomNfts(address?: string): CustomNft[] {
+    return this.getAddressState(address)?.customNfts ?? [];
+  }
+
+  // Custom Network methods
+  public async addCustomNetwork({ type, network }: { type: string; network: CustomNetworkPayload }): Promise<number> {
+    try {
+      const apiUrl = new URL(this.config.api);
+      apiUrl.pathname = `/customnetwork/${type}`;
+      const { selectedAddress } = this.state;
+      const payload = {
+        network_name: network.displayName,
+        rpc_url: network.rpcTarget,
+        chain_id: network.chainId,
+        symbol: network.ticker,
+        block_explorer_url: network.blockExplorerUrl || undefined,
+        is_test_net: network.isTestNet || false,
+      };
+      const res = await post<{ data: CustomNetworks }>(apiUrl.href, payload, this.headers(selectedAddress), { useAPIKey: true });
+      await this.sync(selectedAddress);
+
+      return res.data.id;
+    } catch {
+      log.error("error adding custom network");
+      return null;
+    }
+  }
+
+  async deleteCustomNetwork(id: number) {
+    try {
+      const { selectedAddress } = this.state;
+      const apiUrl = new URL(this.config.api);
+      apiUrl.pathname = `/customnetwork/${id}`;
+      await remove(apiUrl.href, {}, this.headers(selectedAddress), { useAPIKey: true });
+      await this.sync(selectedAddress);
+      return true;
+    } catch {
+      log.error("error deleting custom network");
+      return false;
+    }
+  }
+
+  async editCustomNetwork({ network, id }: { network: CustomNetworkPayload; id: number | null }) {
+    try {
+      const { selectedAddress } = this.state;
+      const apiUrl = new URL(this.config.api);
+      apiUrl.pathname = `/customnetwork/${id}`;
+
+      const payload = {
+        network_name: network.displayName,
+        rpc_url: network.rpcTarget,
+        chain_id: network.chainId,
+        symbol: network.ticker || undefined,
+        block_explorer_url: network.blockExplorerUrl || undefined,
+        is_test_net: network.isTestNet || false,
+      };
+      await patch(apiUrl.href, payload, this.headers(selectedAddress), { useAPIKey: true });
+      await this.sync(selectedAddress);
+      return true;
+    } catch {
+      log.error("error editing custom network");
+      return false;
+    }
+  }
+
+  private calculatePaymentTx(txs: FetchCommonTransaction[], address: string) {
+    const accumulator: FetchCommonTransaction[] = [];
+    for (const x of txs) {
+      let action = "";
+      const lowerCaseAction = x.action.toLowerCase();
+      if (ACTIVITY_ACTION_TOPUP.includes(lowerCaseAction)) action = ACTIVITY_ACTION_TOPUP;
+      else if (ACTIVITY_ACTION_SEND.includes(lowerCaseAction)) action = ACTIVITY_ACTION_SEND;
+      else if (ACTIVITY_ACTION_RECEIVE.includes(lowerCaseAction)) action = ACTIVITY_ACTION_RECEIVE;
+
+      accumulator.push({
+        id: x.id,
+        date: new Date(x.date).toDateString(),
+        from: x.from,
+        slicedFrom: x.slicedFrom,
+        action,
+        to: x.to,
+        slicedTo: x.slicedTo,
+        totalAmount: x.totalAmount,
+        totalAmountString: x.totalAmountString,
+        currencyAmount: x.currencyAmount,
+        currencyAmountString: x.currencyAmountString,
+        amount: x.amount,
+        ethRate: x.ethRate,
+        status: x.status.toLowerCase(),
+        etherscanLink: x.etherscanLink || "",
+        blockExplorerLink: "",
+        currencyUsed: x.currencyUsed,
+      });
+    }
+    this.updateState({ paymentTx: accumulator }, address);
+  }
+
+  private async calculatePastTx(txs: FetchedTransaction[], address: string) {
+    const pastTx = [];
+    const pendingTx = [];
+    const lowerCaseSelectedAddress = address.toLowerCase();
+    for (const x of txs) {
+      if (
+        x.network === SUPPORTED_NETWORKS[this.getProviderConfig().chainId].chainId &&
+        x.to &&
+        x.from &&
+        (lowerCaseSelectedAddress === x.from.toLowerCase() || lowerCaseSelectedAddress === x.to.toLowerCase())
+      ) {
+        if (x.status !== "confirmed") {
+          pendingTx.push(x);
+        } else {
+          const finalObject = formatPastTx(x, lowerCaseSelectedAddress);
+          pastTx.push(finalObject);
+        }
+      }
+    }
+    const pendingTxPromises = pendingTx.map((x) => getEthTxStatus(x.transaction_hash, this.provider).catch((error) => log.error(error)));
+    const resolvedTxStatuses = await Promise.all(pendingTxPromises);
+    for (const [index, element] of pendingTx.entries()) {
+      const finalObject = formatPastTx(element, lowerCaseSelectedAddress);
+      finalObject.status = resolvedTxStatuses[index] || TransactionStatus.submitted;
+      pastTx.push(finalObject);
+      if (lowerCaseSelectedAddress === element.from.toLowerCase() && finalObject.status && finalObject.status !== element.status)
+        this.patchPastTx({ id: element.id, status: finalObject.status, updated_at: new Date().toISOString() }, address);
+    }
+
+    const finalTx = this.cancelTxCalculate(pastTx);
+
+    this.updateState({ formattedPastTransactions: [...finalTx] }, address);
+  }
+
+  private cancelTxCalculate(pastTx: FormattedTransactionActivity[]) {
+    const nonceMap: Record<string, FormattedTransactionActivity[]> = {};
+    for (const x of pastTx) {
+      if (!nonceMap[x.nonce]) nonceMap[x.nonce] = [x];
+      else {
+        nonceMap[x.nonce].push(x);
+      }
+    }
+
+    for (const [, value] of Object.entries(nonceMap)) {
+      // has duplicate
+      if (value.length > 1) {
+        // get latest and mark it as is_cancel
+        const latestTxs = value.sort((a, b) => {
+          const aDate = new Date(a.date).getTime();
+          const bDate = new Date(b.date).getTime();
+          return bDate - aDate;
+        });
+        const latestCancelTx = latestTxs[0];
+        latestCancelTx.is_cancel = true;
+        latestTxs.slice(1).forEach((x) => {
+          x.hasCancel = true;
+          x.status = latestCancelTx.status === "confirmed" ? TransactionStatus.cancelled : TransactionStatus.cancelling;
+          x.cancelDateInitiated = `${formatTime(new Date(latestCancelTx.date).getTime())} - ${formatDate(latestCancelTx.date)}`;
+          x.etherscanLink = latestCancelTx.etherscanLink;
+          x.cancelGas = latestCancelTx.gas;
+          x.cancelGasPrice = latestCancelTx.gasPrice;
+        });
+      }
+    }
+
+    return pastTx;
+  }
+}

package/src/Tokens/ITokensController.ts

@@ -0,0 +1,13 @@
+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[]>;
+}