0xtrails 0.8.2 → 0.8.3

package/src/tokenBalances.ts

@@ -437,6 +437,125 @@ export function useTokenBalances(address: Address.Address | null): {
   }
 }
 
+export type TokenBalancesForAccount = {
+  tokenBalancesData: FlatTokenBalancesData | undefined
+  isLoading: boolean
+  error: Error | null
+}
+
+export type UseTokenBalancesForMultipleAccountsReturn = {
+  /** Per-account token balances data, keyed by lowercase address */
+  balancesByAccount: { [account: string]: TokenBalancesForAccount }
+  /** Combined loading state - true if any account is loading */
+  isLoading: boolean
+  /** Combined error - first error encountered */
+  error: Error | null
+}
+
+/**
+ * Hook to fetch token balances for multiple accounts in a single API call
+ * This is more efficient than calling useTokenBalances multiple times
+ */
+export function useTokenBalancesForMultipleAccounts(
+  addresses: (Address.Address | null)[],
+): UseTokenBalancesForMultipleAccountsReturn {
+  const indexerClient = useIndexerGatewayClient()
+
+  // Filter out null addresses and normalize to lowercase
+  const validAddresses = addresses
+    .filter((addr): addr is Address.Address => addr !== null && addr.length > 0)
+    .map((addr) => addr.toLowerCase())
+
+  // Create stable query key from sorted addresses
+  const sortedAddresses = [...validAddresses].sort()
+  const addressesKey = sortedAddresses.join(",")
+
+  const {
+    data: multiAccountData,
+    isLoading,
+    error,
+  } = useQuery<GetTokenBalancesForMultipleAccountsReturn>({
+    queryKey: ["getTokenBalancesWithPrices", "multipleAccounts", addressesKey],
+    queryFn: async () => {
+      if (!validAddresses.length) {
+        return {}
+      }
+      try {
+        // Data is already flat per-account from getTokenBalancesForMultipleAccounts
+        // Each account has { balances: [tokenResults], nativeBalances: [nativeResults] }
+        return await getTokenBalancesForMultipleAccounts({
+          accounts: validAddresses,
+          indexerGatewayClient: indexerClient,
+        })
+      } catch (err) {
+        const errorMessage = getFullErrorMessage(err)
+
+        const isCorsError =
+          errorMessage.includes("Cross-Origin") ||
+          errorMessage.includes("CORS") ||
+          errorMessage.includes("Same Origin Policy")
+        const isNetworkError =
+          errorMessage.includes("fetch failed") ||
+          errorMessage.includes("network")
+
+        if (isCorsError || isNetworkError) {
+          logger.console.warn(
+            "[trails-sdk] Network or CORS error fetching token balances for multiple accounts:",
+            { error: errorMessage, addresses: validAddresses },
+          )
+          // Return empty balances for all accounts
+          const emptyResult: GetTokenBalancesForMultipleAccountsReturn = {}
+          for (const addr of validAddresses) {
+            emptyResult[addr] = {
+              tokens: [],
+              nativeTokens: [],
+              erc20Tokens: [],
+              page: defaultPage,
+            }
+          }
+          return emptyResult
+        }
+
+        logger.console.error(
+          "[trails-sdk] Failed to fetch token balances for multiple accounts:",
+          err,
+        )
+        throw err
+      }
+    },
+    enabled: validAddresses.length > 0 && !!indexerClient,
+    staleTime: 10000,
+    gcTime: 10000,
+    retry: (failureCount, err) => {
+      if (err && "status" in err && err.status === 404) return false
+      if (failureCount < 3) return true
+      return false
+    },
+    retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
+    refetchOnWindowFocus: true,
+    refetchOnReconnect: true,
+    refetchInterval: REFRESH_INTERVAL,
+    refetchIntervalInBackground: true,
+    refetchOnMount: true,
+  })
+
+  // Build the per-account result structure
+  const balancesByAccount: { [account: string]: TokenBalancesForAccount } = {}
+  for (const addr of validAddresses) {
+    balancesByAccount[addr] = {
+      tokenBalancesData: multiAccountData?.[addr],
+      isLoading,
+      error,
+    }
+  }
+
+  return {
+    balancesByAccount,
+    isLoading,
+    error,
+  }
+}
+
 // Helper to format balance
 export function formatRawAmount(
   balance: string | bigint,
@@ -801,7 +920,163 @@ export type GetTokenBalancesParams = {
   indexerGatewayClient: SequenceIndexerGateway
 }
 
-// Separate fetch function for token balances summary
+export type GetTokenBalancesForMultipleAccountsParams = {
+  accounts: string[]
+  indexerGatewayClient: SequenceIndexerGateway
+}
+
+/**
+ * Flat balance data for a single account using Token type (converted from raw gateway data)
+ */
+export type FlatTokenBalancesData = {
+  /** All tokens (native + ERC20) converted to Token type */
+  tokens: Token[]
+  /** Native tokens only (converted to Token type) */
+  nativeTokens: Token[]
+  /** ERC20 tokens only (converted to Token type) */
+  erc20Tokens: Token[]
+  page: Page
+}
+
+export type GetTokenBalancesForMultipleAccountsReturn = {
+  [account: string]: FlatTokenBalancesData
+}
+
+/**
+ * Fetch token balances summary for multiple accounts in a single API call
+ */
+export async function fetchGetTokenBalancesSummaryForMultipleAccounts({
+  accounts,
+  indexerGatewayClient,
+}: GetTokenBalancesForMultipleAccountsParams): Promise<GetTokenBalancesForMultipleAccountsReturn> {
+  if (!accounts.length || !indexerGatewayClient) {
+    throw new Error(
+      "At least one account address and indexer client are required",
+    )
+  }
+
+  // Filter out empty/null accounts
+  const validAccounts = accounts.filter((a) => a && a.length > 0)
+  if (!validAccounts.length) {
+    return {}
+  }
+
+  try {
+    const summaryFromGateway =
+      await indexerGatewayClient.getTokenBalancesSummary({
+        filter: {
+          accountAddresses: validAccounts,
+          contractStatus: ContractVerificationStatus.VERIFIED,
+          contractTypes: ["ERC20"],
+          omitNativeBalances: false,
+        },
+      })
+
+    // 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 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)
+        }
+      }
+    }
+
+    // For native balances: iterate through chain entries, then through results
+    for (const chainEntry of gatewayNativeBalances) {
+      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)
+        }
+      }
+    }
+
+    // Set page info from gateway response
+    for (const account of validAccounts) {
+      const accountEntry = result[account.toLowerCase()]
+      if (accountEntry) {
+        accountEntry.page = summaryFromGateway.page ?? defaultPage
+      }
+    }
+
+    return result
+  } catch (error) {
+    const errorMessage = getFullErrorMessage(error)
+
+    // Check if this is a CORS error or network error
+    const isCorsError =
+      errorMessage.includes("Cross-Origin") ||
+      errorMessage.includes("CORS") ||
+      errorMessage.includes("Same Origin Policy")
+    const isNetworkError =
+      errorMessage.includes("fetch failed") || errorMessage.includes("network")
+
+    if (isCorsError || isNetworkError) {
+      logger.console.warn(
+        "[trails-sdk] Network or CORS error fetching token balances, returning empty result:",
+        {
+          error: errorMessage,
+          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
+    }
+
+    logger.console.error(
+      "[trails-sdk] Failed to fetch token balances summary for multiple accounts:",
+      error,
+    )
+    throw error
+  }
+}
+
+/**
+ * Fetch token balances summary for a single account
+ * Returns chain-grouped data: { balances: [{ chainId, results: [...] }] }
+ */
 export async function fetchGetTokenBalancesSummary({
   account,
   indexerGatewayClient,
@@ -870,6 +1145,31 @@ export async function getTokenBalances({
   })
 }
 
+/**
+ * Get token balances for multiple accounts in a single query
+ */
+export async function getTokenBalancesForMultipleAccounts({
+  accounts,
+  indexerGatewayClient,
+}: GetTokenBalancesForMultipleAccountsParams): Promise<GetTokenBalancesForMultipleAccountsReturn> {
+  // Sort accounts to ensure consistent cache key
+  const sortedAccounts = [...accounts].sort()
+  return tokenBalancesQueryClient.fetchQuery({
+    queryKey: [
+      "fetchGetTokenBalancesSummary",
+      "multipleAccounts",
+      sortedAccounts.join(","),
+    ],
+    queryFn: () =>
+      fetchGetTokenBalancesSummaryForMultipleAccounts({
+        accounts,
+        indexerGatewayClient,
+      }),
+    staleTime: REFRESH_INTERVAL,
+    gcTime: REFRESH_INTERVAL,
+  })
+}
+
 // Cache invalidation utility function
 export function invalidateTokenBalancesCache(account?: string) {
   // Invalidate all token balance queries that match the pattern

package/src/trailsRouter.ts

@@ -13,6 +13,83 @@ function getAmountOffset(calldata: `0x${string}`, placeholder: bigint): number {
   return byteOffset
 }
 
+/**
+ * Check if calldata contains the placeholder amount.
+ * If no placeholder is found, the calldata has a real amount baked in.
+ * @param calldata - The calldata to check
+ * @returns true if calldata contains the placeholder, false otherwise
+ */
+export function calldataHasPlaceholder(calldata?: string): boolean {
+  if (!calldata || calldata === "0x") return false
+  return (
+    getAmountOffset(
+      calldata as `0x${string}`,
+      TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
+    ) !== -1
+  )
+}
+
+/**
+ * Replace the placeholder amount in calldata with the actual amount.
+ * Used for same-chain same-token vault deposits where the calldata was generated with a placeholder.
+ * @param calldata - The calldata containing the placeholder
+ * @param amount - The actual amount to inject (as string in wei)
+ * @returns The calldata with the placeholder replaced, or original calldata if no placeholder found
+ */
+export function replacePlaceholderInCalldata(
+  calldata: string,
+  amount: string,
+): string {
+  if (!calldata || calldata === "0x") return calldata
+
+  // Validate amount
+  if (!amount || amount === "") {
+    console.warn(
+      "replacePlaceholderInCalldata: Amount is empty, returning original calldata",
+    )
+    return calldata
+  }
+
+  // Check if amount is a valid number/bigint
+  let amountBigInt: bigint
+  try {
+    amountBigInt = BigInt(amount)
+  } catch (error) {
+    console.warn(
+      `replacePlaceholderInCalldata: Invalid amount "${amount}", returning original calldata`,
+      error,
+    )
+    return calldata
+  }
+
+  // Check for negative values
+  if (amountBigInt < 0n) {
+    console.warn(
+      `replacePlaceholderInCalldata: Amount cannot be negative (${amount}), returning original calldata`,
+    )
+    return calldata
+  }
+
+  // Optional: check if amount exceeds uint256 max
+  const MAX_UINT256 = BigInt(
+    "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+  )
+  if (amountBigInt > MAX_UINT256) {
+    console.warn(
+      `replacePlaceholderInCalldata: Amount exceeds uint256 max (${amount}), returning original calldata`,
+    )
+    return calldata
+  }
+
+  const placeholderHex = TRAILS_ROUTER_PLACEHOLDER_AMOUNT.toString(16).padStart(
+    64,
+    "0",
+  )
+  const amountHex = amountBigInt.toString(16).padStart(64, "0")
+
+  return calldata.replace(new RegExp(placeholderHex, "gi"), amountHex)
+}
+
 const trailsRouterAbi = [
   {
     type: "function",

package/src/transactionIntent/deposits/depositOrchestrator.ts

@@ -31,8 +31,6 @@ export async function attemptUserDepositTx({
   walletClient,
   destinationTokenDecimals,
   sourceTokenDecimals,
-  fee,
-  dryMode,
   sourceTokenPriceUsd,
   destinationTokenPriceUsd,
   swapAmount,
@@ -67,10 +65,8 @@ export async function attemptUserDepositTx({
   destinationTokenDecimals: number
   sourceTokenDecimals: number
   swapAmount: string
-  dryMode: boolean
   sourceTokenPriceUsd: number | null
   destinationTokenPriceUsd: number | null
-  fee: string
   onTransactionStateChange: (transactionStates: TransactionState[]) => void
   transactionStates: TransactionState[]
   fundMethod?: string
@@ -193,8 +189,6 @@ export async function attemptUserDepositTx({
       originChainId,
       chain,
       account,
-      fee,
-      dryMode,
       sourceTokenPriceUsd,
       destinationTokenPriceUsd,
       swapAmount,