@toruslabs/ethereum-controllers 5.5.2 → 5.5.4

package/src/utils/conversionUtils.ts

@@ -1,269 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-/* Currency Conversion Utility
- * This utility function can be used for converting currency related values within metamask.
- * The caller should be able to pass it a value, along with information about the value's
- * numeric base, denomination and currency, and the desired numeric base, denomination and
- * currency. It should return a single value.
- *
- * @param {(number | string | BN)} value - The value to convert.
- * @param {Object} [options] - Options to specify details of the conversion
- * @param {string} [options.fromCurrency = 'ETH' | 'USD'] - The currency of the passed value
- * @param {string} [options.toCurrency = 'ETH' | 'USD'] - The desired currency of the result
- * @param {string} [options.fromNumericBase = 'hex' | 'dec' | 'BN'] - The numeric basic of the passed value.
- * @param {string} [options.toNumericBase = 'hex' | 'dec' | 'BN'] - The desired numeric basic of the result.
- * @param {string} [options.fromDenomination = 'WEI'] - The denomination of the passed value
- * @param {string} [options.numberOfDecimals] - The desired number of decimals in the result
- * @param {string} [options.roundDown] - The desired number of decimals to round down to
- * @param {number} [options.conversionRate] - The rate to use to make the fromCurrency -> toCurrency conversion
- * @returns {(number | string | BN)}
- *
- * The utility passes value along with the options as a single object to the `converter` function.
- * `converter` conditional modifies the supplied `value` property, depending
- * on the accompanying options.
- */
-
-import { stripHexPrefix } from "@ethereumjs/util";
-import BigNumber from "bignumber.js";
-import BN from "bn.js";
-
-// 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");
-
-type NumericBase = "hex" | "dec" | "BN";
-
-type EthDenomination = "WEI" | "GWEI" | "ETH";
-
-type ConverterOptions = {
-  value: BigNumber | string;
-  fromNumericBase: NumericBase;
-  fromDenomination: EthDenomination;
-  fromCurrency: string;
-  toNumericBase: NumericBase;
-  toDenomination: EthDenomination;
-  toCurrency: string;
-  numberOfDecimals: number;
-  conversionRate: number;
-  invertConversionRate: boolean;
-  roundDown?: number;
-};
-
-// 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,
-}: ConverterOptions) => {
-  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;
-};
-
-export const conversionUtil = (
-  value: BigNumber | string,
-  {
-    fromCurrency = null,
-    toCurrency = fromCurrency,
-    fromNumericBase,
-    toNumericBase,
-    fromDenomination,
-    toDenomination,
-    numberOfDecimals,
-    conversionRate,
-    invertConversionRate,
-  }: Omit<ConverterOptions, "value">
-) => {
-  if (fromCurrency !== toCurrency && !conversionRate) {
-    return 0;
-  }
-  return converter({
-    fromCurrency,
-    toCurrency,
-    fromNumericBase,
-    toNumericBase,
-    fromDenomination,
-    toDenomination,
-    numberOfDecimals,
-    conversionRate,
-    invertConversionRate,
-    value,
-  });
-};
-
-export 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);
-};
-
-export const addCurrencies = (a, b, options: Record<string, unknown> = {}) => {
-  const { aBase, bBase, ...conversionOptions } = options;
-
-  if (!isValidBase(aBase) || !isValidBase(bBase)) {
-    throw new Error("Must specify valid aBase and bBase");
-  }
-
-  const value = getBigNumber(a, aBase).plus(getBigNumber(b, bBase));
-
-  return converter({
-    value,
-    ...conversionOptions,
-  } as ConverterOptions);
-};
-
-export const subtractCurrencies = (a, b, options: Record<string, unknown> = {}) => {
-  const { aBase, bBase, ...conversionOptions } = options;
-
-  if (!isValidBase(aBase) || !isValidBase(bBase)) {
-    throw new Error("Must specify valid aBase and bBase");
-  }
-
-  const value = getBigNumber(a, aBase).minus(getBigNumber(b, bBase));
-
-  return converter({
-    value,
-    ...conversionOptions,
-  } as ConverterOptions);
-};
-
-export const multiplyCurrencies = (a, b, options: Record<string, unknown> = {}) => {
-  const { multiplicandBase, multiplierBase, ...conversionOptions } = options;
-
-  if (!isValidBase(multiplicandBase) || !isValidBase(multiplierBase)) {
-    throw new Error("Must specify valid multiplicandBase and multiplierBase");
-  }
-
-  const value = getBigNumber(a, multiplicandBase).times(getBigNumber(b, multiplierBase));
-
-  return converter({
-    value,
-    ...conversionOptions,
-  } as ConverterOptions);
-};
-
-export const conversionGreaterThan = ({ ...firstProps }: ConverterOptions, { ...secondProps }: ConverterOptions) => {
-  const firstValue = converter({ ...firstProps });
-  const secondValue = converter({ ...secondProps });
-
-  return firstValue.gt(secondValue);
-};
-
-export const conversionLessThan = ({ ...firstProps }: ConverterOptions, { ...secondProps }: ConverterOptions) => {
-  const firstValue = converter({ ...firstProps });
-  const secondValue = converter({ ...secondProps });
-
-  return firstValue.lt(secondValue);
-};
-
-export const conversionMax = ({ ...firstProps }, { ...secondProps }) => {
-  const firstIsGreater = conversionGreaterThan({ ...firstProps }, { ...secondProps });
-
-  return firstIsGreater ? firstProps.value : secondProps.value;
-};
-
-export const conversionGTE = ({ ...firstProps }, { ...secondProps }) => {
-  const firstValue = converter({ ...firstProps } as ConverterOptions);
-  const secondValue = converter({ ...secondProps } as ConverterOptions);
-  return firstValue.isGreaterThanOrEqualTo(secondValue);
-};
-
-export const conversionLTE = ({ ...firstProps }, { ...secondProps }) => {
-  const firstValue = converter({ ...firstProps } as ConverterOptions);
-  const secondValue = converter({ ...secondProps } as ConverterOptions);
-  return firstValue.isLessThanOrEqualTo(secondValue);
-};
-
-export const toNegative = (n, options = {}) => multiplyCurrencies(n, -1, options);
-
-export const decGWEIToHexWEI = (decGWEI: BigNumber): BigNumber => {
-  return conversionUtil(decGWEI, {
-    fromNumericBase: "dec",
-    toNumericBase: "hex",
-    fromDenomination: "GWEI",
-    toDenomination: "WEI",
-  } as ConverterOptions);
-};
-
-export const hexWEIToDecGWEI = (decGWEI: BigNumber | string): BigNumber => {
-  return conversionUtil(decGWEI, {
-    fromNumericBase: "hex",
-    toNumericBase: "dec",
-    fromDenomination: "WEI",
-    toDenomination: "GWEI",
-  } as ConverterOptions);
-};

package/src/utils/helpers.ts

@@ -1,234 +0,0 @@
-import { addHexPrefix, isValidAddress, toChecksumAddress } from "@ethereumjs/util";
-import {
-  ACTIVITY_ACTION_RECEIVE,
-  ACTIVITY_ACTION_SEND,
-  addressSlicer,
-  formatSmallNumbers,
-  significantDigits,
-  TransactionStatus,
-} from "@toruslabs/base-controllers";
-import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
-import BigNumber from "bignumber.js";
-import { formatEther } from "ethers";
-import log from "loglevel";
-
-import { determineTransactionType } from "../Transaction/TransactionUtils";
-import {
-  CONTRACT_TYPE_ERC20,
-  CONTRACT_TYPE_ERC721,
-  CONTRACT_TYPE_ERC1155,
-  CONTRACT_TYPE_ETH,
-  MAINNET_CHAIN_ID,
-  METHOD_TYPES,
-  SUPPORTED_NETWORKS,
-  TEST_CHAINS,
-} from "./constants";
-import { EtherscanTransaction, FormattedTransactionActivity, TransactionParams, TransactionPayload, TransactionReceipt } from "./interfaces";
-
-export function getEtherScanHashLink(txHash: string, chainId: string) {
-  if (!SUPPORTED_NETWORKS[chainId]) return "";
-  return `${SUPPORTED_NETWORKS[chainId].blockExplorerUrl}/tx/${txHash}`;
-}
-
-export const formatPastTx = (x: TransactionPayload, lowerCaseSelectedAddress?: string): FormattedTransactionActivity => {
-  let totalAmountString = "";
-  if (x.type === CONTRACT_TYPE_ERC721 || x.type === CONTRACT_TYPE_ERC1155) totalAmountString = x.symbol;
-  else if (x.type === CONTRACT_TYPE_ERC20) totalAmountString = formatSmallNumbers(Number.parseFloat(x.total_amount), x.symbol, true);
-  else totalAmountString = formatSmallNumbers(Number.parseFloat(x.total_amount), x.type_name, true);
-  const currencyAmountString =
-    x.type === CONTRACT_TYPE_ERC721 || x.type === CONTRACT_TYPE_ERC1155 || x.isEtherscan
-      ? ""
-      : formatSmallNumbers(Number.parseFloat(x.currency_amount), x.selected_currency, true);
-  const finalObject: FormattedTransactionActivity = {
-    id: x.created_at.toString(),
-    date: new Date(x.created_at).toString(),
-    from: x.from,
-    from_aa_address: x.from_aa_address,
-    slicedFrom: typeof x.from === "string" ? addressSlicer(x.from) : "",
-    to: x.to,
-    slicedTo: typeof x.to === "string" ? addressSlicer(x.to) : "",
-    action: lowerCaseSelectedAddress === x.to?.toLowerCase() || "" ? ACTIVITY_ACTION_RECEIVE : ACTIVITY_ACTION_SEND,
-    totalAmount: x.total_amount,
-    totalAmountString,
-    currencyAmount: x.currency_amount,
-    currencyAmountString,
-    amount: `${totalAmountString} / ${currencyAmountString}`,
-    status: x.status,
-    etherscanLink: getEtherScanHashLink(x.transaction_hash, x.chain_id || MAINNET_CHAIN_ID),
-    chainId: x.chain_id,
-    ethRate:
-      Number.parseFloat(x?.total_amount) && Number.parseFloat(x?.currency_amount)
-        ? `1 ${x.symbol} = ${significantDigits(Number.parseFloat(x.currency_amount) / Number.parseFloat(x.total_amount))}`
-        : "",
-    currencyUsed: x.selected_currency,
-    type: x.type,
-    type_name: x.type_name,
-    type_image_link: x.type_image_link,
-    transaction_hash: x.transaction_hash,
-    transaction_category: x.transaction_category,
-    isEtherscan: x.isEtherscan,
-    input: x.input || "",
-    token_id: x.token_id || "",
-    contract_address: x.contract_address || "",
-    nonce: x.nonce || "",
-    is_cancel: !!x.is_cancel || false,
-    gas: x.gas || "",
-    gasPrice: x.gasPrice || "",
-  };
-  return finalObject;
-};
-
-/**
- * Ref - https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt
- */
-export const getEthTxStatus = async (hash: string, provider: SafeEventEmitterProvider): Promise<TransactionStatus | undefined> => {
-  try {
-    const result = await provider.request<[string], TransactionReceipt>({ 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;
-  }
-};
-
-export function formatDate(inputDate: string) {
-  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}`;
-}
-
-export function formatTime(time: number) {
-  return new Date(time).toTimeString().slice(0, 8);
-}
-
-export const idleTimeTracker = ((activityThresholdTime: number): { checkIfIdle: () => boolean } => {
-  let isIdle = false;
-  let idleTimeout: number = 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);
-  }
-
-  function checkIfIdle() {
-    return isIdle;
-  }
-  return {
-    checkIfIdle,
-  };
-})(60 * 3);
-
-export function isAddressByChainId(address: string, _chainId: string) {
-  // TOOD: add rsk network checks.
-  return isValidAddress(address);
-}
-
-export function toChecksumAddressByChainId(address: string, chainId: string) {
-  // TOOD: add rsk network checks.
-  if (!isAddressByChainId(address, chainId)) return address;
-  return toChecksumAddress(address);
-}
-
-export const GAS_LIMITS = {
-  // maximum gasLimit of a simple send
-  SIMPLE: addHexPrefix((21_000).toString(16)),
-  // a base estimate for token transfers.
-  BASE_TOKEN_ESTIMATE: addHexPrefix((100_000).toString(16)),
-};
-
-export function bnLessThan(a: string | number, b: string | number) {
-  if (a === null || a === undefined || b === null || b === undefined) {
-    return null;
-  }
-  return new BigNumber(a, 10).lt(b, 10);
-}
-
-export const getIpfsEndpoint = (path: string) => `https://infura-ipfs.io/${path}`;
-
-export function sanitizeNftMetdataUrl(url: string): string {
-  let finalUri = url;
-  if (url?.startsWith("ipfs")) {
-    const ipfsPath = url.split("ipfs://")[1];
-    finalUri = getIpfsEndpoint(ipfsPath);
-  }
-  return finalUri;
-}
-
-export function getChainType(chainId: string) {
-  if (chainId === MAINNET_CHAIN_ID) {
-    return "mainnet";
-  } else if ((TEST_CHAINS as string[]).includes(chainId)) {
-    return "testnet";
-  }
-  return "custom";
-}
-
-export const addEtherscanTransactions = async (
-  txn: EtherscanTransaction[],
-  lowerCaseSelectedAddress: string,
-  provider: SafeEventEmitterProvider,
-  chainId: string
-) => {
-  const transactionPromises = await Promise.all(
-    txn.map(async (tx: EtherscanTransaction) => {
-      const { category, type } = await determineTransactionType({ ...tx, data: tx.input } as TransactionParams, provider);
-      tx.transaction_category = tx.transaction_category || category;
-      tx.type_image_link = SUPPORTED_NETWORKS[chainId]?.logo || "";
-      tx.type_name = SUPPORTED_NETWORKS[chainId]?.ticker;
-      tx.type = type;
-      return tx;
-    })
-  );
-
-  const finalTxs = transactionPromises.reduce((accumulator, x) => {
-    const totalAmountString = x.value ? formatEther(x.value) : "";
-
-    const etherscanTransaction: TransactionPayload = {
-      etherscanLink: getEtherScanHashLink(x.hash, chainId),
-      type: x.type || SUPPORTED_NETWORKS[chainId]?.ticker || CONTRACT_TYPE_ETH,
-      type_image_link: x.type_image_link || "n/a",
-      type_name: x.type_name || "n/a",
-      symbol: SUPPORTED_NETWORKS[chainId]?.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: x.gas,
-      gasPrice: x.gasPrice,
-      chain_id: chainId,
-      currency_amount: "",
-      nonce: x.nonce,
-      from_aa_address: "",
-      is_cancel: false,
-      selected_currency: "",
-    };
-    accumulator.push(formatPastTx(etherscanTransaction, lowerCaseSelectedAddress));
-    return accumulator;
-  }, []);
-
-  return finalTxs;
-};