0xtrails 0.13.2 → 0.14.0

package/src/widget/hooks/useOnRampCountryDefaults.ts

@@ -1,57 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import { useCountryCode } from "../../query/geo.hooks.js"
-import { useOnrampClient } from "../../onrampClient.js"
-import { meldQueries } from "../../query/meld.queries.js"
-
-export interface OnRampCountryDefaults {
-  countryCode: string
-  defaultCurrencyCode: string
-  defaultPaymentMethods: Array<string>
-  [key: string]: any
-}
-
-export interface UseOnRampCountryDefaultsOptions {
-  enabled?: boolean
-}
-
-export interface UseOnRampCountryDefaultsResult {
-  countryCode: string | null
-  defaultCurrencyCode: string | null
-  defaultPaymentMethods: Array<string>
-  isLoading: boolean
-  error: Error | null
-}
-
-export function useOnRampCountryDefaults(
-  options: UseOnRampCountryDefaultsOptions = {},
-): UseOnRampCountryDefaultsResult {
-  const { enabled = true } = options
-
-  const {
-    data: countryCode,
-    isLoading: isCountryLoading,
-    error: countryError,
-  } = useCountryCode({ enabled })
-
-  const onrampClient = useOnrampClient()
-
-  const {
-    data: countryDefaults,
-    isLoading: isDefaultsLoading,
-    error: defaultsError,
-  } = useQuery({
-    ...meldQueries.countryDefaultsByCode(onrampClient, countryCode ?? null),
-    enabled,
-  })
-
-  const isLoading = isCountryLoading || isDefaultsLoading
-  const error = countryError || defaultsError
-
-  return {
-    countryCode: countryCode || null,
-    defaultCurrencyCode: countryDefaults?.defaultCurrencyCode || null,
-    defaultPaymentMethods: countryDefaults?.defaultPaymentMethods || [],
-    isLoading,
-    error: error as Error | null,
-  }
-}

package/src/widget/hooks/useOnRampPaymentMethods.ts

@@ -1,72 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import type { MeldPaymentMethod } from "../../query/meld.fetchers.js"
-import { useOnRampCountryDefaults } from "./useOnRampCountryDefaults.js"
-import type { TrailsOnramp } from "../../onrampClient.js"
-import { useOnrampClient } from "../../onrampClient.js"
-import { meldQueries } from "../../query/meld.queries.js"
-
-export type PaymentMethod = MeldPaymentMethod
-
-export interface UseOnRampPaymentMethodsOptions {
-  trailsClient?: TrailsOnramp | null
-  fiatCurrency?: string
-  enabled?: boolean
-}
-
-export interface UseOnRampPaymentMethodsResult {
-  paymentMethods: PaymentMethod[]
-  isLoading: boolean
-  error: Error | null
-}
-
-const ALLOWED_PAYMENT_METHODS = [
-  "CREDIT_DEBIT_CARD",
-  "EXCHANGE",
-  "PAYPAL",
-  "GOOGLE_PAY",
-  "APPLE_PAY",
-  "SEPA",
-] as const
-
-const selectAllowedPaymentMethods = (methods: MeldPaymentMethod[]) =>
-  methods.filter((method) =>
-    ALLOWED_PAYMENT_METHODS.includes(
-      method.paymentMethod as (typeof ALLOWED_PAYMENT_METHODS)[number],
-    ),
-  )
-
-export function useOnRampPaymentMethods(
-  options: UseOnRampPaymentMethodsOptions,
-): UseOnRampPaymentMethodsResult {
-  const { trailsClient, fiatCurrency, enabled = true } = options
-
-  const defaultOnrampClient = useOnrampClient()
-
-  const { defaultCurrencyCode, isLoading: isLoadingCountryDefaults } =
-    useOnRampCountryDefaults({ enabled })
-
-  const currencyToUse = fiatCurrency || defaultCurrencyCode || null
-
-  const client = trailsClient !== undefined ? trailsClient : defaultOnrampClient
-
-  const factoryOptions = meldQueries.paymentMethodList(client, currencyToUse)
-
-  const isQueryEnabled =
-    enabled && !(fiatCurrency === undefined && isLoadingCountryDefaults)
-
-  const {
-    data: paymentMethods = [],
-    isLoading,
-    error,
-  } = useQuery({
-    ...factoryOptions,
-    enabled: isQueryEnabled,
-    select: selectAllowedPaymentMethods,
-  })
-
-  return {
-    paymentMethods,
-    isLoading,
-    error: error as Error | null,
-  }
-}

package/src/widget/hooks/useOnRampProviderWidget.ts

@@ -1,184 +0,0 @@
-import { useMutation } from "@tanstack/react-query"
-import { logger } from "../../logger.js"
-import type { TrailsOnramp } from "../../onrampClient.js"
-import { useOnrampClient } from "../../onrampClient.js"
-
-import { normalizeAddress } from "../../utils/address.js"
-export interface CreateOnrampWidgetSessionOptions {
-  trailsClient?: TrailsOnramp | null
-  depositAddress: string
-  userAddress: string
-  countryCode: string
-  sourceCurrencyCode: string
-  sourceAmount: string
-  destinationCurrencyCode: string
-  serviceProvider: string
-  redirectUrl?: string
-  paymentMethodType?: string
-  lockFields?: string[]
-}
-
-export interface CreateOnrampWidgetSessionResult {
-  id: string
-  externalSessionId: string
-  externalCustomerId: string
-  customerId: string
-  widgetUrl: string
-  token: string
-}
-
-export interface UseOnRampProviderWidgetResult {
-  createWidgetSession: (
-    options: CreateOnrampWidgetSessionOptions,
-  ) => Promise<CreateOnrampWidgetSessionResult>
-  /**
-   * Whether the request is currently loading
-   */
-  isLoading: boolean
-  /**
-   * Error object if the request failed, null otherwise
-   */
-  error: Error | null
-}
-
-/**
- * Hook to create an onramp provider widget session.
- *
- * Creates a widget session via CreateOnrampWidgetSession API and returns the widget URL.
- */
-export function useOnRampProviderWidget(): UseOnRampProviderWidgetResult {
-  const defaultOnrampClient = useOnrampClient()
-
-  const mutation = useMutation({
-    mutationFn: async (
-      options: CreateOnrampWidgetSessionOptions,
-    ): Promise<CreateOnrampWidgetSessionResult> => {
-      const {
-        trailsClient,
-        depositAddress,
-        userAddress,
-        countryCode,
-        sourceCurrencyCode,
-        sourceAmount,
-        destinationCurrencyCode,
-        serviceProvider,
-        redirectUrl,
-        paymentMethodType,
-        lockFields,
-      } = options
-
-      const timestamp = Date.now()
-      const randomString = Math.random().toString(36).substring(2, 8)
-      const externalCustomerId = normalizeAddress(userAddress)
-
-      const requestBody = {
-        sessionData: {
-          walletAddress: depositAddress,
-          countryCode,
-          sourceCurrencyCode,
-          sourceAmount,
-          destinationCurrencyCode,
-          serviceProvider,
-          paymentMethodType,
-          ...(redirectUrl && { redirectUrl }),
-          ...(lockFields && { lockFields }),
-        },
-        sessionType: "BUY" as const,
-        externalCustomerId: normalizeAddress(externalCustomerId),
-        externalSessionId: `meld-${timestamp}-${randomString}`,
-      }
-
-      logger.console.log(
-        "[useOnRampProviderWidget] Creating widget session",
-        requestBody,
-      )
-
-      const client = trailsClient || defaultOnrampClient
-      const data = await client.createMeldWidgetSession(requestBody)
-
-      logger.console.log("[useOnRampProviderWidget] Raw response", data)
-      logger.console.log(
-        "[useOnRampProviderWidget] Request externalSessionId:",
-        requestBody.externalSessionId,
-      )
-
-      // Parse the widgetSession response - handle different formats
-      let widgetSession: unknown
-
-      if (data.widgetSession && typeof data.widgetSession === "string") {
-        if (data.widgetSession === "undefined") {
-          throw new Error("No widget session response received from server")
-        }
-        try {
-          const parsed = JSON.parse(data.widgetSession)
-          widgetSession = parsed.WidgetSession || parsed.widgetSession || parsed
-        } catch (parseError) {
-          logger.console.error(
-            "[useOnRampProviderWidget] Failed to parse widget session JSON:",
-            parseError,
-            "Raw response:",
-            data.widgetSession,
-          )
-          throw new Error(
-            `Invalid widget session format: ${parseError instanceof Error ? parseError.message : "Unknown parsing error"}`,
-          )
-        }
-      } else if ((data as unknown as Record<string, unknown>).WidgetSession) {
-        // Response is already parsed and has WidgetSession at root
-        widgetSession = (data as unknown as Record<string, unknown>)
-          .WidgetSession
-      } else if (data.widgetSession && typeof data.widgetSession === "object") {
-        // Response has widgetSession as an object
-        widgetSession = data.widgetSession
-      } else {
-        throw new Error("No valid widget session found in server response")
-      }
-
-      const sessionData = widgetSession as Record<string, unknown>
-
-      if (
-        !sessionData ||
-        typeof sessionData.serviceProviderWidgetUrl !== "string"
-      ) {
-        throw new Error(
-          "Invalid response: widgetSession.serviceProviderWidgetUrl not found in response",
-        )
-      }
-
-      logger.console.log("[useOnRampProviderWidget] Widget session created", {
-        id: sessionData.id,
-        externalSessionId: sessionData.externalSessionId,
-        externalCustomerId: sessionData.externalCustomerId,
-        customerId: sessionData.customerId,
-        token: sessionData.token,
-        serviceProviderWidgetUrl: sessionData.serviceProviderWidgetUrl,
-      })
-      logger.console.log(
-        "[useOnRampProviderWidget] Response externalSessionId:",
-        sessionData.externalSessionId,
-      )
-
-      return {
-        id: sessionData.id as string,
-        externalSessionId: sessionData.externalSessionId as string,
-        externalCustomerId: sessionData.externalCustomerId as string,
-        customerId: sessionData.customerId as string,
-        token: sessionData.token as string,
-        widgetUrl: sessionData.serviceProviderWidgetUrl as string,
-      }
-    },
-    onError: (error) => {
-      logger.console.error(
-        "[useOnRampProviderWidget] Error creating widget session",
-        error,
-      )
-    },
-    retry: 1, // Only retry once for mutations
-  })
-
-  return {
-    createWidgetSession: mutation.mutateAsync,
-    isLoading: mutation.isPending,
-    error: mutation.error as Error | null,
-  }
-}

package/src/widget/hooks/useOnRampQuote.ts

@@ -1,340 +0,0 @@
-import { useMemo } from "react"
-import { useQuery } from "@tanstack/react-query"
-import { isValidStringAmount } from "../../utils/validation.js"
-import { logger } from "../../logger.js"
-import { SECOND_MS, MINUTE_MS } from "../../utils/time.js"
-import type { MeldQuote } from "../../meld/utils/meld.js"
-import type { TrailsOnramp } from "../../onrampClient.js"
-import { useOnrampClient } from "../../onrampClient.js"
-import type { OnrampTrackingData } from "../types/analytics.js"
-import {
-  trackOnrampQuoteRequested,
-  trackOnrampQuoteReceived,
-  trackOnrampQuoteError,
-} from "../../analytics.js"
-import { getFullErrorMessage } from "../../error.js"
-
-export type OnrampQuote = MeldQuote
-
-export interface UseOnRampQuoteOptions {
-  trailsClient?: TrailsOnramp | null
-  amount?: string
-  sourceCurrencyCode?: string
-  destinationCurrencyCode?: string
-  countryCode?: string
-  walletAddress?: string
-  paymentMethodType?: string
-  enabled?: boolean
-}
-
-export interface UseOnRampQuoteResult {
-  quotes: OnrampQuote[]
-  selectedQuote: OnrampQuote | null
-  isLoading: boolean
-  error: Error | null
-  /**
-   * Manually trigger fetching with the current params
-   */
-  refetch: () => Promise<void>
-  /**
-   * Tracking data for analytics
-   */
-  onrampTrackingData: OnrampTrackingData | null
-}
-
-/**
- * Hook to fetch onramp quotes for a given fiat amount and destination token.
- *
- * It:
- * - Validates that required inputs are present
- * - Calls GetMeldQuote
- * - Returns quotes in the order provided by the API
- */
-export function useOnRampQuote(
-  options: UseOnRampQuoteOptions,
-): UseOnRampQuoteResult {
-  const {
-    trailsClient,
-    amount,
-    sourceCurrencyCode,
-    destinationCurrencyCode,
-    countryCode,
-    walletAddress,
-    paymentMethodType,
-    enabled = true,
-  } = options
-
-  const defaultOnrampClient = useOnrampClient({
-    // hostname: "http://localhost:4424",
-  })
-
-  // Check if all required params are present
-  const hasRequiredParams = useMemo(() => {
-    // Validate amount is present and is a valid positive number
-    const isValidAmount = isValidStringAmount(amount ?? "")
-
-    return (
-      isValidAmount &&
-      Boolean(sourceCurrencyCode) &&
-      Boolean(destinationCurrencyCode) &&
-      Boolean(countryCode) &&
-      Boolean(walletAddress)
-    )
-  }, [
-    amount,
-    sourceCurrencyCode,
-    destinationCurrencyCode,
-    countryCode,
-    walletAddress,
-  ])
-
-  // We don't have a session ID from the API for quotes
-  // We'll remove sessionId from tracking since it's not available
-
-  // Determine if query should be enabled
-  const isQueryEnabled = () => {
-    if (!enabled) return false
-    if (trailsClient !== undefined && !trailsClient) return false
-    return hasRequiredParams
-  }
-
-  // Use React Query for automatic caching and refetching
-  const {
-    data: quotes = [],
-    isLoading,
-    error,
-    refetch,
-  } = useQuery({
-    queryKey: [
-      "meldQuote",
-      amount,
-      sourceCurrencyCode,
-      destinationCurrencyCode,
-      countryCode,
-      walletAddress,
-      "onrampClient",
-    ],
-    queryFn: async () => {
-      if (!hasRequiredParams) {
-        throw new Error("All required parameters must be provided")
-      }
-
-      const requestStartTime = Date.now()
-
-      // Track quote request
-      trackOnrampQuoteRequested({
-        sourceAmount: amount,
-        sourceCurrencyCode,
-        destinationCurrencyCode,
-        countryCode,
-        walletAddress,
-      })
-
-      logger.console.log("[useOnRampQuote] Fetching onramp quotes", {
-        amount,
-        sourceCurrencyCode,
-        destinationCurrencyCode,
-        countryCode,
-        walletAddress,
-      })
-
-      const client = trailsClient || defaultOnrampClient
-
-      let data: any
-      try {
-        data = await client.getMeldQuote({
-          sourceAmount: amount!,
-          sourceCurrencyCode: sourceCurrencyCode!,
-          destinationCurrencyCode: destinationCurrencyCode!,
-          countryCode: countryCode!,
-          walletAddress: walletAddress!,
-          paymentMethodType: paymentMethodType!,
-        })
-      } catch (apiError) {
-        const responseTime = Date.now() - requestStartTime
-        const errorMessage = getFullErrorMessage(apiError)
-
-        // Track quote error
-        trackOnrampQuoteError({
-          error: errorMessage,
-          sourceAmount: amount,
-          sourceCurrencyCode,
-          destinationCurrencyCode,
-          countryCode,
-          walletAddress,
-          responseTime,
-        })
-
-        throw apiError
-      }
-
-      logger.console.log("[useOnRampQuote] GetMeldQuote response", data)
-      logger.console.log("[useOnRampQuote] Response structure analysis:", {
-        hasQuoteResponse: !!data.quoteResponse,
-        quoteResponseType: typeof data.quoteResponse,
-        hasQuoteResponseCap: !!(data as unknown as Record<string, unknown>)
-          .QuoteResponse,
-        quoteResponseCapType: typeof (
-          data as unknown as Record<string, unknown>
-        ).QuoteResponse,
-        dataKeys: Object.keys(data),
-      })
-
-      // The response can be structured in different ways:
-      // 1. data.quoteResponse is a string that needs parsing
-      // 2. data is already parsed and has QuoteResponse at the root
-      let quoteResponse: unknown
-
-      if (data.quoteResponse && typeof data.quoteResponse === "string") {
-        if (data.quoteResponse === "undefined") {
-          throw new Error("No quote response received from server")
-        }
-        try {
-          const parsed = JSON.parse(data.quoteResponse)
-          quoteResponse = parsed.QuoteResponse || parsed
-        } catch (parseError) {
-          logger.console.error(
-            "[useOnRampQuote] Failed to parse quote response JSON:",
-            parseError,
-            "Raw response:",
-            data.quoteResponse,
-          )
-          throw new Error(
-            `Invalid quote response format: ${parseError instanceof Error ? parseError.message : "Unknown parsing error"}`,
-          )
-        }
-      } else if ((data as unknown as Record<string, unknown>).QuoteResponse) {
-        // Response is already parsed and has QuoteResponse at root
-        quoteResponse = (data as unknown as Record<string, unknown>)
-          .QuoteResponse
-      } else if (data.quoteResponse && typeof data.quoteResponse === "object") {
-        // Response has quoteResponse as an object
-        quoteResponse = data.quoteResponse
-      } else {
-        throw new Error("No valid quote response found in server response")
-      }
-
-      logger.console.log("[useOnRampQuote] Final quoteResponse:", quoteResponse)
-
-      let quotesArray: OnrampQuote[] = []
-
-      if (
-        quoteResponse &&
-        typeof quoteResponse === "object" &&
-        quoteResponse !== null &&
-        "quotes" in quoteResponse &&
-        Array.isArray((quoteResponse as Record<string, unknown>).quotes)
-      ) {
-        quotesArray = (quoteResponse as Record<string, unknown>)
-          .quotes as OnrampQuote[]
-        logger.console.log(
-          "[useOnRampQuote] Found quotes array with length:",
-          quotesArray.length,
-        )
-      } else {
-        logger.console.log(
-          "[useOnRampQuote] No quotes array found. quoteResponse structure:",
-          quoteResponse,
-        )
-      }
-
-      logger.console.log("[useOnRampQuote] Quotes received", {
-        count: quotesArray.length,
-        selectedQuote: quotesArray[0]
-          ? {
-              destinationAmount: quotesArray[0].destinationAmount,
-              serviceProvider: quotesArray[0].serviceProvider,
-              exchangeRate: quotesArray[0].exchangeRate,
-            }
-          : null,
-      })
-
-      const responseTime = Date.now() - requestStartTime
-
-      // Track ALL quotes received, not just the first one
-      if (quotesArray.length > 0) {
-        // Track each quote individually
-        quotesArray.forEach((quote, index) => {
-          if (quote) {
-            trackOnrampQuoteReceived({
-              provider: quote.serviceProvider || "Meld",
-              sourceAmount: amount,
-              sourceCurrencyCode,
-              destinationAmount: String(quote.destinationAmount || ""),
-              destinationCurrencyCode,
-              exchangeRate: String(quote.exchangeRate || ""),
-              networkFees: String(quote.networkFee || ""),
-              transactionFee: String(quote.transactionFee || ""),
-              totalFees: String(quote.totalFee || ""),
-              countryCode,
-              paymentMethod: quote.paymentMethodType || "",
-              quotesCount: quotesArray.length,
-              responseTime,
-              walletAddress,
-              // Add additional quote fields
-              institutionName: quote.institutionName || undefined,
-              customerScore: String(quote.customerScore || ""),
-              quoteIndex: String(index),
-              isSelectedQuote: String(index === 0), // First quote is the selected one
-            })
-          }
-        })
-      }
-
-      // TODO: Kryptonim is temporarily disabled
-      quotesArray = quotesArray.filter(
-        (quote) => quote.serviceProvider?.toLowerCase() !== "kryptonim",
-      )
-
-      return quotesArray
-    },
-    enabled: isQueryEnabled(),
-    staleTime: 30 * SECOND_MS, // 30 seconds - quotes are price-sensitive and change frequently
-    gcTime: 2 * MINUTE_MS, // 2 minutes cache time
-    retry: false, // Don't retry - if it fails once, return error immediately
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: true,
-  })
-
-  // Derive selectedQuote from the first quote
-  const selectedQuote = quotes[0] ?? null
-
-  // Create onramp tracking data
-  const onrampTrackingData: OnrampTrackingData | null = useMemo(() => {
-    if (!selectedQuote || !amount || !walletAddress) return null
-
-    return {
-      provider: selectedQuote.serviceProvider || "Meld",
-      sourceAmount: amount,
-      sourceCurrencyCode: sourceCurrencyCode || "",
-      destinationAmount: String(selectedQuote.destinationAmount || ""),
-      destinationCurrencyCode: destinationCurrencyCode || "",
-      exchangeRate: String(selectedQuote.exchangeRate || ""),
-      networkFees: String(selectedQuote.networkFee || ""),
-      transactionFee: String(selectedQuote.transactionFee || ""),
-      totalFees: String(selectedQuote.totalFee || ""),
-      countryCode: countryCode || "",
-      paymentMethod: selectedQuote.paymentMethodType || "",
-      walletAddress: walletAddress,
-      timestamp: new Date().toISOString(),
-    }
-  }, [
-    selectedQuote,
-    amount,
-    sourceCurrencyCode,
-    destinationCurrencyCode,
-    countryCode,
-    walletAddress,
-  ])
-
-  return {
-    quotes,
-    selectedQuote,
-    isLoading,
-    error: error as Error | null,
-    refetch: async () => {
-      await refetch()
-    },
-    onrampTrackingData,
-  }
-}