0xtrails 0.12.0 → 0.12.2

package/src/poolUtils.ts

@@ -1,6 +1,7 @@
 import { encodeFunctionData, type WalletClient } from "viem"
 import { logger } from "./logger.js"
 import type { Pool } from "./pools.js"
+import { isValidStringAmount, isPositiveBigInt } from "./utils/validation.js"
 
 /**
  * Generate Aave deposit calldata
@@ -47,25 +48,15 @@ export function generateAaveDepositCalldata(
     }
 
     // Validate amount
-    if (
-      !amount ||
-      amount === "" ||
-      Number.isNaN(Number(amount)) ||
-      Number(amount) <= 0
-    ) {
+    if (!isValidStringAmount(amount)) {
       throw new Error(`Invalid amount: ${amount}`)
     }
 
     // Validate amount can be converted to BigInt
-    let amountBigInt: bigint
-    try {
-      amountBigInt = BigInt(amount)
-      if (amountBigInt <= 0n) {
-        throw new Error("Amount must be greater than 0")
-      }
-    } catch {
+    if (!isPositiveBigInt(amount)) {
       throw new Error(`Invalid amount format: ${amount}`)
     }
+    const amountBigInt = BigInt(amount)
 
     // Aave V3 Pool contract deposit function
     // function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode)
@@ -115,12 +106,7 @@ export function generateMorphoDepositCalldata(
     }
 
     // Validate amount
-    if (
-      !amount ||
-      amount === "" ||
-      Number.isNaN(Number(amount)) ||
-      Number(amount) <= 0
-    ) {
+    if (!isValidStringAmount(amount)) {
       throw new Error("Invalid amount")
     }
 

package/src/prepareSend.ts

@@ -1,7 +1,7 @@
 import { abortControllerRegistry } from "./abortController.js"
 import { trackPaymentError, trackPaymentStarted } from "./analytics.js"
 import { getSlippageToleranceValue } from "./widget/components/SlippageToleranceSettings.js"
-import { isNativeToken, isZeroAccount } from "./utils/address.js"
+import { addressEqual, isNativeToken, isZeroAccount } from "./utils/address.js"
 import { getERC20TransferData } from "./utils.js"
 import { getTokenPrice } from "./prices.js"
 import {
@@ -9,7 +9,7 @@ import {
   replacePlaceholderInCalldata,
   TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
 } from "./placeholder.js"
-import { IntentProtocolVersion } from "@0xtrails/api"
+import { IntentProtocolVersion, RouteProvider } from "@0xtrails/api"
 import { wrapCalldataWithTrailsRouterIfNeeded } from "./abis/trailsRouter.js"
 import { logger } from "./logger.js"
 import { getIsCustomCalldata } from "./contractUtils.js"
@@ -24,6 +24,7 @@ import {
   isSameToken,
 } from "./transactionIntent/index.js"
 import { Address, Bytes, Hex } from "ox"
+import { getWethAddress } from "./tokens.js"
 import {
   createHydratePayload,
   encodeHydrateExecuteCalldata,
@@ -76,6 +77,8 @@ export async function prepareSend(
     originNativeTokenPriceUsd,
     swapProvider,
     bridgeProvider,
+    swapProviderFallback,
+    bridgeProviderFallback,
     fundMethod: fundMethodFromOptions,
     mode,
     checkoutOnHandlers,
@@ -151,11 +154,32 @@ export async function prepareSend(
   let effectiveDestinationAddress = recipient
   let effectiveDestinationApprovalAddress: Address.Address | undefined
   let effectiveDestinationCalldata = destinationCalldata
+  let effectiveSwapProvider = swapProvider
 
   // Check if this is a same-chain same-token transfer (before modifying effectiveDestinationAddress)
   const isToSameChain = isSameChain(originChainId, destinationChainId)
   const isToSameToken = isSameToken(originTokenAddress, destinationTokenAddress)
   const isSameChainSameToken = isToSameChain && isToSameToken
+  const chainWethAddress = getWethAddress(originChainId)
+  const isSameChainNativeWrappedPair =
+    isToSameChain &&
+    !!chainWethAddress &&
+    ((isNativeToken(originTokenAddress) &&
+      addressEqual(destinationTokenAddress, chainWethAddress)) ||
+      (addressEqual(originTokenAddress, chainWethAddress) &&
+        isNativeToken(destinationTokenAddress)))
+  const isSameChainNativeWrappedToSelf =
+    isSameChainNativeWrappedPair && addressEqual(recipient, account.address)
+
+  if (isSameChainNativeWrappedToSelf) {
+    effectiveDestinationAddress = account.address
+    effectiveSwapProvider = RouteProvider.WETH
+    // Only force empty calldata when caller did not provide custom calldata.
+    if (!hasCustomCalldata) {
+      effectiveDestinationCalldata = undefined
+      hasCustomCalldata = false
+    }
+  }
 
   // For same-chain same-token with custom calldata:
   // Replace any placeholder in the calldata with the actual swapAmount
@@ -179,7 +203,8 @@ export async function prepareSend(
     !hasCustomCalldata &&
     tradeType === TradeType.EXACT_INPUT &&
     !isNativeToken(destinationTokenAddress) &&
-    !isSameChainSameToken // Don't override recipient for same-chain same-token transfers
+    !isSameChainSameToken &&
+    !isSameChainNativeWrappedToSelf // Keep backend-owned passthrough handling for native<->WETH to-self
   ) {
     effectiveDestinationCalldata = getERC20TransferData(
       recipient,
@@ -401,7 +426,7 @@ export async function prepareSend(
     sourceTokenPriceUsd: sourceTokenPriceUsd?.toString(),
     destinationTokenPriceUsd: destinationTokenPriceUsd?.toString(),
     tradeType: tradeType.toString(),
-    swapProvider: swapProvider || undefined,
+    swapProvider: effectiveSwapProvider || undefined,
     bridgeProvider: bridgeProvider || undefined,
     onramp,
     walletId,
@@ -476,8 +501,10 @@ export async function prepareSend(
     originNativeTokenPriceUsd,
     slippageTolerance,
     tradeType,
-    swapProvider,
+    swapProvider: effectiveSwapProvider,
     bridgeProvider,
+    swapProviderFallback,
+    bridgeProviderFallback,
     fundMethod,
     mode,
     checkoutOnHandlers,

package/src/prices.ts

@@ -7,6 +7,7 @@ import { queryClient as defaultQueryClient } from "./query/client.js"
 import { useTrailsClient, type TrailsClient } from "./trailsClient.js"
 import { MINUTE_MS, SECOND_MS, retryDelay } from "./utils/time.js"
 import { useUserActivityContext } from "./widget/providers/UserActivityProvider.js"
+import { isValidNumber, isNonNegativeNumber } from "./utils/validation.js"
 
 import { normalizeAddress } from "./utils/address.js"
 
@@ -459,25 +460,17 @@ export function calcAmountUsdPrice({
   const sanitizedPrice = normalizeNumber(usdPrice)
 
   // Validate inputs
-  if (
-    !Number.isFinite(sanitizedAmount) ||
-    Number.isNaN(sanitizedAmount) ||
-    sanitizedAmount < 0
-  ) {
+  if (!isNonNegativeNumber(sanitizedAmount)) {
     return 0
   }
-  if (
-    !Number.isFinite(sanitizedPrice) ||
-    Number.isNaN(sanitizedPrice) ||
-    sanitizedPrice < 0
-  ) {
+  if (!isNonNegativeNumber(sanitizedPrice)) {
     return 0
   }
 
   const result = sanitizedAmount * sanitizedPrice
 
   // Validate result
-  if (!Number.isFinite(result) || Number.isNaN(result)) {
+  if (!isValidNumber(result)) {
     logger.console.error("[trails-sdk] Error calculating amount USD:", {
       sanitizedAmount,
       sanitizedPrice,
@@ -501,7 +494,7 @@ export function normalizeNumber(
   // If already a number, return it directly
   if (typeof number === "number") {
     // Validate the number
-    if (!Number.isFinite(number) || Number.isNaN(number)) {
+    if (!isValidNumber(number)) {
       logger.console.error("[trails-sdk] Invalid number value:", number)
       return 0
     }
@@ -513,7 +506,7 @@ export function normalizeNumber(
   const normalized = parseLocaleNumber(number)
 
   // Return 0 for invalid numbers
-  if (!Number.isFinite(normalized) || Number.isNaN(normalized)) {
+  if (!isValidNumber(normalized)) {
     logger.console.error("[trails-sdk] Error normalizing number string:", {
       number,
       normalized,
@@ -532,23 +525,4 @@ export function formatTvl(tvl: number): string {
   return `$${tvl.toFixed(0)}`
 }
 
-// Helper function to validate numeric values
-export const isValidNumeric = (
-  value: number | string | null | undefined,
-): boolean => {
-  if (value === null || value === undefined || value === "") {
-    return true // Empty values are considered valid
-  }
-  const strValue = String(value).trim()
-  return /^\d+(\.\d+)?$/.test(strValue)
-}
-
-export const isValidInteger = (
-  value: number | string | null | undefined,
-): boolean => {
-  if (value === null || value === undefined || value === "") {
-    return true // Empty values are considered valid
-  }
-  const strValue = String(value).trim()
-  return /^\d+$/.test(strValue)
-}
+export { isValidNumeric, isValidInteger } from "./utils/validation.js"

package/src/query/balance.fetchers.ts

@@ -3,9 +3,7 @@
  * This is a leaf module — NO React imports, NO queryClient, NO balanceKeys.
  */
 import type {
-  GatewayNativeTokenBalances,
-  GatewayTokenBalance,
-  GetTokenBalancesSummaryReturn,
+  IndexerGateway as IndexerGatewayTypes,
   NativeTokenBalance,
   Page,
   SequenceIndexerGateway,
@@ -90,8 +88,14 @@ function addPriceAndUsdFields(
   priceData?: TokenPrice,
 ): void {
   // Get prices from both sources
-  const apiPriceUSD = (token as { priceUSD?: string }).priceUSD
-  const apiBalanceUSD = (token as { balanceUSD?: string }).balanceUSD
+  const apiPriceUSD =
+    "priceUSD" in token && typeof token.priceUSD === "string"
+      ? token.priceUSD
+      : undefined
+  const apiBalanceUSD =
+    "balanceUSD" in token && typeof token.balanceUSD === "string"
+      ? token.balanceUSD
+      : undefined
   const coinApiPrice = priceData?.priceUsd
   const parsedIndexerPrice = apiPriceUSD ? parseFloat(apiPriceUSD) : Number.NaN
   const indexerPrice = Number.isNaN(parsedIndexerPrice)
@@ -233,6 +237,87 @@ export function convertNativeTokenBalanceToToken(
 // Default empty page info for query fallback
 export const defaultPage = { page: 1, pageSize: 10, more: false }
 
+function getPageRequest(page?: number, pageSize?: number): Page | undefined {
+  if (page === undefined && pageSize === undefined) return undefined
+  return {
+    page,
+    pageSize,
+  }
+}
+
+function createEmptyMultiAccountResult(
+  accounts: string[],
+): GetTokenBalancesForMultipleAccountsReturn {
+  const result: GetTokenBalancesForMultipleAccountsReturn = {}
+  for (const account of accounts) {
+    result[account.toLowerCase()] = {
+      tokens: [],
+      nativeTokens: [],
+      erc20Tokens: [],
+      page: defaultPage,
+    }
+  }
+  return result
+}
+
+function mapChainEntryResults<T extends { accountAddress?: string }>(
+  entries: Array<{ chainId: number; results?: T[] }>,
+  result: GetTokenBalancesForMultipleAccountsReturn,
+  toToken: (entry: T) => Token,
+  bucket: "erc20Tokens" | "nativeTokens",
+): void {
+  for (const chainEntry of entries) {
+    if (!getChainInfo(chainEntry.chainId)) {
+      logger.console.warn(
+        `[tokenBalances] Skipping unsupported chain ID: ${chainEntry.chainId}`,
+      )
+      continue
+    }
+
+    for (const entry of chainEntry.results || []) {
+      const accountAddr = entry.accountAddress?.toLowerCase()
+      const accountEntry = accountAddr ? result[accountAddr] : undefined
+      if (!accountEntry) continue
+
+      const token = toToken(entry)
+      accountEntry[bucket].push(token)
+      accountEntry.tokens.push(token)
+    }
+  }
+}
+
+function toTokenPriceKey(chainId: number, tokenAddress?: string): string {
+  return `${chainId}:${tokenAddress || zeroAddress}`
+}
+
+function createTokenMapFromGatewaySummary(
+  summary: IndexerGatewayTypes.GetTokenBalancesSummaryResponse,
+): Map<string, TokenBalance | NativeTokenBalance> {
+  const tokenMap = new Map<string, TokenBalance | NativeTokenBalance>()
+
+  for (const chainEntry of summary.balances) {
+    for (const tokenBalance of chainEntry.results) {
+      if (!("contractAddress" in tokenBalance)) continue
+      if (!("contractInfo" in tokenBalance)) continue
+      tokenMap.set(
+        `${tokenBalance.contractAddress}-${tokenBalance.chainId}-${tokenBalance.contractInfo?.symbol}`,
+        tokenBalance,
+      )
+    }
+  }
+
+  for (const chainEntry of summary.nativeBalances) {
+    for (const nativeBalance of chainEntry.results) {
+      tokenMap.set(
+        `${zeroAddress}-${nativeBalance.chainId}-native`,
+        nativeBalance,
+      )
+    }
+  }
+
+  return tokenMap
+}
+
 // Type guard for native token balance
 export function isNativeToken(
   token: TokenBalance | NativeTokenBalance,
@@ -304,7 +389,7 @@ export async function fetchTokenBalancesSummary({
   indexerGatewayClient,
   page,
   pageSize,
-}: GetTokenBalancesParams): Promise<GetTokenBalancesSummaryReturn> {
+}: GetTokenBalancesParams): Promise<IndexerGatewayTypes.GetTokenBalancesSummaryResponse> {
   if (!account || !indexerGatewayClient) {
     throw new Error("Account address and indexer client are required")
   }
@@ -319,16 +404,10 @@ export async function fetchTokenBalancesSummary({
           contractWhitelist: tokenAddress ? [tokenAddress] : undefined,
           omitNativeBalances: false,
         },
-        page:
-          page !== undefined || pageSize !== undefined
-            ? {
-                page: page,
-                pageSize: pageSize,
-              }
-            : undefined,
+        page: getPageRequest(page, pageSize),
       })
 
-    return summaryFromGateway as unknown as GetTokenBalancesSummaryReturn
+    return summaryFromGateway
   } catch (error) {
     if (isNetworkError(error)) {
       logger.console.warn(
@@ -380,84 +459,24 @@ export async function fetchMultiAccountBalances({
           contractTypes: ["ERC20"],
           omitNativeBalances: false,
         },
-        page:
-          page !== undefined || pageSize !== undefined
-            ? {
-                page: page,
-                pageSize: pageSize,
-              }
-            : undefined,
+        page: getPageRequest(page, pageSize),
       })
 
-    // The gateway returns balances grouped by account
-    // Each entry in balances/nativeBalances arrays corresponds to an account
-    const result: GetTokenBalancesForMultipleAccountsReturn = {}
-
-    // Initialize result with empty arrays for each account
-    for (const account of validAccounts) {
-      result[account.toLowerCase()] = {
-        tokens: [],
-        nativeTokens: [],
-        erc20Tokens: [],
-        page: defaultPage,
-      }
-    }
-
-    // Map balances to their respective accounts and convert to Token type
-    // Gateway returns data grouped by chainId: { chainId, results: [...] }
-    // Each result has accountAddress, so we need to iterate through results
-    const gatewayBalances =
-      summaryFromGateway.balances as unknown as GatewayTokenBalance[]
-    const gatewayNativeBalances =
-      summaryFromGateway.nativeBalances as unknown as GatewayNativeTokenBalances[]
-
-    // For ERC20 balances: iterate through chain entries, then through results
-    for (const chainEntry of gatewayBalances) {
-      const chainId = (chainEntry as any).chainId
-      // Skip unsupported chain IDs
-      if (!getChainInfo(chainId)) {
-        logger.console.warn(
-          `[tokenBalances] Skipping unsupported chain ID: ${chainId}`,
-        )
-        continue
-      }
-
-      const results = (chainEntry as any).results || []
-      for (const tokenResult of results) {
-        const accountAddr = tokenResult.accountAddress?.toLowerCase()
-        if (accountAddr && result[accountAddr]) {
-          // Convert to Token type and add to arrays
-          const token = convertTokenBalanceToToken(tokenResult as TokenBalance)
-          result[accountAddr].erc20Tokens.push(token)
-          result[accountAddr].tokens.push(token)
-        }
-      }
-    }
+    const result = createEmptyMultiAccountResult(validAccounts)
 
-    // For native balances: iterate through chain entries, then through results
-    for (const chainEntry of gatewayNativeBalances) {
-      const chainId = (chainEntry as any).chainId
-      // Skip unsupported chain IDs
-      if (!getChainInfo(chainId)) {
-        logger.console.warn(
-          `[tokenBalances] Skipping unsupported chain ID: ${chainId}`,
-        )
-        continue
-      }
+    mapChainEntryResults(
+      summaryFromGateway.balances,
+      result,
+      convertTokenBalanceToToken,
+      "erc20Tokens",
+    )
 
-      const results = (chainEntry as any).results || []
-      for (const nativeResult of results) {
-        const accountAddr = nativeResult.accountAddress?.toLowerCase()
-        if (accountAddr && result[accountAddr]) {
-          // Convert to Token type and add to arrays
-          const token = convertNativeTokenBalanceToToken(
-            nativeResult as NativeTokenBalance,
-          )
-          result[accountAddr].nativeTokens.push(token)
-          result[accountAddr].tokens.push(token)
-        }
-      }
-    }
+    mapChainEntryResults(
+      summaryFromGateway.nativeBalances,
+      result,
+      convertNativeTokenBalanceToToken,
+      "nativeTokens",
+    )
 
     // Set page info from gateway response
     for (const account of validAccounts) {
@@ -474,17 +493,7 @@ export async function fetchMultiAccountBalances({
         "[trails-sdk] Network error fetching token balances, returning empty result:",
         { error, accounts },
       )
-      // Return empty balances for all accounts
-      const result: GetTokenBalancesForMultipleAccountsReturn = {}
-      for (const account of validAccounts) {
-        result[account.toLowerCase()] = {
-          tokens: [],
-          nativeTokens: [],
-          erc20Tokens: [],
-          page: defaultPage,
-        }
-      }
-      return result
+      return createEmptyMultiAccountResult(validAccounts)
     }
 
     logger.console.error(
@@ -510,68 +519,21 @@ export async function fetchBalancesWithPrices({
   indexerGatewayClient,
   trailsClient,
 }: GetTokenBalancesWithPricesParams): Promise<GetTokenBalancesWithPriceReturn> {
-  // Step 1: Fetch raw balance summary
   const summaryFromGateway = await fetchTokenBalancesSummary({
     account,
     indexerGatewayClient,
   })
-
-  // Step 2: Flatten into a TokenBalance array (combining ERC20 + native)
-  const tokenMap = new Map<string, TokenBalance>()
-
-  for (const balance of summaryFromGateway.balances) {
-    ;(balance as any).results.forEach((b: any) => {
-      tokenMap.set(
-        `${b.contractAddress}-${b.contractInfo?.chainId}-${b.contractInfo?.symbol}`,
-        {
-          ...b,
-          contractAddress: b.contractAddress ?? zeroAddress,
-          tokenId: b.contractInfo?.symbol,
-          symbol: b.contractInfo?.symbol,
-          name: b.contractInfo?.name,
-          decimals: b.contractInfo?.decimals,
-          imageUrl: getTokenImageUrl({
-            chainId: b.contractInfo?.chainId || 0,
-            contractAddress: b.contractAddress ?? zeroAddress,
-            symbol: b.contractInfo?.symbol,
-            fallbackImageUrl: b.contractInfo?.logoURI,
-          }),
-        },
-      )
-    })
-  }
-
-  for (const balance of summaryFromGateway.nativeBalances) {
-    ;(balance as any).results.forEach((b: any) => {
-      const contractAddr = b.contractAddress ?? zeroAddress
-      tokenMap.set(`${contractAddr}-${b.chainId}-${b.symbol}`, {
-        ...b,
-        contractAddress: contractAddr,
-        tokenId: b.symbol,
-        symbol: b.symbol,
-        name: b.name,
-        decimals: b.decimals ?? b.contractInfo?.decimals ?? 18,
-        imageUrl: getTokenImageUrl({
-          chainId: b.chainId,
-          contractAddress: zeroAddress,
-          symbol: b.symbol,
-          fallbackImageUrl: b.contractInfo?.logoURI,
-        }),
-      })
-    })
-  }
-
+  const tokenMap = createTokenMapFromGatewaySummary(summaryFromGateway)
   const tokens = Array.from(tokenMap.values())
 
-  // Step 3: Fetch prices for all tokens (graceful — balances without prices beats no data)
   let tokenPrices: Awaited<ReturnType<typeof getTokenPrices>> = []
   try {
     tokenPrices = await getTokenPrices(
       trailsClient,
       tokens.map((t) => ({
         chainId: t.chainId,
-        tokenAddress: t.contractAddress || zeroAddress,
-        tokenSymbol: t.contractInfo?.symbol || "",
+        tokenAddress: isNativeToken(t) ? zeroAddress : t.contractAddress,
+        tokenSymbol: isNativeToken(t) ? "" : t.contractInfo?.symbol || "",
       })),
     )
   } catch (err) {
@@ -581,27 +543,25 @@ export async function fetchBalancesWithPrices({
     )
   }
 
-  // Step 4: Convert to Token[] with price data
-  const balancesWithPrices: Token[] = tokens.map((b) => {
-    const priceData: TokenPrice | undefined = tokenPrices.find((p) => {
-      const tokenChainId = b.chainId ?? (b as any).contractInfo?.chainId
-      const isSameChain = p.token.chainId === tokenChainId
-      let isSameToken = p.token.tokenAddress === b.contractAddress
-      if (!b.contractAddress) {
-        isSameToken =
-          p.token.tokenAddress === zeroAddress || !p.token.tokenAddress
-      }
-      return isSameChain && isSameToken
-    })
+  const tokenPriceMap = new Map<string, TokenPrice>()
+  for (const tokenPrice of tokenPrices) {
+    tokenPriceMap.set(
+      toTokenPriceKey(tokenPrice.token.chainId, tokenPrice.token.tokenAddress),
+      tokenPrice,
+    )
+  }
 
-    const native = isNativeToken(b)
-    if (native) {
-      return convertNativeTokenBalanceToToken(
-        b as NativeTokenBalance,
-        priceData,
-      )
+  const balancesWithPrices: Token[] = tokens.map((b) => {
+    const priceData = tokenPriceMap.get(
+      toTokenPriceKey(
+        b.chainId,
+        isNativeToken(b) ? zeroAddress : b.contractAddress,
+      ),
+    )
+    if (isNativeToken(b)) {
+      return convertNativeTokenBalanceToToken(b, priceData)
     }
-    return convertTokenBalanceToToken(b as TokenBalance, priceData)
+    return convertTokenBalanceToToken(b, priceData)
   })
 
   return {

package/src/query/fiat.fetchers.ts

@@ -0,0 +1,33 @@
+/**
+ * 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
+}