@toruslabs/ethereum-controllers 5.10.1 → 6.0.0

package/dist/lib.cjs/utils/helpers.js

@@ -0,0 +1,244 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var util = require('@ethereumjs/util');
+var baseControllers = require('@toruslabs/base-controllers');
+var BigNumber = require('bignumber.js');
+var log = require('loglevel');
+var TransactionUtils = require('../Transaction/TransactionUtils.js');
+var constants = require('./constants.js');
+
+function hexToBn(hex) {
+  return new BigNumber(util.stripHexPrefix(hex), 16);
+}
+function BNToHex(bn) {
+  return util.addHexPrefix(bn.toString(16));
+}
+function getEtherScanHashLink(txHash, chainId) {
+  if (!constants.SUPPORTED_NETWORKS[chainId]) return "";
+  return `${constants.SUPPORTED_NETWORKS[chainId].blockExplorerUrl}/tx/${txHash}`;
+}
+const formatPastTx = params => {
+  var _transaction$to;
+  const {
+    transaction,
+    lowerCaseSelectedAddress,
+    blockExplorerUrl
+  } = params;
+  let totalAmountString = "";
+  if (transaction.type === constants.CONTRACT_TYPE_ERC721 || transaction.type === constants.CONTRACT_TYPE_ERC1155) totalAmountString = transaction.symbol;else if (transaction.type === constants.CONTRACT_TYPE_ERC20) totalAmountString = baseControllers.formatSmallNumbers(Number.parseFloat(transaction.total_amount), transaction.symbol, true);else totalAmountString = baseControllers.formatSmallNumbers(Number.parseFloat(transaction.total_amount), transaction.type_name, true);
+  const currencyAmountString = transaction.type === constants.CONTRACT_TYPE_ERC721 || transaction.type === constants.CONTRACT_TYPE_ERC1155 || transaction.isEtherscan ? "" : baseControllers.formatSmallNumbers(Number.parseFloat(transaction.currency_amount), transaction.selected_currency, true);
+  const finalObject = {
+    id: transaction.created_at.toString(),
+    date: new Date(transaction.created_at).toString(),
+    from: transaction.from,
+    from_aa_address: transaction.from_aa_address,
+    slicedFrom: typeof transaction.from === "string" ? baseControllers.addressSlicer(transaction.from) : "",
+    to: transaction.to,
+    slicedTo: typeof transaction.to === "string" ? baseControllers.addressSlicer(transaction.to) : "",
+    action: lowerCaseSelectedAddress === ((_transaction$to = transaction.to) === null || _transaction$to === void 0 ? void 0 : _transaction$to.toLowerCase()) || "" ? baseControllers.ACTIVITY_ACTION_RECEIVE : baseControllers.ACTIVITY_ACTION_SEND,
+    totalAmount: transaction.total_amount,
+    totalAmountString,
+    currencyAmount: transaction.currency_amount,
+    currencyAmountString,
+    amount: `${totalAmountString} / ${currencyAmountString}`,
+    status: transaction.status,
+    etherscanLink: blockExplorerUrl ? `${blockExplorerUrl}/tx/${transaction.transaction_hash}` : "",
+    chainId: transaction.chain_id,
+    ethRate: Number.parseFloat(transaction === null || transaction === void 0 ? void 0 : transaction.total_amount) && Number.parseFloat(transaction === null || transaction === void 0 ? void 0 : transaction.currency_amount) ? `1 ${transaction.symbol} = ${baseControllers.significantDigits(Number.parseFloat(transaction.currency_amount) / Number.parseFloat(transaction.total_amount))}` : "",
+    currencyUsed: transaction.selected_currency,
+    type: transaction.type,
+    type_name: transaction.type_name,
+    type_image_link: transaction.type_image_link,
+    transaction_hash: transaction.transaction_hash,
+    transaction_category: transaction.transaction_category,
+    isEtherscan: transaction.isEtherscan,
+    input: transaction.input || "",
+    token_id: transaction.token_id || "",
+    contract_address: transaction.contract_address || "",
+    nonce: transaction.nonce || "",
+    is_cancel: !!transaction.is_cancel || false,
+    gas: transaction.gas || "",
+    gasPrice: transaction.gasPrice || ""
+  };
+  return finalObject;
+};
+
+/**
+ * Ref - https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt
+ */
+const getEthTxStatus = async (hash, provider) => {
+  try {
+    const result = await provider.request({
+      method: constants.METHOD_TYPES.ETH_GET_TRANSACTION_RECEIPT,
+      params: [hash]
+    });
+    if (result === null) return baseControllers.TransactionStatus.submitted;
+    if (result && result.status === "0x1") return baseControllers.TransactionStatus.confirmed;
+    if (result && result.status === "0x0") return baseControllers.TransactionStatus.rejected;
+    return undefined;
+  } catch (err) {
+    log.warn("unable to fetch transaction status", err);
+    return undefined;
+  }
+};
+function formatDate(inputDate) {
+  const monthList = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const date = new Date(inputDate);
+  const day = date.getDate();
+  const month = monthList[date.getMonth()];
+  const year = date.getFullYear();
+  return `${day} ${month} ${year}`;
+}
+function formatTime(time) {
+  return new Date(time).toTimeString().slice(0, 8);
+}
+const idleTimeTracker = (activityThresholdTime => {
+  let isIdle = false;
+  let idleTimeout = null;
+  const resetTimer = () => {
+    if (idleTimeout) {
+      window.clearTimeout(idleTimeout);
+    }
+    isIdle = false;
+    idleTimeout = window.setTimeout(() => {
+      isIdle = true;
+    }, activityThresholdTime * 1000);
+  };
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    window.addEventListener("load", resetTimer);
+    document.addEventListener("mousemove", resetTimer);
+    document.addEventListener("keydown", resetTimer);
+  }
+  function checkIfIdle() {
+    return isIdle;
+  }
+  return {
+    checkIfIdle
+  };
+})(60 * 3);
+function isAddressByChainId(address, _chainId) {
+  // TOOD: add rsk network checks.
+  return util.isValidAddress(address);
+}
+function toChecksumAddressByChainId(address, chainId) {
+  // TOOD: add rsk network checks.
+  if (!isAddressByChainId(address)) return address;
+  return util.toChecksumAddress(address);
+}
+const GAS_LIMITS = {
+  // maximum gasLimit of a simple send
+  SIMPLE: util.addHexPrefix(21000 .toString(16)),
+  // a base estimate for token transfers.
+  BASE_TOKEN_ESTIMATE: util.addHexPrefix(100000 .toString(16))
+};
+function bnLessThan(a, b) {
+  if (a === null || a === undefined || b === null || b === undefined) {
+    return null;
+  }
+  return new BigNumber(a, 10).lt(b, 10);
+}
+const getIpfsEndpoint = path => `https://infura-ipfs.io/${path}`;
+function sanitizeNftMetdataUrl(url) {
+  let finalUri = url;
+  if (url !== null && url !== void 0 && url.startsWith("ipfs")) {
+    const ipfsPath = url.split("ipfs://")[1];
+    finalUri = getIpfsEndpoint(ipfsPath);
+  }
+  return finalUri;
+}
+function getChainType(chainId) {
+  if (chainId === constants.MAINNET_CHAIN_ID) {
+    return "mainnet";
+  } else if (constants.TEST_CHAINS.includes(chainId)) {
+    return "testnet";
+  }
+  return "custom";
+}
+const addEtherscanTransactions = async params => {
+  const {
+    txn,
+    lowerCaseSelectedAddress,
+    provider,
+    chainId,
+    blockExplorerUrl
+  } = params;
+  const transactionPromises = await Promise.all(txn.map(async tx => {
+    var _SUPPORTED_NETWORKS$c, _SUPPORTED_NETWORKS$c2;
+    const {
+      category,
+      type
+    } = await TransactionUtils.determineTransactionType(_objectSpread(_objectSpread({}, tx), {}, {
+      data: tx.input
+    }), provider);
+    tx.transaction_category = tx.transaction_category || category;
+    tx.type_image_link = ((_SUPPORTED_NETWORKS$c = constants.SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c === void 0 ? void 0 : _SUPPORTED_NETWORKS$c.logo) || "";
+    tx.type_name = (_SUPPORTED_NETWORKS$c2 = constants.SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c2 === void 0 ? void 0 : _SUPPORTED_NETWORKS$c2.ticker;
+    tx.type = type;
+    return tx;
+  }));
+  const finalTxs = transactionPromises.reduce((accumulator, x) => {
+    var _SUPPORTED_NETWORKS$c3, _SUPPORTED_NETWORKS$c4;
+    let totalAmountString = x.value ? new BigNumber(x.value).div(new BigNumber(10).pow(new BigNumber(x.tokenDecimal || 18))).toString() : "";
+    let type = constants.CONTRACT_TYPE_ETH;
+    if (x.contractAddress !== "") {
+      if (x.tokenID) {
+        type = x.tokenValue ? constants.CONTRACT_TYPE_ERC1155 : constants.CONTRACT_TYPE_ERC721;
+      } else {
+        type = constants.CONTRACT_TYPE_ERC20;
+      }
+    }
+    if (type === constants.CONTRACT_TYPE_ERC1155) {
+      totalAmountString = x.tokenValue;
+    }
+    const etherscanTransaction = {
+      type,
+      type_image_link: x.type_image_link || "n/a",
+      type_name: x.tokenName || ((_SUPPORTED_NETWORKS$c3 = constants.SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c3 === void 0 ? void 0 : _SUPPORTED_NETWORKS$c3.ticker) || "n/a",
+      symbol: x.tokenSymbol || ((_SUPPORTED_NETWORKS$c4 = constants.SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c4 === void 0 ? void 0 : _SUPPORTED_NETWORKS$c4.ticker),
+      token_id: x.tokenID || "",
+      total_amount: totalAmountString,
+      created_at: new Date(Number(x.timeStamp) * 1000),
+      from: x.from,
+      to: x.to,
+      transaction_hash: x.hash,
+      status: x.txreceipt_status && x.txreceipt_status === "0" ? baseControllers.TransactionStatus.failed : baseControllers.TransactionStatus.confirmed,
+      isEtherscan: true,
+      input: x.input,
+      contract_address: x.contractAddress,
+      transaction_category: x.transaction_category,
+      gas: `0x${new BigNumber(x.gasUsed || 0, 10).toString(16)}`,
+      gasPrice: `0x${new BigNumber(x.gasPrice || 0, 10).toString(16)}`,
+      chain_id: chainId,
+      currency_amount: "",
+      nonce: x.nonce,
+      from_aa_address: "",
+      is_cancel: false,
+      selected_currency: ""
+    };
+    accumulator.push(formatPastTx({
+      transaction: etherscanTransaction,
+      lowerCaseSelectedAddress,
+      blockExplorerUrl
+    }));
+    return accumulator;
+  }, []);
+  return finalTxs;
+};
+
+exports.BNToHex = BNToHex;
+exports.GAS_LIMITS = GAS_LIMITS;
+exports.addEtherscanTransactions = addEtherscanTransactions;
+exports.bnLessThan = bnLessThan;
+exports.formatDate = formatDate;
+exports.formatPastTx = formatPastTx;
+exports.formatTime = formatTime;
+exports.getChainType = getChainType;
+exports.getEthTxStatus = getEthTxStatus;
+exports.getEtherScanHashLink = getEtherScanHashLink;
+exports.getIpfsEndpoint = getIpfsEndpoint;
+exports.hexToBn = hexToBn;
+exports.idleTimeTracker = idleTimeTracker;
+exports.isAddressByChainId = isAddressByChainId;
+exports.sanitizeNftMetdataUrl = sanitizeNftMetdataUrl;
+exports.toChecksumAddressByChainId = toChecksumAddressByChainId;

package/dist/lib.cjs/utils/lodashUtils.js

@@ -0,0 +1,25 @@
+'use strict';
+
+function sortBy(arr, key) {
+  return arr.slice().sort((a, b) => {
+    if (a[key] < b[key]) return -1;
+    if (a[key] > b[key]) return 1;
+    return 0;
+  });
+}
+function keyBy(arr, key) {
+  return arr.reduce((acc, item) => {
+    const keyValue = item[key];
+    if (typeof keyValue === "string" || typeof keyValue === "number") {
+      acc[keyValue.toString()] = item;
+    }
+    return acc;
+  }, {});
+}
+function mapValues(obj, iteratee) {
+  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, iteratee(value, key)]));
+}
+
+exports.keyBy = keyBy;
+exports.mapValues = mapValues;
+exports.sortBy = sortBy;

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

@@ -0,0 +1,158 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { BaseController } from '@toruslabs/base-controllers';
+import { Mutex } from 'async-mutex';
+import { BrowserProvider, toQuantity, Contract } from 'ethers';
+import log from 'loglevel';
+import { singleBalanceCheckerAbi } from '../utils/abis.js';
+import { SINGLE_CALL_BALANCES_ADDRESSES } from '../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 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 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 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 (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)));
+    }
+  }
+  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: toQuantity(balance)
+    };
+    this.update({
+      accounts
+    });
+  }
+  async _updateAccountsViaBalanceChecker(addresses, deployedContractAddress) {
+    const ethContract = new Contract(deployedContractAddress, singleBalanceCheckerAbi, this.ethersProvider);
+    try {
+      const result = 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 { AccountTrackerController };

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

@@ -0,0 +1,83 @@
+import { BaseBlockTracker, timeout } from '@toruslabs/base-controllers';
+import log from 'loglevel';
+import { idleTimeTracker } from '../utils/helpers.js';
+
+const DEFAULT_POLLING_INTERVAL = 20;
+const DEFAULT_RETRY_TIMEOUT = 2;
+const SEC = 1000;
+class PollingBlockTracker extends 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 (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.stack}`);
+        try {
+          this.emit("error", newErr);
+        } catch (emitErr) {
+          log.error(newErr);
+        }
+        await 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}`);
+    }
+  }
+}
+
+export { PollingBlockTracker };

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

@@ -0,0 +1,109 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { BaseCurrencyController } from '@toruslabs/base-controllers';
+import { get } from '@toruslabs/http-helpers';
+import log from 'loglevel';
+import { idleTimeTracker } from '../utils/helpers.js';
+
+class CurrencyController extends 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 (!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 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"
+    };
+  }
+}
+
+export { CurrencyController };