@swapper-finance/sdk/src/utils/numbers.ts

JavaScript SDK form Swapper

import BigNumberJS from "bignumber.js";
import { BigNumber, ethers } from "ethers";

const safeBigNumberFrom = (value: string) => {
  BigNumberJS.config({ DECIMAL_PLACES: 0 });
  return BigNumber.from(new BigNumberJS(value).div(1).toFixed());
};

export const weiToHumanReadable = ({
  amount,
  decimals,
  precisionFractionalPlaces,
  prettifySmallNumber = false,
}: {
  amount: string;
  decimals: number;
  precisionFractionalPlaces: number;
  prettifySmallNumber?: boolean;
}): string => {
  const decimalsFactor = Math.pow(10, decimals);

  BigNumberJS.config({ DECIMAL_PLACES: precisionFractionalPlaces });

  const res = new BigNumberJS(amount).div(decimalsFactor).toFixed();
  if (prettifySmallNumber && res === "0" && amount !== "0") {
    return `<${(1 / 10 ** precisionFractionalPlaces).toFixed(
      precisionFractionalPlaces,
    )}`;
  }
  return res;
};

export const humanReadableToWei = ({
  amount,
  decimals,
}: {
  amount: string;
  decimals: number;
}): string => {
  const decimalsFactor = Math.pow(10, decimals);
  const parsedAmount = new BigNumberJS(amount || "0");
  return safeBigNumberFrom(
    parsedAmount.mul(decimalsFactor).toFixed(),
  ).toString();
};

export const formatTokenValue = (tokenBalance, tokenPrice, tokenDecimals) => {
  if (!tokenBalance || !tokenPrice) {
    return;
  }
  return (
    Number(ethers.utils.formatUnits(tokenBalance, tokenDecimals)) *
    Number(tokenPrice)
  ).toFixed(2);
};

export const abbreviateNumber = (
  value: number | string,
  forcedPrecision?: number,
  isUsdc: boolean = false,
) => {
  const numberValue = parseFloat(value.toString());
  if (numberValue === 0) return "0";
  if (isNaN(numberValue)) return value.toString();

  const floorDecimals = (num: number, decimals: number) => {
    const factor = 10 ** decimals;
    return (Math.floor(num * factor) / factor)
      .toString()
      .replace(/(\.\d*?[1-9])0+$/, "$1")
      .replace(/\.0+$/, "");
  };
  if (numberValue >= 1_000_000_000_000) {
    return (
      floorDecimals(numberValue / 1_000_000_000_000, forcedPrecision || 2) + "t"
    );
  } else if (numberValue >= 1_000_000_000) {
    return (
      floorDecimals(numberValue / 1_000_000_000, forcedPrecision || 2) + "b"
    );
  } else if (numberValue >= 1_000_000) {
    return floorDecimals(numberValue / 1_000_000, forcedPrecision || 2) + "m";
  } else if (numberValue >= 1_000) {
    return floorDecimals(numberValue / 1_000, forcedPrecision || 2) + "k";
  } else if (numberValue >= 1) {
    return floorDecimals(numberValue, forcedPrecision || 2);
  } else if (isUsdc && numberValue < 0.01 && numberValue > 0) {
    return "<0.01";
  } else if (numberValue < 0.00001 && numberValue > 0) {
    return "<0.00001";
  } else {
    return floorDecimals(numberValue, forcedPrecision || 5);
  }
};

export const displayLessThan = (value: number | string, threshold: number) => {
  const num = Number(value);
  if (num === 0) return "0";
  return num < threshold ? `<${threshold}` : num;
};

export const formatWithThousandSpaces = (value: number | string): string => {
  return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, " ");
};