0xtrails 0.13.1 → 0.14.0

package/src/widget/hooks/useFiatSelectedCurrency.tsx

@@ -1,123 +0,0 @@
-import React, {
-  createContext,
-  useContext,
-  useState,
-  type ReactNode,
-} from "react"
-
-import type { OnrampFiatCurrency } from "./useFiatOnRampCurrencies.js"
-
-interface FiatSelectedCurrencyContextType {
-  selectedCurrency: OnrampFiatCurrency | null
-  setSelectedCurrency: (currency: OnrampFiatCurrency | null) => void
-  clearSelectedCurrency: () => void
-  hasManualSelection: boolean
-  setHasManualSelection: (value: boolean) => void
-  fiatAmount: string
-  setFiatAmount: (amount: string) => void
-}
-
-const FiatSelectedCurrencyContext = createContext<
-  FiatSelectedCurrencyContextType | undefined
->(undefined)
-
-interface FiatSelectedCurrencyProviderProps {
-  children: ReactNode
-  initialCurrency?: OnrampFiatCurrency | null
-}
-
-export const FiatSelectedCurrencyProvider: React.FC<
-  FiatSelectedCurrencyProviderProps
-> = ({ children, initialCurrency = null }) => {
-  const [selectedCurrency, setSelectedCurrencyState] =
-    useState<OnrampFiatCurrency | null>(() => {
-      if (typeof window !== "undefined") {
-        try {
-          const savedCurrency = localStorage.getItem(
-            "trails_fiat_selected_currency",
-          )
-          if (savedCurrency) {
-            return JSON.parse(savedCurrency)
-          }
-        } catch (error) {
-          console.warn("Failed to parse saved fiat currency:", error)
-        }
-      }
-      return initialCurrency
-    })
-
-  const [hasManualSelection, setHasManualSelection] = useState(() => {
-    if (typeof window !== "undefined") {
-      try {
-        return !!localStorage.getItem("trails_fiat_selected_currency")
-      } catch (error) {
-        console.error("Failed to read fiat currency from localStorage:", error)
-        return false
-      }
-    }
-    return false
-  })
-
-  const [fiatAmount, setFiatAmountState] = useState<string>("0")
-
-  const setSelectedCurrency = (currency: OnrampFiatCurrency | null) => {
-    setSelectedCurrencyState(currency)
-    setHasManualSelection(true)
-    if (typeof window !== "undefined") {
-      try {
-        if (currency) {
-          const currencyMetadata = {
-            currencyCode: currency.currencyCode,
-            name: currency.name,
-            symbolImageUrl: currency.symbolImageUrl,
-          }
-          localStorage.setItem(
-            "trails_fiat_selected_currency",
-            JSON.stringify(currencyMetadata),
-          )
-        } else {
-          localStorage.removeItem("trails_fiat_selected_currency")
-        }
-      } catch (error) {
-        console.error("Failed to save fiat currency to localStorage:", error)
-      }
-    }
-  }
-
-  const clearSelectedCurrency = () => {
-    setSelectedCurrency(null)
-    setHasManualSelection(false)
-  }
-
-  const setFiatAmount = (amount: string) => {
-    setFiatAmountState(amount)
-  }
-
-  const value: FiatSelectedCurrencyContextType = {
-    selectedCurrency,
-    setSelectedCurrency,
-    clearSelectedCurrency,
-    hasManualSelection,
-    setHasManualSelection,
-    fiatAmount,
-    setFiatAmount,
-  }
-
-  return (
-    <FiatSelectedCurrencyContext.Provider value={value}>
-      {children}
-    </FiatSelectedCurrencyContext.Provider>
-  )
-}
-
-export function useFiatSelectedCurrency(): FiatSelectedCurrencyContextType {
-  const context = useContext(FiatSelectedCurrencyContext)
-
-  if (context === undefined) {
-    throw new Error(
-      "useFiatSelectedCurrency must be used within a FiatSelectedCurrencyProvider",
-    )
-  }
-
-  return context
-}

package/src/widget/hooks/useGetIntent.ts

@@ -1,54 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import type { Intent } from "@0xtrails/api"
-import { useTrailsClient } from "../../trailsClient.js"
-import { getIntent } from "../../intents.js"
-import { useTrails } from "../providers/TrailsProvider.js"
-
-export interface UseGetIntentParams {
-  intentId: string | undefined
-  enabled?: boolean
-}
-
-export interface UseGetIntentReturn {
-  intent: Intent | null
-  isLoading: boolean
-  isError: boolean
-  error: Error | null
-  refetch: () => Promise<void>
-}
-
-/**
- * Hook to fetch intent data from the Trails API
- * @param params - Object containing intentId and optional enabled flag
- * @returns Intent data, loading state, error state, and refetch function
- */
-export function useGetIntent({
-  intentId,
-  enabled = true,
-}: UseGetIntentParams): UseGetIntentReturn {
-  const trailsConfig = useTrails()
-  const trailsClient = useTrailsClient()
-
-  const { data, isLoading, isError, error, refetch } = useQuery({
-    queryKey: ["getIntent", intentId],
-    queryFn: async () => {
-      if (!intentId || !trailsConfig.trailsApiKey) {
-        throw new Error("Intent ID and API key required")
-      }
-
-      const response = await getIntent(trailsClient, intentId)
-      return response.intent
-    },
-    enabled: enabled && !!intentId && !!trailsConfig.trailsApiKey,
-  })
-
-  return {
-    intent: data ?? null,
-    isLoading,
-    isError,
-    error: error as Error | null,
-    refetch: async () => {
-      await refetch()
-    },
-  }
-}

package/src/widget/hooks/useIntentReceiptBalances.ts

@@ -1,141 +0,0 @@
-import { useMemo } from "react"
-import { useQuery } from "@tanstack/react-query"
-import { logger } from "../../logger.js"
-import { formatRawAmount } from "../../utils/format.js"
-import { useTrailsClient } from "../../trailsClient.js"
-import { useTrails } from "../providers/TrailsProvider.js"
-import type {
-  RecoverableChainGroup,
-  RecoverableToken,
-} from "../components/ReceiptRecoverableFunds.js"
-
-interface UseIntentReceiptBalancesParams {
-  intentId?: string
-  ownerAddress?: string
-  enabled?: boolean
-}
-
-interface UseIntentReceiptBalancesResult {
-  chainGroups: RecoverableChainGroup[]
-  hasRecoverableFunds: boolean
-  isLoading: boolean
-  error: Error | null
-  refetch: () => Promise<void>
-}
-
-type HistoryBalanceGroup = {
-  intentAddress: string
-  chainId: number
-  tokens: Array<{
-    contractAddress: string
-    balance: string
-    decimals: number
-    chainId: number
-    symbol: string
-  }>
-}
-
-const RECEIPT_BALANCE_POLL_INTERVAL_MS = 30_000
-const MAX_RECEIPT_BALANCE_POLLS = 5
-
-function mapTokens(tokens: HistoryBalanceGroup["tokens"]): RecoverableToken[] {
-  return tokens
-    .filter((token) => {
-      try {
-        return BigInt(token.balance || "0") > 0n
-      } catch {
-        return false
-      }
-    })
-    .map((token) => ({
-      chainId: token.chainId,
-      contractAddress: token.contractAddress,
-      symbol: token.symbol,
-      decimals: token.decimals,
-      rawBalance: token.balance,
-      formattedBalance: formatRawAmount(token.balance, token.decimals),
-    }))
-}
-
-export function useIntentReceiptBalances({
-  intentId,
-  ownerAddress,
-  enabled = true,
-}: UseIntentReceiptBalancesParams): UseIntentReceiptBalancesResult {
-  const trailsConfig = useTrails()
-  const trailsClient = useTrailsClient()
-
-  const { data, isLoading, error, refetch } = useQuery({
-    queryKey: ["receiptIntentBalances", intentId, ownerAddress],
-    enabled:
-      enabled &&
-      !!intentId &&
-      !!ownerAddress &&
-      !!trailsConfig.trailsApiKey &&
-      !!trailsConfig.trailsApiUrl,
-    queryFn: async () => {
-      const response = await trailsClient.getIntentHistory({
-        byOwnerAddress: ownerAddress,
-        includeBalances: true,
-        page: { pageSize: 5 },
-      })
-
-      const normalizedIntentId = intentId?.toLowerCase()
-      const matchedIntent = (response.intents || []).find(
-        (item) => item.intentId?.toLowerCase() === normalizedIntentId,
-      )
-
-      if (!matchedIntent) {
-        return {
-          hasBalance: false,
-          balances: [] as HistoryBalanceGroup[],
-        }
-      }
-
-      logger.console.log("[trails-sdk] receipt balance intent match", {
-        intentId,
-        hasBalance: matchedIntent.hasBalance,
-        balanceGroupCount: (matchedIntent.balances || []).length,
-      })
-
-      return {
-        hasBalance: !!matchedIntent.hasBalance,
-        balances: (matchedIntent.balances || []) as HistoryBalanceGroup[],
-      }
-    },
-    staleTime: 0,
-    gcTime: 10 * 60 * 1000,
-    refetchInterval: (query) => {
-      return query.state.dataUpdateCount >= MAX_RECEIPT_BALANCE_POLLS
-        ? false
-        : RECEIPT_BALANCE_POLL_INTERVAL_MS
-    },
-    refetchIntervalInBackground: false,
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
-    refetchOnMount: false,
-  })
-
-  const chainGroups = useMemo<RecoverableChainGroup[]>(() => {
-    const balances = data?.balances || []
-    if (balances.length === 0) return []
-
-    return balances
-      .map((group) => ({
-        intentAddress: group.intentAddress,
-        chainId: group.chainId,
-        tokens: mapTokens(group.tokens || []),
-      }))
-      .filter((group) => group.tokens.length > 0)
-  }, [data?.balances])
-
-  return {
-    chainGroups,
-    hasRecoverableFunds: (data?.hasBalance ?? false) && chainGroups.length > 0,
-    isLoading,
-    error: (error as Error) || null,
-    refetch: async () => {
-      await refetch()
-    },
-  }
-}