@mezo-org/passport 0.4.0-dev.9 → 0.5.1-dev.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
+}