@toruslabs/ethereum-controllers 4.1.0

package/src/utils/helpers.ts

@@ -0,0 +1,177 @@
+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 log from "loglevel";
+
+import {
+  CONTRACT_TYPE_ERC20,
+  CONTRACT_TYPE_ERC721,
+  CONTRACT_TYPE_ERC1155,
+  MAINNET_CHAIN_ID,
+  METHOD_TYPES,
+  SUPPORTED_NETWORKS,
+  TEST_CHAINS,
+} from "./constants";
+import { FormattedTransactionActivity, 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
+      ? ""
+      : 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.network || MAINNET_CHAIN_ID),
+    networkType: x.network,
+    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,
+    // TODO: // figure out how to handle these values.
+    // 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);
+  };
+
+  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";
+}

package/src/utils/interfaces.ts

@@ -0,0 +1,454 @@
+import { AccessList } from "@ethereumjs/common";
+import { SignTypedDataVersion } from "@metamask/eth-sig-util";
+import {
+  AddressPreferences,
+  BaseBlockTrackerState,
+  NetworkConfig,
+  NetworkState,
+  PaymentTransaction,
+  PopupWhitelabelData,
+  ProviderConfig,
+  TRANSACTION_TYPE,
+  TransactionMeta,
+  TransactionStatus,
+  User,
+} from "@toruslabs/base-controllers";
+import { Json } from "@toruslabs/openlogin-jrpc";
+import { MutexInterface } from "async-mutex";
+
+import { MessageStatus, METHOD_TYPES, TRANSACTION_ENVELOPE_TYPES } from "./constants";
+
+export type CustomTokenInfo = {
+  tokenAddress: string;
+  name: string;
+  chainId: string;
+  erc20: boolean;
+  symbol: string;
+  decimals: string;
+  balance?: string;
+  customTokenId?: string;
+  isEtherScan?: boolean;
+  logo?: string;
+};
+
+export type CustomNftItemInfo = {
+  image: string;
+  name: string;
+  tokenBalance: string;
+  description: string;
+  tokenId: string;
+  video?: string;
+  decimals?: string;
+  customNftId?: string;
+};
+export type NftStandardType = "erc721" | "erc1155";
+
+export type CustomNftInfo = {
+  contractAddress: string;
+  contractName: string;
+  contractSymbol: string;
+  contractImage?: string;
+  contractSupply?: string;
+  contractFallbackLogo?: string;
+  nftStandard: NftStandardType;
+  contractDescription?: string;
+  chainId: string;
+  assets: CustomNftItemInfo[];
+};
+
+export interface EthereumBlock {
+  blockHash: string;
+  idempotencyKey: string;
+  timestamp: string;
+  baseFeePerGas: string;
+  gasLimit: string;
+}
+
+export interface UserRequestApprovalParams {
+  windowId?: string;
+  origin?: string;
+}
+
+export interface BaseRequestParams {
+  /**
+   * Unique id for each request
+   */
+  id: string;
+  /**
+   * Address to send this transaction from.
+   */
+  from: string;
+
+  /**
+   * Domain requested from
+   */
+  origin?: string;
+}
+
+export interface MessageParams extends BaseRequestParams {
+  data: string;
+}
+
+export type MessageStatusType = (typeof MessageStatus)[keyof typeof MessageStatus];
+
+export interface AbstractMessage {
+  id: string;
+  time: number;
+  status: MessageStatusType;
+  /**
+   * JRPC method for which sig request is made
+   */
+  type: string;
+  rawSig?: string;
+  metadata?: Json;
+  error?: string;
+}
+
+export interface Message extends AbstractMessage {
+  messageParams: MessageParams;
+}
+
+export type SignTypedDataMessageV3V4 = {
+  types: Record<string, unknown>;
+  domain: Record<string, unknown>;
+  primaryType: string;
+  message: unknown;
+};
+
+export interface TypedMessageParams extends BaseRequestParams {
+  data: Record<string, unknown>[] | string | SignTypedDataMessageV3V4;
+  version?: SignTypedDataVersion;
+}
+
+export interface TypedMessage extends AbstractMessage {
+  messageParams: TypedMessageParams;
+}
+export type TRANSACTION_ENVELOPE_TYPES_TYPE = (typeof TRANSACTION_ENVELOPE_TYPES)[keyof typeof TRANSACTION_ENVELOPE_TYPES];
+
+export interface TransactionParams extends BaseRequestParams {
+  /**
+   * Network ID as per EIP-155.
+   */
+  chainId?: string;
+
+  /**
+   * Data to pass with this transaction.
+   */
+  data?: string;
+
+  /**
+   * Error message for gas estimation failure.
+   */
+  estimateGasError?: string;
+
+  /**
+   * Estimated base fee for this transaction.
+   */
+  estimatedBaseFee?: string;
+
+  /**
+   * Gas to send with this transaction.
+   */
+  gas?: string;
+
+  /**
+   * Price of gas with this transaction.
+   */
+  gasPrice?: string;
+
+  /**
+   * Gas used in the transaction.
+   */
+  gasUsed?: string;
+
+  /**
+   * Maximum fee per gas for this transaction.
+   */
+  maxFeePerGas?: string;
+
+  /**
+   * Maximum priority fee per gas for this transaction.
+   */
+  maxPriorityFeePerGas?: string;
+
+  /**
+   * Unique number to prevent replay attacks.
+   */
+  nonce?: string;
+
+  /**
+   * Address to send this transaction to.
+   */
+  to?: string;
+
+  /**
+   * Value associated with this transaction.
+   */
+  value?: string;
+
+  /**
+   * EIP 2930
+   */
+  accessList?: AccessList;
+  /**
+   * Custom Nonce passed by the user
+   */
+  customNonceValue?: string;
+  /**
+   * Transaction envelope type
+   */
+  type?: TRANSACTION_ENVELOPE_TYPES_TYPE;
+
+  /**
+   * Max Gas to send with this transaction.
+   */
+  gasLimit?: string;
+}
+
+export type Nonce = {
+  name: string;
+  nonce: number;
+  details: {
+    startPoint?: number;
+    highest?: number;
+    block?: EthereumBlock;
+    baseCount?: number;
+  };
+};
+
+export type NonceDetails = {
+  params: {
+    highestLocallyConfirmed: number; // A hex string of the highest nonce on a confirmed transaction.
+    nextNetworkNonce: number; // The next nonce suggested by the eth_getTransactionCount method.
+    highestSuggested: number; // The maximum between the other two, the number returned.
+  };
+  local: Nonce;
+  network: Nonce;
+};
+
+/**
+ * Ref - https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_gettransactionreceipt
+ */
+export interface TransactionReceipt {
+  transactionHash: string;
+  transactionIndex: string;
+  blockNumber: string;
+  blockHash: string;
+  from: string;
+  to: string | null;
+  cumulativeGasUsed: string;
+  effectiveGasPrice: string;
+  gasUsed: string;
+  contractAddress: string | null;
+  logs: unknown[];
+  logsBloom: string;
+  type: TRANSACTION_ENVELOPE_TYPES_TYPE;
+  root?: string;
+  status?: "0x0" | "0x1";
+}
+
+export type BlockTag = "earliest" | "finalized" | "safe" | "latest" | "pending";
+export type BlockParams = string | BlockTag;
+
+export interface TransactionRPCMeta {
+  v: string;
+  r: string;
+  s: string;
+  to: string | null;
+  gas: string;
+  from: string;
+  hash: string;
+  nonce: string;
+  input: string;
+  value: string;
+  accessList?: string[];
+  blockHash: string | null;
+  blockNumber: string | null;
+  transactionIndex: string | null;
+  maxFeePerGas?: string;
+  maxPriorityFeePerGas?: string;
+  gasPrice?: string;
+  type: TRANSACTION_ENVELOPE_TYPES_TYPE;
+  chainID?: string;
+}
+
+export type PollingBlockTrackerState = BaseBlockTrackerState<EthereumBlock>;
+
+export interface EthereumProviderConfig extends ProviderConfig {
+  isErc20?: boolean;
+  tokenAddress?: string;
+  isTestNet?: boolean;
+  // infuraKey?: string;
+}
+
+export interface EthereumNetworkState extends NetworkState {
+  providerConfig: EthereumProviderConfig;
+}
+
+export interface EthereumNetworkConfig extends NetworkConfig {
+  providerConfig: EthereumProviderConfig;
+}
+
+export type CustomNetworkPayload = Partial<EthereumProviderConfig> & Pick<EthereumProviderConfig, "chainId" | "displayName" | "rpcTarget" | "ticker">;
+
+export interface CustomNetworks {
+  id: number;
+  created_at: Date;
+  updated_at: Date;
+  network_name: string;
+  public_address: string;
+  chain_id: string;
+  type: string;
+  rpc_url: string;
+  deleted: boolean;
+  symbol?: string;
+  block_explorer_url?: string;
+  is_test_net?: boolean;
+}
+
+export interface EthereumUser extends User {
+  customNetworks: CustomNetworks[];
+}
+
+export interface ContractParams {
+  erc20?: boolean;
+  erc721?: boolean;
+  erc1155?: boolean;
+  isSpecial?: boolean;
+  symbol?: string;
+  logo?: string;
+  decimals?: number;
+}
+
+export interface DappSuggestedGasFees {
+  gasPrice?: string;
+  maxPriorityFeePerGas?: string;
+  maxFeePerGas?: string;
+  gas?: string;
+}
+
+export interface EthereumTransactionMeta extends TransactionMeta<TransactionParams> {
+  r?: string;
+  s?: string;
+  v?: string;
+  type: string;
+  txReceipt?: TransactionReceipt;
+  history: Record<string, unknown>[];
+  accessList?: string[];
+  firstRetryBlockNumber?: string;
+  retryCount?: number;
+  simulationFails?: Record<string, unknown>;
+  loadingDefaults?: boolean;
+  transactionCategory?: TRANSACTION_TYPE;
+  nonceDetails?: NonceDetails;
+  methodParams?: unknown[];
+  dappSuggestedGasFees?: DappSuggestedGasFees;
+}
+
+// TODO:// mark fields which will be optional.
+export interface TransactionPayload {
+  created_at: Date;
+  from: string;
+  to: string;
+  total_amount: string;
+  currency_amount: string;
+  selected_currency: string;
+  status?: TransactionStatus;
+  network: string;
+  transaction_hash: string;
+  transaction_category: string;
+  gas: string;
+  gasPrice: string;
+  nonce: string;
+  type: string;
+  type_name: string;
+  type_image_link: string;
+  symbol: string;
+  is_cancel: boolean;
+  contract_address?: string;
+  from_aa_address?: string;
+}
+
+export interface FetchedTransaction extends TransactionPayload {
+  id: string;
+}
+
+export interface FetchCommonTransaction extends PaymentTransaction {
+  etherscanLink?: string | null;
+}
+
+export interface FormattedTransactionActivity {
+  id: string;
+  date: string;
+  from: string;
+  from_aa_address?: string;
+  slicedFrom: string;
+  to: string;
+  slicedTo: string;
+  action: string;
+  totalAmount: string;
+  totalAmountString: string;
+  currencyAmount: string;
+  currencyAmountString: string;
+  amount: string;
+  status: TransactionStatus;
+  etherscanLink: string;
+  ethRate: string;
+  currencyUsed: string;
+  networkType: string;
+  type: string;
+  type_name: string;
+  type_image_link: string;
+  transaction_hash: string;
+  isEtherscan?: boolean;
+  transaction_category: string;
+  input?: string;
+  contract_address?: string;
+  token_id?: string;
+  nonce: string;
+  is_cancel: boolean;
+  gas: string;
+  gasPrice: string;
+  hasCancel?: boolean;
+  cancelDateInitiated?: string;
+  cancelGas?: string;
+  cancelGasPrice?: string;
+}
+
+export interface ExtendedAddressPreferences extends AddressPreferences {
+  fetchedPastTx?: FetchedTransaction[];
+  formattedPastTransactions?: FormattedTransactionActivity[];
+  paymentTx: FetchCommonTransaction[];
+  customNetworks: CustomNetworks[];
+}
+
+export interface ProviderChangeChannelEventData {
+  newNetwork: EthereumProviderConfig;
+  whitelabelData: PopupWhitelabelData;
+  origin: string;
+  currentChainId: string;
+}
+
+export interface NonceLockRes {
+  nextNonce: number;
+  nonceDetails: NonceDetails;
+  releaseLock: MutexInterface.Releaser;
+}
+
+export type METHOD_TYPES_TYPE = (typeof METHOD_TYPES)[keyof typeof METHOD_TYPES];
+
+export interface EncryptionPublicKeyParams extends BaseRequestParams {
+  data: string;
+}
+
+export interface EncryptionPublicKey extends AbstractMessage {
+  messageParams: EncryptionPublicKeyParams;
+}
+
+export interface DecryptMessageParams extends BaseRequestParams {
+  data: string;
+}
+
+export interface DecryptMessage extends AbstractMessage {
+  messageParams: DecryptMessageParams;
+}