@toruslabs/ethereum-controllers 5.10.1 → 6.0.0

package/dist/lib.cjs/Transaction/TransactionStateManager.js

@@ -0,0 +1,296 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var baseControllers = require('@toruslabs/base-controllers');
+var lodashUtils = require('../utils/lodashUtils.js');
+var TransactionStateHistoryHelper = require('./TransactionStateHistoryHelper.js');
+var TransactionUtils = require('./TransactionUtils.js');
+
+class TransactionStateManager extends baseControllers.BaseTransactionStateManager {
+  constructor({
+    config,
+    state,
+    getCurrentChainId
+  }) {
+    super({
+      config,
+      state,
+      getCurrentChainId
+    });
+  }
+  generateTxMeta(opts = {}) {
+    var _opts$transaction;
+    const chainId = this.getCurrentChainId();
+    if (chainId === "loading") throw new Error("Torus is having trouble connecting to the network");
+    let dappSuggestedGasFees = null;
+
+    // If we are dealing with a transaction suggested by a dapp and not
+    // an internally created transaction, we need to keep record of
+    // the originally submitted gasParams.
+    if (opts.transaction && typeof opts.origin === "string" && opts.origin !== "torus") {
+      if (typeof opts.transaction.gasPrice !== "undefined") {
+        dappSuggestedGasFees = {
+          gasPrice: opts.transaction.gasPrice
+        };
+      } else if (typeof opts.transaction.maxFeePerGas !== "undefined" || typeof opts.transaction.maxPriorityFeePerGas !== "undefined") {
+        dappSuggestedGasFees = {
+          maxPriorityFeePerGas: opts.transaction.maxPriorityFeePerGas,
+          maxFeePerGas: opts.transaction.maxFeePerGas
+        };
+      }
+      if (typeof opts.transaction.gas !== "undefined") {
+        dappSuggestedGasFees = _objectSpread(_objectSpread({}, dappSuggestedGasFees), {}, {
+          gas: opts.transaction.gas
+        });
+      }
+    }
+    return _objectSpread({
+      id: ((_opts$transaction = opts.transaction) === null || _opts$transaction === void 0 ? void 0 : _opts$transaction.id) || baseControllers.randomId(),
+      time: Date.now(),
+      status: baseControllers.TransactionStatus.unapproved,
+      loadingDefaults: true,
+      chainId,
+      dappSuggestedGasFees
+    }, opts);
+  }
+  addTransactionToState(txMeta) {
+    if (txMeta.transaction) {
+      txMeta.transaction = TransactionUtils.normalizeAndValidateTxParams(txMeta.transaction, false);
+    }
+    this.once(`${txMeta.id}:signed`, () => {
+      this.removeAllListeners(`${txMeta.id}:rejected`);
+    });
+    this.once(`${txMeta.id}:rejected`, () => {
+      this.removeAllListeners(`${txMeta.id}:signed`);
+    });
+    // initialize history
+    txMeta.history = [];
+    // capture initial snapshot of txMeta for history
+    const snapshot = TransactionStateHistoryHelper.snapshotFromTxMeta(txMeta);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    txMeta.history.push(snapshot);
+    const transactions = this.getTransactions({
+      filterToCurrentNetwork: false
+    });
+    const {
+      txHistoryLimit
+    } = this.config;
+
+    // checks if the length of the tx history is longer then desired persistence
+    // limit and then if it is removes the oldest confirmed or rejected tx.
+    // Pending or unapproved transactions will not be removed by this
+    // operation. For safety of presenting a fully functional transaction UI
+    // representation, this function will not break apart transactions with the
+    // same nonce, per network. Not accounting for transactions of the same
+    // nonce and network combo can result in confusing or broken experiences
+    // in the UI.
+    //
+    // we will send UI only collected groups of transactions *per page* so at
+    // some point in the future, this persistence limit can be adjusted. When
+    // we do that I think we should figure out a better storage solution for
+    // transaction history entries.
+    const nonceNetworkSet = new Set();
+    const txsToDelete = transactions.reverse().filter(tx => {
+      const {
+        nonce
+      } = tx.transaction;
+      const {
+        chainId,
+        status
+      } = tx;
+      const key = `${nonce}-${chainId}`;
+      if (nonceNetworkSet.has(key)) {
+        return false;
+      }
+      if (nonceNetworkSet.size < txHistoryLimit - 1 || TransactionUtils.getFinalStates().includes(status) === false) {
+        nonceNetworkSet.add(key);
+        return false;
+      }
+      return true;
+    }).map(tx => tx.id);
+    this._deleteTransactions(txsToDelete);
+    this._addTransactionsToState([txMeta]);
+    return txMeta;
+  }
+
+  /**
+    Removes transaction from the given address for the current network
+    from the txList
+  */
+  wipeTransactions(address) {
+    const {
+      transactions
+    } = this.state;
+    const chainId = this.getCurrentChainId();
+    this.update({
+      transactions: baseControllers.omitBy(transactions, txMeta => {
+        const transactionMatch = baseControllers.transactionMatchesNetwork(txMeta, chainId);
+        return txMeta.transaction.from === address && transactionMatch;
+      })
+    });
+  }
+  getTransactions({
+    searchCriteria = {},
+    initialList = undefined,
+    filterToCurrentNetwork = true,
+    limit = undefined
+  } = {}) {
+    const chainId = this.getCurrentChainId();
+    // searchCriteria is an object that might have values that aren't predicate
+    // methods. When providing any other value type (string, number, etc), we
+    // consider this shorthand for "check the value at key for strict equality
+    // with the provided value". To conform this object to be only methods, we
+    // mapValues (lodash) such that every value on the object is a method that
+    // returns a boolean.
+    const predicateMethods = lodashUtils.mapValues(searchCriteria, predicate => typeof predicate === "function" ? predicate : v => v === predicate);
+
+    // If an initial list is provided we need to change it back into an object
+    // first, so that it matches the shape of our state. This is done by the
+    // lodash keyBy method. This is the edge case for this method, typically
+    // initialList will be undefined.
+    const transactionsToFilter = initialList ? lodashUtils.keyBy(initialList, "id") : this.state.transactions;
+
+    // Combine sortBy and pickBy to transform our state object into an array of
+    // matching transactions that are sorted by time.
+    const filteredTransactions = lodashUtils.sortBy(Object.values(baseControllers.pickBy(transactionsToFilter, txMeta => {
+      // default matchesCriteria to the value of transactionMatchesNetwork
+      // when filterToCurrentNetwork is true.
+      const transactionMatches = baseControllers.transactionMatchesNetwork(txMeta, chainId);
+      if (filterToCurrentNetwork && !transactionMatches) {
+        return false;
+      }
+      // iterate over the predicateMethods keys to check if the transaction
+      // matches the searchCriteria
+      for (const [key, predicate] of Object.entries(predicateMethods)) {
+        // We return false early as soon as we know that one of the specified
+        // search criteria do not match the transaction. This prevents
+        // needlessly checking all criteria when we already know the criteria
+        // are not fully satisfied. We check both txParams and the base
+        // object as predicate keys can be either.
+        if (key in txMeta.transaction) {
+          if (predicate(txMeta.transaction[key]) === false) {
+            return false;
+          }
+        } else if (predicate(txMeta[key]) === false) {
+          return false;
+        }
+      }
+      return true;
+    })), "time");
+    if (limit !== undefined) {
+      // We need to have all transactions of a given nonce in order to display
+      // necessary details in the UI. We use the size of this set to determine
+      // whether we have reached the limit provided, thus ensuring that all
+      // transactions of nonces we include will be sent to the UI.
+      const nonces = new Set();
+      const txs = [];
+      // By default, the transaction list we filter from is sorted by time ASC.
+      // To ensure that filtered results prefers the newest transactions we
+      // iterate from right to left, inserting transactions into front of a new
+      // array. The original order is preserved, but we ensure that newest txs
+      // are preferred.
+      for (let i = filteredTransactions.length - 1; i > -1; i -= 1) {
+        const txMeta = filteredTransactions[i];
+        const {
+          nonce
+        } = txMeta.transaction;
+        if (!nonces.has(nonce)) {
+          if (nonces.size < limit) {
+            nonces.add(nonce);
+          } else {
+            continue;
+          }
+        }
+        // Push transaction into the beginning of our array to ensure the
+        // original order is preserved.
+        txs.unshift(txMeta);
+      }
+      return txs;
+    }
+    return filteredTransactions;
+  }
+  getApprovedTransactions(address) {
+    const searchCriteria = {
+      status: baseControllers.TransactionStatus.approved
+    };
+    if (address) {
+      searchCriteria.from = address;
+    }
+    return this.getTransactions({
+      searchCriteria
+    });
+  }
+  getSubmittedTransactions(address) {
+    const searchCriteria = {
+      status: baseControllers.TransactionStatus.submitted
+    };
+    if (address) {
+      searchCriteria.from = address;
+    }
+    return this.getTransactions({
+      searchCriteria
+    });
+  }
+  getPendingTransactions(address) {
+    const submitted = this.getSubmittedTransactions(address);
+    const approved = this.getApprovedTransactions(address);
+    return [...submitted, ...approved];
+  }
+  getConfirmedTransactions(address) {
+    const searchCriteria = {
+      status: baseControllers.TransactionStatus.confirmed
+    };
+    if (address) {
+      searchCriteria.from = address;
+    }
+    return this.getTransactions({
+      searchCriteria
+    });
+  }
+  getUnapprovedTxList() {
+    const chainId = this.getCurrentChainId();
+    return baseControllers.pickBy(this.state.transactions, transaction => {
+      const transactionMatches = baseControllers.transactionMatchesNetwork(transaction, chainId);
+      return transaction.status === baseControllers.TransactionStatus.unapproved && transactionMatches;
+    });
+  }
+  updateTransactionInState(txMeta, note) {
+    // validate txParams
+    if (txMeta.transaction) {
+      txMeta.transaction = TransactionUtils.normalizeAndValidateTxParams(txMeta.transaction, false);
+    }
+
+    // create txMeta snapshot for history
+    const currentState = TransactionStateHistoryHelper.snapshotFromTxMeta(txMeta);
+    // recover previous tx state obj
+    const previousState = TransactionStateHistoryHelper.replayHistory(txMeta.history);
+    // generate history entry and add to history
+    const entry = TransactionStateHistoryHelper.generateHistoryEntry(previousState, currentState, note);
+    if (entry.length > 0) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      txMeta.history.push(entry);
+    }
+
+    // commit txMeta to state
+    this.updateTransaction(txMeta);
+  }
+  _setTransactionStatus(txId, status, isFinalStep) {
+    const txMeta = this.getTransaction(txId);
+    if (!txMeta) {
+      return;
+    }
+    txMeta.status = status;
+    this.updateTransactionInState(txMeta);
+    this.emit(baseControllers.TX_EVENTS.TX_STATUS_UPDATE, {
+      txId,
+      status
+    });
+    if (this.isFinalState(status) || isFinalStep) {
+      this.emit(`${txMeta.id}:finished`, txMeta);
+    } else {
+      this.emit(`${txMeta.id}:${status}`, txId);
+    }
+  }
+}
+
+exports.TransactionStateManager = TransactionStateManager;

package/dist/lib.cjs/Transaction/TransactionUtils.js

@@ -0,0 +1,341 @@
+'use strict';
+
+var util = require('@ethereumjs/util');
+var baseControllers = require('@toruslabs/base-controllers');
+var auth = require('@web3auth/auth');
+var ethers = require('ethers');
+var log = require('loglevel');
+var abis = require('../utils/abis.js');
+var constants = require('../utils/constants.js');
+
+const erc20Interface = new ethers.Interface(abis.erc20Abi);
+const erc721Interface = new ethers.Interface(abis.erc721Abi);
+const erc1155Interface = new ethers.Interface(abis.erc1155Abi);
+
+// functions that handle normalizing of that key in txParams
+
+const normalizers = {
+  from: (from, LowerCase = true) => LowerCase ? util.addHexPrefix(from).toLowerCase() : util.addHexPrefix(from),
+  to: (to, LowerCase = true) => LowerCase ? util.addHexPrefix(to).toLowerCase() : util.addHexPrefix(to),
+  nonce: nonce => util.addHexPrefix(nonce),
+  customNonceValue: nonce => util.addHexPrefix(nonce),
+  value: value => util.addHexPrefix(value),
+  data: data => util.addHexPrefix(data),
+  gas: gas => util.addHexPrefix(gas),
+  gasPrice: gasPrice => util.addHexPrefix(gasPrice),
+  type: util.addHexPrefix,
+  maxFeePerGas: util.addHexPrefix,
+  maxPriorityFeePerGas: util.addHexPrefix
+};
+
+/**
+ * normalizes txParams
+ */
+function normalizeTxParameters(txParameters, lowerCase = true) {
+  // apply only keys in the normalizers
+  const normalizedTxParameters = {
+    id: txParameters.id || baseControllers.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 normalizedTxParameters;
+}
+function transactionMatchesNetwork(transaction, chainId) {
+  if (typeof transaction.chainId !== "undefined") {
+    return transaction.chainId === chainId;
+  }
+  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 util.isHexString(util.addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact = transaction.transaction) === null || _transaction$transact === void 0 ? void 0 : _transaction$transact.maxFeePerGas)) && util.isHexString(util.addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact2 = transaction.transaction) === null || _transaction$transact2 === void 0 ? void 0 : _transaction$transact2.maxPriorityFeePerGas));
+}
+
+/**
+ * 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" || util.isHexString(util.addHexPrefix(transaction.transaction.gasPrice)));
+}
+
+/**
+ * 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 auth.rpcErrors.invalidParams(`Invalid transaction params: specified ${fieldBeingValidated} but also included ${mutuallyExclusiveField}, these cannot be mixed`);
+  }
+}
+
+/**
+ * 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 auth.rpcErrors.invalidParams(`Invalid transaction params: ${field} is not a string. got: (${txParams[field]})`);
+  }
+}
+
+/**
+ * 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 !== constants.TRANSACTION_ENVELOPE_TYPES.FEE_MARKET) {
+        throw auth.rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + `including maxFeePerGas and maxPriorityFeePerGas requires type: "${constants.TRANSACTION_ENVELOPE_TYPES.FEE_MARKET}"`);
+      }
+      break;
+    case "gasPrice":
+    default:
+      if (txParams.type && txParams.type === constants.TRANSACTION_ENVELOPE_TYPES.FEE_MARKET) {
+        throw auth.rpcErrors.invalidParams(`Invalid transaction envelope type: specified type "${txParams.type}" but ` + "included a gasPrice instead of maxFeePerGas and maxPriorityFeePerGas");
+      }
+  }
+}
+
+/**
+ * validates the from field in  txParams
+ */
+function validateFrom(txParams) {
+  if (!(typeof txParams.from === "string")) {
+    throw auth.rpcErrors.invalidParams(`Invalid "from" address "${txParams.from}": not a string.`);
+  }
+  if (!util.isValidAddress(txParams.from)) {
+    throw auth.rpcErrors.invalidParams('Invalid "from" address.');
+  }
+}
+
+/**
+ * validates the to field in  txParams
+ */
+function validateRecipient(txParameters) {
+  if (txParameters.to === "0x" || txParameters.to === null) {
+    if (txParameters.data) {
+      delete txParameters.to;
+    } else {
+      throw auth.rpcErrors.invalidParams('Invalid "to" address.');
+    }
+  } else if (txParameters.to !== undefined && !util.isValidAddress(txParameters.to)) {
+    throw auth.rpcErrors.invalidParams('Invalid "to" address.');
+  }
+  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 auth.rpcErrors.invalidParams("Invalid transaction params: must be an object.");
+  }
+  if (!txParams.to && !txParams.data) {
+    throw auth.rpcErrors.invalidParams('Invalid transaction params: must specify "data" for contract deployments, or "to" (and optionally "data") for all other types of transactions.');
+  }
+  if (isEIP1559Transaction({
+    transaction: txParams
+  }) && !eip1559Compatibility) {
+    throw auth.rpcErrors.invalidParams("Invalid transaction params: params specify an EIP-1559 transaction but the current network does not support EIP-1559");
+  }
+  Object.entries(txParams).forEach(([key, value]) => {
+    // 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 auth.rpcErrors.invalidParams(`Invalid transaction value "${value}": not a positive number.`);
+        }
+        if (value.toString().includes(".")) {
+          throw auth.rpcErrors.invalidParams(`Invalid transaction value of "${value}": number must be in wei.`);
+        }
+        break;
+      case "chainId":
+        if (typeof value !== "number" && typeof value !== "string") {
+          throw auth.rpcErrors.invalidParams(`Invalid transaction params: ${key} is not a Number or hex string. got: (${value})`);
+        }
+        break;
+      default:
+        ensureFieldIsString(txParams, key);
+    }
+  });
+}
+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 [baseControllers.TransactionStatus.rejected,
+  // the user has responded no!
+  baseControllers.TransactionStatus.confirmed,
+  // the tx has been included in a block.
+  baseControllers.TransactionStatus.failed,
+  // the tx failed for some reason, included on tx data.
+  baseControllers.TransactionStatus.dropped // the tx nonce was already used
+  ];
+}
+function parseStandardTokenTransactionData(data) {
+  try {
+    const txDesc = erc20Interface.parseTransaction({
+      data
+    });
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: constants.CONTRACT_TYPE_ERC20
+    };
+  } catch {
+    // ignore and next try to parse with erc721 ABI
+  }
+  try {
+    const txDesc = erc721Interface.parseTransaction({
+      data
+    });
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: constants.CONTRACT_TYPE_ERC721
+    };
+  } catch {
+    // ignore and next try to parse with erc1155 ABI
+  }
+  try {
+    const txDesc = erc1155Interface.parseTransaction({
+      data
+    });
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: constants.CONTRACT_TYPE_ERC1155
+    };
+  } catch {
+    // ignore and return undefined
+  }
+  return undefined;
+}
+const readAddressAsContract = async (provider, address) => {
+  let contractCode;
+  try {
+    contractCode = await provider.request({
+      method: constants.METHOD_TYPES.ETH_GET_CODE,
+      params: [address, "latest"]
+    });
+  } catch (e) {
+    contractCode = null;
+  }
+  const isContractAddress = contractCode ? contractCode !== "0x" && contractCode !== "0x0" : false;
+  return {
+    contractCode,
+    isContractAddress
+  };
+};
+async function determineTransactionType(txParams, provider) {
+  const {
+    data,
+    to
+  } = txParams;
+  let name = "";
+  let methodParams = [];
+  let type = "";
+  try {
+    ({
+      name,
+      methodParams,
+      type
+    } = data && parseStandardTokenTransactionData(data) || {});
+  } catch (error) {
+    log.debug("Failed to parse transaction data", error);
+  }
+  let result;
+  let contractCode = "";
+  if (data && !to) {
+    result = baseControllers.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 = [baseControllers.TRANSACTION_TYPES.TOKEN_METHOD_APPROVE, baseControllers.TRANSACTION_TYPES.TOKEN_METHOD_TRANSFER, baseControllers.TRANSACTION_TYPES.TOKEN_METHOD_TRANSFER_FROM, baseControllers.TRANSACTION_TYPES.COLLECTIBLE_METHOD_SAFE_TRANSFER_FROM, baseControllers.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 : baseControllers.TRANSACTION_TYPES.CONTRACT_INTERACTION;
+    } else {
+      result = baseControllers.TRANSACTION_TYPES.SENT_ETHER;
+    }
+  }
+  return {
+    type: type || constants.CONTRACT_TYPE_ETH,
+    category: result,
+    methodParams,
+    getCodeResponse: contractCode
+  };
+}
+
+exports.determineTransactionType = determineTransactionType;
+exports.ensureFieldIsString = ensureFieldIsString;
+exports.ensureMutuallyExclusiveFieldsNotProvided = ensureMutuallyExclusiveFieldsNotProvided;
+exports.getFinalStates = getFinalStates;
+exports.isEIP1559Transaction = isEIP1559Transaction;
+exports.isLegacyTransaction = isLegacyTransaction;
+exports.normalizeAndValidateTxParams = normalizeAndValidateTxParams;
+exports.normalizeTxParameters = normalizeTxParameters;
+exports.parseStandardTokenTransactionData = parseStandardTokenTransactionData;
+exports.readAddressAsContract = readAddressAsContract;
+exports.transactionMatchesNetwork = transactionMatchesNetwork;
+exports.validateFrom = validateFrom;
+exports.validateRecipient = validateRecipient;
+exports.validateTxParameters = validateTxParameters;