@toruslabs/ethereum-controllers 4.1.0

package/src/utils/constants.ts

@@ -0,0 +1,379 @@
+import { EthereumProviderConfig } from "./interfaces";
+
+export const LOCALHOST = "localhost";
+
+export const CONTRACT_TYPE_ETH = "eth";
+export const CONTRACT_TYPE_ERC20 = "erc20";
+export const CONTRACT_TYPE_ERC721 = "erc721";
+export const CONTRACT_TYPE_ERC1155 = "erc1155";
+
+export const ERC1155_INTERFACE_ID = "0xd9b67a26";
+export const ERC721_INTERFACE_ID = "0x80ac58cd";
+export const ERC721_METADATA_INTERFACE_ID = "0x5b5e139f";
+export const ERC721_ENUMERABLE_INTERFACE_ID = "0x780e9d63";
+
+export const MAINNET_CHAIN_ID = "0x1";
+export const POLYGON_CHAIN_ID = "0x89";
+export const BSC_MAINNET_CHAIN_ID = "0x38";
+export const AVALANCHE_MAINNET_CHAIN_ID = "0xa86a";
+export const XDAI_CHAIN_ID = "0x64";
+export const ARBITRUM_MAINNET_CHAIN_ID = "0xa4b1";
+export const OPTIMISM_MAINNET_CHAIN_ID = "0xa";
+export const CELO_MAINNET_CHAIN_ID = "0xa4ec";
+
+export const GOERLI_CHAIN_ID = "0x5";
+export const SEPOLIA_CHAIN_ID = "0xaa36a7";
+export const POLYGON_MUMBAI_CHAIN_ID = "0x13881";
+export const BSC_TESTNET_CHAIN_ID = "0x61";
+export const AVALANCHE_TESTNET_CHAIN_ID = "0xa869";
+export const ARBITRUM_TESTNET_CHAIN_ID = "0x66eeb";
+export const OPTIMISM_TESTNET_CHAIN_ID = "0x1a4";
+
+export const SUPPORTED_NETWORKS: Record<string, EthereumProviderConfig> = {
+  [MAINNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://etherscan.io",
+    chainId: MAINNET_CHAIN_ID,
+    displayName: "Main Ethereum Network",
+    logo: "eth.svg",
+    rpcTarget: `https://mainnet.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "ETH",
+    tickerName: "Ethereum",
+  },
+  [POLYGON_CHAIN_ID]: {
+    blockExplorerUrl: "https://polygonscan.com",
+    chainId: POLYGON_CHAIN_ID,
+    displayName: "Polygon Mainnet",
+    logo: "matic-network-logo.svg",
+    rpcTarget: `https://polygon-mainnet.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "MATIC",
+    tickerName: "Matic Network Token",
+  },
+  [BSC_MAINNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://bscscan.com",
+    chainId: BSC_MAINNET_CHAIN_ID,
+    displayName: "Binance Smart Chain Mainnet",
+    logo: "bnb.png",
+    rpcTarget: `https://bsc-dataseed.binance.org`,
+    ticker: "BNB",
+    tickerName: "Binance Coin",
+  },
+  [AVALANCHE_MAINNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://snowtrace.io",
+    chainId: AVALANCHE_MAINNET_CHAIN_ID,
+    displayName: "Avalanche Mainnet C-Chain",
+    logo: "avax.svg",
+    rpcTarget: `https://api.avax.network/ext/bc/C/rpc`,
+    ticker: "AVAX",
+    tickerName: "Avalanche",
+  },
+  [OPTIMISM_MAINNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://optimistic.etherscan.io",
+    chainId: OPTIMISM_MAINNET_CHAIN_ID,
+    displayName: "Optimism",
+    logo: "optimism.svg",
+    rpcTarget: `https://optimism-mainnet.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "ETH",
+    tickerName: "Ethereum",
+  },
+  [CELO_MAINNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://explorer.celo.org",
+    chainId: CELO_MAINNET_CHAIN_ID,
+    displayName: "Celo Mainnet",
+    logo: "celo.svg",
+    rpcTarget: `https://celo-mainnet.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "CELO",
+    tickerName: "Celo",
+  },
+  [ARBITRUM_MAINNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://arbiscan.io",
+    chainId: ARBITRUM_MAINNET_CHAIN_ID,
+    displayName: "Arbitrum One",
+    logo: "eth.svg",
+    rpcTarget: `https://arbitrum-mainnet.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "ETH",
+    tickerName: "Ethereum",
+  },
+  [XDAI_CHAIN_ID]: {
+    blockExplorerUrl: "https://blockscout.com/poa/xdai",
+    chainId: XDAI_CHAIN_ID,
+    displayName: "xDai",
+    logo: "xdai.svg",
+    rpcTarget: `https://rpc.gnosischain.com`,
+    ticker: "DAI",
+    tickerName: "xDai Network Token",
+  },
+  [GOERLI_CHAIN_ID]: {
+    blockExplorerUrl: "https://goerli.etherscan.io",
+    chainId: GOERLI_CHAIN_ID,
+    displayName: "Goerli Test Network",
+    logo: "eth.svg",
+    rpcTarget: `https://goerli.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "ETH",
+    tickerName: "Ethereum",
+    isTestNet: true,
+  },
+  [SEPOLIA_CHAIN_ID]: {
+    blockExplorerUrl: "https://sepolia.etherscan.io",
+    chainId: SEPOLIA_CHAIN_ID,
+    displayName: "Sepolia Test Network",
+    logo: "eth.svg",
+    rpcTarget: `https://sepolia.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "ETH",
+    tickerName: "Ethereum",
+    isTestNet: true,
+  },
+  [POLYGON_MUMBAI_CHAIN_ID]: {
+    blockExplorerUrl: "https://mumbai.polygonscan.com",
+    chainId: POLYGON_MUMBAI_CHAIN_ID,
+    displayName: "Polygon Mumbai",
+    logo: "matic-network-logo.svg",
+    rpcTarget: `https://polygon-mumbai.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "MATIC",
+    tickerName: "Matic Network Token",
+    isTestNet: true,
+  },
+  [BSC_TESTNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://testnet.bscscan.com",
+    chainId: BSC_TESTNET_CHAIN_ID,
+    displayName: "Binance Smart Chain Testnet",
+    logo: "bnb.png",
+    rpcTarget: `https://data-seed-prebsc-1-s1.binance.org:8545`,
+    ticker: "BNB",
+    tickerName: "Binance Coin",
+    isTestNet: true,
+  },
+  [AVALANCHE_TESTNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://testnet.snowtrace.io",
+    chainId: AVALANCHE_TESTNET_CHAIN_ID,
+    displayName: "Avalanche Testnet C-Chain",
+    logo: "avax.png",
+    rpcTarget: `https://api.avax-test.network/ext/bc/C/rpc`,
+    ticker: "AVAX",
+    tickerName: "Avalanche",
+    isTestNet: true,
+  },
+  [ARBITRUM_TESTNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://testnet.arbiscan.io",
+    chainId: ARBITRUM_TESTNET_CHAIN_ID,
+    displayName: "Arbitrum Goerli",
+    logo: "eth.svg",
+    rpcTarget: `https://arbitrum-rinkeby.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "ETH",
+    tickerName: "Ethereum",
+    isTestNet: true,
+  },
+  [OPTIMISM_TESTNET_CHAIN_ID]: {
+    blockExplorerUrl: "https://goerli-optimism.etherscan.io",
+    chainId: OPTIMISM_TESTNET_CHAIN_ID,
+    displayName: "Optimism Goerli",
+    logo: "optimism.svg",
+    rpcTarget: `https://optimism-goerli.infura.io/v3/${process.env.VITE_APP_INFURA_PROJECT_KEY}`,
+    ticker: "ETH",
+    tickerName: "Ethereum",
+    isTestNet: true,
+  },
+};
+
+export const METHOD_TYPES = {
+  GET_ACCOUNTS: "eth_accounts",
+  ETH_TRANSACTION: "eth_sendTransaction",
+  ETH_REQUEST_ACCOUNTS: "eth_requestAccounts",
+  ETH_SEND_RAW_TRANSACTION: "eth_sendRawTransaction",
+  ETH_SIGN: "eth_sign",
+  ETH_SIGN_TYPED_DATA: "eth_signTypedData",
+  ETH_SIGN_TYPED_DATA_V3: "eth_signTypedData_v3",
+  ETH_SIGN_TYPED_DATA_V4: "eth_signTypedData_v4",
+  PERSONAL_SIGN: "personal_sign",
+  ETH_GET_TRANSACTION_COUNT: "eth_getTransactionCount",
+  ETH_GET_TRANSACTION_BY_HASH: "eth_getTransactionByHash",
+  ETH_GET_ENCRYPTION_PUBLIC_KEY: "eth_getEncryptionPublicKey",
+  ETH_DECRYPT: "eth_decrypt",
+  ETH_GET_TRANSACTION_RECEIPT: "eth_getTransactionReceipt",
+  WATCH_ASSET: "wallet_watchAsset",
+  ETH_GET_BLOCK_BY_HASH: "eth_getBlockByHash",
+  ETH_GET_CODE: "eth_getCode",
+  ETH_GET_GAS_PRICE: "eth_gasPrice",
+} as const;
+
+export const TRANSACTION_ENVELOPE_TYPES = {
+  LEGACY: "0x0",
+  ACCESS_LIST: "0x1",
+  FEE_MARKET: "0x2",
+} as const;
+
+export const GAS_ESTIMATE_TYPES = {
+  // Fee Market describes the way gas is set after the london hardfork, and was
+  // defined by EIP-1559.
+  FEE_MARKET: "fee-market",
+  // Legacy describes gasPrice estimates from before london hardfork, when the
+  // user is connected to mainnet and are presented with fast/average/slow
+  // estimate levels to choose from.
+  LEGACY: "legacy",
+  // EthGasPrice describes a gasPrice estimate received from eth_gasPrice. Post
+  // london this value should only be used for legacy type transactions when on
+  // networks that support EIP-1559. This type of estimate is the most accurate
+  // to display on custom networks that don't support EIP-1559.
+  ETH_GASPRICE: "eth_gasPrice",
+  // NoEstimate describes the state of the controller before receiving its first
+  // estimate.
+  NONE: "none",
+} as const;
+
+// https://help.optimism.io/hc/en-us/articles/4411895794715-Transaction-fees
+export const CHAIN_ID_TO_GAS_LIMIT_BUFFER_MAP: Record<string, number> = {
+  [OPTIMISM_MAINNET_CHAIN_ID]: 1,
+  [OPTIMISM_TESTNET_CHAIN_ID]: 1,
+};
+
+export const OLD_ERC721_LIST: Record<string, { name?: string; logo?: string; erc20?: boolean; symbol?: string; decimals?: number }> = {
+  "0x06012c8cf97bead5deae237070f9587f8e7a266d": {
+    name: "Cryptokitties",
+    logo: "dapp-cryptokitty.svg",
+    erc20: true,
+    symbol: "CK",
+    decimals: 0,
+  },
+};
+
+export const TEST_CHAINS = [GOERLI_CHAIN_ID, SEPOLIA_CHAIN_ID];
+
+export const ETHERSCAN_SUPPORTED_CHAINS = [
+  MAINNET_CHAIN_ID,
+  GOERLI_CHAIN_ID,
+  SEPOLIA_CHAIN_ID,
+  BSC_MAINNET_CHAIN_ID,
+  BSC_TESTNET_CHAIN_ID,
+  OPTIMISM_MAINNET_CHAIN_ID,
+  OPTIMISM_TESTNET_CHAIN_ID,
+  AVALANCHE_MAINNET_CHAIN_ID,
+  AVALANCHE_TESTNET_CHAIN_ID,
+  ARBITRUM_MAINNET_CHAIN_ID,
+  ARBITRUM_TESTNET_CHAIN_ID,
+  POLYGON_CHAIN_ID,
+  POLYGON_MUMBAI_CHAIN_ID,
+  CELO_MAINNET_CHAIN_ID,
+];
+
+export const SIMPLEHASH_SUPPORTED_CHAINS = [
+  MAINNET_CHAIN_ID,
+  POLYGON_CHAIN_ID,
+  POLYGON_MUMBAI_CHAIN_ID,
+  BSC_MAINNET_CHAIN_ID,
+  BSC_TESTNET_CHAIN_ID,
+  ARBITRUM_MAINNET_CHAIN_ID,
+  ARBITRUM_TESTNET_CHAIN_ID,
+  OPTIMISM_MAINNET_CHAIN_ID,
+  OPTIMISM_TESTNET_CHAIN_ID,
+  CELO_MAINNET_CHAIN_ID,
+  AVALANCHE_MAINNET_CHAIN_ID,
+  AVALANCHE_TESTNET_CHAIN_ID,
+  GOERLI_CHAIN_ID,
+];
+
+export const COINGECKO_SUPPORTED_CURRENCIES = new Set([
+  "btc",
+  "eth",
+  "ltc",
+  "bch",
+  "bnb",
+  "eos",
+  "xrp",
+  "xlm",
+  "link",
+  "dot",
+  "yfi",
+  "usd",
+  "aed",
+  "ars",
+  "aud",
+  "bdt",
+  "bhd",
+  "bmd",
+  "brl",
+  "cad",
+  "chf",
+  "clp",
+  "cny",
+  "czk",
+  "dkk",
+  "eur",
+  "gbp",
+  "hkd",
+  "huf",
+  "idr",
+  "ils",
+  "inr",
+  "jpy",
+  "krw",
+  "kwd",
+  "lkr",
+  "mmk",
+  "mxn",
+  "myr",
+  "ngn",
+  "nok",
+  "nzd",
+  "php",
+  "pkr",
+  "pln",
+  "rub",
+  "sar",
+  "sek",
+  "sgd",
+  "thb",
+  "try",
+  "twd",
+  "uah",
+  "vef",
+  "vnd",
+  "zar",
+  "xdr",
+  "xag",
+  "xau",
+  "bits",
+  "sats",
+]);
+
+export const COINGECKO_PLATFORMS_CHAIN_CODE_MAP: Record<string, { platform: string; currency: string }> = {
+  [POLYGON_CHAIN_ID]: {
+    platform: "polygon-pos",
+    currency: "matic",
+  },
+  [BSC_MAINNET_CHAIN_ID]: {
+    platform: "binance-smart-chain",
+    currency: "bnb",
+  },
+  [MAINNET_CHAIN_ID]: {
+    platform: "ethereum",
+    currency: "eth",
+  },
+  [ARBITRUM_MAINNET_CHAIN_ID]: {
+    platform: "arbitrum-one",
+    currency: "eth",
+  },
+  [OPTIMISM_MAINNET_CHAIN_ID]: {
+    platform: "optimistic-ethereum",
+    currency: "eth",
+  },
+  [CELO_MAINNET_CHAIN_ID]: {
+    platform: "celo",
+    currency: "celo",
+  },
+  [XDAI_CHAIN_ID]: {
+    platform: "xdai",
+    currency: "xDAI",
+  },
+  [AVALANCHE_MAINNET_CHAIN_ID]: {
+    platform: "avalanche",
+    currency: "avax",
+  },
+};
+
+export const MessageStatus = {
+  UNAPPROVED: "unapproved",
+  SIGNED: "signed",
+  PENDING: "pending",
+  APPROVED: "approved",
+  REJECTED: "rejected",
+  FAILED: "failed",
+} as const;

package/src/utils/contractAddresses.ts

@@ -0,0 +1,21 @@
+import {
+  ARBITRUM_MAINNET_CHAIN_ID,
+  AVALANCHE_MAINNET_CHAIN_ID,
+  BSC_MAINNET_CHAIN_ID,
+  GOERLI_CHAIN_ID,
+  MAINNET_CHAIN_ID,
+  OPTIMISM_MAINNET_CHAIN_ID,
+  POLYGON_CHAIN_ID,
+} from "../utils/constants";
+
+export const SINGLE_CALL_BALANCES_ADDRESSES: Record<string, string> = {
+  [MAINNET_CHAIN_ID]: "0xb1f8e55c7f64d203c1400b9d8555d050f94adf39",
+  [GOERLI_CHAIN_ID]: "0x9788C4E93f9002a7ad8e72633b11E8d1ecd51f9b",
+  // [SEPOLIA_CHAIN_ID]: SINGLE_CALL_BALANCES_ADDRESS_SEPOLIA,
+  // [FANTOM_CHAIN_ID]: "0x07f697424ABe762bB808c109860c04eA488ff92B",
+  [BSC_MAINNET_CHAIN_ID]: "0x2352c63A83f9Fd126af8676146721Fa00924d7e4",
+  [OPTIMISM_MAINNET_CHAIN_ID]: "0xB1c568e9C3E6bdaf755A60c7418C269eb11524FC",
+  [POLYGON_CHAIN_ID]: "0x2352c63A83f9Fd126af8676146721Fa00924d7e4",
+  [AVALANCHE_MAINNET_CHAIN_ID]: "0xD023D153a0DFa485130ECFdE2FAA7e612EF94818",
+  [ARBITRUM_MAINNET_CHAIN_ID]: "0x151E24A486D7258dd7C33Fb67E4bB01919B7B32c",
+};

package/src/utils/conversionUtils.ts

@@ -0,0 +1,269 @@
+// 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);
+};