@mezo-org/passport 0.4.0-dev.9 → 0.5.0

package/src/utils/address.test.ts

@@ -10,12 +10,6 @@ describe("trimAddress", () => {
     const expected = "0x123...bcdef"
     expect(trimAddress(input)).toBe(expected)
   })
-
-  it("returns lowercase result", () => {
-    const input = "0xABCDEF1234567890"
-    const expected = "0xabc...67890"
-    expect(trimAddress(input)).toBe(expected)
-  })
 })
 
 describe("getAddressExplorerUrl", () => {
@@ -41,4 +35,14 @@ describe("getAddressExplorerUrl", () => {
     const url = getAddressExplorerUrl(evmAddress, "evm", true)
     expect(url).toBe(`https://sepolia.etherscan.io/address/${evmAddress}`)
   })
+
+  it("returns correct mainnet Mezo explorer URL", () => {
+    const url = getAddressExplorerUrl(evmAddress, "mezo", false)
+    expect(url).toBe(`https://explorer.mezo.org/address/${evmAddress}`)
+  })
+
+  it("returns correct testnet Mezo explorer URL", () => {
+    const url = getAddressExplorerUrl(evmAddress, "mezo", true)
+    expect(url).toBe(`https://explorer.test.mezo.org/address/${evmAddress}`)
+  })
 })

package/src/utils/address.ts

@@ -11,14 +11,16 @@ export function trimAddress(address: string): string {
   return trimmedAddress
 }
 
-const MAINNET_EXPLORER_URLS: Record<"bitcoin" | "evm", string> = {
+const MAINNET_EXPLORER_URLS: Record<"bitcoin" | "evm" | "mezo", string> = {
   bitcoin: "https://mempool.space",
   evm: "https://etherscan.io",
+  mezo: "https://explorer.mezo.org",
 }
 
-const TESTNET_EXPLORER_URLS: Record<"bitcoin" | "evm", string> = {
+const TESTNET_EXPLORER_URLS: Record<"bitcoin" | "evm" | "mezo", string> = {
   bitcoin: "https://mempool.space/testnet",
   evm: "https://sepolia.etherscan.io",
+  mezo: "https://explorer.test.mezo.org",
 }
 
 /**
@@ -30,7 +32,7 @@ const TESTNET_EXPLORER_URLS: Record<"bitcoin" | "evm", string> = {
  */
 export function getAddressExplorerUrl(
   address: string,
-  chainType: "bitcoin" | "evm",
+  chainType: "bitcoin" | "evm" | "mezo",
   isTestnet: boolean,
 ) {
   const EXPLORER_URLS = isTestnet

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", () => {
@@ -36,3 +36,79 @@ describe("formatUsd", () => {
     expect(result).toBe("$0.00")
   })
 })
+
+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,8 +1,5 @@
-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
@@ -12,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,
   })
 
@@ -27,6 +26,33 @@ 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" })
+}
+
+/**
+ * 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,
+) {
+  const value = normalizePrecision(
+    assetAmount * conversionRate,
+    assetDecimals + conversionRateDecimals,
+    conversionRateDecimals,
+  )
+
+  const formatted = formatUnits(value, conversionRateDecimals)
+
+  return {
+    value,
+    formatted,
+  }
 }

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,89 +1,96 @@
 import {
-  formatHumanReadableNumber,
-  formatTokenAmount,
-  fromFixedPoint,
-  roundUpNumber,
+  formatNumberToCompactString,
+  bigIntMax,
+  normalizePrecision,
 } 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")
   })
 })
 
-describe("roundUpNumber", () => {
-  it("rounds up to 2 decimals", () => {
-    expect(roundUpNumber(1.234)).toBe(1.24)
+describe("bigIntMax", () => {
+  it("returns the maximum of positive bigint values", () => {
+    expect(bigIntMax(1n, 2n, 3n)).toBe(3n)
   })
 
-  it("rounds up to 3 decimals", () => {
-    expect(roundUpNumber(9.87654, 3)).toBe(9.877)
+  it("returns the maximum of negative bigint values", () => {
+    expect(bigIntMax(-10n, -5n, -20n)).toBe(-5n)
   })
 
-  it("rounds up exact decimal", () => {
-    expect(roundUpNumber(2.5, 1)).toBe(2.5)
+  it("returns the only element if array has one bigint", () => {
+    expect(bigIntMax(42n)).toBe(42n)
   })
-})
 
-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("works with a mix of positive and negative bigints", () => {
+    expect(bigIntMax(-100n, 0n, 50n, -10n)).toBe(50n)
   })
 
-  it("converts with truncation to 2 decimals", () => {
-    const raw = 987654321000000000n // ~0.987654321 ETH
-    expect(fromFixedPoint(raw, 18, 2)).toBe(0.98)
+  it("throws an error if called with no arguments", () => {
+    expect(() => bigIntMax()).toThrow()
   })
 
-  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)
+  it("returns the correct value when all values are equal", () => {
+    expect(bigIntMax(5n, 5n, 5n)).toBe(5n)
   })
 })
 
-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("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 <0.01 if amount is less than minimum display value", () => {
-    expect(formatTokenAmount("1", 18, 2)).toBe("<0.01") // 1 wei = 1e-18
+  it("returns the same value when precision is equal", () => {
+    const result = normalizePrecision(987654321n, 5, 5)
+    expect(result).toBe(987654321n)
   })
 
-  it("formats a normal value without rounding", () => {
-    const result = formatTokenAmount("1230000000000000000", 18, 2)
-    expect(result).toBe("1.23")
+  it("handles zero value correctly", () => {
+    const result = normalizePrecision(0n, 4, 8)
+    expect(result).toBe(0n)
   })
 
-  it("formats with rounding if withRoundUp = true", () => {
-    const result = formatTokenAmount("1234560000000000000", 18, 2, true)
-    expect(result).toBe("1.24")
+  it("handles large numbers without precision loss", () => {
+    const value = 123456789012345678901234567890n
+    const result = normalizePrecision(value, 18, 20)
+    expect(result).toBe(value * 100n)
   })
 })