@mezo-org/passport 0.4.0-dev.8 → 0.4.0-dev.80

package/src/utils/cryptoAssets.test.ts

@@ -1,59 +1,79 @@
+import { BitcoinCircle, EthCircle, MUsdCircle02 } from "@mezo-org/mezo-clay"
 import {
-  BitcoinCircle,
-  EthCircle,
-  MUsdCircle,
-  TBtcCircle,
-} from "@mezo-org/mezo-clay"
-import { getCryptoAsset } from "./cryptoAssets"
+  CryptoAssetKey,
+  getCryptoAsset,
+  isBitcoinLikeCryptoAsset,
+  isUsdLikeCryptoAsset,
+} 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")
+  it("returns the correct asset for 'BTC (mBTC)'", () => {
+    const asset = getCryptoAsset("BTC")
     expect(asset.name).toBe("Bitcoin")
     expect(asset.symbol).toBe("BTC")
-    expect(asset.decimals).toBe(8)
+    expect(asset.decimals).toBe(18)
     expect(asset.icon).toBe(BitcoinCircle)
   })
 
-  it("returns the correct asset for 'eth'", () => {
-    const asset = getCryptoAsset("eth")
+  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")
+  it("returns the correct asset for 'MUSD'", () => {
+    const asset = getCryptoAsset("MUSD")
+    expect(asset.name).toBe("MUSD")
+    expect(asset.symbol).toBe("MUSD")
     expect(asset.decimals).toBe(18)
-    expect(asset.icon).toBe(TBtcCircle)
+    expect(asset.icon).toBe(MUsdCircle02)
   })
+})
 
-  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))
-  })
+describe("isBitcoinLikeCryptoAsset", () => {
+  const cases = [
+    { input: "mcbBTC", expected: true },
+    { input: "mDAI", expected: false },
+    { input: "mFBTC", expected: true },
+    { input: "mSolvBTC", expected: true },
+    { input: "mswBTC", expected: true },
+    { input: "mT", expected: false },
+    { input: "mUSDC", expected: false },
+    { input: "mUSDe", expected: false },
+    { input: "mUSDT", expected: false },
+    { input: "mxSolvBTC", expected: true },
+    { input: "MUSD", expected: false },
+  ]
 
-  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))
+  cases.forEach(({ input, expected }) => {
+    it(`returns ${expected} for ${input}`, () => {
+      expect(isBitcoinLikeCryptoAsset(input as CryptoAssetKey)).toBe(expected)
+    })
   })
+})
 
-  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)
+describe("isUsdLikeCryptoAsset", () => {
+  const cases = [
+    { input: "mcbBTC", expected: false },
+    { input: "mDAI", expected: true },
+    { input: "mFBTC", expected: false },
+    { input: "mSolvBTC", expected: false },
+    { input: "mswBTC", expected: false },
+    { input: "mT", expected: false },
+    { input: "mUSDC", expected: true },
+    { input: "mUSDe", expected: true },
+    { input: "mUSDT", expected: true },
+    { input: "mxSolvBTC", expected: false },
+    { input: "MUSD", expected: true },
+  ]
+
+  cases.forEach(({ input, expected }) => {
+    it(`returns ${expected} for ${input}`, () => {
+      expect(isUsdLikeCryptoAsset(input as CryptoAssetKey)).toBe(expected)
+    })
   })
 })

package/src/utils/cryptoAssets.ts

@@ -2,12 +2,15 @@ import {
   BitcoinCircle,
   EthCircle,
   IconProps,
-  MUsdCircle,
-  TBtcCircle,
+  MUsdCircle02,
+  Cryptocurrency04,
 } from "@mezo-org/mezo-clay"
-import { createElement, FC } from "react"
+import { FC } from "react"
+import { MezoChainToken } from "../lib/contracts"
+import { convertToUsd, formatUsd } from "./currency"
+import { fromFixedPointToString } from "./numbers"
 
-export type CryptoAssetKey = "btc" | "eth" | "tbtc" | "wbtc" | "mbtc" | "musd"
+export type CryptoAssetKey = MezoChainToken | "BTC" | "ETH"
 
 export type CryptoAsset = {
   name: string
@@ -16,51 +19,85 @@ export type CryptoAsset = {
   decimals: number
 }
 
+// TODO: Add actual icons for the assets
+
 const CRYPTO_ASSETS: Record<CryptoAssetKey, CryptoAsset> = {
-  btc: {
+  BTC: {
     name: "Bitcoin",
     symbol: "BTC",
     icon: BitcoinCircle,
-    decimals: 8,
+    decimals: 18,
   },
-  eth: {
+  ETH: {
     name: "Ethereum",
     symbol: "ETH",
     icon: EthCircle,
     decimals: 18,
   },
-  tbtc: {
-    name: "Threshold Bitcoin",
-    symbol: "tBTC",
-    icon: TBtcCircle,
+  MUSD: {
+    name: "MUSD",
+    symbol: "MUSD",
+    icon: MUsdCircle02,
+    decimals: 18,
+  },
+  mDAI: {
+    name: "mDAI",
+    symbol: "mDAI",
+    icon: Cryptocurrency04,
     decimals: 18,
   },
-  wbtc: {
-    name: "Wrapped Bitcoin",
-    symbol: "wBTC",
-    icon: (props) =>
-      createElement(BitcoinCircle, {
-        ...props,
-        symbolColor: "#FF8A00",
-        color: "#000000",
-      }),
+  mFBTC: {
+    name: "mFBTC",
+    symbol: "mFBTC",
+    icon: BitcoinCircle,
     decimals: 8,
   },
-  mbtc: {
-    name: "Matsnet Bitcoin",
-    symbol: "BTC",
-    icon: (props) =>
-      createElement(BitcoinCircle, {
-        ...props,
-        symbolColor: "#000000",
-        color: "#FFC907",
-      }),
+  mcbBTC: {
+    name: "mcbBTC",
+    symbol: "mcbBTC",
+    icon: BitcoinCircle,
+    decimals: 8,
+  },
+  mSolvBTC: {
+    name: "mSolvBTC",
+    symbol: "mSolvBTC",
+    icon: BitcoinCircle,
     decimals: 18,
   },
-  musd: {
-    name: "Mezo USD",
-    symbol: "MUSD",
-    icon: MUsdCircle,
+  mswBTC: {
+    name: "mswBTC",
+    symbol: "mswBTC",
+    icon: BitcoinCircle,
+    decimals: 8,
+  },
+  mT: {
+    name: "mT",
+    symbol: "mT",
+    icon: Cryptocurrency04,
+    decimals: 18,
+  },
+  mUSDC: {
+    name: "mUSDC",
+    symbol: "mUSDC",
+    icon: Cryptocurrency04,
+    decimals: 6,
+  },
+  mUSDe: {
+    name: "mUSDe",
+    symbol: "mUSDe",
+    icon: Cryptocurrency04,
+    decimals: 18,
+  },
+  mUSDT: {
+    name: "mUSDT",
+    symbol: "mUSDT",
+    icon: Cryptocurrency04,
+    decimals: 6,
+  },
+  mxSolvBTC: {
+    name: "mxSolvBTC",
+    symbol: "mxSolvBTC",
+    icon: BitcoinCircle,
     decimals: 18,
   },
 }
@@ -80,7 +117,7 @@ export function getCryptoAsset(key: CryptoAssetKey) {
  * @returns True if crypto asset is Bitcoin-like
  */
 export function isBitcoinLikeCryptoAsset(key: CryptoAssetKey) {
-  return ["btc", "tbtc", "wbtc", "mbtc"].includes(key)
+  return /(btc)/i.test(key)
 }
 
 /**
@@ -89,5 +126,46 @@ export function isBitcoinLikeCryptoAsset(key: CryptoAssetKey) {
  * @returns True if crypto asset is USD-like
  */
 export function isUsdLikeCryptoAsset(key: CryptoAssetKey) {
-  return ["musd"].includes(key)
+  return /(usd|dai)/i.test(key)
+}
+
+/**
+ * Formats crypto asset to balance details (balance in USD and decimals)
+ * @param type The type of crypto asset
+ * @param balance The balance of crypto asset
+ * @param usdConversionRate The USD conversion rate
+ * @returns The balance details
+ */
+export function mapCryptoAssetToDetails(
+  type: CryptoAssetKey,
+  balance: bigint,
+  usdConversionRate: bigint,
+  usdConversionRateDecimals: number,
+) {
+  const { decimals } = getCryptoAsset(type)
+
+  const formattedBalance = fromFixedPointToString(
+    balance,
+    decimals,
+    isUsdLikeCryptoAsset(type) ? 2 : 4,
+  )
+
+  const usdBalance = convertToUsd(
+    balance,
+    decimals,
+    usdConversionRate,
+    usdConversionRateDecimals,
+  )
+
+  const formattedUsdBalance = formatUsd(usdBalance)
+
+  return {
+    type,
+    rawBalance: balance,
+    formattedBalance,
+    usdBalance,
+    formattedUsdBalance,
+  }
 }
+
+export type DetailedCryptoAsset = ReturnType<typeof mapCryptoAssetToDetails>

package/src/utils/currency.test.ts

@@ -36,3 +36,5 @@ describe("formatUsd", () => {
     expect(result).toBe("$0.00")
   })
 })
+
+// TODO: Add tests for convertToUsd function

package/src/utils/currency.ts

@@ -1,3 +1,5 @@
+import { fromFixedPoint } from "./numbers"
+
 const DEFAULT_FORMAT_OPTIONS: Intl.NumberFormatOptions = {
   style: "currency",
   minimumFractionDigits: 2,
@@ -30,3 +32,22 @@ export function formatCurrency(
 export function formatUsd(value: number): string {
   return formatCurrency(value, { currency: "USD" })
 }
+
+/**
+ * Converts an asset amount to USD based on a conversion rate and decimals
+ * @param assetAmount - The amount of the asset in its smallest unit (e.g., satoshis for BTC)
+ * @param conversionRate - The conversion rate from the asset to USD in fixed-point format
+ * @param decimals - The number of decimals for the asset
+ * @returns - The value in USD as a number
+ */
+export function convertToUsd(
+  assetAmount: bigint,
+  assetDecimals: number,
+  conversionRate: bigint,
+  conversionRateDecimals: number,
+): number {
+  return fromFixedPoint(
+    (assetAmount * conversionRate) / 10n ** BigInt(conversionRateDecimals),
+    assetDecimals,
+  )
+}

package/src/utils/mezoId.ts

@@ -0,0 +1,51 @@
+export type MezoId = `${string}.mezo`
+
+// NOTE: This was copied from mezo-portal and is based on the validation from
+// workers/passport-auth/src/utils/mezo-id.ts.
+
+// Most of these are restrictions for an DNS hostname label (i.e., the part
+// before/after `.` in a full hostname) as outlined in RFC1034
+// (https://www.rfc-editor.org/rfc/rfc1034).
+//
+// A few addenda are made to ensure that nothing can sneak through that could
+// look like an Ethereum or Bitcoin address.
+export const DISALLOWED_MEZO_ID_PATTERNS: { pattern: RegExp; error: string }[] =
+  [
+    // RFC1034.
+    { pattern: /^$/, error: "Must not be empty." },
+    { pattern: /^.{16,}$/, error: "Must have 15 characters or fewer." },
+    {
+      pattern: /^[^A-Za-z]/,
+      error: "Must start with one of the letters A-Z or a-z.",
+    },
+    {
+      pattern: /[^A-Za-z0-9-]/,
+      error:
+        "Must only use letters or numbers (A-Z, a-z, or 0-9), or hyphen (-).",
+    },
+    { pattern: /-$/, error: "Must not end in a hyphen (-)." },
+    // On-chain shenanigan avoidance.
+    { pattern: /0x/i, error: "Must not contain 0x." },
+    {
+      pattern: /^(?:bc1|tb1|[a-z]pub|[a-z]priv)/i,
+      error: "Must not start with a Bitcoin magic string.",
+    },
+    {
+      pattern: /^m[0-9]+$/i,
+      error: 'No "m" + "numeric string" prefixes.',
+    },
+  ]
+
+export function validateMezoId(mezoId: string): string[] {
+  if (!/\.mezo$/.test(mezoId)) {
+    return ["Must end with '.mezo'."]
+  }
+
+  const mezoIdWithoutSuffix = mezoId.replace(/\.mezo$/, "")
+
+  const errors = DISALLOWED_MEZO_ID_PATTERNS.flatMap(({ pattern, error }) =>
+    pattern.test(mezoIdWithoutSuffix) ? [error] : [],
+  )
+
+  return errors
+}

package/src/utils/numbers.test.ts

@@ -1,38 +1,46 @@
 import {
-  formatHumanReadableNumber,
-  formatTokenAmount,
+  formatNumberToCompactString,
   fromFixedPoint,
   roundUpNumber,
+  formatNumberToLocaleString,
+  fromFixedPointToString,
+  bigIntMax,
 } from "./numbers"
 
-describe("formatHumanReadableNumber", () => {
+describe("formatNumberToCompactString", () => {
   it("formats number less than 1000 with decimals", () => {
-    expect(formatHumanReadableNumber(123.456789, 2)).toBe("123.46")
+    expect(formatNumberToCompactString(123.456789, 2)).toBe("123.46")
   })
 
   it("formats thousands with K", () => {
-    expect(formatHumanReadableNumber(12_345, 2)).toBe("12.35K")
+    expect(formatNumberToCompactString(12_345, 2)).toBe("12.35K")
   })
 
   it("formats millions with M", () => {
-    expect(formatHumanReadableNumber(12_345_678, 2)).toBe("12.35M")
+    expect(formatNumberToCompactString(12_345_678, 2)).toBe("12.35M")
   })
 
   it("formats billions with B", () => {
-    expect(formatHumanReadableNumber(12_345_678_901, 2)).toBe("12.35B")
+    expect(formatNumberToCompactString(12_345_678_901, 2)).toBe("12.35B")
   })
 
   it("formats trillions with T", () => {
-    expect(formatHumanReadableNumber(12_345_678_901_234, 2)).toBe("12.35T")
+    expect(formatNumberToCompactString(12_345_678_901_234, 2)).toBe("12.35T")
   })
 
   it("formats bigint as readable number", () => {
-    expect(formatHumanReadableNumber(1234567890123456789n, 2)).toBe("> 1000T")
+    expect(formatNumberToCompactString(1234567890123456789n, 2)).toBe(
+      "1,234,567.89T",
+    )
   })
 
   it("caps at > 1000T for huge numbers", () => {
     const hugeNumber = 10 ** 18 // 1e18
-    expect(formatHumanReadableNumber(hugeNumber, 2)).toBe("> 1000T")
+    expect(formatNumberToCompactString(hugeNumber, 2)).toBe("1,000,000T")
+  })
+
+  it("formats numbers with trailing zeros correctly", () => {
+    expect(formatNumberToCompactString(1_000, 2)).toBe("1K")
   })
 })
 
@@ -53,7 +61,7 @@ describe("roundUpNumber", () => {
 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)
+    expect(fromFixedPoint(raw, 18)).toBe(1.2345)
   })
 
   it("converts with truncation to 2 decimals", () => {
@@ -67,23 +75,173 @@ describe("fromFixedPoint", () => {
   })
 })
 
-describe("formatTokenAmount", () => {
-  it("formats zero value with desired decimals", () => {
-    expect(formatTokenAmount(0, 18, 3)).toBe("0.000")
-    expect(formatTokenAmount("0", 18, 2)).toBe("0.00")
+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)
+  })
+
+  it("returns the maximum of negative bigint values", () => {
+    expect(bigIntMax(-10n, -5n, -20n)).toBe(-5n)
+  })
+
+  it("returns the only element if array has one bigint", () => {
+    expect(bigIntMax(42n)).toBe(42n)
   })
 
-  it("returns <0.01 if amount is less than minimum display value", () => {
-    expect(formatTokenAmount("1", 18, 2)).toBe("<0.01") // 1 wei = 1e-18
+  it("works with a mix of positive and negative bigints", () => {
+    expect(bigIntMax(-100n, 0n, 50n, -10n)).toBe(50n)
   })
 
-  it("formats a normal value without rounding", () => {
-    const result = formatTokenAmount("1230000000000000000", 18, 2)
-    expect(result).toBe("1.23")
+  it("throws an error if called with no arguments", () => {
+    expect(() => bigIntMax()).toThrow()
   })
 
-  it("formats with rounding if withRoundUp = true", () => {
-    const result = formatTokenAmount("1234560000000000000", 18, 2, true)
-    expect(result).toBe("1.24")
+  it("returns the correct value when all values are equal", () => {
+    expect(bigIntMax(5n, 5n, 5n)).toBe(5n)
   })
 })