0xtrails 0.13.2 → 0.15.0

package/src/query/chains.queries.ts

@@ -1,17 +0,0 @@
-import { queryOptions } from "@tanstack/react-query"
-import { HOUR_MS, DAY_MS } from "../utils/time.js"
-import { getSupportedChains, type Chain } from "../chains.js"
-import { STATIC_QUERY_OPTIONS } from "./helpers.js"
-
-export const chainQueries = {
-  all: ["chains"] as const,
-
-  supported: (config?: { trailsApiUrl?: string; trailsApiKey?: string }) =>
-    queryOptions<Chain[]>({
-      queryKey: [...chainQueries.all, "supported"] as const,
-      queryFn: () => getSupportedChains(config),
-      staleTime: HOUR_MS,
-      gcTime: DAY_MS,
-      ...STATIC_QUERY_OPTIONS,
-    }),
-}

package/src/query/client.ts

@@ -1,20 +0,0 @@
-import { QueryClient } from "@tanstack/react-query"
-import { MINUTE_MS, retryDelay, SECOND_MS } from "../utils/time.js"
-
-/** Shared default options reused by all QueryClient instances in the SDK. */
-export const defaultQueryOptions = {
-  queries: {
-    staleTime: 5 * SECOND_MS,
-    gcTime: 5 * MINUTE_MS,
-    retry: 2,
-    retryDelay,
-    refetchOnWindowFocus: false,
-    refetchIntervalInBackground: false,
-    refetchOnReconnect: true,
-  },
-} as const
-
-/** Singleton QueryClient for the SDK — shared cache for all queries and invalidations. */
-export const queryClient = new QueryClient({
-  defaultOptions: defaultQueryOptions,
-})

package/src/query/fiat.fetchers.ts

@@ -1,33 +0,0 @@
-/**
- * Pure async fetcher functions and helpers for fiat/currency queries.
- * This is a leaf module — NO React imports, NO queryClient.
- */
-import type { ExchangeRate, FiatCurrency } from "@0xtrails/api"
-import type { TrailsClient } from "../trailsClient.js"
-
-// ============================================================================
-// Fetchers
-// ============================================================================
-
-/**
- * Fetch the list of supported fiat currencies from the API.
- */
-export async function getFiatCurrencyList(
-  trailsClient: TrailsClient,
-): Promise<FiatCurrency[]> {
-  const response = await trailsClient.getFiatCurrencyList()
-  return response.currencies || []
-}
-
-/**
- * Fetch the exchange rate from USD to a target currency.
- */
-export async function getExchangeRate(
-  trailsClient: TrailsClient,
-  targetCurrency: string,
-): Promise<ExchangeRate> {
-  const response = await trailsClient.getExchangeRate({
-    toCurrency: targetCurrency,
-  })
-  return response.exchangeRate
-}

package/src/query/fiat.hooks.ts

@@ -1,71 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import { useTrailsClient } from "../trailsClient.js"
-import { fiatQueries } from "./fiat.queries.js"
-
-// ============================================================================
-// Fiat Currency List
-// ============================================================================
-
-export function useFiatCurrencyList() {
-  const trailsClient = useTrailsClient()
-  return useQuery(fiatQueries.currencyList(trailsClient))
-}
-
-// ============================================================================
-// Exchange Rate
-// ============================================================================
-
-interface UseExchangeRateOptions {
-  fromCurrency?: string
-  toCurrency?: string
-  disabled?: boolean
-}
-
-interface UseExchangeRateResult {
-  exchangeRate: number | undefined
-  isLoading: boolean
-  error: Error | null
-}
-
-/**
- * Fetch the exchange rate between two currencies.
- * Handles same-currency (returns 1) and direction inversion (X→USD = 1/rate).
- */
-export function useExchangeRate(
-  options: UseExchangeRateOptions = {},
-): UseExchangeRateResult {
-  const { fromCurrency = "USD", toCurrency = "USD", disabled = false } = options
-  const trailsClient = useTrailsClient()
-
-  const isSameCurrency = fromCurrency === toCurrency
-  const targetCurrency = fromCurrency === "USD" ? toCurrency : fromCurrency
-
-  // Pass null when disabled or same-currency → factory uses skipToken
-  const { data, isLoading, error } = useQuery(
-    fiatQueries.exchangeRate(
-      trailsClient,
-      disabled || isSameCurrency ? null : targetCurrency,
-    ),
-  )
-
-  // Calculate the exchange rate based on the conversion direction
-  let exchangeRate: number | undefined
-
-  if (isSameCurrency) {
-    exchangeRate = 1
-  } else if (data?.value) {
-    if (fromCurrency === "USD" && toCurrency !== "USD") {
-      // USD to another currency — use the rate directly
-      exchangeRate = data.value
-    } else if (fromCurrency !== "USD" && toCurrency === "USD") {
-      // Currency to USD — invert the rate
-      exchangeRate = 1 / data.value
-    }
-  }
-
-  return {
-    exchangeRate,
-    isLoading: isSameCurrency ? false : isLoading,
-    error: isSameCurrency ? null : (error as Error | null),
-  }
-}

package/src/query/fiat.queries.ts

@@ -1,67 +0,0 @@
-import { queryOptions, skipToken } from "@tanstack/react-query"
-import type { ExchangeRate, FiatCurrency } from "@0xtrails/api"
-import type { TrailsClient } from "../trailsClient.js"
-import { DAY_MS, MINUTE_MS, HOUR_MS } from "../utils/time.js"
-import { createRetry, retryDelay } from "./helpers.js"
-import { queryPersister } from "./persister.js"
-import { getFiatCurrencyList, getExchangeRate } from "./fiat.fetchers.js"
-
-// ============================================================================
-// Fiat Query Factory
-//
-// Single factory following the TanStack Query v5 canonical pattern.
-// Key-only entries (all, currencies, exchangeRates) enable hierarchical
-// invalidation. Leaf entries return full queryOptions objects.
-//
-// Usage:
-//   useQuery(fiatQueries.currencyList(trailsClient))
-//   queryClient.invalidateQueries({ queryKey: fiatQueries.all })
-//   fiatQueries.exchangeRate(trailsClient, "EUR").queryKey
-// ============================================================================
-
-export const fiatQueries = {
-  // -- invalidation root (key-only) --
-  all: ["fiat"] as const,
-
-  // -- currency list --
-  currencies: () => [...fiatQueries.all, "currencies"] as const,
-
-  currencyList: (trailsClient: TrailsClient | null | undefined) => {
-    const canFetch = !!trailsClient
-    return queryOptions<FiatCurrency[]>({
-      queryKey: [...fiatQueries.currencies()] as const,
-      queryFn: canFetch ? () => getFiatCurrencyList(trailsClient) : skipToken,
-      staleTime: DAY_MS,
-      gcTime: DAY_MS,
-      retry: createRetry(3),
-      retryDelay,
-      persister: queryPersister.persisterFn,
-      refetchOnMount: false,
-      refetchOnReconnect: false,
-    })
-  },
-
-  // -- exchange rates --
-  exchangeRates: () => [...fiatQueries.all, "exchangeRate"] as const,
-
-  exchangeRate: (
-    trailsClient: TrailsClient | null | undefined,
-    targetCurrency: string | null | undefined,
-  ) => {
-    const canFetch = !!trailsClient && !!targetCurrency
-    return queryOptions<ExchangeRate>({
-      queryKey: [
-        ...fiatQueries.exchangeRates(),
-        targetCurrency ?? null,
-      ] as const,
-      queryFn: canFetch
-        ? () => getExchangeRate(trailsClient, targetCurrency)
-        : skipToken,
-      staleTime: 5 * MINUTE_MS,
-      gcTime: HOUR_MS,
-      retry: createRetry(2),
-      retryDelay,
-      persister: queryPersister.persisterFn,
-    })
-  },
-}

package/src/query/geo.fetchers.ts

@@ -1,100 +0,0 @@
-import type { Country } from "@0xtrails/api"
-import type { TrailsClient } from "../trailsClient.js"
-import { logger } from "../logger.js"
-
-const detectUserCountryFromBrowser = (): string | null => {
-  try {
-    const locale = navigator.language || navigator.languages?.[0]
-    if (locale) {
-      const parts = locale.split("-")
-      if (parts.length === 2 && parts[1] && parts[1].length === 2) {
-        logger.console.log(
-          "[geolocation] Detected user country from locale:",
-          parts[1],
-        )
-        return parts[1]
-      }
-    }
-
-    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
-    const timezoneToCountry: Record<string, string> = {
-      "America/New_York": "US",
-      "America/Chicago": "US",
-      "America/Denver": "US",
-      "America/Los_Angeles": "US",
-      "America/Toronto": "CA",
-      "America/Vancouver": "CA",
-      "Europe/London": "GB",
-      "Europe/Paris": "FR",
-      "Europe/Berlin": "DE",
-      "Europe/Rome": "IT",
-      "Europe/Madrid": "ES",
-      "Europe/Amsterdam": "NL",
-      "Europe/Brussels": "BE",
-      "Europe/Vienna": "AT",
-      "Europe/Zurich": "CH",
-      "Europe/Stockholm": "SE",
-      "Europe/Oslo": "NO",
-      "Europe/Copenhagen": "DK",
-      "Europe/Helsinki": "FI",
-      "Europe/Dublin": "IE",
-      "Europe/Luxembourg": "LU",
-      "Asia/Tokyo": "JP",
-      "Asia/Seoul": "KR",
-      "Asia/Singapore": "SG",
-      "Asia/Hong_Kong": "HK",
-      "Australia/Sydney": "AU",
-      "Australia/Melbourne": "AU",
-      "Pacific/Auckland": "NZ",
-    }
-
-    if (timezone && timezoneToCountry[timezone]) {
-      logger.console.log(
-        "[geolocation] Detected user country from timezone:",
-        timezoneToCountry[timezone],
-      )
-      return timezoneToCountry[timezone]
-    }
-
-    logger.console.log(
-      "[geolocation] Could not detect user country from browser",
-    )
-    return null
-  } catch (error) {
-    logger.console.error(
-      "[geolocation] Error detecting user country from browser:",
-      error,
-    )
-    return null
-  }
-}
-
-export const fetchCountryCode = async (): Promise<string> => {
-  try {
-    const response = await fetch("https://ipapi.co/json/")
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`)
-    }
-
-    const data = await response.json()
-    if (data.country_code) {
-      return data.country_code
-    }
-  } catch (error) {
-    logger.console.error(
-      "[geolocation] IP-based country detection failed",
-      error,
-    )
-  }
-
-  logger.console.log("[geolocation] Falling back to browser-based detection")
-  const browserCountry = detectUserCountryFromBrowser()
-  return browserCountry || "US"
-}
-
-export async function fetchCountryList(
-  trailsClient: TrailsClient,
-): Promise<Country[]> {
-  const response = await trailsClient.getCountryList()
-  return response.countries
-}

package/src/query/geo.hooks.ts

@@ -1,16 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import { useTrailsClient } from "../trailsClient.js"
-import { geoQueries } from "./geo.queries.js"
-
-export function useCountryCode(options: { enabled?: boolean } = {}) {
-  return useQuery({
-    ...geoQueries.countryCode(),
-    enabled: options.enabled,
-  })
-}
-
-export function useCountryList() {
-  const trailsClient = useTrailsClient()
-
-  return useQuery(geoQueries.countryList(trailsClient))
-}

package/src/query/geo.queries.ts

@@ -1,36 +0,0 @@
-import { queryOptions, skipToken } from "@tanstack/react-query"
-import type { Country } from "@0xtrails/api"
-import type { TrailsClient } from "../trailsClient.js"
-import { DAY_MS } from "../utils/time.js"
-import { retryDelay, STATIC_QUERY_OPTIONS } from "./helpers.js"
-import { fetchCountryCode, fetchCountryList } from "./geo.fetchers.js"
-import { queryPersister } from "./persister.js"
-
-export const geoQueries = {
-  all: ["geo"] as const,
-
-  countryCode: () =>
-    queryOptions<string>({
-      queryKey: [...geoQueries.all, "countryCode"] as const,
-      queryFn: () => fetchCountryCode(),
-      staleTime: DAY_MS,
-      gcTime: DAY_MS,
-      retry: 2,
-      ...STATIC_QUERY_OPTIONS,
-      persister: queryPersister.persisterFn,
-    }),
-
-  countryList: (trailsClient: TrailsClient | null | undefined) => {
-    const canFetch = !!trailsClient
-    return queryOptions<Country[]>({
-      queryKey: [...geoQueries.all, "countryList"] as const,
-      queryFn: canFetch ? () => fetchCountryList(trailsClient) : skipToken,
-      staleTime: DAY_MS,
-      gcTime: DAY_MS,
-      ...STATIC_QUERY_OPTIONS,
-      retry: 3,
-      retryDelay,
-      persister: queryPersister.persisterFn,
-    })
-  },
-}

package/src/query/helpers.ts

@@ -1,81 +0,0 @@
-import { retryDelay } from "../utils/time.js"
-
-export { retryDelay }
-
-export function isHttpNotFound(error: unknown): boolean {
-  return (
-    error != null &&
-    typeof error === "object" &&
-    "status" in error &&
-    (error as { status: number }).status === 404
-  )
-}
-
-/**
- * Known fetch network error messages by runtime.
- * Vendored from sindresorhus/is-network-error (MIT), the de-facto standard
- * used by p-retry, n8n, LangChain, Vercel Storage, and MetaMask.
- * @see https://github.com/sindresorhus/is-network-error
- */
-const NETWORK_ERROR_MESSAGES = new Set([
-  "network error", // Chrome
-  "Failed to fetch", // Chrome
-  "NetworkError when attempting to fetch resource.", // Firefox
-  "The Internet connection appears to be offline.", // Safari 16
-  "Network request failed", // cross-fetch
-  "fetch failed", // Undici (Node.js)
-  "terminated", // Undici (Node.js)
-  " A network error occurred.", // Bun (WebKit)
-  "Network connection lost", // Cloudflare Workers
-])
-
-/**
- * Checks whether an error represents a network-level failure (DNS, CORS,
- * offline, connection refused). Per the Fetch spec, these surface as TypeError.
- *
- * CORS errors are covered — browsers throw TypeError with "Failed to fetch"
- * (Chrome) or "NetworkError when attempting to fetch resource." (Firefox).
- */
-export function isNetworkError(error: unknown): boolean {
-  if (
-    !(
-      error instanceof Error &&
-      error.name === "TypeError" &&
-      typeof error.message === "string"
-    )
-  ) {
-    // node-fetch throws FetchError, not TypeError (MetaMask addition)
-    if (
-      error instanceof Error &&
-      error.name === "FetchError" &&
-      /request to .+ failed/i.test(error.message)
-    ) {
-      return true
-    }
-    return false
-  }
-
-  const { message } = error
-
-  // Safari 17+: generic message, identified by missing stack trace
-  if (message === "Load failed") {
-    return error.stack === undefined
-  }
-
-  // Deno
-  if (message.startsWith("error sending request for url")) {
-    return true
-  }
-
-  return NETWORK_ERROR_MESSAGES.has(message)
-}
-
-export const createRetry =
-  (maxRetries: number) => (failureCount: number, error: Error) =>
-    !isHttpNotFound(error) && failureCount < maxRetries
-
-export const STATIC_QUERY_OPTIONS = {
-  refetchOnMount: false,
-  refetchOnWindowFocus: false,
-  refetchOnReconnect: false,
-} as const

package/src/query/meld.fetchers.ts

@@ -1,97 +0,0 @@
-/**
- * Pure async fetcher functions for Meld/onramp queries.
- * This is a leaf module — NO React imports, NO queryClient.
- */
-import type { TrailsOnramp } from "../onrampClient.js"
-import type {
-  MeldServiceProvider,
-  GetMeldServiceProvidersRequest,
-  MeldPaymentMethod,
-  MeldFiatCurrency,
-  MeldCryptoCurrency,
-  MeldCountryDefault,
-  MeldTransaction,
-} from "@0xtrails/api/onramp"
-import { normalizeAddress } from "../utils/address.js"
-
-export interface MeldCountryDefaults {
-  defaultCurrencyCode: string | undefined
-  defaultPaymentMethods: string[]
-}
-
-export type {
-  MeldServiceProvider,
-  MeldPaymentMethod,
-  MeldFiatCurrency,
-  MeldCryptoCurrency,
-  MeldCountryDefault,
-}
-
-export type { MeldTransaction }
-
-export async function fetchMeldPaymentMethods(
-  onrampClient: TrailsOnramp,
-  fiatCurrency: string,
-): Promise<MeldPaymentMethod[]> {
-  const response = await onrampClient.getMeldPaymentMethods({ fiatCurrency })
-  return Array.isArray(response.paymentMethods) ? response.paymentMethods : []
-}
-
-export async function fetchMeldCryptoCurrencies(
-  onrampClient: TrailsOnramp,
-  countryCode: string,
-): Promise<MeldCryptoCurrency[]> {
-  const response = await onrampClient.getMeldCryptoCurrencies({ countryCode })
-  return Array.isArray(response.cryptoCurrencies)
-    ? response.cryptoCurrencies
-    : []
-}
-
-export async function fetchMeldServiceProviders(
-  onrampClient: TrailsOnramp,
-  options: Partial<GetMeldServiceProvidersRequest> = {},
-): Promise<MeldServiceProvider[]> {
-  const response = await onrampClient.getMeldServiceProviders(options)
-  return response.serviceProviders || []
-}
-
-export async function fetchMeldFiatCurrencies(
-  onrampClient: TrailsOnramp,
-  countryCode: string,
-): Promise<MeldFiatCurrency[]> {
-  const response = await onrampClient.getMeldFiatCurrencies({ countryCode })
-  return Array.isArray(response.fiatCurrencies) ? response.fiatCurrencies : []
-}
-
-export async function fetchMeldCountryDefaults(
-  onrampClient: TrailsOnramp,
-  countryCode: string,
-): Promise<MeldCountryDefaults> {
-  const response = await onrampClient.getMeldCountryDefaults({ countryCode })
-  const defaults = response.defaults?.[0]
-  return {
-    defaultCurrencyCode: defaults?.defaultCurrencyCode ?? undefined,
-    defaultPaymentMethods: defaults?.defaultPaymentMethods || [],
-  }
-}
-
-export interface MeldTransactionHistoryResult {
-  transactions: MeldTransaction[]
-  hasMore: boolean
-}
-
-export async function fetchMeldTransactionHistory(
-  onrampClient: TrailsOnramp,
-  walletAddress: string,
-  limit: number,
-): Promise<MeldTransactionHistoryResult> {
-  const response = await onrampClient.searchMeldTransactions({
-    externalCustomerIds: normalizeAddress(walletAddress),
-    limit,
-  })
-  const transactions = response.transactions?.transactions || []
-  return {
-    transactions,
-    hasMore: transactions.length >= limit,
-  }
-}

package/src/query/meld.hooks.ts

@@ -1,18 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import { useOnrampClient } from "../onrampClient.js"
-import type { GetMeldServiceProvidersRequest } from "@0xtrails/api/onramp"
-import { meldQueries } from "./meld.queries.js"
-
-export function useMeldPaymentMethods(fiatCurrency?: string) {
-  const onrampClient = useOnrampClient()
-  return useQuery(
-    meldQueries.paymentMethodList(onrampClient, fiatCurrency ?? null),
-  )
-}
-
-export function useMeldServiceProviders(
-  options?: Partial<GetMeldServiceProvidersRequest>,
-) {
-  const onrampClient = useOnrampClient()
-  return useQuery(meldQueries.serviceProviderList(onrampClient, options))
-}