0xtrails 0.13.2 → 0.14.0

package/src/widget/hooks/useDestinationSelectedToken.tsx

@@ -1,310 +0,0 @@
-import React, {
-  createContext,
-  useCallback,
-  useContext,
-  useState,
-  useEffect,
-  useRef,
-  type ReactNode,
-} from "react"
-
-import type { Token } from "../../tokens.js"
-import { useWidgetProps } from "./useWidgetProps.js"
-import { useSupportedTokens } from "../../tokens.js"
-import { isAddress } from "viem"
-
-const STORAGE_KEY = "trails_destination_selected_token"
-
-interface DestinationSelectedTokenContextType {
-  selectedToken: Token | null
-  setSelectedToken: (token: Token | null) => void
-  clearSelectedToken: () => void
-  /** True when user has manually selected a token (only relevant when not controlled by props) */
-  hasManualSelection: boolean
-  setHasManualSelection: (value: boolean) => void
-  /** True when toToken + toChainId props are provided (user cannot change) */
-  isControlledByProps: boolean
-  /** True when defaultToToken + defaultToChainId are used as initial values (user can change) */
-  hasDefaultProps: boolean
-  /** True when waiting for supported tokens to load for prop resolution */
-  isResolvingProps: boolean
-}
-
-const DestinationSelectedTokenContext = createContext<
-  DestinationSelectedTokenContextType | undefined
->(undefined)
-
-interface DestinationSelectedTokenProviderProps {
-  children: ReactNode
-  initialToken?: Token | null
-}
-
-// --- localStorage helpers ---
-
-function clearCachedToken(): void {
-  try {
-    localStorage.removeItem(STORAGE_KEY)
-  } catch {
-    // ignore
-  }
-}
-
-function getCachedToken(): Token | null {
-  try {
-    const saved = localStorage.getItem(STORAGE_KEY)
-    return saved ? JSON.parse(saved) : null
-  } catch {
-    return null
-  }
-}
-
-function setCachedToken(token: Token): void {
-  try {
-    localStorage.setItem(STORAGE_KEY, JSON.stringify(token))
-  } catch {
-    // ignore
-  }
-}
-
-function findTokenInSupported(
-  supportedTokens: Token[],
-  tokenIdentifier: string,
-  chainId: number,
-): Token | null {
-  const tokensOnChain = supportedTokens.filter((t) => t.chainId === chainId)
-
-  if (isAddress(tokenIdentifier)) {
-    return (
-      tokensOnChain.find(
-        (t) =>
-          t.contractAddress?.toLowerCase() === tokenIdentifier.toLowerCase(),
-      ) || null
-    )
-  }
-  return (
-    tokensOnChain.find(
-      (t) => t.symbol?.toLowerCase() === tokenIdentifier.toLowerCase(),
-    ) || null
-  )
-}
-
-// --- Provider ---
-
-export const DestinationSelectedTokenProvider: React.FC<
-  DestinationSelectedTokenProviderProps
-> = ({ children, initialToken = null }) => {
-  const { toToken, toChainId, defaultToToken, defaultToChainId } =
-    useWidgetProps()
-  const { supportedTokens, isLoadingTokens } = useSupportedTokens()
-
-  const isControlledByProps = Boolean(toToken && toChainId)
-
-  const hasDefaultProps = Boolean(
-    !isControlledByProps && defaultToToken && defaultToChainId,
-  )
-
-  const isResolvingProps =
-    (isControlledByProps || hasDefaultProps) && isLoadingTokens
-
-  // Track prop changes to re-resolve
-  const prevPropsRef = useRef({
-    toToken,
-    toChainId,
-    defaultToToken,
-    defaultToChainId,
-  })
-  const hasInitializedDefaultsRef = useRef(false)
-
-  const [selectedToken, setSelectedTokenState] = useState<Token | null>(() => {
-    // If controlled props provided, start null (will resolve in useEffect)
-    if (toToken && toChainId) {
-      return null
-    }
-    // If default props provided, check for cached selection first
-    if (defaultToToken && defaultToChainId) {
-      const cached = getCachedToken()
-      if (cached) {
-        // User has a cached selection, use it instead of defaults
-        return cached
-      }
-      // No cached selection, will resolve defaults in useEffect
-      return null
-    }
-    // No props at all, use cached or initial
-    return getCachedToken() || initialToken
-  })
-
-  // Track if user has manually selected (used by components for auto-selection logic)
-  const [hasManualSelection, setHasManualSelection] = useState(() => {
-    if (isControlledByProps) return false
-    // For defaults, check if there's a cached selection
-    if (hasDefaultProps) {
-      return getCachedToken() !== null
-    }
-    return getCachedToken() !== null
-  })
-
-  // Main effect: resolve token from props OR restore from cache
-  useEffect(() => {
-    const controlledPropsChanged =
-      toToken !== prevPropsRef.current.toToken ||
-      toChainId !== prevPropsRef.current.toChainId
-    const defaultPropsChanged =
-      defaultToToken !== prevPropsRef.current.defaultToToken ||
-      defaultToChainId !== prevPropsRef.current.defaultToChainId
-
-    prevPropsRef.current = {
-      toToken,
-      toChainId,
-      defaultToToken,
-      defaultToChainId,
-    }
-
-    if (toToken && toChainId) {
-      clearCachedToken()
-      setHasManualSelection(false)
-
-      // Wait for supported tokens to load
-      if (isLoadingTokens || supportedTokens.length === 0) {
-        if (controlledPropsChanged) {
-          setSelectedTokenState(null) // Show loading state
-        }
-        return
-      }
-
-      const matchingToken = findTokenInSupported(
-        supportedTokens,
-        toToken,
-        Number(toChainId),
-      )
-
-      if (matchingToken) {
-        setSelectedTokenState(matchingToken)
-      } else {
-        // Not found, useSendForm may do custom token lookup for addresses
-        setSelectedTokenState(null)
-      }
-      return
-    }
-
-    if (defaultToToken && defaultToChainId) {
-      // Wait for supported tokens to load
-      if (isLoadingTokens || supportedTokens.length === 0) {
-        return
-      }
-
-      // If defaults changed, clear cache and apply new defaults
-      if (defaultPropsChanged && hasInitializedDefaultsRef.current) {
-        clearCachedToken()
-        setHasManualSelection(false)
-
-        const matchingToken = findTokenInSupported(
-          supportedTokens,
-          defaultToToken,
-          Number(defaultToChainId),
-        )
-
-        if (matchingToken) {
-          setSelectedTokenState(matchingToken)
-        }
-        return
-      }
-
-      // First load: only apply defaults if no cached selection
-      if (!hasInitializedDefaultsRef.current) {
-        hasInitializedDefaultsRef.current = true
-
-        const cached = getCachedToken()
-        if (cached) {
-          // User has a cached selection, use it instead of defaults
-          setSelectedTokenState(cached)
-          setHasManualSelection(true)
-          return
-        }
-
-        // No cached selection, apply defaults
-        const matchingToken = findTokenInSupported(
-          supportedTokens,
-          defaultToToken,
-          Number(defaultToChainId),
-        )
-
-        if (matchingToken) {
-          setSelectedTokenState(matchingToken)
-        }
-      }
-      return
-    }
-
-    if (controlledPropsChanged || defaultPropsChanged) {
-      // Props were just removed, restore from cache
-      hasInitializedDefaultsRef.current = false
-      setSelectedTokenState(getCachedToken() || initialToken)
-    }
-  }, [
-    toToken,
-    toChainId,
-    defaultToToken,
-    defaultToChainId,
-    isLoadingTokens,
-    supportedTokens,
-    initialToken,
-  ])
-
-  // setSelectedToken: called when user manually selects a token
-  const setSelectedToken = useCallback(
-    (token: Token | null) => {
-      setSelectedTokenState(token)
-
-      // Don't cache if controlled props are active (props always override)
-      if (isControlledByProps) {
-        return
-      }
-
-      // Cache manual selection (works for both default props and no props)
-      if (token) {
-        setCachedToken(token)
-        setHasManualSelection(true)
-      } else {
-        clearCachedToken()
-      }
-    },
-    [isControlledByProps],
-  )
-
-  const clearSelectedToken = useCallback(() => {
-    setSelectedTokenState(null)
-    clearCachedToken()
-    setHasManualSelection(false)
-  }, [])
-
-  const value: DestinationSelectedTokenContextType = {
-    selectedToken,
-    setSelectedToken,
-    clearSelectedToken,
-    hasManualSelection,
-    setHasManualSelection,
-    isControlledByProps,
-    hasDefaultProps,
-    isResolvingProps,
-  }
-
-  return (
-    <DestinationSelectedTokenContext.Provider value={value}>
-      {children}
-    </DestinationSelectedTokenContext.Provider>
-  )
-}
-
-export const useDestinationSelectedToken =
-  (): DestinationSelectedTokenContextType => {
-    const context = useContext(DestinationSelectedTokenContext)
-
-    if (context === undefined) {
-      throw new Error(
-        "useDestinationSelectedToken must be used within a DestinationSelectedTokenProvider",
-      )
-    }
-
-    return context
-  }

package/src/widget/hooks/useDisplayCurrencyPreference.tsx

@@ -1,145 +0,0 @@
-import React, {
-  createContext,
-  useContext,
-  useState,
-  useEffect,
-  type ReactNode,
-} from "react"
-import { useExchangeRate, useFiatCurrencyList } from "../../query/fiat.hooks.js"
-import { forexRateStore } from "../utils/forexRateStore.js"
-
-// For backwards compatibility, export SUPPORTED_CURRENCIES as a placeholder
-// The actual data comes from the API via useFiatCurrencyList
-export const SUPPORTED_CURRENCIES = [] as const
-
-interface DisplayCurrencyPreferenceContextType {
-  selectedCurrency: string | null
-  setSelectedCurrency: (currency: string) => void
-  resetCurrencyPreference: () => void
-  getEffectiveCurrency: () => string
-}
-
-const DisplayCurrencyPreferenceContext = createContext<
-  DisplayCurrencyPreferenceContextType | undefined
->(undefined)
-
-interface DisplayCurrencyPreferenceProviderProps {
-  children: ReactNode
-}
-
-const DISPLAY_CURRENCY_PREFERENCE_KEY = "trails-display-currency-preference"
-
-export const DisplayCurrencyPreferenceProvider: React.FC<
-  DisplayCurrencyPreferenceProviderProps
-> = ({ children }) => {
-  const { data: currencies = [] } = useFiatCurrencyList()
-
-  const [selectedCurrency, setSelectedCurrencyState] = useState<string | null>(
-    () => {
-      try {
-        const stored = localStorage.getItem(DISPLAY_CURRENCY_PREFERENCE_KEY)
-        // Just return the stored value, we'll validate it when currencies load
-        return stored
-      } catch (error) {
-        console.warn(
-          "Failed to read currency preference from localStorage:",
-          error,
-        )
-        return null
-      }
-    },
-  )
-
-  // Validate stored currency when currencies list loads
-  useEffect(() => {
-    if (currencies.length > 0 && selectedCurrency) {
-      if (!currencies.some((c) => c.code === selectedCurrency)) {
-        // Stored currency is not supported, reset it
-        setSelectedCurrencyState(null)
-        localStorage.removeItem(DISPLAY_CURRENCY_PREFERENCE_KEY)
-      }
-    }
-  }, [currencies, selectedCurrency])
-
-  // Get the effective currency (selected or default USD)
-  const effectiveCurrency = selectedCurrency || "USD"
-
-  // Fetch exchange rate when currency changes
-  // useGetExchangeRate actually returns the USD to currency rate (e.g., 1 USD = X currency)
-  const { exchangeRate } = useExchangeRate({
-    fromCurrency: "USD",
-    toCurrency: effectiveCurrency,
-    disabled: effectiveCurrency === "USD",
-  })
-
-  // Store the exchange rate when it changes
-  useEffect(() => {
-    if (effectiveCurrency === "USD") {
-      // Clear the rate for USD
-      forexRateStore.clearRate()
-    } else if (exchangeRate) {
-      // useGetExchangeRate returns the USD to currency rate directly
-      // e.g., for CAD it returns 1.38705 meaning 1 USD = 1.38705 CAD
-      forexRateStore.setRate(effectiveCurrency, exchangeRate)
-    }
-  }, [effectiveCurrency, exchangeRate])
-
-  useEffect(() => {
-    try {
-      if (selectedCurrency) {
-        localStorage.setItem(DISPLAY_CURRENCY_PREFERENCE_KEY, selectedCurrency)
-      } else {
-        localStorage.removeItem(DISPLAY_CURRENCY_PREFERENCE_KEY)
-      }
-    } catch (error) {
-      console.warn("Failed to save currency preference to localStorage:", error)
-    }
-  }, [selectedCurrency])
-
-  const setSelectedCurrency = (currency: string) => {
-    if (currencies.some((c) => c.code === currency)) {
-      setSelectedCurrencyState(currency)
-    } else {
-      console.warn(`Unsupported currency: ${currency}`)
-    }
-  }
-
-  const resetCurrencyPreference = () => {
-    try {
-      localStorage.removeItem(DISPLAY_CURRENCY_PREFERENCE_KEY)
-      setSelectedCurrencyState(null)
-    } catch (error) {
-      console.warn("Failed to reset currency preference:", error)
-      setSelectedCurrencyState(null)
-    }
-  }
-
-  const getEffectiveCurrency = () => {
-    return selectedCurrency || "USD"
-  }
-
-  const value: DisplayCurrencyPreferenceContextType = {
-    selectedCurrency,
-    setSelectedCurrency,
-    resetCurrencyPreference,
-    getEffectiveCurrency,
-  }
-
-  return (
-    <DisplayCurrencyPreferenceContext.Provider value={value}>
-      {children}
-    </DisplayCurrencyPreferenceContext.Provider>
-  )
-}
-
-export function useDisplayCurrencyPreference(): DisplayCurrencyPreferenceContextType {
-  const context = useContext(DisplayCurrencyPreferenceContext)
-
-  if (context === undefined) {
-    throw new Error(
-      "useDisplayCurrencyPreference must be used within a DisplayCurrencyPreferenceProvider",
-    )
-  }
-
-  return context
-}

package/src/widget/hooks/useEarnPool.tsx

@@ -1,36 +0,0 @@
-import React, {
-  createContext,
-  useContext,
-  useState,
-  type ReactNode,
-} from "react"
-import type { Pool } from "../../pools.js"
-
-interface EarnPoolContextType {
-  selectedPool: Pool | null
-  setSelectedPool: (pool: Pool | null) => void
-}
-
-const EarnPoolContext = createContext<EarnPoolContextType | undefined>(
-  undefined,
-)
-
-export const EarnPoolProvider: React.FC<{ children: ReactNode }> = ({
-  children,
-}) => {
-  const [selectedPool, setSelectedPool] = useState<Pool | null>(null)
-
-  return (
-    <EarnPoolContext.Provider value={{ selectedPool, setSelectedPool }}>
-      {children}
-    </EarnPoolContext.Provider>
-  )
-}
-
-export function useEarnPool(): EarnPoolContextType {
-  const context = useContext(EarnPoolContext)
-  if (context === undefined) {
-    throw new Error("useEarnPool must be used within an EarnPoolProvider")
-  }
-  return context
-}

package/src/widget/hooks/useExecutingIntentsCount.ts

@@ -1,78 +0,0 @@
-import { useState, useEffect, useMemo } from "react"
-import { useAccount } from "wagmi"
-import { useIntentTransactionHistory } from "./useIntentTransactionHistory.js"
-import { logger } from "../../logger.js"
-import { SECOND_MS, HOUR_MS } from "../../utils/time.js"
-
-const REFETCH_INTERVAL_MS = 5 * SECOND_MS // 5 seconds
-
-export interface UseExecutingIntentsCountReturn {
-  /** Number of intents currently executing/pending/mining */
-  count: number
-  /** Whether the data is loading */
-  loading: boolean
-}
-
-/**
- * Hook to get the count of currently executing intents.
- * Only tracks intents actively in-flight (EXECUTING or MINING status).
- * Does not count PENDING (waiting to be sent) or COMMITTED (not yet started).
- * Auto-refetches every 30s while there are executing intents.
- */
-export function useExecutingIntentsCount(): UseExecutingIntentsCountReturn {
-  const { address } = useAccount()
-  const [hasExecuting, setHasExecuting] = useState(false)
-
-  const { transactions, loading } = useIntentTransactionHistory({
-    accountAddress: address,
-    pageSize: 50,
-    enabled: !!address,
-    refetchInterval: hasExecuting ? REFETCH_INTERVAL_MS : false,
-  })
-
-  const count = useMemo(() => {
-    if (!transactions?.length) return 0
-
-    const now = Date.now()
-    const minAgeMs = now - 2 * SECOND_MS // 2 seconds
-    const maxAgeMs = now - HOUR_MS // 1 hour
-
-    const executingTxs = transactions.filter((tx) => {
-      const status = tx.executionStatus?.toUpperCase()
-      // Only count actively executing transactions, not pending/waiting ones
-      if (status !== "EXECUTING" && status !== "MINING") return false
-
-      // Only count transactions between min and max age
-      if (tx.createdAt) {
-        const createdAtTime = new Date(tx.createdAt).getTime()
-        if (createdAtTime > minAgeMs) return false
-        if (createdAtTime < maxAgeMs) return false
-      }
-
-      return true
-    })
-
-    if (executingTxs.length > 0) {
-      logger.console.log("[trails-sdk] Executing intents:", {
-        count: executingTxs.length,
-        intents: executingTxs.map((tx) => ({
-          intentId: tx.intentId,
-          status: tx.executionStatus,
-          originChainId: tx.originChainId,
-          destinationChainId: tx.destinationChainId,
-          createdAt: tx.createdAt,
-        })),
-      })
-    }
-
-    return executingTxs.length
-  }, [transactions])
-
-  useEffect(() => {
-    setHasExecuting(count > 0)
-  }, [count])
-
-  return { count, loading }
-}
-
-export default useExecutingIntentsCount

package/src/widget/hooks/useExternalFundingReceiptSync.ts

@@ -1,79 +0,0 @@
-import { useEffect, type Dispatch, type SetStateAction } from "react"
-import { useIntentReceiptMonitor } from "../../intentReceiptMonitor.js"
-import { logger } from "../../logger.js"
-import {
-  applyIntentReceiptToTransactionStates,
-  hasIntentReceiptObservedFundingProgress,
-} from "../../transactionIntent/helpers/transactionStateHelpers.js"
-import type { TransactionState } from "../../transactions.js"
-import { useTrailsClient } from "../../trailsClient.js"
-
-export function useExternalFundingReceiptSync(params: {
-  enabled: boolean
-  intentId?: string
-  fallbackTransactionStates?: TransactionState[]
-  setTransactionStates: Dispatch<SetStateAction<TransactionState[]>>
-  onStatusUpdate?: (transactionStates: TransactionState[]) => void
-  onFundingObserved?: () => void
-}): void {
-  const {
-    enabled,
-    intentId,
-    fallbackTransactionStates,
-    setTransactionStates,
-    onStatusUpdate,
-    onFundingObserved,
-  } = params
-  const trailsClient = useTrailsClient()
-  const { intentReceipt } = useIntentReceiptMonitor(
-    enabled ? intentId : undefined,
-    trailsClient,
-  )
-
-  useEffect(() => {
-    if (!intentReceipt) {
-      return
-    }
-
-    setTransactionStates((currentStates) => {
-      const baseStates =
-        currentStates.length > 0
-          ? currentStates
-          : (fallbackTransactionStates ?? [])
-
-      if (baseStates.length === 0) {
-        return currentStates
-      }
-
-      const { transactionStates, changed } =
-        applyIntentReceiptToTransactionStates({
-          currentStates: baseStates,
-          receipt: intentReceipt,
-        })
-
-      if (changed) {
-        logger.console.log(
-          "[trails-sdk] External funding receipt sync updated transaction states",
-          {
-            intentId,
-            status: intentReceipt.status,
-          },
-        )
-        onStatusUpdate?.(transactionStates)
-      }
-
-      return changed ? transactionStates : currentStates
-    })
-
-    if (hasIntentReceiptObservedFundingProgress(intentReceipt)) {
-      onFundingObserved?.()
-    }
-  }, [
-    fallbackTransactionStates,
-    intentId,
-    intentReceipt,
-    onFundingObserved,
-    onStatusUpdate,
-    setTransactionStates,
-  ])
-}

package/src/widget/hooks/useFiatOnRampCurrencies.ts

@@ -1,46 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import type { TrailsOnramp } from "../../onrampClient.js"
-import { useOnrampClient } from "../../onrampClient.js"
-import type { MeldFiatCurrency } from "@0xtrails/api/onramp"
-import { meldQueries } from "../../query/meld.queries.js"
-
-export type OnrampFiatCurrency = MeldFiatCurrency
-
-export interface UseFiatOnRampCurrenciesOptions {
-  trailsClient?: TrailsOnramp | null
-  countryCode?: string | null
-  enabled?: boolean
-}
-
-export interface UseFiatOnRampCurrenciesResult {
-  fiatCurrencies: MeldFiatCurrency[]
-  isLoading: boolean
-  error: Error | null
-}
-
-export function useFiatOnRampCurrencies(
-  options: UseFiatOnRampCurrenciesOptions,
-): UseFiatOnRampCurrenciesResult {
-  const { trailsClient, countryCode, enabled = true } = options
-
-  const defaultOnrampClient = useOnrampClient()
-
-  const effectiveCountryCode =
-    !enabled || !countryCode || (trailsClient !== undefined && !trailsClient)
-      ? null
-      : countryCode
-
-  const client = trailsClient !== undefined ? trailsClient : defaultOnrampClient
-
-  const {
-    data: fiatCurrencies = [],
-    isLoading,
-    error,
-  } = useQuery(meldQueries.fiatCurrencyList(client, effectiveCountryCode))
-
-  return {
-    fiatCurrencies,
-    isLoading,
-    error: error as Error | null,
-  }
-}