0xtrails 0.8.2 → 0.8.3

package/src/recover.ts

@@ -17,13 +17,14 @@ import { splitSignature } from "./gasless.js"
 import { useMemo, useCallback } from "react"
 import { useGetIntent } from "./widget/hooks/useGetIntent.js"
 import {
-  useTokenBalances,
+  useTokenBalancesForMultipleAccounts,
   getTokenBalanceUsd,
   type Price,
 } from "./tokenBalances.js"
 import { getERC20TransferData } from "./encoders.js"
 import { zeroAddress } from "viem"
 import { useTokenPrices } from "./prices.js"
+import type { Token } from "./tokens.js"
 import type { Payload as WalletPayload } from "@0xsequence/wallet-primitives"
 import { attemptSwitchChain } from "./chainSwitch.js"
 import { decodeGuestModuleEvents } from "./decoders.js"
@@ -440,15 +441,17 @@ export async function buildRefundTransaction(
 
 /**
  * Determines the refund call based on token balances at the intent address
+ * Uses Token type which has symbol, name, decimals, chainId directly (no contractInfo)
  */
 export function determineRefundCall(
   tokenBalancesData:
     | {
-        nativeBalances?: Array<{ balance?: string; chainId?: number }>
-        balances?: Array<{
+        tokens?: Array<{
           balance?: string
           contractAddress?: string
-          contractInfo?: { decimals?: number; chainId?: number }
+          decimals?: number
+          chainId?: number
+          isNativeToken?: boolean
         }>
       }
     | undefined,
@@ -467,34 +470,18 @@ export function determineRefundCall(
     chainId?: number
   } | null = null
 
-  // Check native token balances
-  if (tokenBalancesData?.nativeBalances) {
-    for (const nativeBalance of tokenBalancesData.nativeBalances) {
-      const balance = BigInt(nativeBalance.balance || "0")
+  // Check all tokens (both native and ERC20)
+  if (tokenBalancesData?.tokens) {
+    for (const token of tokenBalancesData.tokens) {
+      const balance = BigInt(token.balance || "0")
       if (balance > 0n) {
         if (!highestBalanceToken || balance > highestBalanceToken.balance) {
           highestBalanceToken = {
-            type: "native",
+            type: token.isNativeToken ? "native" : "erc20",
             balance,
-            chainId: nativeBalance.chainId,
-          }
-        }
-      }
-    }
-  }
-
-  // Check ERC20 token balances
-  if (tokenBalancesData?.balances) {
-    for (const tokenBalance of tokenBalancesData.balances) {
-      const balance = BigInt(tokenBalance.balance || "0")
-      if (balance > 0n) {
-        if (!highestBalanceToken || balance > highestBalanceToken.balance) {
-          highestBalanceToken = {
-            type: "erc20",
-            balance,
-            tokenAddress: tokenBalance.contractAddress,
-            decimals: tokenBalance.contractInfo?.decimals,
-            chainId: tokenBalance.contractInfo?.chainId,
+            tokenAddress: token.contractAddress,
+            decimals: token.decimals,
+            chainId: token.chainId,
           }
         }
       }
@@ -581,6 +568,8 @@ export interface UseIntentRecoverReturn {
   intentError: Error | null
   balancesError: Error | null
   hasIntentBalance: boolean
+  /** Token that will be recovered (the one with highest balance) */
+  recoverToken: Token | null
   refetchIntent: () => void
   signPayload: () => Promise<{
     signature: string
@@ -655,49 +644,41 @@ export function useIntentRecover({
       return Address.from(intentData.destinationIntentAddress)
     }, [intentData?.destinationIntentAddress])
 
+  // Fetch balances for both origin and destination in a single API call
   const {
-    tokenBalancesData: originTokenBalancesData,
-    isLoadingBalances: isLoadingOriginBalances,
-    balanceError: originBalanceError,
-  } = useTokenBalances(originIntentAddressForBalances)
+    balancesByAccount,
+    isLoading: isLoadingBalances,
+    error: balanceError,
+  } = useTokenBalancesForMultipleAccounts([
+    originIntentAddressForBalances,
+    destinationIntentAddressForBalances,
+  ])
 
-  const {
-    tokenBalancesData: destinationTokenBalancesData,
-    isLoadingBalances: isLoadingDestinationBalances,
-    balanceError: destinationBalanceError,
-  } = useTokenBalances(destinationIntentAddressForBalances)
+  // Extract individual account balances
+  const originTokenBalancesData = originIntentAddressForBalances
+    ? balancesByAccount[originIntentAddressForBalances.toLowerCase()]
+        ?.tokenBalancesData
+    : undefined
+  const destinationTokenBalancesData = destinationIntentAddressForBalances
+    ? balancesByAccount[destinationIntentAddressForBalances.toLowerCase()]
+        ?.tokenBalancesData
+    : undefined
+
+  // balancesError alias for backward compatibility in component return
+  const balancesError = balanceError
 
   // Get token prices for origin balances
+  // Note: Token type already has balance/price fields populated, but we fetch prices
+  // separately for more accurate/up-to-date pricing
   const originTokensForPricing = useMemo(() => {
-    if (!originTokenBalancesData) return []
-    const tokens: Array<{
-      tokenSymbol: string
-      tokenAddress: string
-      chainId: number
-    }> = []
-    if (originTokenBalancesData.nativeBalances) {
-      for (const nativeBalance of originTokenBalancesData.nativeBalances) {
-        if (nativeBalance.chainId) {
-          tokens.push({
-            tokenSymbol: (nativeBalance as any).symbol || "ETH",
-            tokenAddress: zeroAddress,
-            chainId: nativeBalance.chainId,
-          })
-        }
-      }
-    }
-    if (originTokenBalancesData.balances) {
-      for (const tokenBalance of originTokenBalancesData.balances) {
-        if (tokenBalance.contractInfo?.chainId) {
-          tokens.push({
-            tokenSymbol: tokenBalance.contractInfo?.symbol || "",
-            tokenAddress: tokenBalance.contractAddress || zeroAddress,
-            chainId: tokenBalance.contractInfo.chainId,
-          })
-        }
-      }
-    }
-    return tokens
+    if (!originTokenBalancesData?.tokens) return []
+    return originTokenBalancesData.tokens
+      .filter((token) => token.chainId !== undefined)
+      .map((token) => ({
+        tokenSymbol: token.symbol,
+        tokenAddress: token.contractAddress || zeroAddress,
+        chainId: token.chainId!,
+      }))
   }, [originTokenBalancesData])
 
   const { tokenPrices: originTokenPrices } = useTokenPrices(
@@ -706,35 +687,14 @@ export function useIntentRecover({
 
   // Get token prices for destination balances
   const destinationTokensForPricing = useMemo(() => {
-    if (!destinationTokenBalancesData) return []
-    const tokens: Array<{
-      tokenSymbol: string
-      tokenAddress: string
-      chainId: number
-    }> = []
-    if (destinationTokenBalancesData.nativeBalances) {
-      for (const nativeBalance of destinationTokenBalancesData.nativeBalances) {
-        if (nativeBalance.chainId) {
-          tokens.push({
-            tokenSymbol: (nativeBalance as any).symbol || "ETH",
-            tokenAddress: zeroAddress,
-            chainId: nativeBalance.chainId,
-          })
-        }
-      }
-    }
-    if (destinationTokenBalancesData.balances) {
-      for (const tokenBalance of destinationTokenBalancesData.balances) {
-        if (tokenBalance.contractInfo?.chainId) {
-          tokens.push({
-            tokenSymbol: tokenBalance.contractInfo?.symbol || "",
-            tokenAddress: tokenBalance.contractAddress || zeroAddress,
-            chainId: tokenBalance.contractInfo.chainId,
-          })
-        }
-      }
-    }
-    return tokens
+    if (!destinationTokenBalancesData?.tokens) return []
+    return destinationTokenBalancesData.tokens
+      .filter((token) => token.chainId !== undefined)
+      .map((token) => ({
+        tokenSymbol: token.symbol,
+        tokenAddress: token.contractAddress || zeroAddress,
+        chainId: token.chainId!,
+      }))
   }, [destinationTokenBalancesData])
 
   const { tokenPrices: destinationTokenPrices } = useTokenPrices(
@@ -746,19 +706,13 @@ export function useIntentRecover({
     (
       balancesData:
         | {
-            nativeBalances?: Array<{
+            tokens?: Array<{
               balance?: string
               chainId?: number
-              symbol?: string
-            }>
-            balances?: Array<{
-              balance?: string
               contractAddress?: string
-              contractInfo?: {
-                decimals?: number
-                chainId?: number
-                symbol?: string
-              }
+              decimals?: number
+              isNativeToken?: boolean
+              balanceUsd?: number
             }>
           }
         | undefined,
@@ -773,56 +727,44 @@ export function useIntentRecover({
 
       let totalUsd = 0
 
-      // Sum native token USD values
-      if (balancesData.nativeBalances) {
-        for (const nativeBalance of balancesData.nativeBalances) {
-          const priceData = tokenPrices.find(
-            (p) =>
-              p.token.tokenAddress === zeroAddress &&
-              p.token.chainId === nativeBalance.chainId &&
-              p.priceUsd !== undefined,
-          )
-          if (priceData?.priceUsd && nativeBalance.balance) {
-            const price: Price = {
-              value: priceData.priceUsd,
-              currency: "USD",
-            }
-            const usdValue = getTokenBalanceUsd(
-              {
-                balance: nativeBalance.balance,
-                chainId: nativeBalance.chainId,
-              } as any,
-              price,
-            )
-            totalUsd += usdValue
-          }
-        }
-      }
+      // Sum all token USD values (both native and ERC20)
+      if (balancesData.tokens) {
+        for (const token of balancesData.tokens) {
+          const tokenAddress = token.isNativeToken
+            ? zeroAddress
+            : token.contractAddress || zeroAddress
 
-      // Sum ERC20 token USD values
-      if (balancesData.balances) {
-        for (const tokenBalance of balancesData.balances) {
           const priceData = tokenPrices.find(
             (p) =>
               p.token.tokenAddress?.toLowerCase() ===
-                (tokenBalance.contractAddress || zeroAddress).toLowerCase() &&
-              p.token.chainId === tokenBalance.contractInfo?.chainId &&
+                tokenAddress.toLowerCase() &&
+              p.token.chainId === token.chainId &&
               p.priceUsd !== undefined,
           )
-          if (priceData?.priceUsd && tokenBalance.balance) {
+
+          if (priceData?.priceUsd && token.balance) {
             const price: Price = {
               value: priceData.priceUsd,
               currency: "USD",
             }
-            const usdValue = getTokenBalanceUsd(
-              {
-                balance: tokenBalance.balance,
-                contractAddress: tokenBalance.contractAddress,
-                contractInfo: tokenBalance.contractInfo,
-              } as any,
-              price,
-            )
-            totalUsd += usdValue
+
+            // Use balanceUsd if already calculated, otherwise calculate
+            if (token.balanceUsd !== undefined) {
+              totalUsd += token.balanceUsd
+            } else {
+              // Create a compatible object for getTokenBalanceUsd
+              const balanceObj = token.isNativeToken
+                ? { balance: token.balance, chainId: token.chainId }
+                : {
+                    balance: token.balance,
+                    contractInfo: {
+                      decimals: token.decimals,
+                      chainId: token.chainId,
+                    },
+                  }
+              const usdValue = getTokenBalanceUsd(balanceObj as any, price)
+              totalUsd += usdValue
+            }
           }
         }
       }
@@ -919,9 +861,7 @@ export function useIntentRecover({
     calculateTotalUsdBalance,
   ])
 
-  const isLoadingBalances =
-    isLoadingOriginBalances || isLoadingDestinationBalances
-  const balancesError = originBalanceError || destinationBalanceError
+  // isLoadingBalances and balancesError are already defined above from useTokenBalancesForMultipleAccounts
 
   // Check if ANY intent address (origin or destination) has any balance (native or ERC20)
   // This ensures we show the recover button if there are balances in either address
@@ -930,34 +870,17 @@ export function useIntentRecover({
     const checkBalances = (
       balancesData:
         | {
-            nativeBalances?: Array<{ balance?: string; chainId?: number }>
-            balances?: Array<{
-              balance?: string
-              contractAddress?: string
-              contractInfo?: { decimals?: number; chainId?: number }
-            }>
+            tokens?: Array<{ balance?: string }>
           }
         | undefined,
     ): boolean => {
-      if (!balancesData) return false
-
-      // Check native token balances
-      if (balancesData.nativeBalances) {
-        for (const nativeBalance of balancesData.nativeBalances) {
-          const balance = BigInt(nativeBalance.balance || "0")
-          if (balance > 0n) {
-            return true
-          }
-        }
-      }
+      if (!balancesData?.tokens) return false
 
-      // Check ERC20 token balances
-      if (balancesData.balances) {
-        for (const tokenBalance of balancesData.balances) {
-          const balance = BigInt(tokenBalance.balance || "0")
-          if (balance > 0n) {
-            return true
-          }
+      // Check all tokens (both native and ERC20)
+      for (const token of balancesData.tokens) {
+        const balance = BigInt(token.balance || "0")
+        if (balance > 0n) {
+          return true
         }
       }
 
@@ -971,6 +894,26 @@ export function useIntentRecover({
     return originHasBalance || destinationHasBalance
   }, [originTokenBalancesData, destinationTokenBalancesData])
 
+  // Get the token that will be recovered (highest balance from selected intent address)
+  // Get the token that will be recovered (highest balance from selected intent address)
+  const recoverToken = useMemo<Token | null>(() => {
+    if (!selectedIntentAddress?.tokenBalancesData?.tokens) return null
+
+    // Find the token with the highest balance
+    let highestBalanceToken: Token | null = null
+    let highestBalance = 0n
+
+    for (const token of selectedIntentAddress.tokenBalancesData.tokens) {
+      const balance = BigInt(token.balance || "0")
+      if (balance > 0n && balance > highestBalance) {
+        highestBalance = balance
+        highestBalanceToken = token
+      }
+    }
+
+    return highestBalanceToken
+  }, [selectedIntentAddress?.tokenBalancesData?.tokens])
+
   // Get refund address (use walletClient account or provided address)
   // Don't throw during render - validate when methods are called
   const effectiveRefundAddress = useMemo<`0x${string}` | null>(() => {
@@ -1411,6 +1354,7 @@ export function useIntentRecover({
     intentError: intentError as Error | null,
     balancesError: balancesError as Error | null,
     hasIntentBalance,
+    recoverToken,
     refetchIntent,
     signPayload,
     getRecoverTx,