@toruslabs/ethereum-controllers 5.9.1 → 5.10.0

package/dist/ethereumControllers.cjs.js

@@ -1,7 +1,53 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
-/******/ 	// The require scope
-/******/ 	var __webpack_require__ = {};
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 652:
+/***/ ((module) => {
+
+module.exports = require("@ethereumjs/common");
+
+/***/ }),
+
+/***/ 81:
+/***/ ((module) => {
+
+module.exports = require("@ethereumjs/tx");
+
+/***/ }),
+
+/***/ 731:
+/***/ ((module) => {
+
+module.exports = require("jsonschema");
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
 /******/ 	
 /************************************************************************/
 /******/ 	/* webpack/runtime/compat get default export */
@@ -16,6 +62,36 @@
 /******/ 		};
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/create fake namespace object */
+/******/ 	(() => {
+/******/ 		var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
+/******/ 		var leafPrototypes;
+/******/ 		// create a fake namespace object
+/******/ 		// mode & 1: value is a module id, require it
+/******/ 		// mode & 2: merge all properties of value into the ns
+/******/ 		// mode & 4: return value when already ns object
+/******/ 		// mode & 16: return value when it's Promise-like
+/******/ 		// mode & 8|1: behave like require
+/******/ 		__webpack_require__.t = function(value, mode) {
+/******/ 			if(mode & 1) value = this(value);
+/******/ 			if(mode & 8) return value;
+/******/ 			if(typeof value === 'object' && value) {
+/******/ 				if((mode & 4) && value.__esModule) return value;
+/******/ 				if((mode & 16) && typeof value.then === 'function') return value;
+/******/ 			}
+/******/ 			var ns = Object.create(null);
+/******/ 			__webpack_require__.r(ns);
+/******/ 			var def = {};
+/******/ 			leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
+/******/ 			for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {
+/******/ 				Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
+/******/ 			}
+/******/ 			def['default'] = () => (value);
+/******/ 			__webpack_require__.d(ns, def);
+/******/ 			return ns;
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/define property getters */
 /******/ 	(() => {
 /******/ 		// define getter functions for harmony exports
@@ -1067,15 +1143,16 @@ const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
  * Network state changes also retrigger accounts update.
  */
 class AccountTrackerController extends base_controllers_namespaceObject.BaseController {
-  constructor({
-    config,
-    state,
-    provider,
-    blockTracker,
-    getIdentities,
-    onPreferencesStateChange,
-    getCurrentChainId
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      provider,
+      blockTracker,
+      getIdentities,
+      onPreferencesStateChange,
+      getCurrentChainId
+    } = _ref;
     super({
       config,
       state
@@ -1211,8 +1288,8 @@ const util_namespaceObject = require("@ethereumjs/util");
 ;// CONCATENATED MODULE: external "bignumber.js"
 const external_bignumber_js_namespaceObject = require("bignumber.js");
 var external_bignumber_js_default = /*#__PURE__*/__webpack_require__.n(external_bignumber_js_namespaceObject);
-;// CONCATENATED MODULE: external "@metamask/rpc-errors"
-const rpc_errors_namespaceObject = require("@metamask/rpc-errors");
+;// CONCATENATED MODULE: external "@toruslabs/openlogin-jrpc"
+const openlogin_jrpc_namespaceObject = require("@toruslabs/openlogin-jrpc");
 ;// CONCATENATED MODULE: ./src/Transaction/TransactionUtils.ts
 
 
@@ -1228,8 +1305,14 @@ const erc1155Interface = new external_ethers_namespaceObject.Interface(erc1155Ab
 // functions that handle normalizing of that key in txParams
 
 const normalizers = {
-  from: (from, LowerCase = true) => LowerCase ? (0,util_namespaceObject.addHexPrefix)(from).toLowerCase() : (0,util_namespaceObject.addHexPrefix)(from),
-  to: (to, LowerCase = true) => LowerCase ? (0,util_namespaceObject.addHexPrefix)(to).toLowerCase() : (0,util_namespaceObject.addHexPrefix)(to),
+  from: function (from) {
+    let LowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    return LowerCase ? (0,util_namespaceObject.addHexPrefix)(from).toLowerCase() : (0,util_namespaceObject.addHexPrefix)(from);
+  },
+  to: function (to) {
+    let LowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    return LowerCase ? (0,util_namespaceObject.addHexPrefix)(to).toLowerCase() : (0,util_namespaceObject.addHexPrefix)(to);
+  },
   nonce: nonce => (0,util_namespaceObject.addHexPrefix)(nonce),
   customNonceValue: nonce => (0,util_namespaceObject.addHexPrefix)(nonce),
   value: value => (0,util_namespaceObject.addHexPrefix)(value),
@@ -1244,7 +1327,8 @@ const normalizers = {
 /**
  * normalizes txParams
  */
-function normalizeTxParameters(txParameters, lowerCase = true) {
+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 || (0,base_controllers_namespaceObject.randomId)(),
@@ -1295,7 +1379,7 @@ function isLegacyTransaction(transaction) {
  */
 function ensureMutuallyExclusiveFieldsNotProvided(txParams, fieldBeingValidated, mutuallyExclusiveField) {
   if (typeof txParams[mutuallyExclusiveField] !== "undefined") {
-    throw rpc_errors_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: specified ${fieldBeingValidated} but also included ${mutuallyExclusiveField}, these cannot be mixed`);
+    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: specified ${fieldBeingValidated} but also included ${mutuallyExclusiveField}, these cannot be mixed`);
   }
 }
 
@@ -1305,7 +1389,7 @@ function ensureMutuallyExclusiveFieldsNotProvided(txParams, fieldBeingValidated,
  */
 function ensureFieldIsString(txParams, field) {
   if (typeof txParams[field] !== "string") {
-    throw rpc_errors_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: ${field} is not a string. got: (${txParams[field]})`);
+    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: ${field} is not a string. got: (${txParams[field]})`);
   }
 }
 
@@ -1319,13 +1403,13 @@ function ensureProperTransactionEnvelopeTypeProvided(txParams, field) {
     case "maxFeePerGas":
     case "maxPriorityFeePerGas":
       if (txParams.type && txParams.type !== TRANSACTION_ENVELOPE_TYPES.FEE_MARKET) {
-        throw rpc_errors_namespaceObject.rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + `including maxFeePerGas and maxPriorityFeePerGas requires type: "${TRANSACTION_ENVELOPE_TYPES.FEE_MARKET}"`);
+        throw openlogin_jrpc_namespaceObject.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 rpc_errors_namespaceObject.rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + "included a gasPrice instead of maxFeePerGas and maxPriorityFeePerGas");
+        throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + "included a gasPrice instead of maxFeePerGas and maxPriorityFeePerGas");
       }
   }
 }
@@ -1335,10 +1419,10 @@ function ensureProperTransactionEnvelopeTypeProvided(txParams, field) {
  */
 function validateFrom(txParams) {
   if (!(typeof txParams.from === "string")) {
-    throw rpc_errors_namespaceObject.rpcErrors.invalidParams(`Invalid "from" address "${txParams.from}": not a string.`);
+    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid "from" address "${txParams.from}": not a string.`);
   }
   if (!(0,util_namespaceObject.isValidAddress)(txParams.from)) {
-    throw rpc_errors_namespaceObject.rpcErrors.invalidParams('Invalid "from" address.');
+    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams('Invalid "from" address.');
   }
 }
 
@@ -1350,10 +1434,10 @@ function validateRecipient(txParameters) {
     if (txParameters.data) {
       delete txParameters.to;
     } else {
-      throw rpc_errors_namespaceObject.rpcErrors.invalidParams('Invalid "to" address.');
+      throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams('Invalid "to" address.');
     }
   } else if (txParameters.to !== undefined && !(0,util_namespaceObject.isValidAddress)(txParameters.to)) {
-    throw rpc_errors_namespaceObject.rpcErrors.invalidParams('Invalid "to" address.');
+    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams('Invalid "to" address.');
   }
   return txParameters;
 }
@@ -1362,19 +1446,21 @@ function validateRecipient(txParameters) {
  * Validates the given tx parameters
  * @throws if the tx params contains invalid fields
  */
-function validateTxParameters(txParams, eip1559Compatibility = true) {
+function validateTxParameters(txParams) {
+  let eip1559Compatibility = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
   if (!txParams || typeof txParams !== "object" || Array.isArray(txParams)) {
-    throw rpc_errors_namespaceObject.rpcErrors.invalidParams("Invalid transaction params: must be an object.");
+    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams("Invalid transaction params: must be an object.");
   }
   if (!txParams.to && !txParams.data) {
-    throw rpc_errors_namespaceObject.rpcErrors.invalidParams('Invalid transaction params: must specify "data" for contract deployments, or "to" (and optionally "data") for all other types of transactions.');
+    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams('Invalid transaction params: must specify "data" for contract deployments, or "to" (and optionally "data") for all other types of transactions.');
   }
   if (isEIP1559Transaction({
     transaction: txParams
   }) && !eip1559Compatibility) {
-    throw rpc_errors_namespaceObject.rpcErrors.invalidParams("Invalid transaction params: params specify an EIP-1559 transaction but the current network does not support EIP-1559");
+    throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams("Invalid transaction params: params specify an EIP-1559 transaction but the current network does not support EIP-1559");
   }
-  Object.entries(txParams).forEach(([key, value]) => {
+  Object.entries(txParams).forEach(_ref => {
+    let [key, value] = _ref;
     // validate types
     switch (key) {
       case "from":
@@ -1402,15 +1488,15 @@ function validateTxParameters(txParams, eip1559Compatibility = true) {
       case "value":
         ensureFieldIsString(txParams, "value");
         if (value.toString().includes("-")) {
-          throw rpc_errors_namespaceObject.rpcErrors.invalidParams(`Invalid transaction value "${value}": not a positive number.`);
+          throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction value "${value}": not a positive number.`);
         }
         if (value.toString().includes(".")) {
-          throw rpc_errors_namespaceObject.rpcErrors.invalidParams(`Invalid transaction value of "${value}": number must be in wei.`);
+          throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction value of "${value}": number must be in wei.`);
         }
         break;
       case "chainId":
         if (typeof value !== "number" && typeof value !== "string") {
-          throw rpc_errors_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: ${key} is not a Number or hex string. got: (${value})`);
+          throw openlogin_jrpc_namespaceObject.rpcErrors.invalidParams(`Invalid transaction params: ${key} is not a Number or hex string. got: (${value})`);
         }
         break;
       default:
@@ -1418,7 +1504,8 @@ function validateTxParameters(txParams, eip1559Compatibility = true) {
     }
   });
 }
-function normalizeAndValidateTxParams(txParams, lowerCase = true) {
+function normalizeAndValidateTxParams(txParams) {
+  let lowerCase = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
   const normalizedTxParams = normalizeTxParameters(txParams, lowerCase);
   validateTxParameters(normalizedTxParams);
   return normalizedTxParams;
@@ -1764,10 +1851,11 @@ const DEFAULT_POLLING_INTERVAL = 20;
 const DEFAULT_RETRY_TIMEOUT = 2;
 const SEC = 1000;
 class PollingBlockTracker extends base_controllers_namespaceObject.BaseBlockTracker {
-  constructor({
-    config,
-    state = {}
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state = {}
+    } = _ref;
     if (!config.provider) {
       throw new Error("PollingBlockTracker - no provider specified.");
     }
@@ -1848,11 +1936,12 @@ const http_helpers_namespaceObject = require("@toruslabs/http-helpers");
 
 
 class CurrencyController extends base_controllers_namespaceObject.BaseCurrencyController {
-  constructor({
-    config,
-    state,
-    onNetworkChanged
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      onNetworkChanged
+    } = _ref;
     super({
       config,
       state
@@ -1947,8 +2036,6 @@ class CurrencyController extends base_controllers_namespaceObject.BaseCurrencyCo
     };
   }
 }
-;// CONCATENATED MODULE: external "lodash"
-const external_lodash_namespaceObject = require("lodash");
 ;// CONCATENATED MODULE: external "@babel/runtime/helpers/objectDestructuringEmpty"
 const objectDestructuringEmpty_namespaceObject = require("@babel/runtime/helpers/objectDestructuringEmpty");
 var objectDestructuringEmpty_default = /*#__PURE__*/__webpack_require__.n(objectDestructuringEmpty_namespaceObject);
@@ -2026,19 +2113,20 @@ const isValidBase = base => Number.isInteger(base) && base > 1;
 /**
  * Utility method to convert a value between denominations, formats and currencies.
  */
-const converter = ({
-  value,
-  fromNumericBase,
-  fromDenomination,
-  fromCurrency,
-  toNumericBase,
-  toDenomination,
-  toCurrency,
-  numberOfDecimals,
-  conversionRate,
-  invertConversionRate,
-  roundDown
-}) => {
+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);
@@ -2067,17 +2155,18 @@ const converter = ({
   }
   return convertedValue;
 };
-const conversionUtil = (value, {
-  fromCurrency = null,
-  toCurrency = fromCurrency,
-  fromNumericBase,
-  toNumericBase,
-  fromDenomination,
-  toDenomination,
-  numberOfDecimals,
-  conversionRate,
-  invertConversionRate
-}) => {
+const conversionUtil = (value, _ref2) => {
+  let {
+    fromCurrency = null,
+    toCurrency = fromCurrency,
+    fromNumericBase,
+    toNumericBase,
+    fromDenomination,
+    toDenomination,
+    numberOfDecimals,
+    conversionRate,
+    invertConversionRate
+  } = _ref2;
   if (fromCurrency !== toCurrency && !conversionRate) {
     return 0;
   }
@@ -2106,7 +2195,8 @@ const getBigNumber = (value, base) => {
   }
   return new (external_bignumber_js_default())(String(value), base);
 };
-const addCurrencies = (a, b, options = {}) => {
+const addCurrencies = function (a, b) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   const {
       aBase,
       bBase
@@ -2120,7 +2210,8 @@ const addCurrencies = (a, b, options = {}) => {
     value
   }, conversionOptions));
 };
-const subtractCurrencies = (a, b, options = {}) => {
+const subtractCurrencies = function (a, b) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   const {
       aBase,
       bBase
@@ -2134,7 +2225,8 @@ const subtractCurrencies = (a, b, options = {}) => {
     value
   }, conversionOptions));
 };
-const multiplyCurrencies = (a, b, options = {}) => {
+const multiplyCurrencies = function (a, b) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   const {
       multiplicandBase,
       multiplierBase
@@ -2148,41 +2240,44 @@ const multiplyCurrencies = (a, b, options = {}) => {
     value
   }, conversionOptions));
 };
-const conversionGreaterThan = (_ref, _ref2) => {
-  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref2), _ref2));
-  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref), _ref));
+const conversionGreaterThan = (_ref3, _ref4) => {
+  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref4), _ref4));
+  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref3), _ref3));
   const firstValue = converter(objectSpread2_default()({}, firstProps));
   const secondValue = converter(objectSpread2_default()({}, secondProps));
   return firstValue.gt(secondValue);
 };
-const conversionLessThan = (_ref3, _ref4) => {
-  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref4), _ref4));
-  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref3), _ref3));
+const conversionLessThan = (_ref5, _ref6) => {
+  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref6), _ref6));
+  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref5), _ref5));
   const firstValue = converter(objectSpread2_default()({}, firstProps));
   const secondValue = converter(objectSpread2_default()({}, secondProps));
   return firstValue.lt(secondValue);
 };
-const conversionMax = (_ref5, _ref6) => {
-  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref6), _ref6));
-  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref5), _ref5));
+const conversionMax = (_ref7, _ref8) => {
+  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref8), _ref8));
+  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref7), _ref7));
   const firstIsGreater = conversionGreaterThan(objectSpread2_default()({}, firstProps), objectSpread2_default()({}, secondProps));
   return firstIsGreater ? firstProps.value : secondProps.value;
 };
-const conversionGTE = (_ref7, _ref8) => {
-  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref8), _ref8));
-  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref7), _ref7));
+const conversionGTE = (_ref9, _ref10) => {
+  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref10), _ref10));
+  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref9), _ref9));
   const firstValue = converter(objectSpread2_default()({}, firstProps));
   const secondValue = converter(objectSpread2_default()({}, secondProps));
   return firstValue.isGreaterThanOrEqualTo(secondValue);
 };
-const conversionLTE = (_ref9, _ref10) => {
-  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref10), _ref10));
-  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref9), _ref9));
+const conversionLTE = (_ref11, _ref12) => {
+  let secondProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref12), _ref12));
+  let firstProps = Object.assign({}, (objectDestructuringEmpty_default()(_ref11), _ref11));
   const firstValue = converter(objectSpread2_default()({}, firstProps));
   const secondValue = converter(objectSpread2_default()({}, secondProps));
   return firstValue.isLessThanOrEqualTo(secondValue);
 };
-const toNegative = (n, options = {}) => multiplyCurrencies(n, -1, options);
+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",
@@ -2346,27 +2441,27 @@ function calculateTimeEstimate(maxPriorityFeePerGas, maxFeePerGas, gasFeeEstimat
 
 
 
-
 const GAS_FEE_API = "https://mock-gas-server.herokuapp.com/";
 const LEGACY_GAS_PRICES_API_URL = "https://api.metaswap.codefi.network/gasPrices";
 /**
  * Returns gas prices in dec gwei
  */
 class GasFeeController extends base_controllers_namespaceObject.BaseController {
-  constructor({
-    config,
-    state,
-    getNetworkIdentifier,
-    getProvider,
-    fetchGasEstimates = gasUtil_fetchGasEstimates,
-    fetchEthGasPriceEstimate = gasUtil_fetchEthGasPriceEstimate,
-    fetchLegacyGasPriceEstimates = gasUtil_fetchLegacyGasPriceEstimates,
-    fetchGasEstimatesViaEthFeeHistory = gasUtil_fetchGasEstimatesViaEthFeeHistory,
-    getCurrentNetworkLegacyGasAPICompatibility,
-    getCurrentNetworkEIP1559Compatibility,
-    getCurrentAccountEIP1559Compatibility,
-    onNetworkStateChange
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      getNetworkIdentifier,
+      getProvider,
+      fetchGasEstimates = gasUtil_fetchGasEstimates,
+      fetchEthGasPriceEstimate = gasUtil_fetchEthGasPriceEstimate,
+      fetchLegacyGasPriceEstimates = gasUtil_fetchLegacyGasPriceEstimates,
+      fetchGasEstimatesViaEthFeeHistory = gasUtil_fetchGasEstimatesViaEthFeeHistory,
+      getCurrentNetworkLegacyGasAPICompatibility,
+      getCurrentNetworkEIP1559Compatibility,
+      getCurrentAccountEIP1559Compatibility,
+      onNetworkStateChange
+    } = _ref;
     super({
       config,
       state
@@ -2472,7 +2567,7 @@ class GasFeeController extends base_controllers_namespaceObject.BaseController {
       external_loglevel_default().warn(error);
       isEIP1559Compatible = false;
     }
-    let newState = (0,external_lodash_namespaceObject.cloneDeep)(this.defaultState);
+    let newState = (0,base_controllers_namespaceObject.cloneDeep)(this.defaultState);
     try {
       if (isEIP1559Compatible) {
         let estimates;
@@ -2534,7 +2629,7 @@ class GasFeeController extends base_controllers_namespaceObject.BaseController {
     }, this.config.interval);
   }
   resetState() {
-    this.update((0,external_lodash_namespaceObject.cloneDeep)(this.defaultState));
+    this.update((0,base_controllers_namespaceObject.cloneDeep)(this.defaultState));
   }
   async getEIP1559Compatibility() {
     var _this$getCurrentAccou, _this$getCurrentAccou2;
@@ -2556,10 +2651,11 @@ const eth_sig_util_namespaceObject = require("@metamask/eth-sig-util");
 
 
 class KeyringController extends base_controllers_namespaceObject.BaseKeyringController {
-  constructor({
-    config,
-    state
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state
+    } = _ref;
     super({
       config,
       state
@@ -2669,11 +2765,12 @@ class AbstractMessageController extends base_controllers_namespaceObject.BaseCon
    * Controller in charge of managing - storing, adding, removing, updating - Messages.
    *
    */
-  constructor({
-    config,
-    state,
-    getNetworkIdentifier
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      getNetworkIdentifier
+    } = _ref;
     super({
       config,
       state
@@ -2733,15 +2830,15 @@ class AbstractMessageController extends base_controllers_namespaceObject.BaseCon
     return new Promise((resolve, reject) => {
       const handleFinished = msg => {
         if (msg.status === MessageStatus.REJECTED) {
-          return reject(rpc_errors_namespaceObject.providerErrors.userRejectedRequest(`${messageName} Signature: User denied message signature`));
+          return reject(openlogin_jrpc_namespaceObject.providerErrors.userRejectedRequest(`${messageName} Signature: User denied message signature`));
         }
         if (msg.status === MessageStatus.FAILED) {
-          return reject(rpc_errors_namespaceObject.rpcErrors.internal(`${messageName} Signature: failed to sign message ${msg.error}`));
+          return reject(openlogin_jrpc_namespaceObject.rpcErrors.internal(`${messageName} Signature: failed to sign message ${msg.error}`));
         }
         if (msg.status === MessageStatus.SIGNED) {
           return resolve(msg.rawSig);
         }
-        return reject(rpc_errors_namespaceObject.rpcErrors.internal(`${messageName} Signature: Unknown problem: ${JSON.stringify(msgParams)}`));
+        return reject(openlogin_jrpc_namespaceObject.rpcErrors.internal(`${messageName} Signature: Unknown problem: ${JSON.stringify(msgParams)}`));
       };
       this.once(`${msgParams.id}:finished`, handleFinished);
     });
@@ -2762,13 +2859,10 @@ class AbstractMessageController extends base_controllers_namespaceObject.BaseCon
     });
   }
 }
-;// CONCATENATED MODULE: external "jsonschema"
-const external_jsonschema_namespaceObject = require("jsonschema");
 ;// CONCATENATED MODULE: ./src/Message/utils.ts
 
 
 
-
 const hexRe = /^[0-9A-Fa-f]+$/gu;
 function validateAddress(address, propertyName) {
   if (!address || typeof address !== "string" || !(0,util_namespaceObject.isValidAddress)(address)) {
@@ -2806,7 +2900,7 @@ function validateTypedSignMessageDataV1(messageData) {
     throw new Error(`Expected EIP712 typed data.`);
   }
 }
-function validateTypedSignMessageDataV3V4(messageData, currentChainId) {
+async function validateTypedSignMessageDataV3V4(messageData, currentChainId) {
   validateAddress(messageData.from, "from");
   if (!messageData.data || Array.isArray(messageData.data) || typeof messageData.data !== "object" && typeof messageData.data !== "string") {
     throw new Error(`Invalid message "data": Must be a valid string or object.`);
@@ -2821,7 +2915,10 @@ function validateTypedSignMessageDataV3V4(messageData, currentChainId) {
       throw new Error("Data must be passed as a valid JSON string.");
     }
   }
-  const validation = (0,external_jsonschema_namespaceObject.validate)(data, eth_sig_util_namespaceObject.TYPED_MESSAGE_SCHEMA);
+  const {
+    validate
+  } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 731, 23));
+  const validation = validate(data, eth_sig_util_namespaceObject.TYPED_MESSAGE_SCHEMA);
   if (validation.errors.length > 0) {
     throw new Error("Data must conform to EIP-712 schema. See https://git.io/fNtcx.");
   }
@@ -2911,12 +3008,13 @@ function validateSwitchChainData(data) {
 
 
 class AddChainController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    getNetworkIdentifier,
-    addChain
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      getNetworkIdentifier,
+      addChain
+    } = _ref;
     super({
       config,
       state,
@@ -2981,12 +3079,13 @@ class AddChainController extends AbstractMessageController {
 
 
 class DecryptMessageController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    decryptMessage,
-    getNetworkIdentifier
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      decryptMessage,
+      getNetworkIdentifier
+    } = _ref;
     super({
       config,
       state,
@@ -3053,12 +3152,13 @@ class DecryptMessageController extends AbstractMessageController {
 
 
 class EncryptionPublicKeyController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    signEncryptionPublicKey,
-    getNetworkIdentifier
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      signEncryptionPublicKey,
+      getNetworkIdentifier
+    } = _ref;
     super({
       config,
       state,
@@ -3125,12 +3225,13 @@ class EncryptionPublicKeyController extends AbstractMessageController {
 
 
 class MessageController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    signMessage,
-    getNetworkIdentifier
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      signMessage,
+      getNetworkIdentifier
+    } = _ref;
     super({
       config,
       state,
@@ -3195,12 +3296,13 @@ class MessageController extends AbstractMessageController {
 
 
 class PersonalMessageController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    signPersonalMessage,
-    getNetworkIdentifier
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      signPersonalMessage,
+      getNetworkIdentifier
+    } = _ref;
     super({
       config,
       state,
@@ -3265,12 +3367,13 @@ class PersonalMessageController extends AbstractMessageController {
 
 
 class SwitchChainController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    getNetworkIdentifier,
-    switchChain
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      getNetworkIdentifier,
+      switchChain
+    } = _ref;
     super({
       config,
       state,
@@ -3349,12 +3452,13 @@ function getMessageType(version) {
   }
 }
 class TypedMessageController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    signTypedData,
-    getNetworkIdentifier
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      signTypedData,
+      getNetworkIdentifier
+    } = _ref;
     super({
       config,
       state,
@@ -3392,7 +3496,7 @@ class TypedMessageController extends AbstractMessageController {
     }
     if (version === eth_sig_util_namespaceObject.SignTypedDataVersion.V3 || version === eth_sig_util_namespaceObject.SignTypedDataVersion.V4) {
       const currentChainId = this.getNetworkIdentifier();
-      validateTypedSignMessageDataV3V4(messageParams, currentChainId);
+      await validateTypedSignMessageDataV3V4(messageParams, currentChainId);
     }
     if (typeof messageParams.data !== "string" && (version === eth_sig_util_namespaceObject.SignTypedDataVersion.V3 || version === eth_sig_util_namespaceObject.SignTypedDataVersion.V4)) {
       messageParams.data = JSON.stringify(messageParams.data);
@@ -3420,16 +3524,15 @@ class TypedMessageController extends AbstractMessageController {
     return Promise.resolve(messageParams);
   }
 }
-;// CONCATENATED MODULE: external "@toruslabs/openlogin-jrpc"
-const openlogin_jrpc_namespaceObject = require("@toruslabs/openlogin-jrpc");
 ;// CONCATENATED MODULE: ./src/Network/createEthereumMiddleware.ts
 
 
 
 
-function createGetAccountsMiddleware({
-  getAccounts
-}) {
+function createGetAccountsMiddleware(_ref) {
+  let {
+    getAccounts
+  } = _ref;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3440,9 +3543,10 @@ function createGetAccountsMiddleware({
     response.result = accounts;
   });
 }
-function createProcessTransactionMiddleware({
-  processTransaction
-}) {
+function createProcessTransactionMiddleware(_ref2) {
+  let {
+    processTransaction
+  } = _ref2;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3452,9 +3556,10 @@ function createProcessTransactionMiddleware({
     response.result = await processTransaction(request.params, request);
   });
 }
-function createProcessEthSignMessage({
-  processEthSignMessage
-}) {
+function createProcessEthSignMessage(_ref3) {
+  let {
+    processEthSignMessage
+  } = _ref3;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3476,9 +3581,10 @@ function createProcessEthSignMessage({
     response.result = await processEthSignMessage(msgParams, request);
   });
 }
-function createProcessTypedMessage({
-  processTypedMessage
-}) {
+function createProcessTypedMessage(_ref4) {
+  let {
+    processTypedMessage
+  } = _ref4;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3501,9 +3607,10 @@ function createProcessTypedMessage({
     response.result = await processTypedMessage(msgParams, request);
   });
 }
-function createProcessTypedMessageV3({
-  processTypedMessageV3
-}) {
+function createProcessTypedMessageV3(_ref5) {
+  let {
+    processTypedMessageV3
+  } = _ref5;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3526,9 +3633,10 @@ function createProcessTypedMessageV3({
     response.result = await processTypedMessageV3(msgParams, request);
   });
 }
-function createProcessTypedMessageV4({
-  processTypedMessageV4
-}) {
+function createProcessTypedMessageV4(_ref6) {
+  let {
+    processTypedMessageV4
+  } = _ref6;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3551,9 +3659,10 @@ function createProcessTypedMessageV4({
     response.result = await processTypedMessageV4(msgParams, request);
   });
 }
-function createProcessPersonalMessage({
-  processPersonalMessage
-}) {
+function createProcessPersonalMessage(_ref7) {
+  let {
+    processPersonalMessage
+  } = _ref7;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3586,9 +3695,10 @@ function createProcessPersonalMessage({
     response.result = await processPersonalMessage(msgParams, request);
   });
 }
-function createPendingNonceMiddleware({
-  getPendingNonce
-}) {
+function createPendingNonceMiddleware(_ref8) {
+  let {
+    getPendingNonce
+  } = _ref8;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       params,
@@ -3650,9 +3760,10 @@ function formatTxMetaForRpcResult(txMeta) {
   }
   return formattedTxMeta;
 }
-function createPendingTxMiddleware({
-  getPendingTransactionByHash
-}) {
+function createPendingTxMiddleware(_ref9) {
+  let {
+    getPendingTransactionByHash
+  } = _ref9;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       params,
@@ -3668,9 +3779,10 @@ function createPendingTxMiddleware({
     return undefined;
   });
 }
-function createProcessEncryptionPublicKeyMiddleware({
-  processEncryptionPublicKey
-}) {
+function createProcessEncryptionPublicKeyMiddleware(_ref10) {
+  let {
+    processEncryptionPublicKey
+  } = _ref10;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3690,9 +3802,10 @@ function createProcessEncryptionPublicKeyMiddleware({
     response.result = await processEncryptionPublicKey(msgParams, request);
   });
 }
-function createProcessDecryptMessageMiddleware({
-  processDecryptMessage
-}) {
+function createProcessDecryptMessageMiddleware(_ref11) {
+  let {
+    processDecryptMessage
+  } = _ref11;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3712,9 +3825,10 @@ function createProcessDecryptMessageMiddleware({
     response.result = await processDecryptMessage(msgParams, request);
   });
 }
-function createProcessSwitchEthereumChain({
-  processSwitchEthereumChain
-}) {
+function createProcessSwitchEthereumChain(_ref12) {
+  let {
+    processSwitchEthereumChain
+  } = _ref12;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3731,9 +3845,10 @@ function createProcessSwitchEthereumChain({
     response.result = await processSwitchEthereumChain(msgParams, request);
   });
 }
-function createProcessAddEthereumChain({
-  processAddEthereumChain
-}) {
+function createProcessAddEthereumChain(_ref13) {
+  let {
+    processAddEthereumChain
+  } = _ref13;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3750,9 +3865,10 @@ function createProcessAddEthereumChain({
     response.result = await processAddEthereumChain(msgParams, request);
   });
 }
-function createRequestAccountsMiddleware({
-  requestAccounts
-}) {
+function createRequestAccountsMiddleware(_ref14) {
+  let {
+    requestAccounts
+  } = _ref14;
   return (0,openlogin_jrpc_namespaceObject.createAsyncMiddleware)(async (request, response, next) => {
     const {
       method
@@ -3996,10 +4112,11 @@ const NetworkController_excluded = ["chainId", "rpcTarget"];
 
 
 class NetworkController extends base_controllers_namespaceObject.BaseController {
-  constructor({
-    config,
-    state
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state
+    } = _ref;
     super({
       config,
       state
@@ -4126,10 +4243,11 @@ class NetworkController extends base_controllers_namespaceObject.BaseController
       rpcTarget
     }, rest));
   }
-  setNetworkClient({
-    networkMiddleware,
-    blockTracker
-  }) {
+  setNetworkClient(_ref2) {
+    let {
+      networkMiddleware,
+      blockTracker
+    } = _ref2;
     const ethereumMiddleware = createEthereumMiddleware(this.baseProviderHandlers);
     const engine = new openlogin_jrpc_namespaceObject.JRPCEngine();
     engine.push(ethereumMiddleware);
@@ -4140,10 +4258,11 @@ class NetworkController extends base_controllers_namespaceObject.BaseController
       blockTracker
     });
   }
-  setProvider({
-    provider,
-    blockTracker
-  }) {
+  setProvider(_ref3) {
+    let {
+      provider,
+      blockTracker
+    } = _ref3;
     if (this.providerProxy) {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore
@@ -4190,18 +4309,19 @@ class NetworkController extends base_controllers_namespaceObject.BaseController
 
 
 class NftHandler {
-  constructor({
-    chainId,
-    contractAddress,
-    contractImage,
-    contractName,
-    contractSymbol,
-    nftStandard,
-    provider,
-    contractDescription,
-    contractFallbackLogo,
-    contractSupply
-  }) {
+  constructor(_ref) {
+    let {
+      chainId,
+      contractAddress,
+      contractImage,
+      contractName,
+      contractSymbol,
+      nftStandard,
+      provider,
+      contractDescription,
+      contractFallbackLogo,
+      contractSupply
+    } = _ref;
     defineProperty_default()(this, "contractAddress", void 0);
     defineProperty_default()(this, "contractName", void 0);
     defineProperty_default()(this, "contractSymbol", void 0);
@@ -4349,13 +4469,17 @@ class NftHandler {
     const contract = new external_ethers_namespaceObject.Contract(this.contractAddress, abi, this.provider);
     return contract.supportsInterface(interfaceId);
   }
-  async getCollectibleTokenURI(tokenId, standard = CONTRACT_TYPE_ERC721) {
+  async getCollectibleTokenURI(tokenId) {
+    let standard = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CONTRACT_TYPE_ERC721;
     const method = standard === CONTRACT_TYPE_ERC721 ? "tokenURI" : "uri";
     const abi = standard === CONTRACT_TYPE_ERC721 ? erc721Abi : erc1155Abi;
     const contract = new external_ethers_namespaceObject.Contract(this.contractAddress, abi, this.provider);
     return contract[method](tokenId);
   }
 }
+;// CONCATENATED MODULE: external "deepmerge"
+const external_deepmerge_namespaceObject = require("deepmerge");
+var external_deepmerge_default = /*#__PURE__*/__webpack_require__.n(external_deepmerge_namespaceObject);
 ;// CONCATENATED MODULE: ./src/Nfts/NftsController.ts
 
 
@@ -4368,15 +4492,16 @@ class NftHandler {
 
 const DEFAULT_INTERVAL = 180 * 1000;
 class NftsController extends base_controllers_namespaceObject.BaseController {
-  constructor({
-    config,
-    state,
-    provider,
-    getCustomNfts,
-    getSimpleHashNfts,
-    onPreferencesStateChange,
-    onNetworkStateChange
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      provider,
+      getCustomNfts,
+      getSimpleHashNfts,
+      onPreferencesStateChange,
+      onNetworkStateChange
+    } = _ref;
     super({
       config,
       state
@@ -4560,7 +4685,7 @@ class NftsController extends base_controllers_namespaceObject.BaseController {
     const nonZeroTokens = promiseSettledResult.filter(x => x.status === "fulfilled").map(x => x.value);
     this.update({
       nfts: {
-        [userAddress]: (0,external_lodash_namespaceObject.merge)(this.userNfts, nonZeroTokens)
+        [userAddress]: external_deepmerge_default()(this.userNfts, nonZeroTokens)
       }
     });
   }
@@ -4574,15 +4699,16 @@ class NftsController extends base_controllers_namespaceObject.BaseController {
 
 
 class PreferencesController extends base_controllers_namespaceObject.BasePreferencesController {
-  constructor({
-    config,
-    state,
-    provider,
-    signAuthMessage,
-    getProviderConfig,
-    setProviderConfig,
-    validateSignMessage
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      provider,
+      signAuthMessage,
+      getProviderConfig,
+      setProviderConfig,
+      validateSignMessage
+    } = _ref;
     super({
       config,
       state,
@@ -4862,9 +4988,10 @@ class PreferencesController extends base_controllers_namespaceObject.BasePrefere
   }
 
   // Custom Network methods
-  async addCustomNetwork({
-    network
-  }) {
+  async addCustomNetwork(_ref2) {
+    let {
+      network
+    } = _ref2;
     try {
       const {
         selectedAddress
@@ -4904,10 +5031,11 @@ class PreferencesController extends base_controllers_namespaceObject.BasePrefere
       return false;
     }
   }
-  async editCustomNetwork({
-    network,
-    id
-  }) {
+  async editCustomNetwork(_ref3) {
+    let {
+      network,
+      id
+    } = _ref3;
     try {
       const {
         selectedAddress
@@ -4930,8 +5058,9 @@ class PreferencesController extends base_controllers_namespaceObject.BasePrefere
       return false;
     }
   }
-  getChainOptions(address = this.state.selectedAddress) {
+  getChainOptions() {
     var _identities$address$c, _identities$address;
+    let address = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state.selectedAddress;
     const {
       identities
     } = this.state;
@@ -5041,15 +5170,15 @@ class PreferencesController extends base_controllers_namespaceObject.BasePrefere
 
 
 
-
 class TokenHandler {
-  constructor({
-    address,
-    symbol,
-    decimals,
-    name,
-    provider
-  }) {
+  constructor(_ref) {
+    let {
+      address,
+      symbol,
+      decimals,
+      name,
+      provider
+    } = _ref;
     defineProperty_default()(this, "address", void 0);
     defineProperty_default()(this, "symbol", void 0);
     defineProperty_default()(this, "decimals", void 0);
@@ -5081,7 +5210,7 @@ class TokenHandler {
   async getUserBalance(userAddress) {
     if (!this.decimals) await this.getDecimals();
     const balance = await this.contract.balanceOf(userAddress);
-    return new (external_bignumber_js_default())(balance).toString(16);
+    return balance.toString(16);
   }
 }
 ;// CONCATENATED MODULE: ./src/Tokens/TokenRatesController.ts
@@ -5094,13 +5223,14 @@ class TokenHandler {
 
 const DEFAULT_CURRENCY = "eth";
 class TokenRatesController extends base_controllers_namespaceObject.BaseController {
-  constructor({
-    config,
-    state,
-    onPreferencesStateChange,
-    onNetworkStateChange,
-    onTokensStateChange
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      onPreferencesStateChange,
+      onNetworkStateChange,
+      onTokensStateChange
+    } = _ref;
     super({
       config,
       state
@@ -5221,16 +5351,17 @@ const mergeTokenArrays = (oldArray, newArray) => {
 };
 const TokensController_DEFAULT_INTERVAL = 180 * 1000;
 class TokensController extends base_controllers_namespaceObject.BaseController {
-  constructor({
-    config,
-    state,
-    provider,
-    getCustomTokens,
-    getEtherScanTokens,
-    getProviderConfig,
-    onPreferencesStateChange,
-    onNetworkStateChange
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      provider,
+      getCustomTokens,
+      getEtherScanTokens,
+      getProviderConfig,
+      onPreferencesStateChange,
+      onNetworkStateChange
+    } = _ref;
     super({
       config,
       state
@@ -5453,12 +5584,13 @@ class TokensController extends base_controllers_namespaceObject.BaseController {
 
 
 class NonceTracker {
-  constructor({
-    provider,
-    blockTracker,
-    getPendingTransactions,
-    getConfirmedTransactions
-  }) {
+  constructor(_ref) {
+    let {
+      provider,
+      blockTracker,
+      getPendingTransactions,
+      getConfirmedTransactions
+    } = _ref;
     defineProperty_default()(this, "provider", void 0);
     defineProperty_default()(this, "blockTracker", void 0);
     defineProperty_default()(this, "getPendingTransactions", void 0);
@@ -5602,14 +5734,15 @@ class NonceTracker {
 
 
 class PendingTransactionTracker extends openlogin_jrpc_namespaceObject.SafeEventEmitter {
-  constructor({
-    provider,
-    nonceTracker,
-    approveTransaction,
-    publishTransaction,
-    getPendingTransactions,
-    getConfirmedTransactions
-  }) {
+  constructor(_ref) {
+    let {
+      provider,
+      nonceTracker,
+      approveTransaction,
+      publishTransaction,
+      getPendingTransactions,
+      getConfirmedTransactions
+    } = _ref;
     super();
     defineProperty_default()(this, "DROPPED_BUFFER_COUNT", 3);
     defineProperty_default()(this, "nonceTracker", void 0);
@@ -5813,10 +5946,6 @@ class PendingTransactionTracker extends openlogin_jrpc_namespaceObject.SafeEvent
     });
   }
 }
-;// CONCATENATED MODULE: external "@ethereumjs/common"
-const common_namespaceObject = require("@ethereumjs/common");
-;// CONCATENATED MODULE: external "@ethereumjs/tx"
-const tx_namespaceObject = require("@ethereumjs/tx");
 ;// CONCATENATED MODULE: ./src/Transaction/TransactionGasUtil.ts
 
 
@@ -5860,7 +5989,8 @@ class TransactionGasUtil {
   /**
     Adds a gas buffer with out exceeding the block gas limit
   */
-  addGasBuffer(initialGasLimitHex, blockGasLimitHex, multiplier = 1.5) {
+  addGasBuffer(initialGasLimitHex, blockGasLimitHex) {
+    let multiplier = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1.5;
     const initialGasLimitBn = new external_bn_js_namespaceObject.BN((0,util_namespaceObject.stripHexPrefix)(initialGasLimitHex), 16);
     const blockGasLimitBn = new external_bn_js_namespaceObject.BN((0,util_namespaceObject.stripHexPrefix)(blockGasLimitHex), 16);
     const upperGasLimitBn = blockGasLimitBn.muln(0.9);
@@ -5878,7 +6008,7 @@ class TransactionGasUtil {
     Estimates the tx's gas usage
   */
   async estimateTxGas(txMeta) {
-    const txParams = (0,external_lodash_namespaceObject.cloneDeep)(txMeta.transaction);
+    const txParams = (0,base_controllers_namespaceObject.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
@@ -5894,6 +6024,29 @@ class TransactionGasUtil {
     });
   }
 }
+;// CONCATENATED MODULE: ./src/utils/lodashUtils.ts
+function sortBy(arr, key) {
+  return arr.slice().sort((a, b) => {
+    if (a[key] < b[key]) return -1;
+    if (a[key] > b[key]) return 1;
+    return 0;
+  });
+}
+function keyBy(arr, key) {
+  return arr.reduce((acc, item) => {
+    const keyValue = item[key];
+    if (typeof keyValue === "string" || typeof keyValue === "number") {
+      acc[keyValue.toString()] = item;
+    }
+    return acc;
+  }, {});
+}
+function mapValues(obj, iteratee) {
+  return Object.fromEntries(Object.entries(obj).map(_ref => {
+    let [key, value] = _ref;
+    return [key, iteratee(value, key)];
+  }));
+}
 ;// CONCATENATED MODULE: external "fast-json-patch"
 const external_fast_json_patch_namespaceObject = require("fast-json-patch");
 var external_fast_json_patch_default = /*#__PURE__*/__webpack_require__.n(external_fast_json_patch_namespaceObject);
@@ -5925,13 +6078,13 @@ function generateHistoryEntry(previousState, newState, note) {
   Recovers previous txMeta state obj
 */
 function replayHistory(_shortHistory) {
-  const shortHistory = (0,external_lodash_namespaceObject.cloneDeep)(_shortHistory);
+  const shortHistory = (0,base_controllers_namespaceObject.cloneDeep)(_shortHistory);
   return shortHistory.reduce((val, entry) => external_fast_json_patch_default().applyPatch(val, entry).newDocument);
 }
 function snapshotFromTxMeta(txMeta) {
   const shallow = objectSpread2_default()({}, txMeta);
   delete shallow.history;
-  return (0,external_lodash_namespaceObject.cloneDeep)(shallow);
+  return (0,base_controllers_namespaceObject.cloneDeep)(shallow);
 }
 
 ;// CONCATENATED MODULE: ./src/Transaction/TransactionStateManager.ts
@@ -5941,18 +6094,20 @@ function snapshotFromTxMeta(txMeta) {
 
 
 class TransactionStateManager extends base_controllers_namespaceObject.BaseTransactionStateManager {
-  constructor({
-    config,
-    state,
-    getCurrentChainId
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      getCurrentChainId
+    } = _ref;
     super({
       config,
       state,
       getCurrentChainId
     });
   }
-  generateTxMeta(opts = {}) {
+  generateTxMeta() {
+    let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const chainId = this.getCurrentChainId();
     if (chainId === "loading") throw new Error("Torus is having trouble connecting to the network");
     let dappSuggestedGasFees = null;
@@ -6056,18 +6211,19 @@ class TransactionStateManager extends base_controllers_namespaceObject.BaseTrans
     } = this.state;
     const chainId = this.getCurrentChainId();
     this.update({
-      transactions: (0,external_lodash_namespaceObject.omitBy)(transactions, txMeta => {
+      transactions: (0,base_controllers_namespaceObject.omitBy)(transactions, txMeta => {
         const transactionMatch = (0,base_controllers_namespaceObject.transactionMatchesNetwork)(txMeta, chainId);
         return txMeta.transaction.from === address && transactionMatch;
       })
     });
   }
-  getTransactions({
-    searchCriteria = {},
-    initialList = undefined,
-    filterToCurrentNetwork = true,
-    limit = undefined
-  } = {}) {
+  getTransactions() {
+    let {
+      searchCriteria = {},
+      initialList = undefined,
+      filterToCurrentNetwork = true,
+      limit = undefined
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const chainId = this.getCurrentChainId();
     // searchCriteria is an object that might have values that aren't predicate
     // methods. When providing any other value type (string, number, etc), we
@@ -6075,17 +6231,17 @@ class TransactionStateManager extends base_controllers_namespaceObject.BaseTrans
     // with the provided value". To conform this object to be only methods, we
     // mapValues (lodash) such that every value on the object is a method that
     // returns a boolean.
-    const predicateMethods = (0,external_lodash_namespaceObject.mapValues)(searchCriteria, predicate => typeof predicate === "function" ? predicate : v => v === predicate);
+    const predicateMethods = mapValues(searchCriteria, predicate => typeof predicate === "function" ? predicate : v => v === predicate);
 
     // If an initial list is provided we need to change it back into an object
     // first, so that it matches the shape of our state. This is done by the
     // lodash keyBy method. This is the edge case for this method, typically
     // initialList will be undefined.
-    const transactionsToFilter = initialList ? (0,external_lodash_namespaceObject.keyBy)(initialList, "id") : this.state.transactions;
+    const transactionsToFilter = initialList ? keyBy(initialList, "id") : this.state.transactions;
 
     // Combine sortBy and pickBy to transform our state object into an array of
     // matching transactions that are sorted by time.
-    const filteredTransactions = (0,external_lodash_namespaceObject.sortBy)((0,external_lodash_namespaceObject.pickBy)(transactionsToFilter, txMeta => {
+    const filteredTransactions = sortBy(Object.values((0,base_controllers_namespaceObject.pickBy)(transactionsToFilter, txMeta => {
       // default matchesCriteria to the value of transactionMatchesNetwork
       // when filterToCurrentNetwork is true.
       const transactionMatches = (0,base_controllers_namespaceObject.transactionMatchesNetwork)(txMeta, chainId);
@@ -6109,7 +6265,7 @@ class TransactionStateManager extends base_controllers_namespaceObject.BaseTrans
         }
       }
       return true;
-    }), "time");
+    })), "time");
     if (limit !== undefined) {
       // We need to have all transactions of a given nonce in order to display
       // necessary details in the UI. We use the size of this set to determine
@@ -6182,7 +6338,7 @@ class TransactionStateManager extends base_controllers_namespaceObject.BaseTrans
   }
   getUnapprovedTxList() {
     const chainId = this.getCurrentChainId();
-    return (0,external_lodash_namespaceObject.pickBy)(this.state.transactions, transaction => {
+    return (0,base_controllers_namespaceObject.pickBy)(this.state.transactions, transaction => {
       const transactionMatches = (0,base_controllers_namespaceObject.transactionMatchesNetwork)(transaction, chainId);
       return transaction.status === base_controllers_namespaceObject.TransactionStatus.unapproved && transactionMatches;
     });
@@ -6242,22 +6398,21 @@ class TransactionStateManager extends base_controllers_namespaceObject.BaseTrans
 
 
 
-
-
 class TransactionController extends TransactionStateManager {
-  constructor({
-    config,
-    state,
-    provider,
-    blockTracker,
-    signEthTx,
-    getCurrentChainId,
-    getCurrentNetworkEIP1559Compatibility,
-    getProviderConfig,
-    getCurrentAccountEIP1559Compatibility,
-    getSelectedAddress,
-    getEIP1559GasFeeEstimates
-  }) {
+  constructor(_ref) {
+    let {
+      config,
+      state,
+      provider,
+      blockTracker,
+      signEthTx,
+      getCurrentChainId,
+      getCurrentNetworkEIP1559Compatibility,
+      getProviderConfig,
+      getCurrentAccountEIP1559Compatibility,
+      getSelectedAddress,
+      getEIP1559GasFeeEstimates
+    } = _ref;
     super({
       config,
       state,
@@ -6318,15 +6473,15 @@ class TransactionController extends TransactionStateManager {
     return new Promise((resolve, reject) => {
       const handleFinished = msg => {
         if (msg.status === base_controllers_namespaceObject.TransactionStatus.rejected) {
-          return reject(rpc_errors_namespaceObject.providerErrors.userRejectedRequest(`Transaction Signature: User denied message signature`));
+          return reject(openlogin_jrpc_namespaceObject.providerErrors.userRejectedRequest(`Transaction Signature: User denied message signature`));
         }
         if (msg.status === base_controllers_namespaceObject.TransactionStatus.failed) {
-          return reject(rpc_errors_namespaceObject.rpcErrors.internal(`Transaction Signature: failed to sign message ${msg.error}`));
+          return reject(openlogin_jrpc_namespaceObject.rpcErrors.internal(`Transaction Signature: failed to sign message ${msg.error}`));
         }
         if (msg.status === base_controllers_namespaceObject.TransactionStatus.submitted) {
           return resolve(msg.transactionHash);
         }
-        return reject(rpc_errors_namespaceObject.rpcErrors.internal(`Transaction Signature: Unknown problem: ${JSON.stringify(txMeta.transaction)}`));
+        return reject(openlogin_jrpc_namespaceObject.rpcErrors.internal(`Transaction Signature: Unknown problem: ${JSON.stringify(txMeta.transaction)}`));
       };
       this.once(`${txMeta.id}:finished`, handleFinished);
     });
@@ -6386,7 +6541,10 @@ class TransactionController extends TransactionStateManager {
     });
     const fromAddress = txParams.from;
     const common = await this.getCommonConfiguration(fromAddress);
-    const unsignedEthTx = tx_namespaceObject.TransactionFactory.fromTxData(txParams, {
+    const {
+      TransactionFactory
+    } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 81, 23));
+    const unsignedEthTx = TransactionFactory.fromTxData(txParams, {
       common
     });
     const signedEthTx = await this.signEthTx(unsignedEthTx, fromAddress);
@@ -6649,10 +6807,11 @@ class TransactionController extends TransactionStateManager {
       this.updateTransactionInState(data.txMeta);
     });
     this.pendingTxTracker.on(base_controllers_namespaceObject.TX_EVENTS.TX_DROPPED, data => this.setTxStatusDropped(data.txId));
-    this.pendingTxTracker.on(base_controllers_namespaceObject.TX_EVENTS.TX_BLOCK_UPDATE, ({
-      txMeta,
-      latestBlockNumber
-    }) => {
+    this.pendingTxTracker.on(base_controllers_namespaceObject.TX_EVENTS.TX_BLOCK_UPDATE, _ref2 => {
+      let {
+        txMeta,
+        latestBlockNumber
+      } = _ref2;
       if (!txMeta.firstRetryBlockNumber) {
         txMeta.firstRetryBlockNumber = latestBlockNumber;
         this.updateTransactionInState(txMeta);
@@ -6702,8 +6861,12 @@ class TransactionController extends TransactionStateManager {
       displayName
     } = this.getProviderConfig();
     const supportsEIP1559 = await this.getEIP1559Compatibility(fromAddress);
-    const hardfork = supportsEIP1559 ? common_namespaceObject.Hardfork.Paris : common_namespaceObject.Hardfork.Berlin;
-    return common_namespaceObject.Common.custom({
+    const {
+      Common,
+      Hardfork
+    } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 652, 23));
+    const hardfork = supportsEIP1559 ? Hardfork.Paris : Hardfork.Berlin;
+    return Common.custom({
       chainId: chainId === "loading" ? 0 : Number.parseInt(chainId, 16),
       defaultHardfork: hardfork,
       name: displayName,