0xtrails 0.13.2 → 0.15.0

package/src/utils/format.ts

@@ -1,625 +0,0 @@
-import type { NativeTokenBalance, TokenBalance } from "@0xsequence/indexer"
-import { formatUnits, zeroAddress } from "viem"
-import { logger } from "../logger.js"
-import { parseLocaleNumber } from "../localeUtils.js"
-import { isNonNegativeNumber, isValidNumber } from "./validation.js"
-import { forexRateStore } from "../widget/utils/forexRateStore.js"
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export type Price = {
-  value: number
-  currency: string
-}
-
-// ============================================================================
-// Internal helpers
-// ============================================================================
-
-/** Cap used across all USD formatters to prevent display issues */
-const MAX_DISPLAY_VALUE = 100_000_000_000_000
-const MAX_SUPPORTED_TOKEN_DECIMALS = 255
-
-// navigator.language provides the browser's UI language (e.g., 'es-ES', 'en-US')
-// Currently hardcoded to en-US until entire app is updated with locale display values
-function getFormatLocale() {
-  // TODO: use user's locale for formatting once entire app is updated with local locale display values
-  // return typeof navigator !== "undefined" ? navigator.language : "en-US"
-  return "en-US"
-}
-
-/**
- * Core number formatter shared by formatAmount, formatAmountDisplay, formatAmountLocaleDisplay.
- * All three differ only in locale and useGrouping.
- */
-function formatNumber(
-  value: string | number,
-  locale: string | undefined,
-  useGrouping: boolean,
-  maxFractionDigits: number,
-  minFractionDigits: number,
-): string {
-  if (!value) {
-    value = 0
-  }
-
-  let numericValue: number
-  if (typeof value === "string") {
-    numericValue = parseFloat(value)
-  } else {
-    numericValue = Number(value)
-  }
-
-  if (Number.isNaN(numericValue)) {
-    logger.console.warn("[trails-sdk] formatNumber: Invalid number", value)
-    return String(value)
-  }
-
-  try {
-    return numericValue.toLocaleString(locale, {
-      maximumFractionDigits: maxFractionDigits,
-      minimumFractionDigits: minFractionDigits,
-      useGrouping,
-    })
-  } catch (err) {
-    logger.console.error("[trails-sdk] Error formatting value:", err)
-  }
-
-  return value.toString()
-}
-
-/**
- * Shared validation and conversion for rawAmountToNumber / formatRawAmount / formatBalanceFields.
- * Returns the formatted string from formatUnits, or null if balance is falsy.
- * Throws on invalid decimals or negative balance.
- */
-function parseRawBalance(
-  balance: string | bigint,
-  decimals: number,
-): string | null {
-  if (!balance) {
-    return null
-  }
-
-  if (
-    !Number.isInteger(decimals) ||
-    decimals < 0 ||
-    decimals > MAX_SUPPORTED_TOKEN_DECIMALS
-  ) {
-    throw new Error("Invalid decimals")
-  }
-
-  const balanceBigInt = BigInt(balance)
-
-  if (balanceBigInt < 0n) {
-    throw new Error("Negative balance")
-  }
-
-  return formatUnits(balanceBigInt, decimals)
-}
-
-/**
- * Shared validation + sign/cap logic for all USD formatters.
- * Returns null if value is invalid, otherwise the prepared parts.
- */
-function prepareUsdValue(value: number | string): {
-  isNegative: boolean
-  cappedValue: number
-} | null {
-  if (!value) {
-    value = 0
-  }
-
-  const numValue = Number(value)
-
-  if (!Number.isFinite(numValue) || Number.isNaN(numValue)) {
-    return null
-  }
-
-  return {
-    isNegative: numValue < 0,
-    cappedValue: Math.min(Math.abs(numValue), MAX_DISPLAY_VALUE),
-  }
-}
-
-// ============================================================================
-// Amount formatters
-// ============================================================================
-
-export function formatAmount(
-  value: string | number,
-  {
-    maxFractionDigits = 8,
-    minFractionDigits = 2,
-  }: { maxFractionDigits?: number; minFractionDigits?: number } = {},
-): string {
-  // Use 'en-US' locale explicitly to ensure consistent decimal formatting
-  // This ensures we always get period as decimal separator, not comma
-  return formatNumber(
-    value,
-    "en-US",
-    false,
-    maxFractionDigits,
-    minFractionDigits,
-  )
-}
-
-export function formatAmountDisplay(
-  value: string | number,
-  {
-    maxFractionDigits = 8,
-    minFractionDigits = 2,
-  }: { maxFractionDigits?: number; minFractionDigits?: number } = {},
-): string {
-  return formatNumber(
-    value,
-    undefined,
-    true,
-    maxFractionDigits,
-    minFractionDigits,
-  )
-}
-
-/**
- * Formats amount with locale-aware display.
- * Currently hardcoded to en-US (see getFormatLocale).
- */
-export function formatAmountLocaleDisplay(
-  value: string | number,
-  {
-    maxFractionDigits = 8,
-    minFractionDigits = 2,
-  }: { maxFractionDigits?: number; minFractionDigits?: number } = {},
-): string {
-  return formatNumber(
-    value,
-    getFormatLocale(),
-    true,
-    maxFractionDigits,
-    minFractionDigits,
-  )
-}
-
-// ============================================================================
-// USD formatters
-// ============================================================================
-
-export function formatUsdAmountDisplay(value: number | string = 0): string {
-  const prepared = prepareUsdValue(value)
-  if (!prepared) {
-    return "$0.00"
-  }
-
-  const { isNegative, cappedValue } = prepared
-  const signedValue = isNegative ? -cappedValue : cappedValue
-
-  // For very small amounts (less than $0.01), show 3 decimal places or <$0.01
-  if (cappedValue > 0 && cappedValue < 0.01) {
-    const displayValue = Intl.NumberFormat("en-US", {
-      style: "currency",
-      currency: "USD",
-      maximumFractionDigits: 3,
-      minimumFractionDigits: 3,
-    }).format(signedValue)
-
-    if (displayValue === "$0.000") {
-      return "<$0.01"
-    }
-    return displayValue
-  }
-
-  return Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: "USD",
-    maximumFractionDigits: 2,
-    minimumFractionDigits: 2,
-  }).format(signedValue)
-}
-
-/**
- * Formats USD value with user's locale settings (for locale-aware display)
- * Uses browser's locale for number formatting and currency placement.
- * Also converts to the user's display currency via forexRateStore if available.
- */
-export function formatUsdAmountLocaleDisplay(
-  value: number | string = 0,
-): string {
-  const locale = getFormatLocale()
-  const prepared = prepareUsdValue(value)
-
-  if (!prepared) {
-    return new Intl.NumberFormat(locale, {
-      style: "currency",
-      currency: "USD",
-    }).format(0)
-  }
-
-  const { isNegative, cappedValue } = prepared
-
-  // Try to get forex rate from store and convert if available
-  let displayCurrency = "USD"
-  let convertedValue = cappedValue
-
-  const rateData = forexRateStore.getRate()
-  if (rateData && rateData.currency !== "USD") {
-    displayCurrency = rateData.currency
-    convertedValue = cappedValue * rateData.rate
-  }
-
-  // Get currency decimals based on currency code
-  const zeroDecimalCurrencies = ["JPY", "KRW", "VND", "CLP", "ISK"]
-  const decimals = zeroDecimalCurrencies.includes(displayCurrency) ? 0 : 2
-
-  const signedValue = isNegative ? -convertedValue : convertedValue
-
-  // For very small amounts, show more decimal places
-  const smallAmountThreshold =
-    displayCurrency === "USD" ? 0.01 : 10 ** -decimals
-
-  if (convertedValue > 0 && convertedValue < smallAmountThreshold) {
-    const extraDecimals = Math.max(3, decimals + 1)
-    const displayValue = new Intl.NumberFormat(locale, {
-      style: "currency",
-      currency: displayCurrency,
-      maximumFractionDigits: extraDecimals,
-      minimumFractionDigits: extraDecimals,
-    }).format(signedValue)
-
-    // If still rounds to 0, show locale-aware <threshold
-    const zeroValue = new Intl.NumberFormat(locale, {
-      style: "currency",
-      currency: displayCurrency,
-      maximumFractionDigits: extraDecimals,
-      minimumFractionDigits: extraDecimals,
-    }).format(0)
-
-    if (displayValue === zeroValue) {
-      const smallValue = new Intl.NumberFormat(locale, {
-        style: "currency",
-        currency: displayCurrency,
-        maximumFractionDigits: decimals,
-        minimumFractionDigits: decimals,
-      }).format(smallAmountThreshold)
-      return smallValue.replace(/[0-9.,]+/, (match) => `<${match}`)
-    }
-
-    return displayValue
-  }
-
-  return new Intl.NumberFormat(locale, {
-    style: "currency",
-    currency: displayCurrency,
-    maximumFractionDigits: decimals,
-    minimumFractionDigits: decimals,
-  }).format(signedValue)
-}
-
-/**
- * Formats USD value without currency symbol (for formatted fields)
- * Similar to formatUsdAmountDisplay but without the $ sign
- */
-export function formatUsdAmountFormatted(value: number | string = 0): string {
-  const prepared = prepareUsdValue(value)
-  if (!prepared) {
-    return "0.00"
-  }
-
-  const { isNegative, cappedValue } = prepared
-
-  // For very small amounts (less than 0.01), show 3 decimal places
-  if (cappedValue > 0 && cappedValue < 0.01) {
-    const formatted = cappedValue.toLocaleString("en-US", {
-      maximumFractionDigits: 3,
-      minimumFractionDigits: 3,
-      useGrouping: false,
-    })
-    return isNegative ? `-${formatted}` : formatted
-  }
-
-  const formatted = cappedValue.toLocaleString("en-US", {
-    maximumFractionDigits: 2,
-    minimumFractionDigits: 2,
-    useGrouping: false,
-  })
-  return isNegative ? `-${formatted}` : formatted
-}
-
-// ============================================================================
-// Raw amount helpers
-// ============================================================================
-
-export function rawAmountToNumber(
-  balance: string | bigint,
-  decimals: number,
-): number {
-  try {
-    const formatted = parseRawBalance(balance, decimals)
-    if (formatted === null) {
-      return 0
-    }
-    return Number(formatted)
-  } catch (err) {
-    logger.console.error("[trails-sdk] Error converting balance:", {
-      balance,
-      decimals,
-      err,
-    })
-    return 0
-  }
-}
-
-export function formatRawAmount(
-  balance: string | bigint,
-  decimals: number,
-): string {
-  if (!balance) {
-    return "0"
-  }
-
-  try {
-    const formatted = parseRawBalance(balance, decimals)
-    if (formatted === null) {
-      return "0"
-    }
-    return formatAmount(formatted)
-  } catch (err) {
-    logger.console.error("[trails-sdk] Error formatting balance:", {
-      balance,
-      decimals,
-      err,
-    })
-    throw err
-  }
-}
-
-// ============================================================================
-// Token balance USD helpers
-// ============================================================================
-
-export function getTokenBalanceUsd(
-  token: TokenBalance | NativeTokenBalance,
-  tokenPrice: Price,
-): number {
-  const isNative =
-    !("contractAddress" in token) || token.contractAddress === zeroAddress
-  const decimals = isNative ? 18 : token.contractInfo?.decimals
-  if (!decimals) {
-    logger.console.error(
-      "[trails-sdk] [getTokenBalanceUsd] Missing decimals for token:",
-      {
-        token: token,
-        isNative,
-      },
-    )
-    return 0
-  }
-  const formattedBalance = formatRawAmount(token.balance, decimals)
-
-  const priceUsd = Number(tokenPrice.value) || 0
-
-  if (!Number.isFinite(priceUsd) || Number.isNaN(priceUsd) || priceUsd < 0) {
-    return 0
-  }
-
-  const balanceNum = Number(formattedBalance)
-
-  if (
-    !Number.isFinite(balanceNum) ||
-    Number.isNaN(balanceNum) ||
-    balanceNum < 0
-  ) {
-    return 0
-  }
-
-  const result = balanceNum * priceUsd
-
-  if (!Number.isFinite(result) || Number.isNaN(result)) {
-    logger.console.error("[trails-sdk] Error calculating balance USD:", {
-      balanceNum,
-      priceUsd,
-      result,
-      token,
-      tokenPrice,
-    })
-    return 0
-  }
-
-  return result
-}
-
-export function getTokenBalanceUsdFormatted(
-  token: TokenBalance | NativeTokenBalance,
-  tokenPrice: Price,
-): string {
-  const balanceUsd = getTokenBalanceUsd(token, tokenPrice)
-  return formatUsdAmountDisplay(balanceUsd)
-}
-
-// ============================================================================
-// Compound field formatters
-// ============================================================================
-
-/**
- * Formats balance fields (raw → formatted → display)
- * Returns all three versions for Token
- */
-export function formatBalanceFields(
-  balance: string | bigint,
-  decimals: number,
-): {
-  balance: string
-  balanceFormatted: string
-  balanceDisplay: string
-  balanceLocaleDisplay: string
-} {
-  if (!balance) {
-    return {
-      balance: "0",
-      balanceFormatted: "0",
-      balanceDisplay: "0",
-      balanceLocaleDisplay: "0",
-    }
-  }
-
-  try {
-    const formatted = parseRawBalance(balance, decimals)
-    if (formatted === null) {
-      return {
-        balance: "0",
-        balanceFormatted: "0",
-        balanceDisplay: "0",
-        balanceLocaleDisplay: "0",
-      }
-    }
-
-    const balanceString = BigInt(balance).toString()
-
-    return {
-      balance: balanceString,
-      balanceFormatted: formatAmount(formatted),
-      balanceDisplay: formatAmountDisplay(formatted),
-      balanceLocaleDisplay: formatAmountLocaleDisplay(formatted),
-    }
-  } catch (err) {
-    logger.console.error("[trails-sdk] Error formatting balance fields:", {
-      balance,
-      decimals,
-      err,
-    })
-    return {
-      balance: typeof balance === "string" ? balance : balance.toString(),
-      balanceFormatted: "0",
-      balanceDisplay: "0",
-      balanceLocaleDisplay: "0",
-    }
-  }
-}
-
-/**
- * Formats USD value fields (raw → formatted → display)
- * Returns all three versions for Token
- */
-export function formatUsdFields(usdValue: number | string | null | undefined): {
-  balanceUsd?: number
-  balanceUsdFormatted?: string
-  balanceUsdDisplay?: string
-  balanceUsdLocaleDisplay?: string
-} {
-  if (usdValue === null || usdValue === undefined) {
-    return {}
-  }
-
-  const numValue = Number(usdValue)
-
-  if (!Number.isFinite(numValue) || Number.isNaN(numValue)) {
-    return {
-      balanceUsd: 0,
-      balanceUsdFormatted: "0.00",
-      balanceUsdDisplay: "$0.00",
-      balanceUsdLocaleDisplay: formatUsdAmountLocaleDisplay(0),
-    }
-  }
-
-  return {
-    balanceUsd: numValue,
-    balanceUsdFormatted: formatUsdAmountFormatted(numValue),
-    balanceUsdDisplay: formatUsdAmountDisplay(numValue),
-    balanceUsdLocaleDisplay: formatUsdAmountLocaleDisplay(numValue),
-  }
-}
-
-/**
- * Formats price fields (raw → formatted → display)
- * Returns all three versions for Token
- */
-export function formatPriceFields(price: number | string | null | undefined): {
-  priceUsd?: number
-  priceUsdFormatted?: string
-  priceUsdDisplay?: string
-} {
-  const usdFields = formatUsdFields(price)
-  return {
-    priceUsd: usdFields.balanceUsd,
-    priceUsdFormatted: usdFields.balanceUsdFormatted,
-    priceUsdDisplay: usdFields.balanceUsdDisplay,
-  }
-}
-
-export function normalizeNumber(
-  number: number | string | null | undefined,
-): number {
-  if (number === null || number === undefined) {
-    return 0
-  }
-
-  // If already a number, return it directly
-  if (typeof number === "number") {
-    // Validate the number
-    if (!isValidNumber(number)) {
-      logger.console.error("[trails-sdk] Invalid number value:", number)
-      return 0
-    }
-    return number
-  }
-
-  // Only parse strings that might be locale-formatted
-  // This should ideally only be used for user input, not internal calculations
-  const normalized = parseLocaleNumber(number)
-
-  // Return 0 for invalid numbers
-  if (!isValidNumber(normalized)) {
-    logger.console.error("[trails-sdk] Error normalizing number string:", {
-      number,
-      normalized,
-    })
-    return 0
-  }
-
-  return normalized
-}
-
-export function calcAmountUsdPrice({
-  amount,
-  usdPrice,
-}: {
-  amount: number | string
-  usdPrice: string | number | null | undefined
-}) {
-  const sanitizedAmount = normalizeNumber(amount)
-  const sanitizedPrice = normalizeNumber(usdPrice)
-
-  // Validate inputs
-  if (!isNonNegativeNumber(sanitizedAmount)) {
-    return 0
-  }
-  if (!isNonNegativeNumber(sanitizedPrice)) {
-    return 0
-  }
-
-  const result = sanitizedAmount * sanitizedPrice
-
-  // Validate result
-  if (!isValidNumber(result)) {
-    logger.console.error("[trails-sdk] Error calculating amount USD:", {
-      sanitizedAmount,
-      sanitizedPrice,
-      result,
-      amount,
-      usdPrice,
-    })
-    return 0
-  }
-
-  return result
-}
-
-export function formatTvl(tvl: number): string {
-  if (tvl >= 1e9) return `$${(tvl / 1e9).toFixed(1)}B`
-  if (tvl >= 1e6) return `$${(tvl / 1e6).toFixed(1)}M`
-  if (tvl >= 1e3) return `$${(tvl / 1e3).toFixed(1)}K`
-  return `$${tvl.toFixed(0)}`
-}
-
-export { isValidInteger, isValidNumeric } from "./validation.js"

package/src/utils/passthrough.ts

@@ -1,93 +0,0 @@
-/**
- * Utilities for quote and transaction flow determination
- */
-
-import type { FeeOption } from "@0xtrails/api"
-import { isNativeToken } from "./address.js"
-import type { TransactionState } from "../transactions.js"
-
-/**
- * Determines if a transaction will use passthrough flow based on quote and fee option eligibility.
- *
- * Passthrough is eligible when:
- * 1. The quote's passthroughEligible is true, AND
- * 2. The effective fee path is passthrough-eligible:
- *    - selected fee option is explicitly marked passthrough-eligible, OR
- *    - native fee is selected and the native fee option is marked passthrough-eligible
- *
- * @param passthroughEligible - Quote's passthrough eligibility flag
- * @param selectedFeeOption - The selected fee option (null = native token)
- * @param feeOptions - Available fee options in quote context
- * @returns true if passthrough flow should be used
- */
-export function isPassthroughEligible(
-  passthroughEligible: boolean | undefined,
-  selectedFeeOption: FeeOption | null | undefined,
-  feeOptions?: ReadonlyArray<FeeOption> | null,
-): boolean {
-  if (selectedFeeOption === undefined) return false
-
-  if (selectedFeeOption === null) {
-    const nativeFeeOption = feeOptions?.find((option) =>
-      isNativeToken(option.tokenAddress),
-    )
-    return (
-      passthroughEligible === true &&
-      nativeFeeOption?.isPassthroughEligible === true
-    )
-  }
-
-  return (
-    passthroughEligible === true &&
-    selectedFeeOption.isPassthroughEligible === true
-  )
-}
-
-interface TokenLike {
-  contractAddress?: string | null
-  chainId?: number
-}
-
-interface ChainLike {
-  id?: number
-}
-
-interface QuoteLike {
-  originToken?: TokenLike | null
-  destinationToken?: TokenLike | null
-  originChain?: ChainLike | null
-  destinationChain?: ChainLike | null
-}
-
-/**
- * Checks if origin and destination are the same token on the same chain.
- *
- * @param quote - Quote object containing origin/destination token and chain info
- * @returns true if same token on same chain
- */
-export function isSameChainSameToken(
-  quote: QuoteLike | null | undefined,
-): boolean {
-  if (!quote) return false
-  return (
-    quote.originToken?.contractAddress?.toLowerCase() ===
-      quote.destinationToken?.contractAddress?.toLowerCase() &&
-    quote.originChain?.id === quote.destinationChain?.id
-  )
-}
-
-/**
- * Checks if a transaction state has a meta-transaction error (CallFailed event).
- *
- * @param tx - Transaction state to check
- * @returns true if the transaction has a CallFailed event
- */
-export function hasMetaTxError(
-  tx: TransactionState | null | undefined,
-): boolean {
-  return (
-    tx?.decodedGuestModuleEvents?.some(
-      (event) => event.type === "CallFailed",
-    ) ?? false
-  )
-}