@mezo-org/passport 0.4.0-dev.81 → 0.4.0-dev.83

package/src/provider.ts

@@ -1,10 +1,13 @@
 import { createContext, createElement } from "react"
 import { AuthApiClient, PortalApiClient } from "./api"
+import { ONE_SECOND_MS } from "./utils/time"
 
 export interface PassportContextValue {
   authApiClient: AuthApiClient
   portalApiClient: PortalApiClient
   environment?: Environment
+  accountDataRefetchInterval: number
+  nativeBalanceRefetchInterval: number
 }
 
 export const PassportContext = createContext<PassportContextValue | undefined>(
@@ -15,12 +18,13 @@ type Environment = "mainnet" | "testnet"
 
 type PassportProviderProps = {
   children: React.ReactNode
-  // eslint-disable-next-line react/require-default-props
   environment?: Environment
-  // eslint-disable-next-line react/require-default-props
   authApiUrl?: string
-  // eslint-disable-next-line react/require-default-props
   portalApiUrl?: string
+  /** Time in milliseconds after which account data (like mats or mezo id) in dropdown should be re-fetched. Default is 90000 (90 secs) */
+  accountDataRefetchInterval?: number
+  /** Time in milliseconds after which native balance in dropdown should be re-fetched. Default is 90000 (90 secs) */
+  nativeBalanceRefetchInterval?: number
 }
 
 export function PassportProvider({
@@ -28,6 +32,8 @@ export function PassportProvider({
   authApiUrl,
   portalApiUrl,
   children,
+  accountDataRefetchInterval = 90 * ONE_SECOND_MS,
+  nativeBalanceRefetchInterval = 90 * ONE_SECOND_MS,
 }: PassportProviderProps) {
   if (environment && !["mainnet", "testnet"].includes(environment)) {
     throw new Error("Wrong environment passed to PassportProvider.")
@@ -43,6 +49,8 @@ export function PassportProvider({
           portalApiUrl,
         ),
         environment,
+        accountDataRefetchInterval,
+        nativeBalanceRefetchInterval,
       },
     },
     children,

package/src/utils/assets.test.ts

@@ -0,0 +1,57 @@
+import {
+  getAsset,
+  isBitcoinLikeCryptoAsset,
+  isUsdLikeCryptoAsset,
+  isTTokenCryptoAsset,
+} from "./assets"
+
+describe("getAsset", () => {
+  it("should return correct asset data", () => {
+    const asset = getAsset("BTC")
+    expect(asset).toEqual({
+      name: "Bitcoin",
+      symbol: "BTC",
+      decimals: 18,
+    })
+  })
+})
+
+describe("isBitcoinLikeCryptoAsset", () => {
+  it('should return true for keys containing "btc"', () => {
+    expect(isBitcoinLikeCryptoAsset("BTC")).toBe(true)
+    expect(isBitcoinLikeCryptoAsset("mFBTC")).toBe(true)
+    expect(isBitcoinLikeCryptoAsset("mcbBTC")).toBe(true)
+    expect(isBitcoinLikeCryptoAsset("mxSolvBTC")).toBe(true)
+  })
+
+  it("should return false for non-Bitcoin assets", () => {
+    expect(isBitcoinLikeCryptoAsset("ETH")).toBe(false)
+    expect(isBitcoinLikeCryptoAsset("mUSDC")).toBe(false)
+  })
+})
+
+describe("isUsdLikeCryptoAsset", () => {
+  it('should return true for keys containing "usd" or "dai"', () => {
+    expect(isUsdLikeCryptoAsset("mUSDC")).toBe(true)
+    expect(isUsdLikeCryptoAsset("mUSDT")).toBe(true)
+    expect(isUsdLikeCryptoAsset("mUSDe")).toBe(true)
+    expect(isUsdLikeCryptoAsset("mDAI")).toBe(true)
+  })
+
+  it("should return false for other tokens", () => {
+    expect(isUsdLikeCryptoAsset("BTC")).toBe(false)
+    expect(isUsdLikeCryptoAsset("mT")).toBe(false)
+  })
+})
+
+describe("isTTokenCryptoAsset", () => {
+  it('should return true for keys like "mT" or "t"', () => {
+    expect(isTTokenCryptoAsset("mT")).toBe(true)
+    expect(isTTokenCryptoAsset("T")).toBe(true)
+  })
+
+  it("should return false for other tokens", () => {
+    expect(isTTokenCryptoAsset("BTC")).toBe(false)
+    expect(isTTokenCryptoAsset("mUSDT")).toBe(false)
+  })
+})

package/src/utils/assets.ts

@@ -0,0 +1,103 @@
+const ASSETS = {
+  BTC: {
+    name: "Bitcoin",
+    symbol: "BTC",
+    decimals: 18,
+  },
+  ETH: {
+    name: "Ethereum",
+    symbol: "ETH",
+    decimals: 18,
+  },
+  MUSD: {
+    name: "MUSD",
+    symbol: "MUSD",
+    decimals: 18,
+  },
+  mDAI: {
+    name: "Mezo Dai Stablecoin",
+    symbol: "mDAI",
+    decimals: 18,
+  },
+  mFBTC: {
+    name: "Mezo Fire Bitcoin",
+    symbol: "mFBTC",
+    decimals: 8,
+  },
+  mcbBTC: {
+    name: "Mezo Coinbase Wrapped BTC",
+    symbol: "mcbBTC",
+    decimals: 8,
+  },
+  mSolvBTC: {
+    name: "Mezo SolvBTC",
+    symbol: "mSolvBTC",
+    decimals: 18,
+  },
+  mswBTC: {
+    name: "Mezo swBTC",
+    symbol: "mswBTC",
+    decimals: 8,
+  },
+  mT: {
+    name: "Mezo Threshold Network Token",
+    symbol: "mT",
+    decimals: 18,
+  },
+  mUSDC: {
+    name: "Mezo Circle USDC",
+    symbol: "mUSDC",
+    decimals: 6,
+  },
+  mUSDe: {
+    name: "Mezo Ethena USDe",
+    symbol: "mUSDe",
+    decimals: 18,
+  },
+  mUSDT: {
+    name: "Mezo Tether USDe",
+    symbol: "mUSDT",
+    decimals: 6,
+  },
+  mxSolvBTC: {
+    name: "Mezo xSolvBTC",
+    symbol: "mxSolvBTC",
+    decimals: 18,
+  },
+}
+
+/**
+ * Gets details of given crypto asset
+ * @param key The key of crypto asset
+ * @returns The crypto asset details
+ */
+export function getAsset(key: keyof typeof ASSETS) {
+  return 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: string) {
+  return /(btc)/i.test(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: string) {
+  return /(usd|dai)/i.test(key)
+}
+
+/**
+ * Checks if given crypto asset is T token
+ * @param key The key of crypto asset
+ * @returns True if crypto asset is T token
+ */
+export function isTTokenCryptoAsset(key: string) {
+  return /^(mt|t)$/i.test(key)
+}

package/src/utils/currency.test.ts

@@ -1,4 +1,4 @@
-import { formatCurrency, formatUsd } from "./currency"
+import { convertToUsd, formatCurrency, formatUsd } from "./currency"
 
 describe("formatCurrency", () => {
   it("formats a number as currency with default options", () => {
@@ -37,4 +37,78 @@ describe("formatUsd", () => {
   })
 })
 
-// TODO: Add tests for convertToUsd function
+describe("convertToUsd", () => {
+  it("converts 1 BTC (8 decimals) with $30,000 rate (6 decimals)", () => {
+    const assetAmount = 1_00000000n // 1 BTC
+    const assetDecimals = 8
+    const conversionRate = 30_000_000000n // $30,000 in 6 decimals
+    const conversionRateDecimals = 6
+
+    const result = convertToUsd(
+      assetAmount,
+      assetDecimals,
+      conversionRate,
+      conversionRateDecimals,
+    )
+
+    expect(result.value).toBe(30_000_000000n)
+    expect(result.formatted).toBe("30000")
+  })
+
+  it("converts 0.5 BTC correctly", () => {
+    const assetAmount = 50_000000n // 0.5 BTC
+    const assetDecimals = 8
+    const conversionRate = 40_000_000000n // $40,000
+    const conversionRateDecimals = 6
+
+    const result = convertToUsd(
+      assetAmount,
+      assetDecimals,
+      conversionRate,
+      conversionRateDecimals,
+    )
+
+    expect(result.value).toBe(20_000_000000n)
+    expect(result.formatted).toBe("20000")
+  })
+
+  it("converts 1 ETH (18 decimals) with $2,000 rate (6 decimals)", () => {
+    const assetAmount = 1_000000000000000000n // 1 ETH
+    const assetDecimals = 18
+    const conversionRate = 2_000_000000n
+    const conversionRateDecimals = 6
+
+    const result = convertToUsd(
+      assetAmount,
+      assetDecimals,
+      conversionRate,
+      conversionRateDecimals,
+    )
+
+    expect(result.value).toBe(2_000_000000n)
+    expect(result.formatted).toBe("2000")
+  })
+
+  it("handles zero amount correctly", () => {
+    const result = convertToUsd(0n, 18, 999_999999n, 6)
+    expect(result.value).toBe(0n)
+    expect(result.formatted).toBe("0")
+  })
+
+  it("handles assets with fewer decimals than conversion rate", () => {
+    const assetAmount = 100n
+    const assetDecimals = 2
+    const conversionRate = 1_500_000000n // $1500
+    const conversionRateDecimals = 6
+
+    const result = convertToUsd(
+      assetAmount,
+      assetDecimals,
+      conversionRate,
+      conversionRateDecimals,
+    )
+
+    expect(result.value).toBe(1_500_000000n)
+    expect(result.formatted).toBe("1500")
+  })
+})

package/src/utils/currency.ts

@@ -1,10 +1,5 @@
-import { fromFixedPoint } from "./numbers"
-
-const DEFAULT_FORMAT_OPTIONS: Intl.NumberFormatOptions = {
-  style: "currency",
-  minimumFractionDigits: 2,
-  maximumFractionDigits: 2,
-}
+import { formatUnits } from "viem"
+import { normalizePrecision } from "./numbers"
 
 /**
  * Formats a number as a currency
@@ -14,10 +9,12 @@ const DEFAULT_FORMAT_OPTIONS: Intl.NumberFormatOptions = {
  */
 export function formatCurrency(
   value: number,
-  options: Omit<Intl.NumberFormatOptions, "style"> = {},
+  options: Omit<Intl.NumberFormatOptions, "style">,
 ): string {
   const formatter = new Intl.NumberFormat("en-US", {
-    ...DEFAULT_FORMAT_OPTIONS,
+    style: "currency",
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
     ...options,
   })
 
@@ -29,8 +26,8 @@ export function formatCurrency(
  * @param value The value to format
  * @returns The formatted currency
  */
-export function formatUsd(value: number): string {
-  return formatCurrency(value, { currency: "USD" })
+export function formatUsd(value: number | string): string {
+  return formatCurrency(Number(value), { currency: "USD" })
 }
 
 /**
@@ -45,9 +42,17 @@ export function convertToUsd(
   assetDecimals: number,
   conversionRate: bigint,
   conversionRateDecimals: number,
-): number {
-  return fromFixedPoint(
-    (assetAmount * conversionRate) / 10n ** BigInt(conversionRateDecimals),
-    assetDecimals,
+) {
+  const value = normalizePrecision(
+    assetAmount * conversionRate,
+    assetDecimals + conversionRateDecimals,
+    conversionRateDecimals,
   )
+
+  const formatted = formatUnits(value, conversionRateDecimals)
+
+  return {
+    value,
+    formatted,
+  }
 }

package/src/utils/numbers.test.ts

@@ -1,10 +1,7 @@
 import {
   formatNumberToCompactString,
-  fromFixedPoint,
-  roundUpNumber,
-  formatNumberToLocaleString,
-  fromFixedPointToString,
   bigIntMax,
+  normalizePrecision,
 } from "./numbers"
 
 describe("formatNumberToCompactString", () => {
@@ -44,182 +41,6 @@ describe("formatNumberToCompactString", () => {
   })
 })
 
-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)).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)
-  })
-})
-
-describe("formatNumberToLocaleString", () => {
-  it("formats zero with 0 decimals", () => {
-    expect(formatNumberToLocaleString(0, 0)).toBe("0")
-  })
-
-  it("formats zero with >0 decimals", () => {
-    expect(formatNumberToLocaleString(0, 2)).toBe("0.00")
-    expect(formatNumberToLocaleString(0, 4)).toBe("0.0000")
-  })
-
-  it("formats small decimal number", () => {
-    expect(formatNumberToLocaleString(0.123456, 2)).toBe("0.12")
-    expect(formatNumberToLocaleString(0.123456, 4)).toBe("0.1235")
-  })
-
-  it("formats number just above 1", () => {
-    expect(formatNumberToLocaleString(1.000001, 3)).toBe("1.000")
-    expect(formatNumberToLocaleString(1.234567, 2)).toBe("1.23")
-  })
-
-  it("formats whole number", () => {
-    expect(formatNumberToLocaleString(1234, 0)).toBe("1,234")
-    expect(formatNumberToLocaleString(1000, 2)).toBe("1,000.00")
-  })
-
-  it("formats number with trailing decimal zeroes", () => {
-    expect(formatNumberToLocaleString(10.1, 3)).toBe("10.100")
-    expect(formatNumberToLocaleString(5.0, 2)).toBe("5.00")
-  })
-
-  it("formats string input", () => {
-    expect(formatNumberToLocaleString("123.456", 2)).toBe("123.46")
-    expect(formatNumberToLocaleString("0.00123", 4)).toBe("0.0012")
-  })
-
-  it("formats negative number", () => {
-    expect(formatNumberToLocaleString(-123.456, 2)).toBe("-123.46")
-    expect(formatNumberToLocaleString("-0.00999", 3)).toBe("-0.010")
-  })
-
-  it("formats large number with commas", () => {
-    expect(formatNumberToLocaleString(12345678.9, 2)).toBe("12,345,678.90")
-  })
-
-  it("handles max decimals safely", () => {
-    expect(formatNumberToLocaleString(1.123456789, 8)).toBe("1.12345679")
-    expect(formatNumberToLocaleString("0.000000000000000001", 18)).toBe(
-      "0.000000000000000001",
-    )
-  })
-
-  it("defaults to 0 decimals if not passed", () => {
-    expect(formatNumberToLocaleString(1234.567)).toBe("1,235") // rounds up by default
-  })
-})
-
-describe("fromFixedPointToString", () => {
-  const toFixedPoint = (num: number) => BigInt(Math.round(num * 1e18))
-
-  const cases = [
-    { input: 2.0, expected: "2.000" },
-    { input: 2.009, expected: "2.009" },
-    { input: 2.01, expected: "2.010" },
-    { input: 2.015, expected: "2.016" },
-    { input: 2.05, expected: "2.050" },
-    { input: 2.09, expected: "2.090" },
-  ]
-
-  describe("withRoundUp: true", () => {
-    cases.forEach(({ input, expected }) => {
-      it(`formats ${input} → ${expected}`, () => {
-        const fixed = toFixedPoint(input)
-        expect(fromFixedPointToString(fixed, 18, 3, true)).toBe(expected)
-      })
-    })
-  })
-
-  describe("withRoundUp: false", () => {
-    const noRoundCases = [
-      { input: 2.0099, expected: "2.009" },
-      { input: 2.0159, expected: "2.015" },
-      { input: 2.0101, expected: "2.010" },
-      { input: 2.0199, expected: "2.019" },
-    ]
-
-    noRoundCases.forEach(({ input, expected }) => {
-      it(`formats ${input} → ${expected} (no rounding)`, () => {
-        const fixed = toFixedPoint(input)
-        expect(fromFixedPointToString(fixed, 18, 3, false)).toBe(expected)
-      })
-    })
-  })
-
-  describe("zero handling", () => {
-    it("formats 0 → 0.000 (3 decimals)", () => {
-      expect(fromFixedPointToString(0n, 18, 3)).toBe("0.000")
-    })
-
-    it("formats 0 → 0.0000 (4 decimals)", () => {
-      expect(fromFixedPointToString(0n, 18, 4)).toBe("0.0000")
-    })
-  })
-
-  describe("very small numbers below display threshold", () => {
-    it("returns <0.0001 for small number (3 decimals)", () => {
-      const small = BigInt(123) // ~1.23e-16
-      expect(fromFixedPointToString(small, 18, 4)).toBe("<0.0001")
-    })
-
-    it("returns <0.01 for small number with only 2 decimals", () => {
-      const tiny = BigInt(9999999999999) // <0.01
-      expect(fromFixedPointToString(tiny, 18, 2)).toBe("<0.01")
-    })
-  })
-
-  describe("input types", () => {
-    it("accepts bigint", () => {
-      const amount = 2100000000000000000n
-      expect(fromFixedPointToString(amount, 18, 3)).toBe("2.100")
-    })
-
-    it("accepts string", () => {
-      expect(fromFixedPointToString("2000000000000000000", 18, 3)).toBe("2.000")
-    })
-
-    it("accepts number", () => {
-      expect(fromFixedPointToString(Number("1000000000000000000"), 18, 3)).toBe(
-        "1.000",
-      )
-    })
-  })
-
-  describe("high values", () => {
-    it("formats 1_000_000.123456789 correctly", () => {
-      const big = toFixedPoint(1_000_000.123456789)
-      expect(fromFixedPointToString(big, 18, 6)).toBe("1,000,000.123456")
-    })
-
-    it("formats 1e12 ETH", () => {
-      const big = BigInt("1000000000000000000000000000000")
-      expect(fromFixedPointToString(big, 18, 2)).toBe("1,000,000,000,000.00")
-    })
-  })
-})
-
 describe("bigIntMax", () => {
   it("returns the maximum of positive bigint values", () => {
     expect(bigIntMax(1n, 2n, 3n)).toBe(3n)
@@ -245,3 +66,31 @@ describe("bigIntMax", () => {
     expect(bigIntMax(5n, 5n, 5n)).toBe(5n)
   })
 })
+
+describe("normalizePrecision", () => {
+  it("reduces precision correctly (scale down)", () => {
+    const result = normalizePrecision(1234500n, 6, 3)
+    expect(result).toBe(1234n)
+  })
+
+  it("increases precision correctly (scale up)", () => {
+    const result = normalizePrecision(1234n, 3, 6)
+    expect(result).toBe(1234000n)
+  })
+
+  it("returns the same value when precision is equal", () => {
+    const result = normalizePrecision(987654321n, 5, 5)
+    expect(result).toBe(987654321n)
+  })
+
+  it("handles zero value correctly", () => {
+    const result = normalizePrecision(0n, 4, 8)
+    expect(result).toBe(0n)
+  })
+
+  it("handles large numbers without precision loss", () => {
+    const value = 123456789012345678901234567890n
+    const result = normalizePrecision(value, 18, 20)
+    expect(result).toBe(value * 100n)
+  })
+})