@toruslabs/ethereum-controllers 5.3.3 → 5.3.5

package/dist/ethereumControllers.esm.js

@@ -1,18 +1,18 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { CHAIN_NAMESPACES, BaseController, formatSmallNumbers, addressSlicer, ACTIVITY_ACTION_RECEIVE, ACTIVITY_ACTION_SEND, significantDigits, TransactionStatus, BaseBlockTracker, timeout, BaseCurrencyController, BaseKeyringController, randomId, PROVIDER_JRPC_METHODS, createFetchMiddleware, createSwappableProxy, createEventEmitterProxy, BasePreferencesController, TX_EVENTS, TRANSACTION_TYPES, BaseTransactionStateManager, transactionMatchesNetwork as transactionMatchesNetwork$1 } from '@toruslabs/base-controllers';
+import { CHAIN_NAMESPACES, BaseController, randomId, TransactionStatus, TRANSACTION_TYPES, formatSmallNumbers, addressSlicer, ACTIVITY_ACTION_RECEIVE, ACTIVITY_ACTION_SEND, significantDigits, BaseBlockTracker, timeout, BaseCurrencyController, BaseKeyringController, PROVIDER_JRPC_METHODS, createFetchMiddleware, createSwappableProxy, createEventEmitterProxy, BasePreferencesController, TX_EVENTS, BaseTransactionStateManager, transactionMatchesNetwork as transactionMatchesNetwork$1 } from '@toruslabs/base-controllers';
 import { Mutex } from 'async-mutex';
-import { BrowserProvider, toQuantity, Contract, SigningKey, Wallet, isHexString as isHexString$1, JsonRpcProvider, Interface, keccak256 } from 'ethers';
+import { BrowserProvider, toQuantity, Contract, Interface, formatEther, SigningKey, Wallet, isHexString as isHexString$1, JsonRpcProvider, keccak256 } from 'ethers';
 import log from 'loglevel';
-import { addHexPrefix, isValidAddress, toChecksumAddress, stripHexPrefix, isHexString, ecsign, bigIntToBytes, bytesToHex } from '@ethereumjs/util';
+import { isHexString, addHexPrefix, isValidAddress, toChecksumAddress, stripHexPrefix, ecsign, bigIntToBytes, bytesToHex } from '@ethereumjs/util';
 import BigNumber from 'bignumber.js';
+import { rpcErrors, providerErrors } from '@metamask/rpc-errors';
 import { get, post, remove, patch } from '@toruslabs/http-helpers';
 import { cloneDeep, merge, omitBy, mapValues, keyBy, sortBy, pickBy } from 'lodash';
-import '@babel/runtime/helpers/objectDestructuringEmpty';
+import _objectDestructuringEmpty from '@babel/runtime/helpers/objectDestructuringEmpty';
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import BN, { BN as BN$1 } from 'bn.js';
 import { concatSig, personalSign, signTypedData, getEncryptionPublicKey, decrypt, typedSignatureHash, TYPED_MESSAGE_SCHEMA, SignTypedDataVersion } from '@metamask/eth-sig-util';
-import { providerErrors, rpcErrors } from '@metamask/rpc-errors';
 import { validate } from 'jsonschema';
 import { createAsyncMiddleware, mergeMiddleware, createScaffoldMiddleware, providerFromMiddleware, JRPCEngine, providerFromEngine, SafeEventEmitter } from '@toruslabs/openlogin-jrpc';
 import { Hardfork, Common } from '@ethereumjs/common';
@@ -578,7 +578,7 @@ const SUPPORTED_NETWORKS = {
     blockExplorerUrl: "https://bscscan.com",
     chainId: BSC_MAINNET_CHAIN_ID,
     displayName: "Binance Smart Chain (BSC)",
-    logo: "bnb_logo.png",
+    logo: "bnb_logo.svg",
     rpcTarget: `https://bsc-dataseed.binance.org`,
     ticker: "BNB",
     tickerName: "Binance Coin"
@@ -633,7 +633,7 @@ const SUPPORTED_NETWORKS = {
     blockExplorerUrl: "https://gnosis.blockscout.com",
     chainId: XDAI_CHAIN_ID,
     displayName: "xDai",
-    logo: "xdai.svg",
+    logo: "xDai.svg",
     rpcTarget: `https://rpc.gnosischain.com`,
     ticker: "DAI",
     tickerName: "xDai Token"
@@ -679,7 +679,7 @@ const SUPPORTED_NETWORKS = {
     blockExplorerUrl: "https://testnet.bscscan.com",
     chainId: BSC_TESTNET_CHAIN_ID,
     displayName: "Binance Smart Chain Testnet",
-    logo: "bnb_logo.png",
+    logo: "bnb_logo.svg",
     rpcTarget: `https://data-seed-prebsc-1-s1.binance.org:8545`,
     ticker: "BNB",
     tickerName: "Binance Coin",
@@ -1015,425 +1015,903 @@ class AccountTrackerController extends BaseController {
   }
 }
 
-function getEtherScanHashLink(txHash, chainId) {
-  if (!SUPPORTED_NETWORKS[chainId]) return "";
-  return `${SUPPORTED_NETWORKS[chainId].blockExplorerUrl}/tx/${txHash}`;
-}
-const formatPastTx = (x, lowerCaseSelectedAddress) => {
-  var _x$to;
-  let totalAmountString = "";
-  if (x.type === CONTRACT_TYPE_ERC721 || x.type === CONTRACT_TYPE_ERC1155) totalAmountString = x.symbol;else if (x.type === CONTRACT_TYPE_ERC20) totalAmountString = formatSmallNumbers(Number.parseFloat(x.total_amount), x.symbol, true);else totalAmountString = formatSmallNumbers(Number.parseFloat(x.total_amount), x.type_name, true);
-  const currencyAmountString = x.type === CONTRACT_TYPE_ERC721 || x.type === CONTRACT_TYPE_ERC1155 ? "" : formatSmallNumbers(Number.parseFloat(x.currency_amount), x.selected_currency, true);
-  const finalObject = {
-    id: x.created_at.toString(),
-    date: new Date(x.created_at).toString(),
-    from: x.from,
-    from_aa_address: x.from_aa_address,
-    slicedFrom: typeof x.from === "string" ? addressSlicer(x.from) : "",
-    to: x.to,
-    slicedTo: typeof x.to === "string" ? addressSlicer(x.to) : "",
-    action: lowerCaseSelectedAddress === ((_x$to = x.to) === null || _x$to === void 0 ? void 0 : _x$to.toLowerCase()) || "" ? ACTIVITY_ACTION_RECEIVE : ACTIVITY_ACTION_SEND,
-    totalAmount: x.total_amount,
-    totalAmountString,
-    currencyAmount: x.currency_amount,
-    currencyAmountString,
-    amount: `${totalAmountString} / ${currencyAmountString}`,
-    status: x.status,
-    etherscanLink: getEtherScanHashLink(x.transaction_hash, x.chain_id || MAINNET_CHAIN_ID),
-    chainId: x.chain_id,
-    ethRate: Number.parseFloat(x === null || x === void 0 ? void 0 : x.total_amount) && Number.parseFloat(x === null || x === void 0 ? void 0 : x.currency_amount) ? `1 ${x.symbol} = ${significantDigits(Number.parseFloat(x.currency_amount) / Number.parseFloat(x.total_amount))}` : "",
-    currencyUsed: x.selected_currency,
-    type: x.type,
-    type_name: x.type_name,
-    type_image_link: x.type_image_link,
-    transaction_hash: x.transaction_hash,
-    transaction_category: x.transaction_category,
-    // TODO: // figure out how to handle these values.
-    // isEtherscan: x.isEtherscan,
-    // input: x.input || "",
-    // token_id: x.token_id || "",
-    contract_address: x.contract_address || "",
-    nonce: x.nonce || "",
-    is_cancel: !!x.is_cancel || false,
-    gas: x.gas || "",
-    gasPrice: x.gasPrice || ""
-  };
-  return finalObject;
+const erc20Interface = new Interface(erc20Abi);
+const erc721Interface = new Interface(erc721Abi);
+const erc1155Interface = new Interface(erc1155Abi);
+
+// functions that handle normalizing of that key in txParams
+
+const normalizers = {
+  from: function (from) {
+    let LowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    return LowerCase ? addHexPrefix(from).toLowerCase() : addHexPrefix(from);
+  },
+  to: function (to) {
+    let LowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    return LowerCase ? addHexPrefix(to).toLowerCase() : addHexPrefix(to);
+  },
+  nonce: nonce => addHexPrefix(nonce),
+  customNonceValue: nonce => addHexPrefix(nonce),
+  value: value => addHexPrefix(value),
+  data: data => addHexPrefix(data),
+  gas: gas => addHexPrefix(gas),
+  gasPrice: gasPrice => addHexPrefix(gasPrice),
+  type: addHexPrefix,
+  maxFeePerGas: addHexPrefix,
+  maxPriorityFeePerGas: addHexPrefix
 };
 
 /**
- * Ref - https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt
+ * normalizes txParams
  */
-const getEthTxStatus = async (hash, provider) => {
-  try {
-    const result = await provider.request({
-      method: METHOD_TYPES.ETH_GET_TRANSACTION_RECEIPT,
-      params: [hash]
-    });
-    if (result === null) return TransactionStatus.submitted;
-    if (result && result.status === "0x1") return TransactionStatus.confirmed;
-    if (result && result.status === "0x0") return 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);
+function normalizeTxParameters(txParameters) {
+  let lowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  // apply only keys in the normalizers
+  const normalizedTxParameters = {
+    id: txParameters.id || randomId(),
+    from: txParameters.from
   };
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    window.addEventListener("load", resetTimer);
-    document.addEventListener("mousemove", resetTimer);
-    document.addEventListener("keydown", resetTimer);
+  for (const key in normalizers) {
+    const currentKey = key;
+    if (txParameters[currentKey])
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      normalizedTxParameters[currentKey] = normalizers[currentKey](txParameters[currentKey], lowerCase);
   }
-  function checkIfIdle() {
-    return isIdle;
+  return normalizedTxParameters;
+}
+function transactionMatchesNetwork(transaction, chainId) {
+  if (typeof transaction.chainId !== "undefined") {
+    return transaction.chainId === chainId;
   }
-  return {
-    checkIfIdle
-  };
-})(60 * 3);
-function isAddressByChainId(address, _chainId) {
-  // TOOD: add rsk network checks.
-  return isValidAddress(address);
+  return false;
 }
-function toChecksumAddressByChainId(address, chainId) {
-  // TOOD: add rsk network checks.
-  if (!isAddressByChainId(address)) return address;
-  return toChecksumAddress(address);
+
+/**
+ * Determines if the maxFeePerGas and maxPriorityFeePerGas fields are supplied
+ * and valid inputs. This will return false for non hex string inputs.
+ *  the transaction to check
+ * @returns true if transaction uses valid EIP1559 fields
+ */
+function isEIP1559Transaction(transaction) {
+  var _transaction$transact, _transaction$transact2;
+  return isHexString(addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact = transaction.transaction) === null || _transaction$transact === void 0 ? void 0 : _transaction$transact.maxFeePerGas)) && isHexString(addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact2 = transaction.transaction) === null || _transaction$transact2 === void 0 ? void 0 : _transaction$transact2.maxPriorityFeePerGas));
 }
-const GAS_LIMITS = {
-  // maximum gasLimit of a simple send
-  SIMPLE: addHexPrefix(21000 .toString(16)),
-  // a base estimate for token transfers.
-  BASE_TOKEN_ESTIMATE: 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);
+
+/**
+ * Determine if the maxFeePerGas and maxPriorityFeePerGas fields are not
+ * supplied and that the gasPrice field is valid if it is provided. This will
+ * return false if gasPrice is a non hex string.
+ * transaction -
+ *  the transaction to check
+ * @returns true if transaction uses valid Legacy fields OR lacks
+ *  EIP1559 fields
+ */
+function isLegacyTransaction(transaction) {
+  return typeof transaction.transaction.maxFeePerGas === "undefined" && typeof transaction.transaction.maxPriorityFeePerGas === "undefined" && (typeof transaction.transaction.gasPrice === "undefined" || isHexString(addHexPrefix(transaction.transaction.gasPrice)));
 }
-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);
+
+/**
+ * Given two fields, ensure that the second field is not included in txParams,
+ * and if it is throw an invalidParams error.
+ */
+function ensureMutuallyExclusiveFieldsNotProvided(txParams, fieldBeingValidated, mutuallyExclusiveField) {
+  if (typeof txParams[mutuallyExclusiveField] !== "undefined") {
+    throw rpcErrors.invalidParams(`Invalid transaction params: specified ${fieldBeingValidated} but also included ${mutuallyExclusiveField}, these cannot be mixed`);
   }
-  return finalUri;
 }
-function getChainType(chainId) {
-  if (chainId === MAINNET_CHAIN_ID) {
-    return "mainnet";
-  } else if (TEST_CHAINS.includes(chainId)) {
-    return "testnet";
+
+/**
+ * Ensures that the provided value for field is a string, throws an
+ * invalidParams error if field is not a string.
+ */
+function ensureFieldIsString(txParams, field) {
+  if (typeof txParams[field] !== "string") {
+    throw rpcErrors.invalidParams(`Invalid transaction params: ${field} is not a string. got: (${txParams[field]})`);
   }
-  return "custom";
 }
 
-const DEFAULT_POLLING_INTERVAL = 20;
-const DEFAULT_RETRY_TIMEOUT = 2;
-const SEC = 1000;
-class PollingBlockTracker extends BaseBlockTracker {
-  constructor(_ref) {
-    let {
-      config,
-      state = {}
-    } = _ref;
-    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();
+/**
+ * Ensures that the provided txParams has the proper 'type' specified for the
+ * given field, if it is provided. If types do not match throws an
+ * invalidParams error.
+ */
+function ensureProperTransactionEnvelopeTypeProvided(txParams, field) {
+  switch (field) {
+    case "maxFeePerGas":
+    case "maxPriorityFeePerGas":
+      if (txParams.type && txParams.type !== TRANSACTION_ENVELOPE_TYPES.FEE_MARKET) {
+        throw rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + `including maxFeePerGas and maxPriorityFeePerGas requires type: "${TRANSACTION_ENVELOPE_TYPES.FEE_MARKET}"`);
+      }
+      break;
+    case "gasPrice":
+    default:
+      if (txParams.type && txParams.type === TRANSACTION_ENVELOPE_TYPES.FEE_MARKET) {
+        throw rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + "included a gasPrice instead of maxFeePerGas and maxPriorityFeePerGas");
+      }
   }
+}
 
-  // 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);
+/**
+ * validates the from field in  txParams
+ */
+function validateFrom(txParams) {
+  if (!(typeof txParams.from === "string")) {
+    throw rpcErrors.invalidParams(`Invalid "from" address "${txParams.from}": not a string.`);
   }
-  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}`);
-    }
+  if (!isValidAddress(txParams.from)) {
+    throw rpcErrors.invalidParams('Invalid "from" address.');
   }
 }
 
-class CurrencyController extends BaseCurrencyController {
-  constructor(_ref) {
-    let {
-      config,
-      state,
-      onNetworkChanged
-    } = _ref;
-    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);
-      }
+/**
+ * validates the to field in  txParams
+ */
+function validateRecipient(txParameters) {
+  if (txParameters.to === "0x" || txParameters.to === null) {
+    if (txParameters.data) {
+      delete txParameters.to;
     } else {
-      this.setConversionRate(0);
-      this.setConversionDate("N/A");
-    }
-  }
-  async retrieveConversionRate(fromCurrency, toCurrency, commonDenomination) {
-    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(apiUrl);
-      return parsedResponse;
-    } catch (error) {
-      log.error(error, `CurrencyController - updateCommonDenominatorPrice: Failed to query rate for currency: ${fromCurrency}/ ${toCurrency}`);
+      throw rpcErrors.invalidParams('Invalid "to" address.');
     }
-    return {
-      [toCurrency.toUpperCase()]: "0",
-      [commonDenomination.toUpperCase()]: "0"
-    };
+  } else if (txParameters.to !== undefined && !isValidAddress(txParameters.to)) {
+    throw rpcErrors.invalidParams('Invalid "to" address.');
   }
+  return txParameters;
 }
 
-// Big Number Constants
-const BIG_NUMBER_WEI_MULTIPLIER = new BigNumber("1000000000000000000");
-const BIG_NUMBER_GWEI_MULTIPLIER = new BigNumber("1000000000");
-const BIG_NUMBER_ETH_MULTIPLIER = new BigNumber("1");
-// Setter Maps
-const toBigNumber = {
-  hex: n => new BigNumber(stripHexPrefix(n), 16),
-  dec: n => new BigNumber(String(n), 10),
-  BN: n => new BigNumber(n.toString(16), 16)
-};
-const toNormalizedDenomination = {
-  WEI: bigNumber => bigNumber.div(BIG_NUMBER_WEI_MULTIPLIER),
-  GWEI: bigNumber => bigNumber.div(BIG_NUMBER_GWEI_MULTIPLIER),
-  ETH: bigNumber => bigNumber.div(BIG_NUMBER_ETH_MULTIPLIER)
-};
-const toSpecifiedDenomination = {
-  WEI: bigNumber => bigNumber.times(BIG_NUMBER_WEI_MULTIPLIER).dp(0, BigNumber.ROUND_HALF_UP),
-  GWEI: bigNumber => bigNumber.times(BIG_NUMBER_GWEI_MULTIPLIER).dp(9, BigNumber.ROUND_HALF_UP),
-  ETH: bigNumber => bigNumber.times(BIG_NUMBER_ETH_MULTIPLIER).dp(9, BigNumber.ROUND_HALF_UP)
-};
-const baseChange = {
-  hex: n => n.toString(16),
-  dec: n => new BigNumber(n).toString(10),
-  BN: n => new BN(n.toString(16))
-};
-
 /**
- * Utility method to convert a value between denominations, formats and currencies.
+ * Validates the given tx parameters
+ * @throws if the tx params contains invalid fields
  */
-const converter = _ref => {
-  let {
-    value,
-    fromNumericBase,
-    fromDenomination,
-    fromCurrency,
-    toNumericBase,
-    toDenomination,
-    toCurrency,
-    numberOfDecimals,
-    conversionRate,
-    invertConversionRate,
-    roundDown
-  } = _ref;
-  let convertedValue = fromNumericBase ? toBigNumber[fromNumericBase](value) : value;
-  if (fromDenomination) {
-    convertedValue = toNormalizedDenomination[fromDenomination](convertedValue);
-  }
-  if (fromCurrency !== toCurrency) {
-    if (conversionRate === null || conversionRate === undefined) {
-      throw new Error(`Converting from ${fromCurrency} to ${toCurrency} requires a conversionRate, but one was not provided`);
-    }
-    let rate = toBigNumber.dec(conversionRate);
-    if (invertConversionRate) {
-      rate = new BigNumber(1).div(conversionRate);
-    }
-    convertedValue = convertedValue.times(rate);
-  }
-  if (toDenomination) {
-    convertedValue = toSpecifiedDenomination[toDenomination](convertedValue);
-  }
-  if (numberOfDecimals) {
-    convertedValue = convertedValue.dp(numberOfDecimals, BigNumber.ROUND_HALF_DOWN);
-  }
-  if (roundDown) {
-    convertedValue = convertedValue.dp(roundDown, BigNumber.ROUND_DOWN);
+function validateTxParameters(txParams) {
+  let eip1559Compatibility = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (!txParams || typeof txParams !== "object" || Array.isArray(txParams)) {
+    throw rpcErrors.invalidParams("Invalid transaction params: must be an object.");
   }
-  if (toNumericBase) {
-    convertedValue = baseChange[toNumericBase](convertedValue);
+  if (!txParams.to && !txParams.data) {
+    throw rpcErrors.invalidParams('Invalid transaction params: must specify "data" for contract deployments, or "to" (and optionally "data") for all other types of transactions.');
   }
-  return convertedValue;
-};
-const conversionUtil = (value, _ref2) => {
-  let {
-    fromCurrency = null,
-    toCurrency = fromCurrency,
-    fromNumericBase,
-    toNumericBase,
-    fromDenomination,
-    toDenomination,
-    numberOfDecimals,
-    conversionRate,
-    invertConversionRate
-  } = _ref2;
-  if (fromCurrency !== toCurrency && !conversionRate) {
-    return 0;
+  if (isEIP1559Transaction({
+    transaction: txParams
+  }) && !eip1559Compatibility) {
+    throw rpcErrors.invalidParams("Invalid transaction params: params specify an EIP-1559 transaction but the current network does not support EIP-1559");
   }
-  return converter({
-    fromCurrency,
-    toCurrency,
-    fromNumericBase,
-    toNumericBase,
-    fromDenomination,
-    toDenomination,
-    numberOfDecimals,
-    conversionRate,
-    invertConversionRate,
+  Object.entries(txParams).forEach(_ref => {
+    let [key, value] = _ref;
+    // validate types
+    switch (key) {
+      case "from":
+        validateFrom(txParams);
+        break;
+      case "to":
+        validateRecipient(txParams);
+        break;
+      case "gasPrice":
+        ensureProperTransactionEnvelopeTypeProvided(txParams, "gasPrice");
+        ensureMutuallyExclusiveFieldsNotProvided(txParams, "gasPrice", "maxFeePerGas");
+        ensureMutuallyExclusiveFieldsNotProvided(txParams, "gasPrice", "maxPriorityFeePerGas");
+        ensureFieldIsString(txParams, "gasPrice");
+        break;
+      case "maxFeePerGas":
+        ensureProperTransactionEnvelopeTypeProvided(txParams, "maxFeePerGas");
+        ensureMutuallyExclusiveFieldsNotProvided(txParams, "maxFeePerGas", "gasPrice");
+        ensureFieldIsString(txParams, "maxFeePerGas");
+        break;
+      case "maxPriorityFeePerGas":
+        ensureProperTransactionEnvelopeTypeProvided(txParams, "maxPriorityFeePerGas");
+        ensureMutuallyExclusiveFieldsNotProvided(txParams, "maxPriorityFeePerGas", "gasPrice");
+        ensureFieldIsString(txParams, "maxPriorityFeePerGas");
+        break;
+      case "value":
+        ensureFieldIsString(txParams, "value");
+        if (value.toString().includes("-")) {
+          throw rpcErrors.invalidParams(`Invalid transaction value "${value}": not a positive number.`);
+        }
+        if (value.toString().includes(".")) {
+          throw rpcErrors.invalidParams(`Invalid transaction value of "${value}": number must be in wei.`);
+        }
+        break;
+      case "chainId":
+        if (typeof value !== "number" && typeof value !== "string") {
+          throw rpcErrors.invalidParams(`Invalid transaction params: ${key} is not a Number or hex string. got: (${value})`);
+        }
+        break;
+      default:
+        ensureFieldIsString(txParams, key);
+    }
+  });
+}
+function normalizeAndValidateTxParams(txParams) {
+  let lowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  const normalizedTxParams = normalizeTxParameters(txParams, lowerCase);
+  validateTxParameters(normalizedTxParams);
+  return normalizedTxParams;
+}
+
+/**
+ * @returns an array of states that can be considered final
+ */
+function getFinalStates() {
+  return [TransactionStatus.rejected,
+  // the user has responded no!
+  TransactionStatus.confirmed,
+  // the tx has been included in a block.
+  TransactionStatus.failed,
+  // the tx failed for some reason, included on tx data.
+  TransactionStatus.dropped // the tx nonce was already used
+  ];
+}
+function parseStandardTokenTransactionData(data) {
+  try {
+    const txDesc = erc20Interface.parseTransaction({
+      data
+    });
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: CONTRACT_TYPE_ERC20
+    };
+  } catch {
+    // ignore and next try to parse with erc721 ABI
+  }
+  try {
+    const txDesc = erc721Interface.parseTransaction({
+      data
+    });
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: CONTRACT_TYPE_ERC721
+    };
+  } catch {
+    // ignore and next try to parse with erc1155 ABI
+  }
+  try {
+    const txDesc = erc1155Interface.parseTransaction({
+      data
+    });
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: CONTRACT_TYPE_ERC1155
+    };
+  } catch {
+    // ignore and return undefined
+  }
+  return undefined;
+}
+const readAddressAsContract = async (provider, address) => {
+  let contractCode;
+  try {
+    contractCode = await provider.request({
+      method: METHOD_TYPES.ETH_GET_CODE,
+      params: [address, "latest"]
+    });
+  } catch (e) {
+    contractCode = null;
+  }
+  const isContractAddress = contractCode ? contractCode !== "0x" && contractCode !== "0x0" : false;
+  return {
+    contractCode,
+    isContractAddress
+  };
+};
+async function determineTransactionType(txParams, provider) {
+  const {
+    data,
+    to
+  } = txParams;
+  let name = "";
+  let methodParams = [];
+  let type = "";
+  try {
+    ({
+      name,
+      methodParams,
+      type
+    } = data && parseStandardTokenTransactionData(data) || {});
+  } catch (error) {
+    log.debug("Failed to parse transaction data", error);
+  }
+  let result;
+  let contractCode = "";
+  if (data && !to) {
+    result = TRANSACTION_TYPES.DEPLOY_CONTRACT;
+  } else {
+    const {
+      contractCode: resultCode,
+      isContractAddress
+    } = await readAddressAsContract(provider, to);
+    contractCode = resultCode;
+    if (isContractAddress) {
+      const valueExists = txParams.value && Number(txParams.value) !== 0;
+      const tokenMethodName = [TRANSACTION_TYPES.TOKEN_METHOD_APPROVE, TRANSACTION_TYPES.TOKEN_METHOD_TRANSFER, TRANSACTION_TYPES.TOKEN_METHOD_TRANSFER_FROM, TRANSACTION_TYPES.COLLECTIBLE_METHOD_SAFE_TRANSFER_FROM, TRANSACTION_TYPES.SET_APPROVAL_FOR_ALL].find(x => {
+        var _name;
+        return x.toLowerCase() === ((_name = name) === null || _name === void 0 ? void 0 : _name.toLowerCase());
+      });
+      result = data && tokenMethodName && !valueExists ? tokenMethodName : TRANSACTION_TYPES.CONTRACT_INTERACTION;
+    } else {
+      result = TRANSACTION_TYPES.SENT_ETHER;
+    }
+  }
+  return {
+    type: type || CONTRACT_TYPE_ETH,
+    category: result,
+    methodParams,
+    getCodeResponse: contractCode
+  };
+}
+
+function getEtherScanHashLink(txHash, chainId) {
+  if (!SUPPORTED_NETWORKS[chainId]) return "";
+  return `${SUPPORTED_NETWORKS[chainId].blockExplorerUrl}/tx/${txHash}`;
+}
+const formatPastTx = (x, lowerCaseSelectedAddress) => {
+  var _x$to;
+  let totalAmountString = "";
+  if (x.type === CONTRACT_TYPE_ERC721 || x.type === CONTRACT_TYPE_ERC1155) totalAmountString = x.symbol;else if (x.type === CONTRACT_TYPE_ERC20) totalAmountString = formatSmallNumbers(Number.parseFloat(x.total_amount), x.symbol, true);else totalAmountString = formatSmallNumbers(Number.parseFloat(x.total_amount), x.type_name, true);
+  const currencyAmountString = x.type === CONTRACT_TYPE_ERC721 || x.type === CONTRACT_TYPE_ERC1155 ? "" : formatSmallNumbers(Number.parseFloat(x.currency_amount), x.selected_currency, true);
+  const finalObject = {
+    id: x.created_at.toString(),
+    date: new Date(x.created_at).toString(),
+    from: x.from,
+    from_aa_address: x.from_aa_address,
+    slicedFrom: typeof x.from === "string" ? addressSlicer(x.from) : "",
+    to: x.to,
+    slicedTo: typeof x.to === "string" ? addressSlicer(x.to) : "",
+    action: lowerCaseSelectedAddress === ((_x$to = x.to) === null || _x$to === void 0 ? void 0 : _x$to.toLowerCase()) || "" ? ACTIVITY_ACTION_RECEIVE : ACTIVITY_ACTION_SEND,
+    totalAmount: x.total_amount,
+    totalAmountString,
+    currencyAmount: x.currency_amount,
+    currencyAmountString,
+    amount: `${totalAmountString} / ${currencyAmountString}`,
+    status: x.status,
+    etherscanLink: getEtherScanHashLink(x.transaction_hash, x.chain_id || MAINNET_CHAIN_ID),
+    chainId: x.chain_id,
+    ethRate: Number.parseFloat(x === null || x === void 0 ? void 0 : x.total_amount) && Number.parseFloat(x === null || x === void 0 ? void 0 : x.currency_amount) ? `1 ${x.symbol} = ${significantDigits(Number.parseFloat(x.currency_amount) / Number.parseFloat(x.total_amount))}` : "",
+    currencyUsed: x.selected_currency,
+    type: x.type,
+    type_name: x.type_name,
+    type_image_link: x.type_image_link,
+    transaction_hash: x.transaction_hash,
+    transaction_category: x.transaction_category,
+    // TODO: // figure out how to handle these values.
+    isEtherscan: x.isEtherscan,
+    input: x.input || "",
+    token_id: x.token_id || "",
+    contract_address: x.contract_address || "",
+    nonce: x.nonce || "",
+    is_cancel: !!x.is_cancel || false,
+    gas: x.gas || "",
+    gasPrice: x.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: METHOD_TYPES.ETH_GET_TRANSACTION_RECEIPT,
+      params: [hash]
+    });
+    if (result === null) return TransactionStatus.submitted;
+    if (result && result.status === "0x1") return TransactionStatus.confirmed;
+    if (result && result.status === "0x0") return 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 isValidAddress(address);
+}
+function toChecksumAddressByChainId(address, chainId) {
+  // TOOD: add rsk network checks.
+  if (!isAddressByChainId(address)) return address;
+  return toChecksumAddress(address);
+}
+const GAS_LIMITS = {
+  // maximum gasLimit of a simple send
+  SIMPLE: addHexPrefix(21000 .toString(16)),
+  // a base estimate for token transfers.
+  BASE_TOKEN_ESTIMATE: 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 === MAINNET_CHAIN_ID) {
+    return "mainnet";
+  } else if (TEST_CHAINS.includes(chainId)) {
+    return "testnet";
+  }
+  return "custom";
+}
+const addEtherscanTransactions = async (txn, lowerCaseSelectedAddress, provider, chainId) => {
+  const transactionPromises = await Promise.all(txn.map(async tx => {
+    var _SUPPORTED_NETWORKS$c, _SUPPORTED_NETWORKS$c2;
+    const {
+      category,
+      type
+    } = await determineTransactionType(_objectSpread(_objectSpread({}, tx), {}, {
+      data: tx.input
+    }), provider);
+    tx.transaction_category = tx.transaction_category || category;
+    tx.type_image_link = ((_SUPPORTED_NETWORKS$c = SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c === void 0 ? void 0 : _SUPPORTED_NETWORKS$c.logo) || "";
+    tx.type_name = (_SUPPORTED_NETWORKS$c2 = 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;
+    const totalAmount = x.value ? formatEther(x.value) : "";
+    const etherscanTransaction = {
+      etherscanLink: getEtherScanHashLink(x.hash, chainId),
+      type: x.type || ((_SUPPORTED_NETWORKS$c3 = SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c3 === void 0 ? void 0 : _SUPPORTED_NETWORKS$c3.ticker) || CONTRACT_TYPE_ETH,
+      type_image_link: x.type_image_link || "n/a",
+      type_name: x.type_name || "n/a",
+      symbol: (_SUPPORTED_NETWORKS$c4 = SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c4 === void 0 ? void 0 : _SUPPORTED_NETWORKS$c4.ticker,
+      token_id: x.tokenID || "",
+      total_amount: totalAmount,
+      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" ? TransactionStatus.failed : TransactionStatus.approved,
+      isEtherscan: true,
+      input: x.input,
+      contract_address: x.contractAddress,
+      transaction_category: x.transaction_category,
+      gas: x.gas,
+      gasPrice: x.gasPrice,
+      chain_id: chainId,
+      currency_amount: "",
+      nonce: x.nonce,
+      from_aa_address: "",
+      is_cancel: false,
+      selected_currency: ""
+    };
+    accumulator.push(formatPastTx(etherscanTransaction, lowerCaseSelectedAddress));
+    return accumulator;
+  }, []);
+  return finalTxs;
+};
+
+const DEFAULT_POLLING_INTERVAL = 20;
+const DEFAULT_RETRY_TIMEOUT = 2;
+const SEC = 1000;
+class PollingBlockTracker extends BaseBlockTracker {
+  constructor(_ref) {
+    let {
+      config,
+      state = {}
+    } = _ref;
+    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}`);
+    }
+  }
+}
+
+class CurrencyController extends BaseCurrencyController {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      onNetworkChanged
+    } = _ref;
+    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 {
+      // 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(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"
+    };
+  }
+}
+
+const _excluded$1 = ["aBase", "bBase"],
+  _excluded2 = ["aBase", "bBase"],
+  _excluded3 = ["multiplicandBase", "multiplierBase"];
+
+// Big Number Constants
+const BIG_NUMBER_WEI_MULTIPLIER = new BigNumber("1000000000000000000");
+const BIG_NUMBER_GWEI_MULTIPLIER = new BigNumber("1000000000");
+const BIG_NUMBER_ETH_MULTIPLIER = new BigNumber("1");
+// Setter Maps
+const toBigNumber = {
+  hex: n => new BigNumber(stripHexPrefix(n), 16),
+  dec: n => new BigNumber(String(n), 10),
+  BN: n => new BigNumber(n.toString(16), 16)
+};
+const toNormalizedDenomination = {
+  WEI: bigNumber => bigNumber.div(BIG_NUMBER_WEI_MULTIPLIER),
+  GWEI: bigNumber => bigNumber.div(BIG_NUMBER_GWEI_MULTIPLIER),
+  ETH: bigNumber => bigNumber.div(BIG_NUMBER_ETH_MULTIPLIER)
+};
+const toSpecifiedDenomination = {
+  WEI: bigNumber => bigNumber.times(BIG_NUMBER_WEI_MULTIPLIER).dp(0, BigNumber.ROUND_HALF_UP),
+  GWEI: bigNumber => bigNumber.times(BIG_NUMBER_GWEI_MULTIPLIER).dp(9, BigNumber.ROUND_HALF_UP),
+  ETH: bigNumber => bigNumber.times(BIG_NUMBER_ETH_MULTIPLIER).dp(9, BigNumber.ROUND_HALF_UP)
+};
+const baseChange = {
+  hex: n => n.toString(16),
+  dec: n => new BigNumber(n).toString(10),
+  BN: n => new BN(n.toString(16))
+};
+
+// Utility function for checking base types
+const isValidBase = base => Number.isInteger(base) && base > 1;
+
+/**
+ * Utility method to convert a value between denominations, formats and currencies.
+ */
+const converter = _ref => {
+  let {
+    value,
+    fromNumericBase,
+    fromDenomination,
+    fromCurrency,
+    toNumericBase,
+    toDenomination,
+    toCurrency,
+    numberOfDecimals,
+    conversionRate,
+    invertConversionRate,
+    roundDown
+  } = _ref;
+  let convertedValue = fromNumericBase ? toBigNumber[fromNumericBase](value) : value;
+  if (fromDenomination) {
+    convertedValue = toNormalizedDenomination[fromDenomination](convertedValue);
+  }
+  if (fromCurrency !== toCurrency) {
+    if (conversionRate === null || conversionRate === undefined) {
+      throw new Error(`Converting from ${fromCurrency} to ${toCurrency} requires a conversionRate, but one was not provided`);
+    }
+    let rate = toBigNumber.dec(conversionRate);
+    if (invertConversionRate) {
+      rate = new BigNumber(1).div(conversionRate);
+    }
+    convertedValue = convertedValue.times(rate);
+  }
+  if (toDenomination) {
+    convertedValue = toSpecifiedDenomination[toDenomination](convertedValue);
+  }
+  if (numberOfDecimals) {
+    convertedValue = convertedValue.dp(numberOfDecimals, BigNumber.ROUND_HALF_DOWN);
+  }
+  if (roundDown) {
+    convertedValue = convertedValue.dp(roundDown, BigNumber.ROUND_DOWN);
+  }
+  if (toNumericBase) {
+    convertedValue = baseChange[toNumericBase](convertedValue);
+  }
+  return convertedValue;
+};
+const conversionUtil = (value, _ref2) => {
+  let {
+    fromCurrency = null,
+    toCurrency = fromCurrency,
+    fromNumericBase,
+    toNumericBase,
+    fromDenomination,
+    toDenomination,
+    numberOfDecimals,
+    conversionRate,
+    invertConversionRate
+  } = _ref2;
+  if (fromCurrency !== toCurrency && !conversionRate) {
+    return 0;
+  }
+  return converter({
+    fromCurrency,
+    toCurrency,
+    fromNumericBase,
+    toNumericBase,
+    fromDenomination,
+    toDenomination,
+    numberOfDecimals,
+    conversionRate,
+    invertConversionRate,
     value
   });
 };
+const getBigNumber = (value, base) => {
+  if (!isValidBase(base)) {
+    throw new Error("Must specificy valid base");
+  }
+
+  // We don't include 'number' here, because BigNumber will throw if passed
+  // a number primitive it considers unsafe.
+  if (typeof value === "string" || value instanceof BigNumber) {
+    return new BigNumber(value, base);
+  }
+  return new BigNumber(String(value), base);
+};
+const addCurrencies = function (a, b) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const {
+      aBase,
+      bBase
+    } = options,
+    conversionOptions = _objectWithoutProperties(options, _excluded$1);
+  if (!isValidBase(aBase) || !isValidBase(bBase)) {
+    throw new Error("Must specify valid aBase and bBase");
+  }
+  const value = getBigNumber(a, aBase).plus(getBigNumber(b, bBase));
+  return converter(_objectSpread({
+    value
+  }, conversionOptions));
+};
+const subtractCurrencies = function (a, b) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const {
+      aBase,
+      bBase
+    } = options,
+    conversionOptions = _objectWithoutProperties(options, _excluded2);
+  if (!isValidBase(aBase) || !isValidBase(bBase)) {
+    throw new Error("Must specify valid aBase and bBase");
+  }
+  const value = getBigNumber(a, aBase).minus(getBigNumber(b, bBase));
+  return converter(_objectSpread({
+    value
+  }, conversionOptions));
+};
+const multiplyCurrencies = function (a, b) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const {
+      multiplicandBase,
+      multiplierBase
+    } = options,
+    conversionOptions = _objectWithoutProperties(options, _excluded3);
+  if (!isValidBase(multiplicandBase) || !isValidBase(multiplierBase)) {
+    throw new Error("Must specify valid multiplicandBase and multiplierBase");
+  }
+  const value = getBigNumber(a, multiplicandBase).times(getBigNumber(b, multiplierBase));
+  return converter(_objectSpread({
+    value
+  }, conversionOptions));
+};
+const conversionGreaterThan = (_ref3, _ref4) => {
+  let secondProps = Object.assign({}, (_objectDestructuringEmpty(_ref4), _ref4));
+  let firstProps = Object.assign({}, (_objectDestructuringEmpty(_ref3), _ref3));
+  const firstValue = converter(_objectSpread({}, firstProps));
+  const secondValue = converter(_objectSpread({}, secondProps));
+  return firstValue.gt(secondValue);
+};
+const conversionLessThan = (_ref5, _ref6) => {
+  let secondProps = Object.assign({}, (_objectDestructuringEmpty(_ref6), _ref6));
+  let firstProps = Object.assign({}, (_objectDestructuringEmpty(_ref5), _ref5));
+  const firstValue = converter(_objectSpread({}, firstProps));
+  const secondValue = converter(_objectSpread({}, secondProps));
+  return firstValue.lt(secondValue);
+};
+const conversionMax = (_ref7, _ref8) => {
+  let secondProps = Object.assign({}, (_objectDestructuringEmpty(_ref8), _ref8));
+  let firstProps = Object.assign({}, (_objectDestructuringEmpty(_ref7), _ref7));
+  const firstIsGreater = conversionGreaterThan(_objectSpread({}, firstProps), _objectSpread({}, secondProps));
+  return firstIsGreater ? firstProps.value : secondProps.value;
+};
+const conversionGTE = (_ref9, _ref10) => {
+  let secondProps = Object.assign({}, (_objectDestructuringEmpty(_ref10), _ref10));
+  let firstProps = Object.assign({}, (_objectDestructuringEmpty(_ref9), _ref9));
+  const firstValue = converter(_objectSpread({}, firstProps));
+  const secondValue = converter(_objectSpread({}, secondProps));
+  return firstValue.isGreaterThanOrEqualTo(secondValue);
+};
+const conversionLTE = (_ref11, _ref12) => {
+  let secondProps = Object.assign({}, (_objectDestructuringEmpty(_ref12), _ref12));
+  let firstProps = Object.assign({}, (_objectDestructuringEmpty(_ref11), _ref11));
+  const firstValue = converter(_objectSpread({}, firstProps));
+  const secondValue = converter(_objectSpread({}, secondProps));
+  return firstValue.isLessThanOrEqualTo(secondValue);
+};
+const toNegative = function (n) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return multiplyCurrencies(n, -1, options);
+};
 const decGWEIToHexWEI = decGWEI => {
   return conversionUtil(decGWEI, {
     fromNumericBase: "dec",
@@ -3619,7 +4097,8 @@ class PreferencesController extends BasePreferencesController {
       defaultPreferences: {
         formattedPastTransactions: [],
         fetchedPastTx: [],
-        paymentTx: []
+        paymentTx: [],
+        etherscanTransactions: []
       },
       signAuthMessage
     });
@@ -3800,10 +4279,15 @@ class PreferencesController extends BasePreferencesController {
         chainId
       } = this.getProviderConfig();
       if (ETHERSCAN_SUPPORTED_CHAINS.includes(chainId)) {
-        return this.fetchEtherscanTx({
+        const etherscanTxn = await this.fetchEtherscanTx({
           selectedAddress,
           chainId: this.getProviderConfig().chainId
         });
+        const finalEthScanTxn = await addEtherscanTransactions(etherscanTxn, selectedAddress, this.provider, chainId);
+        this.updateState({
+          etherscanTransactions: finalEthScanTxn
+        });
+        return etherscanTxn;
       }
     }
   }
@@ -3812,6 +4296,7 @@ class PreferencesController extends BasePreferencesController {
       const url = new URL(`${this.config.api}/etherscan`);
       url.searchParams.append("chainId", parameters.chainId);
       const response = await get(url.href, this.headers(parameters.selectedAddress));
+      log.info("Etherscan Response", response);
       return response.success ? response.data : [];
     } catch (error) {
       log.error("unable to fetch etherscan tx", error);
@@ -4522,712 +5007,385 @@ class NonceTracker {
     let mutex = this.lockMap[lockId];
     if (!mutex) {
       mutex = new Mutex();
-      this.lockMap[lockId] = mutex;
-    }
-    return mutex;
-  }
-  async _getNetworkNextNonce(address) {
-    // 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({
-      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
-    };
-  }
-  _getHighestLocallyConfirmed(address) {
-    const confirmedTransactions = this.getConfirmedTransactions(address);
-    const highest = this._getHighestNonce(confirmedTransactions);
-    return Number.isInteger(highest) ? highest + 1 : 0;
-  }
-  _getHighestNonce(txList) {
-    const nonces = txList.map(txMeta => {
-      const {
-        nonce
-      } = txMeta.transaction;
-      return Number.parseInt(nonce, 16);
-    });
-    const highestNonce = Math.max.apply(null, nonces);
-    return highestNonce;
-  }
-  _getHighestContinuousFrom(txList, startPoint) {
-    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
-      }
-    };
-  }
-}
-
-class PendingTransactionTracker extends SafeEventEmitter {
-  constructor(_ref) {
-    let {
-      provider,
-      nonceTracker,
-      approveTransaction,
-      publishTransaction,
-      getPendingTransactions,
-      getConfirmedTransactions
-    } = _ref;
-    super();
-    _defineProperty(this, "DROPPED_BUFFER_COUNT", 3);
-    _defineProperty(this, "nonceTracker", void 0);
-    _defineProperty(this, "provider", void 0);
-    _defineProperty(this, "approveTransaction", void 0);
-    _defineProperty(this, "droppedBlocksBufferByHash", void 0);
-    _defineProperty(this, "getConfirmedTransactions", void 0);
-    _defineProperty(this, "getPendingTransactions", void 0);
-    _defineProperty(this, "publishTransaction", void 0);
-    this.provider = provider;
-    this.nonceTracker = nonceTracker;
-    this.approveTransaction = approveTransaction;
-    this.publishTransaction = publishTransaction;
-    this.getPendingTransactions = getPendingTransactions;
-    this.getConfirmedTransactions = getConfirmedTransactions;
-    this.droppedBlocksBufferByHash = new Map();
-  }
-
-  /**
-    checks the network for signed txs and releases the nonce global lock if it is
-  */
-  async updatePendingTxs() {
-    // in order to keep the nonceTracker accurate we block it while updating pending transactions
-    const nonceGlobalLock = await this.nonceTracker.getGlobalLock();
-    try {
-      const pendingTxs = this.getPendingTransactions();
-      await Promise.all(pendingTxs.map(txMeta => this._checkPendingTx(txMeta)));
-    } catch (error) {
-      log.error("PendingTransactionTracker - Error updating pending transactions");
-      log.error(error);
-    }
-    nonceGlobalLock.releaseLock();
-  }
-  async resubmitPendingTxs(block) {
-    const pending = this.getPendingTransactions();
-    // only try resubmitting if their are transactions to resubmit
-    if (pending.length === 0) return;
-    // Keep this as a for loop because we want to wait for each item to be submitted
-    for (const txMeta of pending) {
-      try {
-        await this._resubmitTx(txMeta, block.idempotencyKey);
-      } catch (error) {
-        var _value;
-        /*
-        Dont marked as failed if the error is a "known" transaction warning
-        "there is already a transaction with the same sender-nonce
-        but higher/same gas price"
-        Also don't mark as failed if it has ever been broadcast successfully.
-        A successful broadcast means it may still be mined.
-        */
-        const errorMessage = ((_value = error.value) === null || _value === void 0 || (_value = _value.message) === null || _value === void 0 ? void 0 : _value.toLowerCase()) || error.message.toLowerCase();
-        const isKnownTx =
-        // geth
-        errorMessage.includes("replacement transaction underpriced") || errorMessage.includes("known transaction") ||
-        // parity
-        errorMessage.includes("gas price too low to replace") || errorMessage.includes("transaction with the same hash was already imported") ||
-        // other
-        errorMessage.includes("gateway timeout") || errorMessage.includes("nonce too low");
-        // ignore resubmit warnings, return early
-        if (isKnownTx) return;
-        // encountered real error - transition to error state
-        txMeta.warning = {
-          error: errorMessage,
-          message: "There was an error when resubmitting this transaction."
-        };
-        this.emit(TX_EVENTS.TX_WARNING, {
-          txMeta,
-          error,
-          txId: txMeta.id
-        });
-      }
-    }
-  }
-  async _resubmitTx(txMeta, latestBlockNumber) {
-    if (!txMeta.firstRetryBlockNumber) {
-      this.emit(TX_EVENTS.TX_BLOCK_UPDATE, {
-        txMeta,
-        latestBlockNumber,
-        txId: txMeta.id
-      });
-    }
-    const firstRetryBlockNumber = txMeta.firstRetryBlockNumber || latestBlockNumber;
-    const txBlockDistance = Number.parseInt(latestBlockNumber, 16) - Number.parseInt(firstRetryBlockNumber, 16);
-    const retryCount = txMeta.retryCount || 0;
-
-    // Exponential backoff to limit retries at publishing (capped at last 15 mins)
-    if (txBlockDistance <= Math.min(50, 2 ** retryCount)) return undefined;
-
-    // Only auto-submit already-signed txs:
-    if (!("rawTx" in txMeta)) return this.approveTransaction(txMeta.id);
-    const {
-      rawTx
-    } = txMeta;
-    const txHash = await this.publishTransaction(rawTx);
-
-    // Increment successful tries:
-    this.emit(TX_EVENTS.TX_RETRY, {
-      txMeta,
-      txId: txMeta.id
-    });
-    return txHash;
-  }
-  async _checkPendingTx(foundTx) {
-    const txMeta = foundTx;
-    const txHash = txMeta.transactionHash;
-    const txId = txMeta.id;
-
-    // Only check submitted txs
-    if (txMeta.status !== TransactionStatus.submitted) return;
-
-    // extra check in case there was an uncaught error during the
-    // signature and submission process
-    if (!txHash) {
-      const noTxHashError = new Error("We had an error while submitting this transaction, please try again.");
-      noTxHashError.name = "NoTxHashError";
-      this.emit(TX_EVENTS.TX_FAILED, {
-        txId,
-        error: noTxHashError
-      });
-      return;
-    }
-
-    // If another tx with the same nonce is mined, set as failed.
-    if (this._checkIfNonceIsTaken(txMeta)) {
-      this.emit(TX_EVENTS.TX_DROPPED, {
-        txId
-      });
-      return;
-    }
-    try {
-      const transactionReceipt = await this.provider.request({
-        method: METHOD_TYPES.ETH_GET_TRANSACTION_RECEIPT,
-        params: [txHash]
-      });
-      if (transactionReceipt !== null && transactionReceipt !== void 0 && transactionReceipt.blockNumber) {
-        const {
-          baseFeePerGas,
-          timestamp
-        } = await this.provider.request({
-          method: METHOD_TYPES.ETH_GET_BLOCK_BY_HASH,
-          params: [transactionReceipt.blockHash, false]
-        });
-        this.emit(TX_EVENTS.TX_CONFIRMED, {
-          txId,
-          txReceipt: transactionReceipt,
-          baseFeePerGas,
-          blockTimestamp: timestamp
-        });
-        return;
-      }
-    } catch (error) {
-      log.error("error while loading tx", error);
-      txMeta.warning = {
-        error: error.message,
-        message: "There was a problem loading this transaction."
-      };
-      this.emit(TX_EVENTS.TX_WARNING, {
-        txMeta
-      });
-    }
-    if (await this._checkIfTxWasDropped(txMeta)) {
-      this.emit(TX_EVENTS.TX_DROPPED, {
-        txId
-      });
+      this.lockMap[lockId] = mutex;
     }
+    return mutex;
   }
-  async _checkIfTxWasDropped(txMeta) {
-    const {
-      transactionHash: txHash,
-      transaction: {
-        nonce,
-        from
-      }
-    } = txMeta;
-    const networkNextNonce = await this.provider.request({
+  async _getNetworkNextNonce(address) {
+    // 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({
       method: METHOD_TYPES.ETH_GET_TRANSACTION_COUNT,
-      params: [from, "latest"]
+      params: [address, block.idempotencyKey]
     });
-    if (Number.parseInt(nonce, 16) >= Number.parseInt(networkNextNonce, 16)) {
-      return false;
-    }
-    if (!this.droppedBlocksBufferByHash.has(txHash)) {
-      this.droppedBlocksBufferByHash.set(txHash, 0);
-    }
-    const currentBlockBuffer = this.droppedBlocksBufferByHash.get(txHash);
-    if (currentBlockBuffer < this.DROPPED_BUFFER_COUNT) {
-      this.droppedBlocksBufferByHash.set(txHash, currentBlockBuffer + 1);
-      return false;
-    }
-    this.droppedBlocksBufferByHash.delete(txHash);
-    return true;
+    const baseCount = Number.parseInt(baseCountStr, 16);
+    const nonceDetails = {
+      block,
+      baseCount
+    };
+    return {
+      name: "network",
+      nonce: baseCount,
+      details: nonceDetails
+    };
   }
-  _checkIfNonceIsTaken(txMeta) {
-    const address = txMeta.transaction.from;
-    const completed = this.getConfirmedTransactions(address);
-    return completed.some(otherMeta => {
-      if (otherMeta.id === txMeta.id) {
-        return false;
-      }
-      return otherMeta.transaction.nonce === txMeta.transaction.nonce;
-    });
+  _getHighestLocallyConfirmed(address) {
+    const confirmedTransactions = this.getConfirmedTransactions(address);
+    const highest = this._getHighestNonce(confirmedTransactions);
+    return Number.isInteger(highest) ? highest + 1 : 0;
   }
-}
-
-class TransactionGasUtil {
-  constructor(provider, blockTracker) {
-    _defineProperty(this, "provider", void 0);
-    _defineProperty(this, "blockTracker", void 0);
-    this.provider = provider;
-    this.blockTracker = blockTracker;
+  _getHighestNonce(txList) {
+    const nonces = txList.map(txMeta => {
+      const {
+        nonce
+      } = txMeta.transaction;
+      return Number.parseInt(nonce, 16);
+    });
+    const highestNonce = Math.max.apply(null, nonces);
+    return highestNonce;
   }
-  async analyzeGasUsage(txMeta) {
-    const block = await this.blockTracker.getLatestBlock();
-    // fallback to block gasLimit
-    const blockGasLimitBN = new BN$1(stripHexPrefix(block.gasLimit), 16);
-    const saferGasLimitBN = blockGasLimitBN.mul(new BN$1(19)).div(new BN$1(20));
-    let estimatedGasHex = addHexPrefix(saferGasLimitBN.toString("hex"));
-    let simulationFails;
-    try {
-      estimatedGasHex = await this.estimateTxGas(txMeta);
-    } catch (error) {
-      log.warn(error);
-      simulationFails = {
-        reason: error.message,
-        errorKey: error.errorKey,
-        debug: {
-          blockNumber: block.idempotencyKey,
-          blockGasLimit: block.gasLimit
-        }
-      };
+  _getHighestContinuousFrom(txList, startPoint) {
+    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 {
-      blockGasLimit: block.gasLimit,
-      estimatedGasHex,
-      simulationFails
+      name: "local",
+      nonce: highest,
+      details: {
+        startPoint,
+        highest
+      }
     };
   }
+}
 
-  /**
-    Adds a gas buffer with out exceeding the block gas limit
-  */
-  addGasBuffer(initialGasLimitHex, blockGasLimitHex) {
-    let multiplier = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1.5;
-    const initialGasLimitBn = new BN$1(stripHexPrefix(initialGasLimitHex), 16);
-    const blockGasLimitBn = new BN$1(stripHexPrefix(blockGasLimitHex), 16);
-    const upperGasLimitBn = blockGasLimitBn.muln(0.9);
-    const bufferedGasLimitBn = initialGasLimitBn.muln(multiplier);
-
-    // if initialGasLimit is above blockGasLimit, dont modify it
-    if (initialGasLimitBn.gt(upperGasLimitBn)) return addHexPrefix(initialGasLimitBn.toString("hex"));
-    // if bufferedGasLimit is below blockGasLimit, use bufferedGasLimit
-    if (bufferedGasLimitBn.lt(upperGasLimitBn)) return addHexPrefix(bufferedGasLimitBn.toString("hex"));
-    // otherwise use blockGasLimit
-    return addHexPrefix(upperGasLimitBn.toString("hex"));
+class PendingTransactionTracker extends SafeEventEmitter {
+  constructor(_ref) {
+    let {
+      provider,
+      nonceTracker,
+      approveTransaction,
+      publishTransaction,
+      getPendingTransactions,
+      getConfirmedTransactions
+    } = _ref;
+    super();
+    _defineProperty(this, "DROPPED_BUFFER_COUNT", 3);
+    _defineProperty(this, "nonceTracker", void 0);
+    _defineProperty(this, "provider", void 0);
+    _defineProperty(this, "approveTransaction", void 0);
+    _defineProperty(this, "droppedBlocksBufferByHash", void 0);
+    _defineProperty(this, "getConfirmedTransactions", void 0);
+    _defineProperty(this, "getPendingTransactions", void 0);
+    _defineProperty(this, "publishTransaction", void 0);
+    this.provider = provider;
+    this.nonceTracker = nonceTracker;
+    this.approveTransaction = approveTransaction;
+    this.publishTransaction = publishTransaction;
+    this.getPendingTransactions = getPendingTransactions;
+    this.getConfirmedTransactions = getConfirmedTransactions;
+    this.droppedBlocksBufferByHash = new Map();
   }
 
   /**
-    Estimates the tx's gas usage
+    checks the network for signed txs and releases the nonce global lock if it is
   */
-  async estimateTxGas(txMeta) {
-    const txParams = cloneDeep(txMeta.transaction);
-
-    // `eth_estimateGas` can fail if the user has insufficient balance for the
-    // value being sent, or for the gas cost. We don't want to check their
-    // balance here, we just want the gas estimate. The gas price is removed
-    // to skip those balance checks. We check balance elsewhere. We also delete
-    // maxFeePerGas and maxPriorityFeePerGas to support EIP-1559 txs.
-    delete txParams.gasPrice;
-    delete txParams.maxFeePerGas;
-    delete txParams.maxPriorityFeePerGas;
-    return this.provider.request({
-      method: "eth_estimateGas",
-      params: [txParams]
-    });
-  }
-}
-
-/**
-  Generates an array of history objects sense the previous state.
-  The object has the keys
-    op (the operation performed),
-    path (the key and if a nested object then each key will be seperated with a `/`)
-    value
-  with the first entry having the note and a timestamp when the change took place
-*/
-function generateHistoryEntry(previousState, newState, note) {
-  const entry = jsonDiffer.compare(previousState, newState);
-  // Add a note to the first op, since it breaks if we append it to the entry
-  if (entry[0]) {
-    if (note) {
-      entry[0].note = note;
+  async updatePendingTxs() {
+    // in order to keep the nonceTracker accurate we block it while updating pending transactions
+    const nonceGlobalLock = await this.nonceTracker.getGlobalLock();
+    try {
+      const pendingTxs = this.getPendingTransactions();
+      await Promise.all(pendingTxs.map(txMeta => this._checkPendingTx(txMeta)));
+    } catch (error) {
+      log.error("PendingTransactionTracker - Error updating pending transactions");
+      log.error(error);
     }
-    entry[0].timestamp = Date.now();
-  }
-  return entry;
-}
-
-/**
-  Recovers previous txMeta state obj
-*/
-function replayHistory(_shortHistory) {
-  const shortHistory = cloneDeep(_shortHistory);
-  return shortHistory.reduce((val, entry) => jsonDiffer.applyPatch(val, entry).newDocument);
-}
-function snapshotFromTxMeta(txMeta) {
-  const shallow = _objectSpread({}, txMeta);
-  delete shallow.history;
-  return cloneDeep(shallow);
-}
-
-const erc20Interface = new Interface(erc20Abi);
-const erc721Interface = new Interface(erc721Abi);
-const erc1155Interface = new Interface(erc1155Abi);
-
-// functions that handle normalizing of that key in txParams
-
-const normalizers = {
-  from: function (from) {
-    let LowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    return LowerCase ? addHexPrefix(from).toLowerCase() : addHexPrefix(from);
-  },
-  to: function (to) {
-    let LowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    return LowerCase ? addHexPrefix(to).toLowerCase() : addHexPrefix(to);
-  },
-  nonce: nonce => addHexPrefix(nonce),
-  customNonceValue: nonce => addHexPrefix(nonce),
-  value: value => addHexPrefix(value),
-  data: data => addHexPrefix(data),
-  gas: gas => addHexPrefix(gas),
-  gasPrice: gasPrice => addHexPrefix(gasPrice),
-  type: addHexPrefix,
-  maxFeePerGas: addHexPrefix,
-  maxPriorityFeePerGas: addHexPrefix
-};
-
-/**
- * normalizes txParams
- */
-function normalizeTxParameters(txParameters) {
-  let lowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  // apply only keys in the normalizers
-  const normalizedTxParameters = {
-    id: txParameters.id || randomId(),
-    from: txParameters.from
-  };
-  for (const key in normalizers) {
-    const currentKey = key;
-    if (txParameters[currentKey])
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      normalizedTxParameters[currentKey] = normalizers[currentKey](txParameters[currentKey], lowerCase);
+    nonceGlobalLock.releaseLock();
   }
-  return normalizedTxParameters;
-}
-function transactionMatchesNetwork(transaction, chainId) {
-  if (typeof transaction.chainId !== "undefined") {
-    return transaction.chainId === chainId;
+  async resubmitPendingTxs(block) {
+    const pending = this.getPendingTransactions();
+    // only try resubmitting if their are transactions to resubmit
+    if (pending.length === 0) return;
+    // Keep this as a for loop because we want to wait for each item to be submitted
+    for (const txMeta of pending) {
+      try {
+        await this._resubmitTx(txMeta, block.idempotencyKey);
+      } catch (error) {
+        var _value;
+        /*
+        Dont marked as failed if the error is a "known" transaction warning
+        "there is already a transaction with the same sender-nonce
+        but higher/same gas price"
+        Also don't mark as failed if it has ever been broadcast successfully.
+        A successful broadcast means it may still be mined.
+        */
+        const errorMessage = ((_value = error.value) === null || _value === void 0 || (_value = _value.message) === null || _value === void 0 ? void 0 : _value.toLowerCase()) || error.message.toLowerCase();
+        const isKnownTx =
+        // geth
+        errorMessage.includes("replacement transaction underpriced") || errorMessage.includes("known transaction") ||
+        // parity
+        errorMessage.includes("gas price too low to replace") || errorMessage.includes("transaction with the same hash was already imported") ||
+        // other
+        errorMessage.includes("gateway timeout") || errorMessage.includes("nonce too low");
+        // ignore resubmit warnings, return early
+        if (isKnownTx) return;
+        // encountered real error - transition to error state
+        txMeta.warning = {
+          error: errorMessage,
+          message: "There was an error when resubmitting this transaction."
+        };
+        this.emit(TX_EVENTS.TX_WARNING, {
+          txMeta,
+          error,
+          txId: txMeta.id
+        });
+      }
+    }
   }
-  return false;
-}
-
-/**
- * Determines if the maxFeePerGas and maxPriorityFeePerGas fields are supplied
- * and valid inputs. This will return false for non hex string inputs.
- *  the transaction to check
- * @returns true if transaction uses valid EIP1559 fields
- */
-function isEIP1559Transaction(transaction) {
-  var _transaction$transact, _transaction$transact2;
-  return isHexString(addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact = transaction.transaction) === null || _transaction$transact === void 0 ? void 0 : _transaction$transact.maxFeePerGas)) && isHexString(addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact2 = transaction.transaction) === null || _transaction$transact2 === void 0 ? void 0 : _transaction$transact2.maxPriorityFeePerGas));
-}
+  async _resubmitTx(txMeta, latestBlockNumber) {
+    if (!txMeta.firstRetryBlockNumber) {
+      this.emit(TX_EVENTS.TX_BLOCK_UPDATE, {
+        txMeta,
+        latestBlockNumber,
+        txId: txMeta.id
+      });
+    }
+    const firstRetryBlockNumber = txMeta.firstRetryBlockNumber || latestBlockNumber;
+    const txBlockDistance = Number.parseInt(latestBlockNumber, 16) - Number.parseInt(firstRetryBlockNumber, 16);
+    const retryCount = txMeta.retryCount || 0;
 
-/**
- * Determine if the maxFeePerGas and maxPriorityFeePerGas fields are not
- * supplied and that the gasPrice field is valid if it is provided. This will
- * return false if gasPrice is a non hex string.
- * transaction -
- *  the transaction to check
- * @returns true if transaction uses valid Legacy fields OR lacks
- *  EIP1559 fields
- */
-function isLegacyTransaction(transaction) {
-  return typeof transaction.transaction.maxFeePerGas === "undefined" && typeof transaction.transaction.maxPriorityFeePerGas === "undefined" && (typeof transaction.transaction.gasPrice === "undefined" || isHexString(addHexPrefix(transaction.transaction.gasPrice)));
-}
+    // Exponential backoff to limit retries at publishing (capped at last 15 mins)
+    if (txBlockDistance <= Math.min(50, 2 ** retryCount)) return undefined;
 
-/**
- * Given two fields, ensure that the second field is not included in txParams,
- * and if it is throw an invalidParams error.
- */
-function ensureMutuallyExclusiveFieldsNotProvided(txParams, fieldBeingValidated, mutuallyExclusiveField) {
-  if (typeof txParams[mutuallyExclusiveField] !== "undefined") {
-    throw rpcErrors.invalidParams(`Invalid transaction params: specified ${fieldBeingValidated} but also included ${mutuallyExclusiveField}, these cannot be mixed`);
-  }
-}
+    // Only auto-submit already-signed txs:
+    if (!("rawTx" in txMeta)) return this.approveTransaction(txMeta.id);
+    const {
+      rawTx
+    } = txMeta;
+    const txHash = await this.publishTransaction(rawTx);
 
-/**
- * Ensures that the provided value for field is a string, throws an
- * invalidParams error if field is not a string.
- */
-function ensureFieldIsString(txParams, field) {
-  if (typeof txParams[field] !== "string") {
-    throw rpcErrors.invalidParams(`Invalid transaction params: ${field} is not a string. got: (${txParams[field]})`);
+    // Increment successful tries:
+    this.emit(TX_EVENTS.TX_RETRY, {
+      txMeta,
+      txId: txMeta.id
+    });
+    return txHash;
   }
-}
+  async _checkPendingTx(foundTx) {
+    const txMeta = foundTx;
+    const txHash = txMeta.transactionHash;
+    const txId = txMeta.id;
 
-/**
- * Ensures that the provided txParams has the proper 'type' specified for the
- * given field, if it is provided. If types do not match throws an
- * invalidParams error.
- */
-function ensureProperTransactionEnvelopeTypeProvided(txParams, field) {
-  switch (field) {
-    case "maxFeePerGas":
-    case "maxPriorityFeePerGas":
-      if (txParams.type && txParams.type !== TRANSACTION_ENVELOPE_TYPES.FEE_MARKET) {
-        throw rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + `including maxFeePerGas and maxPriorityFeePerGas requires type: "${TRANSACTION_ENVELOPE_TYPES.FEE_MARKET}"`);
-      }
-      break;
-    case "gasPrice":
-    default:
-      if (txParams.type && txParams.type === TRANSACTION_ENVELOPE_TYPES.FEE_MARKET) {
-        throw rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + "included a gasPrice instead of maxFeePerGas and maxPriorityFeePerGas");
-      }
-  }
-}
+    // Only check submitted txs
+    if (txMeta.status !== TransactionStatus.submitted) return;
 
-/**
- * validates the from field in  txParams
- */
-function validateFrom(txParams) {
-  if (!(typeof txParams.from === "string")) {
-    throw rpcErrors.invalidParams(`Invalid "from" address "${txParams.from}": not a string.`);
-  }
-  if (!isValidAddress(txParams.from)) {
-    throw rpcErrors.invalidParams('Invalid "from" address.');
-  }
-}
+    // extra check in case there was an uncaught error during the
+    // signature and submission process
+    if (!txHash) {
+      const noTxHashError = new Error("We had an error while submitting this transaction, please try again.");
+      noTxHashError.name = "NoTxHashError";
+      this.emit(TX_EVENTS.TX_FAILED, {
+        txId,
+        error: noTxHashError
+      });
+      return;
+    }
 
-/**
- * validates the to field in  txParams
- */
-function validateRecipient(txParameters) {
-  if (txParameters.to === "0x" || txParameters.to === null) {
-    if (txParameters.data) {
-      delete txParameters.to;
-    } else {
-      throw rpcErrors.invalidParams('Invalid "to" address.');
+    // If another tx with the same nonce is mined, set as failed.
+    if (this._checkIfNonceIsTaken(txMeta)) {
+      this.emit(TX_EVENTS.TX_DROPPED, {
+        txId
+      });
+      return;
+    }
+    try {
+      const transactionReceipt = await this.provider.request({
+        method: METHOD_TYPES.ETH_GET_TRANSACTION_RECEIPT,
+        params: [txHash]
+      });
+      if (transactionReceipt !== null && transactionReceipt !== void 0 && transactionReceipt.blockNumber) {
+        const {
+          baseFeePerGas,
+          timestamp
+        } = await this.provider.request({
+          method: METHOD_TYPES.ETH_GET_BLOCK_BY_HASH,
+          params: [transactionReceipt.blockHash, false]
+        });
+        this.emit(TX_EVENTS.TX_CONFIRMED, {
+          txId,
+          txReceipt: transactionReceipt,
+          baseFeePerGas,
+          blockTimestamp: timestamp
+        });
+        return;
+      }
+    } catch (error) {
+      log.error("error while loading tx", error);
+      txMeta.warning = {
+        error: error.message,
+        message: "There was a problem loading this transaction."
+      };
+      this.emit(TX_EVENTS.TX_WARNING, {
+        txMeta
+      });
+    }
+    if (await this._checkIfTxWasDropped(txMeta)) {
+      this.emit(TX_EVENTS.TX_DROPPED, {
+        txId
+      });
     }
-  } else if (txParameters.to !== undefined && !isValidAddress(txParameters.to)) {
-    throw rpcErrors.invalidParams('Invalid "to" address.');
   }
-  return txParameters;
-}
-
-/**
- * Validates the given tx parameters
- * @throws if the tx params contains invalid fields
- */
-function validateTxParameters(txParams) {
-  let eip1559Compatibility = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  if (!txParams || typeof txParams !== "object" || Array.isArray(txParams)) {
-    throw rpcErrors.invalidParams("Invalid transaction params: must be an object.");
+  async _checkIfTxWasDropped(txMeta) {
+    const {
+      transactionHash: txHash,
+      transaction: {
+        nonce,
+        from
+      }
+    } = txMeta;
+    const networkNextNonce = await this.provider.request({
+      method: METHOD_TYPES.ETH_GET_TRANSACTION_COUNT,
+      params: [from, "latest"]
+    });
+    if (Number.parseInt(nonce, 16) >= Number.parseInt(networkNextNonce, 16)) {
+      return false;
+    }
+    if (!this.droppedBlocksBufferByHash.has(txHash)) {
+      this.droppedBlocksBufferByHash.set(txHash, 0);
+    }
+    const currentBlockBuffer = this.droppedBlocksBufferByHash.get(txHash);
+    if (currentBlockBuffer < this.DROPPED_BUFFER_COUNT) {
+      this.droppedBlocksBufferByHash.set(txHash, currentBlockBuffer + 1);
+      return false;
+    }
+    this.droppedBlocksBufferByHash.delete(txHash);
+    return true;
   }
-  if (!txParams.to && !txParams.data) {
-    throw rpcErrors.invalidParams('Invalid transaction params: must specify "data" for contract deployments, or "to" (and optionally "data") for all other types of transactions.');
+  _checkIfNonceIsTaken(txMeta) {
+    const address = txMeta.transaction.from;
+    const completed = this.getConfirmedTransactions(address);
+    return completed.some(otherMeta => {
+      if (otherMeta.id === txMeta.id) {
+        return false;
+      }
+      return otherMeta.transaction.nonce === txMeta.transaction.nonce;
+    });
   }
-  if (isEIP1559Transaction({
-    transaction: txParams
-  }) && !eip1559Compatibility) {
-    throw rpcErrors.invalidParams("Invalid transaction params: params specify an EIP-1559 transaction but the current network does not support EIP-1559");
+}
+
+class TransactionGasUtil {
+  constructor(provider, blockTracker) {
+    _defineProperty(this, "provider", void 0);
+    _defineProperty(this, "blockTracker", void 0);
+    this.provider = provider;
+    this.blockTracker = blockTracker;
   }
-  Object.entries(txParams).forEach(_ref => {
-    let [key, value] = _ref;
-    // validate types
-    switch (key) {
-      case "from":
-        validateFrom(txParams);
-        break;
-      case "to":
-        validateRecipient(txParams);
-        break;
-      case "gasPrice":
-        ensureProperTransactionEnvelopeTypeProvided(txParams, "gasPrice");
-        ensureMutuallyExclusiveFieldsNotProvided(txParams, "gasPrice", "maxFeePerGas");
-        ensureMutuallyExclusiveFieldsNotProvided(txParams, "gasPrice", "maxPriorityFeePerGas");
-        ensureFieldIsString(txParams, "gasPrice");
-        break;
-      case "maxFeePerGas":
-        ensureProperTransactionEnvelopeTypeProvided(txParams, "maxFeePerGas");
-        ensureMutuallyExclusiveFieldsNotProvided(txParams, "maxFeePerGas", "gasPrice");
-        ensureFieldIsString(txParams, "maxFeePerGas");
-        break;
-      case "maxPriorityFeePerGas":
-        ensureProperTransactionEnvelopeTypeProvided(txParams, "maxPriorityFeePerGas");
-        ensureMutuallyExclusiveFieldsNotProvided(txParams, "maxPriorityFeePerGas", "gasPrice");
-        ensureFieldIsString(txParams, "maxPriorityFeePerGas");
-        break;
-      case "value":
-        ensureFieldIsString(txParams, "value");
-        if (value.toString().includes("-")) {
-          throw rpcErrors.invalidParams(`Invalid transaction value "${value}": not a positive number.`);
-        }
-        if (value.toString().includes(".")) {
-          throw rpcErrors.invalidParams(`Invalid transaction value of "${value}": number must be in wei.`);
-        }
-        break;
-      case "chainId":
-        if (typeof value !== "number" && typeof value !== "string") {
-          throw rpcErrors.invalidParams(`Invalid transaction params: ${key} is not a Number or hex string. got: (${value})`);
+  async analyzeGasUsage(txMeta) {
+    const block = await this.blockTracker.getLatestBlock();
+    // fallback to block gasLimit
+    const blockGasLimitBN = new BN$1(stripHexPrefix(block.gasLimit), 16);
+    const saferGasLimitBN = blockGasLimitBN.mul(new BN$1(19)).div(new BN$1(20));
+    let estimatedGasHex = addHexPrefix(saferGasLimitBN.toString("hex"));
+    let simulationFails;
+    try {
+      estimatedGasHex = await this.estimateTxGas(txMeta);
+    } catch (error) {
+      log.warn(error);
+      simulationFails = {
+        reason: error.message,
+        errorKey: error.errorKey,
+        debug: {
+          blockNumber: block.idempotencyKey,
+          blockGasLimit: block.gasLimit
         }
-        break;
-      default:
-        ensureFieldIsString(txParams, key);
+      };
     }
-  });
-}
-function normalizeAndValidateTxParams(txParams) {
-  let lowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  const normalizedTxParams = normalizeTxParameters(txParams, lowerCase);
-  validateTxParameters(normalizedTxParams);
-  return normalizedTxParams;
-}
-
-/**
- * @returns an array of states that can be considered final
- */
-function getFinalStates() {
-  return [TransactionStatus.rejected,
-  // the user has responded no!
-  TransactionStatus.confirmed,
-  // the tx has been included in a block.
-  TransactionStatus.failed,
-  // the tx failed for some reason, included on tx data.
-  TransactionStatus.dropped // the tx nonce was already used
-  ];
-}
-function parseStandardTokenTransactionData(data) {
-  try {
-    const txDesc = erc20Interface.parseTransaction({
-      data
-    });
-    if (txDesc) return {
-      name: txDesc.name,
-      methodParams: txDesc.args.toArray(),
-      type: CONTRACT_TYPE_ERC20
+    return {
+      blockGasLimit: block.gasLimit,
+      estimatedGasHex,
+      simulationFails
     };
-  } catch {
-    // ignore and next try to parse with erc721 ABI
   }
-  try {
-    const txDesc = erc721Interface.parseTransaction({
-      data
-    });
-    if (txDesc) return {
-      name: txDesc.name,
-      methodParams: txDesc.args.toArray(),
-      type: CONTRACT_TYPE_ERC721
-    };
-  } catch {
-    // ignore and next try to parse with erc1155 ABI
+
+  /**
+    Adds a gas buffer with out exceeding the block gas limit
+  */
+  addGasBuffer(initialGasLimitHex, blockGasLimitHex) {
+    let multiplier = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1.5;
+    const initialGasLimitBn = new BN$1(stripHexPrefix(initialGasLimitHex), 16);
+    const blockGasLimitBn = new BN$1(stripHexPrefix(blockGasLimitHex), 16);
+    const upperGasLimitBn = blockGasLimitBn.muln(0.9);
+    const bufferedGasLimitBn = initialGasLimitBn.muln(multiplier);
+
+    // if initialGasLimit is above blockGasLimit, dont modify it
+    if (initialGasLimitBn.gt(upperGasLimitBn)) return addHexPrefix(initialGasLimitBn.toString("hex"));
+    // if bufferedGasLimit is below blockGasLimit, use bufferedGasLimit
+    if (bufferedGasLimitBn.lt(upperGasLimitBn)) return addHexPrefix(bufferedGasLimitBn.toString("hex"));
+    // otherwise use blockGasLimit
+    return addHexPrefix(upperGasLimitBn.toString("hex"));
   }
-  try {
-    const txDesc = erc1155Interface.parseTransaction({
-      data
+
+  /**
+    Estimates the tx's gas usage
+  */
+  async estimateTxGas(txMeta) {
+    const txParams = cloneDeep(txMeta.transaction);
+
+    // `eth_estimateGas` can fail if the user has insufficient balance for the
+    // value being sent, or for the gas cost. We don't want to check their
+    // balance here, we just want the gas estimate. The gas price is removed
+    // to skip those balance checks. We check balance elsewhere. We also delete
+    // maxFeePerGas and maxPriorityFeePerGas to support EIP-1559 txs.
+    delete txParams.gasPrice;
+    delete txParams.maxFeePerGas;
+    delete txParams.maxPriorityFeePerGas;
+    return this.provider.request({
+      method: "eth_estimateGas",
+      params: [txParams]
     });
-    if (txDesc) return {
-      name: txDesc.name,
-      methodParams: txDesc.args.toArray(),
-      type: CONTRACT_TYPE_ERC1155
-    };
-  } catch {
-    // ignore and return undefined
   }
-  return undefined;
 }
-const readAddressAsContract = async (provider, address) => {
-  let contractCode;
-  try {
-    contractCode = await provider.request({
-      method: METHOD_TYPES.ETH_GET_CODE,
-      params: [address, "latest"]
-    });
-  } catch (e) {
-    contractCode = null;
-  }
-  const isContractAddress = contractCode ? contractCode !== "0x" && contractCode !== "0x0" : false;
-  return {
-    contractCode,
-    isContractAddress
-  };
-};
-async function determineTransactionType(txParams, provider) {
-  const {
-    data,
-    to
-  } = txParams;
-  let name = "";
-  let methodParams = [];
-  let type = "";
-  try {
-    ({
-      name,
-      methodParams,
-      type
-    } = data && parseStandardTokenTransactionData(data) || {});
-  } catch (error) {
-    log.debug("Failed to parse transaction data", error);
-  }
-  let result;
-  let contractCode = "";
-  if (data && !to) {
-    result = TRANSACTION_TYPES.DEPLOY_CONTRACT;
-  } else {
-    const {
-      contractCode: resultCode,
-      isContractAddress
-    } = await readAddressAsContract(provider, to);
-    contractCode = resultCode;
-    if (isContractAddress) {
-      const valueExists = txParams.value && Number(txParams.value) !== 0;
-      const tokenMethodName = [TRANSACTION_TYPES.TOKEN_METHOD_APPROVE, TRANSACTION_TYPES.TOKEN_METHOD_TRANSFER, TRANSACTION_TYPES.TOKEN_METHOD_TRANSFER_FROM, TRANSACTION_TYPES.COLLECTIBLE_METHOD_SAFE_TRANSFER_FROM, TRANSACTION_TYPES.SET_APPROVAL_FOR_ALL].find(x => {
-        var _name;
-        return x.toLowerCase() === ((_name = name) === null || _name === void 0 ? void 0 : _name.toLowerCase());
-      });
-      result = data && tokenMethodName && !valueExists ? tokenMethodName : TRANSACTION_TYPES.CONTRACT_INTERACTION;
-    } else {
-      result = TRANSACTION_TYPES.SENT_ETHER;
+
+/**
+  Generates an array of history objects sense the previous state.
+  The object has the keys
+    op (the operation performed),
+    path (the key and if a nested object then each key will be seperated with a `/`)
+    value
+  with the first entry having the note and a timestamp when the change took place
+*/
+function generateHistoryEntry(previousState, newState, note) {
+  const entry = jsonDiffer.compare(previousState, newState);
+  // Add a note to the first op, since it breaks if we append it to the entry
+  if (entry[0]) {
+    if (note) {
+      entry[0].note = note;
     }
+    entry[0].timestamp = Date.now();
   }
-  return {
-    type: type || CONTRACT_TYPE_ETH,
-    category: result,
-    methodParams,
-    getCodeResponse: contractCode
-  };
+  return entry;
+}
+
+/**
+  Recovers previous txMeta state obj
+*/
+function replayHistory(_shortHistory) {
+  const shortHistory = cloneDeep(_shortHistory);
+  return shortHistory.reduce((val, entry) => jsonDiffer.applyPatch(val, entry).newDocument);
+}
+function snapshotFromTxMeta(txMeta) {
+  const shallow = _objectSpread({}, txMeta);
+  delete shallow.history;
+  return cloneDeep(shallow);
 }
 
 class TransactionStateManager extends BaseTransactionStateManager {
@@ -6008,5 +6166,5 @@ class TransactionController extends TransactionStateManager {
   }
 }
 
-export { ARBITRUM_MAINNET_CHAIN_ID, ARBITRUM_TESTNET_CHAIN_ID, AVALANCHE_MAINNET_CHAIN_ID, AVALANCHE_TESTNET_CHAIN_ID, AccountTrackerController, AddChainController, BASE_CHAIN_ID, BASE_TESTNET_CHAIN_ID, BSC_MAINNET_CHAIN_ID, BSC_TESTNET_CHAIN_ID, CELO_MAINNET_CHAIN_ID, CHAIN_ID_TO_GAS_LIMIT_BUFFER_MAP, COINGECKO_PLATFORMS_CHAIN_CODE_MAP, COINGECKO_SUPPORTED_CURRENCIES, CONTRACT_TYPE_ERC1155, CONTRACT_TYPE_ERC20, CONTRACT_TYPE_ERC721, CONTRACT_TYPE_ETH, CurrencyController, DEFAULT_CURRENCY, DecryptMessageController, ERC1155_INTERFACE_ID, ERC721_ENUMERABLE_INTERFACE_ID, ERC721_INTERFACE_ID, ERC721_METADATA_INTERFACE_ID, ETHERSCAN_SUPPORTED_CHAINS, EncryptionPublicKeyController, GAS_ESTIMATE_TYPES, GAS_LIMITS, GasFeeController, KeyringController, LOCALHOST, MAINNET_CHAIN_ID, MESSAGE_EVENTS, METHOD_TYPES, MessageController, MessageStatus, NetworkController, NftHandler, NftsController, NonceTracker, OLD_ERC721_LIST, OPTIMISM_MAINNET_CHAIN_ID, OPTIMISM_TESTNET_CHAIN_ID, POLYGON_CHAIN_ID, POLYGON_MUMBAI_CHAIN_ID, PendingTransactionTracker, PersonalMessageController, PollingBlockTracker, PreferencesController, SEPOLIA_CHAIN_ID, SIMPLEHASH_SUPPORTED_CHAINS, SUPPORTED_NETWORKS, SwitchChainController, TEST_CHAINS, TRANSACTION_ENVELOPE_TYPES, TokenHandler, TokenRatesController, TokensController, TransactionController, TransactionGasUtil, TransactionStateManager, TypedMessageController, XDAI_CHAIN_ID, bnLessThan, createChainIdMiddleware, createEthereumMiddleware, createGetAccountsMiddleware, createJsonRpcClient, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessDecryptMessageMiddleware, createProcessEncryptionPublicKeyMiddleware, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessage, createProcessTypedMessageV3, createProcessTypedMessageV4, createProviderConfigMiddleware, createRequestAccountsMiddleware, determineTransactionType, ensureFieldIsString, ensureMutuallyExclusiveFieldsNotProvided, erc1155Abi, erc20Abi, erc721Abi, formatDate, formatPastTx, formatTime, formatTxMetaForRpcResult, generateHistoryEntry, getChainType, getEthTxStatus, getEtherScanHashLink, getFinalStates, getIpfsEndpoint, idleTimeTracker, isAddressByChainId, isEIP1559Transaction, isLegacyTransaction, normalizeAndValidateTxParams, normalizeMessageData, normalizeTxParameters, parseDecryptMessageData, parseStandardTokenTransactionData, readAddressAsContract, replayHistory, sanitizeNftMetdataUrl, singleBalanceCheckerAbi, snapshotFromTxMeta, toChecksumAddressByChainId, transactionMatchesNetwork, validateAddChainData, validateAddress, validateDecryptedMessageData, validateEncryptionPublicKeyMessageData, validateFrom, validateRecipient, validateSignMessageData, validateSwitchChainData, validateTxParameters, validateTypedSignMessageDataV1, validateTypedSignMessageDataV3V4 };
+export { ARBITRUM_MAINNET_CHAIN_ID, ARBITRUM_TESTNET_CHAIN_ID, AVALANCHE_MAINNET_CHAIN_ID, AVALANCHE_TESTNET_CHAIN_ID, AccountTrackerController, AddChainController, BASE_CHAIN_ID, BASE_TESTNET_CHAIN_ID, BSC_MAINNET_CHAIN_ID, BSC_TESTNET_CHAIN_ID, CELO_MAINNET_CHAIN_ID, CHAIN_ID_TO_GAS_LIMIT_BUFFER_MAP, COINGECKO_PLATFORMS_CHAIN_CODE_MAP, COINGECKO_SUPPORTED_CURRENCIES, CONTRACT_TYPE_ERC1155, CONTRACT_TYPE_ERC20, CONTRACT_TYPE_ERC721, CONTRACT_TYPE_ETH, CurrencyController, DEFAULT_CURRENCY, DecryptMessageController, ERC1155_INTERFACE_ID, ERC721_ENUMERABLE_INTERFACE_ID, ERC721_INTERFACE_ID, ERC721_METADATA_INTERFACE_ID, ETHERSCAN_SUPPORTED_CHAINS, EncryptionPublicKeyController, GAS_ESTIMATE_TYPES, GAS_LIMITS, GasFeeController, KeyringController, LOCALHOST, MAINNET_CHAIN_ID, MESSAGE_EVENTS, METHOD_TYPES, MessageController, MessageStatus, NetworkController, NftHandler, NftsController, NonceTracker, OLD_ERC721_LIST, OPTIMISM_MAINNET_CHAIN_ID, OPTIMISM_TESTNET_CHAIN_ID, POLYGON_CHAIN_ID, POLYGON_MUMBAI_CHAIN_ID, PendingTransactionTracker, PersonalMessageController, PollingBlockTracker, PreferencesController, SEPOLIA_CHAIN_ID, SIMPLEHASH_SUPPORTED_CHAINS, SUPPORTED_NETWORKS, SwitchChainController, TEST_CHAINS, TRANSACTION_ENVELOPE_TYPES, TokenHandler, TokenRatesController, TokensController, TransactionController, TransactionGasUtil, TransactionStateManager, TypedMessageController, XDAI_CHAIN_ID, addCurrencies, addEtherscanTransactions, bnLessThan, conversionGTE, conversionGreaterThan, conversionLTE, conversionLessThan, conversionMax, conversionUtil, createChainIdMiddleware, createEthereumMiddleware, createGetAccountsMiddleware, createJsonRpcClient, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessDecryptMessageMiddleware, createProcessEncryptionPublicKeyMiddleware, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessage, createProcessTypedMessageV3, createProcessTypedMessageV4, createProviderConfigMiddleware, createRequestAccountsMiddleware, decGWEIToHexWEI, determineTransactionType, ensureFieldIsString, ensureMutuallyExclusiveFieldsNotProvided, erc1155Abi, erc20Abi, erc721Abi, formatDate, formatPastTx, formatTime, formatTxMetaForRpcResult, generateHistoryEntry, getBigNumber, getChainType, getEthTxStatus, getEtherScanHashLink, getFinalStates, getIpfsEndpoint, hexWEIToDecGWEI, idleTimeTracker, isAddressByChainId, isEIP1559Transaction, isLegacyTransaction, multiplyCurrencies, normalizeAndValidateTxParams, normalizeMessageData, normalizeTxParameters, parseDecryptMessageData, parseStandardTokenTransactionData, readAddressAsContract, replayHistory, sanitizeNftMetdataUrl, singleBalanceCheckerAbi, snapshotFromTxMeta, subtractCurrencies, toChecksumAddressByChainId, toNegative, transactionMatchesNetwork, validateAddChainData, validateAddress, validateDecryptedMessageData, validateEncryptionPublicKeyMessageData, validateFrom, validateRecipient, validateSignMessageData, validateSwitchChainData, validateTxParameters, validateTypedSignMessageDataV1, validateTypedSignMessageDataV3V4 };
 //# sourceMappingURL=ethereumControllers.esm.js.map