0xtrails 0.9.2 → 0.9.4

package/src/transactionIntent/handlers/crossChain.ts

@@ -212,6 +212,7 @@ export async function handleCrossChain({
       destinationTokenSymbol,
       feeTokenSymbol: originTokenSymbol,
     },
+    abortSignal,
   )
   logger.console.log("[trails-sdk] Quote intent:", intent)
   logger.console.log("[trails-sdk] Quote intent gasFeeOptions:", gasFeeOptions)
@@ -687,6 +688,8 @@ export async function handleCrossChain({
             abortSignal,
             intentId: intent.intentId,
             executeIntentFn,
+            sequenceProjectAccessKey,
+            sequenceIndexerUrl,
           })
 
           // In gasless mode, depositUserTxnReceipt will be null because the transaction
@@ -817,6 +820,9 @@ export async function handleCrossChain({
         }
 
         const checkForDepositTx = async () => {
+          let consecutiveErrors = 0
+          const maxConsecutiveErrors = 5
+
           while (true) {
             // Check if we should abort
             if (abortSignal?.aborted) {
@@ -827,120 +833,129 @@ export async function handleCrossChain({
             }
 
             try {
-              if (!sequenceIndexerUrl) {
-                throw new Error("sequenceIndexerUrl is required")
-              }
-              const response = await getAccountTransactionHistory({
-                chainId: originChainId,
-                accountAddress: originIntentAddress,
-                abortSignal,
-                apiKey: sequenceProjectAccessKey!,
-                indexerUrl: sequenceIndexerUrl,
+              // First try balance check as primary method
+              const balanceCheck = await checkAccountBalance({
+                account: {
+                  address: originIntentAddress as `0x${string}`,
+                } as Account,
+                tokenAddress: originTokenAddress,
+                depositAmount: quote.originAmount,
+                publicClient: publicClient,
               })
-              logger.console.log(
-                "[trails-sdk] getAccountTransactionHistory response",
-                response,
-              )
-              if (response.transactions.length > 0) {
-                const tx = response.transactions[0]
-                if (!tx?.txnHash) {
-                  await new Promise((resolve) =>
-                    setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
-                  )
-                  continue
-                }
-                // const isReceive = tx.transfers.some(
-                //   (transfer) => transfer.transferType === "RECEIVE",
-                // )
-                // if (!isReceive) {
-                //   await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY))
-                //   continue
-                // }
-                const originDepositTxReceipt =
-                  await publicClient.getTransactionReceipt({
-                    hash: tx.txnHash as `0x${string}`,
-                  })
 
-                // Validate that the deposit amount is sufficient before proceeding
+              if (balanceCheck.hasEnoughBalance) {
                 logger.console.log(
-                  "[trails-sdk] Checking if deposit amount is sufficient (cross-chain)",
+                  "[trails-sdk] Deposit detected via balance check (QR/exchange mode)",
                   {
-                    depositAddress: originIntentAddress,
-                    requiredAmount: quote.originAmount,
-                    tokenAddress: originTokenAddress,
+                    balance: balanceCheck.balanceFormatted,
+                    required: balanceCheck.requiredAmountFormatted,
                   },
                 )
 
-                const balanceCheck = await checkAccountBalance({
-                  account: {
-                    address: originIntentAddress as `0x${string}`,
-                  } as Account,
-                  tokenAddress: originTokenAddress,
-                  depositAmount: quote.originAmount,
-                  publicClient: publicClient,
-                })
+                // Try to find the actual transaction via indexer
+                if (sequenceIndexerUrl && sequenceProjectAccessKey) {
+                  try {
+                    const response = await getAccountTransactionHistory({
+                      chainId: originChainId,
+                      accountAddress: originIntentAddress,
+                      abortSignal,
+                      apiKey: sequenceProjectAccessKey,
+                      indexerUrl: sequenceIndexerUrl,
+                    })
 
-                if (!balanceCheck.hasEnoughBalance) {
-                  logger.console.warn(
-                    "[trails-sdk] Deposit amount is insufficient, continuing to poll (cross-chain)",
-                    {
-                      balance: balanceCheck.balanceFormatted,
-                      required: balanceCheck.requiredAmountFormatted,
-                      percentComplete: (
-                        (Number(balanceCheck.balance) /
-                          Number(balanceCheck.requiredAmount)) *
-                        100
-                      ).toFixed(2),
-                    },
-                  )
-                  // Continue polling - don't break out of the loop yet
-                  await new Promise((resolve) =>
-                    setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
-                  )
-                  continue
+                    if (response.transactions.length > 0) {
+                      const tx = response.transactions[0]
+                      if (tx?.txnHash) {
+                        depositUserTxnReceipt =
+                          await publicClient.getTransactionReceipt({
+                            hash: tx.txnHash as `0x${string}`,
+                          })
+
+                        transactionStates[0] = getTransactionStateFromReceipt(
+                          depositUserTxnReceipt,
+                          originChainId,
+                          transactionStates[0]?.label,
+                        )
+                        onTransactionStateChange(transactionStates)
+                        if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
+                          checkoutOnHandlers.triggerCheckoutStatusUpdate(
+                            transactionStates,
+                          )
+                        }
+
+                        // Call executeIntent after deposit detection
+                        if (
+                          depositUserTxnReceipt.status === "success" &&
+                          intent.intentId &&
+                          !executeIntentCalled
+                        ) {
+                          logger.console.log(
+                            "[trails-sdk] Calling executeIntent after deposit detection",
+                          )
+                          try {
+                            const executeIntentFnToUse =
+                              executeIntentFn ||
+                              trailsClient.executeIntent.bind(trailsClient)
+                            await executeIntentFnToUse({
+                              intentId: intent.intentId,
+                              depositTransactionHash:
+                                depositUserTxnReceipt.transactionHash,
+                            })
+                            executeIntentCalled = true
+                            if (!unifiedPollerPromise) {
+                              startUnifiedPolling()
+                            }
+                          } catch (error) {
+                            logger.console.error(
+                              "[trails-sdk] Error calling executeIntent:",
+                              error,
+                            )
+                          }
+                        }
+
+                        if (onOriginSend) {
+                          onOriginSend()
+                        }
+                        break
+                      }
+                    }
+                  } catch (indexerError) {
+                    logger.console.debug(
+                      "[trails-sdk] Indexer failed but balance is sufficient, proceeding",
+                      { error: (indexerError as Error)?.message },
+                    )
+                  }
                 }
 
+                // Even without tx hash, we know deposit happened
+                // Set a flag that deposit was detected but we'll need to poll for the actual tx
                 logger.console.log(
-                  "[trails-sdk] Deposit amount is sufficient, proceeding (cross-chain)",
-                  {
-                    balance: balanceCheck.balanceFormatted,
-                    required: balanceCheck.requiredAmountFormatted,
-                  },
+                  "[trails-sdk] Balance detected but no transaction hash - proceeding with intent execution",
                 )
 
-                depositUserTxnReceipt = originDepositTxReceipt
-
-                transactionStates[0] = getTransactionStateFromReceipt(
-                  originDepositTxReceipt,
-                  originChainId,
-                  transactionStates[0]?.label,
-                )
+                // Don't create a fake receipt - just mark that we detected funds
+                depositUserTxnReceipt = null
+
+                // Update state to show deposit detected (but without fake hash)
+                transactionStates[0] = {
+                  ...transactionStates[0],
+                  state: "pending",
+                  transactionHash: "", // Empty string instead of undefined for type compatibility
+                  explorerUrl: transactionStates[0]?.explorerUrl || "",
+                  chainId: transactionStates[0]?.chainId || originChainId,
+                  label: transactionStates[0]?.label || "Deposit detected",
+                }
                 onTransactionStateChange(transactionStates)
-                // Also trigger checkout status update if handler is provided
                 if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
                   checkoutOnHandlers.triggerCheckoutStatusUpdate(
                     transactionStates,
                   )
                 }
 
-                // Call executeIntent after detecting deposit transaction (for QR code and exchange modes)
-                // This triggers the backend to start executing the intent
-                // Must be called BEFORE waitIntentReceipt polling starts
-                // For onramp-meld, executeIntent was already called after commitIntent
-                if (
-                  originDepositTxReceipt.status === "success" &&
-                  intent.intentId &&
-                  (fundMethod === "qr-code" ||
-                    fundMethod === "onramp-exchange") &&
-                  !executeIntentCalled
-                ) {
+                // Call executeIntent with balance-based detection
+                if (intent.intentId && !executeIntentCalled) {
                   logger.console.log(
-                    "[trails-sdk] Calling executeIntent with detected deposit transaction hash (external funding mode)",
-                    {
-                      intentId: intent.intentId,
-                      txHash: originDepositTxReceipt.transactionHash,
-                      fundMethod,
-                    },
+                    "[trails-sdk] Calling executeIntent after balance-based deposit detection",
                   )
                   try {
                     const executeIntentFnToUse =
@@ -948,24 +963,15 @@ export async function handleCrossChain({
                       trailsClient.executeIntent.bind(trailsClient)
                     await executeIntentFnToUse({
                       intentId: intent.intentId,
-                      depositTransactionHash:
-                        originDepositTxReceipt.transactionHash,
+                      // Note: No depositTransactionHash available in this case
                     })
                     executeIntentCalled = true
-                    logger.console.log(
-                      "[trails-sdk] executeIntent completed successfully (QR code mode)",
-                    )
-
-                    // Now that executeIntent has been called, start unified polling if not already started
                     if (!unifiedPollerPromise) {
-                      logger.console.log(
-                        "[trails-sdk] Starting unified polling after executeIntent (QR code mode)",
-                      )
                       startUnifiedPolling()
                     }
                   } catch (error) {
                     logger.console.error(
-                      "[trails-sdk] Error calling executeIntent (QR code mode):",
+                      "[trails-sdk] Error calling executeIntent:",
                       error,
                     )
                   }
@@ -976,9 +982,50 @@ export async function handleCrossChain({
                 }
                 break
               }
+
+              // If sequenceIndexerUrl is available, also try the indexer as backup
+              if (sequenceIndexerUrl && sequenceProjectAccessKey) {
+                try {
+                  const _response = await getAccountTransactionHistory({
+                    chainId: originChainId,
+                    accountAddress: originIntentAddress,
+                    abortSignal,
+                    apiKey: sequenceProjectAccessKey,
+                    indexerUrl: sequenceIndexerUrl,
+                  })
+
+                  // Original indexer-based logic continues here...
+                  // (keeping the existing logic for when balance check doesn't pass)
+                } catch (indexerError) {
+                  logger.console.debug(
+                    "[trails-sdk] Indexer check failed, relying on balance check",
+                    { error: (indexerError as Error)?.message },
+                  )
+                }
+              }
+
+              // Reset consecutive errors on successful iteration
+              consecutiveErrors = 0
             } catch (error) {
-              logger.console.error("Error checking for deposit tx", error)
+              consecutiveErrors++
+              logger.console.error(
+                "[trails-sdk] Error checking for deposit tx",
+                {
+                  error,
+                  consecutiveErrors,
+                  maxConsecutiveErrors,
+                },
+              )
+
+              if (consecutiveErrors >= maxConsecutiveErrors) {
+                logger.console.error(
+                  "[trails-sdk] Max consecutive errors reached in deposit polling, continuing anyway",
+                )
+                // Don't break - continue polling as transaction might still go through
+                consecutiveErrors = 0 // Reset counter to keep trying
+              }
             }
+
             await new Promise((resolve) =>
               setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
             )

package/src/transactionIntent/handlers/sameChainSameToken.ts

@@ -536,6 +536,7 @@ export async function handleSameChainSameToken({
       destinationTokenSymbol,
       feeTokenSymbol: originTokenSymbol,
     },
+    abortSignal,
   )
 
   logger.console.log("[trails-sdk] Quote intent:", intent)

package/src/transactionIntent/quote/normalizeQuote.ts

@@ -238,18 +238,19 @@ export async function getNormalizedQuoteObject({
 
   // Calculate exchange rates using server-derived prices when available
   // This ensures consistency with server-provided USD amounts (fromAmountUsd, toAmountUsd)
+  // Uses != null checks to handle 0 values correctly (not truthy checks)
   const originTokenPrice =
-    intent?.quote?.fromAmountUsd && intent?.quote?.fromAmount
+    intent?.quote?.fromAmountUsd != null && intent?.quote?.fromAmount != null
       ? intent.quote.fromAmountUsd /
         Number(formatUnits(intent.quote.fromAmount, originToken.decimals))
-      : originTokenPriceUsd
+      : originTokenPriceUsd != null
         ? Number(originTokenPriceUsd)
         : 0
   const destinationTokenPrice =
-    intent?.quote?.toAmountUsd && intent?.quote?.toAmount
+    intent?.quote?.toAmountUsd != null && intent?.quote?.toAmount != null
       ? intent.quote.toAmountUsd /
         Number(formatUnits(intent.quote.toAmount, destinationToken.decimals))
-      : destinationTokenPriceUsd
+      : destinationTokenPriceUsd != null
         ? Number(destinationTokenPriceUsd)
         : 0
   const exchangeRates = getTokenExchangeRates(
@@ -373,6 +374,8 @@ export async function getNormalizedQuoteObject({
     gasCostFormatted,
     originTokenRate: exchangeRates.originTokenRate,
     destinationTokenRate: exchangeRates.destinationTokenRate,
+    originTokenPriceUsd: originTokenPrice,
+    destinationTokenPriceUsd: destinationTokenPrice,
     originAmountDisplay: formatAmountDisplay(originAmountFormatted),
     destinationAmountDisplay: formatAmountDisplay(destinationAmountFormatted),
     originAmountMinDisplay: formatAmountDisplay(originAmountMinFormatted),

package/src/transactionIntent/types.ts

@@ -126,6 +126,8 @@ export type PrepareSendQuote = {
   gasCostFormatted: string
   originTokenRate: string
   destinationTokenRate: string
+  originTokenPriceUsd: number
+  destinationTokenPriceUsd: number
   routeProviders?: RouteProviderInfo[]
   noSufficientBalance: boolean
   trailsFeeBreakdown?: TrailsFeeBreakdown | null

package/src/transactionIntent/utils/resilientDepositTracker.ts

@@ -0,0 +1,281 @@
+import type { PublicClient, TransactionReceipt } from "viem"
+import { logger } from "../../logger.js"
+import { POLLING_INTERVALS } from "../constants.js"
+import { getAccountTransactionHistory } from "../../transactions.js"
+import type { Account } from "viem"
+import { checkAccountBalance } from "./balanceChecker.js"
+
+export interface ResilientDepositTrackerOptions {
+  publicClient: PublicClient
+  originChainId: number
+  originIntentAddress: string
+  originTokenAddress: string
+  depositAmount: string
+  txHash?: `0x${string}` | null
+  abortSignal?: AbortSignal
+  sequenceProjectAccessKey?: string
+  sequenceIndexerUrl?: string
+  maxRetries?: number
+  onDepositDetected?: (
+    txHash: `0x${string}` | null,
+    receipt: TransactionReceipt | null,
+  ) => void
+}
+
+/**
+ * Resilient deposit tracker that handles RPC failures gracefully
+ * Falls back to polling when transaction submission fails
+ */
+export async function trackDepositResilient({
+  publicClient,
+  originChainId,
+  originIntentAddress,
+  originTokenAddress,
+  depositAmount,
+  txHash,
+  abortSignal,
+  sequenceProjectAccessKey,
+  sequenceIndexerUrl,
+  maxRetries = 60, // 60 attempts = ~3 minutes with 3s intervals
+  onDepositDetected,
+}: ResilientDepositTrackerOptions): Promise<TransactionReceipt | null> {
+  logger.console.log("[trails-sdk] Starting resilient deposit tracking", {
+    hasHash: !!txHash,
+    txHash,
+    originIntentAddress,
+    depositAmount,
+  })
+
+  let attempts = 0
+  let lastError: Error | null = null
+
+  // If we have a transaction hash, try to get its receipt first
+  if (txHash) {
+    while (attempts < maxRetries) {
+      if (abortSignal?.aborted) {
+        logger.console.log("[trails-sdk] Deposit tracking aborted by signal")
+        return null
+      }
+
+      try {
+        // Try to get the transaction receipt
+        const receipt = await publicClient.getTransactionReceipt({
+          hash: txHash,
+        })
+
+        if (receipt) {
+          logger.console.log("[trails-sdk] Deposit transaction receipt found", {
+            hash: receipt.transactionHash,
+            status: receipt.status,
+            blockNumber: receipt.blockNumber,
+          })
+
+          // Notify callback if provided
+          if (onDepositDetected) {
+            onDepositDetected(txHash, receipt)
+          }
+
+          return receipt
+        }
+      } catch (error) {
+        // Receipt not found yet, this is expected for pending transactions
+        if (attempts === 0) {
+          logger.console.log(
+            "[trails-sdk] Transaction receipt not available yet, will continue polling",
+            { txHash, error: (error as Error)?.message },
+          )
+        }
+        lastError = error as Error
+      }
+
+      attempts++
+      await new Promise((resolve) =>
+        setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_RECEIPT),
+      )
+    }
+
+    logger.console.warn(
+      "[trails-sdk] Could not get receipt for known transaction hash after retries",
+      {
+        txHash,
+        attempts,
+        lastError: lastError?.message,
+      },
+    )
+  }
+
+  // Fall back to polling the intent address for deposits
+  logger.console.log(
+    "[trails-sdk] Falling back to intent address polling for deposit detection",
+  )
+
+  attempts = 0
+  const pollingStartTime = Date.now()
+  const maxPollingDuration = 10 * 60 * 1000 // 10 minutes max
+
+  while (attempts < maxRetries) {
+    if (abortSignal?.aborted) {
+      logger.console.log("[trails-sdk] Deposit tracking aborted by signal")
+      return null
+    }
+
+    // Check if we've exceeded maximum polling duration
+    if (Date.now() - pollingStartTime > maxPollingDuration) {
+      logger.console.warn(
+        "[trails-sdk] Maximum polling duration exceeded for deposit detection",
+      )
+      break
+    }
+
+    try {
+      // Primary method: Check transaction history via indexer to find ANY transaction to intent address
+      if (sequenceIndexerUrl && sequenceProjectAccessKey) {
+        try {
+          const response = await getAccountTransactionHistory({
+            chainId: originChainId,
+            accountAddress: originIntentAddress,
+            abortSignal,
+            apiKey: sequenceProjectAccessKey,
+            indexerUrl: sequenceIndexerUrl,
+          })
+
+          if (response.transactions.length > 0) {
+            const recentTx = response.transactions[0]
+            if (recentTx?.txnHash) {
+              logger.console.log(
+                "[trails-sdk] Found deposit transaction to intent address via indexer",
+                { txHash: recentTx.txnHash },
+              )
+
+              // Get the full receipt
+              const receipt = await publicClient.getTransactionReceipt({
+                hash: recentTx.txnHash as `0x${string}`,
+              })
+
+              logger.console.log(
+                "[trails-sdk] Deposit transaction detected - proceeding",
+                {
+                  txHash: receipt.transactionHash,
+                  to: receipt.to,
+                  status: receipt.status,
+                },
+              )
+
+              // Notify callback if provided
+              if (onDepositDetected) {
+                onDepositDetected(
+                  receipt.transactionHash as `0x${string}`,
+                  receipt,
+                )
+              }
+
+              return receipt
+            }
+          }
+        } catch (indexerError) {
+          logger.console.debug(
+            "[trails-sdk] Indexer check failed, will continue polling",
+            { error: (indexerError as Error)?.message },
+          )
+        }
+      }
+
+      // Fallback method: Check if ANY balance exists at the intent address
+      // This indicates a transaction has occurred even if we can't find the specific tx
+      const balanceCheck = await checkAccountBalance({
+        account: {
+          address: originIntentAddress as `0x${string}`,
+        } as Account,
+        tokenAddress: originTokenAddress,
+        depositAmount: "1", // Check for any non-zero balance
+        publicClient: publicClient,
+      })
+
+      if (balanceCheck.hasEnoughBalance) {
+        logger.console.log(
+          "[trails-sdk] Detected funds at intent address (transaction occurred)",
+          {
+            balance: balanceCheck.balanceFormatted,
+            intentAddress: originIntentAddress,
+          },
+        )
+
+        // We detected a deposit via balance, but don't have the tx hash
+        // This means a transaction definitely occurred
+        // Return null to indicate we detected funds but have no transaction details
+        logger.console.log(
+          "[trails-sdk] Funds detected but no transaction hash available - proceeding anyway",
+        )
+        return null
+      }
+    } catch (error) {
+      logger.console.debug("[trails-sdk] Error during deposit polling", {
+        attempt: attempts,
+        error: (error as Error)?.message,
+      })
+    }
+
+    attempts++
+    await new Promise((resolve) =>
+      setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+    )
+  }
+
+  logger.console.warn(
+    "[trails-sdk] Deposit tracking ended without detecting deposit",
+    {
+      attempts,
+      duration: Date.now() - pollingStartTime,
+    },
+  )
+
+  return null
+}
+
+/**
+ * Helper to determine if an error is recoverable via polling
+ */
+export function isRecoverableDepositError(error: unknown): boolean {
+  if (!error) return false
+
+  const errorMessage = (error as Error)?.message?.toLowerCase() || ""
+  const errorCode = (error as any)?.code
+  const errorCodeLower =
+    typeof errorCode === "string" ? errorCode.toLowerCase() : errorCode
+
+  // User rejections are not recoverable (case-insensitive)
+  if (
+    errorCode === 4001 ||
+    errorCodeLower === "action_rejected" ||
+    errorMessage.includes("user rejected") ||
+    errorMessage.includes("user denied") ||
+    errorMessage.includes("rejected by user")
+  ) {
+    return false
+  }
+
+  // Specific recoverable errors (case-insensitive)
+  if (
+    errorMessage.includes("wallet timeout") ||
+    errorMessage.includes("an unknown rpc error occurred")
+  ) {
+    return true
+  }
+
+  // Other network/RPC errors are also recoverable (case-insensitive)
+  if (
+    errorMessage.includes("network") ||
+    errorMessage.includes("timeout") ||
+    errorMessage.includes("rpc") ||
+    errorMessage.includes("connection") ||
+    errorMessage.includes("fetch") ||
+    errorCodeLower === "network_error" ||
+    errorCodeLower === "timeout" ||
+    errorCode === -32603 // Internal JSON-RPC error (numeric, no case)
+  ) {
+    return true
+  }
+
+  // Unknown errors - DON'T attempt recovery by default (safer)
+  return false
+}