@toruslabs/ethereum-controllers 4.1.0

package/src/Transaction/TransactionStateManager.ts

@@ -0,0 +1,315 @@
+import {
+  BaseTransactionStateManager,
+  ITransactionStateManager,
+  randomId,
+  TransactionConfig,
+  transactionMatchesNetwork,
+  TransactionState,
+  TransactionStatus,
+  TX_EVENTS,
+  TX_STATUS_UPDATE_EVENT_TYPE,
+} from "@toruslabs/base-controllers";
+import { keyBy, mapValues, omitBy, pickBy, sortBy } from "lodash";
+
+import NetworkController from "../Network/NetworkController";
+import { DappSuggestedGasFees, EthereumTransactionMeta, TransactionParams } from "../utils/interfaces";
+import { generateHistoryEntry, replayHistory, snapshotFromTxMeta } from "./TransactionStateHistoryHelper";
+import { getFinalStates, normalizeAndValidateTxParams } from "./TransactionUtils";
+
+export default class TransactionStateManager
+  extends BaseTransactionStateManager<TransactionParams, EthereumTransactionMeta>
+  implements ITransactionStateManager<TransactionParams>
+{
+  constructor({
+    config,
+    state,
+    getCurrentChainId,
+  }: {
+    config?: Partial<TransactionConfig>;
+    state?: Partial<TransactionState<TransactionParams, EthereumTransactionMeta>>;
+    getCurrentChainId: NetworkController["getNetworkIdentifier"];
+  }) {
+    super({ config, state, getCurrentChainId });
+  }
+
+  generateTxMeta(opts: Partial<EthereumTransactionMeta> = {}): EthereumTransactionMeta {
+    const chainId = this.getCurrentChainId();
+    if (chainId === "loading") throw new Error("Torus is having trouble connecting to the network");
+    let dappSuggestedGasFees: 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 = {
+          ...dappSuggestedGasFees,
+          gas: opts.transaction.gas,
+        };
+      }
+    }
+
+    return {
+      id: randomId(),
+      time: Date.now(),
+      status: TransactionStatus.unapproved,
+      loadingDefaults: true,
+      chainId,
+      dappSuggestedGasFees,
+      ...opts,
+    } as EthereumTransactionMeta;
+  }
+
+  addTransactionToState(txMeta: EthereumTransactionMeta): EthereumTransactionMeta {
+    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 as any);
+
+    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: string): void {
+    const { transactions } = this.state;
+    const chainId = this.getCurrentChainId();
+
+    this.update({
+      transactions: omitBy(transactions, (txMeta: EthereumTransactionMeta) => {
+        const transactionMatch = transactionMatchesNetwork(txMeta, chainId);
+        return txMeta.transaction.from === address && transactionMatch;
+      }),
+    });
+  }
+
+  getTransactions({
+    searchCriteria = {},
+    initialList = undefined,
+    filterToCurrentNetwork = true,
+    limit = undefined,
+  }: {
+    searchCriteria?: Record<string, (val: unknown) => boolean> | Record<string, unknown>;
+    initialList?: EthereumTransactionMeta[];
+    filterToCurrentNetwork?: boolean;
+    limit?: number;
+  } = {}): EthereumTransactionMeta[] {
+    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: unknown = mapValues(searchCriteria, (predicate) =>
+      typeof predicate === "function" ? predicate : (v: unknown) => 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(
+      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 as keyof TransactionParams]) === false) {
+              return false;
+            }
+          } else if (predicate(txMeta[key as keyof EthereumTransactionMeta]) === 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?: string): EthereumTransactionMeta[] {
+    const searchCriteria: { status: TransactionStatus; from?: string } = { status: TransactionStatus.approved };
+    if (address) {
+      searchCriteria.from = address;
+    }
+    return this.getTransactions({ searchCriteria });
+  }
+
+  getSubmittedTransactions(address?: string): EthereumTransactionMeta[] {
+    const searchCriteria: { status: TransactionStatus; from?: string } = { status: TransactionStatus.submitted };
+    if (address) {
+      searchCriteria.from = address;
+    }
+    return this.getTransactions({ searchCriteria });
+  }
+
+  getPendingTransactions(address?: string): EthereumTransactionMeta[] {
+    const submitted = this.getSubmittedTransactions(address);
+    const approved = this.getApprovedTransactions(address);
+    return [...submitted, ...approved];
+  }
+
+  getConfirmedTransactions(address?: string): EthereumTransactionMeta[] {
+    const searchCriteria: { status: TransactionStatus; from?: string } = { status: TransactionStatus.confirmed };
+    if (address) {
+      searchCriteria.from = address;
+    }
+    return this.getTransactions({ searchCriteria });
+  }
+
+  getUnapprovedTxList(): Record<string, EthereumTransactionMeta> {
+    const chainId = this.getCurrentChainId();
+
+    return pickBy(this.state.transactions, (transaction) => {
+      const transactionMatches = transactionMatchesNetwork(transaction, chainId);
+      return transaction.status === TransactionStatus.unapproved && transactionMatches;
+    });
+  }
+
+  updateTransactionInState(txMeta: EthereumTransactionMeta, note?: string) {
+    // 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 as unknown as Record<string, unknown>, note);
+    if (entry.length > 0) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      txMeta.history.push(entry as any);
+    }
+
+    // commit txMeta to state
+    this.updateTransaction(txMeta);
+  }
+
+  protected override _setTransactionStatus(txId: string, status: TransactionStatus, isFinalStep?: boolean): void {
+    const txMeta = this.getTransaction(txId);
+    if (!txMeta) {
+      return;
+    }
+    txMeta.status = status;
+    this.updateTransactionInState(txMeta);
+    this.emit(TX_EVENTS.TX_STATUS_UPDATE, { txId, status } as TX_STATUS_UPDATE_EVENT_TYPE);
+    if (this.isFinalState(status) || isFinalStep) {
+      this.emit(`${txMeta.id}:finished`, txMeta);
+    } else {
+      this.emit(`${txMeta.id}:${status}`, txId);
+    }
+  }
+}

package/src/Transaction/TransactionUtils.ts

@@ -0,0 +1,333 @@
+import { addHexPrefix, isHexString, isValidAddress } from "@ethereumjs/util";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { randomId, TRANSACTION_TYPE, TRANSACTION_TYPES, TransactionStatus } from "@toruslabs/base-controllers";
+import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
+import { Interface } from "ethers";
+import log from "loglevel";
+
+import { ecr20Abi, erc721Abi, erc1155Abi } from "../utils/abis";
+import {
+  CONTRACT_TYPE_ERC20,
+  CONTRACT_TYPE_ERC721,
+  CONTRACT_TYPE_ERC1155,
+  CONTRACT_TYPE_ETH,
+  METHOD_TYPES,
+  TRANSACTION_ENVELOPE_TYPES,
+} from "../utils/constants";
+import { EthereumTransactionMeta, TRANSACTION_ENVELOPE_TYPES_TYPE, TransactionParams } from "../utils/interfaces";
+
+const erc20Interface = new Interface(ecr20Abi);
+const erc721Interface = new Interface(erc721Abi);
+const erc1155Interface = new Interface(erc1155Abi);
+
+// functions that handle normalizing of that key in txParams
+type NormalizableTransactionParams = keyof Omit<TransactionParams, "accessList">;
+const normalizers: Partial<
+  Record<
+    NormalizableTransactionParams,
+    (param: NormalizableTransactionParams, ...args: unknown[]) => TransactionParams[NormalizableTransactionParams]
+  >
+> = {
+  from: (from: string, LowerCase = true) => (LowerCase ? addHexPrefix(from).toLowerCase() : addHexPrefix(from)),
+  to: (to: string, LowerCase = true) => (LowerCase ? addHexPrefix(to).toLowerCase() : addHexPrefix(to)),
+  nonce: (nonce: string) => addHexPrefix(nonce),
+  customNonceValue: (nonce: string) => addHexPrefix(nonce),
+  value: (value: string) => addHexPrefix(value),
+  data: (data: string) => addHexPrefix(data),
+  gas: (gas: string) => addHexPrefix(gas),
+  gasPrice: (gasPrice: string) => addHexPrefix(gasPrice),
+  type: addHexPrefix as (str: string) => TRANSACTION_ENVELOPE_TYPES_TYPE,
+  maxFeePerGas: addHexPrefix,
+  maxPriorityFeePerGas: addHexPrefix,
+};
+
+/**
+ * normalizes txParams
+ */
+export function normalizeTxParameters(txParameters: TransactionParams, lowerCase = true): TransactionParams {
+  // apply only keys in the normalizers
+  const normalizedTxParameters: TransactionParams = { id: txParameters.id || randomId(), from: txParameters.from };
+  for (const key in normalizers) {
+    const currentKey = key as NormalizableTransactionParams;
+    if (txParameters[currentKey])
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      normalizedTxParameters[currentKey] = normalizers[currentKey](txParameters[currentKey] as NormalizableTransactionParams, lowerCase) as any;
+  }
+  return normalizedTxParameters;
+}
+
+export function transactionMatchesNetwork(transaction: EthereumTransactionMeta, chainId: string) {
+  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
+ */
+export function isEIP1559Transaction(transaction: Partial<EthereumTransactionMeta>) {
+  return (
+    isHexString(addHexPrefix(transaction?.transaction?.maxFeePerGas)) && isHexString(addHexPrefix(transaction?.transaction?.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
+ */
+export function isLegacyTransaction(transaction: EthereumTransactionMeta) {
+  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.
+ */
+export function ensureMutuallyExclusiveFieldsNotProvided(
+  txParams: TransactionParams,
+  fieldBeingValidated: NormalizableTransactionParams,
+  mutuallyExclusiveField: NormalizableTransactionParams
+) {
+  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.
+ */
+export function ensureFieldIsString(txParams: TransactionParams, field: NormalizableTransactionParams) {
+  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: TransactionParams, field: NormalizableTransactionParams) {
+  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
+ */
+export function validateFrom(txParams: TransactionParams) {
+  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
+ */
+export function validateRecipient(txParameters: TransactionParams) {
+  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
+ */
+export function validateTxParameters(txParams: TransactionParams, 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 as NormalizableTransactionParams);
+    }
+  });
+}
+
+export function normalizeAndValidateTxParams(txParams: TransactionParams, lowerCase = true) {
+  const normalizedTxParams = normalizeTxParameters(txParams, lowerCase);
+  validateTxParameters(normalizedTxParams);
+  return normalizedTxParams;
+}
+
+/**
+ * @returns an array of states that can be considered final
+ */
+export 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
+  ];
+}
+
+export function parseStandardTokenTransactionData(data: string) {
+  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;
+}
+
+export const readAddressAsContract = async (
+  provider: SafeEventEmitterProvider,
+  address: string
+): Promise<{ contractCode: string; isContractAddress: boolean }> => {
+  let contractCode;
+  try {
+    contractCode = await provider.request<[string, string], string>({ method: METHOD_TYPES.ETH_GET_CODE, params: [address, "latest"] });
+  } catch (e) {
+    contractCode = null;
+  }
+
+  const isContractAddress = contractCode ? contractCode !== "0x" && contractCode !== "0x0" : false;
+  return { contractCode, isContractAddress };
+};
+
+export async function determineTransactionType(txParams: TransactionParams, provider: SafeEventEmitterProvider) {
+  const { data, to } = txParams;
+  let name: string = "";
+  let methodParams = [];
+  let type = "";
+  try {
+    ({ name, methodParams, type } = (data && parseStandardTokenTransactionData(data)) || {});
+  } catch (error) {
+    log.debug("Failed to parse transaction data", error);
+  }
+  let result: TRANSACTION_TYPE;
+  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_TYPE = [
+        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) => x.toLowerCase() === 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 };
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+export { default as AccountTrackerController } from "./Account/AccountTrackerController";
+export { default as PollingBlockTracker } from "./Block/PollingBlockTracker";
+export { default as CurrencyController } from "./Currency/CurrencyController";
+export { default as GasFeeController } from "./Gas/GasFeeController";
+export * from "./Gas/IGasFeeController";
+export { default as KeyringController } from "./Keyring/KeyringController";
+export * from "./Message/AbstractMessageController";
+export * from "./Message/DecryptMessageController";
+export * from "./Message/EncryptionPublicKeyController";
+export * from "./Message/MessageController";
+export * from "./Message/PersonalMessageController";
+export * from "./Message/TypedMessageController";
+export * from "./Message/utils";
+export * from "./Network/createEthereumMiddleware";
+export * from "./Network/createJsonRpcClient";
+export { default as NetworkController } from "./Network/NetworkController";
+export * from "./Nfts/INftsController";
+export * from "./Nfts/NftHandler";
+export * from "./Nfts/NftsController";
+export { default as PreferencesController } from "./Preferences/PreferencesController";
+export * from "./Tokens/ITokensController";
+export * from "./Tokens/TokenHandler";
+export * from "./Tokens/TokenRatesController";
+export * from "./Tokens/TokensController";
+export { default as NonceTracker } from "./Transaction/NonceTracker";
+export { default as PendingTransactionTracker } from "./Transaction/PendingTransactionTracker";
+export { default as TransactionController } from "./Transaction/TransactionController";
+export { default as TransactionGasUtil } from "./Transaction/TransactionGasUtil";
+export * from "./Transaction/TransactionStateHistoryHelper";
+export { default as TransactionStateManager } from "./Transaction/TransactionStateManager";
+export * from "./Transaction/TransactionUtils";
+export * from "./utils/constants";
+export * from "./utils/helpers";
+export * from "./utils/interfaces";
+
+/**
+ * Pending controllers
+ * - Transaction Controllers
+//  * - AA Controller
+ */
+
+/**
+ * Backend apis
+ * - Preferences Controller
+ */