0xtrails 0.13.2 → 0.15.0

package/src/analytics.ts

@@ -1,2029 +0,0 @@
-import { Databeat, type Event as DatabeatEvent } from "@databeat/tracker"
-import { Bytes, Hash } from "ox"
-import { DATABEAT_KEY, DATABEAT_SERVER } from "./constants.js"
-import { getQueryParam } from "./queryParams.js"
-import { getEnvVar } from "./config.js"
-import { logger } from "./logger.js"
-import { getUserLocale } from "./localeUtils.js"
-import packageJson from "../package.json" with { type: "json" }
-import type { OnrampTrackingData } from "./widget/types/analytics.js"
-import type { FundMethod } from "./transactionIntent/types.js"
-import { isValidNumber, isNonNegativeNumber } from "./utils/validation.js"
-
-import { normalizeAddress } from "./utils/address.js"
-let checkoutIdSingleton: string | null = null
-
-export function getSdkVersion() {
-  return packageJson.version || "dev"
-}
-
-export function hasCheckoutId() {
-  return checkoutIdSingleton !== null
-}
-
-export function resetCheckoutId() {
-  checkoutIdSingleton = null
-
-  try {
-    localStorage.removeItem("checkoutId")
-  } catch (error) {
-    logger.console.error("Error removing checkout id:", error)
-  }
-}
-
-export function getCheckoutUserId() {
-  try {
-    return localStorage.getItem("checkoutUserId")
-  } catch (error) {
-    logger.console.error("Error getting checkout user id:", error)
-  }
-}
-
-export function getNewCheckoutId(userAddress?: string) {
-  if (userAddress) {
-    try {
-      localStorage.setItem("checkoutUserId", normalizeAddress(userAddress))
-    } catch (error) {
-      logger.console.error("Error setting checkout user id:", error)
-    }
-  }
-
-  generateCheckoutIdAndSet()
-
-  return getCheckoutId()
-}
-
-export function getCheckoutId() {
-  if (checkoutIdSingleton) {
-    return checkoutIdSingleton
-  }
-
-  try {
-    checkoutIdSingleton = localStorage.getItem("checkoutId")
-  } catch (error) {
-    logger.console.error("Error getting checkout id:", error)
-  }
-
-  return checkoutIdSingleton
-}
-
-export function generateCheckoutIdAndSet() {
-  resetCheckoutId()
-
-  checkoutIdSingleton = generateCheckoutId()
-  try {
-    localStorage.setItem("checkoutId", checkoutIdSingleton)
-  } catch (error) {
-    logger.console.error("Error setting checkout id:", error)
-  }
-}
-
-export function generateCheckoutId() {
-  try {
-    return crypto.randomUUID()
-  } catch (error) {
-    logger.console.error("Error generating checkout id:", error)
-    return Date.now().toString()
-  }
-}
-
-// Pseudonymize sensitive data like transaction hashes and addresses
-export function pseudonymizeSimple(value: string): string {
-  if (!value) return value
-
-  // Use ox Hash function for proper synchronous hashing
-  // Convert any string to Bytes and then to hex
-  const normalizedValue = value?.toString()?.trim().toLowerCase() || ""
-  const inputBytes = Bytes.fromString(normalizedValue)
-  const hashBytes = Hash.sha256(inputBytes)
-  const hashHex = Bytes.toHex(hashBytes)
-  const id = `anon_${hashHex.replace("0x", "")}`
-
-  return id
-}
-
-// Pseudonymize user address using the same logic as Databeat with userIdHash: true
-// This replicates the genUserId function from Databeat when privacy.userIdHash is enabled
-export function pseudonymize(
-  address: string,
-  options?: {
-    userAgentSalt?: boolean
-    extraSalt?: string
-  },
-): string {
-  if (!address) return ""
-
-  // Normalize the address (lowercase, as done in identifyUser)
-  let seed = normalizeAddress(address)
-
-  // Add user agent salt if enabled (matches Databeat logic)
-  if (options?.userAgentSalt && typeof navigator !== "undefined") {
-    seed = `${seed}:${navigator.userAgent}`
-  }
-
-  // Add extra salt if provided (matches Databeat logic)
-  if (options?.extraSalt && options.extraSalt.length > 0) {
-    seed = `${seed}:${options.extraSalt}`
-  }
-
-  // Hash using SHA256 and convert to hex (same as Databeat)
-  const inputBytes = Bytes.fromString(seed)
-  const hashBytes = Hash.sha256(inputBytes)
-  const hashHex = Bytes.toHex(hashBytes)
-
-  // Return first 50 characters without 0x prefix (matches Databeat's substring(0, 50))
-  return hashHex.replace("0x", "").substring(0, 50)
-}
-
-export function hashUserAddress(address: string) {
-  return pseudonymize(pseudonymize(address), {
-    userAgentSalt: false,
-    extraSalt: "s3qs4lt",
-  })
-}
-
-declare global {
-  interface Window {
-    _pseudonymize?: typeof pseudonymize
-  }
-}
-
-if (typeof window !== "undefined") {
-  // for debugging
-  window._pseudonymize = pseudonymize
-}
-
-export const EventType = {
-  PAGEVIEW: "PAGEVIEW" as const,
-  WIDGET_SCREEN: "WIDGET_SCREEN" as const,
-  PAYMENT_STARTED: "PAYMENT_STARTED" as const,
-  PAYMENT_COMPLETED: "PAYMENT_COMPLETED" as const,
-  PAYMENT_ERROR: "PAYMENT_ERROR" as const,
-
-  // Wallet events
-  WALLET_CONNECTED: "WALLET_CONNECTED" as const,
-  WALLET_DISCONNECTED: "WALLET_DISCONNECTED" as const,
-
-  // Intent events
-  INTENT_QUOTE_REQUESTED: "INTENT_QUOTE_REQUESTED" as const,
-  INTENT_QUOTE_RECEIVED: "INTENT_QUOTE_RECEIVED" as const,
-  INTENT_QUOTE_ERROR: "INTENT_QUOTE_ERROR" as const,
-  INTENT_COMMIT_STARTED: "INTENT_COMMIT_STARTED" as const,
-  INTENT_COMMIT_COMPLETED: "INTENT_COMMIT_COMPLETED" as const,
-  INTENT_COMMIT_ERROR: "INTENT_COMMIT_ERROR" as const,
-
-  // Transaction events
-  TRANSACTION_STARTED: "TRANSACTION_STARTED" as const,
-  TRANSACTION_SIGNED: "TRANSACTION_SIGNED" as const,
-  TRANSACTION_SUBMITTED: "TRANSACTION_SUBMITTED" as const,
-  TRANSACTION_CONFIRMED: "TRANSACTION_CONFIRMED" as const,
-  TRANSACTION_ERROR: "TRANSACTION_ERROR" as const,
-
-  // Relayer events
-  RELAYER_CALL_STARTED: "RELAYER_CALL_STARTED" as const,
-  RELAYER_CALL_COMPLETED: "RELAYER_CALL_COMPLETED" as const,
-  RELAYER_CALL_ERROR: "RELAYER_CALL_ERROR" as const,
-
-  // Onramp events
-  ONRAMP_QUOTE_REQUESTED: "ONRAMP_QUOTE_REQUESTED" as const,
-  ONRAMP_QUOTE_RECEIVED: "ONRAMP_QUOTE_RECEIVED" as const,
-  ONRAMP_QUOTE_ERROR: "ONRAMP_QUOTE_ERROR" as const,
-  ONRAMP_WIDGET_SESSION: "ONRAMP_WIDGET_SESSION" as const,
-  ONRAMP_PAYMENT_COMPLETED: "ONRAMP_PAYMENT_COMPLETED" as const,
-
-  // Click tracking event
-  WIDGET_CLICK: "WIDGET_CLICK" as const,
-}
-
-export type EventTypes = keyof typeof EventType
-export type Event = DatabeatEvent<EventTypes>
-export type AnalyticsPropValue = unknown
-export type AnalyticsProps = Record<string, AnalyticsPropValue>
-export type EventProps = {
-  event: EventTypes
-  props: AnalyticsProps
-}
-
-function toDatabeatProps(props: AnalyticsProps): Record<string, string> {
-  const normalized: Record<string, string> = {}
-
-  for (const [key, value] of Object.entries(props)) {
-    if (value === undefined || value === null) continue
-    normalized[key] = typeof value === "string" ? value : String(value)
-  }
-
-  return normalized
-}
-
-abstract class BaseAnalytics {
-  protected sequenceProjectAccessKey: string | undefined
-
-  constructor(sequenceProjectAccessKey?: string) {
-    this.sequenceProjectAccessKey = sequenceProjectAccessKey
-  }
-
-  updateProjectAccessKey(sequenceProjectAccessKey: string) {
-    this.sequenceProjectAccessKey = sequenceProjectAccessKey
-  }
-
-  // Helper to auto-identify users when userAddress is provided but no ident is set
-  protected autoIdentifyIfNeeded(
-    userAddress: string | undefined,
-    eventName: string,
-  ) {
-    if (!userAddress) return
-
-    const currentUserId = this.getCurrentUserId()
-
-    // Check if userId matches the expected hashed address format (52 chars like the hash)
-    // Example: "10249047220fb6b1a68f5ef6d62f109d82f71dffd587e183fb"
-    const isHashedAddressFormat =
-      currentUserId &&
-      typeof currentUserId === "string" &&
-      currentUserId.length > 20
-
-    const isIdentified =
-      currentUserId && currentUserId !== "anonymous" && isHashedAddressFormat
-
-    if (!isIdentified) {
-      logger.console.log(
-        `[trails-sdk] DEBUG: Auto-identifying from ${eventName}`,
-        {
-          userAddress,
-          currentUserId,
-          currentUserIdLength: currentUserId?.length,
-          isHashedAddressFormat,
-          timestamp: new Date().toISOString(),
-        },
-      )
-      this.identifyUser({ address: userAddress })
-    }
-  }
-
-  protected getCurrentUserId(): string | undefined {
-    return undefined
-  }
-
-  abstract identifyUser(data: { address: string }): void
-
-  private getCommonProps(): Record<string, string> {
-    return {
-      ...this.getNavigatorProps(),
-      ...this.getDocumentProps(),
-      ...this.getWindowProps(),
-      sequenceProjectAccessKey: this.sequenceProjectAccessKey || "",
-      sdkVersion: getSdkVersion(),
-    }
-  }
-
-  private getNavigatorProps(): Record<string, string> {
-    if (typeof navigator === "undefined") {
-      return {
-        userAgent: "",
-        userLocale: "",
-        userLanguage: "",
-        userCountry: "",
-        userTimezone: "",
-        userTimezoneOffset: "",
-      }
-    }
-
-    const locale = getUserLocale()
-    // Extract country code from locale (e.g., "en-US" -> "US", "fr-FR" -> "FR")
-    const countryCode = locale.includes("-") ? locale.split("-")[1] || "" : ""
-    const languageCode = locale.includes("-")
-      ? locale.split("-")[0] || locale
-      : locale
-
-    // Get timezone information
-    let timezone = ""
-    let timezoneOffset = ""
-    try {
-      timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || ""
-      timezoneOffset = new Date().getTimezoneOffset().toString() // Minutes offset from UTC
-    } catch (_e) {
-      // Intl might not be available in some environments
-    }
-
-    return {
-      userAgent: navigator.userAgent,
-      userLocale: locale,
-      userLanguage: languageCode,
-      userCountry: countryCode,
-      userTimezone: timezone,
-      userTimezoneOffset: timezoneOffset,
-    }
-  }
-
-  private getDocumentProps(): Record<string, string> {
-    if (typeof window === "undefined") {
-      return {
-        userAgent: "",
-        title: "",
-      }
-    }
-
-    return {
-      title: document.title,
-      referrer: document.referrer,
-    }
-  }
-
-  private getWindowProps(): Record<string, string> {
-    if (typeof window === "undefined") {
-      return {
-        url: "",
-        origin: "",
-        hostname: "",
-        pathname: "",
-        screenWidth: "",
-        screenHeight: "",
-        screenPixelRatio: "",
-        screenResolution: "",
-        screenOrientation: "",
-      }
-    }
-
-    return {
-      url: window.location?.href,
-      origin: window?.origin || window?.location?.origin,
-      hostname: window.location?.hostname,
-      pathname: window.location?.pathname,
-      screenWidth: window.innerWidth?.toString(),
-      screenHeight: window.innerHeight?.toString(),
-      screenPixelRatio: window.devicePixelRatio?.toString(),
-      screenResolution: `${window.screen?.width}x${window.screen?.height}`,
-      screenOrientation: window.screen?.orientation?.type?.toString(),
-    }
-  }
-
-  abstract track(event: EventProps): void
-
-  trackPageview() {
-    this.track({
-      event: EventType.PAGEVIEW,
-      props: this.getCommonProps(),
-    })
-  }
-
-  trackWidgetScreen(data: {
-    screen: string
-    userAddress?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    // Auto-identify if userAddress provided but no ident set
-    this.autoIdentifyIfNeeded(data.userAddress, "trackWidgetScreen")
-
-    this.track({
-      event: EventType.WIDGET_SCREEN,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-      },
-    })
-  }
-
-  trackPaymentStarted(data: {
-    userAddress?: string
-    intentAddress?: string
-    originChainId?: number
-    destinationChainId?: number
-    originTokenAddress?: string
-    originTokenAmount?: string
-    originTokenDecimals?: number
-    destinationTokenSymbol?: string
-    destinationTokenAddress?: string
-    destinationTokenAmount?: string
-    destinationTokenDecimals?: number
-    mode?: string
-    fundMethod?: FundMethod
-    sourceTokenPriceUsd?: string
-    destinationTokenPriceUsd?: string
-    tradeType?: string
-    swapProvider?: string
-    bridgeProvider?: string
-    onramp?: OnrampTrackingData | null
-    walletId?: string
-    destinationCalldata?: string
-  }) {
-    // Auto-identify if userAddress provided but no ident set
-    this.autoIdentifyIfNeeded(data.userAddress, "trackPaymentStarted")
-    resetCheckoutId()
-
-    // Destructure onramp data if present and exclude it from data spread
-    const { onramp, ...dataWithoutOnramp } = data
-    const onrampProps = onramp
-      ? {
-          ...(onramp.sessionId && { onrampSessionId: onramp.sessionId }),
-          onrampProvider: onramp.provider,
-          onrampSourceAmount: onramp.sourceAmount,
-          onrampSourceCurrency: onramp.sourceCurrencyCode,
-          onrampDestinationAmount: onramp.destinationAmount,
-          onrampDestinationCurrency: onramp.destinationCurrencyCode,
-          onrampExchangeRate: onramp.exchangeRate,
-          ...(onramp.networkFees && { onrampNetworkFees: onramp.networkFees }),
-          ...(onramp.transactionFee && {
-            onrampTransactionFee: onramp.transactionFee,
-          }),
-          ...(onramp.totalFees && { onrampTotalFees: onramp.totalFees }),
-          onrampCountryCode: onramp.countryCode,
-          ...(onramp.paymentMethod && {
-            onrampPaymentMethod: onramp.paymentMethod,
-          }),
-          ...(onramp.quoteId && { onrampQuoteId: onramp.quoteId }),
-          onrampTimestamp: onramp.timestamp,
-        }
-      : {}
-
-    this.track({
-      event: EventType.PAYMENT_STARTED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getNewCheckoutId(data.userAddress),
-        ...dataWithoutOnramp,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-        destinationChainId: data.destinationChainId?.toString(),
-        originChainId: data.originChainId?.toString(),
-        originTokenAmount: data.originTokenAmount?.toString(),
-        originTokenDecimals: data.originTokenDecimals?.toString(),
-        destinationTokenAmount: data.destinationTokenAmount?.toString(),
-        destinationTokenDecimals: data.destinationTokenDecimals?.toString(),
-        sourceTokenPriceUsd: data.sourceTokenPriceUsd?.toString(),
-        destinationTokenPriceUsd: data.destinationTokenPriceUsd?.toString(),
-        tradeType: data.tradeType,
-        swapProvider: data.swapProvider,
-        bridgeProvider: data.bridgeProvider,
-        ...onrampProps,
-      },
-    })
-  }
-
-  /**
-   * Validates USD amounts are reasonable before sending to analytics
-   * Returns undefined if the value is invalid or suspicious
-   */
-  private validateUsdAmount(
-    usdAmount: string | number | undefined | null,
-    context: {
-      rawAmount?: string
-      formattedAmount?: string
-      decimals?: number
-      priceUsd?: string | number | null
-      tokenSymbol?: string
-    },
-  ): string | undefined {
-    if (!usdAmount) return undefined
-
-    // Only accept numbers for USD amounts - no locale parsing for internal calculations
-    let numValue: number
-    if (typeof usdAmount === "number") {
-      numValue = usdAmount
-    } else if (typeof usdAmount === "string") {
-      // Try to parse as a plain number (no locale detection)
-      numValue = Number(usdAmount)
-      if (!isValidNumber(numValue)) {
-        logger.console.warn(
-          "[trails-sdk] Invalid USD amount string, expected a number:",
-          { usdAmount, context },
-        )
-        return undefined
-      }
-    } else {
-      return undefined
-    }
-
-    // Check for invalid numbers
-    if (!isNonNegativeNumber(numValue)) {
-      logger.console.warn(
-        "[trails-sdk] Invalid USD amount detected, not sending to analytics:",
-        {
-          usdAmount,
-          context,
-        },
-      )
-      return undefined
-    }
-
-    // Check for suspiciously large values (more than 1 billion USD)
-    const MAX_REASONABLE_USD = 1_000_000_000
-    if (numValue > MAX_REASONABLE_USD) {
-      logger.console.warn(
-        "[trails-sdk] Suspiciously large USD amount detected, not sending to analytics:",
-        {
-          usdAmount,
-          context,
-        },
-      )
-      return undefined
-    }
-
-    // Validate raw amount matches formatted amount (using decimals)
-    // This catches cases where wrong decimals were used
-    if (
-      context.rawAmount &&
-      context.formattedAmount &&
-      context.decimals !== undefined &&
-      context.decimals >= 0 &&
-      context.decimals <= 18
-    ) {
-      try {
-        const rawAmountBig = BigInt(context.rawAmount)
-        const decimals = context.decimals
-        const divisor = BigInt(10 ** decimals)
-        const expectedFormatted = Number(rawAmountBig) / Number(divisor)
-        const actualFormatted = Number(context.formattedAmount)
-        const ratio = actualFormatted / expectedFormatted
-
-        // If formatted amount is more than 2x or less than 0.5x the expected value, it's suspicious
-        // (allowing some tolerance for rounding differences)
-        if (ratio > 2 || ratio < 0.5) {
-          logger.console.warn(
-            "[trails-sdk] Formatted amount doesn't match raw amount with decimals, not sending USD to analytics:",
-            {
-              usdAmount,
-              rawAmount: context.rawAmount,
-              formattedAmount: context.formattedAmount,
-              decimals: context.decimals,
-              expectedFormatted,
-              actualFormatted,
-              ratio,
-              context,
-            },
-          )
-          return undefined
-        }
-      } catch (err) {
-        // If parsing fails, log but don't block (might be edge case)
-        logger.console.warn(
-          "[trails-sdk] Error validating raw amount against formatted amount:",
-          err,
-        )
-      }
-    }
-
-    // If we have formatted amount and price, validate the calculation makes sense
-    if (
-      context.formattedAmount &&
-      context.priceUsd &&
-      Number(context.formattedAmount) > 0 &&
-      Number(context.priceUsd) > 0
-    ) {
-      const expectedUsd =
-        Number(context.formattedAmount) * Number(context.priceUsd)
-      const ratio = numValue / expectedUsd
-
-      // If the actual USD is more than 10x or less than 0.1x the expected value, it's suspicious
-      if (ratio > 10 || ratio < 0.1) {
-        logger.console.warn(
-          "[trails-sdk] USD amount doesn't match expected calculation, not sending to analytics:",
-          {
-            usdAmount,
-            expectedUsd,
-            ratio,
-            context,
-          },
-        )
-        return undefined
-      }
-    }
-
-    return numValue.toString()
-  }
-
-  trackPaymentCompleted(data: {
-    userAddress?: string
-    intentAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    originTokenAddress?: string
-    originTokenSymbol?: string
-    originTokenAmount?: string
-    originTokenAmountFormatted?: string
-    depositTokenAmount?: string
-    depositTokenAmountFormatted?: string
-    depositTokenAmountUsd?: string | number
-    destinationTokenAmount?: string
-    destinationTokenAmountFormatted?: string
-    destinationTokenAmountUsd?: string | number
-    originTokenDecimals?: number
-    destinationTokenDecimals?: number
-    destinationTokenSymbol?: string
-    originChainId?: number
-    destinationChainId?: number
-    tradeType?: string
-    sourceTokenPriceUsd?: string | number | null
-    destinationTokenPriceUsd?: string | number | null
-    swapProvider?: string
-    bridgeProvider?: string
-    onramp?: OnrampTrackingData | null
-    walletId?: string
-    destinationCalldata?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    // Auto-identify if userAddress provided but no ident set
-    this.autoIdentifyIfNeeded(data.userAddress, "trackPaymentCompleted")
-
-    // Validate USD amounts before sending
-    const validatedDepositTokenAmountUsd = this.validateUsdAmount(
-      data.depositTokenAmountUsd,
-      {
-        rawAmount: data.depositTokenAmount,
-        formattedAmount: data.depositTokenAmountFormatted,
-        decimals: data.originTokenDecimals,
-        priceUsd: data.sourceTokenPriceUsd,
-        tokenSymbol: data.originTokenSymbol,
-      },
-    )
-
-    const validatedDestinationTokenAmountUsd = this.validateUsdAmount(
-      data.destinationTokenAmountUsd,
-      {
-        rawAmount: data.destinationTokenAmount,
-        formattedAmount: data.destinationTokenAmountFormatted,
-        decimals: data.destinationTokenDecimals,
-        priceUsd: data.destinationTokenPriceUsd,
-        tokenSymbol: data.destinationTokenSymbol,
-      },
-    )
-
-    // Cross-validate: destination USD shouldn't be wildly different from deposit USD
-    // (unless there's a huge price difference, but even then, 100x difference is suspicious)
-    let finalDestinationTokenAmountUsd = validatedDestinationTokenAmountUsd
-    if (validatedDepositTokenAmountUsd && validatedDestinationTokenAmountUsd) {
-      const depositUsd = Number(validatedDepositTokenAmountUsd)
-      const destUsd = Number(validatedDestinationTokenAmountUsd)
-      const ratio = destUsd / depositUsd
-
-      // If destination USD is more than 100x or less than 0.01x the deposit USD, it's suspicious
-      if (ratio > 100 || ratio < 0.01) {
-        logger.console.warn(
-          "[trails-sdk] Suspicious USD ratio between deposit and destination, not sending destination USD:",
-          {
-            depositTokenAmountUsd: validatedDepositTokenAmountUsd,
-            destinationTokenAmountUsd: validatedDestinationTokenAmountUsd,
-            ratio,
-            depositTokenAmount: data.depositTokenAmount,
-            destinationTokenAmount: data.destinationTokenAmount,
-            originTokenSymbol: data.originTokenSymbol,
-            destinationTokenSymbol: data.destinationTokenSymbol,
-          },
-        )
-        // Don't send the suspicious destination USD value
-        finalDestinationTokenAmountUsd = undefined
-      }
-    }
-
-    // Destructure onramp data if present and exclude it from data spread
-    const { onramp, ...dataWithoutOnramp } = data
-    const onrampProps = onramp
-      ? {
-          ...(onramp.sessionId && { onrampSessionId: onramp.sessionId }),
-          onrampProvider: onramp.provider,
-          onrampSourceAmount: onramp.sourceAmount,
-          onrampSourceCurrency: onramp.sourceCurrencyCode,
-          onrampDestinationAmount: onramp.destinationAmount,
-          onrampDestinationCurrency: onramp.destinationCurrencyCode,
-          onrampExchangeRate: onramp.exchangeRate,
-          ...(onramp.networkFees && { onrampNetworkFees: onramp.networkFees }),
-          ...(onramp.transactionFee && {
-            onrampTransactionFee: onramp.transactionFee,
-          }),
-          ...(onramp.totalFees && { onrampTotalFees: onramp.totalFees }),
-          onrampCountryCode: onramp.countryCode,
-          ...(onramp.paymentMethod && {
-            onrampPaymentMethod: onramp.paymentMethod,
-          }),
-          ...(onramp.quoteId && { onrampQuoteId: onramp.quoteId }),
-          onrampTimestamp: onramp.timestamp,
-        }
-      : {}
-
-    this.track({
-      event: EventType.PAYMENT_COMPLETED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...dataWithoutOnramp,
-        originChainId: data.originChainId?.toString(),
-        destinationChainId: data.destinationChainId?.toString(),
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-        originTokenAddress: data.originTokenAddress,
-        originTokenSymbol: data.originTokenSymbol,
-        originTokenAmount: data.originTokenAmount?.toString(),
-        originTokenAmountFormatted: data.originTokenAmountFormatted?.toString(),
-        depositTokenAmount: data.depositTokenAmount?.toString(),
-        depositTokenAmountFormatted:
-          data.depositTokenAmountFormatted?.toString(),
-        depositTokenAmountUsd: validatedDepositTokenAmountUsd,
-        destinationTokenAmount: data.destinationTokenAmount?.toString(),
-        destinationTokenAmountFormatted:
-          data.destinationTokenAmountFormatted?.toString(),
-        destinationTokenAmountUsd: finalDestinationTokenAmountUsd,
-        originTokenDecimals: data.originTokenDecimals?.toString(),
-        destinationTokenDecimals: data.destinationTokenDecimals?.toString(),
-        tradeType: data.tradeType,
-        sourceTokenPriceUsd: data.sourceTokenPriceUsd?.toString(),
-        destinationTokenPriceUsd: data.destinationTokenPriceUsd?.toString(),
-        swapProvider: data.swapProvider,
-        bridgeProvider: data.bridgeProvider,
-        ...onrampProps,
-      },
-    })
-    resetCheckoutId()
-  }
-
-  trackPaymentError(data: {
-    error: string
-    userAddress?: string
-    intentAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    originChainId?: number
-    destinationChainId?: number
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.PAYMENT_ERROR,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-        originChainId: data.originChainId?.toString(),
-        destinationChainId: data.destinationChainId?.toString(),
-      },
-    })
-  }
-
-  // Wallet tracking methods
-  trackWalletConnected(data: {
-    walletType: string
-    address: string
-    chainId: number
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.WALLET_CONNECTED,
-      props: {
-        ...this.getCommonProps(),
-        ...data,
-        address: data.address,
-        chainId: data.chainId?.toString(),
-      },
-    })
-  }
-
-  trackWalletDisconnected(data?: { [key: string]: AnalyticsPropValue }) {
-    this.track({
-      event: EventType.WALLET_DISCONNECTED,
-      props: {
-        ...this.getCommonProps(),
-        ...(data || {}),
-      },
-    })
-  }
-
-  // Intent tracking methods
-  trackIntentQuoteRequested(data: {
-    originChainId: number
-    destinationChainId: number
-    originTokenAddress?: string
-    destinationTokenAddress?: string
-    userAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    originTokenSymbol?: string
-    destinationTokenSymbol?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    // Auto-identify if userAddress provided but no ident set
-    this.autoIdentifyIfNeeded(data.userAddress, "trackIntentQuoteRequested")
-    this.track({
-      event: EventType.INTENT_QUOTE_REQUESTED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        originChainId: data.originChainId?.toString(),
-        destinationChainId: data.destinationChainId?.toString(),
-        originTokenAddress: data.originTokenAddress,
-        destinationTokenAddress: data.destinationTokenAddress,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        originTokenSymbol: data.originTokenSymbol,
-        destinationTokenSymbol: data.destinationTokenSymbol,
-      },
-    })
-  }
-
-  trackIntentQuoteReceived(data: {
-    quoteId: string
-    totalFeeUSD?: string
-    trailsFixedFeeUSD?: number
-    crossChainFeeTotalUSD?: number
-    takerFeeUSD?: number
-    providerFeeUSD?: number
-    trailsSwapFeeUSD?: number
-    gasFeesPerChainUSD?: number[]
-    originTokenTotalAmount?: string
-    totalFeeAmount?: string
-    provider?: string
-    swapProvider?: string
-    bridgeProvider?: string
-    feeToken?: string
-    userAddress?: string
-    intentAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    feeTokenSymbol?: string
-    originTokenSymbol?: string
-    destinationTokenSymbol?: string
-    depositTokenAmountUsd?: string
-    originPreconditionAmount?: string
-    destinationPreconditionAmount?: string
-    fromAmount?: string
-    fromAmountMin?: string
-    toAmount?: string
-    toAmountMin?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    // Auto-identify if userAddress provided but no ident set
-    this.autoIdentifyIfNeeded(data.userAddress, "trackIntentQuoteReceived")
-    this.track({
-      event: EventType.INTENT_QUOTE_RECEIVED,
-      props: {
-        ...this.getCommonProps(),
-        quoteId: data.quoteId,
-        checkoutId: getCheckoutId(),
-        totalFeeUSD: data.totalFeeUSD?.toString(),
-        trailsFixedFeeUSD: data.trailsFixedFeeUSD?.toString(),
-        crossChainFeeTotalUSD: data.crossChainFeeTotalUSD?.toString(),
-        takerFeeUSD: data.takerFeeUSD?.toString(),
-        providerFeeUSD: data.providerFeeUSD?.toString(),
-        trailsSwapFeeUSD: data.trailsSwapFeeUSD?.toString(),
-        gasFeesPerChainUSD: data.gasFeesPerChainUSD
-          ?.map((fee) => fee?.toString())
-          .join(","),
-        originTokenTotalAmount: data.originTokenTotalAmount?.toString(),
-        totalFeeAmount: data.totalFeeAmount?.toString(),
-        provider: data.provider,
-        swapProvider: data.swapProvider,
-        bridgeProvider: data.bridgeProvider,
-        feeToken: data.feeToken,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-        feeTokenSymbol: data.feeTokenSymbol,
-        originTokenSymbol: data.originTokenSymbol,
-        destinationTokenSymbol: data.destinationTokenSymbol,
-        depositTokenAmountUsd: data.depositTokenAmountUsd?.toString(),
-        originPreconditionAmount: data.originPreconditionAmount?.toString(),
-        destinationPreconditionAmount:
-          data.destinationPreconditionAmount?.toString(),
-        fromAmount: data.fromAmount?.toString(),
-        fromAmountMin: data.fromAmountMin?.toString(),
-        toAmount: data.toAmount?.toString(),
-        toAmountMin: data.toAmountMin?.toString(),
-      },
-    })
-  }
-
-  trackIntentQuoteError(data: {
-    error: string
-    userAddress?: string
-    originChainId?: number
-    destinationChainId?: number
-    originTokenAddress?: string
-    destinationTokenAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    originTokenSymbol?: string
-    destinationTokenSymbol?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.INTENT_QUOTE_ERROR,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        originChainId: data.originChainId?.toString(),
-        destinationChainId: data.destinationChainId?.toString(),
-        originTokenSymbol: data.originTokenSymbol,
-        destinationTokenSymbol: data.destinationTokenSymbol,
-      },
-    })
-  }
-
-  trackIntentCommitStarted(data: {
-    intentAddress: string
-    userAddress?: string
-    originTokenSymbol?: string
-    destinationTokenSymbol?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.INTENT_COMMIT_STARTED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        originChainId: data.originChainId?.toString(),
-        destinationChainId: data.destinationChainId?.toString(),
-        intentAddress: data.intentAddress,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        originTokenSymbol: data.originTokenSymbol,
-        destinationTokenSymbol: data.destinationTokenSymbol,
-      },
-    })
-  }
-
-  trackIntentCommitCompleted(data: {
-    intentAddress: string
-    userAddress?: string
-    originTokenSymbol?: string
-    destinationTokenSymbol?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.INTENT_COMMIT_COMPLETED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        originChainId: data.originChainId?.toString(),
-        destinationChainId: data.destinationChainId?.toString(),
-        intentAddress: data.intentAddress,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        originTokenSymbol: data.originTokenSymbol,
-        destinationTokenSymbol: data.destinationTokenSymbol,
-      },
-    })
-  }
-
-  trackIntentCommitError(data: {
-    error: string
-    userAddress?: string
-    intentAddress?: string
-    originChainId?: number
-    destinationChainId?: number
-    mode?: string
-    fundMethod?: FundMethod
-    originTokenSymbol?: string
-    destinationTokenSymbol?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.INTENT_COMMIT_ERROR,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-        originChainId: data.originChainId?.toString(),
-        destinationChainId: data.destinationChainId?.toString(),
-        originTokenSymbol: data.originTokenSymbol,
-        destinationTokenSymbol: data.destinationTokenSymbol,
-      },
-    })
-  }
-
-  // Transaction tracking methods
-  trackTransactionStarted(data: {
-    transactionType: string
-    chainId: number
-    userAddress?: string
-    intentAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    depositTokenAmountUsd?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    // Auto-identify if userAddress provided but no ident set
-    this.autoIdentifyIfNeeded(data.userAddress, "trackTransactionStarted")
-
-    this.track({
-      event: EventType.TRANSACTION_STARTED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-        chainId: data.chainId?.toString(),
-        depositTokenAmountUsd: data.depositTokenAmountUsd?.toString(),
-      },
-    })
-  }
-
-  trackTransactionSigned(data: {
-    transactionHash: string
-    userAddress?: string
-    intentAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    depositTokenAmountUsd?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.TRANSACTION_SIGNED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-        depositTokenAmountUsd: data.depositTokenAmountUsd?.toString(),
-      },
-    })
-  }
-
-  trackTransactionSubmitted(data: {
-    transactionHash: string
-    chainId: number
-    userAddress?: string
-    intentAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    depositTokenAmountUsd?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.TRANSACTION_SUBMITTED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-        chainId: data.chainId?.toString(),
-        depositTokenAmountUsd: data.depositTokenAmountUsd?.toString(),
-      },
-    })
-  }
-
-  trackTransactionConfirmed(data: {
-    transactionHash: string
-    blockNumber?: number
-    userAddress?: string
-    intentAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    depositTokenAmountUsd?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.TRANSACTION_CONFIRMED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        chainId: data.chainId?.toString(),
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-        blockNumber: data.blockNumber?.toString(),
-        depositTokenAmountUsd: data.depositTokenAmountUsd?.toString(),
-      },
-    })
-  }
-
-  trackTransactionError(data: {
-    transactionHash: string
-    error: string
-    userAddress?: string
-    intentAddress?: string
-    mode?: string
-    fundMethod?: FundMethod
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.TRANSACTION_ERROR,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-        ...(data.intentAddress && {
-          intentAddress: data.intentAddress,
-        }),
-      },
-    })
-  }
-
-  // Relayer tracking methods
-  trackRelayerCallStarted(data: {
-    walletAddress?: string
-    contractAddress?: string
-    chainId?: number
-    mode?: string
-    fundMethod?: FundMethod
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.RELAYER_CALL_STARTED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.walletAddress && {
-          walletAddress: data.walletAddress,
-        }),
-        ...(data.contractAddress && {
-          contractAddress: data.contractAddress,
-        }),
-        chainId: data.chainId?.toString(),
-      },
-    })
-  }
-
-  trackRelayerCallCompleted(data: {
-    walletAddress?: string
-    contractAddress?: string
-    chainId?: number
-    mode?: string
-    fundMethod?: FundMethod
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.RELAYER_CALL_COMPLETED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.walletAddress && {
-          walletAddress: data.walletAddress,
-        }),
-        ...(data.contractAddress && {
-          contractAddress: data.contractAddress,
-        }),
-        chainId: data.chainId?.toString(),
-      },
-    })
-  }
-
-  trackRelayerCallError(data: {
-    error: string
-    walletAddress?: string
-    contractAddress?: string
-    chainId?: number
-    mode?: string
-    fundMethod?: FundMethod
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.RELAYER_CALL_ERROR,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.walletAddress && {
-          walletAddress: data.walletAddress,
-        }),
-        ...(data.contractAddress && {
-          contractAddress: data.contractAddress,
-        }),
-        chainId: data.chainId?.toString(),
-      },
-    })
-  }
-
-  // Onramp tracking methods
-  trackOnrampQuoteRequested(data: {
-    sourceAmount?: string
-    sourceCurrencyCode?: string
-    destinationCurrencyCode?: string
-    countryCode?: string
-    walletAddress?: string
-    sessionId?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.ONRAMP_QUOTE_REQUESTED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.walletAddress && {
-          walletAddress: hashUserAddress(data.walletAddress),
-        }),
-      },
-    })
-  }
-
-  trackOnrampQuoteReceived(data: {
-    sessionId?: string
-    provider?: string
-    sourceAmount?: string
-    sourceCurrencyCode?: string
-    destinationAmount?: string
-    destinationCurrencyCode?: string
-    exchangeRate?: string
-    networkFees?: string
-    transactionFee?: string
-    totalFees?: string
-    countryCode?: string
-    paymentMethod?: string
-    quoteId?: string
-    quotesCount?: number
-    responseTime?: number
-    walletAddress?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.ONRAMP_QUOTE_RECEIVED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        quotesCount: data.quotesCount?.toString(),
-        responseTime: data.responseTime?.toString(),
-        ...(data.walletAddress && {
-          walletAddress: hashUserAddress(data.walletAddress),
-        }),
-      },
-    })
-  }
-
-  trackOnrampQuoteError(data: {
-    error: string
-    errorCode?: string
-    sessionId?: string
-    sourceAmount?: string
-    sourceCurrencyCode?: string
-    destinationCurrencyCode?: string
-    countryCode?: string
-    responseTime?: number
-    walletAddress?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.ONRAMP_QUOTE_ERROR,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        responseTime: data.responseTime?.toString(),
-        ...(data.walletAddress && {
-          walletAddress: hashUserAddress(data.walletAddress),
-        }),
-      },
-    })
-  }
-
-  trackWidgetClick(data: {
-    component?: string
-    action?: string
-    label?: string
-    value?: string | number
-    userAddress?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    const userAddress = data.userAddress
-    this.autoIdentifyIfNeeded(userAddress, "trackWidgetClick")
-
-    this.track({
-      event: EventType.WIDGET_CLICK,
-      props: {
-        ...this.getCommonProps(),
-        ...data,
-        userAddress: userAddress ? pseudonymize(userAddress) : undefined,
-      },
-    })
-  }
-
-  trackOnrampWidgetSession(data: {
-    sessionId?: string
-    provider?: string
-    widgetUrl?: string
-    depositAddress?: string
-    userAddress?: string
-    countryCode?: string
-    sourceCurrencyCode?: string
-    sourceAmount?: string
-    destinationCurrencyCode?: string
-    paymentMethodType?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.ONRAMP_WIDGET_SESSION,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-      },
-    })
-  }
-
-  trackOnrampPaymentCompleted(data: {
-    userAddress?: string
-    intentId?: string
-    intentAddress?: string
-    fundMethod?: FundMethod
-    sessionId?: string
-    externalSessionId?: string
-    transactionId?: string
-    transactionHash?: string
-    status?: string
-    provider?: string
-    sourceAmount?: string | number
-    sourceCurrencyCode?: string
-    destinationAmount?: string | number
-    destinationCurrencyCode?: string
-    countryCode?: string
-    paymentMethodType?: string
-    paymentMethod?: string
-    [key: string]: AnalyticsPropValue
-  }) {
-    this.track({
-      event: EventType.ONRAMP_PAYMENT_COMPLETED,
-      props: {
-        ...this.getCommonProps(),
-        checkoutId: getCheckoutId(),
-        ...data,
-        sourceAmount: data.sourceAmount?.toString(),
-        destinationAmount: data.destinationAmount?.toString(),
-        ...(data.userAddress && {
-          userAddress: hashUserAddress(data.userAddress),
-        }),
-      },
-    })
-  }
-}
-
-class Analytics extends BaseAnalytics {
-  private databeat: Databeat<EventTypes>
-  private loggingEnabled: boolean = false
-
-  constructor(
-    server: string,
-    auth: { jwt: string },
-    config: object,
-    sequenceProjectAccessKey?: string,
-  ) {
-    super(sequenceProjectAccessKey)
-    this.databeat = new Databeat<EventTypes>(server, auth, {
-      userIdentTracking: true,
-      privacy: {
-        userIdHash: false, // Don't hash client-side, let server handle it
-        userAgentSalt: false,
-      },
-      ...config,
-    })
-
-    // Emit VIEW event on instance creation
-    setTimeout(() => {
-      this.databeat.trackView()
-    }, 100)
-  }
-
-  identifyUser({ address }: { address: string }) {
-    if (getCheckoutUserId() !== address?.toLowerCase()) {
-      resetCheckoutId()
-    }
-    const hashedAddress = hashUserAddress(address)
-    logger.console.log("[trails-sdk] DEBUG: identifyUser called", {
-      address,
-      hashedAddress,
-      timestamp: new Date().toISOString(),
-    })
-    this.databeat.identify(hashedAddress, {
-      userIdHash: false,
-      allowTracking: true,
-    })
-  }
-
-  unidentifyUser() {
-    resetCheckoutId()
-    this.databeat.reset()
-    this.databeat.identify()
-  }
-
-  protected getCurrentUserId(): string | undefined {
-    return this.databeat.getUserId()
-  }
-
-  track(event: EventProps) {
-    const databeatEvent: Event = {
-      ...event,
-      props: toDatabeatProps(event.props),
-    }
-
-    return this.databeat
-      .track(databeatEvent)
-      .catch(() => {})
-      .then(() => this.logEvent(event))
-  }
-
-  enable() {
-    return this.databeat.enable()
-  }
-
-  allowTracking(allowTracking: boolean) {
-    return this.databeat.allowTracking(allowTracking)
-  }
-
-  disable() {
-    return this.databeat.disable()
-  }
-
-  logEvent(event: EventProps) {
-    if (this.loggingEnabled) {
-      logger.console.log("[trails-sdk] Analytics track:", event)
-    }
-  }
-
-  getSessionId() {
-    return this.databeat.getSessionId()
-  }
-
-  getUserId() {
-    return this.databeat.getUserId()
-  }
-}
-
-class MockAnalytics extends BaseAnalytics {
-  private loggingEnabled: boolean = false
-
-  constructor({
-    loggingEnabled,
-    sequenceProjectAccessKey,
-  }: {
-    loggingEnabled: boolean
-    sequenceProjectAccessKey?: string
-  }) {
-    super(sequenceProjectAccessKey)
-    this.loggingEnabled = loggingEnabled
-  }
-
-  identifyUser(_data: { address: string }) {
-    return this
-  }
-
-  unidentifyUser() {
-    return this
-  }
-
-  enable() {
-    return this
-  }
-
-  allowTracking(_allowTracking: boolean) {
-    return this
-  }
-
-  track(event: EventProps) {
-    this.logEvent(event)
-    return this
-  }
-
-  disable() {
-    return this
-  }
-
-  logEvent(event: EventProps) {
-    if (this.loggingEnabled) {
-      logger.console.log("[trails-sdk] MockAnalytics track:", event)
-    }
-  }
-
-  getSessionId() {
-    return `0x${Math.random().toString(16).slice(2, 10)}`
-  }
-
-  getUserId() {
-    return `0x${Math.random().toString(16).slice(2, 10)}`
-  }
-}
-
-export function isLocalhost() {
-  if (typeof window !== "undefined") {
-    return (
-      window.location.hostname === "localhost" ||
-      window.location.hostname === "127.0.0.1"
-    )
-  }
-  return false
-}
-
-let singleton: Analytics | MockAnalytics | null = null
-// Holds the key when updateProjectAccessKey is called before the singleton exists.
-let pendingProjectAccessKey: string | undefined
-
-export const getAnalytics = (sequenceProjectAccessKey?: string) => {
-  const debugLocalMode = getQueryParam("analyticsDebugLocal") === "true"
-  const debugProdMode = getQueryParam("analyticsDebugProd") === "true"
-  const isCI = getEnvVar("CI") === "true"
-
-  const enableMockAnalytics =
-    (!DATABEAT_KEY || debugLocalMode || isCI) && !debugProdMode
-
-  // Use the pending key if no key is passed explicitly
-  const effectiveKey = sequenceProjectAccessKey ?? pendingProjectAccessKey
-
-  if (!singleton) {
-    if (enableMockAnalytics) {
-      singleton = new MockAnalytics({
-        loggingEnabled: !isCI,
-        sequenceProjectAccessKey: effectiveKey,
-      })
-    } else {
-      singleton = new Analytics(
-        DATABEAT_SERVER,
-        {
-          jwt: DATABEAT_KEY,
-        },
-        {},
-        effectiveKey,
-      )
-    }
-    pendingProjectAccessKey = undefined
-  } else if (effectiveKey) {
-    // Update the existing singleton if a new key is provided
-    singleton.updateProjectAccessKey(effectiveKey)
-  }
-
-  if (!isCI) {
-    logger.console.log(
-      "[trails-sdk] Analytics sessionId:",
-      singleton.getSessionId(),
-      "[trails-sdk] Analytics userId:",
-      singleton.getUserId(),
-    )
-  }
-
-  return singleton
-}
-
-export const updateProjectAccessKey = (sequenceProjectAccessKey: string) => {
-  if (singleton) {
-    singleton.updateProjectAccessKey(sequenceProjectAccessKey)
-  } else {
-    // Stash the key so getAnalytics() picks it up when the singleton is created
-    pendingProjectAccessKey = sequenceProjectAccessKey
-  }
-}
-
-export const enableAnalytics = () => {
-  const analytics = getAnalytics()
-  analytics.enable()
-  analytics.allowTracking(true)
-  analytics.trackPageview()
-}
-
-export const disableAnalytics = () => {
-  const analytics = getAnalytics()
-  analytics.disable()
-  analytics.allowTracking(false)
-}
-
-export const trackPageview = () => {
-  const analytics = getAnalytics()
-  analytics.trackPageview()
-}
-
-export const trackWidgetScreen = (data: {
-  screen: string
-  userAddress?: string
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackWidgetScreen(data)
-}
-
-export const trackPaymentStarted = (data: {
-  userAddress?: string
-  intentAddress?: string
-  originChainId?: number
-  destinationChainId?: number
-  originTokenAddress?: string
-  originTokenAmount?: string
-  originTokenDecimals?: number
-  destinationTokenAddress?: string
-  destinationTokenSymbol?: string
-  destinationTokenAmount?: string
-  destinationTokenDecimals?: number
-  mode?: string
-  fundMethod?: FundMethod
-  sourceTokenPriceUsd?: string
-  destinationTokenPriceUsd?: string
-  tradeType?: string
-  swapProvider?: string
-  bridgeProvider?: string
-  onramp?: OnrampTrackingData | null
-  walletId?: string
-  destinationCalldata?: string
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackPaymentStarted(data)
-}
-
-export const trackPaymentCompleted = (data: {
-  userAddress?: string
-  intentAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  swapProvider?: string
-  bridgeProvider?: string
-  onramp?: OnrampTrackingData | null
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackPaymentCompleted(data)
-}
-
-export const trackPaymentError = (data: {
-  error: string
-  userAddress?: string
-  intentAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackPaymentError(data)
-}
-
-// Wallet tracking exports
-export const trackWalletConnected = (data: {
-  walletType: string
-  address: string
-  chainId: number
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.identifyUser({ address: data.address })
-  analytics.trackWalletConnected(data)
-}
-
-export const trackWalletDisconnected = (data?: {
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.unidentifyUser()
-  analytics.trackWalletDisconnected(data)
-}
-
-// Intent tracking exports
-export const trackIntentQuoteRequested = (data: {
-  originChainId: number
-  destinationChainId: number
-  tokenAddress?: string
-  userAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackIntentQuoteRequested(data)
-}
-
-export const trackIntentQuoteReceived = (data: {
-  quoteId: string
-  totalFeeUSD?: string
-  trailsFixedFeeUSD?: number
-  crossChainFeeTotalUSD?: number
-  takerFeeUSD?: number
-  providerFeeUSD?: number
-  trailsSwapFeeUSD?: number
-  gasFeesPerChainUSD?: number[]
-  originTokenTotalAmount?: string
-  destinationTokenAmount?: string
-  provider?: string
-  swapProvider?: string
-  bridgeProvider?: string
-  feeToken?: string
-  userAddress?: string
-  intentAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  originPreconditionAmount?: string
-  destinationPreconditionAmount?: string
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackIntentQuoteReceived(data)
-}
-
-export const trackIntentQuoteError = (data: {
-  error: string
-  userAddress?: string
-  originChainId?: number
-  destinationChainId?: number
-  originTokenAddress?: string
-  destinationTokenAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackIntentQuoteError(data)
-}
-
-export const trackIntentCommitStarted = (data: {
-  intentAddress: string
-  userAddress?: string
-  originChainId?: number
-  destinationChainId?: number
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackIntentCommitStarted(data)
-}
-
-export const trackIntentCommitCompleted = (data: {
-  intentAddress: string
-  userAddress?: string
-  originChainId?: number
-  destinationChainId?: number
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackIntentCommitCompleted(data)
-}
-
-export const trackIntentCommitError = (data: {
-  error: string
-  userAddress?: string
-  intentAddress?: string
-  originChainId?: number
-  destinationChainId?: number
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackIntentCommitError(data)
-}
-
-// Transaction tracking exports
-export const trackTransactionStarted = (data: {
-  transactionType: string
-  chainId: number
-  userAddress?: string
-  intentAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackTransactionStarted(data)
-}
-
-export const trackTransactionSigned = (data: {
-  transactionHash: string
-  userAddress?: string
-  intentAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackTransactionSigned(data)
-}
-
-export const trackTransactionSubmitted = (data: {
-  transactionHash: string
-  chainId: number
-  userAddress?: string
-  intentAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackTransactionSubmitted(data)
-}
-
-export const trackTransactionConfirmed = (data: {
-  transactionHash: string
-  blockNumber?: number
-  userAddress?: string
-  intentAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackTransactionConfirmed(data)
-}
-
-export const trackTransactionError = (data: {
-  transactionHash: string
-  error: string
-  userAddress?: string
-  intentAddress?: string
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackTransactionError(data)
-}
-
-// Relayer tracking exports
-export const trackRelayerCallStarted = (data: {
-  walletAddress?: string
-  contractAddress?: string
-  chainId?: number
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackRelayerCallStarted(data)
-}
-
-export const trackRelayerCallCompleted = (data: {
-  walletAddress?: string
-  contractAddress?: string
-  chainId?: number
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackRelayerCallCompleted(data)
-}
-
-export const trackRelayerCallError = (data: {
-  error: string
-  walletAddress?: string
-  contractAddress?: string
-  chainId?: number
-  mode?: string
-  fundMethod?: FundMethod
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackRelayerCallError(data)
-}
-
-// Onramp tracking exports
-export const trackOnrampQuoteRequested = (data: {
-  sourceAmount?: string
-  sourceCurrencyCode?: string
-  destinationCurrencyCode?: string
-  countryCode?: string
-  walletAddress?: string
-  sessionId?: string
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackOnrampQuoteRequested(data)
-}
-
-export const trackOnrampQuoteReceived = (data: {
-  sessionId?: string
-  provider?: string
-  sourceAmount?: string
-  sourceCurrencyCode?: string
-  destinationAmount?: string
-  destinationCurrencyCode?: string
-  exchangeRate?: string
-  networkFees?: string
-  transactionFee?: string
-  totalFees?: string
-  countryCode?: string
-  paymentMethod?: string
-  quoteId?: string
-  quotesCount?: number
-  responseTime?: number
-  walletAddress?: string
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackOnrampQuoteReceived(data)
-}
-
-export const trackOnrampQuoteError = (data: {
-  error: string
-  errorCode?: string
-  sessionId?: string
-  sourceAmount?: string
-  sourceCurrencyCode?: string
-  destinationCurrencyCode?: string
-  countryCode?: string
-  responseTime?: number
-  walletAddress?: string
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackOnrampQuoteError(data)
-}
-
-export const trackWidgetClick = (data: {
-  component?: string
-  action?: string
-  label?: string
-  value?: string | number
-  userAddress?: string
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackWidgetClick(data)
-}
-
-export const trackOnrampWidgetSession = (data: {
-  sessionId?: string
-  provider?: string
-  widgetUrl?: string
-  depositAddress?: string
-  userAddress?: string
-  countryCode?: string
-  sourceCurrencyCode?: string
-  sourceAmount?: string
-  destinationCurrencyCode?: string
-  paymentMethodType?: string
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackOnrampWidgetSession(data)
-}
-
-export const trackOnrampPaymentCompleted = (data: {
-  userAddress?: string
-  intentId?: string
-  intentAddress?: string
-  fundMethod?: FundMethod
-  sessionId?: string
-  externalSessionId?: string
-  transactionId?: string
-  transactionHash?: string
-  status?: string
-  provider?: string
-  sourceAmount?: string | number
-  sourceCurrencyCode?: string
-  destinationAmount?: string | number
-  destinationCurrencyCode?: string
-  countryCode?: string
-  paymentMethodType?: string
-  paymentMethod?: string
-  [key: string]: AnalyticsPropValue
-}) => {
-  const analytics = getAnalytics()
-  analytics.trackOnrampPaymentCompleted(data)
-}
-
-export function getSessionId() {
-  const analytics = getAnalytics()
-  return analytics.getSessionId()
-}