@mezo-org/passport 0.4.0-dev.4 → 0.4.0-dev.41

package/src/utils/numbers.ts

@@ -0,0 +1,188 @@
+type DesiredDecimals = Intl.NumberFormatOptions &
+  BigIntToLocaleStringOptions["minimumFractionDigits"]
+
+/**
+ * Formats a number or bigint into compact string with K, M, B, or T suffix.
+ * @param value The number or bigint to format.
+ * @param decimals Number of decimal places to include (ignored for bigint to avoid floating point issues).
+ * @returns The formatted number as a string.
+ */
+export function formatNumberToCompactString(
+  value: number | bigint,
+  decimals = 4,
+): string {
+  return value.toLocaleString("en-US", {
+    notation: "compact",
+    compactDisplay: "short",
+    maximumFractionDigits: decimals as DesiredDecimals,
+  })
+}
+
+/**
+ * Formats a number or string into a locale-sensitive string with the desired number of decimals.
+ * @param value The number or string to format.
+ * @param desiredDecimals The number of decimal places to include.
+ * @returns The formatted number as a string.
+ * @see https://github.com/thesis/acre/blob/2078d339f4ddce79e69c78529c9d72910dd2640a/dapp/src/utils/numbersUtils.ts#L5-L19
+ */
+export function formatNumberToLocaleString(
+  value: string | number,
+  desiredDecimals = 0,
+) {
+  const number = typeof value === "number" ? value : parseFloat(value)
+
+  if (number === 0 && desiredDecimals === 0) return "0"
+
+  if (number === 0) return `0.${"0".repeat(desiredDecimals)}`
+
+  return number.toLocaleString("en-US", {
+    minimumFractionDigits: desiredDecimals,
+    maximumFractionDigits: desiredDecimals,
+  })
+}
+
+/**
+ * Returns a number rounded up to the desired number of decimals.
+ * @param amount The number to round up.
+ * @param desiredDecimals The number of decimals to round up to.
+ * @returns The rounded up number.
+ * @see https://github.com/thesis/acre/blob/2078d339f4ddce79e69c78529c9d72910dd2640a/dapp/src/utils/numbersUtils.ts#L1-L3
+ */
+export function roundUpNumber(amount: number, desiredDecimals = 2): number {
+  return Math.ceil(amount * 10 ** desiredDecimals) / 10 ** desiredDecimals
+}
+
+/**
+ * Convert a fixed point bigint with precision `fixedPointDecimals` to a
+ * floating point number truncated to `desiredDecimals`.
+ * @param fixedPoint The fixed point bigint to convert.
+ * @param fixedPointDecimals The number of decimals in the fixed point bigint.
+ * @param desiredDecimals The number of decimals in the output number.
+ * @returns The floating point number truncated to `desiredDecimals`.
+ * @see https://github.com/tahowallet/extension/blob/f6b26b7cb4a0a0278b1fccc6319626638f1a6dfa/background/lib/fixed-point.ts#L216-L239
+ */
+export function fromFixedPoint(
+  fixedPoint: bigint,
+  fixedPointDecimals: number,
+  desiredDecimals = 4,
+): number {
+  const fixedPointDesiredDecimalsAmount =
+    fixedPoint /
+    10n ** BigInt(Math.max(1, fixedPointDecimals - desiredDecimals))
+
+  const formattedAmount =
+    Number(fixedPointDesiredDecimalsAmount) /
+    10 ** Math.min(desiredDecimals, fixedPointDecimals)
+
+  return formattedAmount
+}
+
+/**
+ * Display a token amount correctly with desired decimals.
+ * The function returns a string with a language-sensitive representation of this number.
+ * @param amount The fixed point number to convert.
+ * @param decimals The number of decimals in the fixed point number.
+ * @param desiredDecimals The number of decimals to display.
+ * @param withRoundUp Whether to round up the number.
+ * @returns The formatted number as a string.
+ * @see https://github.com/thesis/acre/blob/2078d339f4ddce79e69c78529c9d72910dd2640a/dapp/src/utils/numbersUtils.ts#L57-L87
+ */
+export const fromFixedPointToString = (
+  amount: number | string | bigint,
+  decimals = 18,
+  desiredDecimals = 4,
+  withRoundUp = false,
+) => {
+  const fixedPoint = BigInt(amount)
+
+  if (fixedPoint === 0n) {
+    return `0.${"0".repeat(desiredDecimals)}`
+  }
+
+  const formattedAmount = fromFixedPoint(
+    fixedPoint,
+    decimals,
+    // To round the amount up, let's increase the precision by one.
+    // The desired decimal numbers will be set later anyway.
+    withRoundUp ? desiredDecimals + 1 : desiredDecimals,
+  )
+
+  const minAmountToDisplay = 1 / 10 ** Math.min(desiredDecimals, decimals)
+
+  if (minAmountToDisplay > formattedAmount) {
+    return `<0.${"0".repeat(desiredDecimals - 1)}1`
+  }
+
+  const finalFormattedAmount = withRoundUp
+    ? Math.ceil(formattedAmount * 10 ** desiredDecimals) / 10 ** desiredDecimals
+    : formattedAmount
+  return formatNumberToLocaleString(finalFormattedAmount, desiredDecimals)
+}
+
+/**
+ * Converts a floating-point number or string to a bigint representation
+ * scaled by the specified number of decimal places (default: 18).
+ *
+ * This function avoids floating-point precision issues by manually
+ * parsing and scaling the number.
+ *
+ * @param amount - A number or string containing a floating point number.
+ * @param decimals - Number of decimals to scale to (default: 18).
+ * @returns A bigint representation scaled to the given decimal places.
+ * @see https://github.com/thesis/mezo-portal/blob/3bd4f39cb77c39948af2886a6ce7415a0c60307a/dapp/src/shared/utils/numbers.ts#L55
+ */
+export const fromFloatToBigInt = (
+  amount: string | number,
+  decimals = 18,
+): bigint => {
+  const FLOATING_POINT_REGEX = /^-?\d{1,3}(,\d{3})*(\.\d+)?$|^-?\d+(\.\d+)?$/
+
+  const parseToFixedPointNumber = (
+    floatingPointString: string,
+  ): { amount: bigint; decimals: number } | undefined => {
+    if (!floatingPointString.match(FLOATING_POINT_REGEX)) {
+      return undefined
+    }
+
+    const [whole, decimalsPart, ...extra] = floatingPointString.split(".")
+
+    if (extra.length > 0) return undefined
+
+    const noThousandsSeparatorWhole = whole.replace(/,/g, "")
+    const setDecimals = decimalsPart ?? ""
+
+    try {
+      return {
+        amount: BigInt([noThousandsSeparatorWhole, setDecimals].join("")),
+        decimals: setDecimals.length,
+      }
+    } catch {
+      return undefined
+    }
+  }
+
+  const convertFixedPoint = (
+    fixedPoint: bigint,
+    fixedPointDecimals: number,
+    targetDecimals: number,
+  ): bigint => {
+    if (fixedPointDecimals >= targetDecimals) {
+      return fixedPoint / 10n ** BigInt(fixedPointDecimals - targetDecimals)
+    }
+
+    return fixedPoint * 10n ** BigInt(targetDecimals - fixedPointDecimals)
+  }
+
+  const parsedAmount = amount.toString()
+  const fixedPointAmount = parseToFixedPointNumber(parsedAmount)
+
+  if (typeof fixedPointAmount === "undefined") {
+    return 0n
+  }
+
+  return convertFixedPoint(
+    fixedPointAmount.amount,
+    fixedPointAmount.decimals,
+    decimals,
+  )
+}