0xtrails 0.5.0 → 0.6.0

package/src/tokens.ts

@@ -1,6 +1,10 @@
-import { QueryClient, useQuery } from "@tanstack/react-query"
-import { zeroAddress, erc20Abi, createPublicClient, http } from "viem"
-import { getChainInfo, getSupportedChains } from "./chains.js"
+import { useQuery } from "@tanstack/react-query"
+import { zeroAddress, erc20Abi } from "viem"
+import {
+  getChainInfo,
+  getSupportedChains,
+  getPublicRpcClient,
+} from "./chains.js"
 import {
   arbitrum,
   base,
@@ -17,7 +21,10 @@ import { getRelaySupportedTokens, type Chain } from "./relaySdk.js"
 import { useReadContracts } from "wagmi"
 import { useMemo } from "react"
 import { logger } from "./logger.js"
+import { isNativeToken } from "./utils.js"
 import { somnia } from "./customChains.js"
+import { PROD_SEQUENCE_METADATA_URL } from "./constants.js"
+import { useTrails } from "./widget/providers/TrailsProvider.js"
 
 export type SupportedToken = {
   id: string
@@ -48,6 +55,8 @@ export const commonTokenImages: Record<string, string> = {
   APE: "https://assets.sequence.info/images/tokens/large/33139/0x0000000000000000000000000000000000000000.webp",
   ANIME:
     "https://assets.coingecko.com/coins/images/53575/large/anime.jpg?1736748703",
+  BNB: "https://assets.sequence.info/images/tokens/large/56/0x0000000000000000000000000000000000000000.webp",
+  AVAX: "https://assets.sequence.info/images/tokens/large/43114/0x0000000000000000000000000000000000000000.webp",
 }
 
 const cacheVersion = "01"
@@ -183,40 +192,6 @@ function getTokenImageCache(): Record<string, TokenImageCacheEntry> {
   }
 }
 
-function setTokenImageCache(
-  key: string,
-  imageUrl: string,
-  found: boolean,
-): void {
-  if (typeof window === "undefined") return
-
-  try {
-    const cache = getTokenImageCache()
-    cache[key] = {
-      imageUrl,
-      timestamp: Date.now(),
-      found,
-    }
-    localStorage.setItem(TOKEN_IMAGE_CACHE_KEY, JSON.stringify(cache))
-  } catch (error) {
-    logger.console.warn("[trails-sdk] Failed to cache token image:", error)
-  }
-}
-
-// Dedicated QueryClient for token image fetching
-const tokenImageQueryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 24 * 60 * 60 * 1000, // 24 hours
-      gcTime: 7 * 24 * 60 * 60 * 1000, // 7 days
-      retry: 2,
-      retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-    },
-  },
-})
-
 // Priority tokens that should appear first in the list
 const PRIORITY_TOKENS = [
   "ETH",
@@ -282,60 +257,6 @@ export function getCachedTokenImageUrl(
   return cachedEntry?.imageUrl || ""
 }
 
-export async function getTokenImageUrlOrFallback({
-  chainId,
-  contractAddress,
-  symbol,
-}: {
-  chainId?: number
-  contractAddress?: string
-  symbol?: string
-}): Promise<string> {
-  const cacheKey = `${chainId}:${contractAddress}:${symbol}`
-  const imageUrl = getTokenImageUrl({ chainId, contractAddress, symbol })
-
-  // Check localStorage cache first
-  const cache = getTokenImageCache()
-  const cachedEntry = cache[cacheKey]
-
-  if (cachedEntry) {
-    if (cachedEntry.found) {
-      return cachedEntry.imageUrl
-    } else {
-      return "" // Return empty string if we previously found no image
-    }
-  }
-
-  // Use QueryClient to fetch and cache the result
-  try {
-    const result = await tokenImageQueryClient.fetchQuery({
-      queryKey: ["tokenImage", chainId, contractAddress],
-      queryFn: async () => {
-        const response = await fetch(imageUrl, {
-          method: "HEAD", // Only fetch headers to check if image exists
-          cache: "no-cache", // Don't cache the fetch request itself
-        })
-        const found = response.ok
-        const resultUrl = found ? imageUrl : ""
-
-        // Cache the result in localStorage
-        setTokenImageCache(cacheKey, resultUrl, found)
-
-        return resultUrl
-      },
-      staleTime: 24 * 60 * 60 * 1000, // 24 hours
-      gcTime: 7 * 24 * 60 * 60 * 1000, // 7 days
-    })
-
-    return result
-  } catch (error) {
-    logger.console.error("[trails-sdk] Error fetching token image:", error)
-    // Cache the failure to avoid repeated requests
-    setTokenImageCache(cacheKey, "", false)
-    return ""
-  }
-}
-
 export async function getAllTokens(): Promise<SupportedToken[]> {
   const relayTokens = (await getRelaySupportedTokens()) as SupportedToken[]
   return relayTokens
@@ -352,20 +273,15 @@ export async function getSupportedTokens(): Promise<SupportedToken[]> {
       })
     }
 
-    getTokenImageUrlOrFallback({
+    // Use getTokenImageUrl directly (synchronous)
+    const imageUrl = getTokenImageUrl({
       chainId: token.chainId,
       contractAddress: token.contractAddress,
       symbol: token.symbol,
     })
-      .then((imageUrl) => {
-        token.imageUrl = imageUrl
-      })
-      .catch((error) => {
-        logger.console.error(
-          "[trails-sdk] Error getting token image url:",
-          error,
-        )
-      })
+    if (imageUrl) {
+      token.imageUrl = imageUrl
+    }
   }
 
   const additionalTokens: SupportedToken[] = []
@@ -451,23 +367,6 @@ export function useSupportedTokens({ chainId }: { chainId?: number } = {}): {
   }
 }
 
-export async function getSourceTokenList(): Promise<string[]> {
-  const tokens = await getSupportedTokens()
-  return tokens.map((token) => token.symbol)
-}
-
-export function useSourceTokenList(): string[] {
-  const { data: list = [] } = useQuery({
-    queryKey: ["sourceTokenList"],
-    queryFn: getSourceTokenList,
-    staleTime: 1000 * 60 * 60, // 1 hour - token list rarely changes
-    gcTime: 1000 * 60 * 60 * 24, // 24 hours cache time
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
-  })
-  return list
-}
-
 const tokenNames: Record<string, string> = {
   ETH: "Ethereum",
   WETH: "Wrapped ETH",
@@ -593,10 +492,7 @@ export async function getTokenInfo(
     }
 
     // Create a public client for the specific chain
-    const publicClient = createPublicClient({
-      chain: chainInfo,
-      transport: http(),
-    })
+    const publicClient = getPublicRpcClient(chainInfo)
 
     // Read token data on-chain
     const [name, symbol, decimals] = await Promise.all([
@@ -735,11 +631,13 @@ export function getTokenImageUrl({
   contractAddress,
   symbol,
   fallbackImageUrl,
+  sequenceMetadataUrl,
 }: {
   chainId?: number
   contractAddress?: string
   symbol?: string
   fallbackImageUrl?: string
+  sequenceMetadataUrl?: string
 }) {
   if (!chainId || !contractAddress || !symbol) {
     return ""
@@ -765,14 +663,42 @@ export function getTokenImageUrl({
     }
   }
 
-  if (fallbackImageUrl) {
-    return fallbackImageUrl
-  }
-
-  const imageUrl = `https://assets.sequence.info/images/tokens/large/${chainId}/${contractAddress.toLowerCase()}.webp`
+  const baseUrl = sequenceMetadataUrl || PROD_SEQUENCE_METADATA_URL
+  const fallbackParam = fallbackImageUrl
+    ? `?fallback=${encodeURIComponent(fallbackImageUrl)}`
+    : "?happy=true"
+  const imageUrl = `${baseUrl}/tokens/${chainId}/${contractAddress.toLowerCase()}/image${fallbackParam}`
   return imageUrl
 }
 
+// React hook that returns a configured getTokenImageUrl function
+export function useGetTokenImageUrl(): {
+  getTokenImageUrl: (params: {
+    chainId?: number
+    contractAddress?: string
+    symbol?: string
+    fallbackImageUrl?: string
+  }) => string
+} {
+  const { sequenceMetadataUrl } = useTrails()
+
+  return useMemo(
+    () => ({
+      getTokenImageUrl: (params: {
+        chainId?: number
+        contractAddress?: string
+        symbol?: string
+        fallbackImageUrl?: string
+      }) =>
+        getTokenImageUrl({
+          ...params,
+          sequenceMetadataUrl,
+        }),
+    }),
+    [sequenceMetadataUrl],
+  )
+}
+
 // React hook for token image fetching with caching
 export function useTokenImageUrl({
   chainId,
@@ -788,6 +714,7 @@ export function useTokenImageUrl({
   error: Error | null
   hasImage: boolean
 } {
+  const { getTokenImageUrl } = useGetTokenImageUrl()
   const {
     data: imageUrl = "",
     isLoading,
@@ -795,7 +722,7 @@ export function useTokenImageUrl({
   } = useQuery({
     queryKey: ["tokenImage", chainId, contractAddress, symbol],
     queryFn: () =>
-      getTokenImageUrlOrFallback({ chainId, contractAddress, symbol }),
+      Promise.resolve(getTokenImageUrl({ chainId, contractAddress, symbol })),
     enabled: !!chainId && !!contractAddress,
     staleTime: 24 * 60 * 60 * 1000, // 24 hours
     gcTime: 7 * 24 * 60 * 60 * 1000, // 7 days
@@ -834,11 +761,11 @@ export function useTokenInfo({
   error: Error | null
 } {
   // Always call hooks unconditionally
+  const { getTokenImageUrl } = useGetTokenImageUrl()
   const isAddress = address?.startsWith("0x") ?? false
 
   // Handle any native token (zero address) - before any blockchain calls
-  const isNativeToken =
-    address?.toLowerCase() === zeroAddress.toLowerCase() && !!chainId
+  const isNativeTokenAddress = isNativeToken(address) && !!chainId
 
   // Check cache first
   const cachedInfo = useMemo(() => {
@@ -853,7 +780,7 @@ export function useTokenInfo({
   } as const
   const result = useReadContracts({
     contracts:
-      !!isAddress && !!chainId && !cachedInfo && !isNativeToken
+      !!isAddress && !!chainId && !cachedInfo && !isNativeTokenAddress
         ? [
             { ...contract, functionName: "name" },
             { ...contract, functionName: "symbol" },
@@ -868,7 +795,7 @@ export function useTokenInfo({
 
   const tokenInfo = useMemo(() => {
     // Handle native token (zero address) for any chain
-    if (isNativeToken) {
+    if (isNativeTokenAddress) {
       const nativeSymbol = chainInfo?.nativeCurrency.symbol || "ETH"
       const nativeName = chainInfo?.nativeCurrency.name || "Ethereum"
       const decimals = chainInfo?.nativeCurrency.decimals ?? 18
@@ -930,7 +857,7 @@ export function useTokenInfo({
   }, [
     address,
     chainId,
-    isNativeToken,
+    isNativeTokenAddress,
     cachedInfo,
     chainInfo?.name,
     chainInfo?.nativeCurrency.symbol,
@@ -939,6 +866,7 @@ export function useTokenInfo({
     name?.result,
     symbol?.result,
     decimals?.result,
+    getTokenImageUrl,
   ])
 
   // Early return if not a valid address or chainId
@@ -967,6 +895,7 @@ export const tokenImageSymbolMap: Record<string, string> = {
   USDT: "USDT",
   DAI: "DAI",
   xDAI: "DAI",
+  XDAI: "DAI",
   WBTC: "WBTC",
   cbBTC: "WBTC",
   BAT: "BAT",

package/src/trailsClient.ts

@@ -25,7 +25,7 @@ export const useTrailsClient = (
 
   const trailsClient = useMemo(() => {
     return getTrailsClient({
-      apiKey: configOverride?.apiKey || trailsConfig.trailsApiKey,
+      apiKey: configOverride?.apiKey || trailsConfig.trailsApiKey || "",
       hostname: configOverride?.hostname || trailsConfig.trailsApiUrl,
       jwt: configOverride?.jwt,
     })

package/src/transactionIntent/deposits/depositOrchestrator.ts

@@ -5,8 +5,7 @@ import type {
   WalletClient,
   TransactionReceipt,
 } from "viem"
-import { zeroAddress } from "viem"
-import type { TrailsApi } from "@0xsequence/trails-api"
+import type { FeeOption, TrailsApi } from "@0xsequence/trails-api"
 import type { TransactionState } from "../../transactions.js"
 import type { CheckoutOnHandlers } from "../../widget/hooks/useCheckout.js"
 import type {
@@ -14,8 +13,8 @@ import type {
   GasFeeOptions,
   ExecuteIntentResponse,
 } from "@0xsequence/trails-api"
-import type { SelectedFeeToken } from "../types.js"
 import { logger } from "../../logger.js"
+import { isNativeToken } from "../../utils.js"
 import { attemptGaslessDeposit, getDoGasless } from "./gaslessDeposit.js"
 import { attemptStandardDeposit } from "./standardDeposit.js"
 
@@ -24,7 +23,7 @@ export async function attemptUserDepositTx({
   paymasterUrl,
   chain,
   account,
-  firstPreconditionMin,
+  depositAmount,
   originIntentAddress,
   onOriginSend,
   publicClient,
@@ -44,7 +43,7 @@ export async function attemptUserDepositTx({
   depositAmountUsd,
   feeOptions,
   trailsClient,
-  selectedFeeToken,
+  selectedFeeOption,
   walletId,
   abortSignal,
   checkoutOnHandlers,
@@ -58,7 +57,7 @@ export async function attemptUserDepositTx({
   paymasterUrl?: string
   chain: Chain
   account: Account
-  firstPreconditionMin: string
+  depositAmount: string
   originIntentAddress: string
   onOriginSend?: () => void
   publicClient: PublicClient
@@ -78,7 +77,7 @@ export async function attemptUserDepositTx({
   depositAmountUsd: number
   feeOptions?: GasFeeOptions
   trailsClient: TrailsApi
-  selectedFeeToken?: SelectedFeeToken
+  selectedFeeOption?: FeeOption | null
   walletId?: string
   abortSignal?: AbortSignal
   checkoutOnHandlers?: Partial<CheckoutOnHandlers>
@@ -121,7 +120,7 @@ export async function attemptUserDepositTx({
   const doGasless = getDoGasless(
     originTokenAddress,
     feeOptions,
-    selectedFeeToken,
+    selectedFeeOption,
     walletId,
   )
   logger.console.log(
@@ -131,11 +130,11 @@ export async function attemptUserDepositTx({
       paymasterUrl,
       hasFeeOptions: !!feeOptions,
       feeOptionsCount: feeOptions?.feeOptions?.length || 0,
-      selectedFeeToken,
-      selectedFeeTokenSet:
-        selectedFeeToken !== null && selectedFeeToken !== undefined,
+      selectedFeeOption,
+      selectedFeeOptionSet:
+        selectedFeeOption !== null && selectedFeeOption !== undefined,
       originTokenAddress,
-      isNotNative: originTokenAddress !== zeroAddress,
+      isNotNative: !isNativeToken(originTokenAddress),
     },
   )
   if (doGasless || paymasterUrl) {
@@ -151,7 +150,7 @@ export async function attemptUserDepositTx({
       await attemptGaslessDeposit({
         paymasterUrl,
         depositTokenAddress: originTokenAddress,
-        depositTokenAmount: firstPreconditionMin,
+        depositTokenAmount: depositAmount,
         depositRecipient: originIntentAddress,
         onOriginSend,
         walletClient,
@@ -159,7 +158,7 @@ export async function attemptUserDepositTx({
         account,
         trailsClient,
         feeOptions: feeOptions,
-        selectedFeeToken: selectedFeeToken,
+        selectedFeeOption,
         abortSignal,
         checkoutOnHandlers,
         intentId,
@@ -182,7 +181,7 @@ export async function attemptUserDepositTx({
   if (!depositUserTxnReceipt && !doGasless) {
     depositUserTxnReceipt = await attemptStandardDeposit({
       originTokenAddress,
-      firstPreconditionMin,
+      depositAmount,
       originIntentAddress,
       onOriginSend,
       publicClient,