@toruslabs/ethereum-controllers 6.3.2 → 7.0.0-alpha.1

package/dist/ethereumControllers.esm.js

@@ -1,19 +1,22 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { CHAIN_NAMESPACES, BaseController, randomId, TransactionStatus, TRANSACTION_TYPES, formatSmallNumbers, addressSlicer, ACTIVITY_ACTION_RECEIVE, ACTIVITY_ACTION_SEND, significantDigits, BaseBlockTracker, timeout, BaseCurrencyController, cloneDeep, BaseKeyringController, concatSig, PROVIDER_JRPC_METHODS, createFetchMiddleware, createInflightCacheMiddleware, createSwappableProxy, createEventEmitterProxy, BasePreferencesController, isUnauthorizedError, TX_EVENTS, BaseTransactionStateManager, omitBy, transactionMatchesNetwork as transactionMatchesNetwork$1, pickBy } from '@toruslabs/base-controllers';
+import { CHAIN_NAMESPACES, BaseController, TransactionStatus, BaseBlockTracker, idleTimeTracker, timeout, BaseCurrencyController, cloneDeep, BaseKeyringController, concatSig, AbstractMessageController, MessageStatus, randomId, MESSAGE_EVENTS, PROVIDER_JRPC_METHODS, createFetchMiddleware, createInflightCacheMiddleware, createSwappableProxy, createEventEmitterProxy, TRANSACTION_TYPES, formatSmallNumbers, addressSlicer, ACTIVITY_ACTION_RECEIVE, ACTIVITY_ACTION_SEND, significantDigits, BasePreferencesController, isUnauthorizedError, TX_EVENTS, BaseTransactionStateManager, omitBy, transactionMatchesNetwork as transactionMatchesNetwork$1, pickBy } from '@toruslabs/base-controllers';
 import { Mutex } from 'async-mutex';
-import { BrowserProvider, toQuantity, Contract, Interface, SigningKey, hashMessage, TypedDataEncoder, isHexString as isHexString$1, JsonRpcProvider, Transaction, keccak256 } from 'ethers';
+import { BrowserProvider, toQuantity, Contract, isHexString, SigningKey, hashMessage, TypedDataEncoder, JsonRpcProvider, Interface, Transaction, keccak256 } from 'ethers';
 import log from 'loglevel';
-import { isHexString, addHexPrefix, isValidAddress, stripHexPrefix, toChecksumAddress, bytesToHex, privateToPublic, privateToAddress, ecsign, bigIntToBytes } from '@ethereumjs/util';
-import BigNumber from 'bignumber.js';
-import { rpcErrors, providerErrors, createAsyncMiddleware, mergeMiddleware, createScaffoldMiddleware, providerFromMiddleware, JRPCEngine, providerFromEngine, SafeEventEmitter } from '@web3auth/auth';
+import { JRPCEngine, providerFromEngine, createAsyncMiddleware, mergeMiddleware, createScaffoldMiddleware, providerFromMiddleware, rpcErrors, SafeEventEmitter, providerErrors } from '@web3auth/auth';
+import { defineChain, createPublicClient, http, createWalletClient } from 'viem';
+import { createPaymasterClient, createBundlerClient, entryPoint06Address, entryPoint07Address } from 'viem/account-abstraction';
 import { get } from '@toruslabs/http-helpers';
+import { stripHexPrefix, isHexString as isHexString$1, addHexPrefix, bytesToHex, privateToPublic, toChecksumAddress, privateToAddress, ecsign, bigIntToBytes, isValidAddress } from '@ethereumjs/util';
+import BigNumber from 'bignumber.js';
 import _objectDestructuringEmpty from '@babel/runtime/helpers/objectDestructuringEmpty';
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import BN, { BN as BN$1 } from 'bn.js';
 import stringify from 'fast-safe-stringify';
 import deepmerge from 'deepmerge';
 import jsonDiffer from 'fast-json-patch';
+import { toBiconomySmartAccount, toEcdsaKernelSmartAccount, toNexusSmartAccount, toSafeSmartAccount, toTrustSmartAccount } from 'permissionless/accounts';
 
 const erc20Abi = [{
   constant: true,
@@ -827,16 +830,15 @@ const COINGECKO_PLATFORMS_CHAIN_CODE_MAP = {
     currency: "eth"
   }
 };
-const MessageStatus = {
-  UNAPPROVED: "unapproved",
-  SIGNED: "signed",
-  PENDING: "pending",
-  APPROVED: "approved",
-  REJECTED: "rejected",
-  FAILED: "failed"
-};
-const MESSAGE_EVENTS = {
-  UNAPPROVED_MESSAGE: "unapprovedMessage"
+const SMART_ACCOUNT = {
+  BICONOMY: "biconomy",
+  KERNEL: "kernel",
+  SAFE: "safe",
+  TRUST: "trust",
+  // TODO: disabled because of pimlico issues
+  LIGHT: "light",
+  SIMPLE: "simple",
+  NEXUS: "nexus"
 };
 
 const SINGLE_CALL_BALANCES_ADDRESSES = {
@@ -998,837 +1000,607 @@ class AccountTrackerController extends BaseController {
   }
 }
 
-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: (from, LowerCase = true) => LowerCase ? addHexPrefix(from).toLowerCase() : addHexPrefix(from),
-  to: (to, LowerCase = true) => 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
+const eoaInterceptorMiddleware = eoaAddress => (req, res, next, end) => {
+  req.isAAProviderRequest = true;
+  if (req.method === "eth_accounts" || req.method === "eth_requestAccounts") {
+    res.result = [eoaAddress];
+    end();
+    return;
+  }
+  next();
 };
-
-/**
- * normalizes txParams
- */
-function normalizeTxParameters(txParameters, lowerCase = true) {
-  // apply only keys in the normalizers
-  const normalizedTxParameters = {
-    id: txParameters.id || randomId(),
-    from: txParameters.from
+function eoaProviderAsMiddleware(provider) {
+  return async (req, res, _next, end) => {
+    // send request to provider
+    try {
+      const providerRes = await provider.request(req);
+      res.result = providerRes;
+      return end();
+    } catch (error) {
+      return end(error);
+    }
   };
-  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);
-  }
-  return normalizedTxParameters;
 }
-function transactionMatchesNetwork(transaction, chainId) {
-  if (typeof transaction.chainId !== "undefined") {
-    return transaction.chainId === chainId;
+class AccountAbstractionController extends BaseController {
+  constructor({
+    config,
+    state,
+    getProviderConfig,
+    onNetworkStateChange
+  }) {
+    super({
+      state,
+      config
+    });
+    _defineProperty(this, "_smartAccount", void 0);
+    _defineProperty(this, "_publicClient", void 0);
+    _defineProperty(this, "_walletClient", void 0);
+    _defineProperty(this, "_bundlerClient", void 0);
+    _defineProperty(this, "_paymasterClient", void 0);
+    _defineProperty(this, "getProviderConfig", void 0);
+    this.initialize();
+    this.getProviderConfig = getProviderConfig;
+    // TODO: handle network change in torus controller & call setupProvider
+    onNetworkStateChange(networkState => {
+      if (networkState.chainId !== this.config.chainId) {
+        this.configure({
+          chainId: networkState.chainId
+        });
+      }
+    });
+  }
+  get smartAccount() {
+    return this._smartAccount;
+  }
+  get bundlerClient() {
+    return this._bundlerClient;
+  }
+  get walletClient() {
+    return this._walletClient;
+  }
+  async setupProvider(eoaProvider, eoaAddress) {
+    var _this$config$bundlerC;
+    const providerConfig = this.getProviderConfig();
+    const chain = defineChain({
+      id: Number.parseInt(providerConfig.chainId, 16),
+      // id in number form
+      name: providerConfig.displayName,
+      rpcUrls: {
+        default: {
+          http: [providerConfig.rpcTarget],
+          webSocket: [providerConfig.wsTarget]
+        }
+      },
+      blockExplorers: providerConfig.blockExplorerUrl ? {
+        default: {
+          name: "explorer",
+          // TODO: correct name if chain config has it
+          url: providerConfig.blockExplorerUrl
+        }
+      } : undefined,
+      nativeCurrency: {
+        name: providerConfig.tickerName,
+        symbol: providerConfig.ticker,
+        decimals: providerConfig.decimals || 18
+      }
+    });
+    this._publicClient = createPublicClient({
+      chain,
+      transport: http(providerConfig.rpcTarget)
+    });
+    const aaEngine = new JRPCEngine();
+    aaEngine.push(eoaInterceptorMiddleware(eoaAddress));
+    aaEngine.push(eoaProviderAsMiddleware(eoaProvider));
+    const provider = providerFromEngine(aaEngine);
+    this._smartAccount = await this.config.smartAccountInit.getSmartAccount({
+      owner: provider,
+      client: this._publicClient
+    });
+    if (this.config.paymasterConfig) {
+      var _this$config$paymaste;
+      this._paymasterClient = createPaymasterClient(_objectSpread(_objectSpread({}, this.config.paymasterConfig), {}, {
+        transport: (_this$config$paymaste = this.config.paymasterConfig.transport) !== null && _this$config$paymaste !== void 0 ? _this$config$paymaste : http(this.config.paymasterConfig.url)
+      }));
+    }
+    this._bundlerClient = createBundlerClient(_objectSpread(_objectSpread({}, this.config.bundlerConfig), {}, {
+      account: this.smartAccount,
+      client: this._publicClient,
+      transport: (_this$config$bundlerC = this.config.bundlerConfig.transport) !== null && _this$config$bundlerC !== void 0 ? _this$config$bundlerC : http(this.config.bundlerConfig.url),
+      paymaster: this._paymasterClient
+    }));
+    this._walletClient = createWalletClient({
+      account: this.smartAccount,
+      chain,
+      transport: http()
+    });
+    log.info("check: this._smartAccount", this.smartAccount.address);
+    this.update({
+      smartAccountAddress: this.smartAccount.address
+    });
+  }
+  async sendTransaction(id, tx, address) {
+    var _txParams$chainId;
+    if (address.toLowerCase() !== this.smartAccount.address.toLowerCase()) {
+      throw new Error("Invalid address");
+    }
+    const txParams = tx;
+    const userOperationParams = {
+      account: this.smartAccount,
+      calls: [{
+        to: txParams.to,
+        // Explicit conversation required to avoid value being passed as hex
+        value: BigInt(txParams.value),
+        data: txParams.data
+      }]
+      // should not use maxFeePerGas/maxPriorityFeePerGas from transaction params since that's fee for transaction not user operation and let bundler handle it instead
+    };
+    const userOpMeta = {
+      transactionParams: txParams,
+      chainId: (_txParams$chainId = txParams.chainId) !== null && _txParams$chainId !== void 0 ? _txParams$chainId : this.getProviderConfig().chainId,
+      createdAt: new Date(),
+      status: TransactionStatus.approved
+    };
+    this.updateUserOpMeta(id, userOpMeta);
+    // @ts-expect-error viem types are too deep
+    const userOpHash = await this.bundlerClient.sendUserOperation(userOperationParams);
+    this.updateUserOpMeta(id, {
+      userOpHash,
+      status: TransactionStatus.submitted
+    });
+    const txReceipt = await this.bundlerClient.waitForUserOperationReceipt({
+      hash: userOpHash
+    });
+    this.updateUserOpMeta(id, {
+      receipt: txReceipt,
+      status: txReceipt.success ? TransactionStatus.confirmed : TransactionStatus.failed
+    });
+    return txReceipt.receipt.transactionHash;
+  }
+  async signMessage(message, address) {
+    if (address.toLowerCase() !== this.smartAccount.address.toLowerCase()) {
+      throw new Error("Invalid address");
+    }
+    return this.smartAccount.sign({
+      hash: message
+    });
+  }
+  async signPersonalMessage(message, address) {
+    var _this$walletClient;
+    if (address.toLowerCase() !== this.smartAccount.address.toLowerCase()) {
+      throw new Error("Invalid address");
+    }
+    return (_this$walletClient = this.walletClient) === null || _this$walletClient === void 0 ? void 0 : _this$walletClient.signMessage({
+      account: this.smartAccount,
+      message: isHexString(message) ? {
+        raw: message
+      } : message
+    });
+  }
+  async signTypedData(data, address) {
+    var _this$walletClient2;
+    if (address.toLowerCase() !== this.smartAccount.address.toLowerCase()) {
+      throw new Error("Invalid address");
+    }
+    return (_this$walletClient2 = this.walletClient) === null || _this$walletClient2 === void 0 ? void 0 : _this$walletClient2.signTypedData({
+      account: this.smartAccount,
+      domain: _objectSpread(_objectSpread({}, data.domain), {}, {
+        verifyingContract: data.domain.verifyingContract,
+        salt: data.domain.salt,
+        chainId: Number(data.domain.chainId)
+      }),
+      primaryType: data.primaryType,
+      types: data.types,
+      message: data.message
+    });
+  }
+  updateUserOpMeta(id, data) {
+    const userOp = this.state.userOperations[id];
+    this.update({
+      userOperations: _objectSpread(_objectSpread({}, this.state.userOperations), {}, {
+        [id]: _objectSpread(_objectSpread({}, userOp), data)
+      })
+    });
   }
-  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));
+class BiconomySmartAccount {
+  constructor(options) {
+    _defineProperty(this, "name", SMART_ACCOUNT.BICONOMY);
+    _defineProperty(this, "options", void 0);
+    this.options = options;
+  }
+  async getSmartAccount(params) {
+    var _this$options, _this$options2;
+    return toBiconomySmartAccount(_objectSpread(_objectSpread(_objectSpread({}, this.options || {}), {}, {
+      entryPoint: {
+        address: ((_this$options = this.options) === null || _this$options === void 0 || (_this$options = _this$options.entryPoint) === null || _this$options === void 0 ? void 0 : _this$options.address) || entryPoint06Address,
+        version: ((_this$options2 = this.options) === null || _this$options2 === void 0 || (_this$options2 = _this$options2.entryPoint) === null || _this$options2 === void 0 ? void 0 : _this$options2.version) || "0.6"
+      }
+    }, params), {}, {
+      owners: [params.owner],
+      client: params.client
+    }));
+  }
 }
 
-/**
- * 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)));
-}
+// use type of function so we don't need to pass in generic to parameter type
 
-/**
- * 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`);
+class KernelSmartAccount {
+  constructor(options) {
+    _defineProperty(this, "name", SMART_ACCOUNT.KERNEL);
+    _defineProperty(this, "options", void 0);
+    this.options = options;
+  }
+  async getSmartAccount(params) {
+    return toEcdsaKernelSmartAccount(_objectSpread(_objectSpread(_objectSpread({}, this.options || {}), params), {}, {
+      owners: [params.owner],
+      client: params.client
+    }));
   }
 }
 
-/**
- * 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]})`);
+class NexusSmartAccount {
+  constructor(options) {
+    _defineProperty(this, "name", SMART_ACCOUNT.NEXUS);
+    _defineProperty(this, "options", void 0);
+    this.options = options;
+  }
+  async getSmartAccount(params) {
+    var _this$options, _this$options2, _this$options3;
+    return toNexusSmartAccount(_objectSpread(_objectSpread(_objectSpread({}, this.options || {}), {}, {
+      entryPoint: {
+        address: ((_this$options = this.options) === null || _this$options === void 0 || (_this$options = _this$options.entryPoint) === null || _this$options === void 0 ? void 0 : _this$options.address) || entryPoint07Address,
+        version: ((_this$options2 = this.options) === null || _this$options2 === void 0 || (_this$options2 = _this$options2.entryPoint) === null || _this$options2 === void 0 ? void 0 : _this$options2.version) || "0.7"
+      },
+      version: ((_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : _this$options3.version) || "1.0.0"
+    }, params), {}, {
+      owners: [params.owner],
+      client: params.client
+    }));
   }
 }
 
-/**
- * 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");
-      }
+// use type of function so we don't need to pass in generic to parameter type
+
+class SafeSmartAccount {
+  constructor(options) {
+    _defineProperty(this, "name", SMART_ACCOUNT.SAFE);
+    _defineProperty(this, "options", void 0);
+    this.options = options;
+  }
+  async getSmartAccount(params) {
+    var _this$options, _this$options2, _this$options3;
+    return toSafeSmartAccount(_objectSpread(_objectSpread(_objectSpread({}, this.options || {}), {}, {
+      entryPoint: {
+        address: ((_this$options = this.options) === null || _this$options === void 0 || (_this$options = _this$options.entryPoint) === null || _this$options === void 0 ? void 0 : _this$options.address) || entryPoint07Address,
+        version: ((_this$options2 = this.options) === null || _this$options2 === void 0 || (_this$options2 = _this$options2.entryPoint) === null || _this$options2 === void 0 ? void 0 : _this$options2.version) || "0.7"
+      },
+      version: ((_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : _this$options3.version) || "1.4.1"
+    }, params), {}, {
+      owners: [params.owner],
+      client: params.client
+    }));
   }
 }
 
-/**
- * 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.');
+// use type of function so we don't need to pass in generic to parameter type
+
+class TrustSmartAccount {
+  constructor(options) {
+    _defineProperty(this, "name", SMART_ACCOUNT.TRUST);
+    _defineProperty(this, "options", void 0);
+    this.options = options;
+  }
+  async getSmartAccount(params) {
+    var _this$options, _this$options2;
+    return toTrustSmartAccount(_objectSpread(_objectSpread(_objectSpread({}, this.options || {}), {}, {
+      entryPoint: {
+        address: ((_this$options = this.options) === null || _this$options === void 0 || (_this$options = _this$options.entryPoint) === null || _this$options === void 0 ? void 0 : _this$options.address) || entryPoint06Address,
+        version: ((_this$options2 = this.options) === null || _this$options2 === void 0 || (_this$options2 = _this$options2.entryPoint) === null || _this$options2 === void 0 ? void 0 : _this$options2.version) || "0.6"
+      }
+    }, params), {}, {
+      owner: params.owner,
+      client: params.client
+    }));
   }
 }
 
-/**
- * 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.');
+const DEFAULT_POLLING_INTERVAL = 20;
+const DEFAULT_RETRY_TIMEOUT = 2;
+const SEC = 1000;
+class PollingBlockTracker extends BaseBlockTracker {
+  constructor({
+    config,
+    state = {}
+  }) {
+    if (!config.provider) {
+      throw new Error("PollingBlockTracker - no provider specified.");
     }
-  } else if (txParameters.to !== undefined && !isValidAddress(txParameters.to)) {
-    throw rpcErrors.invalidParams('Invalid "to" address.');
+    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();
   }
-  return txParameters;
-}
 
-/**
- * Validates the given tx parameters
- * @throws if the tx params contains invalid fields
- */
-function validateTxParameters(txParams, eip1559Compatibility = true) {
-  if (!txParams || typeof txParams !== "object" || Array.isArray(txParams)) {
-    throw rpcErrors.invalidParams("Invalid transaction params: must be an object.");
+  // overrides the BaseBlockTracker._start method.
+  _start() {
+    this._synchronize().catch(err => this.emit("error", err));
   }
-  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.');
+  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);
+      }
+    }
   }
-  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");
+  async _updateLatestBlock() {
+    // fetch + set latest block
+    const latestBlock = await this._fetchLatestBlock();
+    this._newPotentialLatest(latestBlock);
   }
-  Object.entries(txParams).forEach(([key, value]) => {
-    // 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);
+  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}`);
     }
-  });
-}
-function normalizeAndValidateTxParams(txParams, lowerCase = 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
+class CurrencyController extends BaseCurrencyController {
+  constructor({
+    config,
+    state,
+    onNetworkChanged
+  }) {
+    super({
+      config,
+      state
     });
-    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
+    _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();
+      }
     });
-    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
+  setCommonDenomination(commonDenomination) {
+    this.update({
+      commonDenomination
     });
-    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"]
+  getCommonDenomination() {
+    return this.state.commonDenomination;
+  }
+  setCommonDenominatorPrice(commonDenominatorPrice) {
+    this.update({
+      commonDenominatorPrice
     });
-  } 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);
+  getCommonDenominatorPrice() {
+    return this.state.commonDenominatorPrice;
   }
-  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;
+
+  /**
+   * 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 {
-      result = TRANSACTION_TYPES.SENT_ETHER;
+      this.setConversionRate(0);
+      this.setConversionDate("N/A");
     }
   }
-  return {
-    type: type || CONTRACT_TYPE_ETH,
-    category: result,
-    methodParams,
-    getCodeResponse: contractCode
-  };
+  async retrieveConversionRate(fromCurrency, toCurrency, commonDenomination) {
+    try {
+      let apiUrl = `${this.config.api}/currency?fsym=${fromCurrency.toUpperCase()}&tsyms=${toCurrency.toUpperCase()}`;
+      if (commonDenomination && commonDenomination.toUpperCase() !== toCurrency.toUpperCase()) {
+        apiUrl += `,${commonDenomination.toUpperCase()}`;
+      }
+      const parsedResponse = await get(apiUrl);
+      return parsedResponse;
+    } catch (error) {
+      log.error(error, `CurrencyController - updateCommonDenominatorPrice: Failed to query rate for currency: ${fromCurrency}/ ${toCurrency}`);
+    }
+    return {
+      [toCurrency.toUpperCase()]: "0",
+      [commonDenomination.toUpperCase()]: "0"
+    };
+  }
 }
 
-function hexToBn(hex) {
-  return new BigNumber(stripHexPrefix(hex), 16);
-}
-function BNToHex(bn) {
-  return addHexPrefix(bn.toString(16));
-}
-function getEtherScanHashLink(txHash, chainId) {
-  if (!SUPPORTED_NETWORKS[chainId]) return "";
-  return `${SUPPORTED_NETWORKS[chainId].blockExplorerUrl}/tx/${txHash}`;
-}
-const formatPastTx = params => {
-  var _transaction$to;
-  const {
-    transaction,
-    lowerCaseSelectedAddress,
-    blockExplorerUrl
-  } = params;
-  let totalAmountString = "";
-  if (transaction.type === CONTRACT_TYPE_ERC721 || transaction.type === CONTRACT_TYPE_ERC1155) totalAmountString = transaction.symbol;else if (transaction.type === CONTRACT_TYPE_ERC20) totalAmountString = formatSmallNumbers(Number.parseFloat(transaction.total_amount), transaction.symbol, true);else totalAmountString = formatSmallNumbers(Number.parseFloat(transaction.total_amount), transaction.type_name, true);
-  const currencyAmountString = transaction.type === CONTRACT_TYPE_ERC721 || transaction.type === CONTRACT_TYPE_ERC1155 || transaction.isEtherscan ? "" : formatSmallNumbers(Number.parseFloat(transaction.currency_amount), transaction.selected_currency, true);
-  const finalObject = {
-    id: transaction.created_at.toString(),
-    date: new Date(transaction.created_at).toString(),
-    from: transaction.from,
-    from_aa_address: transaction.from_aa_address,
-    slicedFrom: typeof transaction.from === "string" ? addressSlicer(transaction.from) : "",
-    to: transaction.to,
-    slicedTo: typeof transaction.to === "string" ? addressSlicer(transaction.to) : "",
-    action: lowerCaseSelectedAddress === ((_transaction$to = transaction.to) === null || _transaction$to === void 0 ? void 0 : _transaction$to.toLowerCase()) || "" ? ACTIVITY_ACTION_RECEIVE : ACTIVITY_ACTION_SEND,
-    totalAmount: transaction.total_amount,
-    totalAmountString,
-    currencyAmount: transaction.currency_amount,
-    currencyAmountString,
-    amount: `${totalAmountString} / ${currencyAmountString}`,
-    status: transaction.status,
-    etherscanLink: blockExplorerUrl ? `${blockExplorerUrl}/tx/${transaction.transaction_hash}` : "",
-    chainId: transaction.chain_id,
-    ethRate: Number.parseFloat(transaction === null || transaction === void 0 ? void 0 : transaction.total_amount) && Number.parseFloat(transaction === null || transaction === void 0 ? void 0 : transaction.currency_amount) ? `1 ${transaction.symbol} = ${significantDigits(Number.parseFloat(transaction.currency_amount) / Number.parseFloat(transaction.total_amount))}` : "",
-    currencyUsed: transaction.selected_currency,
-    type: transaction.type,
-    type_name: transaction.type_name,
-    type_image_link: transaction.type_image_link,
-    transaction_hash: transaction.transaction_hash,
-    transaction_category: transaction.transaction_category,
-    isEtherscan: transaction.isEtherscan,
-    input: transaction.input || "",
-    token_id: transaction.token_id || "",
-    contract_address: transaction.contract_address || "",
-    nonce: transaction.nonce || "",
-    is_cancel: !!transaction.is_cancel || false,
-    gas: transaction.gas || "",
-    gasPrice: transaction.gasPrice || ""
-  };
-  return finalObject;
+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;
+
 /**
- * Ref - https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt
+ * Utility method to convert a value between denominations, formats and currencies.
  */
-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;
+const converter = ({
+  value,
+  fromNumericBase,
+  fromDenomination,
+  fromCurrency,
+  toNumericBase,
+  toDenomination,
+  toCurrency,
+  numberOfDecimals,
+  conversionRate,
+  invertConversionRate,
+  roundDown
+}) => {
+  let convertedValue = fromNumericBase ? toBigNumber[fromNumericBase](value) : value;
+  if (fromDenomination) {
+    convertedValue = toNormalizedDenomination[fromDenomination](convertedValue);
   }
-};
-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);
+  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);
   }
-  function checkIfIdle() {
-    return isIdle;
+  if (numberOfDecimals) {
+    convertedValue = convertedValue.dp(numberOfDecimals, BigNumber.ROUND_HALF_DOWN);
   }
-  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))
+  if (roundDown) {
+    convertedValue = convertedValue.dp(roundDown, BigNumber.ROUND_DOWN);
+  }
+  if (toNumericBase) {
+    convertedValue = baseChange[toNumericBase](convertedValue);
+  }
+  return convertedValue;
 };
-function bnLessThan(a, b) {
-  if (a === null || a === undefined || b === null || b === undefined) {
-    return null;
+const conversionUtil = (value, {
+  fromCurrency = null,
+  toCurrency = fromCurrency,
+  fromNumericBase,
+  toNumericBase,
+  fromDenomination,
+  toDenomination,
+  numberOfDecimals,
+  conversionRate,
+  invertConversionRate
+}) => {
+  if (fromCurrency !== toCurrency && !conversionRate) {
+    return 0;
   }
-  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 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");
   }
-  return finalUri;
-}
-function getChainType(chainId) {
-  if (chainId === MAINNET_CHAIN_ID) {
-    return "mainnet";
-  } else if (TEST_CHAINS.includes(chainId)) {
-    return "testnet";
+
+  // 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 "custom";
-}
-const addEtherscanTransactions = async params => {
-  const {
-    txn,
-    lowerCaseSelectedAddress,
-    provider,
-    chainId,
-    blockExplorerUrl
-  } = params;
-  const transactionPromises = await Promise.all(txn.map(async tx => {
-    var _SUPPORTED_NETWORKS$c, _SUPPORTED_NETWORKS$c2;
-    const {
-      category,
-      type
-    } = await 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;
-    let totalAmountString = x.value ? new BigNumber(x.value).div(new BigNumber(10).pow(new BigNumber(x.tokenDecimal || 18))).toString() : "";
-    let type = CONTRACT_TYPE_ETH;
-    if (x.contractAddress !== "") {
-      if (x.tokenID) {
-        type = x.tokenValue ? CONTRACT_TYPE_ERC1155 : CONTRACT_TYPE_ERC721;
-      } else {
-        type = CONTRACT_TYPE_ERC20;
-      }
-    }
-    if (type === CONTRACT_TYPE_ERC1155) {
-      totalAmountString = x.tokenValue;
-    }
-    const etherscanTransaction = {
-      type,
-      type_image_link: x.type_image_link || "n/a",
-      type_name: x.tokenName || ((_SUPPORTED_NETWORKS$c3 = SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c3 === void 0 ? void 0 : _SUPPORTED_NETWORKS$c3.ticker) || "n/a",
-      symbol: x.tokenSymbol || ((_SUPPORTED_NETWORKS$c4 = SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c4 === void 0 ? void 0 : _SUPPORTED_NETWORKS$c4.ticker),
-      token_id: x.tokenID || "",
-      total_amount: totalAmountString,
-      created_at: new Date(Number(x.timeStamp) * 1000),
-      from: x.from,
-      to: x.to,
-      transaction_hash: x.hash,
-      status: x.txreceipt_status && x.txreceipt_status === "0" ? TransactionStatus.failed : TransactionStatus.confirmed,
-      isEtherscan: true,
-      input: x.input,
-      contract_address: x.contractAddress,
-      transaction_category: x.transaction_category,
-      gas: `0x${new BigNumber(x.gasUsed || 0, 10).toString(16)}`,
-      gasPrice: `0x${new BigNumber(x.gasPrice || 0, 10).toString(16)}`,
-      chain_id: chainId,
-      currency_amount: "",
-      nonce: x.nonce,
-      from_aa_address: "",
-      is_cancel: false,
-      selected_currency: ""
-    };
-    accumulator.push(formatPastTx({
-      transaction: etherscanTransaction,
-      lowerCaseSelectedAddress,
-      blockExplorerUrl
-    }));
-    return accumulator;
-  }, []);
-  return finalTxs;
-};
-
-const DEFAULT_POLLING_INTERVAL = 20;
-const DEFAULT_RETRY_TIMEOUT = 2;
-const SEC = 1000;
-class PollingBlockTracker extends BaseBlockTracker {
-  constructor({
-    config,
-    state = {}
-  }) {
-    if (!config.provider) {
-      throw new Error("PollingBlockTracker - no provider specified.");
-    }
-    super({
-      config,
-      state
-    });
-    const pollingInterval = config.pollingInterval || DEFAULT_POLLING_INTERVAL;
-    const retryTimeout = config.retryTimeout || DEFAULT_RETRY_TIMEOUT;
-
-    // merge default + provided config.
-    this.defaultConfig = {
-      provider: config.provider,
-      pollingInterval: pollingInterval * SEC,
-      retryTimeout: retryTimeout * SEC,
-      setSkipCacheFlag: config.setSkipCacheFlag || false
-    };
-    this.initialize();
-  }
-  async checkForLatestBlock() {
-    await this._updateLatestBlock();
-    return this.getLatestBlock();
-  }
-
-  // overrides the BaseBlockTracker._start method.
-  _start() {
-    this._synchronize().catch(err => this.emit("error", err));
-  }
-  async _synchronize() {
-    while (this.state._isRunning) {
-      if (idleTimeTracker.checkIfIdle()) return;
-      try {
-        await this._updateLatestBlock();
-        await timeout(this.config.pollingInterval);
-      } catch (err) {
-        const newErr = new Error(`PollingBlockTracker - encountered an error while attempting to update latest block:\n${err.stack}`);
-        try {
-          this.emit("error", newErr);
-        } catch (emitErr) {
-          log.error(newErr);
-        }
-        await timeout(this.config.retryTimeout);
-      }
-    }
-  }
-  async _updateLatestBlock() {
-    // fetch + set latest block
-    const latestBlock = await this._fetchLatestBlock();
-    this._newPotentialLatest(latestBlock);
-  }
-  async _fetchLatestBlock() {
-    try {
-      const block = await this.config.provider.request({
-        method: "eth_getBlockByNumber",
-        params: ["latest", false]
-      });
-      return {
-        blockHash: block.hash,
-        idempotencyKey: block.number,
-        timestamp: block.timestamp,
-        baseFeePerGas: block.baseFeePerGas,
-        gasLimit: block.gasLimit
-      };
-    } catch (error) {
-      log.error("Polling Block Tracker: ", error);
-      throw new Error(`PollingBlockTracker - encountered error fetching block:\n${error.message}`);
-    }
-  }
-}
-
-class CurrencyController extends BaseCurrencyController {
-  constructor({
-    config,
-    state,
-    onNetworkChanged
-  }) {
-    super({
-      config,
-      state
-    });
-    _defineProperty(this, "conversionInterval", void 0);
-    this.defaultState = _objectSpread(_objectSpread({}, this.defaultState), {}, {
-      commonDenomination: "USD",
-      commonDenominatorPrice: 0
-    });
-    this.initialize();
-    onNetworkChanged(networkState => {
-      // to be called as (listener) => this.networkController.on('networkDidChange', listener);
-      if (networkState.providerConfig.ticker.toUpperCase() !== this.state.nativeCurrency.toUpperCase()) {
-        this.setNativeCurrency(networkState.providerConfig.ticker);
-        this.updateConversionRate();
-      }
-    });
-  }
-  setCommonDenomination(commonDenomination) {
-    this.update({
-      commonDenomination
-    });
-  }
-  getCommonDenomination() {
-    return this.state.commonDenomination;
-  }
-  setCommonDenominatorPrice(commonDenominatorPrice) {
-    this.update({
-      commonDenominatorPrice
-    });
-  }
-  getCommonDenominatorPrice() {
-    return this.state.commonDenominatorPrice;
-  }
-
-  /**
-   * Creates a new poll, using setInterval, to periodically call updateConversionRate. The id of the interval is
-   * stored at the controller's conversionInterval property. If it is called and such an id already exists, the
-   * previous interval is clear and a new one is created.
-   */
-  scheduleConversionInterval() {
-    if (this.conversionInterval) {
-      window.clearInterval(this.conversionInterval);
-    }
-    this.conversionInterval = window.setInterval(() => {
-      if (!idleTimeTracker.checkIfIdle()) {
-        this.updateConversionRate();
-      }
-    }, this.config.pollInterval);
-  }
-
-  /**
-   * Updates the conversionRate and conversionDate properties associated with the currentCurrency. Updated info is
-   * fetched from an external API
-   */
-  async updateConversionRate() {
-    const currentCurrency = this.getCurrentCurrency();
-    const nativeCurrency = this.getNativeCurrency();
-    const commonDenomination = this.getCommonDenomination();
-    const conversionRate = await this.retrieveConversionRate(nativeCurrency, currentCurrency, commonDenomination);
-    const currentCurrencyRate = Number.parseFloat(conversionRate[currentCurrency.toUpperCase()]);
-    const commonDenominationRate = Number.parseFloat(conversionRate[commonDenomination.toUpperCase()]);
-    // set conversion rate
-    if (currentCurrencyRate || commonDenominationRate) {
-      // ETC
-      this.setConversionRate(currentCurrencyRate);
-      this.setConversionDate(Math.floor(Date.now() / 1000).toString());
-      if (currentCurrency.toUpperCase() === commonDenomination.toUpperCase()) {
-        this.setCommonDenominatorPrice(currentCurrencyRate);
-      } else {
-        this.setCommonDenominatorPrice(commonDenominationRate);
-      }
-    } else {
-      this.setConversionRate(0);
-      this.setConversionDate("N/A");
-    }
-  }
-  async retrieveConversionRate(fromCurrency, toCurrency, commonDenomination) {
-    try {
-      let apiUrl = `${this.config.api}/currency?fsym=${fromCurrency.toUpperCase()}&tsyms=${toCurrency.toUpperCase()}`;
-      if (commonDenomination && commonDenomination.toUpperCase() !== toCurrency.toUpperCase()) {
-        apiUrl += `,${commonDenomination.toUpperCase()}`;
-      }
-      const parsedResponse = await get(apiUrl);
-      return parsedResponse;
-    } catch (error) {
-      log.error(error, `CurrencyController - updateCommonDenominatorPrice: Failed to query rate for currency: ${fromCurrency}/ ${toCurrency}`);
-    }
-    return {
-      [toCurrency.toUpperCase()]: "0",
-      [commonDenomination.toUpperCase()]: "0"
-    };
-  }
-}
-
-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 = ({
-  value,
-  fromNumericBase,
-  fromDenomination,
-  fromCurrency,
-  toNumericBase,
-  toDenomination,
-  toCurrency,
-  numberOfDecimals,
-  conversionRate,
-  invertConversionRate,
-  roundDown
-}) => {
-  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, {
-  fromCurrency = null,
-  toCurrency = fromCurrency,
-  fromNumericBase,
-  toNumericBase,
-  fromDenomination,
-  toDenomination,
-  numberOfDecimals,
-  conversionRate,
-  invertConversionRate
-}) => {
-  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 = (a, b, options = {}) => {
+  return new BigNumber(String(value), base);
+};
+const addCurrencies = (a, b, options = {}) => {
   const {
       aBase,
       bBase
@@ -2171,7 +1943,7 @@ class GasFeeController extends BaseController {
     const chainId = this.getNetworkIdentifier();
     if (chainId === "loading") return;
     let chainIdInt;
-    if (typeof chainId === "string" && isHexString(addHexPrefix(chainId))) {
+    if (typeof chainId === "string" && isHexString$1(addHexPrefix(chainId))) {
       chainIdInt = Number.parseInt(chainId, 16);
     }
     try {
@@ -2328,7 +2100,7 @@ class KeyringController extends BaseKeyringController {
     // we need to check if the data is hex or not
     // For historical reasons, you must submit the message to sign in hex-encoded UTF-8.
     // https://docs.metamask.io/wallet/how-to/sign-data/#use-personal_sign
-    const message = isHexString(data) ? Buffer.from(stripHexPrefix(data), "hex") : Buffer.from(data);
+    const message = isHexString$1(data) ? Buffer.from(stripHexPrefix(data), "hex") : Buffer.from(data);
     const signature = privKey.sign(hashMessage(message)).serialized;
     return signature;
   }
@@ -2349,105 +2121,6 @@ class KeyringController extends BaseKeyringController {
   }
 }
 
-class AbstractMessageController extends BaseController {
-  /**
-   * Controller in charge of managing - storing, adding, removing, updating - Messages.
-   *
-   */
-  constructor({
-    config,
-    state,
-    getNetworkIdentifier
-  }) {
-    super({
-      config,
-      state
-    });
-    _defineProperty(this, "messages", void 0);
-    _defineProperty(this, "getNetworkIdentifier", void 0);
-    this.defaultState = {
-      unapprovedMessages: {},
-      unapprovedMessagesCount: 0
-    };
-    this.messages = [];
-    this.defaultConfig = {};
-    this.getNetworkIdentifier = getNetworkIdentifier;
-    super.initialize();
-  }
-  getMessage(messageId) {
-    return this.messages.find(message => message.id === messageId);
-  }
-  getAllMessages() {
-    return this.messages;
-  }
-  setMetadata(messageId, metadata) {
-    const message = this.getMessage(messageId);
-    if (!message) {
-      throw new Error(`${this.name}: Message not found for id: ${messageId}.`);
-    }
-    message.metadata = metadata;
-    this.updateMessage(message);
-  }
-  getUnapprovedMessages() {
-    return this.messages.filter(message => message.status === MessageStatus.UNAPPROVED).reduce((result, message) => {
-      result[message.id] = message;
-      return result;
-    }, {});
-  }
-  async addMessage(message) {
-    this.messages.push(message);
-    this.saveMessageList();
-  }
-  approveMessage(messageId, messageParams) {
-    this.setMessageStatus(messageId, MessageStatus.APPROVED);
-    return this.prepMessageForSigning(messageParams);
-  }
-  setMessageStatus(messageId, status) {
-    const message = this.getMessage(messageId);
-    if (!message) {
-      throw new Error(`${this.name}: Message not found for id: ${messageId}.`);
-    }
-    message.status = status;
-    this.updateMessage(message);
-    this.emit(`${messageId}:${status}`, message);
-    if (status === MessageStatus.REJECTED || status === MessageStatus.SIGNED || status === MessageStatus.FAILED) {
-      this.emit(`${messageId}:finished`, message);
-    }
-  }
-  async waitForFinishStatus(msgParams, messageName) {
-    return new Promise((resolve, reject) => {
-      const handleFinished = msg => {
-        if (msg.status === MessageStatus.REJECTED) {
-          return reject(providerErrors.userRejectedRequest(`${messageName} Signature: User denied message signature`));
-        }
-        if (msg.status === MessageStatus.FAILED) {
-          return reject(rpcErrors.internal(`${messageName} Signature: failed to sign message ${msg.error}`));
-        }
-        if (msg.status === MessageStatus.SIGNED) {
-          return resolve(msg.rawSig);
-        }
-        return reject(rpcErrors.internal(`${messageName} Signature: Unknown problem: ${JSON.stringify(msgParams)}`));
-      };
-      this.once(`${msgParams.id}:finished`, handleFinished);
-    });
-  }
-  updateMessage(message) {
-    const index = this.messages.findIndex(msg => message.id === msg.id);
-    if (index !== -1) {
-      this.messages[index] = message;
-    }
-    this.saveMessageList();
-  }
-  saveMessageList() {
-    const unapprovedMessages = this.getUnapprovedMessages();
-    const unapprovedMessagesCount = Object.keys(unapprovedMessages).length;
-    this.update({
-      unapprovedMessages,
-      unapprovedMessagesCount
-    });
-  }
-}
-
 const hexRe = /^[0-9A-Fa-f]+$/gu;
 function validateAddress(address, propertyName) {
   if (!address || typeof address !== "string" || !isValidAddress(address)) {
@@ -2516,7 +2189,7 @@ async function validateAddChainData(data) {
   if (!chainId) {
     throw new Error("Invalid add chain params: please pass chainId in params");
   }
-  if (!isHexString$1(chainId)) {
+  if (!isHexString(chainId)) {
     throw new Error("Invalid add chain params: please pass a valid hex chainId in params, for: ex: 0x1");
   }
   if (!rpcUrls || rpcUrls.length === 0) throw new Error("params.rpcUrls not provided");
@@ -2544,7 +2217,7 @@ function validateSwitchChainData(data) {
   if (!chainId) {
     throw new Error("Invalid switch chain params: please pass chainId in params");
   }
-  if (!isHexString$1(chainId)) {
+  if (!isHexString(chainId)) {
     throw new Error("Invalid switch chain params: please pass a valid hex chainId in params, for: ex: 0x1");
   }
 }
@@ -2553,13 +2226,11 @@ class AddChainController extends AbstractMessageController {
   constructor({
     config,
     state,
-    getNetworkIdentifier,
     addChain
   }) {
     super({
       config,
-      state,
-      getNetworkIdentifier
+      state
     });
     _defineProperty(this, "name", "AddChainController");
     _defineProperty(this, "addChain", void 0);
@@ -2620,13 +2291,11 @@ class MessageController extends AbstractMessageController {
   constructor({
     config,
     state,
-    signMessage,
-    getNetworkIdentifier
+    signMessage
   }) {
     super({
       config,
-      state,
-      getNetworkIdentifier
+      state
     });
     _defineProperty(this, "name", "MessageController");
     _defineProperty(this, "signMessage", void 0);
@@ -2686,27 +2355,158 @@ class PersonalMessageController extends AbstractMessageController {
   constructor({
     config,
     state,
-    signPersonalMessage,
-    getNetworkIdentifier
+    signPersonalMessage
   }) {
     super({
       config,
-      state,
-      getNetworkIdentifier
+      state
     });
     _defineProperty(this, "name", "PersonalMessageController");
     _defineProperty(this, "signPersonalMessage", void 0);
     this.signPersonalMessage = signPersonalMessage;
     this.initialize();
   }
-  async processSignPersonalMessage(messageId) {
+  async processSignPersonalMessage(messageId) {
+    const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
+    try {
+      const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
+      const rawSig = await this.signPersonalMessage(cleanMsgParams.data, cleanMsgParams.from);
+      this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
+        rawSig
+      }));
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return rawSig;
+    } catch (error) {
+      log.error(error);
+      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    validateSignMessageData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    messageParams.data = normalizeMessageData(messageParams.data);
+    const messageId = messageParams.id || randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.PERSONAL_SIGN
+    };
+    await this.addMessage(messageData);
+    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+class SwitchChainController extends AbstractMessageController {
+  constructor({
+    config,
+    state,
+    switchChain
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "name", "SwitchChainController");
+    _defineProperty(this, "switchChain", void 0);
+    this.switchChain = switchChain;
+    this.initialize();
+  }
+  async processSwitchChain(messageId) {
+    const msgObject = this.getMessage(messageId);
+    if (!msgObject) {
+      throw new Error(`Message not found`);
+    }
+    try {
+      await this.approveMessage(messageId, msgObject.messageParams);
+      this.switchChain({
+        chainId: msgObject.messageParams.chainId
+      });
+      this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
+        rawSig: JSON.stringify(msgObject.messageParams)
+      }));
+      this.setMessageStatus(messageId, MessageStatus.SIGNED);
+      return null;
+    } catch (error) {
+      log.error(error);
+      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
+      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    }
+  }
+  async addNewUnapprovedMessage(messageParams, req) {
+    await this.addUnapprovedMessage(messageParams, req);
+    return this.waitForFinishStatus(messageParams, this.name);
+  }
+  async addUnapprovedMessage(messageParams, req) {
+    validateSwitchChainData(messageParams);
+    if (req) {
+      messageParams.origin = req.origin;
+    }
+    const messageId = messageParams.id || randomId();
+    const messageData = {
+      id: messageId,
+      messageParams,
+      status: MessageStatus.UNAPPROVED,
+      time: Date.now(),
+      type: METHOD_TYPES.SWITCH_CHAIN
+    };
+    await this.addMessage(messageData);
+    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
+      messageData,
+      req
+    });
+    return messageId;
+  }
+  prepMessageForSigning(messageParams) {
+    return Promise.resolve(messageParams);
+  }
+}
+
+class TypedMessageController extends AbstractMessageController {
+  constructor({
+    config,
+    state,
+    signTypedData,
+    getNetworkIdentifier
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "name", "TypedMessageController");
+    _defineProperty(this, "signTypedData", void 0);
+    _defineProperty(this, "getNetworkIdentifier", void 0);
+    this.signTypedData = signTypedData;
+    this.getNetworkIdentifier = getNetworkIdentifier;
+    this.initialize();
+  }
+  async processSignTypedMessage(messageId) {
     const msgObject = this.getMessage(messageId);
     if (!msgObject) {
       throw new Error(`Message not found`);
     }
     try {
       const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
-      const rawSig = await this.signPersonalMessage(cleanMsgParams.data, cleanMsgParams.from);
+      const msgData = JSON.parse(cleanMsgParams.data);
+      const rawSig = await this.signTypedData(msgData, cleanMsgParams.from);
       this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
         rawSig
       }));
@@ -2723,18 +2523,21 @@ class PersonalMessageController extends AbstractMessageController {
     return this.waitForFinishStatus(messageParams, this.name);
   }
   async addUnapprovedMessage(messageParams, req) {
-    validateSignMessageData(messageParams);
+    const currentChainId = this.getNetworkIdentifier();
+    await validateTypedSignMessageDataV4(messageParams, currentChainId);
+    if (typeof messageParams.data !== "string") {
+      messageParams.data = JSON.stringify(messageParams.data);
+    }
     if (req) {
       messageParams.origin = req.origin;
     }
-    messageParams.data = normalizeMessageData(messageParams.data);
     const messageId = messageParams.id || randomId();
     const messageData = {
       id: messageId,
       messageParams,
       status: MessageStatus.UNAPPROVED,
       time: Date.now(),
-      type: METHOD_TYPES.PERSONAL_SIGN
+      type: METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4
     };
     await this.addMessage(messageData);
     this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
@@ -2748,770 +2551,1144 @@ class PersonalMessageController extends AbstractMessageController {
   }
 }
 
-class SwitchChainController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    getNetworkIdentifier,
-    switchChain
-  }) {
-    super({
-      config,
-      state,
-      getNetworkIdentifier
-    });
-    _defineProperty(this, "name", "SwitchChainController");
-    _defineProperty(this, "switchChain", void 0);
-    this.switchChain = switchChain;
-    this.initialize();
+function createGetAccountsMiddleware({
+  getAccounts
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== METHOD_TYPES.GET_ACCOUNTS) return next();
+    if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
+    const accounts = await getAccounts(request);
+    response.result = accounts;
+  });
+}
+function createProcessTransactionMiddleware({
+  processTransaction
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== METHOD_TYPES.ETH_TRANSACTION) return next();
+    if (!processTransaction) throw new Error("WalletMiddleware - opts.processTransaction not provided");
+    response.result = await processTransaction(request.params, request);
+  });
+}
+function createProcessEthSignMessage({
+  processEthSignMessage
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== METHOD_TYPES.ETH_SIGN) return next();
+    if (!processEthSignMessage) throw new Error("WalletMiddleware - opts.processEthSignMessage not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, message]`);
+      const params = request.params;
+      const address = params[0];
+      const message = params[1];
+      msgParams = {
+        from: address,
+        data: message
+      };
+    }
+    response.result = await processEthSignMessage(msgParams, request);
+  });
+}
+function createProcessTypedMessageV4({
+  processTypedMessageV4
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4) return next();
+    if (!processTypedMessageV4) throw new Error("WalletMiddleware - opts.processTypedMessageV4 is not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, typedData]`);
+      const params = request.params;
+      const address = params[0];
+      const message = params[1];
+      msgParams = {
+        from: address,
+        data: message
+      };
+    }
+    response.result = await processTypedMessageV4(msgParams, request);
+  });
+}
+function createProcessPersonalMessage({
+  processPersonalMessage
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== METHOD_TYPES.PERSONAL_SIGN) return next();
+    if (!processPersonalMessage) throw new Error("WalletMiddleware - opts.processPersonalMessage is not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length >= 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [message, address]`);
+      const params = request.params;
+      if (typeof params[0] === "object") {
+        const {
+          challenge,
+          address
+        } = params[0];
+        msgParams = {
+          from: address,
+          data: challenge
+        };
+      } else {
+        const message = params[0];
+        const address = params[1];
+        msgParams = {
+          from: address,
+          data: message
+        };
+      }
+    }
+    response.result = await processPersonalMessage(msgParams, request);
+  });
+}
+function createPendingNonceMiddleware({
+  getPendingNonce
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      params,
+      method
+    } = request;
+    if (method !== METHOD_TYPES.ETH_GET_TRANSACTION_COUNT) return next();
+    const {
+      blockReference
+    } = params;
+    if (blockReference !== "pending") return next();
+    response.result = await getPendingNonce(params, request);
+  });
+}
+function formatTxMetaForRpcResult(txMeta) {
+  const {
+    r,
+    s,
+    v,
+    txReceipt,
+    transaction,
+    transactionHash,
+    accessList
+  } = txMeta;
+  const {
+    to,
+    data,
+    nonce,
+    gas,
+    from,
+    value,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas
+  } = transaction;
+  const formattedTxMeta = {
+    v,
+    r,
+    s,
+    to,
+    gas,
+    from,
+    hash: transactionHash,
+    nonce,
+    input: data || "0x",
+    value: value || "0x0",
+    accessList: accessList || null,
+    blockHash: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockHash) || null,
+    blockNumber: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockNumber) || null,
+    transactionIndex: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.transactionIndex) || null,
+    type: null
+  };
+  if (maxFeePerGas && maxPriorityFeePerGas) {
+    formattedTxMeta.maxFeePerGas = maxFeePerGas;
+    formattedTxMeta.maxPriorityFeePerGas = maxPriorityFeePerGas;
+    formattedTxMeta.type = TRANSACTION_ENVELOPE_TYPES.FEE_MARKET;
+  } else {
+    formattedTxMeta.gasPrice = gasPrice;
+    formattedTxMeta.type = TRANSACTION_ENVELOPE_TYPES.LEGACY;
   }
-  async processSwitchChain(messageId) {
-    const msgObject = this.getMessage(messageId);
-    if (!msgObject) {
-      throw new Error(`Message not found`);
+  return formattedTxMeta;
+}
+function createPendingTxMiddleware({
+  getPendingTransactionByHash
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      params,
+      method
+    } = request;
+    if (method !== METHOD_TYPES.ETH_GET_TRANSACTION_BY_HASH) return next();
+    if (!getPendingTransactionByHash) throw new Error("WalletMiddleware - opts.getPendingTransactionByHash not provided");
+    const txMeta = await getPendingTransactionByHash(params, request);
+    if (!txMeta) {
+      return next();
     }
-    try {
-      await this.approveMessage(messageId, msgObject.messageParams);
-      this.switchChain({
-        chainId: msgObject.messageParams.chainId
-      });
-      this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
-        rawSig: JSON.stringify(msgObject.messageParams)
-      }));
-      this.setMessageStatus(messageId, MessageStatus.SIGNED);
-      return null;
-    } catch (error) {
-      log.error(error);
-      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
-      this.setMessageStatus(messageId, MessageStatus.FAILED);
+    response.result = formatTxMetaForRpcResult(txMeta);
+    return undefined;
+  });
+}
+function createProcessSwitchEthereumChain({
+  processSwitchEthereumChain
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== METHOD_TYPES.SWITCH_CHAIN) return next();
+    if (!processSwitchEthereumChain) throw new Error("WalletMiddleware - opts.processSwitchEthereumChain not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
+      const [message] = request.params;
+      msgParams = message;
     }
-  }
-  async addNewUnapprovedMessage(messageParams, req) {
-    await this.addUnapprovedMessage(messageParams, req);
-    return this.waitForFinishStatus(messageParams, this.name);
-  }
-  async addUnapprovedMessage(messageParams, req) {
-    validateSwitchChainData(messageParams);
-    if (req) {
-      messageParams.origin = req.origin;
+    response.result = await processSwitchEthereumChain(msgParams, request);
+  });
+}
+function createProcessAddEthereumChain({
+  processAddEthereumChain
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== METHOD_TYPES.ADD_CHAIN) return next();
+    if (!processAddEthereumChain) throw new Error("WalletMiddleware - opts.processAddEthereumChain not provided");
+    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
+    let msgParams = request.params;
+    if (Array.isArray(request.params)) {
+      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
+      const [message] = request.params;
+      msgParams = message;
     }
-    const messageId = messageParams.id || randomId();
-    const messageData = {
-      id: messageId,
-      messageParams,
-      status: MessageStatus.UNAPPROVED,
-      time: Date.now(),
-      type: METHOD_TYPES.SWITCH_CHAIN
-    };
-    await this.addMessage(messageData);
-    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
-      messageData,
-      req
-    });
-    return messageId;
-  }
-  prepMessageForSigning(messageParams) {
-    return Promise.resolve(messageParams);
+    response.result = await processAddEthereumChain(msgParams, request);
+  });
+}
+function createRequestAccountsMiddleware({
+  requestAccounts
+}) {
+  return createAsyncMiddleware(async (request, response, next) => {
+    const {
+      method
+    } = request;
+    if (method !== "eth_requestAccounts") return next();
+    if (!requestAccounts) throw new Error("WalletMiddleware - opts.requestAccounts not provided");
+    // This calls the UI login function
+    const accounts = await requestAccounts(request);
+    response.result = accounts;
+    return undefined;
+  });
+}
+function createEthereumMiddleware(providerHandlers) {
+  const {
+    requestAccounts,
+    getAccounts,
+    processTransaction,
+    processEthSignMessage,
+    processTypedMessageV4,
+    processPersonalMessage,
+    getPendingNonce,
+    getPendingTransactionByHash,
+    processSwitchEthereumChain,
+    processAddEthereumChain,
+    getProviderState,
+    version
+  } = providerHandlers;
+  return mergeMiddleware([createScaffoldMiddleware({
+    version,
+    [PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: getProviderState
+  }), createRequestAccountsMiddleware({
+    requestAccounts
+  }), createGetAccountsMiddleware({
+    getAccounts
+  }), createProcessTransactionMiddleware({
+    processTransaction
+  }), createProcessEthSignMessage({
+    processEthSignMessage
+  }), createProcessTypedMessageV4({
+    processTypedMessageV4
+  }), createProcessPersonalMessage({
+    processPersonalMessage
+  }), createPendingNonceMiddleware({
+    getPendingNonce
+  }), createPendingTxMiddleware({
+    getPendingTransactionByHash
+  }), createProcessSwitchEthereumChain({
+    processSwitchEthereumChain
+  }), createProcessAddEthereumChain({
+    processAddEthereumChain
+  })]);
+}
+
+let CacheStrategy = /*#__PURE__*/function (CacheStrategy) {
+  CacheStrategy["Block"] = "block";
+  CacheStrategy["Fork"] = "fork";
+  CacheStrategy["Never"] = "never";
+  CacheStrategy["Permanent"] = "perma";
+  return CacheStrategy;
+}({});
+function blockTagParamIndex(method) {
+  switch (method) {
+    // blockTag is at index 2
+    case "eth_getStorageAt":
+      return 2;
+    // blockTag is at index 1
+    case "eth_getBalance":
+    case "eth_getCode":
+    case "eth_getTransactionCount":
+    case "eth_call":
+      return 1;
+    // blockTag is at index 0
+    case "eth_getBlockByNumber":
+      return 0;
+    // there is no blockTag
+    default:
+      return undefined;
   }
 }
+function cacheTypeForMethod(method) {
+  switch (method) {
+    // cache permanently
+    case "web3_clientVersion":
+    case "web3_sha3":
+    case "eth_protocolVersion":
+    case "eth_getBlockTransactionCountByHash":
+    case "eth_getUncleCountByBlockHash":
+    case "eth_getCode":
+    case "eth_getBlockByHash":
+    case "eth_getTransactionByHash":
+    case "eth_getTransactionByBlockHashAndIndex":
+    case "eth_getTransactionReceipt":
+    case "eth_getUncleByBlockHashAndIndex":
+    case "eth_getCompilers":
+    case "eth_compileLLL":
+    case "eth_compileSolidity":
+    case "eth_compileSerpent":
+    case "shh_version":
+    case "test_permaCache":
+      return CacheStrategy.Permanent;
 
-class TypedMessageController extends AbstractMessageController {
-  constructor({
-    config,
-    state,
-    signTypedData,
-    getNetworkIdentifier
-  }) {
-    super({
-      config,
-      state,
-      getNetworkIdentifier
-    });
-    _defineProperty(this, "name", "TypedMessageController");
-    _defineProperty(this, "signTypedData", void 0);
-    this.signTypedData = signTypedData;
-    this.initialize();
+    // cache until fork
+    case "eth_getBlockByNumber":
+    case "eth_getBlockTransactionCountByNumber":
+    case "eth_getUncleCountByBlockNumber":
+    case "eth_getTransactionByBlockNumberAndIndex":
+    case "eth_getUncleByBlockNumberAndIndex":
+    case "test_forkCache":
+      return CacheStrategy.Fork;
+
+    // cache for block
+    case "eth_gasPrice":
+    case "eth_blockNumber":
+    case "eth_getBalance":
+    case "eth_getStorageAt":
+    case "eth_getTransactionCount":
+    case "eth_call":
+    case "eth_estimateGas":
+    case "eth_getFilterLogs":
+    case "eth_getLogs":
+    case "test_blockCache":
+      return CacheStrategy.Block;
+
+    // never cache
+    default:
+      return CacheStrategy.Never;
   }
-  async processSignTypedMessage(messageId) {
-    const msgObject = this.getMessage(messageId);
-    if (!msgObject) {
-      throw new Error(`Message not found`);
-    }
-    try {
-      const cleanMsgParams = await this.approveMessage(messageId, msgObject.messageParams);
-      const msgData = JSON.parse(cleanMsgParams.data);
-      const rawSig = await this.signTypedData(msgData, cleanMsgParams.from);
-      this.updateMessage(_objectSpread(_objectSpread({}, msgObject), {}, {
-        rawSig
-      }));
-      this.setMessageStatus(messageId, MessageStatus.SIGNED);
-      return rawSig;
-    } catch (error) {
-      log.error(error);
-      msgObject.error = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString());
-      this.setMessageStatus(messageId, MessageStatus.FAILED);
-    }
+}
+function canCache(method) {
+  return cacheTypeForMethod(method) !== CacheStrategy.Never;
+}
+function paramsWithoutBlockTag(request) {
+  if (!request.params) {
+    return [];
   }
-  async addNewUnapprovedMessage(messageParams, req) {
-    await this.addUnapprovedMessage(messageParams, req);
-    return this.waitForFinishStatus(messageParams, this.name);
+  const index = blockTagParamIndex(request.method);
+
+  // Block tag param not passed.
+  if (index === undefined || !Array.isArray(request.params) || index >= request.params.length) {
+    return request.params;
   }
-  async addUnapprovedMessage(messageParams, req) {
-    const currentChainId = this.getNetworkIdentifier();
-    await validateTypedSignMessageDataV4(messageParams, currentChainId);
-    if (typeof messageParams.data !== "string") {
-      messageParams.data = JSON.stringify(messageParams.data);
-    }
-    if (req) {
-      messageParams.origin = req.origin;
-    }
-    const messageId = messageParams.id || randomId();
-    const messageData = {
-      id: messageId,
-      messageParams,
-      status: MessageStatus.UNAPPROVED,
-      time: Date.now(),
-      type: METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4
-    };
-    await this.addMessage(messageData);
-    this.emit(MESSAGE_EVENTS.UNAPPROVED_MESSAGE, {
-      messageData,
-      req
-    });
-    return messageId;
+
+  // eth_getBlockByNumber has the block tag first, then the optional includeTx? param
+  if (request.method === "eth_getBlockByNumber") {
+    return request.params.slice(1);
   }
-  prepMessageForSigning(messageParams) {
-    return Promise.resolve(messageParams);
+  return request.params.slice(0, index);
+}
+function cacheIdentifierForRequest(request, skipBlockRef) {
+  var _request$params;
+  const simpleParams = skipBlockRef ? paramsWithoutBlockTag(request) : (_request$params = request.params) !== null && _request$params !== void 0 ? _request$params : [];
+  if (canCache(request.method)) {
+    return `${request.method}:${stringify(simpleParams)}`;
   }
+  return null;
 }
 
-function createGetAccountsMiddleware({
-  getAccounts
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.GET_ACCOUNTS) return next();
-    if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
-    const accounts = await getAccounts(request);
-    response.result = accounts;
-  });
-}
-function createProcessTransactionMiddleware({
-  processTransaction
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_TRANSACTION) return next();
-    if (!processTransaction) throw new Error("WalletMiddleware - opts.processTransaction not provided");
-    response.result = await processTransaction(request.params, request);
-  });
-}
-function createProcessEthSignMessage({
-  processEthSignMessage
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_SIGN) return next();
-    if (!processEthSignMessage) throw new Error("WalletMiddleware - opts.processEthSignMessage not provided");
-    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, message]`);
-      const params = request.params;
-      const address = params[0];
-      const message = params[1];
-      msgParams = {
-        from: address,
-        data: message
-      };
+function createChainIdMiddleware(chainId) {
+  return (req, res, next, end) => {
+    if (req.method === "eth_chainId") {
+      res.result = chainId;
+      return end();
     }
-    response.result = await processEthSignMessage(msgParams, request);
-  });
-}
-function createProcessTypedMessageV4({
-  processTypedMessageV4
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4) return next();
-    if (!processTypedMessageV4) throw new Error("WalletMiddleware - opts.processTypedMessageV4 is not provided");
-    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, typedData]`);
-      const params = request.params;
-      const address = params[0];
-      const message = params[1];
-      msgParams = {
-        from: address,
-        data: message
-      };
+    if (req.method === "net_version") {
+      // convert to decimal
+      res.result = Number.parseInt(chainId, 16).toString(10);
+      return end();
     }
-    response.result = await processTypedMessageV4(msgParams, request);
-  });
+    return next();
+  };
 }
-function createProcessPersonalMessage({
-  processPersonalMessage
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.PERSONAL_SIGN) return next();
-    if (!processPersonalMessage) throw new Error("WalletMiddleware - opts.processPersonalMessage is not provided");
-    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length >= 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [message, address]`);
-      const params = request.params;
-      if (typeof params[0] === "object") {
-        const {
-          challenge,
-          address
-        } = params[0];
-        msgParams = {
-          from: address,
-          data: challenge
-        };
-      } else {
-        const message = params[0];
-        const address = params[1];
-        msgParams = {
-          from: address,
-          data: message
-        };
-      }
+function createProviderConfigMiddleware(providerConfig) {
+  return (req, res, next, end) => {
+    if (req.method === "eth_provider_config") {
+      res.result = providerConfig;
+      return end();
     }
-    response.result = await processPersonalMessage(msgParams, request);
-  });
-}
-function createPendingNonceMiddleware({
-  getPendingNonce
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      params,
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_GET_TRANSACTION_COUNT) return next();
-    const {
-      blockReference
-    } = params;
-    if (blockReference !== "pending") return next();
-    response.result = await getPendingNonce(params, request);
-  });
+    return next();
+  };
 }
-function formatTxMetaForRpcResult(txMeta) {
-  const {
-    r,
-    s,
-    v,
-    txReceipt,
-    transaction,
-    transactionHash,
-    accessList
-  } = txMeta;
+function createJsonRpcClient(providerConfig, networkConfig) {
   const {
-    to,
-    data,
-    nonce,
-    gas,
-    from,
-    value,
-    gasPrice,
-    maxFeePerGas,
-    maxPriorityFeePerGas
-  } = transaction;
-  const formattedTxMeta = {
-    v,
-    r,
-    s,
-    to,
-    gas,
-    from,
-    hash: transactionHash,
-    nonce,
-    input: data || "0x",
-    value: value || "0x0",
-    accessList: accessList || null,
-    blockHash: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockHash) || null,
-    blockNumber: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockNumber) || null,
-    transactionIndex: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.transactionIndex) || null,
-    type: null
+    chainId,
+    rpcTarget
+  } = providerConfig;
+  const fetchMiddleware = createFetchMiddleware({
+    rpcTarget
+  });
+  const blockProvider = providerFromMiddleware(fetchMiddleware);
+  const blockTracker = new PollingBlockTracker({
+    config: _objectSpread(_objectSpread({}, networkConfig), {}, {
+      provider: blockProvider
+    }),
+    state: {}
+  });
+  const networkMiddleware = mergeMiddleware([createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig),
+  // No need for the following middlewares for web because all browser sessions are quite short lived and each session is limited to scope of a window/tab
+  // createBlockRefRewriteMiddleware({ blockTracker }),
+  // createBlockCacheMiddleware({ blockTracker }),
+  createInflightCacheMiddleware({
+    cacheIdentifierForRequest
+  }),
+  // createBlockTrackerInspectorMiddleware({ blockTracker }),
+  fetchMiddleware]);
+  return {
+    networkMiddleware,
+    blockTracker
   };
-  if (maxFeePerGas && maxPriorityFeePerGas) {
-    formattedTxMeta.maxFeePerGas = maxFeePerGas;
-    formattedTxMeta.maxPriorityFeePerGas = maxPriorityFeePerGas;
-    formattedTxMeta.type = TRANSACTION_ENVELOPE_TYPES.FEE_MARKET;
-  } else {
-    formattedTxMeta.gasPrice = gasPrice;
-    formattedTxMeta.type = TRANSACTION_ENVELOPE_TYPES.LEGACY;
+}
+
+const _excluded = ["chainId", "rpcTarget"];
+class NetworkController extends BaseController {
+  constructor({
+    config,
+    state
+  }) {
+    super({
+      config,
+      state
+    });
+    _defineProperty(this, "name", "NetworkController");
+    _defineProperty(this, "providerProxy", void 0);
+    _defineProperty(this, "blockTrackerProxy", void 0);
+    _defineProperty(this, "mutex", new Mutex());
+    _defineProperty(this, "provider", null);
+    _defineProperty(this, "blockTracker", null);
+    _defineProperty(this, "baseProviderHandlers", void 0);
+    this.defaultState = {
+      chainId: "loading",
+      properties: {
+        EIPS_1559: undefined
+      },
+      providerConfig: SUPPORTED_NETWORKS[MAINNET_CHAIN_ID]
+    };
+
+    // when a new network is set,
+    // we set to loading first and
+    // then when connection succeeds,
+    // we update the network
+    this.initialize();
+  }
+  getNetworkIdentifier() {
+    return this.state.chainId;
+  }
+  getNetworkRPCUrl() {
+    return this.state.providerConfig.rpcTarget;
+  }
+
+  /**
+   * Called by orchestrator once while initializing the class
+   * @param providerHandlers - JRPC handlers for provider
+   * @returns - provider - Returns the providerProxy
+   */
+  initializeProvider(providerHandlers) {
+    this.baseProviderHandlers = providerHandlers;
+    this.configureProvider();
+    this.lookupNetwork(); // Not awaiting this, because we don't want to block the initialization
+    return this.providerProxy;
   }
-  return formattedTxMeta;
-}
-function createPendingTxMiddleware({
-  getPendingTransactionByHash
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
+  getProvider() {
+    return this.providerProxy;
+  }
+  getBlockTracker() {
+    return this.blockTrackerProxy;
+  }
+  getProviderConfig() {
+    return this.state.providerConfig;
+  }
+  setProviderConfig(config) {
+    this.update({
+      providerConfig: _objectSpread({}, config)
+    });
+    this.refreshNetwork();
+  }
+  async getEIP1559Compatibility() {
     const {
-      params,
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_GET_TRANSACTION_BY_HASH) return next();
-    if (!getPendingTransactionByHash) throw new Error("WalletMiddleware - opts.getPendingTransactionByHash not provided");
-    const txMeta = await getPendingTransactionByHash(params, request);
-    if (!txMeta) {
-      return next();
+      EIPS_1559
+    } = this.state.properties;
+    // log.info('checking eip 1559 compatibility')
+    if (EIPS_1559 !== undefined) {
+      return EIPS_1559;
     }
-    response.result = formatTxMetaForRpcResult(txMeta);
-    return undefined;
-  });
-}
-function createProcessSwitchEthereumChain({
-  processSwitchEthereumChain
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
+    const latestBlock = await this.blockTracker.getLatestBlock();
+    const supportsEIP1559 = latestBlock && latestBlock.baseFeePerGas !== undefined;
+    this.update({
+      properties: {
+        EIPS_1559: supportsEIP1559
+      }
+    });
+    return supportsEIP1559;
+  }
+
+  /**
+   * Refreshes the current network code
+   */
+  async lookupNetwork() {
     const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.SWITCH_CHAIN) return next();
-    if (!processSwitchEthereumChain) throw new Error("WalletMiddleware - opts.processSwitchEthereumChain not provided");
-    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
-      const [message] = request.params;
-      msgParams = message;
+      chainId,
+      rpcTarget
+    } = this.getProviderConfig();
+    if (!chainId || !rpcTarget || !this.provider) {
+      this.update({
+        chainId: "loading",
+        properties: {}
+      });
+      return;
     }
-    response.result = await processSwitchEthereumChain(msgParams, request);
-  });
-}
-function createProcessAddEthereumChain({
-  processAddEthereumChain
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ADD_CHAIN) return next();
-    if (!processAddEthereumChain) throw new Error("WalletMiddleware - opts.processAddEthereumChain not provided");
-    if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
-      const [message] = request.params;
-      msgParams = message;
+    const releaseLock = await this.mutex.acquire();
+    try {
+      // use eth_chainId
+      const [networkChainId] = await Promise.all([this.provider.request({
+        method: "eth_chainId"
+      }), this.getEIP1559Compatibility()]);
+      log.info("network fetched chain id", networkChainId);
+      // update chain ID
+      this.update({
+        chainId: networkChainId
+      });
+      this.emit("networkDidChange");
+    } catch {
+      this.update({
+        chainId: "loading"
+      });
+    } finally {
+      releaseLock();
+    }
+  }
+  configureProvider() {
+    const _this$getProviderConf = this.getProviderConfig(),
+      {
+        chainId,
+        rpcTarget
+      } = _this$getProviderConf,
+      rest = _objectWithoutProperties(_this$getProviderConf, _excluded);
+    if (!chainId || !rpcTarget) {
+      throw new Error("chainId and rpcTarget must be provider in providerConfig");
+    }
+    this.configureStandardProvider(_objectSpread({
+      chainId,
+      rpcTarget
+    }, rest));
+  }
+  setNetworkClient({
+    networkMiddleware,
+    blockTracker
+  }) {
+    const ethereumMiddleware = createEthereumMiddleware(this.baseProviderHandlers);
+    const engine = new JRPCEngine();
+    engine.push(ethereumMiddleware);
+    engine.push(networkMiddleware);
+    const provider = providerFromEngine(engine);
+    this.setProvider({
+      provider,
+      blockTracker
+    });
+  }
+  setProvider({
+    provider,
+    blockTracker
+  }) {
+    if (this.providerProxy) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      this.providerProxy.setTarget(provider);
+    } else {
+      this.providerProxy = createSwappableProxy(provider);
+    }
+    if (this.blockTrackerProxy) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      this.blockTrackerProxy.setTarget(blockTracker);
+    } else {
+      this.blockTrackerProxy = createEventEmitterProxy(blockTracker, {
+        eventFilter: "skipInternal"
+      });
     }
-    response.result = await processAddEthereumChain(msgParams, request);
-  });
-}
-function createRequestAccountsMiddleware({
-  requestAccounts
-}) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== "eth_requestAccounts") return next();
-    if (!requestAccounts) throw new Error("WalletMiddleware - opts.requestAccounts not provided");
-    // This calls the UI login function
-    const accounts = await requestAccounts(request);
-    response.result = accounts;
-    return undefined;
-  });
-}
-function createEthereumMiddleware(providerHandlers) {
-  const {
-    requestAccounts,
-    getAccounts,
-    processTransaction,
-    processEthSignMessage,
-    processTypedMessageV4,
-    processPersonalMessage,
-    getPendingNonce,
-    getPendingTransactionByHash,
-    processSwitchEthereumChain,
-    processAddEthereumChain,
-    getProviderState,
-    version
-  } = providerHandlers;
-  return mergeMiddleware([createScaffoldMiddleware({
-    version,
-    [PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: getProviderState
-  }), createRequestAccountsMiddleware({
-    requestAccounts
-  }), createGetAccountsMiddleware({
-    getAccounts
-  }), createProcessTransactionMiddleware({
-    processTransaction
-  }), createProcessEthSignMessage({
-    processEthSignMessage
-  }), createProcessTypedMessageV4({
-    processTypedMessageV4
-  }), createProcessPersonalMessage({
-    processPersonalMessage
-  }), createPendingNonceMiddleware({
-    getPendingNonce
-  }), createPendingTxMiddleware({
-    getPendingTransactionByHash
-  }), createProcessSwitchEthereumChain({
-    processSwitchEthereumChain
-  }), createProcessAddEthereumChain({
-    processAddEthereumChain
-  })]);
-}
 
-let CacheStrategy = /*#__PURE__*/function (CacheStrategy) {
-  CacheStrategy["Block"] = "block";
-  CacheStrategy["Fork"] = "fork";
-  CacheStrategy["Never"] = "never";
-  CacheStrategy["Permanent"] = "perma";
-  return CacheStrategy;
-}({});
-function blockTagParamIndex(method) {
-  switch (method) {
-    // blockTag is at index 2
-    case "eth_getStorageAt":
-      return 2;
-    // blockTag is at index 1
-    case "eth_getBalance":
-    case "eth_getCode":
-    case "eth_getTransactionCount":
-    case "eth_call":
-      return 1;
-    // blockTag is at index 0
-    case "eth_getBlockByNumber":
-      return 0;
-    // there is no blockTag
-    default:
-      return undefined;
+    // set new provider and blockTracker
+    this.provider = provider;
+    provider.setMaxListeners(10);
+    this.blockTracker = blockTracker;
+  }
+  configureStandardProvider(providerConfig) {
+    const networkClient = createJsonRpcClient(providerConfig, this.config);
+    log.info("networkClient", networkClient);
+    this.setNetworkClient(networkClient);
+  }
+  refreshNetwork() {
+    this.update({
+      chainId: "loading",
+      properties: {}
+    });
+    this.configureProvider();
+    this.lookupNetwork();
   }
 }
-function cacheTypeForMethod(method) {
-  switch (method) {
-    // cache permanently
-    case "web3_clientVersion":
-    case "web3_sha3":
-    case "eth_protocolVersion":
-    case "eth_getBlockTransactionCountByHash":
-    case "eth_getUncleCountByBlockHash":
-    case "eth_getCode":
-    case "eth_getBlockByHash":
-    case "eth_getTransactionByHash":
-    case "eth_getTransactionByBlockHashAndIndex":
-    case "eth_getTransactionReceipt":
-    case "eth_getUncleByBlockHashAndIndex":
-    case "eth_getCompilers":
-    case "eth_compileLLL":
-    case "eth_compileSolidity":
-    case "eth_compileSerpent":
-    case "shh_version":
-    case "test_permaCache":
-      return CacheStrategy.Permanent;
-
-    // cache until fork
-    case "eth_getBlockByNumber":
-    case "eth_getBlockTransactionCountByNumber":
-    case "eth_getUncleCountByBlockNumber":
-    case "eth_getTransactionByBlockNumberAndIndex":
-    case "eth_getUncleByBlockNumberAndIndex":
-    case "test_forkCache":
-      return CacheStrategy.Fork;
 
-    // cache for block
-    case "eth_gasPrice":
-    case "eth_blockNumber":
-    case "eth_getBalance":
-    case "eth_getStorageAt":
-    case "eth_getTransactionCount":
-    case "eth_call":
-    case "eth_estimateGas":
-    case "eth_getFilterLogs":
-    case "eth_getLogs":
-    case "test_blockCache":
-      return CacheStrategy.Block;
+const erc20Interface = new Interface(erc20Abi);
+const erc721Interface = new Interface(erc721Abi);
+const erc1155Interface = new Interface(erc1155Abi);
 
-    // never cache
-    default:
-      return CacheStrategy.Never;
-  }
-}
-function canCache(method) {
-  return cacheTypeForMethod(method) !== CacheStrategy.Never;
-}
-function paramsWithoutBlockTag(request) {
-  if (!request.params) {
-    return [];
-  }
-  const index = blockTagParamIndex(request.method);
+// functions that handle normalizing of that key in txParams
 
-  // Block tag param not passed.
-  if (index === undefined || !Array.isArray(request.params) || index >= request.params.length) {
-    return request.params;
-  }
+const normalizers = {
+  from: (from, LowerCase = true) => LowerCase ? addHexPrefix(from).toLowerCase() : addHexPrefix(from),
+  to: (to, LowerCase = true) => 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
+};
 
-  // eth_getBlockByNumber has the block tag first, then the optional includeTx? param
-  if (request.method === "eth_getBlockByNumber") {
-    return request.params.slice(1);
+/**
+ * normalizes txParams
+ */
+function normalizeTxParameters(txParameters, lowerCase = 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);
   }
-  return request.params.slice(0, index);
+  return normalizedTxParameters;
 }
-function cacheIdentifierForRequest(request, skipBlockRef) {
-  var _request$params;
-  const simpleParams = skipBlockRef ? paramsWithoutBlockTag(request) : (_request$params = request.params) !== null && _request$params !== void 0 ? _request$params : [];
-  if (canCache(request.method)) {
-    return `${request.method}:${stringify(simpleParams)}`;
+function transactionMatchesNetwork(transaction, chainId) {
+  if (typeof transaction.chainId !== "undefined") {
+    return transaction.chainId === chainId;
   }
-  return null;
+  return false;
 }
 
-function createChainIdMiddleware(chainId) {
-  return (req, res, next, end) => {
-    if (req.method === "eth_chainId") {
-      res.result = chainId;
-      return end();
-    }
-    if (req.method === "net_version") {
-      // convert to decimal
-      res.result = Number.parseInt(chainId, 16).toString(10);
-      return end();
-    }
-    return next();
-  };
+/**
+ * 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$1(addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact = transaction.transaction) === null || _transaction$transact === void 0 ? void 0 : _transaction$transact.maxFeePerGas)) && isHexString$1(addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact2 = transaction.transaction) === null || _transaction$transact2 === void 0 ? void 0 : _transaction$transact2.maxPriorityFeePerGas));
 }
-function createProviderConfigMiddleware(providerConfig) {
-  return (req, res, next, end) => {
-    if (req.method === "eth_provider_config") {
-      res.result = providerConfig;
-      return end();
-    }
-    return next();
-  };
+
+/**
+ * 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$1(addHexPrefix(transaction.transaction.gasPrice)));
 }
-function createJsonRpcClient(providerConfig, networkConfig) {
-  const {
-    chainId,
-    rpcTarget
-  } = providerConfig;
-  const fetchMiddleware = createFetchMiddleware({
-    rpcTarget
-  });
-  const blockProvider = providerFromMiddleware(fetchMiddleware);
-  const blockTracker = new PollingBlockTracker({
-    config: _objectSpread(_objectSpread({}, networkConfig), {}, {
-      provider: blockProvider
-    }),
-    state: {}
-  });
-  const networkMiddleware = mergeMiddleware([createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig),
-  // No need for the following middlewares for web because all browser sessions are quite short lived and each session is limited to scope of a window/tab
-  // createBlockRefRewriteMiddleware({ blockTracker }),
-  // createBlockCacheMiddleware({ blockTracker }),
-  createInflightCacheMiddleware({
-    cacheIdentifierForRequest
-  }),
-  // createBlockTrackerInspectorMiddleware({ blockTracker }),
-  fetchMiddleware]);
-  return {
-    networkMiddleware,
-    blockTracker
-  };
+
+/**
+ * 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`);
+  }
 }
 
-const _excluded = ["chainId", "rpcTarget"];
-class NetworkController extends BaseController {
-  constructor({
-    config,
-    state
-  }) {
-    super({
-      config,
-      state
-    });
-    _defineProperty(this, "name", "NetworkController");
-    _defineProperty(this, "providerProxy", void 0);
-    _defineProperty(this, "blockTrackerProxy", void 0);
-    _defineProperty(this, "mutex", new Mutex());
-    _defineProperty(this, "provider", null);
-    _defineProperty(this, "blockTracker", null);
-    _defineProperty(this, "baseProviderHandlers", void 0);
-    this.defaultState = {
-      chainId: "loading",
-      properties: {
-        EIPS_1559: undefined
-      },
-      providerConfig: SUPPORTED_NETWORKS[MAINNET_CHAIN_ID]
-    };
+/**
+ * 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]})`);
+  }
+}
 
-    // when a new network is set,
-    // we set to loading first and
-    // then when connection succeeds,
-    // we update the network
-    this.initialize();
+/**
+ * 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");
+      }
   }
-  getNetworkIdentifier() {
-    return this.state.chainId;
+}
+
+/**
+ * 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.`);
   }
-  getNetworkRPCUrl() {
-    return this.state.providerConfig.rpcTarget;
+  if (!isValidAddress(txParams.from)) {
+    throw rpcErrors.invalidParams('Invalid "from" address.');
   }
+}
 
-  /**
-   * Called by orchestrator once while initializing the class
-   * @param providerHandlers - JRPC handlers for provider
-   * @returns - provider - Returns the providerProxy
-   */
-  initializeProvider(providerHandlers) {
-    this.baseProviderHandlers = providerHandlers;
-    this.configureProvider();
-    this.lookupNetwork(); // Not awaiting this, because we don't want to block the initialization
-    return this.providerProxy;
-  }
-  getProvider() {
-    return this.providerProxy;
+/**
+ * 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.');
+    }
+  } else if (txParameters.to !== undefined && !isValidAddress(txParameters.to)) {
+    throw rpcErrors.invalidParams('Invalid "to" address.');
   }
-  getBlockTracker() {
-    return this.blockTrackerProxy;
+  return txParameters;
+}
+
+/**
+ * Validates the given tx parameters
+ * @throws if the tx params contains invalid fields
+ */
+function validateTxParameters(txParams, eip1559Compatibility = true) {
+  if (!txParams || typeof txParams !== "object" || Array.isArray(txParams)) {
+    throw rpcErrors.invalidParams("Invalid transaction params: must be an object.");
   }
-  getProviderConfig() {
-    return this.state.providerConfig;
+  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.');
   }
-  setProviderConfig(config) {
-    this.update({
-      providerConfig: _objectSpread({}, config)
-    });
-    this.refreshNetwork();
+  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");
   }
-  async getEIP1559Compatibility() {
-    const {
-      EIPS_1559
-    } = this.state.properties;
-    // log.info('checking eip 1559 compatibility')
-    if (EIPS_1559 !== undefined) {
-      return EIPS_1559;
+  Object.entries(txParams).forEach(([key, value]) => {
+    // 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);
     }
-    const latestBlock = await this.blockTracker.getLatestBlock();
-    const supportsEIP1559 = latestBlock && latestBlock.baseFeePerGas !== undefined;
-    this.update({
-      properties: {
-        EIPS_1559: supportsEIP1559
-      }
+  });
+}
+function normalizeAndValidateTxParams(txParams, lowerCase = 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
     });
-    return supportsEIP1559;
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: CONTRACT_TYPE_ERC20
+    };
+  } catch {
+    // ignore and next try to parse with erc721 ABI
   }
-
-  /**
-   * Refreshes the current network code
-   */
-  async lookupNetwork() {
-    const {
-      chainId,
-      rpcTarget
-    } = this.getProviderConfig();
-    if (!chainId || !rpcTarget || !this.provider) {
-      this.update({
-        chainId: "loading",
-        properties: {}
-      });
-      return;
-    }
-    const releaseLock = await this.mutex.acquire();
-    try {
-      // use eth_chainId
-      const [networkChainId] = await Promise.all([this.provider.request({
-        method: "eth_chainId"
-      }), this.getEIP1559Compatibility()]);
-      log.info("network fetched chain id", networkChainId);
-      // update chain ID
-      this.update({
-        chainId: networkChainId
-      });
-      this.emit("networkDidChange");
-    } catch {
-      this.update({
-        chainId: "loading"
-      });
-    } finally {
-      releaseLock();
-    }
+  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
   }
-  configureProvider() {
-    const _this$getProviderConf = this.getProviderConfig(),
-      {
-        chainId,
-        rpcTarget
-      } = _this$getProviderConf,
-      rest = _objectWithoutProperties(_this$getProviderConf, _excluded);
-    if (!chainId || !rpcTarget) {
-      throw new Error("chainId and rpcTarget must be provider in providerConfig");
-    }
-    this.configureStandardProvider(_objectSpread({
-      chainId,
-      rpcTarget
-    }, rest));
+  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
   }
-  setNetworkClient({
-    networkMiddleware,
-    blockTracker
-  }) {
-    const ethereumMiddleware = createEthereumMiddleware(this.baseProviderHandlers);
-    const engine = new JRPCEngine();
-    engine.push(ethereumMiddleware);
-    engine.push(networkMiddleware);
-    const provider = providerFromEngine(engine);
-    this.setProvider({
-      provider,
-      blockTracker
+  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);
   }
-  setProvider({
-    provider,
-    blockTracker
-  }) {
-    if (this.providerProxy) {
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      this.providerProxy.setTarget(provider);
-    } else {
-      this.providerProxy = createSwappableProxy(provider);
-    }
-    if (this.blockTrackerProxy) {
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      this.blockTrackerProxy.setTarget(blockTracker);
-    } else {
-      this.blockTrackerProxy = createEventEmitterProxy(blockTracker, {
-        eventFilter: "skipInternal"
+  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
+  };
+}
 
-    // set new provider and blockTracker
-    this.provider = provider;
-    provider.setMaxListeners(10);
-    this.blockTracker = blockTracker;
+function hexToBn(hex) {
+  return new BigNumber(stripHexPrefix(hex), 16);
+}
+function BNToHex(bn) {
+  return addHexPrefix(bn.toString(16));
+}
+function getEtherScanHashLink(txHash, chainId) {
+  if (!SUPPORTED_NETWORKS[chainId]) return "";
+  return `${SUPPORTED_NETWORKS[chainId].blockExplorerUrl}/tx/${txHash}`;
+}
+const formatPastTx = params => {
+  var _transaction$to;
+  const {
+    transaction,
+    lowerCaseSelectedAddress,
+    blockExplorerUrl
+  } = params;
+  let totalAmountString = "";
+  if (transaction.type === CONTRACT_TYPE_ERC721 || transaction.type === CONTRACT_TYPE_ERC1155) totalAmountString = transaction.symbol;else if (transaction.type === CONTRACT_TYPE_ERC20) totalAmountString = formatSmallNumbers(Number.parseFloat(transaction.total_amount), transaction.symbol, true);else totalAmountString = formatSmallNumbers(Number.parseFloat(transaction.total_amount), transaction.type_name, true);
+  const currencyAmountString = transaction.type === CONTRACT_TYPE_ERC721 || transaction.type === CONTRACT_TYPE_ERC1155 || transaction.isEtherscan ? "" : formatSmallNumbers(Number.parseFloat(transaction.currency_amount), transaction.selected_currency, true);
+  const finalObject = {
+    id: transaction.created_at.toString(),
+    date: new Date(transaction.created_at).toString(),
+    from: transaction.from,
+    from_aa_address: transaction.from_aa_address,
+    slicedFrom: typeof transaction.from === "string" ? addressSlicer(transaction.from) : "",
+    to: transaction.to,
+    slicedTo: typeof transaction.to === "string" ? addressSlicer(transaction.to) : "",
+    action: lowerCaseSelectedAddress === ((_transaction$to = transaction.to) === null || _transaction$to === void 0 ? void 0 : _transaction$to.toLowerCase()) || "" ? ACTIVITY_ACTION_RECEIVE : ACTIVITY_ACTION_SEND,
+    totalAmount: transaction.total_amount,
+    totalAmountString,
+    currencyAmount: transaction.currency_amount,
+    currencyAmountString,
+    amount: `${totalAmountString} / ${currencyAmountString}`,
+    status: transaction.status,
+    etherscanLink: blockExplorerUrl ? `${blockExplorerUrl}/tx/${transaction.transaction_hash}` : "",
+    chainId: transaction.chain_id,
+    ethRate: Number.parseFloat(transaction === null || transaction === void 0 ? void 0 : transaction.total_amount) && Number.parseFloat(transaction === null || transaction === void 0 ? void 0 : transaction.currency_amount) ? `1 ${transaction.symbol} = ${significantDigits(Number.parseFloat(transaction.currency_amount) / Number.parseFloat(transaction.total_amount))}` : "",
+    currencyUsed: transaction.selected_currency,
+    type: transaction.type,
+    type_name: transaction.type_name,
+    type_image_link: transaction.type_image_link,
+    transaction_hash: transaction.transaction_hash,
+    transaction_category: transaction.transaction_category,
+    isEtherscan: transaction.isEtherscan,
+    input: transaction.input || "",
+    token_id: transaction.token_id || "",
+    contract_address: transaction.contract_address || "",
+    nonce: transaction.nonce || "",
+    is_cancel: !!transaction.is_cancel || false,
+    gas: transaction.gas || "",
+    gasPrice: transaction.gasPrice || ""
+  };
+  return finalObject;
+};
+
+/**
+ * Ref - https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt
+ */
+const getEthTxStatus = async (hash, provider) => {
+  try {
+    const result = await provider.request({
+      method: 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;
   }
-  configureStandardProvider(providerConfig) {
-    const networkClient = createJsonRpcClient(providerConfig, this.config);
-    log.info("networkClient", networkClient);
-    this.setNetworkClient(networkClient);
+};
+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);
+}
+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;
   }
-  refreshNetwork() {
-    this.update({
-      chainId: "loading",
-      properties: {}
-    });
-    this.configureProvider();
-    this.lookupNetwork();
+  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 params => {
+  const {
+    txn,
+    lowerCaseSelectedAddress,
+    provider,
+    chainId,
+    blockExplorerUrl
+  } = params;
+  const transactionPromises = await Promise.all(txn.map(async tx => {
+    var _SUPPORTED_NETWORKS$c, _SUPPORTED_NETWORKS$c2;
+    const {
+      category,
+      type
+    } = await 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;
+    let totalAmountString = x.value ? new BigNumber(x.value).div(new BigNumber(10).pow(new BigNumber(x.tokenDecimal || 18))).toString() : "";
+    let type = CONTRACT_TYPE_ETH;
+    if (x.contractAddress !== "") {
+      if (x.tokenID) {
+        type = x.tokenValue ? CONTRACT_TYPE_ERC1155 : CONTRACT_TYPE_ERC721;
+      } else {
+        type = CONTRACT_TYPE_ERC20;
+      }
+    }
+    if (type === CONTRACT_TYPE_ERC1155) {
+      totalAmountString = x.tokenValue;
+    }
+    const etherscanTransaction = {
+      type,
+      type_image_link: x.type_image_link || "n/a",
+      type_name: x.tokenName || ((_SUPPORTED_NETWORKS$c3 = SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c3 === void 0 ? void 0 : _SUPPORTED_NETWORKS$c3.ticker) || "n/a",
+      symbol: x.tokenSymbol || ((_SUPPORTED_NETWORKS$c4 = SUPPORTED_NETWORKS[chainId]) === null || _SUPPORTED_NETWORKS$c4 === void 0 ? void 0 : _SUPPORTED_NETWORKS$c4.ticker),
+      token_id: x.tokenID || "",
+      total_amount: totalAmountString,
+      created_at: new Date(Number(x.timeStamp) * 1000),
+      from: x.from,
+      to: x.to,
+      transaction_hash: x.hash,
+      status: x.txreceipt_status && x.txreceipt_status === "0" ? TransactionStatus.failed : TransactionStatus.confirmed,
+      isEtherscan: true,
+      input: x.input,
+      contract_address: x.contractAddress,
+      transaction_category: x.transaction_category,
+      gas: `0x${new BigNumber(x.gasUsed || 0, 10).toString(16)}`,
+      gasPrice: `0x${new BigNumber(x.gasPrice || 0, 10).toString(16)}`,
+      chain_id: chainId,
+      currency_amount: "",
+      nonce: x.nonce,
+      from_aa_address: "",
+      is_cancel: false,
+      selected_currency: ""
+    };
+    accumulator.push(formatPastTx({
+      transaction: etherscanTransaction,
+      lowerCaseSelectedAddress,
+      blockExplorerUrl
+    }));
+    return accumulator;
+  }, []);
+  return finalTxs;
+};
 
 class NftHandler {
   constructor({
@@ -3943,8 +4120,13 @@ class PreferencesController extends BasePreferencesController {
       web3AuthClientId,
       web3AuthNetwork,
       loginMode,
-      sessionPubKey
+      sessionPubKey,
+      aaProvider,
+      eoaAddress
     } = params;
+    const {
+      chainId
+    } = this.getProviderConfig();
     await super.init({
       address,
       userInfo,
@@ -3953,7 +4135,10 @@ class PreferencesController extends BasePreferencesController {
       metadata: {
         email: userInfo.email,
         signatures,
-        network: web3AuthNetwork
+        network: web3AuthNetwork,
+        eoa_address: eoaAddress,
+        aa_provider: aaProvider,
+        chain_id: chainId
       }
     });
     const {
@@ -3972,9 +4157,17 @@ class PreferencesController extends BasePreferencesController {
         locale,
         address,
         type,
-        web3AuthNetwork
+        web3AuthNetwork,
+        metadata: {
+          aa_provider: aaProvider,
+          chain_id: chainId,
+          eoa_address: eoaAddress
+        }
       });
     }
+    if (eoaAddress) this.updateState({
+      eoaAddress
+    }, address);
     this.storeUserLogin({
       verifier: aggregateVerifier || verifier,
       verifierId,
@@ -4971,6 +5164,7 @@ class PendingTransactionTracker extends SafeEventEmitter {
     }
   }
   async _resubmitTx(txMeta, latestBlockNumber) {
+    if (txMeta.userOpHash) return;
     if (!txMeta.firstRetryBlockNumber) {
       this.emit(TX_EVENTS.TX_BLOCK_UPDATE, {
         txMeta,
@@ -5005,7 +5199,7 @@ class PendingTransactionTracker extends SafeEventEmitter {
     const txId = txMeta.id;
 
     // Only check submitted txs
-    if (txMeta.status !== TransactionStatus.submitted) return;
+    if (txMeta.status !== TransactionStatus.submitted || txMeta.isUserOperation) return;
 
     // extra check in case there was an uncaught error during the
     // signature and submission process
@@ -5989,4 +6183,4 @@ class TransactionController extends TransactionStateManager {
   }
 }
 
-export { ARBITRUM_MAINNET_CHAIN_ID, ARBITRUM_TESTNET_CHAIN_ID, AVALANCHE_MAINNET_CHAIN_ID, AVALANCHE_TESTNET_CHAIN_ID, AbstractMessageController, AccountTrackerController, AddChainController, BASE_CHAIN_ID, BASE_TESTNET_CHAIN_ID, BNToHex, 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, ERC1155_INTERFACE_ID, ERC721_ENUMERABLE_INTERFACE_ID, ERC721_INTERFACE_ID, ERC721_METADATA_INTERFACE_ID, ETHERSCAN_SUPPORTED_CHAINS, 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_AMOY_CHAIN_ID, POLYGON_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, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessageV4, createProviderConfigMiddleware, createRequestAccountsMiddleware, decGWEIToHexWEI, determineTransactionType, ensureFieldIsString, ensureMutuallyExclusiveFieldsNotProvided, erc1155Abi, erc20Abi, erc721Abi, formatDate, formatPastTx, formatTime, formatTxMetaForRpcResult, generateHistoryEntry, getBigNumber, getChainType, getEthTxStatus, getEtherScanHashLink, getFinalStates, getIpfsEndpoint, hexToBn, hexWEIToDecGWEI, idleTimeTracker, isAddressByChainId, isEIP1559Transaction, isLegacyTransaction, multiplyCurrencies, normalizeAndValidateTxParams, normalizeMessageData, normalizeTxParameters, parseStandardTokenTransactionData, readAddressAsContract, replayHistory, sanitizeNftMetdataUrl, singleBalanceCheckerAbi, snapshotFromTxMeta, subtractCurrencies, toChecksumAddressByChainId, toNegative, transactionMatchesNetwork, validateAddChainData, validateAddress, validateFrom, validateRecipient, validateSignMessageData, validateSwitchChainData, validateTxParameters, validateTypedSignMessageDataV4 };
+export { ARBITRUM_MAINNET_CHAIN_ID, ARBITRUM_TESTNET_CHAIN_ID, AVALANCHE_MAINNET_CHAIN_ID, AVALANCHE_TESTNET_CHAIN_ID, AccountAbstractionController, AccountTrackerController, AddChainController, BASE_CHAIN_ID, BASE_TESTNET_CHAIN_ID, BNToHex, BSC_MAINNET_CHAIN_ID, BSC_TESTNET_CHAIN_ID, BiconomySmartAccount, 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, ERC1155_INTERFACE_ID, ERC721_ENUMERABLE_INTERFACE_ID, ERC721_INTERFACE_ID, ERC721_METADATA_INTERFACE_ID, ETHERSCAN_SUPPORTED_CHAINS, GAS_ESTIMATE_TYPES, GAS_LIMITS, GasFeeController, KernelSmartAccount, KeyringController, LOCALHOST, MAINNET_CHAIN_ID, METHOD_TYPES, MessageController, NetworkController, NexusSmartAccount, NftHandler, NftsController, NonceTracker, OLD_ERC721_LIST, OPTIMISM_MAINNET_CHAIN_ID, OPTIMISM_TESTNET_CHAIN_ID, POLYGON_AMOY_CHAIN_ID, POLYGON_CHAIN_ID, PendingTransactionTracker, PersonalMessageController, PollingBlockTracker, PreferencesController, SEPOLIA_CHAIN_ID, SIMPLEHASH_SUPPORTED_CHAINS, SMART_ACCOUNT, SUPPORTED_NETWORKS, SafeSmartAccount, SwitchChainController, TEST_CHAINS, TRANSACTION_ENVELOPE_TYPES, TokenHandler, TokenRatesController, TokensController, TransactionController, TransactionGasUtil, TransactionStateManager, TrustSmartAccount, TypedMessageController, XDAI_CHAIN_ID, addCurrencies, addEtherscanTransactions, bnLessThan, conversionGTE, conversionGreaterThan, conversionLTE, conversionLessThan, conversionMax, conversionUtil, createChainIdMiddleware, createEthereumMiddleware, createGetAccountsMiddleware, createJsonRpcClient, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessageV4, createProviderConfigMiddleware, createRequestAccountsMiddleware, decGWEIToHexWEI, determineTransactionType, ensureFieldIsString, ensureMutuallyExclusiveFieldsNotProvided, eoaInterceptorMiddleware, eoaProviderAsMiddleware, erc1155Abi, erc20Abi, erc721Abi, formatDate, formatPastTx, formatTime, formatTxMetaForRpcResult, generateHistoryEntry, getBigNumber, getChainType, getEthTxStatus, getEtherScanHashLink, getFinalStates, getIpfsEndpoint, hexToBn, hexWEIToDecGWEI, isAddressByChainId, isEIP1559Transaction, isLegacyTransaction, multiplyCurrencies, normalizeAndValidateTxParams, normalizeMessageData, normalizeTxParameters, parseStandardTokenTransactionData, readAddressAsContract, replayHistory, sanitizeNftMetdataUrl, singleBalanceCheckerAbi, snapshotFromTxMeta, subtractCurrencies, toChecksumAddressByChainId, toNegative, transactionMatchesNetwork, validateAddChainData, validateAddress, validateFrom, validateRecipient, validateSignMessageData, validateSwitchChainData, validateTxParameters, validateTypedSignMessageDataV4 };