@toruslabs/ethereum-controllers 4.1.0

package/src/Tokens/TokenHandler.ts

@@ -0,0 +1,60 @@
+import BigNumber from "bignumber.js";
+import { BrowserProvider, Contract } from "ethers";
+import log from "loglevel";
+
+import { ecr20Abi } from "../utils/abis";
+
+export interface ITokenOptions {
+  address: string;
+  symbol: string;
+  decimals: number;
+  name: string;
+  provider: BrowserProvider;
+}
+
+export class TokenHandler {
+  public address: string;
+
+  public symbol: string;
+
+  public decimals: number;
+
+  public name: string;
+
+  public contract: Contract;
+
+  constructor({ address, symbol, decimals, name, provider }: ITokenOptions) {
+    this.address = address;
+
+    this.contract = new Contract(address, ecr20Abi, provider);
+    this.symbol = symbol;
+    this.decimals = decimals;
+    this.name = name;
+  }
+
+  public async getSymbol(): Promise<string> {
+    if (!this.symbol || this.symbol === "ERC20") this.symbol = await this.contract.symbol();
+    return this.symbol;
+  }
+
+  public async getDecimals(): Promise<number> {
+    try {
+      if (!this.decimals) this.decimals = await this.contract.decimals();
+      return this.decimals;
+    } catch (error) {
+      log.warn(`Could not get decimals for token ${this.address}`, error);
+      return 0;
+    }
+  }
+
+  public async getName(): Promise<string> {
+    if (!this.name) this.name = await this.contract.name();
+    return this.name;
+  }
+
+  public async getUserBalance(userAddress: string) {
+    if (!this.decimals) await this.getDecimals();
+    const balance = await this.contract.balanceOf(userAddress);
+    return new BigNumber(balance).toString(16);
+  }
+}

package/src/Tokens/TokenRatesController.ts

@@ -0,0 +1,134 @@
+import { BaseConfig, BaseController, BaseState, PreferencesState } from "@toruslabs/base-controllers";
+import { get } from "@toruslabs/http-helpers";
+import log from "loglevel";
+
+import { COINGECKO_PLATFORMS_CHAIN_CODE_MAP, COINGECKO_SUPPORTED_CURRENCIES } from "../utils/constants";
+import { idleTimeTracker } from "../utils/helpers";
+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 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 class TokenRatesController extends BaseController<ITokenRatesControllerConfig, ITokenRatesControllerState> {
+  private conversionInterval: number;
+
+  constructor({ config, state, onPreferencesStateChange, onNetworkStateChange, onTokensStateChange }: TokenRatesControllerOptions) {
+    super({ config, state });
+    this.defaultState = {
+      ...this.defaultState,
+      contractExchangeRates: {},
+    };
+    this.initialize();
+
+    onPreferencesStateChange((preferencesState) => {
+      const { selectedAddress } = preferencesState;
+      this.configure({ selectedAddress });
+    });
+
+    onNetworkStateChange((networkState) => {
+      const { chainId, ticker } = networkState.providerConfig;
+      this.configure({ chainId, nativeCurrency: ticker });
+    });
+
+    onTokensStateChange((tokensState) => {
+      const { tokens } = tokensState;
+      const currentUserTokens = tokens[this.config.selectedAddress];
+      if (currentUserTokens?.length > 0 && this.config.tokens !== tokens[this.config.selectedAddress]) {
+        this.configure({ tokens: tokens[this.config.selectedAddress] });
+        this.updateExchangeRates();
+      }
+    });
+  }
+
+  /**
+   * 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.
+   */
+  public scheduleConversionInterval(): void {
+    if (this.conversionInterval) {
+      window.clearInterval(this.conversionInterval);
+    }
+    this.conversionInterval = window.setInterval(() => {
+      if (!idleTimeTracker.checkIfIdle()) {
+        this.updateExchangeRates();
+      }
+    }, this.config.pollInterval);
+  }
+
+  public async updateExchangeRates() {
+    const chainCodes = COINGECKO_PLATFORMS_CHAIN_CODE_MAP[this.config.chainId];
+    let newContractExchangeRates: ContractExchangeRates = {};
+    if (!chainCodes) {
+      log.info(`ChainId ${this.config.chainId} not supported by coingecko`);
+      this.config.tokens.forEach((token) => {
+        newContractExchangeRates[token.tokenAddress] = undefined;
+      });
+    } else {
+      newContractExchangeRates = await this.fetchExchangeRates(this.config.nativeCurrency, chainCodes);
+    }
+    this.update({ contractExchangeRates: newContractExchangeRates });
+  }
+
+  private async fetchExchangeRates(nativeCurrency: string, chainCodes: { platform: string; currency: string }): Promise<ContractExchangeRates> {
+    const contractAddresses = this.config.tokens.map((token) => token.tokenAddress);
+
+    const isNativeCurrencySupported = COINGECKO_SUPPORTED_CURRENCIES.has(nativeCurrency.toLowerCase());
+    if (isNativeCurrencySupported) {
+      const response = await get<CoinGeckoResponse>(
+        `${this.config.api}/simple/token_price/${chainCodes.platform}?contract_addresses=${contractAddresses.join(
+          ","
+        )}&vs_currencies=${nativeCurrency.toLowerCase()}&include_market_cap=false&include_24hr_vol=false&include_24hr_change=false&include_last_updated_at=false`
+      );
+      const newContractExchangeRates: ContractExchangeRates = {};
+      Object.keys(response).forEach((contractAddress) => {
+        newContractExchangeRates[contractAddress] = response[contractAddress][nativeCurrency.toLowerCase()] || 0;
+      });
+      return newContractExchangeRates;
+    }
+    const [response, currencyResponse] = await Promise.all([
+      get<CoinGeckoResponse>(
+        `${this.config.api}/simple/token_price/${chainCodes.platform}?contract_addresses=${contractAddresses.join(
+          ","
+        )}&vs_currencies=${DEFAULT_CURRENCY}&include_market_cap=false&include_24hr_vol=false&include_24hr_change=false&include_last_updated_at=false`
+      ),
+      get<Record<string, string>>(`${this.config.currencyApi}/currency?fsym=${nativeCurrency.toUpperCase()}&tsyms=${DEFAULT_CURRENCY.toUpperCase()}`),
+    ]);
+    const newContractExchangeRates: ContractExchangeRates = {};
+    Object.keys(response).forEach((contractAddress) => {
+      newContractExchangeRates[contractAddress] =
+        response[contractAddress][DEFAULT_CURRENCY] * Number.parseFloat(currencyResponse[DEFAULT_CURRENCY]) || 0;
+    });
+    return newContractExchangeRates;
+  }
+}

package/src/Tokens/TokensController.ts

@@ -0,0 +1,278 @@
+import { BaseController, PreferencesState } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { BrowserProvider, Contract, toQuantity } from "ethers";
+import log from "loglevel";
+
+import NetworkController from "../Network/NetworkController";
+import PreferencesController from "../Preferences/PreferencesController";
+import { singleBalanceCheckerAbi } from "../utils/abis";
+import { ETHERSCAN_SUPPORTED_CHAINS } from "../utils/constants";
+import { SINGLE_CALL_BALANCES_ADDRESSES } from "../utils/contractAddresses";
+import { idleTimeTracker, toChecksumAddressByChainId } from "../utils/helpers";
+import { CustomTokenInfo, EthereumNetworkState, ExtendedAddressPreferences } from "../utils/interfaces";
+import { TokensControllerConfig, TokensControllerState } from "./ITokensController";
+import { TokenHandler } from "./TokenHandler";
+
+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;
+}
+
+function getObjectFromArrayBasedonKey(oldArray: CustomTokenInfo[], key: string) {
+  return oldArray.reduce((acc: Record<string, CustomTokenInfo>, x) => {
+    const xkey = x[key as keyof CustomTokenInfo];
+    if (typeof xkey === "boolean") return acc;
+    acc[xkey] = x;
+    return acc;
+  }, {});
+}
+
+const mergeTokenArrays = (oldArray: CustomTokenInfo[], newArray: CustomTokenInfo[]): CustomTokenInfo[] => {
+  const oldMap = getObjectFromArrayBasedonKey(oldArray || [], "tokenAddress");
+  const newMap = getObjectFromArrayBasedonKey(newArray || [], "tokenAddress");
+  const finalArr = newArray;
+  Object.keys(oldMap).forEach((x) => {
+    if (!newMap[x] && oldMap[x].isEtherScan) finalArr.push(oldMap[x]);
+  });
+  return finalArr;
+};
+
+const DEFAULT_INTERVAL = 180 * 1000;
+
+export class TokensController extends BaseController<TokensControllerConfig, TokensControllerState> {
+  name = "TokensController";
+
+  private provider: SafeEventEmitterProvider;
+
+  private ethersProvider: BrowserProvider;
+
+  private _timer: number;
+
+  private getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+
+  private getProviderConfig: NetworkController["getProviderConfig"];
+
+  private getCustomTokens: PreferencesController["getCustomTokens"];
+
+  private getEtherScanTokens: PreferencesController["getEtherScanTokens"];
+
+  constructor({
+    config,
+    state,
+    provider,
+    getNetworkIdentifier,
+    getCustomTokens,
+    getEtherScanTokens,
+    getProviderConfig,
+    onPreferencesStateChange,
+    onNetworkStateChange,
+  }: ITokensControllerOptions) {
+    super({ config, state });
+
+    this.provider = provider;
+    this.ethersProvider = new BrowserProvider(this.provider, "any");
+    this.getNetworkIdentifier = getNetworkIdentifier;
+
+    this.getCustomTokens = getCustomTokens;
+    this.getEtherScanTokens = getEtherScanTokens;
+    this.getProviderConfig = getProviderConfig;
+
+    this.defaultConfig = {
+      interval: DEFAULT_INTERVAL,
+      selectedAddress: "",
+      chainId: "",
+    };
+
+    this.defaultState = {
+      tokens: {},
+    };
+    this.initialize();
+
+    onPreferencesStateChange((preferencesState) => {
+      if (preferencesState.selectedAddress !== this.config.selectedAddress) {
+        this.configure({ selectedAddress: preferencesState.selectedAddress });
+        this.restartTokenDetection();
+      }
+    });
+
+    onNetworkStateChange((networkState) => {
+      const { chainId } = networkState.providerConfig;
+      if (chainId !== this.config.chainId) {
+        this.configure({ chainId });
+        this.restartTokenDetection();
+      }
+    });
+  }
+
+  get userSelectedAddress(): string {
+    return this.config.selectedAddress;
+  }
+
+  get userTokens() {
+    if (!this.userSelectedAddress) return [];
+    return this.state.tokens[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.detectNewTokens();
+        this.refreshTokenBalances();
+      }
+    }, interval);
+  }
+
+  public startTokenDetection(selectedAddress: string) {
+    this.configure({ selectedAddress });
+    this.restartTokenDetection();
+  }
+
+  /**
+   * Restart token detection polling period and call detectNewTokens
+   * in case of address change or user session initialization.
+   *
+   */
+  public restartTokenDetection() {
+    if (!this.userSelectedAddress) {
+      return;
+    }
+    this.detectNewTokens();
+    this.refreshTokenBalances();
+    this.config.interval = DEFAULT_INTERVAL;
+  }
+
+  public detectNewTokens() {
+    const userAddress = this.userSelectedAddress;
+    if (!userAddress) return;
+    const currentChainId = this.getNetworkIdentifier();
+    const tokens: CustomTokenInfo[] = []; // object[]
+    if (!currentChainId) {
+      this.update({ tokens: { [userAddress]: [...tokens] } });
+      return;
+    }
+
+    const networkConfig = this.getProviderConfig();
+
+    if (networkConfig?.isErc20 && networkConfig?.tokenAddress) {
+      tokens.push({
+        tokenAddress: networkConfig.tokenAddress,
+        name: networkConfig.tickerName,
+        logo: networkConfig.logo,
+        erc20: true,
+        symbol: networkConfig.ticker,
+        decimals: "18",
+        chainId: currentChainId,
+      });
+    }
+    if (this.getCustomTokens) {
+      const customTokens = this.getCustomTokens(userAddress);
+      tokens.push(
+        ...customTokens.reduce((acc, x) => {
+          if (x.network === currentChainId)
+            acc.push({
+              tokenAddress: x.token_address,
+              name: x.token_name,
+              logo: "eth.svg",
+              erc20: true,
+              symbol: x.token_symbol,
+              decimals: x.decimals,
+              balance: "",
+              customTokenId: x.id.toString(),
+              chainId: x.network,
+            });
+          return acc;
+        }, [] as CustomTokenInfo[])
+      );
+    }
+    this.update({ tokens: { [userAddress]: [...tokens] } });
+  }
+
+  async refreshTokenBalances() {
+    const userAddress = this.userSelectedAddress;
+    if (userAddress === "") return;
+    const oldTokens = [...this.userTokens];
+    const tokenAddresses = oldTokens.map((x) => x.tokenAddress);
+    const nonZeroTokens: CustomTokenInfo[] = [];
+    try {
+      const currentChainId = this.getNetworkIdentifier();
+      if (ETHERSCAN_SUPPORTED_CHAINS.includes(currentChainId)) {
+        const etherscanBalances = await this.getEtherScanTokens(userAddress, currentChainId);
+        nonZeroTokens.push(...etherscanBalances);
+      }
+      if (tokenAddresses.length > 0) {
+        const currentSingleCallAddress = SINGLE_CALL_BALANCES_ADDRESSES[currentChainId];
+        if (currentSingleCallAddress) {
+          const ethContract = new Contract(currentSingleCallAddress, singleBalanceCheckerAbi, this.ethersProvider);
+          const result = await ethContract.balances([userAddress], tokenAddresses);
+          tokenAddresses.forEach((_, index) => {
+            const balance = toQuantity(result[index]);
+            if (balance && balance !== "0x0") {
+              nonZeroTokens.push({ ...oldTokens[index], balance, chainId: currentChainId });
+            }
+          });
+        } else {
+          this.getTokenBalancesUsingHandler(oldTokens);
+        }
+      }
+    } catch (error) {
+      log.error(error, "unable to fetch token balances using single call balance address");
+      this.getTokenBalancesUsingHandler(oldTokens);
+    } finally {
+      this.update({ tokens: { [userAddress]: nonZeroTokens } });
+    }
+  }
+
+  async getTokenBalancesUsingHandler(customTokens: CustomTokenInfo[]) {
+    if (!this.userSelectedAddress) return;
+    const currentNetworkTokens = customTokens;
+    const promiseSettledResult = await Promise.allSettled(
+      currentNetworkTokens.map(async (x) => {
+        try {
+          const tokenInstance = new TokenHandler({
+            address: x.tokenAddress,
+            decimals: Number.parseInt(x.decimals),
+            name: x.name,
+            symbol: x.symbol,
+            provider: this.ethersProvider,
+          });
+          const balance = await tokenInstance.getUserBalance(this.userSelectedAddress);
+          return {
+            decimals: tokenInstance.decimals.toString(),
+            erc20: true,
+            logo: x.logo || "eth.svg",
+            name: tokenInstance.name,
+            symbol: tokenInstance.symbol,
+            tokenAddress: toChecksumAddressByChainId(tokenInstance.address, x.chainId),
+            balance: `0x${balance}`,
+            customTokenId: x.customTokenId,
+            network: x.chainId,
+            chainId: x.chainId,
+          } as CustomTokenInfo;
+        } 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<CustomTokenInfo>).value);
+
+    this.update({ tokens: { [this.userSelectedAddress]: mergeTokenArrays(this.userTokens, nonZeroTokens) } });
+  }
+}

package/src/Transaction/NonceTracker.ts

@@ -0,0 +1,152 @@
+// import assert from 'assert'
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { Mutex, MutexInterface } from "async-mutex";
+
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import { METHOD_TYPES } from "../utils/constants";
+import { EthereumTransactionMeta, Nonce, NonceDetails, NonceLockRes } from "../utils/interfaces";
+import TransactionStateManager from "./TransactionStateManager";
+
+interface INonceTrackerOptions {
+  provider: SafeEventEmitterProvider;
+  blockTracker: PollingBlockTracker;
+  getPendingTransactions: TransactionStateManager["getPendingTransactions"];
+  getConfirmedTransactions: TransactionStateManager["getConfirmedTransactions"];
+}
+
+class NonceTracker {
+  private provider: SafeEventEmitterProvider;
+
+  private blockTracker: PollingBlockTracker;
+
+  private getPendingTransactions: TransactionStateManager["getPendingTransactions"];
+
+  private getConfirmedTransactions: TransactionStateManager["getConfirmedTransactions"];
+
+  private lockMap: Record<string, Mutex>;
+
+  constructor({ provider, blockTracker, getPendingTransactions, getConfirmedTransactions }: INonceTrackerOptions) {
+    this.provider = provider;
+    this.blockTracker = blockTracker;
+    this.getPendingTransactions = getPendingTransactions;
+    this.getConfirmedTransactions = getConfirmedTransactions;
+    this.lockMap = {};
+  }
+
+  public async getGlobalLock(): Promise<{ releaseLock: MutexInterface.Releaser }> {
+    const globalMutex = this._lookupMutex("global");
+    // await global mutex free
+    const releaseLock = await globalMutex.acquire();
+    return { releaseLock };
+  }
+
+  /**
+    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).
+  */
+  public async getNonceLock(address: string): Promise<NonceLockRes> {
+    // await global mutex free
+    await this._globalMutexFree();
+    // await lock free, then take lock
+    const releaseLock = await this._takeMutex(address);
+    try {
+      // evaluate multiple nextNonce strategies
+      const nonceDetails = {} as NonceDetails;
+      const networkNonceResult = await this._getNetworkNextNonce(address);
+
+      const highestLocallyConfirmed = this._getHighestLocallyConfirmed(address);
+      const nextNetworkNonce = networkNonceResult.nonce;
+      const highestSuggested = Math.max(nextNetworkNonce, highestLocallyConfirmed);
+
+      const pendingTxs = this.getPendingTransactions(address);
+      const localNonceResult = this._getHighestContinuousFrom(pendingTxs, highestSuggested);
+
+      nonceDetails.params = {
+        highestLocallyConfirmed,
+        highestSuggested,
+        nextNetworkNonce,
+      };
+      nonceDetails.local = localNonceResult;
+      nonceDetails.network = networkNonceResult;
+
+      const nextNonce = Math.max(networkNonceResult.nonce, localNonceResult.nonce);
+
+      // return nonce and release cb
+      return { nextNonce, nonceDetails, releaseLock };
+    } catch (error) {
+      // release lock if we encounter an error
+      releaseLock();
+      throw error;
+    }
+  }
+
+  private async _globalMutexFree() {
+    const globalMutex = this._lookupMutex("global");
+    const releaseLock = await globalMutex.acquire();
+    releaseLock();
+  }
+
+  private async _takeMutex(lockId: string) {
+    const mutex = this._lookupMutex(lockId);
+    const releaseLock = await mutex.acquire();
+    return releaseLock;
+  }
+
+  private _lookupMutex(lockId: string): Mutex {
+    let mutex = this.lockMap[lockId];
+    if (!mutex) {
+      mutex = new Mutex();
+      this.lockMap[lockId] = mutex;
+    }
+    return mutex;
+  }
+
+  private async _getNetworkNextNonce(address: string) {
+    // calculate next nonce
+    // we need to make sure our base count
+    // and pending count are from the same block
+    const block = await this.blockTracker.getLatestBlock();
+    const baseCountStr = await this.provider.request<[string, string], string>({
+      method: METHOD_TYPES.ETH_GET_TRANSACTION_COUNT,
+      params: [address, block.idempotencyKey],
+    });
+    const baseCount = Number.parseInt(baseCountStr, 16);
+    const nonceDetails = { block, baseCount };
+    return { name: "network", nonce: baseCount, details: nonceDetails };
+  }
+
+  private _getHighestLocallyConfirmed(address: string): number {
+    const confirmedTransactions = this.getConfirmedTransactions(address);
+    const highest = this._getHighestNonce(confirmedTransactions);
+    return Number.isInteger(highest) ? highest + 1 : 0;
+  }
+
+  private _getHighestNonce(txList: EthereumTransactionMeta[]): number {
+    const nonces = txList.map((txMeta) => {
+      const { nonce } = txMeta.transaction;
+      return Number.parseInt(nonce, 16);
+    });
+    const highestNonce = Math.max.apply(null, nonces);
+    return highestNonce;
+  }
+
+  private _getHighestContinuousFrom(txList: EthereumTransactionMeta[], startPoint: number): Nonce {
+    const nonces = new Set(
+      txList.map((txMeta) => {
+        const { nonce } = txMeta.transaction;
+        return Number.parseInt(nonce, 16);
+      })
+    );
+
+    let highest = startPoint;
+    while (nonces.has(highest)) {
+      highest += 1;
+    }
+
+    return { name: "local", nonce: highest, details: { startPoint, highest } };
+  }
+}
+
+export default NonceTracker;