0xtrails 0.8.0 → 0.8.2

package/src/{refund.ts → recover.ts}

@@ -16,11 +16,18 @@ import type { WalletClient, Chain } from "viem"
 import { splitSignature } from "./gasless.js"
 import { useMemo, useCallback } from "react"
 import { useGetIntent } from "./widget/hooks/useGetIntent.js"
-import { useTokenBalances } from "./tokenBalances.js"
+import {
+  useTokenBalances,
+  getTokenBalanceUsd,
+  type Price,
+} from "./tokenBalances.js"
 import { getERC20TransferData } from "./encoders.js"
 import { zeroAddress } from "viem"
+import { useTokenPrices } from "./prices.js"
 import type { Payload as WalletPayload } from "@0xsequence/wallet-primitives"
 import { attemptSwitchChain } from "./chainSwitch.js"
+import { decodeGuestModuleEvents } from "./decoders.js"
+import type { TransactionReceipt } from "viem"
 
 // Constants for execute function
 type ChainId = number
@@ -561,13 +568,13 @@ export function determineRefundCall(
   }
 }
 
-export interface UseTrailsRefundParams {
+export interface UseIntentRecoverParams {
   intentId: string | undefined
   walletClient: WalletClient | undefined
   refundToAddress?: `0x${string}`
 }
 
-export interface UseTrailsRefundReturn {
+export interface UseIntentRecoverReturn {
   intent: any | null
   isLoadingIntent: boolean
   isLoadingBalances: boolean
@@ -580,7 +587,7 @@ export interface UseTrailsRefundReturn {
     payload: Payload.Calls
     refundCall: Payload.Call
   }>
-  getRefundTx: (params: {
+  getRecoverTx: (params: {
     signedHash: string
     payload: Payload.Calls
   }) => Promise<{
@@ -589,27 +596,43 @@ export interface UseTrailsRefundReturn {
     chainId: number
     chain: Chain
   }>
+  recover: () => Promise<{
+    txHash: `0x${string}`
+    receipt: TransactionReceipt
+    chainId: number
+  }>
+  getRecoverStatus: (params: {
+    txHash: `0x${string}`
+    chainId: number
+  }) => Promise<{
+    status: "success" | "fail" | "pending"
+  }>
 }
 
 /**
- * Hook for building and signing refund transactions
+ * Hook for building and signing recover transactions
  * @example
  * ```tsx
- * const { signPayload, getRefundTx } = useTrailsRefund({
+ * const { signPayload, getRecoverTx, recover } = useIntentRecover({
  *   intentId: "0x...",
  *   walletClient: walletClient,
  * })
  *
- * const signedHash = await signRefund()
- * const refundTx = await getRefundTx({ signedHash })
- * await walletClient.sendTransaction(refundTx)
+ * // Option 1: Manual flow
+ * const signedHash = await signPayload()
+ * const recoverTx = await getRecoverTx({ signedHash })
+ * await walletClient.sendTransaction(recoverTx)
+ *
+ * // Option 2: Automatic flow (recommended)
+ * const { txHash, receipt, chainId } = await recover()
+ * const status = await getRecoverStatus({ txHash, chainId })
  * ```
  */
-export function useTrailsRefund({
+export function useIntentRecover({
   intentId,
   walletClient,
   refundToAddress,
-}: UseTrailsRefundParams): UseTrailsRefundReturn {
+}: UseIntentRecoverParams): UseIntentRecoverReturn {
   const {
     intent: intentData,
     isLoading: isLoadingIntent,
@@ -620,44 +643,333 @@ export function useTrailsRefund({
     enabled: !!intentId,
   })
 
-  // Get token balances for the intent address
-  const intentAddressForBalances = useMemo<Address.Address | null>(() => {
+  // Get token balances for both origin and destination intent addresses
+  const originIntentAddressForBalances = useMemo<Address.Address | null>(() => {
     if (!intentData?.originIntentAddress) return null
     return Address.from(intentData.originIntentAddress)
   }, [intentData?.originIntentAddress])
 
+  const destinationIntentAddressForBalances =
+    useMemo<Address.Address | null>(() => {
+      if (!intentData?.destinationIntentAddress) return null
+      return Address.from(intentData.destinationIntentAddress)
+    }, [intentData?.destinationIntentAddress])
+
   const {
-    tokenBalancesData,
-    isLoadingBalances,
-    balanceError: balancesError,
-  } = useTokenBalances(intentAddressForBalances)
+    tokenBalancesData: originTokenBalancesData,
+    isLoadingBalances: isLoadingOriginBalances,
+    balanceError: originBalanceError,
+  } = useTokenBalances(originIntentAddressForBalances)
 
-  // Check if intent address has any balance (native or ERC20)
-  const hasIntentBalance = useMemo<boolean>(() => {
-    if (!tokenBalancesData) return false
-
-    // Check native token balances
-    if (tokenBalancesData.nativeBalances) {
-      for (const nativeBalance of tokenBalancesData.nativeBalances) {
-        const balance = BigInt(nativeBalance.balance || "0")
-        if (balance > 0n) {
-          return true
+  const {
+    tokenBalancesData: destinationTokenBalancesData,
+    isLoadingBalances: isLoadingDestinationBalances,
+    balanceError: destinationBalanceError,
+  } = useTokenBalances(destinationIntentAddressForBalances)
+
+  // Get token prices for origin balances
+  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
+  }, [originTokenBalancesData])
+
+  const { tokenPrices: originTokenPrices } = useTokenPrices(
+    originTokensForPricing as any,
+  )
 
-    // Check ERC20 token balances
-    if (tokenBalancesData.balances) {
-      for (const tokenBalance of tokenBalancesData.balances) {
-        const balance = BigInt(tokenBalance.balance || "0")
-        if (balance > 0n) {
-          return true
+  // 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
+  }, [destinationTokenBalancesData])
+
+  const { tokenPrices: destinationTokenPrices } = useTokenPrices(
+    destinationTokensForPricing as any,
+  )
+
+  // Calculate total USD balance for an address
+  const calculateTotalUsdBalance = useCallback(
+    (
+      balancesData:
+        | {
+            nativeBalances?: Array<{
+              balance?: string
+              chainId?: number
+              symbol?: string
+            }>
+            balances?: Array<{
+              balance?: string
+              contractAddress?: string
+              contractInfo?: {
+                decimals?: number
+                chainId?: number
+                symbol?: string
+              }
+            }>
+          }
+        | undefined,
+      tokenPrices:
+        | Array<{
+            token: { chainId: number; tokenAddress: string }
+            priceUsd?: number
+          }>
+        | undefined,
+    ): number => {
+      if (!balancesData || !tokenPrices) return 0
+
+      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 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 &&
+              p.priceUsd !== undefined,
+          )
+          if (priceData?.priceUsd && tokenBalance.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
+          }
+        }
+      }
+
+      return totalUsd
+    },
+    [],
+  )
+
+  // Determine which intent address has the bigger USD balance
+  const selectedIntentAddress = useMemo<{
+    address: Address.Address
+    chainId: number
+    intentAddress: Address.Address
+    tokenBalancesData: typeof originTokenBalancesData
+  } | null>(() => {
+    if (!intentData) return null
+
+    const originTotalUsd = calculateTotalUsdBalance(
+      originTokenBalancesData,
+      originTokenPrices,
+    )
+    const destinationTotalUsd = calculateTotalUsdBalance(
+      destinationTokenBalancesData,
+      destinationTokenPrices,
+    )
+
+    logger.console.log("[recover] Comparing USD balances:", {
+      originAddress: intentData.originIntentAddress,
+      originTotalUsd: `$${originTotalUsd.toFixed(2)}`,
+      destinationAddress: intentData.destinationIntentAddress,
+      destinationTotalUsd: `$${destinationTotalUsd.toFixed(2)}`,
+    })
+
+    // If destination has a bigger USD balance, use it
+    if (
+      destinationIntentAddressForBalances &&
+      destinationTotalUsd > originTotalUsd
+    ) {
+      const chainId = intentData.destinationCalls?.chainId
+      if (!chainId) {
+        logger.console.warn(
+          "[recover] Destination has bigger USD balance but no chainId, using origin",
+        )
+        // Fallback to origin if no destination chainId
+        if (!intentData.originIntentAddress || !originIntentAddressForBalances)
+          return null
+        return {
+          address: originIntentAddressForBalances,
+          chainId: Number(intentData.originCalls?.chainId || 0),
+          intentAddress: Address.from(intentData.originIntentAddress),
+          tokenBalancesData: originTokenBalancesData,
+        }
+      }
+      if (!intentData.destinationIntentAddress) {
+        logger.console.warn(
+          "[recover] Destination has bigger USD balance but no destinationIntentAddress, using origin",
+        )
+        // Fallback to origin if no destinationIntentAddress
+        if (!intentData.originIntentAddress || !originIntentAddressForBalances)
+          return null
+        return {
+          address: originIntentAddressForBalances,
+          chainId: Number(intentData.originCalls?.chainId || 0),
+          intentAddress: Address.from(intentData.originIntentAddress),
+          tokenBalancesData: originTokenBalancesData,
+        }
+      }
+      return {
+        address: destinationIntentAddressForBalances,
+        chainId: Number(chainId),
+        intentAddress: Address.from(intentData.destinationIntentAddress),
+        tokenBalancesData: destinationTokenBalancesData,
+      }
+    }
+
+    // Otherwise use origin (or if destination doesn't exist)
+    if (!intentData.originIntentAddress || !originIntentAddressForBalances)
+      return null
+    return {
+      address: originIntentAddressForBalances,
+      chainId: Number(intentData.originCalls?.chainId || 0),
+      intentAddress: Address.from(intentData.originIntentAddress),
+      tokenBalancesData: originTokenBalancesData,
+    }
+  }, [
+    intentData,
+    originTokenBalancesData,
+    destinationTokenBalancesData,
+    originIntentAddressForBalances,
+    destinationIntentAddressForBalances,
+    originTokenPrices,
+    destinationTokenPrices,
+    calculateTotalUsdBalance,
+  ])
+
+  const isLoadingBalances =
+    isLoadingOriginBalances || isLoadingDestinationBalances
+  const balancesError = originBalanceError || destinationBalanceError
+
+  // 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
+  const hasIntentBalance = useMemo<boolean>(() => {
+    // Helper function to check if balances data has any balance
+    const checkBalances = (
+      balancesData:
+        | {
+            nativeBalances?: Array<{ balance?: string; chainId?: number }>
+            balances?: Array<{
+              balance?: string
+              contractAddress?: string
+              contractInfo?: { decimals?: number; chainId?: number }
+            }>
+          }
+        | 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
+          }
+        }
+      }
+
+      // Check ERC20 token balances
+      if (balancesData.balances) {
+        for (const tokenBalance of balancesData.balances) {
+          const balance = BigInt(tokenBalance.balance || "0")
+          if (balance > 0n) {
+            return true
+          }
+        }
+      }
+
+      return false
+    }
+
+    // Check both origin and destination balances
+    const originHasBalance = checkBalances(originTokenBalancesData)
+    const destinationHasBalance = checkBalances(destinationTokenBalancesData)
 
-    return false
-  }, [tokenBalancesData])
+    return originHasBalance || destinationHasBalance
+  }, [originTokenBalancesData, destinationTokenBalancesData])
 
   // Get refund address (use walletClient account or provided address)
   // Don't throw during render - validate when methods are called
@@ -724,18 +1036,32 @@ export function useTrailsRefund({
       })
     }
 
-    // Determine refund call from token balances
+    // Determine which intent address to recover from (biggest balance)
+    if (!selectedIntentAddress) {
+      throw new Error("No intent address selected for recovery")
+    }
+
+    logger.console.log("[recover] Selected intent address for recovery:", {
+      address: selectedIntentAddress.address,
+      chainId: selectedIntentAddress.chainId,
+      intentAddress: selectedIntentAddress.intentAddress,
+    })
+
+    // Determine refund call from token balances of selected address
     const refundCall = determineRefundCall(
-      tokenBalancesData,
+      selectedIntentAddress.tokenBalancesData,
       effectiveRefundAddress,
     )
 
-    // Get chain ID from origin calls (this is the chain where the refund should execute)
-    const chainId = intentData.originCalls?.chainId
+    // Use chain ID from selected intent address
+    const chainId = selectedIntentAddress.chainId
     if (!chainId) {
-      throw new Error("Chain ID not found in origin calls")
+      throw new Error("Chain ID not found for selected intent address")
     }
-    logger.console.log("[refund] Using chain ID from origin calls:", chainId)
+    logger.console.log(
+      "[recover] Using chain ID from selected intent:",
+      chainId,
+    )
 
     // Switch to the correct chain before signing
     if (walletClient) {
@@ -756,11 +1082,11 @@ export function useTrailsRefund({
       }
     }
 
-    // Get intent address (needed for buildRefundTransactionWithSignature)
-    if (!intentData.originIntentAddress) {
-      throw new Error("Intent data missing originIntentAddress")
+    // Use the selected intent address (biggest balance)
+    if (!selectedIntentAddress) {
+      throw new Error("No intent address selected for recovery")
     }
-    const intentAddress = Address.from(intentData.originIntentAddress)
+    const intentAddress = selectedIntentAddress.intentAddress
 
     // Create payload with random space and calculate hash for signing
     const payload = createRefundPayload(
@@ -783,12 +1109,12 @@ export function useTrailsRefund({
       payload,
       refundCall,
     }
-  }, [intentData, walletClient, tokenBalancesData, effectiveRefundAddress])
+  }, [intentData, walletClient, selectedIntentAddress, effectiveRefundAddress])
 
   // Export as signPayload for the hook return
   const signPayload = signPayloadCallback
 
-  const getRefundTx = useCallback(
+  const getRecoverTx = useCallback(
     async (params: {
       signedHash: string
       payload: Payload.Calls
@@ -847,24 +1173,29 @@ export function useTrailsRefund({
         })
       }
 
+      // Use the selected intent address (biggest balance)
+      if (!selectedIntentAddress) {
+        throw new Error("No intent address selected for recovery")
+      }
+
       // Use the refund call from the payload (passed from signPayload)
       const refundCall = params.payload.calls[0]
       if (!refundCall) {
         throw new Error("Refund call not found in payload")
       }
 
-      // Get chain ID from origin calls (this is the chain where the refund should execute)
-      const chainId = intentData.originCalls?.chainId
+      // Use chain ID from selected intent address
+      const chainId = selectedIntentAddress.chainId
       if (!chainId) {
-        throw new Error("Chain ID not found in origin calls")
+        throw new Error("Chain ID not found for selected intent address")
       }
-      logger.console.log("[refund] Using chain ID from origin calls:", chainId)
+      logger.console.log(
+        "[recover] Using chain ID from selected intent:",
+        chainId,
+      )
 
-      // Get intent address
-      if (!intentData.originIntentAddress) {
-        throw new Error("Intent data missing originIntentAddress")
-      }
-      const intentAddress = Address.from(intentData.originIntentAddress)
+      // Use the selected intent address
+      const intentAddress = selectedIntentAddress.intentAddress
 
       // Build transaction with signature using the payload passed from signPayload
       const mainSigner = walletClient.account.address as Address.Address
@@ -897,7 +1228,180 @@ export function useTrailsRefund({
         chain: chainInfo as Chain,
       }
     },
-    [intentData, walletClient, effectiveRefundAddress],
+    [intentData, walletClient, selectedIntentAddress, effectiveRefundAddress],
+  )
+
+  const recover = useCallback(async (): Promise<{
+    txHash: `0x${string}`
+    receipt: TransactionReceipt
+    chainId: number
+  }> => {
+    if (!intentData || !walletClient || !walletClient.account) {
+      throw new Error("Intent data and wallet client with account required")
+    }
+
+    // Validate refund address
+    if (!effectiveRefundAddress) {
+      throw new Error(
+        "Refund address is required. Provide refundToAddress or connect a wallet with a valid address",
+      )
+    }
+    if (Address.isEqual(effectiveRefundAddress, zeroAddress)) {
+      throw new Error("Refund address cannot be zero address")
+    }
+
+    logger.console.log("[recover] Starting recover process")
+
+    // Step 1: Sign the payload
+    const { signature, payload } = await signPayload()
+    logger.console.log("[recover] Payload signed:", signature)
+
+    // Step 2: Get the recover transaction
+    const recoverTx = await getRecoverTx({
+      signedHash: signature,
+      payload,
+    })
+    logger.console.log("[recover] Recover transaction built:", recoverTx)
+
+    // Step 3: Switch to the correct chain if needed
+    await attemptSwitchChain({
+      walletClient,
+      desiredChainId: recoverTx.chainId,
+    })
+    logger.console.log("[recover] Switched to chain:", recoverTx.chainId)
+
+    // Step 4: Send the transaction
+    if (!walletClient.account) {
+      throw new Error(
+        "Wallet client account is required for sending transaction",
+      )
+    }
+    const txHash = await walletClient.sendTransaction({
+      account: walletClient.account,
+      to: recoverTx.to,
+      data: recoverTx.data,
+      chain: recoverTx.chain,
+    })
+    logger.console.log("[recover] Transaction sent:", txHash)
+
+    // Step 5: Wait for receipt
+    const publicClient = getChainRpcClient(recoverTx.chainId)
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash,
+    })
+    logger.console.log("[recover] Transaction receipt received:", receipt)
+
+    return {
+      txHash,
+      receipt,
+      chainId: recoverTx.chainId,
+    }
+  }, [
+    intentData,
+    walletClient,
+    effectiveRefundAddress,
+    signPayload,
+    getRecoverTx,
+  ])
+
+  const getRecoverStatus = useCallback(
+    async (params: {
+      txHash: `0x${string}`
+      chainId: number
+    }): Promise<{
+      status: "success" | "fail" | "pending"
+    }> => {
+      const { txHash, chainId } = params
+
+      logger.console.log("[recover] Getting recover status:", {
+        txHash,
+        chainId,
+      })
+
+      const publicClient = getChainRpcClient(chainId)
+
+      // First, check if the transaction exists (might be pending)
+      try {
+        const transaction = await publicClient.getTransaction({
+          hash: txHash,
+        })
+
+        // If transaction exists but we can't get receipt, it's pending
+        if (transaction) {
+          try {
+            const receipt = await publicClient.getTransactionReceipt({
+              hash: txHash,
+            })
+
+            // Transaction has been mined, check status
+            // Check if transaction itself failed
+            if (receipt.status === "reverted") {
+              logger.console.log("[recover] Transaction reverted")
+              return { status: "fail" }
+            }
+
+            // Decode events to check for CallFailed events
+            const guestModuleEvents = decodeGuestModuleEvents(receipt)
+            const hasCallFailed = guestModuleEvents.some(
+              (event) => event.type === "CallFailed",
+            )
+
+            if (hasCallFailed) {
+              logger.console.log(
+                "[recover] Found CallFailed events in transaction",
+              )
+              return { status: "fail" }
+            }
+
+            logger.console.log(
+              "[recover] Transaction succeeded with no failures",
+            )
+            return { status: "success" }
+          } catch {
+            // Receipt not available yet, transaction is pending
+            logger.console.log(
+              "[recover] Transaction receipt not available, pending",
+            )
+            return { status: "pending" }
+          }
+        }
+      } catch (error) {
+        // Transaction might not exist yet or there's an error
+        logger.console.warn("[recover] Error getting transaction:", error)
+        // If we can't find the transaction, it might be pending or invalid
+        // Try to get receipt anyway as a fallback
+        try {
+          const receipt = await publicClient.getTransactionReceipt({
+            hash: txHash,
+          })
+
+          if (receipt.status === "reverted") {
+            return { status: "fail" }
+          }
+
+          const guestModuleEvents = decodeGuestModuleEvents(receipt)
+          const hasCallFailed = guestModuleEvents.some(
+            (event) => event.type === "CallFailed",
+          )
+
+          if (hasCallFailed) {
+            return { status: "fail" }
+          }
+
+          return { status: "success" }
+        } catch {
+          // If we can't get receipt either, assume pending
+          logger.console.log(
+            "[recover] Cannot determine status, assuming pending",
+          )
+          return { status: "pending" }
+        }
+      }
+
+      // Fallback: if we can't determine, assume pending
+      return { status: "pending" }
+    },
+    [],
   )
 
   return {
@@ -909,6 +1413,8 @@ export function useTrailsRefund({
     hasIntentBalance,
     refetchIntent,
     signPayload,
-    getRefundTx,
+    getRecoverTx,
+    recover,
+    getRecoverStatus,
   }
 }