@toruslabs/ethereum-controllers 5.10.1 → 6.0.0

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

@@ -0,0 +1,294 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import { BaseTransactionStateManager, randomId, TransactionStatus, omitBy, transactionMatchesNetwork, pickBy, TX_EVENTS } from '@toruslabs/base-controllers';
+import { mapValues, keyBy, sortBy } from '../utils/lodashUtils.js';
+import { snapshotFromTxMeta, replayHistory, generateHistoryEntry } from './TransactionStateHistoryHelper.js';
+import { normalizeAndValidateTxParams, getFinalStates } from './TransactionUtils.js';
+
+class TransactionStateManager extends 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) || randomId(),
+      time: Date.now(),
+      status: TransactionStatus.unapproved,
+      loadingDefaults: true,
+      chainId,
+      dappSuggestedGasFees
+    }, opts);
+  }
+  addTransactionToState(txMeta) {
+    if (txMeta.transaction) {
+      txMeta.transaction = 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 = 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 || 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: omitBy(transactions, txMeta => {
+        const transactionMatch = 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 = 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 ? 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 = sortBy(Object.values(pickBy(transactionsToFilter, txMeta => {
+      // default matchesCriteria to the value of transactionMatchesNetwork
+      // when filterToCurrentNetwork is true.
+      const transactionMatches = 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: TransactionStatus.approved
+    };
+    if (address) {
+      searchCriteria.from = address;
+    }
+    return this.getTransactions({
+      searchCriteria
+    });
+  }
+  getSubmittedTransactions(address) {
+    const searchCriteria = {
+      status: 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: TransactionStatus.confirmed
+    };
+    if (address) {
+      searchCriteria.from = address;
+    }
+    return this.getTransactions({
+      searchCriteria
+    });
+  }
+  getUnapprovedTxList() {
+    const chainId = this.getCurrentChainId();
+    return pickBy(this.state.transactions, transaction => {
+      const transactionMatches = transactionMatchesNetwork(transaction, chainId);
+      return transaction.status === TransactionStatus.unapproved && transactionMatches;
+    });
+  }
+  updateTransactionInState(txMeta, note) {
+    // validate txParams
+    if (txMeta.transaction) {
+      txMeta.transaction = normalizeAndValidateTxParams(txMeta.transaction, false);
+    }
+
+    // create txMeta snapshot for history
+    const currentState = snapshotFromTxMeta(txMeta);
+    // recover previous tx state obj
+    const previousState = replayHistory(txMeta.history);
+    // generate history entry and add to history
+    const entry = 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(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);
+    }
+  }
+}
+
+export { TransactionStateManager };

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

@@ -0,0 +1,326 @@
+import { isHexString, addHexPrefix, isValidAddress } from '@ethereumjs/util';
+import { randomId, TransactionStatus, TRANSACTION_TYPES } from '@toruslabs/base-controllers';
+import { rpcErrors } from '@web3auth/auth';
+import { Interface } from 'ethers';
+import log from 'loglevel';
+import { erc20Abi, erc721Abi, erc1155Abi } from '../utils/abis.js';
+import { CONTRACT_TYPE_ERC20, CONTRACT_TYPE_ERC721, CONTRACT_TYPE_ERC1155, METHOD_TYPES, CONTRACT_TYPE_ETH, TRANSACTION_ENVELOPE_TYPES } from '../utils/constants.js';
+
+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
+};
+
+/**
+ * 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 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 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));
+}
+
+/**
+ * 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)));
+}
+
+/**
+ * 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`);
+  }
+}
+
+/**
+ * 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]})`);
+  }
+}
+
+/**
+ * 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");
+      }
+  }
+}
+
+/**
+ * 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.');
+  }
+}
+
+/**
+ * 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.');
+  }
+  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.");
+  }
+  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.');
+  }
+  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");
+  }
+  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);
+    }
+  });
+}
+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
+    });
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: CONTRACT_TYPE_ERC20
+    };
+  } catch {
+    // ignore and next try to parse with erc721 ABI
+  }
+  try {
+    const txDesc = erc721Interface.parseTransaction({
+      data
+    });
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: CONTRACT_TYPE_ERC721
+    };
+  } catch {
+    // ignore and next try to parse with erc1155 ABI
+  }
+  try {
+    const txDesc = erc1155Interface.parseTransaction({
+      data
+    });
+    if (txDesc) return {
+      name: txDesc.name,
+      methodParams: txDesc.args.toArray(),
+      type: CONTRACT_TYPE_ERC1155
+    };
+  } catch {
+    // ignore and return undefined
+  }
+  return undefined;
+}
+const readAddressAsContract = async (provider, address) => {
+  let contractCode;
+  try {
+    contractCode = await provider.request({
+      method: METHOD_TYPES.ETH_GET_CODE,
+      params: [address, "latest"]
+    });
+  } catch (e) {
+    contractCode = null;
+  }
+  const isContractAddress = contractCode ? contractCode !== "0x" && contractCode !== "0x0" : false;
+  return {
+    contractCode,
+    isContractAddress
+  };
+};
+async function determineTransactionType(txParams, provider) {
+  const {
+    data,
+    to
+  } = txParams;
+  let name = "";
+  let methodParams = [];
+  let type = "";
+  try {
+    ({
+      name,
+      methodParams,
+      type
+    } = data && parseStandardTokenTransactionData(data) || {});
+  } catch (error) {
+    log.debug("Failed to parse transaction data", error);
+  }
+  let result;
+  let contractCode = "";
+  if (data && !to) {
+    result = TRANSACTION_TYPES.DEPLOY_CONTRACT;
+  } else {
+    const {
+      contractCode: resultCode,
+      isContractAddress
+    } = await readAddressAsContract(provider, to);
+    contractCode = resultCode;
+    if (isContractAddress) {
+      const valueExists = txParams.value && Number(txParams.value) !== 0;
+      const tokenMethodName = [TRANSACTION_TYPES.TOKEN_METHOD_APPROVE, TRANSACTION_TYPES.TOKEN_METHOD_TRANSFER, TRANSACTION_TYPES.TOKEN_METHOD_TRANSFER_FROM, TRANSACTION_TYPES.COLLECTIBLE_METHOD_SAFE_TRANSFER_FROM, TRANSACTION_TYPES.SET_APPROVAL_FOR_ALL].find(x => {
+        var _name;
+        return x.toLowerCase() === ((_name = name) === null || _name === void 0 ? void 0 : _name.toLowerCase());
+      });
+      result = data && tokenMethodName && !valueExists ? tokenMethodName : TRANSACTION_TYPES.CONTRACT_INTERACTION;
+    } else {
+      result = TRANSACTION_TYPES.SENT_ETHER;
+    }
+  }
+  return {
+    type: type || CONTRACT_TYPE_ETH,
+    category: result,
+    methodParams,
+    getCodeResponse: contractCode
+  };
+}
+
+export { determineTransactionType, ensureFieldIsString, ensureMutuallyExclusiveFieldsNotProvided, getFinalStates, isEIP1559Transaction, isLegacyTransaction, normalizeAndValidateTxParams, normalizeTxParameters, parseStandardTokenTransactionData, readAddressAsContract, transactionMatchesNetwork, validateFrom, validateRecipient, validateTxParameters };

package/dist/lib.esm/index.js

@@ -0,0 +1,33 @@
+export { AccountTrackerController } from './Account/AccountTrackerController.js';
+export { PollingBlockTracker } from './Block/PollingBlockTracker.js';
+export { CurrencyController } from './Currency/CurrencyController.js';
+export { GasFeeController } from './Gas/GasFeeController.js';
+export { KeyringController } from './Keyring/KeyringController.js';
+export { AbstractMessageController } from './Message/AbstractMessageController.js';
+export { AddChainController } from './Message/AddChainController.js';
+export { MessageController } from './Message/MessageController.js';
+export { PersonalMessageController } from './Message/PersonalMessageController.js';
+export { SwitchChainController } from './Message/SwitchChainController.js';
+export { TypedMessageController } from './Message/TypedMessageController.js';
+export { normalizeMessageData, validateAddChainData, validateAddress, validateSignMessageData, validateSwitchChainData, validateTypedSignMessageDataV4 } from './Message/utils.js';
+export { createEthereumMiddleware, createGetAccountsMiddleware, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessageV4, createRequestAccountsMiddleware, formatTxMetaForRpcResult } from './Network/createEthereumMiddleware.js';
+export { createChainIdMiddleware, createJsonRpcClient, createProviderConfigMiddleware } from './Network/createJsonRpcClient.js';
+export { NetworkController } from './Network/NetworkController.js';
+export { NftHandler } from './Nfts/NftHandler.js';
+export { NftsController } from './Nfts/NftsController.js';
+export { PreferencesController } from './Preferences/PreferencesController.js';
+export { TokenHandler } from './Tokens/TokenHandler.js';
+export { DEFAULT_CURRENCY, TokenRatesController } from './Tokens/TokenRatesController.js';
+export { TokensController } from './Tokens/TokensController.js';
+export { NonceTracker } from './Transaction/NonceTracker.js';
+export { PendingTransactionTracker } from './Transaction/PendingTransactionTracker.js';
+export { TransactionController } from './Transaction/TransactionController.js';
+export { TransactionGasUtil } from './Transaction/TransactionGasUtil.js';
+export { generateHistoryEntry, replayHistory, snapshotFromTxMeta } from './Transaction/TransactionStateHistoryHelper.js';
+export { TransactionStateManager } from './Transaction/TransactionStateManager.js';
+export { determineTransactionType, ensureFieldIsString, ensureMutuallyExclusiveFieldsNotProvided, getFinalStates, isEIP1559Transaction, isLegacyTransaction, normalizeAndValidateTxParams, normalizeTxParameters, parseStandardTokenTransactionData, readAddressAsContract, transactionMatchesNetwork, validateFrom, validateRecipient, validateTxParameters } from './Transaction/TransactionUtils.js';
+export { erc1155Abi, erc20Abi, erc721Abi, singleBalanceCheckerAbi } from './utils/abis.js';
+export { ARBITRUM_MAINNET_CHAIN_ID, ARBITRUM_TESTNET_CHAIN_ID, AVALANCHE_MAINNET_CHAIN_ID, AVALANCHE_TESTNET_CHAIN_ID, BASE_CHAIN_ID, BASE_TESTNET_CHAIN_ID, BSC_MAINNET_CHAIN_ID, BSC_TESTNET_CHAIN_ID, CELO_MAINNET_CHAIN_ID, CHAIN_ID_TO_GAS_LIMIT_BUFFER_MAP, COINGECKO_PLATFORMS_CHAIN_CODE_MAP, COINGECKO_SUPPORTED_CURRENCIES, CONTRACT_TYPE_ERC1155, CONTRACT_TYPE_ERC20, CONTRACT_TYPE_ERC721, CONTRACT_TYPE_ETH, ERC1155_INTERFACE_ID, ERC721_ENUMERABLE_INTERFACE_ID, ERC721_INTERFACE_ID, ERC721_METADATA_INTERFACE_ID, ETHERSCAN_SUPPORTED_CHAINS, GAS_ESTIMATE_TYPES, LOCALHOST, MAINNET_CHAIN_ID, MESSAGE_EVENTS, METHOD_TYPES, MessageStatus, OLD_ERC721_LIST, OPTIMISM_MAINNET_CHAIN_ID, OPTIMISM_TESTNET_CHAIN_ID, POLYGON_AMOY_CHAIN_ID, POLYGON_CHAIN_ID, SEPOLIA_CHAIN_ID, SIMPLEHASH_SUPPORTED_CHAINS, SUPPORTED_NETWORKS, TEST_CHAINS, TRANSACTION_ENVELOPE_TYPES, XDAI_CHAIN_ID } from './utils/constants.js';
+export { addCurrencies, conversionGTE, conversionGreaterThan, conversionLTE, conversionLessThan, conversionMax, conversionUtil, decGWEIToHexWEI, getBigNumber, hexWEIToDecGWEI, multiplyCurrencies, subtractCurrencies, toNegative } from './utils/conversionUtils.js';
+export { BNToHex, GAS_LIMITS, addEtherscanTransactions, bnLessThan, formatDate, formatPastTx, formatTime, getChainType, getEthTxStatus, getEtherScanHashLink, getIpfsEndpoint, hexToBn, idleTimeTracker, isAddressByChainId, sanitizeNftMetdataUrl, toChecksumAddressByChainId } from './utils/helpers.js';
+import '@toruslabs/base-controllers';