0xtrails 0.1.2 → 0.1.4

package/src/prepareSend.ts

@@ -3,7 +3,7 @@ import type {
   GetIntentCallsPayloadsReturn,
   IntentPrecondition,
   SequenceAPIClient,
-} from "@0xsequence/api"
+} from "@0xsequence/trails-api"
 import type { Relayer } from "@0xsequence/wallet-core"
 import type { Payload } from "@0xsequence/wallet-primitives"
 import { useQuery } from "@tanstack/react-query"
@@ -111,7 +111,14 @@ import { getTxTimeDiff, getAccountTransactionHistory } from "./transactions.js"
 import { requestWithTimeout } from "./utils.js"
 import { InsufficientBalanceError } from "./error.js"
 import { estimateGasCostUsd } from "./estimate.js"
-import { wrapCalldataWithProxyCallerIfNeeded } from "./proxyCaller.js"
+import {
+  decodeGuestModuleEvents,
+  decodeTrailsTokenSweeperEvents,
+} from "./decoders.js"
+import {
+  TRAILS_CONTRACT_PLACEHOLDER_AMOUNT,
+  wrapCalldataWithProxyCallerIfNeeded,
+} from "./proxyCaller.js"
 import {
   getSequenceUseV3Relayers,
   getSequenceEnv,
@@ -135,6 +142,7 @@ export type PrepareSendOptions = {
   destinationTokenAddress: string
   swapAmount: string
   tradeType?: TradeType
+  originTokenSymbol: string
   destinationTokenSymbol: string
   sequenceProjectAccessKey?: string
   fee: string
@@ -154,8 +162,10 @@ export type PrepareSendOptions = {
   slippageTolerance?: string
   originNativeTokenPriceUsd?: number | null
   quoteProvider?: string | null
-  fundMethod?: string | null
+  fundMethod?: string
+  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
   checkoutOnHandlers?: CheckoutOnHandlers
+  refundAddress?: string
 }
 
 export type PrepareSendFees = {
@@ -166,7 +176,8 @@ export type PrepareSendFees = {
 }
 
 export type PrepareSendQuote = {
-  originAddress: string
+  originDepositAddress: string
+  destinationDepositAddress: string
   destinationAddress: string
   destinationCalldata: string
   originChain: Chain
@@ -338,6 +349,7 @@ export async function prepareSend(
     destinationTokenAddress,
     swapAmount,
     tradeType = TradeType.EXACT_OUTPUT,
+    originTokenSymbol,
     destinationTokenSymbol,
     fee,
     client: walletClient,
@@ -357,10 +369,11 @@ export async function prepareSend(
     originNativeTokenPriceUsd,
     quoteProvider,
     fundMethod,
+    mode,
     checkoutOnHandlers,
   } = options
 
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
+  let hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
   const mainSignerAddress = account.address
   const transactionStates: TransactionState[] = []
 
@@ -374,6 +387,20 @@ export async function prepareSend(
   let effectiveDestinationAddress = recipient
   let effectiveDestinationCalldata = destinationCalldata
 
+  if (
+    !hasCustomCalldata &&
+    quoteProvider === "cctp" &&
+    tradeType === TradeType.EXACT_INPUT
+  ) {
+    // we need to set custom calldata for the cctp transfer in order to have destination intent adddress execution needed for metatxn tracking
+    effectiveDestinationCalldata = getERC20TransferData({
+      recipient,
+      amount: BigInt(TRAILS_CONTRACT_PLACEHOLDER_AMOUNT),
+    })
+    effectiveDestinationAddress = destinationTokenAddress
+    hasCustomCalldata = true
+  }
+
   if (
     hasCustomCalldata &&
     destinationTokenAddress !== zeroAddress &&
@@ -403,7 +430,10 @@ export async function prepareSend(
     destinationChainId,
     originTokenAddress,
     destinationTokenAddress,
+    destinationTokenSymbol,
     destinationTokenAmount: swapAmount,
+    mode,
+    fundMethod,
   })
 
   if (originTokenBalance === "0") {
@@ -414,6 +444,13 @@ export async function prepareSend(
     trackPaymentError({
       error: "Wallet client not provided",
       userAddress: account.address,
+      mode,
+      fundMethod,
+      originChainId,
+      destinationChainId,
+      originTokenAddress,
+      destinationTokenAddress,
+      destinationTokenSymbol,
     })
     throw new Error("Wallet client not provided")
   }
@@ -423,6 +460,13 @@ export async function prepareSend(
     trackPaymentError({
       error: `Chain ${originChainId} not found`,
       userAddress: account.address,
+      mode,
+      fundMethod,
+      originChainId,
+      destinationChainId,
+      originTokenAddress,
+      destinationTokenAddress,
+      destinationTokenSymbol,
     })
     throw new Error(`Chain ${originChainId} not found`)
   }
@@ -534,6 +578,7 @@ export async function prepareSend(
     destinationChainId,
     destinationTokenAddress,
     swapAmount,
+    originTokenSymbol,
     destinationTokenSymbol,
     recipient: effectiveDestinationAddress,
     destinationCalldata: effectiveDestinationCalldata,
@@ -559,6 +604,7 @@ export async function prepareSend(
     originNativeTokenPriceUsd,
     quoteProvider,
     fundMethod,
+    mode,
     checkoutOnHandlers,
   })
 }
@@ -571,6 +617,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   destinationChainId,
   destinationTokenAddress,
   swapAmount,
+  originTokenSymbol,
   destinationTokenSymbol,
   recipient,
   destinationCalldata,
@@ -596,6 +643,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   originNativeTokenPriceUsd,
   quoteProvider,
   fundMethod,
+  mode,
   checkoutOnHandlers,
 }: {
   mainSignerAddress: string
@@ -605,6 +653,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   destinationChainId: number
   destinationTokenAddress: string
   swapAmount: string
+  originTokenSymbol: string
   destinationTokenSymbol: string
   recipient: string
   destinationCalldata?: string
@@ -629,7 +678,8 @@ async function sendHandlerForDifferentChainDifferentToken({
   tradeType: TradeType
   originNativeTokenPriceUsd?: number | null
   quoteProvider?: string | null
-  fundMethod?: string | null
+  fundMethod?: string
+  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
   checkoutOnHandlers?: CheckoutOnHandlers
 }): Promise<PrepareSendReturn> {
   const testnet = isTestnetDebugMode()
@@ -860,7 +910,15 @@ async function sendHandlerForDifferentChainDifferentToken({
 
   console.log("[trails-sdk] Creating intent with args:", intentArgs)
 
-  const intent = await getIntentCallsPayloadsFromIntents(apiClient, intentArgs)
+  const intent = await getIntentCallsPayloadsFromIntents(
+    apiClient,
+    intentArgs,
+    {
+      originTokenSymbol,
+      destinationTokenSymbol,
+      feeTokenSymbol: originTokenSymbol,
+    },
+  )
   console.log("[trails-sdk] Got intent:", intent)
 
   if (!intent.preconditions?.length || !intent.calls?.length) {
@@ -875,6 +933,10 @@ async function sendHandlerForDifferentChainDifferentToken({
     mainSignerAddress,
     intent.calls,
     intent.preconditions,
+    {
+      originTokenSymbol,
+      destinationTokenSymbol,
+    },
   )
 
   const firstPrecondition = findFirstPreconditionForChainId(
@@ -948,7 +1010,8 @@ async function sendHandlerForDifferentChainDifferentToken({
   }
 
   const quote = await getNormalizedQuoteObject({
-    originAddress: intentAddress,
+    originDepositAddress: intentAddress,
+    destinationDepositAddress: intent.destinationIntentAddress,
     destinationAddress: recipient,
     destinationCalldata,
     originAmount: depositAmount,
@@ -1037,13 +1100,38 @@ async function sendHandlerForDifferentChainDifferentToken({
 
       console.log("[trails-sdk] testnet", testnet)
 
+      const destinationPublicClient = createPublicClient({
+        chain: getChainInfo(destinationChainId)!,
+        transport: http(),
+      })
+
       const depositPromise = async () => {
+        console.log(
+          "[trails-sdk] depositPromise called - starting deposit transaction",
+        )
+        console.log("[trails-sdk] fundMethod value:", fundMethod)
+
         // Skip wallet deposit if fund method is qr-code
         if (fundMethod === "qr-code" || fundMethod === "exchange") {
-          console.log("[trails-sdk] Skipping wallet deposit for QR code mode")
+          console.log(
+            "[trails-sdk] Skipping wallet deposit for QR code mode - fundMethod is:",
+            fundMethod,
+          )
           return
         }
 
+        console.log("[trails-sdk] Calling attemptUserDepositTx with params:", {
+          originTokenAddress: effectiveOriginTokenAddress,
+          gasless,
+          paymasterUrl,
+          chain: effectiveOriginChain.id,
+          account: account.address,
+          firstPreconditionMin,
+          intentAddress,
+          fee,
+          dryMode,
+        })
+
         originUserTxReceipt = await attemptUserDepositTx({
           originTokenAddress: effectiveOriginTokenAddress,
           gasless,
@@ -1066,6 +1154,8 @@ async function sendHandlerForDifferentChainDifferentToken({
           onTransactionStateChange,
           transactionStates,
           fundMethod,
+          originTokenSymbol,
+          destinationTokenSymbol,
         })
 
         if (!originUserTxReceipt) {
@@ -1130,84 +1220,147 @@ async function sendHandlerForDifferentChainDifferentToken({
         }
       }
 
-      const originMetaTxnPromise = async () => {
+      const _checkForDestinationDepositTx: () => Promise<TransactionReceipt | null> =
+        async () => {
+          while (true) {
+            try {
+              const response = await getAccountTransactionHistory({
+                chainId: destinationChainId,
+                accountAddress:
+                  intent.destinationIntentAddress as `0x${string}`,
+              })
+              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, 1000))
+                  continue
+                }
+                // const isReceive = tx.transfers.some(
+                //   (transfer) => transfer.transferType === "RECEIVE",
+                // )
+                // if (!isReceive) {
+                //   await new Promise((resolve) => setTimeout(resolve, 1000))
+                //   continue
+                // }
+                const destinationDepositTxReceipt =
+                  await destinationPublicClient.getTransactionReceipt({
+                    hash: tx.txnHash as `0x${string}`,
+                  })
+
+                transactionStates[2] = getTransactionStateFromReceipt(
+                  destinationDepositTxReceipt,
+                  destinationChainId,
+                  transactionStates[2]?.label,
+                )
+                onTransactionStateChange(transactionStates)
+
+                return destinationDepositTxReceipt
+              }
+            } catch (error) {
+              console.error("Error checking for deposit tx", error)
+            }
+            await new Promise((resolve) => setTimeout(resolve, 1000))
+          }
+        }
+
+      // Variables to store the waitForReceipt functions
+      let originMetaTxnReceiptPromise:
+        | (() => Promise<MetaTxnReceipt | null>)
+        | null = null
+      let destinationMetaTxnReceiptPromise:
+        | (() => Promise<MetaTxnReceipt | null>)
+        | (() => Promise<TransactionReceipt | null>)
+        | null = null
+
+      // First phase: Send meta transactions and queue CCTP
+      const originSendMetaTxnPromise = async () => {
         if (intent.metaTxns[0] && intent.preconditions[0]) {
-          originMetaTxnReceipt = await sendMetaTxAndWaitForReceipt({
+          const { waitForReceipt } = await sendMetaTxAndWaitForReceipt({
             metaTx: intent.metaTxns[0] as MetaTxn,
             relayer: originRelayer,
             precondition: intent.preconditions[0] as IntentPrecondition,
           })
 
-          if (originMetaTxnReceipt && transactionStates[1]) {
-            transactionStates[1] = getTransactionStateFromReceipt(
-              originMetaTxnReceipt,
-              originChainId,
-              transactionStates[1]?.label,
-            )
-            onTransactionStateChange(transactionStates)
-          }
+          // Store the waitForReceipt function for later use
+          originMetaTxnReceiptPromise = waitForReceipt
         }
       }
 
-      const destinationMetaTxnPromise = async () => {
+      const destinationSendMetaTxnPromise = async () => {
         if (
           intent.quote.quoteProvider === "relay" &&
           intent.quote.quoteProviderRequestId &&
           !intent.preconditions[1] &&
           !intent.metaTxns[1]
         ) {
-          console.log("[trails-sdk] waitForRelayDestinationTx")
-          try {
-            const txHash = await waitForRelayDestinationTx(
-              intent.quote.quoteProviderRequestId,
-            )
-            console.log("[trails-sdk] waitForRelayDestinationTx txHash", txHash)
-            if (txHash) {
-              const destinationPublicClient = createPublicClient({
-                chain: getChainInfo(destinationChainId)!,
-                transport: http(),
-              })
-              const destinationTxnReceipt =
-                await destinationPublicClient.getTransactionReceipt({
-                  hash: txHash as `0x${string}`,
-                })
+          console.log("[trails-sdk] Setting up relay destination promise")
+          // For relay, we'll wait for the receipt in the wait phase
+          // Just store the requestId for later use
+          destinationMetaTxnReceiptPromise = async () => {
+            console.log("[trails-sdk] waitForRelayDestinationTx")
+            try {
+              const txHash = await waitForRelayDestinationTx(
+                intent.quote.quoteProviderRequestId,
+              )
               console.log(
-                "[trails-sdk] relay destinationTxnReceipt",
-                destinationTxnReceipt,
+                "[trails-sdk] waitForRelayDestinationTx txHash",
+                txHash,
               )
-              if (transactionStates[2]) {
-                transactionStates[2] = getTransactionStateFromReceipt(
+              if (txHash) {
+                const destinationTxnReceipt =
+                  await destinationPublicClient.getTransactionReceipt({
+                    hash: txHash as `0x${string}`,
+                  })
+                console.log(
+                  "[trails-sdk] relay destinationTxnReceipt",
                   destinationTxnReceipt,
-                  destinationChainId,
-                  transactionStates[2]?.label,
                 )
+                if (transactionStates[2]) {
+                  transactionStates[2] = getTransactionStateFromReceipt(
+                    destinationTxnReceipt,
+                    destinationChainId,
+                    transactionStates[2]?.label,
+                  )
+                }
+                onTransactionStateChange(transactionStates)
+                return destinationTxnReceipt
               }
-              onTransactionStateChange(transactionStates)
-            }
-          } catch (error: unknown) {
-            console.error("Error waiting for relay destination tx", error)
-            if (transactionStates?.[2]) {
-              transactionStates[2].state = "failed"
-              onTransactionStateChange(transactionStates)
+            } catch (error: unknown) {
+              console.error("Error waiting for relay destination tx", error)
+              if (transactionStates?.[2]) {
+                transactionStates[2].state = "failed"
+                onTransactionStateChange(transactionStates)
+              }
+              throw error
             }
+            return null
           }
         } else {
+          console.log(
+            "[trails-sdk] Setting up destination meta transaction promise",
+          )
+          console.log("[trails-sdk] intent.metaTxns[1]", intent.metaTxns[1])
+          console.log(
+            "[trails-sdk] intent.preconditions[1]",
+            intent.preconditions[1],
+          )
           if (intent.metaTxns[1] && intent.preconditions[1]) {
-            destinationMetaTxnReceipt = await sendMetaTxAndWaitForReceipt({
+            const { waitForReceipt } = await sendMetaTxAndWaitForReceipt({
               metaTx: intent.metaTxns[1] as MetaTxn,
               relayer: destinationRelayer,
               precondition: intent.preconditions[1] as IntentPrecondition,
             })
 
-            if (destinationMetaTxnReceipt && transactionStates[2]) {
-              transactionStates[2] = getTransactionStateFromReceipt(
-                destinationMetaTxnReceipt,
-                destinationChainId,
-                transactionStates?.[2]?.label,
-              )
-              onTransactionStateChange(transactionStates)
-            }
+            // Store the waitForReceipt function for later use
+            destinationMetaTxnReceiptPromise = waitForReceipt
           }
+          // } else if (intent.destinationIntentAddress) {
+          //   destinationMetaTxnReceiptPromise = checkForDestinationDepositTx
+          // }
         }
       }
 
@@ -1238,12 +1391,129 @@ async function sendHandlerForDifferentChainDifferentToken({
         console.error("Error checking for deposit tx", error)
       })
 
+      // Phase 1: Send meta transactions and queue CCTP
+      console.log(
+        "[trails-sdk] Starting Phase 1: Sending meta transactions and queuing CCTP",
+      )
+
+      await Promise.all([
+        originSendMetaTxnPromise(),
+        destinationSendMetaTxnPromise(),
+      ])
+
+      console.log("[trails-sdk] Phase 1 completed successfully")
+
+      // Phase 2: Wait for receipts and execute deposit
+      console.log(
+        "[trails-sdk] Starting Phase 2: Waiting for receipts and executing deposit",
+      )
+
+      const waitForOriginMetaTxnReceiptPromise = async () => {
+        console.log("[trails-sdk] Waiting for origin meta transaction receipt")
+        if (originMetaTxnReceiptPromise) {
+          try {
+            originMetaTxnReceipt = await originMetaTxnReceiptPromise()
+
+            if (originMetaTxnReceipt && transactionStates[1]) {
+              transactionStates[1] = getTransactionStateFromReceipt(
+                originMetaTxnReceipt,
+                originChainId,
+                transactionStates[1]?.label,
+              )
+              onTransactionStateChange(transactionStates)
+
+              try {
+                const receipt = await publicClient.getTransactionReceipt({
+                  hash: originMetaTxnReceipt.txnHash as `0x${string}`,
+                })
+                transactionStates[1].decodedTrailsTokenSweeperEvents =
+                  decodeTrailsTokenSweeperEvents(receipt)
+                transactionStates[1].decodedGuestModuleEvents =
+                  decodeGuestModuleEvents(receipt)
+              } catch (error) {
+                console.error("Error decoding origin tx events", error)
+              }
+            }
+          } catch (error) {
+            console.error(
+              "[trails-sdk] Error waiting for origin receipt:",
+              error,
+            )
+          }
+        } else {
+          console.log(
+            "[trails-sdk] No origin meta transaction receipt promise to wait for",
+          )
+        }
+      }
+
+      const waitForDestinationMetaTxnReceiptPromise = async () => {
+        console.log(
+          "[trails-sdk] Waiting for destination meta transaction receipt",
+        )
+        if (destinationMetaTxnReceiptPromise) {
+          try {
+            destinationMetaTxnReceipt =
+              (await destinationMetaTxnReceiptPromise()) as MetaTxnReceipt
+
+            console.log(
+              "[trails-sdk] destinationMetaTxnReceipt",
+              destinationMetaTxnReceipt,
+            )
+
+            if (destinationMetaTxnReceipt && transactionStates[2]) {
+              transactionStates[2] = getTransactionStateFromReceipt(
+                destinationMetaTxnReceipt,
+                destinationChainId,
+                transactionStates[2]?.label,
+              )
+              onTransactionStateChange(transactionStates)
+
+              try {
+                const receipt =
+                  await destinationPublicClient.getTransactionReceipt({
+                    hash: destinationMetaTxnReceipt.txnHash as `0x${string}`,
+                  })
+                transactionStates[2].decodedTrailsTokenSweeperEvents =
+                  decodeTrailsTokenSweeperEvents(receipt)
+                transactionStates[2].decodedGuestModuleEvents =
+                  decodeGuestModuleEvents(receipt)
+              } catch (error) {
+                console.error("Error decoding destination tx events", error)
+              }
+            }
+          } catch (error) {
+            console.error(
+              "[trails-sdk] Error waiting for destination receipt:",
+              error,
+            )
+            // For relay transactions, this might be expected if still waiting
+            if (intent.quote.quoteProvider === "relay") {
+              console.log(
+                "[trails-sdk] Relay transaction still waiting, this is normal",
+              )
+            }
+          }
+        } else {
+          console.log(
+            "[trails-sdk] No destination meta transaction receipt promise to wait for",
+          )
+        }
+      }
+
+      console.log("[trails-sdk] Executing Phase 2 Promise.all with deposit")
+      console.log(
+        "[trails-sdk] About to call depositPromise - fundMethod is:",
+        fundMethod,
+      )
+
       await Promise.all([
         depositPromise(),
+        waitForOriginMetaTxnReceiptPromise(),
+        waitForDestinationMetaTxnReceiptPromise(),
         queueCctpPromise(),
-        originMetaTxnPromise(),
-        destinationMetaTxnPromise(),
       ])
+      console.log("[trails-sdk] Phase 2 completed successfully")
 
       // Track payment completion
       if (originUserTxReceipt && destinationMetaTxnReceipt) {
@@ -1256,6 +1526,12 @@ async function sendHandlerForDifferentChainDifferentToken({
             ?.txnHash,
           originChainId,
           destinationChainId,
+          mode,
+          fundMethod,
+          originTokenSymbol,
+          originTokenAddress,
+          destinationTokenAddress,
+          destinationTokenSymbol,
         })
 
         // Call onCheckoutComplete callback if provided
@@ -1268,6 +1544,14 @@ async function sendHandlerForDifferentChainDifferentToken({
           error: "Payment transactions did not complete successfully",
           userAddress: account.address,
           intentAddress,
+          mode,
+          fundMethod,
+          originChainId,
+          destinationChainId,
+          originTokenSymbol,
+          originTokenAddress,
+          destinationTokenAddress,
+          destinationTokenSymbol,
         })
 
         // Call onCheckoutError callback if provided
@@ -1307,6 +1591,8 @@ async function sendHandlerForSameChainSameToken({
   originNativeTokenPriceUsd,
   slippageTolerance,
   checkoutOnHandlers,
+  mode,
+  fundMethod,
 }: {
   originTokenAddress: string
   swapAmount: string
@@ -1325,6 +1611,8 @@ async function sendHandlerForSameChainSameToken({
   originNativeTokenPriceUsd?: number | null
   slippageTolerance?: string
   checkoutOnHandlers?: CheckoutOnHandlers
+  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
+  fundMethod?: string
 }): Promise<PrepareSendReturn> {
   console.log("[trails-sdk] isToSameToken && isToSameChain")
   const testnet = isTestnetDebugMode()
@@ -1353,7 +1641,8 @@ async function sendHandlerForSameChainSameToken({
   }
 
   const quote = await getNormalizedQuoteObject({
-    originAddress: recipient,
+    originDepositAddress: recipient,
+    destinationDepositAddress: recipient,
     destinationAddress: recipient,
     destinationCalldata,
     originAmount: swapAmount, // fromAmount is same as toAmount for same chain same token
@@ -1490,6 +1779,7 @@ async function sendHandlerForSameChainSameToken({
           chainId: effectiveOriginChainId,
           userAddress: account.address,
           blockNumber: Number(receipt.blockNumber),
+          originTokenAddress,
         })
 
         onTransactionStateChange([
@@ -1506,11 +1796,17 @@ async function sendHandlerForSameChainSameToken({
             userAddress: account.address,
             originTxHash: originUserTxReceipt.transactionHash,
             originChainId: effectiveOriginChainId, // Same chain
+            mode,
+            fundMethod,
+            originTokenAddress,
           })
         } else if (originUserTxReceipt) {
           trackPaymentError({
             error: "Transaction failed",
             userAddress: account.address,
+            mode,
+            fundMethod,
+            originTokenAddress,
           })
         }
       }
@@ -1543,6 +1839,10 @@ async function _sendHandlerForSameChainDifferentToken({
   sourceTokenPriceUsd,
   destinationTokenPriceUsd,
   originNativeTokenPriceUsd,
+  mode,
+  fundMethod,
+  originTokenSymbol,
+  destinationTokenSymbol,
 }: {
   originTokenAddress: string
   swapAmount: string
@@ -1560,6 +1860,10 @@ async function _sendHandlerForSameChainDifferentToken({
   sourceTokenPriceUsd?: number | null
   destinationTokenPriceUsd?: number | null
   originNativeTokenPriceUsd?: number | null
+  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
+  fundMethod?: string
+  originTokenSymbol: string
+  destinationTokenSymbol: string
 }): Promise<PrepareSendReturn> {
   const destinationTxs: { to: string; value: string; data: string }[] = []
   const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
@@ -1647,7 +1951,8 @@ async function _sendHandlerForSameChainDifferentToken({
   }
 
   const normalizedQuote = await getNormalizedQuoteObject({
-    originAddress: depositOriginAddress,
+    originDepositAddress: depositOriginAddress,
+    destinationDepositAddress: recipient,
     destinationAddress: recipient,
     destinationCalldata,
     originAmount: depositAmount,
@@ -1713,11 +2018,23 @@ async function _sendHandlerForSameChainDifferentToken({
           originTxHash: originUserTxReceipt.transactionHash,
           originChainId,
           destinationChainId: originChainId, // Same chain
+          mode,
+          fundMethod,
+          originTokenAddress,
+          originTokenSymbol,
+          destinationTokenAddress,
+          destinationTokenSymbol,
         })
       } else if (originUserTxReceipt) {
         trackPaymentError({
           error: "Relay transaction failed",
           userAddress: account.address,
+          mode,
+          fundMethod,
+          originTokenAddress,
+          originTokenSymbol,
+          destinationTokenAddress,
+          destinationTokenSymbol,
         })
       }
 
@@ -1933,6 +2250,8 @@ export async function attemptNonGaslessUserDeposit({
   intentAddress,
   onTransactionStateChange,
   transactionStates,
+  originTokenSymbol,
+  destinationTokenSymbol,
 }: {
   originTokenAddress: string
   firstPreconditionMin: string
@@ -1952,6 +2271,8 @@ export async function attemptNonGaslessUserDeposit({
   intentAddress: string
   onTransactionStateChange: (transactionStates: TransactionState[]) => void
   transactionStates: TransactionState[]
+  originTokenSymbol: string
+  destinationTokenSymbol: string
 }): Promise<TransactionReceipt | null> {
   let originUserTxReceipt: TransactionReceipt | null = null
   const usingLIfi = false
@@ -2161,6 +2482,8 @@ export async function attemptNonGaslessUserDeposit({
         userAddress: account.address,
         blockNumber: Number(receipt.blockNumber),
         intentAddress,
+        originTokenSymbol,
+        destinationTokenSymbol,
       })
 
       console.log("[trails-sdk] receipt", receipt)
@@ -2193,6 +2516,8 @@ async function attemptUserDepositTx({
   onTransactionStateChange,
   transactionStates,
   fundMethod,
+  originTokenSymbol,
+  destinationTokenSymbol,
 }: {
   originTokenAddress: string
   gasless: boolean
@@ -2214,14 +2539,24 @@ async function attemptUserDepositTx({
   fee: string
   onTransactionStateChange: (transactionStates: TransactionState[]) => void
   transactionStates: TransactionState[]
-  fundMethod?: string | null
+  fundMethod?: string
+  originTokenSymbol: string
+  destinationTokenSymbol: string
 }): Promise<TransactionReceipt | null> {
   let originUserTxReceipt: TransactionReceipt | null = null
   const originChainId = chain.id
 
+  console.log(
+    "[trails-sdk] attemptUserDepositTx called with fundMethod:",
+    fundMethod,
+  )
+
   // Skip wallet deposit if fund method is qr-code
   if (fundMethod === "qr-code" || fundMethod === "exchange") {
-    console.log("[trails-sdk] Skipping wallet deposit for QR code mode")
+    console.log(
+      "[trails-sdk] Skipping wallet deposit for QR code mode - fundMethod is:",
+      fundMethod,
+    )
     return null
   }
 
@@ -2266,6 +2601,8 @@ async function attemptUserDepositTx({
       sourceTokenDecimals,
       onTransactionStateChange,
       transactionStates,
+      originTokenSymbol,
+      destinationTokenSymbol,
     })
   }
 
@@ -2318,9 +2655,10 @@ async function sendMetaTxAndWaitForReceipt({
   metaTx: MetaTxn
   relayer: Relayer.Standard.Rpc.RpcRelayer
   precondition: IntentPrecondition
-}): Promise<MetaTxnReceipt | null> {
+}): Promise<{
+  waitForReceipt: () => Promise<MetaTxnReceipt | null>
+}> {
   try {
-    let originMetaTxnReceipt: MetaTxnReceipt | null = null
     console.log("[trails-sdk] metaTx", metaTx)
     trackRelayerCallStarted({
       walletAddress: metaTx.walletAddress as `0x${string}`,
@@ -2335,31 +2673,6 @@ async function sendMetaTxAndWaitForReceipt({
       contractAddress: metaTx.contract as `0x${string}`,
       chainId: Number(metaTx.chainId),
     })
-
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      console.log(
-        "[trails-sdk] polling status",
-        metaTx.id as `0x${string}`,
-        BigInt(metaTx.chainId),
-      )
-      const receipt: any = await getMetaTxStatus(
-        relayer,
-        metaTx.id,
-        Number(metaTx.chainId),
-      )
-      console.log("[trails-sdk] status", receipt)
-      if (receipt?.transactionHash) {
-        originMetaTxnReceipt = receipt.data?.receipt
-        if (!originMetaTxnReceipt) {
-          throw new Error("No meta txn receipt found")
-        }
-        break
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1000))
-    }
-
-    return originMetaTxnReceipt
   } catch (error) {
     trackRelayerCallError({
       walletAddress: metaTx.walletAddress as `0x${string}`,
@@ -2369,6 +2682,37 @@ async function sendMetaTxAndWaitForReceipt({
     })
     throw error
   }
+
+  return {
+    waitForReceipt: async () => {
+      let originMetaTxnReceipt: MetaTxnReceipt | null = null
+
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        console.log(
+          "[trails-sdk] polling status",
+          metaTx.id as `0x${string}`,
+          BigInt(metaTx.chainId),
+        )
+        const receipt: any = await getMetaTxStatus(
+          relayer,
+          metaTx.id,
+          Number(metaTx.chainId),
+        )
+        console.log("[trails-sdk] status", receipt)
+        if (receipt?.transactionHash) {
+          originMetaTxnReceipt = receipt.data?.receipt
+          if (!originMetaTxnReceipt) {
+            throw new Error("No meta txn receipt found")
+          }
+          break
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000))
+      }
+
+      return originMetaTxnReceipt
+    },
+  }
 }
 
 /**
@@ -2554,25 +2898,27 @@ export type QuoteProviderInfo = {
   url: string
 }
 
+export type Quote = {
+  fromAmount: string
+  fromAmountMin: string
+  toAmount: string
+  toAmountMin: string
+  originToken: SupportedToken
+  destinationToken: SupportedToken
+  originChain: Chain
+  destinationChain: Chain
+  fees: PrepareSendFees
+  slippageTolerance: string
+  priceImpact: string
+  completionEstimateSeconds: number
+  transactionStates?: TransactionState[]
+  originTokenRate?: string
+  quoteProvider?: QuoteProviderInfo | null
+  destinationTokenRate?: string
+}
+
 export type UseQuoteReturn = {
-  quote: {
-    fromAmount: string
-    fromAmountMin: string
-    toAmount: string
-    toAmountMin: string
-    originToken: SupportedToken
-    destinationToken: SupportedToken
-    originChain: Chain
-    destinationChain: Chain
-    fees: PrepareSendFees
-    slippageTolerance: string
-    priceImpact: string
-    completionEstimateSeconds: number
-    transactionStates?: TransactionState[]
-    originTokenRate?: string
-    quoteProvider?: QuoteProviderInfo | null
-    destinationTokenRate?: string
-  } | null
+  quote: Quote | null
   swap: (() => Promise<SwapReturn | null>) | null
   isLoadingQuote: boolean
   quoteError: unknown
@@ -2672,6 +3018,7 @@ export function useQuote({
       const sourceTokenDecimals = originToken?.decimals ?? 18
       const destinationTokenDecimals = destinationToken?.decimals ?? 18
       const destinationTokenSymbol = destinationToken?.symbol ?? ""
+      const originTokenSymbol = originToken?.symbol ?? ""
 
       const options = {
         account: walletClient.account!,
@@ -2683,6 +3030,7 @@ export function useQuote({
         destinationTokenAddress: toTokenAddress,
         swapAmount: swapAmount.toString(),
         tradeType: tradeType ?? TradeType.EXACT_OUTPUT,
+        originTokenSymbol: originTokenSymbol,
         destinationTokenSymbol: destinationTokenSymbol,
         client: walletClient,
         apiClient,
@@ -2790,8 +3138,7 @@ export function getFeesFromIntent(
     toAmountUsd,
   }: { tradeType: TradeType; fromAmountUsd: number; toAmountUsd: number },
 ): PrepareSendFees {
-  // TODO: remove this once API types are regenerated
-  const totalFeeAmountUsd = (intent?.quote as any)?.quoteProviderFeeUsd ?? 0
+  const totalFeeAmountUsd = intent?.trailsFee?.totalFeeUSD ?? 0
   const totalFeeAmountUsdDisplay = formatUsdAmountDisplay(totalFeeAmountUsd)
 
   console.log("[trails-sdk] getFeesFromIntent", {
@@ -2895,7 +3242,8 @@ export function getIsCustomCalldata(calldata: string | undefined): boolean {
 }
 
 export async function getNormalizedQuoteObject({
-  originAddress,
+  originDepositAddress,
+  destinationDepositAddress,
   destinationAddress,
   destinationCalldata,
   originChainId,
@@ -2918,7 +3266,8 @@ export async function getNormalizedQuoteObject({
   noSufficientBalance,
   minimumNotMet,
 }: {
-  originAddress?: string
+  originDepositAddress?: string
+  destinationDepositAddress?: string
   destinationAddress?: string
   destinationCalldata?: string
   originChainId: number
@@ -3094,7 +3443,8 @@ export async function getNormalizedQuoteObject({
   const priceImpactUsdDisplay = formatUsdAmountDisplay(priceImpactUsd)
 
   return {
-    originAddress: originAddress || "",
+    originDepositAddress: originDepositAddress || "",
+    destinationDepositAddress: destinationDepositAddress || "",
     destinationAddress: destinationAddress || "",
     destinationCalldata: hasCustomCalldata ? destinationCalldata || "" : "",
     originAmount: originAmount || "0",