0xtrails 0.9.2 → 0.9.4

package/src/intents.ts

@@ -120,6 +120,7 @@ export async function quoteIntent(
   trailsClient: TrailsApi,
   args: QuoteIntentRequest,
   additionalTrackingProps: Record<string, string> = {},
+  abortSignal?: AbortSignal,
 ): Promise<{
   intent: Intent
   gasFeeOptions?: GasFeeOptions
@@ -137,7 +138,27 @@ export async function quoteIntent(
 
   try {
     logger.console.log("[trails-sdk] quote intent args:", args)
-    const response = await trailsClient.quoteIntent(args)
+
+    // Create a promise that rejects when the abort signal fires
+    let response: any
+    if (abortSignal) {
+      const abortPromise = new Promise((_, reject) => {
+        if (abortSignal.aborted) {
+          reject(new Error("Request aborted"))
+        }
+        abortSignal.addEventListener("abort", () => {
+          reject(new Error("Request aborted"))
+        })
+      })
+
+      // Race between the API call and the abort signal
+      response = await Promise.race([
+        trailsClient.quoteIntent(args, {}, abortSignal),
+        abortPromise,
+      ])
+    } else {
+      response = await trailsClient.quoteIntent(args)
+    }
 
     if (!response || !response.intent) {
       logger.console.error("[trails-sdk] No result from quoteIntent")

package/src/prices.ts

@@ -10,7 +10,7 @@ const CACHE_CONFIG = {
   // Time configurations
   staleTime: 5000, // 5 seconds - max cache time for token balance related prices
   gcTime: 5000, // 5 seconds cache time
-  refetchInterval: 60000, // Background refetch every minute for prices
+  refetchInterval: 15000, // Background refetch every 15 seconds for prices
 
   // Retry configurations
   retry: 2,

package/src/tokens.ts

@@ -529,11 +529,12 @@ export function useSupportedTokens({ chainId }: { chainId?: number } = {}): {
       trailsConfig.trailsApiUrl,
       trailsConfig.trailsApiKey,
     ],
-    queryFn: () =>
-      getSupportedTokens({
+    queryFn: async () => {
+      return getSupportedTokens({
         trailsApiKey: trailsConfig.trailsApiKey,
         trailsApiUrl: trailsConfig.trailsApiUrl,
-      }),
+      })
+    },
     staleTime: 60 * 60 * 1000, // 1 hour - tokens rarely change
     gcTime: 24 * 60 * 60 * 1000, // 24 hours - keep in cache for a full day
     refetchOnWindowFocus: false, // Don't refetch when window regains focus

package/src/transactionIntent/constants.ts

@@ -8,4 +8,6 @@ export const POLLING_INTERVALS = {
   CCTP_QUEUE: 5000,
   // Consistent interval for failure polling (2 seconds)
   FAILURE_POLLING: 2000,
+  // Consistent interval for transaction receipt polling (3 seconds)
+  TRANSACTION_RECEIPT: 3000,
 } as const

package/src/transactionIntent/deposits/depositOrchestrator.ts

@@ -52,6 +52,8 @@ export async function attemptUserDepositTx({
   depositRecipientOverride,
   isSameChainSameToken,
   destinationCalldata,
+  sequenceProjectAccessKey,
+  sequenceIndexerUrl,
 }: {
   originTokenAddress: string
   paymasterUrl?: string
@@ -89,6 +91,8 @@ export async function attemptUserDepositTx({
   depositRecipientOverride?: string
   isSameChainSameToken?: boolean
   destinationCalldata?: string
+  sequenceProjectAccessKey?: string
+  sequenceIndexerUrl?: string
 }): Promise<TransactionReceipt | null> {
   let depositUserTxnReceipt: TransactionReceipt | null = null
   const originChainId = chain.id
@@ -207,6 +211,9 @@ export async function attemptUserDepositTx({
       isSameChainSameToken,
       recipient: effectiveDepositRecipient,
       destinationCalldata,
+      sequenceProjectAccessKey,
+      sequenceIndexerUrl,
+      abortSignal,
     })
   }
 

package/src/transactionIntent/deposits/standardDeposit.ts

@@ -22,6 +22,10 @@ import { updatePersistentToast } from "../../toast.js"
 import { getChainInfo } from "../../chains.js"
 import { trackTransactionConfirmed } from "../../analytics.js"
 import { getIsUserRejectionError } from "../../error.js"
+import {
+  trackDepositResilient,
+  isRecoverableDepositError,
+} from "../utils/resilientDepositTracker.js"
 
 export async function attemptStandardDeposit({
   originTokenAddress,
@@ -42,6 +46,9 @@ export async function attemptStandardDeposit({
   isSameChainSameToken,
   recipient,
   destinationCalldata,
+  sequenceProjectAccessKey,
+  sequenceIndexerUrl,
+  abortSignal,
 }: {
   originTokenAddress: string
   depositAmount: string
@@ -66,6 +73,9 @@ export async function attemptStandardDeposit({
   isSameChainSameToken?: boolean
   recipient?: string
   destinationCalldata?: string
+  sequenceProjectAccessKey?: string
+  sequenceIndexerUrl?: string
+  abortSignal?: AbortSignal
 }): Promise<TransactionReceipt | null> {
   logger.console.log("[trails-sdk] [STANDARD DEPOSIT] initiating deposit...")
   let depositUserTxnReceipt: TransactionReceipt | null = null
@@ -444,7 +454,9 @@ export async function attemptStandardDeposit({
       checkoutOnHandlers.triggerCheckoutSignatureRequest()
     }
 
-    let txHash: `0x${string}`
+    let txHash: `0x${string}` | null = null
+    let sendError: unknown = null
+
     try {
       txHash = await sendOriginTransaction(
         account,
@@ -456,63 +468,208 @@ export async function attemptStandardDeposit({
       ) // TODO: Add proper type
       logger.console.log("[trails-sdk] origin tx", txHash)
 
+      // SIMULATE RPC ERROR: Throw error after successful transaction send
+      // This simulates the scenario where tx is broadcast but RPC fails immediately after
+      // if (true) { // Always enabled for testing
+      //   logger.console.warn(
+      //     "[trails-sdk] SIMULATING RPC ERROR after transaction send",
+      //     { txHash }
+      //   )
+      //   throw new Error("SIMULATED: RPC connection lost after transaction broadcast")
+      // }
+
       // Trigger signature confirmed callback after successful signing
       if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
-        checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+        checkoutOnHandlers?.triggerCheckoutSignatureConfirmed?.()
       }
     } catch (error) {
+      sendError = error
+      logger.console.error(
+        "[trails-sdk] Error sending deposit transaction",
+        error,
+      )
+
       // Check if this is a user rejection error
       if (getIsUserRejectionError(error)) {
         if (checkoutOnHandlers?.triggerCheckoutSignatureRejected) {
           checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
         }
+        throw error // User rejections should fail immediately
       }
-      throw error
-    }
 
-    if (onOriginSend) {
-      onOriginSend()
+      // For recoverable errors, log but don't throw yet
+      if (!isRecoverableDepositError(error)) {
+        throw error // Non-recoverable errors should fail
+      }
+
+      logger.console.log(
+        "[trails-sdk] Deposit send failed with recoverable error, will attempt polling",
+        { error: (error as Error)?.message },
+      )
     }
 
-    if (transactionStates[0]) {
-      transactionStates[0].state = "pending"
+    // Handle successful transaction hash or fall back to resilient tracking
+    if (txHash) {
+      if (onOriginSend) {
+        onOriginSend()
+      }
+
+      if (transactionStates[0]) {
+        transactionStates[0].state = "pending"
+        transactionStates[0].transactionHash = txHash
+
+        try {
+          onTransactionStateChange(transactionStates)
+        } catch (error) {
+          logger.console.error(
+            "[trails-sdk] Error calling onTransactionStateChange:",
+            error,
+          )
+        }
+      }
 
+      // Try normal receipt retrieval first
       try {
-        onTransactionStateChange(transactionStates)
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] Error calling onTransactionStateChange:",
-          error,
+        // Wait for transaction receipt
+        const receipt = await publicClient.waitForTransactionReceipt({
+          hash: txHash,
+          retryCount: 10,
+        })
+
+        const chainInfo = getChainInfo(originChainId)
+        updatePersistentToast(
+          "Transfer Confirmed",
+          `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
+          "info",
         )
+
+        trackTransactionConfirmed({
+          transactionHash: txHash,
+          chainId: originChainId,
+          userAddress: account.address,
+          blockNumber: Number(receipt.blockNumber),
+          originIntentAddress,
+          originTokenSymbol,
+          destinationTokenSymbol,
+          depositTokenAmountUsd: depositAmountUsd?.toString(),
+        })
+
+        logger.console.log("[trails-sdk] receipt", receipt)
+        depositUserTxnReceipt = receipt
+      } catch (receiptError) {
+        logger.console.warn(
+          "[trails-sdk] Could not get receipt, using resilient tracking",
+          { txHash, error: (receiptError as Error)?.message },
+        )
+
+        // Fall back to resilient tracking with known tx hash
+        depositUserTxnReceipt = await trackDepositResilient({
+          publicClient,
+          originChainId,
+          originIntentAddress,
+          originTokenAddress,
+          depositAmount,
+          txHash,
+          abortSignal,
+          sequenceProjectAccessKey,
+          sequenceIndexerUrl,
+          onDepositDetected: (hash, receipt) => {
+            const chainInfo = getChainInfo(originChainId)
+            updatePersistentToast(
+              "Transfer Confirmed",
+              `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
+              "info",
+            )
+
+            if (receipt?.status === "success" && hash) {
+              trackTransactionConfirmed({
+                transactionHash: hash,
+                chainId: originChainId,
+                userAddress: account.address,
+                blockNumber: Number(receipt.blockNumber || 0),
+                originIntentAddress,
+                originTokenSymbol,
+                destinationTokenSymbol,
+                depositTokenAmountUsd: depositAmountUsd?.toString(),
+              })
+            }
+          },
+        })
       }
-    }
+    } else if (sendError && isRecoverableDepositError(sendError)) {
+      // No transaction hash but error is recoverable - start polling
+      logger.console.log(
+        "[trails-sdk] Starting resilient deposit tracking after send failure",
+      )
 
-    // Wait for transaction receipt
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash: txHash,
-      retryCount: 10,
-    })
+      updatePersistentToast(
+        "Checking Transaction",
+        "Verifying transaction status...",
+        "info",
+      )
 
-    const chainInfo = getChainInfo(originChainId)
-    updatePersistentToast(
-      "Transfer Confirmed",
-      `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-      "info",
-    )
+      depositUserTxnReceipt = await trackDepositResilient({
+        publicClient,
+        originChainId,
+        originIntentAddress,
+        originTokenAddress,
+        depositAmount,
+        txHash: null,
+        abortSignal,
+        sequenceProjectAccessKey,
+        sequenceIndexerUrl,
+        onDepositDetected: (detectedHash, receipt) => {
+          logger.console.log(
+            "[trails-sdk] Deposit detected via resilient tracking",
+            { hash: detectedHash },
+          )
+
+          if (onOriginSend) {
+            onOriginSend()
+          }
 
-    trackTransactionConfirmed({
-      transactionHash: txHash,
-      chainId: originChainId,
-      userAddress: account.address,
-      blockNumber: Number(receipt.blockNumber),
-      originIntentAddress,
-      originTokenSymbol,
-      destinationTokenSymbol,
-      depositTokenAmountUsd: depositAmountUsd?.toString(),
-    })
+          if (transactionStates[0] && detectedHash) {
+            transactionStates[0].state = "pending"
+            transactionStates[0].transactionHash = detectedHash
+
+            try {
+              onTransactionStateChange(transactionStates)
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error calling onTransactionStateChange:",
+                error,
+              )
+            }
+          }
 
-    logger.console.log("[trails-sdk] receipt", receipt)
-    depositUserTxnReceipt = receipt
+          const chainInfo = getChainInfo(originChainId)
+          updatePersistentToast(
+            "Transfer Confirmed",
+            `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
+            "info",
+          )
+
+          if (receipt?.status === "success" && detectedHash) {
+            trackTransactionConfirmed({
+              transactionHash: detectedHash,
+              chainId: originChainId,
+              userAddress: account.address,
+              blockNumber: Number(receipt.blockNumber || 0),
+              originIntentAddress,
+              originTokenSymbol,
+              destinationTokenSymbol,
+              depositTokenAmountUsd: depositAmountUsd?.toString(),
+            })
+          }
+        },
+      })
+
+      if (!depositUserTxnReceipt) {
+        throw new Error(
+          "Deposit transaction could not be confirmed. Please check your wallet and try again.",
+        )
+      }
+    }
   }
 
   return depositUserTxnReceipt