@mezo-org/passport 0.4.0-dev.1 → 0.4.0-dev.10

package/src/utils/cryptoAssets.test.ts

@@ -0,0 +1,61 @@
+import {
+  BitcoinCircle,
+  EthCircle,
+  MUsdCircle,
+  TBtcCircle,
+} from "@mezo-org/mezo-clay"
+import { getCryptoAsset } from "./cryptoAssets"
+
+// FIXME: Test fails if run in full suite (pnpm test) but works when run in isolation (pnpm test cryptoAssets)
+
+describe("getCryptoAsset", () => {
+  it("returns the correct asset for 'btc'", () => {
+    const asset = getCryptoAsset("btc")
+    expect(asset.name).toBe("Bitcoin")
+    expect(asset.symbol).toBe("BTC")
+    expect(asset.decimals).toBe(8)
+    expect(asset.icon).toBe(BitcoinCircle)
+  })
+
+  it("returns the correct asset for 'eth'", () => {
+    const asset = getCryptoAsset("eth")
+    expect(asset.name).toBe("Ethereum")
+    expect(asset.symbol).toBe("ETH")
+    expect(asset.decimals).toBe(18)
+    expect(asset.icon).toBe(EthCircle)
+  })
+
+  it("returns the correct asset for 'tbtc'", () => {
+    const asset = getCryptoAsset("tbtc")
+    expect(asset.name).toBe("Threshold Bitcoin")
+    expect(asset.symbol).toBe("tBTC")
+    expect(asset.decimals).toBe(18)
+    expect(asset.icon).toBe(TBtcCircle)
+  })
+
+  it("returns the correct asset for 'wbtc'", () => {
+    const asset = getCryptoAsset("wbtc")
+    expect(asset.name).toBe("Wrapped Bitcoin")
+    expect(asset.symbol).toBe("wBTC")
+    expect(asset.decimals).toBe(8)
+    // FIXME: Test should expect the exact icon component
+    expect(asset.icon).toEqual(expect.any(Function))
+  })
+
+  it("returns the correct asset for 'mbtc'", () => {
+    const asset = getCryptoAsset("mbtc")
+    expect(asset.name).toBe("Matsnet Bitcoin")
+    expect(asset.symbol).toBe("BTC")
+    expect(asset.decimals).toBe(18)
+    // FIXME: Test should expect the exact icon component
+    expect(asset.icon).toEqual(expect.any(Function))
+  })
+
+  it("returns the correct asset for 'musd'", () => {
+    const asset = getCryptoAsset("musd")
+    expect(asset.name).toBe("Mezo USD")
+    expect(asset.symbol).toBe("MUSD")
+    expect(asset.decimals).toBe(18)
+    expect(asset.icon).toBe(MUsdCircle)
+  })
+})

package/src/utils/cryptoAssets.ts

@@ -0,0 +1,93 @@
+import {
+  BitcoinCircle,
+  EthCircle,
+  IconProps,
+  MUsdCircle,
+  TBtcCircle,
+} from "@mezo-org/mezo-clay"
+import { createElement, FC } from "react"
+
+export type CryptoAssetKey = "btc" | "eth" | "tbtc" | "wbtc" | "mbtc" | "musd"
+
+export type CryptoAsset = {
+  name: string
+  symbol: string
+  icon: FC<IconProps>
+  decimals: number
+}
+
+const CRYPTO_ASSETS: Record<CryptoAssetKey, CryptoAsset> = {
+  btc: {
+    name: "Bitcoin",
+    symbol: "BTC",
+    icon: BitcoinCircle,
+    decimals: 8,
+  },
+  eth: {
+    name: "Ethereum",
+    symbol: "ETH",
+    icon: EthCircle,
+    decimals: 18,
+  },
+  tbtc: {
+    name: "Threshold Bitcoin",
+    symbol: "tBTC",
+    icon: TBtcCircle,
+    decimals: 18,
+  },
+  wbtc: {
+    name: "Wrapped Bitcoin",
+    symbol: "wBTC",
+    icon: (props) =>
+      createElement(BitcoinCircle, {
+        ...props,
+        symbolColor: "#FF8A00",
+        color: "#000000",
+      }),
+    decimals: 8,
+  },
+  mbtc: {
+    name: "Matsnet Bitcoin",
+    symbol: "BTC",
+    icon: (props) =>
+      createElement(BitcoinCircle, {
+        ...props,
+        symbolColor: "#000000",
+        color: "#FFC907",
+      }),
+    decimals: 18,
+  },
+  musd: {
+    name: "Mezo USD",
+    symbol: "MUSD",
+    icon: MUsdCircle,
+    decimals: 18,
+  },
+}
+
+/**
+ * Gets details of given crypto asset
+ * @param key The key of crypto asset
+ * @returns The crypto asset details
+ */
+export function getCryptoAsset(key: CryptoAssetKey) {
+  return CRYPTO_ASSETS[key]
+}
+
+/**
+ * Checks if given crypto asset is Bitcoin-like
+ * @param key The key of crypto asset
+ * @returns True if crypto asset is Bitcoin-like
+ */
+export function isBitcoinLikeCryptoAsset(key: CryptoAssetKey) {
+  return ["btc", "tbtc", "wbtc", "mbtc"].includes(key)
+}
+
+/**
+ * Checks if given crypto asset is USD-like
+ * @param key The key of crypto asset
+ * @returns True if crypto asset is USD-like
+ */
+export function isUsdLikeCryptoAsset(key: CryptoAssetKey) {
+  return ["musd"].includes(key)
+}

package/src/utils/currency.test.ts

@@ -0,0 +1,38 @@
+import { formatCurrency, formatUsd } from "./currency"
+
+describe("formatCurrency", () => {
+  it("formats a number as currency with default options", () => {
+    const result = formatCurrency(1234.5, { currency: "EUR" })
+    expect(result).toBe("€1,234.50")
+  })
+
+  it("respects minimumFractionDigits (min = 3, max = 3)", () => {
+    const result = formatCurrency(1.2, {
+      currency: "USD",
+      minimumFractionDigits: 3,
+      maximumFractionDigits: 3,
+    })
+    expect(result).toBe("$1.200")
+  })
+
+  it("respects maximumFractionDigits (min = 0, max = 1)", () => {
+    const result = formatCurrency(1.234567, {
+      currency: "USD",
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 1,
+    })
+    expect(result).toBe("$1.2")
+  })
+})
+
+describe("formatUsd", () => {
+  it("formats a number as USD", () => {
+    const result = formatUsd(99.99)
+    expect(result).toBe("$99.99")
+  })
+
+  it("formats zero", () => {
+    const result = formatUsd(0)
+    expect(result).toBe("$0.00")
+  })
+})

package/src/utils/currency.ts

@@ -0,0 +1,32 @@
+const DEFAULT_FORMAT_OPTIONS: Intl.NumberFormatOptions = {
+  style: "currency",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2,
+}
+
+/**
+ * Formats a number as a currency
+ * @param value The value to format
+ * @param options The options to pass to the formatter
+ * @returns The formatted currency
+ */
+export function formatCurrency(
+  value: number,
+  options: Omit<Intl.NumberFormatOptions, "style"> = {},
+): string {
+  const formatter = new Intl.NumberFormat("en-US", {
+    ...DEFAULT_FORMAT_OPTIONS,
+    ...options,
+  })
+
+  return formatter.format(value)
+}
+
+/**
+ * Formats a number as a USD currency
+ * @param value The value to format
+ * @returns The formatted currency
+ */
+export function formatUsd(value: number): string {
+  return formatCurrency(value, { currency: "USD" })
+}

package/src/utils/numbers.test.ts

@@ -0,0 +1,73 @@
+import {
+  formatHumanReadableNumber,
+  fromFixedPoint,
+  roundUpNumber,
+} from "./numbers"
+
+describe("formatHumanReadableNumber", () => {
+  it("formats number less than 1000 with decimals", () => {
+    expect(formatHumanReadableNumber(123.456789, 2)).toBe("123.46")
+  })
+
+  it("formats thousands with K", () => {
+    expect(formatHumanReadableNumber(12_345, 2)).toBe("12.35K")
+  })
+
+  it("formats millions with M", () => {
+    expect(formatHumanReadableNumber(12_345_678, 2)).toBe("12.35M")
+  })
+
+  it("formats billions with B", () => {
+    expect(formatHumanReadableNumber(12_345_678_901, 2)).toBe("12.35B")
+  })
+
+  it("formats trillions with T", () => {
+    expect(formatHumanReadableNumber(12_345_678_901_234, 2)).toBe("12.35T")
+  })
+
+  it("formats bigint as readable number", () => {
+    expect(formatHumanReadableNumber(1234567890123456789n, 2)).toBe(
+      "1,234,567.89T",
+    )
+  })
+
+  it("caps at > 1000T for huge numbers", () => {
+    const hugeNumber = 10 ** 18 // 1e18
+    expect(formatHumanReadableNumber(hugeNumber, 2)).toBe("1,000,000T")
+  })
+
+  it("formats numbers with trailing zeros correctly", () => {
+    expect(formatHumanReadableNumber(1_000, 2)).toBe("1K")
+  })
+})
+
+describe("roundUpNumber", () => {
+  it("rounds up to 2 decimals", () => {
+    expect(roundUpNumber(1.234)).toBe(1.24)
+  })
+
+  it("rounds up to 3 decimals", () => {
+    expect(roundUpNumber(9.87654, 3)).toBe(9.877)
+  })
+
+  it("rounds up exact decimal", () => {
+    expect(roundUpNumber(2.5, 1)).toBe(2.5)
+  })
+})
+
+describe("fromFixedPoint", () => {
+  it("converts fixed point with 18 decimals to float", () => {
+    const raw = 1234567890000000000n // 1.23456789 ETH in 18 decimals
+    expect(fromFixedPoint(raw, 18, 4)).toBe(1.2345)
+  })
+
+  it("converts with truncation to 2 decimals", () => {
+    const raw = 987654321000000000n // ~0.987654321 ETH
+    expect(fromFixedPoint(raw, 18, 2)).toBe(0.98)
+  })
+
+  it("handles large fixedPoint decimals", () => {
+    const raw = 1_000_000_000_000_000_000_000_000n // 1M with 6 decimals
+    expect(fromFixedPoint(raw, 6, 2)).toBe(1000000000000000000)
+  })
+})

package/src/utils/numbers.ts

@@ -0,0 +1,55 @@
+type DesiredDecimals = Intl.NumberFormatOptions &
+  BigIntToLocaleStringOptions["minimumFractionDigits"]
+
+/**
+ * Formats a number or bigint into a human-readable 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 formatHumanReadableNumber(
+  value: number | bigint,
+  decimals = 4,
+): string {
+  return value.toLocaleString("en-US", {
+    notation: "compact",
+    compactDisplay: "short",
+    maximumFractionDigits: decimals as 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 = 2,
+): number {
+  const fixedPointDesiredDecimalsAmount =
+    fixedPoint /
+    10n ** BigInt(Math.max(1, fixedPointDecimals - desiredDecimals))
+
+  const formattedAmount =
+    Number(fixedPointDesiredDecimalsAmount) /
+    10 ** Math.min(desiredDecimals, fixedPointDecimals)
+
+  return formattedAmount
+}