0xtrails 0.1.13 → 0.2.0

package/src/widget/hooks/useDefaultTokenSelection.tsx

@@ -0,0 +1,475 @@
+import { createContext, useContext, useMemo } from "react"
+import type { ReactNode } from "react"
+import { useAccount } from "wagmi"
+import type { Address } from "ox"
+import { base, arbitrum } from "viem/chains"
+import { zeroAddress } from "viem"
+import { useWidgetProps } from "./useWidgetProps.js"
+import { useTargetAmount } from "./useTargetAmount.js"
+import { useTokenBalances } from "../../tokenBalances.js"
+import type { TokenBalanceExtended } from "../../tokenBalances.js"
+import { useIndexerGatewayClient } from "../../indexerClient.js"
+import { useSupportedTokens } from "../../tokens.js"
+import { getChainInfo } from "../../chains.js"
+import { logger } from "../../logger.js"
+import { MINIMUM_USD_AMOUNT_FOR_SWAP } from "../../constants.js"
+
+const MINIMUM_24H_VOLUME_USD = 1_000_000 // $1M
+
+/**
+ * Hook for intelligent default token selection in 0xtrails widget.
+ *
+ * When toToken and toChainId are specified (user wants specific destination):
+ * 1. Same-chain, same-token with balance >= targetAmountUsd (no swap, no bridge) - FASTEST
+ * 2. Same-chain, different-token with balance >= targetAmountUsd (swap only) - FAST
+ *    - Ordered by: 24h volume > $1M first, then highest balance USD
+ * 3. Different-chain, same-token with balance >= targetAmountUsd (bridge only) - SLOWER
+ *    - Ordered by: 24h volume > $1M first, then highest balance USD
+ * 4. Different-chain, different-token with balance >= targetAmountUsd (swap + bridge) - SLOWEST
+ *    - Ordered by: 24h volume > $1M first, then highest balance USD
+ * 5. Fallback: Any token with balance > 0 if none can cover target amount
+ *
+ * When toToken/toChainId NOT specified (general send/bridge):
+ * - Select highest balance token with 24h volume > $1M
+ * - Fallback to any token with balance > 0
+ *
+ * Destination Token Logic (only when toToken/toChainId not provided):
+ * - Matches origin token symbol on different chain when possible
+ * - Default destination chain: Base (unless origin is Base, then Arbitrum)
+ * - Fallback priority: USDC > ETH > first available token
+ *
+ * @returns defaultOriginToken - Best origin token that can cover targetAmountUsd (if specified)
+ * @returns defaultDestinationToken - Matching token on different chain (null if toToken/toChainId set)
+ * @returns isLoading - Whether token data is still loading
+ */
+export interface DefaultToken {
+  id: number
+  name: string
+  symbol: string
+  balance: string
+  imageUrl: string
+  chainId: number
+  contractAddress: string
+  balanceUsdFormatted: string
+  tokenPriceUsd: number
+  decimals: number // Top-level decimals for compatibility
+  contractInfo?: {
+    decimals: number
+    symbol: string
+    name: string
+  }
+}
+
+export interface UseDefaultTokenSelectionReturn {
+  defaultOriginToken: DefaultToken | null
+  defaultDestinationToken: DefaultToken | null
+  isLoading: boolean
+}
+
+function getToken24hVolume(token: TokenBalanceExtended): number {
+  const price = token.price as any
+  if (!price) return 0
+
+  return Number(
+    price.price24hVol?.value ||
+      price.volume24h ||
+      price.volume_24h ||
+      price.vol24h ||
+      price.dailyVolume ||
+      0,
+  )
+}
+
+function tokenMatches(
+  token: TokenBalanceExtended,
+  targetSymbolOrAddress: string,
+  targetChainId?: number,
+): boolean {
+  const isNative =
+    !("contractAddress" in token) || token.contractAddress === zeroAddress
+
+  // Check chain match first
+  const chainMatches = !targetChainId || token.chainId === targetChainId
+  if (!chainMatches) return false
+
+  // Check if target is an address (starts with 0x and is longer than 5 chars)
+  const isTargetAddress =
+    targetSymbolOrAddress.startsWith("0x") && targetSymbolOrAddress.length > 5
+
+  if (isNative) {
+    const chainInfo = getChainInfo(token.chainId)
+    const nativeSymbol = chainInfo?.nativeCurrency.symbol || "ETH"
+
+    // For native tokens, check if target is zero address or matches symbol
+    if (isTargetAddress) {
+      return targetSymbolOrAddress.toLowerCase() === zeroAddress.toLowerCase()
+    }
+
+    return nativeSymbol.toUpperCase() === targetSymbolOrAddress.toUpperCase()
+  }
+
+  // For non-native tokens, check both address and symbol
+  if (isTargetAddress) {
+    return (
+      token.contractAddress.toLowerCase() ===
+      targetSymbolOrAddress.toLowerCase()
+    )
+  }
+
+  return (
+    token.contractInfo?.symbol.toUpperCase() ===
+    targetSymbolOrAddress.toUpperCase()
+  )
+}
+
+function useDefaultTokenSelectionInternal(): UseDefaultTokenSelectionReturn {
+  const { toToken, toChainId } = useWidgetProps()
+  const { targetAmountUsd } = useTargetAmount()
+  const { address } = useAccount()
+  const indexerGatewayClient = useIndexerGatewayClient()
+
+  const { sortedTokens, isLoadingSortedTokens } = useTokenBalances(
+    address as Address.Address,
+    indexerGatewayClient,
+  )
+
+  const { supportedTokens, isLoadingTokens: isLoadingSupportedTokens } =
+    useSupportedTokens()
+
+  const isLoading = isLoadingSortedTokens || isLoadingSupportedTokens
+
+  const { defaultOriginToken, defaultDestinationToken } = useMemo(() => {
+    if (!sortedTokens?.length || !supportedTokens?.length) {
+      return {
+        defaultOriginToken: null,
+        defaultDestinationToken: null,
+      }
+    }
+
+    // Determine if we should compute destination token
+    // Only compute destination defaults if toToken and toChainId are NOT set
+    const shouldComputeDestination = !toToken && !toChainId
+
+    // Helper to convert TokenBalanceExtended to DefaultToken
+    const toDefaultToken = (
+      token: TokenBalanceExtended,
+    ): DefaultToken | null => {
+      const isNative =
+        !("contractAddress" in token) || token.contractAddress === zeroAddress
+      const chainInfo = getChainInfo(token.chainId)
+
+      if (isNative) {
+        // Native tokens - use token properties as-is
+        const tokenWithInfo = token as any
+        const imageUrl = tokenWithInfo.logoURI || tokenWithInfo.imageUrl || ""
+        const decimals = 18
+
+        return {
+          id: token.chainId,
+          name: chainInfo?.nativeCurrency.name || "Native Token",
+          symbol: chainInfo?.nativeCurrency.symbol || "ETH",
+          balance: token.balance,
+          imageUrl,
+          chainId: token.chainId,
+          contractAddress: zeroAddress,
+          balanceUsdFormatted: token.balanceUsdFormatted ?? "0",
+          tokenPriceUsd: token.price?.value ?? 0,
+          decimals, // Top-level decimals
+          contractInfo: {
+            decimals,
+            symbol: chainInfo?.nativeCurrency.symbol || "ETH",
+            name: chainInfo?.nativeCurrency.name || "Native Token",
+          },
+        }
+      } else {
+        // Non-native tokens - use contractInfo properties
+        const tokenWithInfo = token as any
+        const imageUrl =
+          tokenWithInfo.contractInfo?.logoURI || tokenWithInfo.imageUrl || ""
+        const decimals = token.contractInfo?.decimals
+        if (!decimals) {
+          throw new Error("Decimals not found")
+        }
+
+        return {
+          id: token.chainId,
+          name: token.contractInfo?.name || "Unknown Token",
+          symbol: token.contractInfo?.symbol || "???",
+          balance: token.balance,
+          imageUrl,
+          chainId: token.chainId,
+          contractAddress: token.contractAddress,
+          balanceUsdFormatted: token.balanceUsdFormatted ?? "0",
+          tokenPriceUsd: token.price?.value ?? 0,
+          decimals, // Top-level decimals
+          contractInfo: {
+            decimals,
+            symbol: token.contractInfo?.symbol ?? "???",
+            name: token.contractInfo?.name ?? "Unknown Token",
+          },
+        }
+      }
+    }
+
+    // Filter tokens with balance > 0
+    const tokensWithBalance = sortedTokens.filter((token) => {
+      const balanceUsd = token.balanceUsd ?? 0
+      return balanceUsd > 0
+    })
+
+    if (tokensWithBalance.length === 0) {
+      logger.console.log(
+        "[trails-sdk] No tokens with balance found for default selection",
+      )
+      return {
+        defaultOriginToken: null,
+        defaultDestinationToken: null,
+      }
+    }
+
+    // Helper to sort tokens by balance USD and volume
+    const sortTokensByBalanceAndVolume = (tokens: TokenBalanceExtended[]) => {
+      return [...tokens].sort((a, b) => {
+        const aVolume = getToken24hVolume(a)
+        const bVolume = getToken24hVolume(b)
+        const aHighVolume = aVolume >= MINIMUM_24H_VOLUME_USD
+        const bHighVolume = bVolume >= MINIMUM_24H_VOLUME_USD
+
+        // Prioritize high volume tokens first
+        if (aHighVolume && !bHighVolume) return -1
+        if (!aHighVolume && bHighVolume) return 1
+
+        // Then sort by balance USD (highest first)
+        const aBalanceUsd = a.balanceUsd ?? 0
+        const bBalanceUsd = b.balanceUsd ?? 0
+        return bBalanceUsd - aBalanceUsd
+      })
+    }
+
+    // Find the best origin token using intelligent selection
+    let bestOriginToken: TokenBalanceExtended | null = null
+
+    // When toToken and toChainId are specified (user wants specific destination)
+    if (toToken && toChainId) {
+      const targetChainId = Number(toChainId)
+
+      // Use targetAmountUsd if available, otherwise use minimum amount for swap when toToken is set
+      const effectiveTargetAmount =
+        targetAmountUsd ?? Number(MINIMUM_USD_AMOUNT_FOR_SWAP)
+
+      // Filter tokens that can cover the target amount
+      const tokensWithSufficientBalance = tokensWithBalance.filter(
+        (token) => (token.balanceUsd ?? 0) >= effectiveTargetAmount,
+      )
+
+      // Priority 1: Same-chain, same-token (no swap, no bridge) - FASTEST
+      const sameChainSameToken = tokensWithSufficientBalance.find((token) =>
+        tokenMatches(token, toToken, targetChainId),
+      )
+
+      if (sameChainSameToken) {
+        bestOriginToken = sameChainSameToken
+        logger.console.log(
+          "[trails-sdk] Selected same-chain, same-token (fastest)",
+        )
+      }
+
+      // Priority 2: Same-chain, different-token (swap only, no bridge) - FAST
+      if (!bestOriginToken) {
+        const sameChainTokens = tokensWithSufficientBalance.filter(
+          (token) => token.chainId === targetChainId,
+        )
+        const sortedSameChain = sortTokensByBalanceAndVolume(sameChainTokens)
+        bestOriginToken = sortedSameChain[0] ?? null
+        if (bestOriginToken) {
+          logger.console.log(
+            "[trails-sdk] Selected same-chain, different-token (fast)",
+          )
+        }
+      }
+
+      // Priority 3: Different-chain, same-token (bridge only, no swap) - SLOWER
+      if (!bestOriginToken) {
+        const sameTokenDiffChain = tokensWithSufficientBalance.filter(
+          (token) =>
+            tokenMatches(token, toToken) && token.chainId !== targetChainId,
+        )
+        const sortedSameToken = sortTokensByBalanceAndVolume(sameTokenDiffChain)
+        bestOriginToken = sortedSameToken[0] ?? null
+        if (bestOriginToken) {
+          logger.console.log(
+            "[trails-sdk] Selected different-chain, same-token (slower)",
+          )
+        }
+      }
+
+      // Priority 4: Different-chain, different-token (swap + bridge) - SLOWEST
+      if (!bestOriginToken) {
+        const diffChainDiffToken = tokensWithSufficientBalance.filter(
+          (token) => token.chainId !== targetChainId,
+        )
+        const sortedDiffChainDiffToken =
+          sortTokensByBalanceAndVolume(diffChainDiffToken)
+        bestOriginToken = sortedDiffChainDiffToken[0] ?? null
+        if (bestOriginToken) {
+          logger.console.log(
+            "[trails-sdk] Selected different-chain, different-token (slowest)",
+          )
+        }
+      }
+
+      // Fallback: If no token can cover target amount, use any token (sorted by balance/volume)
+      if (!bestOriginToken) {
+        const allTokensSorted = sortTokensByBalanceAndVolume(tokensWithBalance)
+        bestOriginToken = allTokensSorted[0] ?? null
+        logger.console.log(
+          "[trails-sdk] Fallback: No token can cover target amount, using highest balance token",
+        )
+      }
+    } else {
+      // When no specific destination is set, select highest value token with good liquidity
+      const sortedByBalanceAndVolume =
+        sortTokensByBalanceAndVolume(tokensWithBalance)
+      bestOriginToken = sortedByBalanceAndVolume[0] ?? null
+      logger.console.log(
+        "[trails-sdk] No destination specified, selected highest value token with best liquidity",
+      )
+    }
+
+    if (!bestOriginToken) {
+      return {
+        defaultOriginToken: null,
+        defaultDestinationToken: null,
+      }
+    }
+
+    const originToken = toDefaultToken(bestOriginToken)
+
+    if (!originToken) {
+      return {
+        defaultOriginToken: null,
+        defaultDestinationToken: null,
+      }
+    }
+
+    // Compute destination token only when toToken and toChainId are not provided
+    let destinationToken: DefaultToken | null = null
+
+    if (shouldComputeDestination) {
+      // Determine default destination chain: Base if origin is not Base, Arbitrum if origin is Base
+      const defaultDestChainId =
+        originToken.chainId === base.id ? arbitrum.id : base.id
+
+      // Find matching token on destination chain (prefer same symbol)
+      const destChainTokens = supportedTokens.filter(
+        (token: any) => token.chainId === defaultDestChainId,
+      )
+
+      let destToken: any = null
+
+      // Try to find same symbol on dest chain
+      const sameSymbolToken = destChainTokens.find((token: any) => {
+        return token.symbol.toUpperCase() === originToken.symbol.toUpperCase()
+      })
+
+      if (sameSymbolToken) {
+        destToken = sameSymbolToken
+      } else {
+        // Fallback: USDC > ETH > first available token
+        destToken =
+          destChainTokens.find((token: any) => token.symbol === "USDC") ||
+          destChainTokens.find((token: any) => token.symbol === "ETH") ||
+          destChainTokens[0]
+      }
+
+      const decimals = destToken?.decimals
+      if (!decimals) {
+        throw new Error("Decimals not found")
+      }
+
+      destinationToken = destToken
+        ? {
+            id: destToken.chainId,
+            name: destToken.name,
+            symbol: destToken.symbol,
+            balance: "0", // Destination token doesn't have balance yet
+            imageUrl: destToken.imageUrl || "",
+            chainId: destToken.chainId,
+            contractAddress: destToken.contractAddress || zeroAddress,
+            balanceUsdFormatted: "0",
+            tokenPriceUsd: 0,
+            decimals, // Top-level decimals
+            contractInfo: {
+              decimals,
+              symbol: destToken.symbol,
+              name: destToken.name,
+            },
+          }
+        : null
+    }
+
+    logger.console.log("[trails-sdk] Default token selection:", {
+      origin: originToken
+        ? {
+            symbol: originToken.symbol,
+            chainId: originToken.chainId,
+            balanceUsd: originToken.balanceUsdFormatted,
+            volume24h: getToken24hVolume(bestOriginToken),
+          }
+        : null,
+      destination: destinationToken
+        ? {
+            symbol: destinationToken.symbol,
+            chainId: destinationToken.chainId,
+          }
+        : null,
+      shouldComputeDestination,
+      toToken,
+      toChainId,
+      targetAmountUsd,
+      effectiveTargetAmount:
+        toToken && toChainId
+          ? (targetAmountUsd ?? Number(MINIMUM_USD_AMOUNT_FOR_SWAP))
+          : null,
+    })
+
+    return {
+      defaultOriginToken: originToken,
+      defaultDestinationToken: destinationToken,
+    }
+  }, [toToken, toChainId, sortedTokens, supportedTokens, targetAmountUsd])
+
+  return {
+    defaultOriginToken,
+    defaultDestinationToken,
+    isLoading,
+  }
+}
+
+// Context for sharing default token selection across components
+const DefaultTokenSelectionContext =
+  createContext<UseDefaultTokenSelectionReturn | null>(null)
+
+export function DefaultTokenSelectionProvider({
+  children,
+}: {
+  children: ReactNode
+}) {
+  const value = useDefaultTokenSelectionInternal()
+
+  return (
+    <DefaultTokenSelectionContext.Provider value={value}>
+      {children}
+    </DefaultTokenSelectionContext.Provider>
+  )
+}
+
+export function useDefaultTokenSelection(): UseDefaultTokenSelectionReturn {
+  const context = useContext(DefaultTokenSelectionContext)
+  if (!context) {
+    throw new Error(
+      "useDefaultTokenSelection must be used within a DefaultTokenSelectionProvider",
+    )
+  }
+  return context
+}

package/src/widget/hooks/useIntentTransactionHistory.ts

@@ -1,10 +1,12 @@
 import { useState, useEffect, useCallback } from "react"
 import {
   getIntentTransactionHistory,
+  getAccountTransactionHistory,
   type IntentTransaction,
   type IntentTransactionHistoryResponse,
 } from "../../transactions.js"
 import { getTokenInfo, getSupportedTokens } from "../../tokens.js"
+import { getExplorerUrl } from "../../explorer.js"
 import { logger } from "../../logger.js"
 
 export type UseIntentTransactionHistoryParams = {
@@ -241,10 +243,220 @@ export function useIntentTransactionHistory({
               }
             }
 
+            // Check if origin and destination are the same
+            const isSameIntentAddress =
+              transaction.originIntentAddress?.toLowerCase() ===
+                transaction.destinationIntentAddress?.toLowerCase() &&
+              transaction.originChainId === transaction.destinationChainId
+
+            // Fetch intent wallet transaction hashes
+            let originIntentTxHash: string | undefined
+            let destinationIntentTxHash: string | undefined
+            let originIntentTxExplorerUrl: string | undefined
+            let destinationIntentTxExplorerUrl: string | undefined
+            let originIntentDepositTxHash: string | undefined
+            let destinationIntentDepositTxHash: string | undefined
+            let originIntentDepositTxExplorerUrl: string | undefined
+            let destinationIntentDepositTxExplorerUrl: string | undefined
+
+            // Get origin intent transaction hashes (both deposit and action)
+            if (transaction.originIntentAddress && transaction.originChainId) {
+              try {
+                const originHistory = await getAccountTransactionHistory({
+                  chainId: transaction.originChainId,
+                  accountAddress: transaction.originIntentAddress,
+                  pageSize: 10, // Fetch more to find both deposit and action txs
+                  page: 0,
+                  includeMetadata: true, // Need metadata to check transfer direction
+                })
+                if (
+                  originHistory?.transactions &&
+                  originHistory.transactions.length > 0
+                ) {
+                  const intentAddress =
+                    transaction.originIntentAddress.toLowerCase()
+
+                  // Find first deposit tx (transfer TO intent address)
+                  const depositTx = originHistory.transactions.find((tx) =>
+                    tx.transfers?.some(
+                      (transfer) => transfer.to.toLowerCase() === intentAddress,
+                    ),
+                  )
+                  if (depositTx) {
+                    originIntentDepositTxHash = depositTx.txnHash
+                    originIntentDepositTxExplorerUrl = getExplorerUrl({
+                      txHash: depositTx.txnHash,
+                      chainId: transaction.originChainId,
+                    })
+                  }
+
+                  // Find first action tx (transfer FROM intent address)
+                  const actionTx = originHistory.transactions.find((tx) =>
+                    tx.transfers?.some(
+                      (transfer) =>
+                        transfer.from.toLowerCase() === intentAddress,
+                    ),
+                  )
+                  if (actionTx) {
+                    originIntentTxHash = actionTx.txnHash
+                    originIntentTxExplorerUrl = getExplorerUrl({
+                      txHash: actionTx.txnHash,
+                      chainId: transaction.originChainId,
+                    })
+                  }
+                }
+              } catch (error) {
+                logger.console.warn(
+                  "[trails-sdk] Failed to get origin intent transaction hashes for:",
+                  transaction.originIntentAddress,
+                  "on chain",
+                  transaction.originChainId,
+                  error,
+                )
+              }
+            }
+
+            // Get destination intent transaction hashes (only if different from origin)
+            if (
+              !isSameIntentAddress &&
+              transaction.destinationIntentAddress &&
+              transaction.destinationChainId
+            ) {
+              try {
+                const destinationHistory = await getAccountTransactionHistory({
+                  chainId: transaction.destinationChainId,
+                  accountAddress: transaction.destinationIntentAddress,
+                  pageSize: 10, // Fetch more to find both deposit and action txs
+                  page: 0,
+                  includeMetadata: true, // Need metadata to check transfer direction
+                })
+                if (
+                  destinationHistory?.transactions &&
+                  destinationHistory.transactions.length > 0
+                ) {
+                  const intentAddress =
+                    transaction.destinationIntentAddress.toLowerCase()
+
+                  // Find first deposit tx (transfer TO intent address)
+                  const depositTx = destinationHistory.transactions.find((tx) =>
+                    tx.transfers?.some(
+                      (transfer) => transfer.to.toLowerCase() === intentAddress,
+                    ),
+                  )
+                  if (depositTx) {
+                    destinationIntentDepositTxHash = depositTx.txnHash
+                    destinationIntentDepositTxExplorerUrl = getExplorerUrl({
+                      txHash: depositTx.txnHash,
+                      chainId: transaction.destinationChainId,
+                    })
+                  }
+
+                  // Find first action tx (transfer FROM intent address)
+                  const actionTx = destinationHistory.transactions.find((tx) =>
+                    tx.transfers?.some(
+                      (transfer) =>
+                        transfer.from.toLowerCase() === intentAddress,
+                    ),
+                  )
+                  if (actionTx) {
+                    destinationIntentTxHash = actionTx.txnHash
+                    destinationIntentTxExplorerUrl = getExplorerUrl({
+                      txHash: actionTx.txnHash,
+                      chainId: transaction.destinationChainId,
+                    })
+                  }
+                }
+              } catch (error) {
+                logger.console.warn(
+                  "[trails-sdk] Failed to get destination intent transaction hashes for:",
+                  transaction.destinationIntentAddress,
+                  "on chain",
+                  transaction.destinationChainId,
+                  error,
+                )
+              }
+            }
+
+            // Calculate effective execution status
+            const getEffectiveStatus = (): string => {
+              const {
+                executionStatus,
+                originChainId,
+                destinationChainId,
+                originIntentAddress,
+                destinationIntentAddress,
+                createdAt,
+              } = transaction
+
+              // Check if this is a same-chain transaction (same address and chain)
+              const isSameChain =
+                originIntentAddress?.toLowerCase() ===
+                  destinationIntentAddress?.toLowerCase() &&
+                originChainId === destinationChainId
+
+              // Check if there's no destination (same-chain or no destination intent)
+              const hasNoDestination =
+                !destinationIntentAddress || !destinationChainId || isSameChain
+
+              // Check if it's been over 5 minutes since creation
+              const isOver5Minutes = createdAt
+                ? Date.now() - new Date(createdAt).getTime() > 5 * 60 * 1000
+                : false
+
+              // Rule 1: If there's a destination intent tx, it's completed
+              if (destinationIntentTxHash) {
+                return "completed"
+              }
+
+              // Rule 2: Only origin tx hash exists and no real destination (same-chain case)
+              if (originIntentTxHash && originChainId && hasNoDestination) {
+                return "completed"
+              }
+
+              // Rule 3: If there's a deposit but no action yet, status is pending
+              if (originIntentDepositTxHash && !originIntentTxHash) {
+                return "pending"
+              }
+
+              // Rule 4: Cross-chain with origin tx but no destination tx
+              // If over 5 minutes, consider it failed; otherwise pending
+              if (
+                originIntentTxHash &&
+                !destinationIntentTxHash &&
+                originChainId &&
+                destinationChainId &&
+                !isSameChain &&
+                destinationIntentAddress
+              ) {
+                return isOver5Minutes ? "failed" : "pending"
+              }
+
+              // Otherwise, use the original execution status
+              return executionStatus || "unknown"
+            }
+
+            const effectiveExecutionStatus = getEffectiveStatus()
+
+            // If same intent address, omit destination address/chain to avoid duplication
             return {
               ...transaction,
+              ...(isSameIntentAddress
+                ? {
+                    destinationIntentAddress: "",
+                    destinationChainId: undefined,
+                  }
+                : {}),
               originToken,
               destinationToken,
+              originIntentTxHash,
+              destinationIntentTxHash,
+              originIntentTxExplorerUrl,
+              destinationIntentTxExplorerUrl,
+              originIntentDepositTxHash,
+              destinationIntentDepositTxHash,
+              originIntentDepositTxExplorerUrl,
+              destinationIntentDepositTxExplorerUrl,
+              executionStatus: effectiveExecutionStatus,
             }
           }),
         )