@toruslabs/ethereum-controllers 5.11.0 → 6.0.1

package/dist/ethereumControllers.umd.min.js.LICENSE.txt

@@ -1,3 +1,10 @@
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+
 /*!
  * The buffer module from node.js, for the browser.
  *
@@ -17,8 +24,6 @@
  * MIT licensed
  */
 
-/*! https://mths.be/punycode v1.4.1 by @mathias */
-
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */

package/dist/lib.cjs/Account/AccountTrackerController.js

@@ -0,0 +1,160 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var asyncMutex = require('async-mutex');
+var ethers = require('ethers');
+var log = require('loglevel');
+var abis = require('../utils/abis.js');
+var contractAddresses = require('../utils/contractAddresses.js');
+
+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 baseControllers.BaseController {
+  constructor({
+    config,
+    state,
+    provider,
+    blockTracker,
+    getIdentities,
+    onPreferencesStateChange,
+    getCurrentChainId
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "provider", void 0);
+    _defineProperty(this, "blockTracker", void 0);
+    _defineProperty(this, "mutex", new asyncMutex.Mutex());
+    _defineProperty(this, "ethersProvider", void 0);
+    _defineProperty(this, "getIdentities", void 0);
+    _defineProperty(this, "getCurrentChainId", void 0);
+    this.defaultState = {
+      accounts: {}
+    };
+    this.initialize();
+    this.provider = provider;
+    this.blockTracker = blockTracker;
+    this.ethersProvider = new ethers.BrowserProvider(this.provider, "any");
+    this.getIdentities = getIdentities;
+    this.getCurrentChainId = getCurrentChainId;
+    onPreferencesStateChange(() => {
+      const refreshNeeded = this.syncAccounts();
+      if (refreshNeeded) {
+        log.info("onPreferencesStateChange called");
+        this.refresh();
+      }
+    });
+    this.blockTrackerListener = this.blockTrackerListener.bind(this);
+  }
+  blockTrackerListener() {
+    this.refresh();
+  }
+  startPolling() {
+    this.stopPolling();
+    // Initiate block tracker internal tracking.
+    if (Object.keys(this.state.accounts).length > 0) {
+      // Adding this listener on block tracker triggers it to start polling.
+      this.blockTracker.on("latest", this.blockTrackerListener);
+    }
+  }
+  stopPolling() {
+    this.blockTracker.removeListener("latest", this.blockTrackerListener);
+  }
+  syncAccounts() {
+    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: _objectSpread({}, accounts)
+    });
+    return isUpdated;
+  }
+  async refresh() {
+    const releaseLock = await this.mutex.acquire();
+    try {
+      this._updateAccounts();
+    } catch (error) {} finally {
+      releaseLock();
+    }
+  }
+  async _updateAccounts() {
+    const {
+      accounts
+    } = this.state;
+    const addresses = Object.keys(accounts);
+    const chainId = this.getCurrentChainId();
+    if (chainId === "loading") return;
+    if (addresses.length > 0) {
+      if (contractAddresses.SINGLE_CALL_BALANCES_ADDRESSES[chainId]) {
+        await this._updateAccountsViaBalanceChecker(addresses, contractAddresses.SINGLE_CALL_BALANCES_ADDRESSES[chainId]);
+        return;
+      }
+      log.info("falling back to ethQuery.getBalance");
+      await Promise.all(addresses.map(x => this._updateAccount(x)));
+    }
+  }
+  async _updateAccount(address) {
+    const balance = await this.provider.request({
+      method: "eth_getBalance",
+      params: [address, "latest"]
+    });
+    const {
+      accounts
+    } = this.state;
+    if (!accounts[address]) return;
+    accounts[address] = {
+      balance: ethers.toQuantity(balance)
+    };
+    this.update({
+      accounts
+    });
+  }
+  async _updateAccountsViaBalanceChecker(addresses, deployedContractAddress) {
+    const ethContract = new ethers.Contract(deployedContractAddress, abis.singleBalanceCheckerAbi, this.ethersProvider);
+    try {
+      const result = await ethContract.balances(addresses, [ZERO_ADDRESS]);
+      const {
+        accounts
+      } = this.state;
+      addresses.forEach((address, index) => {
+        const balance = ethers.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)));
+    }
+  }
+}
+
+exports.AccountTrackerController = AccountTrackerController;

package/dist/lib.cjs/Block/PollingBlockTracker.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var baseControllers = require('@toruslabs/base-controllers');
+var log = require('loglevel');
+var helpers = require('../utils/helpers.js');
+
+const DEFAULT_POLLING_INTERVAL = 20;
+const DEFAULT_RETRY_TIMEOUT = 2;
+const SEC = 1000;
+class PollingBlockTracker extends baseControllers.BaseBlockTracker {
+  constructor({
+    config,
+    state = {}
+  }) {
+    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() {
+    await this._updateLatestBlock();
+    return this.getLatestBlock();
+  }
+
+  // overrides the BaseBlockTracker._start method.
+  _start() {
+    this._synchronize().catch(err => this.emit("error", err));
+  }
+  async _synchronize() {
+    while (this.state._isRunning) {
+      if (helpers.idleTimeTracker.checkIfIdle()) return;
+      try {
+        await this._updateLatestBlock();
+        await baseControllers.timeout(this.config.pollingInterval);
+      } catch (err) {
+        const newErr = new Error(`PollingBlockTracker - encountered an error while attempting to update latest block:\n${err.stack}`);
+        try {
+          this.emit("error", newErr);
+        } catch (emitErr) {
+          log.error(newErr);
+        }
+        await baseControllers.timeout(this.config.retryTimeout);
+      }
+    }
+  }
+  async _updateLatestBlock() {
+    // fetch + set latest block
+    const latestBlock = await this._fetchLatestBlock();
+    this._newPotentialLatest(latestBlock);
+  }
+  async _fetchLatestBlock() {
+    try {
+      const block = await this.config.provider.request({
+        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.message}`);
+    }
+  }
+}
+
+exports.PollingBlockTracker = PollingBlockTracker;

package/dist/lib.cjs/Currency/CurrencyController.js

@@ -0,0 +1,111 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var baseControllers = require('@toruslabs/base-controllers');
+var httpHelpers = require('@toruslabs/http-helpers');
+var log = require('loglevel');
+var helpers = require('../utils/helpers.js');
+
+class CurrencyController extends baseControllers.BaseCurrencyController {
+  constructor({
+    config,
+    state,
+    onNetworkChanged
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "conversionInterval", void 0);
+    this.defaultState = _objectSpread(_objectSpread({}, 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();
+      }
+    });
+  }
+  setCommonDenomination(commonDenomination) {
+    this.update({
+      commonDenomination
+    });
+  }
+  getCommonDenomination() {
+    return this.state.commonDenomination;
+  }
+  setCommonDenominatorPrice(commonDenominatorPrice) {
+    this.update({
+      commonDenominatorPrice
+    });
+  }
+  getCommonDenominatorPrice() {
+    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.
+   */
+  scheduleConversionInterval() {
+    if (this.conversionInterval) {
+      window.clearInterval(this.conversionInterval);
+    }
+    this.conversionInterval = window.setInterval(() => {
+      if (!helpers.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
+   */
+  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");
+    }
+  }
+  async retrieveConversionRate(fromCurrency, toCurrency, commonDenomination) {
+    try {
+      let apiUrl = `${this.config.api}/currency?fsym=${fromCurrency.toUpperCase()}&tsyms=${toCurrency.toUpperCase()}`;
+      if (commonDenomination && commonDenomination.toUpperCase() !== toCurrency.toUpperCase()) {
+        apiUrl += `,${commonDenomination.toUpperCase()}`;
+      }
+      const parsedResponse = await httpHelpers.get(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"
+    };
+  }
+}
+
+exports.CurrencyController = CurrencyController;

package/dist/lib.cjs/Gas/GasFeeController.js

@@ -0,0 +1,214 @@
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var util = require('@ethereumjs/util');
+var baseControllers = require('@toruslabs/base-controllers');
+var log = require('loglevel');
+var constants = require('../utils/constants.js');
+var helpers = require('../utils/helpers.js');
+var gasUtil = require('./gasUtil.js');
+
+const GAS_FEE_API = "https://mock-gas-server.herokuapp.com/";
+const LEGACY_GAS_PRICES_API_URL = "https://api.metaswap.codefi.network/gasPrices";
+/**
+ * Returns gas prices in dec gwei
+ */
+class GasFeeController extends baseControllers.BaseController {
+  constructor({
+    config,
+    state,
+    getNetworkIdentifier,
+    getProvider,
+    fetchGasEstimates = gasUtil.fetchGasEstimates,
+    fetchEthGasPriceEstimate = gasUtil.fetchEthGasPriceEstimate,
+    fetchLegacyGasPriceEstimates = gasUtil.fetchLegacyGasPriceEstimates,
+    fetchGasEstimatesViaEthFeeHistory = gasUtil.fetchGasEstimatesViaEthFeeHistory,
+    getCurrentNetworkLegacyGasAPICompatibility,
+    getCurrentNetworkEIP1559Compatibility,
+    getCurrentAccountEIP1559Compatibility,
+    onNetworkStateChange
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "name", "GasFeeController");
+    // https://0x.org/docs/introduction/0x-cheat-sheet#swap-api-endpoints
+    _defineProperty(this, "API_SUPPORTED_CHAINIDS", new Set(["0x1", "0x5", "0xa4b1", "0xa86a", "0x2105", "0x38", "0xfa", "0xa", "0x89"]));
+    _defineProperty(this, "intervalId", void 0);
+    _defineProperty(this, "provider", void 0);
+    _defineProperty(this, "currentChainId", void 0);
+    _defineProperty(this, "getNetworkIdentifier", void 0);
+    _defineProperty(this, "getProvider", void 0);
+    _defineProperty(this, "fetchGasEstimates", void 0);
+    _defineProperty(this, "fetchGasEstimatesViaEthFeeHistory", void 0);
+    _defineProperty(this, "fetchEthGasPriceEstimate", void 0);
+    _defineProperty(this, "fetchLegacyGasPriceEstimates", void 0);
+    _defineProperty(this, "getCurrentNetworkEIP1559Compatibility", void 0);
+    _defineProperty(this, "getCurrentAccountEIP1559Compatibility", void 0);
+    _defineProperty(this, "getCurrentNetworkLegacyGasAPICompatibility", void 0);
+    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: 30000,
+      legacyAPIEndpoint: LEGACY_GAS_PRICES_API_URL,
+      EIP1559APIEndpoint: GAS_FEE_API
+    };
+    this.defaultState = {
+      gasFeeEstimates: {},
+      estimatedGasFeeTimeBounds: {},
+      gasEstimateType: constants.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.fetchGasFeeEstimates();
+    }
+  }
+  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
+   */
+  async _fetchGasFeeEstimateData() {
+    let isEIP1559Compatible;
+    const isLegacyGasAPICompatible = this.getCurrentNetworkLegacyGasAPICompatibility();
+    const chainId = this.getNetworkIdentifier();
+    if (chainId === "loading") return;
+    let chainIdInt;
+    if (typeof chainId === "string" && util.isHexString(util.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 = baseControllers.cloneDeep(this.defaultState);
+    try {
+      if (isEIP1559Compatible) {
+        let estimates;
+        try {
+          if (this.API_SUPPORTED_CHAINIDS.has(chainId)) {
+            estimates = await this.fetchGasEstimates(this.config.EIP1559APIEndpoint.replace("<chain_id>", `${chainIdInt}`));
+          } else {
+            throw new Error("ChainId not supported by api");
+          }
+        } catch (error) {
+          estimates = await this.fetchGasEstimatesViaEthFeeHistory(this.provider);
+        }
+        const {
+          suggestedMaxPriorityFeePerGas,
+          suggestedMaxFeePerGas
+        } = estimates.medium;
+        const estimatedGasFeeTimeBounds = this.getTimeEstimate(suggestedMaxPriorityFeePerGas, suggestedMaxFeePerGas);
+        newState = {
+          gasFeeEstimates: estimates,
+          estimatedGasFeeTimeBounds,
+          gasEstimateType: constants.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: constants.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: constants.GAS_ESTIMATE_TYPES.ETH_GASPRICE
+        };
+      } catch (error) {
+        throw new Error(`Gas fee/price estimation failed. Message: ${error.message}`);
+      }
+    }
+    this.update(newState);
+    return newState;
+  }
+  async _startPolling() {
+    this._poll();
+  }
+  async _poll() {
+    if (this.intervalId) {
+      window.clearInterval(this.intervalId);
+    }
+    this.intervalId = window.setInterval(async () => {
+      if (!helpers.idleTimeTracker.checkIfIdle()) {
+        await this._fetchGasFeeEstimateData();
+      }
+    }, this.config.interval);
+  }
+  resetState() {
+    this.update(baseControllers.cloneDeep(this.defaultState));
+  }
+  async getEIP1559Compatibility() {
+    var _this$getCurrentAccou, _this$getCurrentAccou2;
+    const currentNetworkIsEIP1559Compatible = await this.getCurrentNetworkEIP1559Compatibility();
+    const currentAccountIsEIP1559Compatible = (_this$getCurrentAccou = (_this$getCurrentAccou2 = this.getCurrentAccountEIP1559Compatibility) === null || _this$getCurrentAccou2 === void 0 ? void 0 : _this$getCurrentAccou2.call(this)) !== null && _this$getCurrentAccou !== void 0 ? _this$getCurrentAccou : true;
+    return currentNetworkIsEIP1559Compatible && currentAccountIsEIP1559Compatible;
+  }
+  getTimeEstimate(maxPriorityFeePerGas, maxFeePerGas) {
+    if (!this.state.gasFeeEstimates || this.state.gasEstimateType !== constants.GAS_ESTIMATE_TYPES.FEE_MARKET) {
+      return {};
+    }
+    return gasUtil.calculateTimeEstimate(maxPriorityFeePerGas, maxFeePerGas, this.state.gasFeeEstimates);
+  }
+}
+
+exports.GasFeeController = GasFeeController;