@toruslabs/ethereum-controllers 4.1.0

package/src/Account/AccountTrackerController.ts

@@ -0,0 +1,157 @@
+import { AccountTrackerConfig, AccountTrackerState, BaseController, IAccountTrackerController, PreferencesState } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { Mutex } from "async-mutex";
+import { BrowserProvider, Contract, toQuantity } from "ethers";
+import log from "loglevel";
+
+import PollingBlockTracker from "../Block/PollingBlockTracker";
+import NetworkController from "../Network/NetworkController";
+import { singleBalanceCheckerAbi } from "../utils/abis";
+import { SINGLE_CALL_BALANCES_ADDRESSES } from "../utils/contractAddresses";
+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"];
+}
+
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+
+/**
+ * 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.
+ */
+class AccountTrackerController
+  extends BaseController<AccountTrackerConfig<EthereumBlock>, AccountTrackerState>
+  implements IAccountTrackerController<AccountTrackerConfig<EthereumBlock>, AccountTrackerState>
+{
+  private provider!: SafeEventEmitterProvider;
+
+  private blockTracker!: PollingBlockTracker;
+
+  private mutex = new Mutex();
+
+  private ethersProvider!: BrowserProvider;
+
+  private getIdentities!: AccountTrackerControllerOptions["getIdentities"];
+
+  private getCurrentChainId: NetworkController["getNetworkIdentifier"];
+
+  constructor({
+    config,
+    state,
+    provider,
+    blockTracker,
+    getIdentities,
+    onPreferencesStateChange,
+    getCurrentChainId,
+  }: AccountTrackerControllerOptions) {
+    super({ config, state });
+    this.defaultState = {
+      accounts: {},
+    };
+    this.defaultConfig = {
+      _currentBlock: null,
+    };
+    this.initialize();
+    this.provider = provider;
+    this.blockTracker = blockTracker;
+    this.ethersProvider = new BrowserProvider(this.provider, "any");
+
+    // Initiate block tracker internal tracking.
+    this.blockTracker.on("latest", (block: EthereumBlock) => {
+      this.configure({ _currentBlock: block });
+      this.refresh();
+    });
+
+    this.getIdentities = getIdentities;
+    this.getCurrentChainId = getCurrentChainId;
+
+    onPreferencesStateChange(() => {
+      log.info("onPreferencesStateChange called");
+      const refreshNeeded = this.syncAccounts();
+      if (refreshNeeded) this.refresh();
+    });
+  }
+
+  syncAccounts(): boolean {
+    const { accounts } = this.state;
+    const addresses = Object.keys(this.getIdentities());
+    const existing = Object.keys(accounts);
+    const newAddresses = addresses.filter((address) => existing.indexOf(address) === -1);
+    const oldAddresses = existing.filter((address) => addresses.indexOf(address) === -1);
+    let isUpdated = false;
+    newAddresses.forEach((address) => {
+      isUpdated = true;
+      accounts[address] = { balance: "0x0" };
+    });
+    oldAddresses.forEach((address) => {
+      isUpdated = true;
+      delete accounts[address];
+    });
+    this.update({ accounts: { ...accounts } });
+    return isUpdated;
+  }
+
+  async refresh(): Promise<void> {
+    const releaseLock = await this.mutex.acquire();
+    try {
+      const currentBlock = this.config._currentBlock;
+      if (!currentBlock) return;
+      this._updateAccounts();
+    } catch (error) {
+    } finally {
+      releaseLock();
+    }
+  }
+
+  private async _updateAccounts(): Promise<void> {
+    const { accounts } = this.state;
+    const addresses = Object.keys(accounts);
+    const chainId = this.getCurrentChainId();
+    if (chainId === "loading") return;
+
+    if (addresses.length > 0) {
+      if (SINGLE_CALL_BALANCES_ADDRESSES[chainId]) {
+        await this._updateAccountsViaBalanceChecker(addresses, SINGLE_CALL_BALANCES_ADDRESSES[chainId]);
+        return;
+      }
+      log.info("falling back to ethQuery.getBalance");
+      await Promise.all(addresses.map((x) => this._updateAccount(x)));
+    }
+  }
+
+  private async _updateAccount(address: string): Promise<void> {
+    const balance = await this.provider.request<[string, string], string>({ method: "eth_getBalance", params: [address, "latest"] });
+    const { accounts } = this.state;
+    if (!accounts[address]) return;
+    accounts[address] = { balance: toQuantity(balance) };
+    this.update({ accounts });
+  }
+
+  private async _updateAccountsViaBalanceChecker(addresses: string[], deployedContractAddress: string) {
+    const ethContract = new Contract(deployedContractAddress, singleBalanceCheckerAbi, this.ethersProvider);
+    try {
+      const result: string[] = await ethContract.balances(addresses, [ZERO_ADDRESS]);
+      const { accounts } = this.state;
+      addresses.forEach((address, index) => {
+        const balance = toQuantity(result[index]);
+        if (!accounts[address]) return;
+        accounts[address] = { balance };
+      });
+      return this.update({ accounts });
+    } catch (error) {
+      log.warn("Torus - Account Tracker single call balance fetch failed", error);
+      return Promise.all(addresses.map((x) => this._updateAccount(x)));
+    }
+  }
+}
+
+export default AccountTrackerController;

package/src/Block/PollingBlockTracker.ts

@@ -0,0 +1,89 @@
+import { BaseBlockTracker, PollingBlockTrackerConfig, timeout } from "@toruslabs/base-controllers";
+import { BlockParams } from "ethers";
+import log from "loglevel";
+
+import { idleTimeTracker } from "../utils/helpers";
+import { EthereumBlock, PollingBlockTrackerState } from "../utils/interfaces";
+
+const DEFAULT_POLLING_INTERVAL = 20;
+const DEFAULT_RETRY_TIMEOUT = 2;
+const SEC = 1000;
+
+class PollingBlockTracker extends BaseBlockTracker<EthereumBlock, PollingBlockTrackerConfig, PollingBlockTrackerState> {
+  constructor({ config, state = {} }: { config: Partial<PollingBlockTrackerConfig>; state: Partial<PollingBlockTrackerState> }) {
+    if (!config.provider) {
+      throw new Error("PollingBlockTracker - no provider specified.");
+    }
+
+    super({ config, state });
+
+    const pollingInterval = config.pollingInterval || DEFAULT_POLLING_INTERVAL;
+
+    const retryTimeout = config.retryTimeout || DEFAULT_RETRY_TIMEOUT;
+
+    // merge default + provided config.
+    this.defaultConfig = {
+      provider: config.provider,
+      pollingInterval: pollingInterval * SEC,
+      retryTimeout: retryTimeout * SEC,
+      setSkipCacheFlag: config.setSkipCacheFlag || false,
+    };
+
+    this.initialize();
+  }
+
+  async checkForLatestBlock(): Promise<EthereumBlock> {
+    await this._updateLatestBlock();
+    return this.getLatestBlock();
+  }
+
+  // overrides the BaseBlockTracker._start method.
+  protected _start(): void {
+    this._synchronize().catch((err) => this.emit("error", err));
+  }
+
+  private async _synchronize(): Promise<void> {
+    while (this.state._isRunning) {
+      if (idleTimeTracker.checkIfIdle()) return;
+      try {
+        await this._updateLatestBlock();
+        await timeout(this.config.pollingInterval);
+      } catch (err) {
+        const newErr = new Error(`PollingBlockTracker - encountered an error while attempting to update latest block:\n${(err as Error).stack}`);
+        try {
+          this.emit("error", newErr);
+        } catch (emitErr) {
+          log.error(newErr);
+        }
+        await timeout(this.config.retryTimeout);
+      }
+    }
+  }
+
+  private async _updateLatestBlock(): Promise<void> {
+    // fetch + set latest block
+    const latestBlock = await this._fetchLatestBlock();
+    this._newPotentialLatest(latestBlock);
+  }
+
+  private async _fetchLatestBlock(): Promise<EthereumBlock> {
+    try {
+      const block = await this.config.provider.request<[string, boolean], { [K in keyof BlockParams]: string }>({
+        method: "eth_getBlockByNumber",
+        params: ["latest", false],
+      });
+      return {
+        blockHash: block.hash,
+        idempotencyKey: block.number,
+        timestamp: block.timestamp,
+        baseFeePerGas: block.baseFeePerGas,
+        gasLimit: block.gasLimit,
+      };
+    } catch (error) {
+      log.error("Polling Block Tracker: ", error);
+      throw new Error(`PollingBlockTracker - encountered error fetching block:\n${(error as Error).message}`);
+    }
+  }
+}
+
+export default PollingBlockTracker;

package/src/Currency/CurrencyController.ts

@@ -0,0 +1,117 @@
+import { BaseCurrencyController, BaseCurrencyControllerConfig, BaseCurrencyControllerState } from "@toruslabs/base-controllers";
+import { get } from "@toruslabs/http-helpers";
+import log from "loglevel";
+
+import { idleTimeTracker } from "../utils/helpers";
+import { EthereumNetworkState } from "../utils/interfaces";
+
+export interface IEthereumCurrencyControllerState extends BaseCurrencyControllerState {
+  commonDenomination: string;
+  commonDenominatorPrice: number;
+}
+
+export default class CurrencyController extends BaseCurrencyController<BaseCurrencyControllerConfig, IEthereumCurrencyControllerState> {
+  private conversionInterval: number;
+
+  constructor({
+    config,
+    state,
+    onNetworkChanged,
+  }: {
+    config: Partial<BaseCurrencyControllerConfig>;
+    state: Partial<IEthereumCurrencyControllerState>;
+    onNetworkChanged: (listener: (networkState: EthereumNetworkState) => void) => void;
+  }) {
+    super({ config, state });
+    this.defaultState = {
+      ...this.defaultState,
+      commonDenomination: "USD",
+      commonDenominatorPrice: 0,
+    };
+    this.initialize();
+    onNetworkChanged((networkState) => {
+      // to be called as (listener) => this.networkController.on('networkDidChange', listener);
+      if (networkState.providerConfig.ticker.toUpperCase() !== this.state.nativeCurrency.toUpperCase()) {
+        this.setNativeCurrency(networkState.providerConfig.ticker);
+        this.updateConversionRate();
+      }
+    });
+  }
+
+  public setCommonDenomination(commonDenomination: string): void {
+    this.update({ commonDenomination });
+  }
+
+  public getCommonDenomination(): string {
+    return this.state.commonDenomination;
+  }
+
+  public setCommonDenominatorPrice(commonDenominatorPrice: number): void {
+    this.update({ commonDenominatorPrice });
+  }
+
+  public getCommonDenominatorPrice(): number {
+    return this.state.commonDenominatorPrice;
+  }
+
+  /**
+   * 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.updateConversionRate();
+      }
+    }, this.config.pollInterval);
+  }
+
+  /**
+   * Updates the conversionRate and conversionDate properties associated with the currentCurrency. Updated info is
+   * fetched from an external API
+   */
+  public async updateConversionRate() {
+    const currentCurrency = this.getCurrentCurrency();
+    const nativeCurrency = this.getNativeCurrency();
+    const commonDenomination = this.getCommonDenomination();
+    const conversionRate = await this.retrieveConversionRate(nativeCurrency, currentCurrency, commonDenomination);
+
+    const currentCurrencyRate = Number.parseFloat(conversionRate[currentCurrency.toUpperCase()]);
+    const commonDenominationRate = Number.parseFloat(conversionRate[commonDenomination.toUpperCase()]);
+    // set conversion rate
+    if (currentCurrencyRate || commonDenominationRate) {
+      // ETC
+      this.setConversionRate(currentCurrencyRate);
+      this.setConversionDate(Math.floor(Date.now() / 1000).toString());
+      if (currentCurrency.toUpperCase() === commonDenomination.toUpperCase()) {
+        this.setCommonDenominatorPrice(currentCurrencyRate);
+      } else {
+        this.setCommonDenominatorPrice(commonDenominationRate);
+      }
+    } else {
+      this.setConversionRate(0);
+      this.setConversionDate("N/A");
+    }
+  }
+
+  private async retrieveConversionRate(fromCurrency: string, toCurrency: string, commonDenomination: string): Promise<Record<string, string>> {
+    try {
+      // query cryptocompare
+      let apiUrl = `${this.config.api}/currency?fsym=${fromCurrency.toUpperCase()}&tsyms=${toCurrency.toUpperCase()}`;
+      if (commonDenomination && commonDenomination.toUpperCase() !== toCurrency.toUpperCase()) {
+        apiUrl += `,${commonDenomination.toUpperCase()}`;
+      }
+      const parsedResponse = await get<Record<string, string>>(apiUrl);
+
+      return parsedResponse;
+    } catch (error) {
+      log.error(error, `CurrencyController - updateCommonDenominatorPrice: Failed to query rate for currency: ${fromCurrency}/ ${toCurrency}`);
+    }
+
+    return { [toCurrency.toUpperCase()]: "0", [commonDenomination.toUpperCase()]: "0" };
+  }
+}

package/src/Gas/GasFeeController.ts

@@ -0,0 +1,254 @@
+import { addHexPrefix, isHexString } from "@ethereumjs/util";
+import { BaseController } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { cloneDeep } from "lodash";
+import log from "loglevel";
+
+import NetworkController from "../Network/NetworkController";
+import { GAS_ESTIMATE_TYPES } from "../utils/constants";
+import { idleTimeTracker } from "../utils/helpers";
+import { EthereumNetworkState } from "../utils/interfaces";
+import {
+  calculateTimeEstimate,
+  fetchEthGasPriceEstimate as defaultFetchEthGasPriceEstimate,
+  fetchGasEstimates as defaultFetchGasEstimates,
+  fetchGasEstimatesViaEthFeeHistory as defaultFetchGasEstimatesViaEthFeeHistory,
+  fetchLegacyGasPriceEstimates as defaultFetchLegacyGasPriceEstimates,
+} from "./gasUtil";
+import { EthereumGasConfig, EthereumGasFeeEstimates, EthereumGasState, EthereumLegacyGasFeeEstimates, GasFeeTimeBounds } from "./IGasFeeController";
+const GAS_FEE_API = "https://mock-gas-server.herokuapp.com/";
+const LEGACY_GAS_PRICES_API_URL = "https://api.metaswap.codefi.network/gasPrices";
+
+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 = "GasFeeController";
+
+  private intervalId: number;
+
+  private provider: SafeEventEmitterProvider;
+
+  private currentChainId: string;
+
+  private getNetworkIdentifier: NetworkController["getNetworkIdentifier"];
+
+  private getProvider: NetworkController["getProvider"];
+
+  private fetchGasEstimates: (url: string) => Promise<EthereumGasFeeEstimates>;
+
+  private fetchGasEstimatesViaEthFeeHistory: (provider: SafeEventEmitterProvider) => Promise<EthereumGasFeeEstimates>;
+
+  private fetchEthGasPriceEstimate: (provider: SafeEventEmitterProvider) => Promise<{ gasPrice: string }>;
+
+  private fetchLegacyGasPriceEstimates: (url: string) => Promise<EthereumLegacyGasFeeEstimates>;
+
+  private getCurrentNetworkEIP1559Compatibility: NetworkController["getEIP1559Compatibility"];
+
+  private getCurrentAccountEIP1559Compatibility: (address?: string) => boolean;
+
+  private getCurrentNetworkLegacyGasAPICompatibility: () => boolean;
+
+  constructor({
+    config,
+    state,
+    getNetworkIdentifier,
+    getProvider,
+    fetchGasEstimates = defaultFetchGasEstimates,
+    fetchEthGasPriceEstimate = defaultFetchEthGasPriceEstimate,
+    fetchLegacyGasPriceEstimates = defaultFetchLegacyGasPriceEstimates,
+    fetchGasEstimatesViaEthFeeHistory = defaultFetchGasEstimatesViaEthFeeHistory,
+    getCurrentNetworkLegacyGasAPICompatibility,
+    getCurrentNetworkEIP1559Compatibility,
+    getCurrentAccountEIP1559Compatibility,
+    onNetworkStateChange,
+  }: IGasFeeControllerOptions) {
+    super({ config, state });
+    this.getNetworkIdentifier = getNetworkIdentifier;
+    this.getProvider = getProvider;
+    this.fetchGasEstimates = fetchGasEstimates;
+    this.fetchEthGasPriceEstimate = fetchEthGasPriceEstimate;
+    this.fetchLegacyGasPriceEstimates = fetchLegacyGasPriceEstimates;
+    this.getCurrentNetworkEIP1559Compatibility = getCurrentNetworkEIP1559Compatibility;
+    this.getCurrentNetworkLegacyGasAPICompatibility = getCurrentNetworkLegacyGasAPICompatibility;
+    this.getCurrentAccountEIP1559Compatibility = getCurrentAccountEIP1559Compatibility;
+    this.fetchGasEstimatesViaEthFeeHistory = fetchGasEstimatesViaEthFeeHistory;
+
+    this.defaultConfig = {
+      interval: 30_000,
+      legacyAPIEndpoint: LEGACY_GAS_PRICES_API_URL,
+      EIP1559APIEndpoint: GAS_FEE_API,
+    };
+
+    this.defaultState = {
+      gasFeeEstimates: {} as EthereumGasFeeEstimates,
+      estimatedGasFeeTimeBounds: {},
+      gasEstimateType: GAS_ESTIMATE_TYPES.NONE,
+    };
+    // Initialize.
+    this.currentChainId = this.getNetworkIdentifier();
+    this.provider = this.getProvider();
+    this.initialize();
+    onNetworkStateChange(() => {
+      this.onNetworkStateChange();
+    });
+  }
+
+  async onNetworkStateChange() {
+    this.provider = this.getProvider();
+    const newChainId = this.getNetworkIdentifier();
+    if (this.currentChainId !== newChainId) {
+      this.currentChainId = newChainId;
+      await this.resetPolling();
+    }
+  }
+
+  async resetPolling() {
+    this.stopPolling();
+    await this.getGasFeeEstimatesAndStartPolling();
+  }
+
+  async fetchGasFeeEstimates() {
+    return this._fetchGasFeeEstimateData();
+  }
+
+  async getGasFeeEstimatesAndStartPolling() {
+    await this._fetchGasFeeEstimateData();
+    this._startPolling();
+  }
+
+  disconnectPoller() {
+    this.stopPolling();
+  }
+
+  /**
+   * Prepare to discard this controller.
+   *
+   * This stops any active polling.
+   */
+  destroy() {
+    this.stopPolling();
+  }
+
+  stopPolling() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+    }
+    this.resetState();
+  }
+
+  /**
+   * Gets and sets gasFeeEstimates in state
+   *
+   * @returns GasFeeEstimates
+   */
+  private async _fetchGasFeeEstimateData(): Promise<EthereumGasState> {
+    let isEIP1559Compatible: boolean;
+    const isLegacyGasAPICompatible = this.getCurrentNetworkLegacyGasAPICompatibility();
+
+    const chainId = this.getNetworkIdentifier();
+    if (chainId === "loading") return;
+    let chainIdInt: number;
+    if (typeof chainId === "string" && isHexString(addHexPrefix(chainId))) {
+      chainIdInt = Number.parseInt(chainId, 16);
+    }
+    try {
+      isEIP1559Compatible = await this.getEIP1559Compatibility();
+      log.info("eip1559 compatible", isEIP1559Compatible);
+    } catch (error) {
+      log.warn(error);
+      isEIP1559Compatible = false;
+    }
+
+    let newState = cloneDeep(this.defaultState);
+
+    try {
+      if (isEIP1559Compatible) {
+        let estimates: EthereumGasFeeEstimates;
+        try {
+          estimates = await this.fetchGasEstimates(this.config.EIP1559APIEndpoint.replace("<chain_id>", `${chainIdInt}`));
+        } catch (error) {
+          estimates = await this.fetchGasEstimatesViaEthFeeHistory(this.provider);
+        }
+        const { suggestedMaxPriorityFeePerGas, suggestedMaxFeePerGas } = estimates.medium;
+        const estimatedGasFeeTimeBounds = this.getTimeEstimate(suggestedMaxPriorityFeePerGas, suggestedMaxFeePerGas);
+        newState = {
+          gasFeeEstimates: estimates,
+          estimatedGasFeeTimeBounds,
+          gasEstimateType: GAS_ESTIMATE_TYPES.FEE_MARKET,
+        };
+      } else if (isLegacyGasAPICompatible) {
+        const estimates = await this.fetchLegacyGasPriceEstimates(this.config.legacyAPIEndpoint.replace("<chain_id>", `${chainIdInt}`));
+        newState = {
+          gasFeeEstimates: estimates,
+          estimatedGasFeeTimeBounds: {},
+          gasEstimateType: GAS_ESTIMATE_TYPES.LEGACY,
+        };
+      } else {
+        throw new Error("Main gas fee/price estimation failed. Use fallback");
+      }
+    } catch {
+      try {
+        const estimates = await this.fetchEthGasPriceEstimate(this.provider);
+        newState = {
+          gasFeeEstimates: estimates,
+          estimatedGasFeeTimeBounds: {},
+          gasEstimateType: GAS_ESTIMATE_TYPES.ETH_GASPRICE,
+        };
+      } catch (error) {
+        throw new Error(`Gas fee/price estimation failed. Message: ${(error as Error).message}`);
+      }
+    }
+    this.update(newState);
+
+    return newState;
+  }
+
+  private async _startPolling() {
+    this._poll();
+  }
+
+  private async _poll() {
+    if (this.intervalId) {
+      window.clearInterval(this.intervalId);
+    }
+    this.intervalId = window.setInterval(async () => {
+      if (!idleTimeTracker.checkIfIdle()) {
+        await this._fetchGasFeeEstimateData();
+      }
+    }, this.config.interval);
+  }
+
+  private resetState() {
+    this.update(cloneDeep(this.defaultState));
+  }
+
+  private async getEIP1559Compatibility(): Promise<boolean> {
+    const currentNetworkIsEIP1559Compatible = await this.getCurrentNetworkEIP1559Compatibility();
+    const currentAccountIsEIP1559Compatible = this.getCurrentAccountEIP1559Compatibility?.() ?? true;
+
+    return currentNetworkIsEIP1559Compatible && currentAccountIsEIP1559Compatible;
+  }
+
+  private getTimeEstimate(maxPriorityFeePerGas: string, maxFeePerGas: string): GasFeeTimeBounds {
+    if (!this.state.gasFeeEstimates || this.state.gasEstimateType !== GAS_ESTIMATE_TYPES.FEE_MARKET) {
+      return {};
+    }
+    return calculateTimeEstimate(maxPriorityFeePerGas, maxFeePerGas, this.state.gasFeeEstimates as EthereumGasFeeEstimates);
+  }
+}

package/src/Gas/IGasFeeController.ts

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