0xtrails 0.6.4 → 0.6.6

package/src/prepareSend.ts

@@ -1,7 +1,7 @@
 import { abortControllerRegistry } from "./abortController.js"
 import { trackPaymentError, trackPaymentStarted } from "./analytics.js"
 import { getSlippageToleranceValue } from "./widget/components/SlippageToleranceSettings.js"
-import { isNativeToken } from "./utils.js"
+import { isNativeToken, isZeroAccount } from "./utils.js"
 import { getERC20TransferData } from "./encoders.js"
 import { getTokenPrice } from "./prices.js"
 import {
@@ -135,7 +135,7 @@ export async function prepareSend(
   const transactionStates: TransactionState[] = []
 
   // Validate recipient is not zero address
-  if (isNativeToken(recipient)) {
+  if (isZeroAccount(recipient)) {
     throw new Error("Recipient address cannot be zero address")
   }
 
@@ -149,10 +149,16 @@ export async function prepareSend(
   let effectiveDestinationAddress = recipient
   let effectiveDestinationCalldata = destinationCalldata
 
+  // Check if this is a same-chain same-token transfer (before modifying effectiveDestinationAddress)
+  const isToSameChain = isSameChain(originChainId, destinationChainId)
+  const isToSameToken = isSameToken(originTokenAddress, destinationTokenAddress)
+  const isSameChainSameToken = isToSameChain && isToSameToken
+
   if (
     !hasCustomCalldata &&
     tradeType === TradeType.EXACT_INPUT &&
-    !isNativeToken(destinationTokenAddress)
+    !isNativeToken(destinationTokenAddress) &&
+    !isSameChainSameToken // Don't override recipient for same-chain same-token transfers
   ) {
     // we need to set custom calldata for the cctp transfer in order to have destination intent adddress execution needed for metatxn tracking
     effectiveDestinationCalldata = getERC20TransferData({
@@ -292,8 +298,6 @@ export async function prepareSend(
   }
   const isToSelf =
     account.address.toLowerCase() === effectiveDestinationAddress.toLowerCase()
-  const isToSameChain = isSameChain(originChainId, destinationChainId)
-  const isToSameToken = isSameToken(originTokenAddress, destinationTokenAddress)
 
   logger.console.log("[trails-sdk] isToSameChain", isToSameChain)
   logger.console.log("[trails-sdk] isToSameToken", isToSameToken)
@@ -381,6 +385,17 @@ export async function prepareSend(
   // }
 
   if (isToSameToken && isToSameChain) {
+    logger.console.log(
+      "[trails-sdk] Same-chain same-token detected, using handleSameChainSameToken:",
+      {
+        recipient: effectiveDestinationAddress,
+        originalRecipient: recipient,
+        accountAddress: account.address,
+        originTokenAddress,
+        destinationTokenAddress,
+      },
+    )
+
     return await handleSameChainSameToken({
       mainSignerAddress,
       originTokenAddress,

package/src/relaySdk.ts

@@ -12,6 +12,7 @@ import {
   berachain,
   blast,
   opBNB,
+  bsc,
   bob,
   boba,
   celo,
@@ -90,6 +91,7 @@ export const relaySupportedChains: Record<number, Chain> = {
   [base.id]: base,
   [berachain.id]: berachain,
   [blast.id]: blast,
+  [bsc.id]: bsc,
   [opBNB.id]: opBNB,
   [bob.id]: bob,
   [boba.id]: boba,

package/src/tokens.ts

@@ -16,6 +16,7 @@ import {
   linea,
   unichain,
   worldchain,
+  bsc,
 } from "viem/chains"
 import { getRelaySupportedTokens, type Chain } from "./relaySdk.js"
 import { useReadContracts } from "wagmi"
@@ -49,13 +50,13 @@ export const commonTokenImages: Record<string, string> = {
   ARB: "https://assets.sequence.info/images/tokens/large/42161/0x912ce59144191c1204e64559fe8253a0e49e6548.webp",
   LINK: "https://assets.sequence.info/images/tokens/large/1/0x514910771af9ca656af840dff83e8264ecf986ca.webp",
   XTZ: "https://assets.sequence.info/images/tokens/large/42793/0x0000000000000000000000000000000000000000.webp",
+  BNB: "https://assets.sequence.info/images/tokens/large/56/0x0000000000000000000000000000000000000000.webp",
   WXTZ: "https://assets.coingecko.com/coins/images/976/standard/Tezos-logo.png?1696502091",
   SOMI: "https://assets.sequence.info/images/tokens/large/5031/0x0000000000000000000000000000000000000000.webp",
   XAI: "https://assets.coingecko.com/coins/images/34258/large/round_icon_2048_px.png?1719523838",
   APE: "https://assets.sequence.info/images/tokens/large/33139/0x0000000000000000000000000000000000000000.webp",
   ANIME:
     "https://assets.coingecko.com/coins/images/53575/large/anime.jpg?1736748703",
-  BNB: "https://assets.sequence.info/images/tokens/large/56/0x0000000000000000000000000000000000000000.webp",
   AVAX: "https://assets.sequence.info/images/tokens/large/43114/0x0000000000000000000000000000000000000000.webp",
 }
 
@@ -546,16 +547,43 @@ export async function getTokenInfo(
   }
 }
 
+// Mapping of hyphenated symbols to their canonical token symbols.
+// The Sequence API returns BNB-USD, but we want to use USDT instead.
+const HYPHENATED_SYMBOL_MAP: Record<string, string> = {
+  "BNB-USD": "USDT",
+}
+
 export async function getTokenAddress(chainId: number, tokenSymbol: string) {
   const chainInfo = getChainInfo(chainId)
-  if (tokenSymbol === chainInfo?.nativeCurrency.symbol) {
+  // Normalize token symbol: trim whitespace and convert to uppercase for comparison
+  const normalizedTokenSymbol = tokenSymbol.trim().toUpperCase()
+
+  const nativeSymbol = (chainInfo as any)?.nativeCurrency?.symbol
+  if (nativeSymbol && normalizedTokenSymbol === nativeSymbol.toUpperCase()) {
     return zeroAddress
   }
 
   const tokens = await getSupportedTokens()
-  const token = tokens.find(
-    (t) => t.symbol === tokenSymbol && t.chainId === chainId,
+
+  // First try exact match (normalized)
+  let token = tokens.find(
+    (t) =>
+      t.symbol.trim().toUpperCase() === normalizedTokenSymbol &&
+      t.chainId === chainId,
   )
+
+  // If not found, check if it's a hyphenated symbol that maps to another symbol
+  if (!token) {
+    const mappedSymbol = HYPHENATED_SYMBOL_MAP[normalizedTokenSymbol]
+    if (mappedSymbol) {
+      token = tokens.find(
+        (t) =>
+          t.symbol.trim().toUpperCase() === mappedSymbol.toUpperCase() &&
+          t.chainId === chainId,
+      )
+    }
+  }
+
   if (token?.contractAddress) {
     return token.contractAddress
   }
@@ -1159,6 +1187,26 @@ export const commonTokens: SupportedToken[] = [
     chainName: etherlink.name,
     imageUrl: commonTokenImages.USDT as string,
   },
+  {
+    id: "USDT-bsc",
+    symbol: "USDT",
+    name: "Tether USD",
+    contractAddress: "0x55d398326f99059ff775485246999027b3197955",
+    decimals: 18,
+    chainId: bsc.id,
+    chainName: bsc.name,
+    imageUrl: commonTokenImages.USDT as string,
+  },
+  {
+    id: "BNB-bsc",
+    symbol: "BNB",
+    name: "BNB",
+    contractAddress: "0x0000000000000000000000000000000000000000",
+    decimals: 18,
+    chainId: bsc.id,
+    chainName: bsc.name,
+    imageUrl: commonTokenImages.BNB as string,
+  },
 
   // Somnia
   {

package/src/transactionIntent/deposits/gaslessDeposit.ts

@@ -10,7 +10,7 @@ import type {
 import type { CheckoutOnHandlers } from "../../widget/hooks/useCheckout.js"
 import type { TransactionState } from "../../transactions.js"
 import { logger } from "../../logger.js"
-import { isNativeToken } from "../../utils.js"
+import { isNativeToken, isZeroAccount } from "../../utils.js"
 import { attemptSwitchChain } from "../../chainSwitch.js"
 import { getTransactionStateFromReceipt } from "../execution/transactionState.js"
 import {
@@ -386,7 +386,7 @@ export async function attemptGaslessDeposit({
       | undefined
 
     // Validate that we have a valid fee collector address
-    if (!feeCollectorAddress || isNativeToken(feeCollectorAddress)) {
+    if (!feeCollectorAddress || isZeroAccount(feeCollectorAddress)) {
       throw new Error(
         "[trails-sdk] Fee collector address not provided by API. Cannot proceed with gasless deposit. " +
           "Please ensure the API is returning feeCollectorAddress in the gasFeeOptions response.",

package/src/transactionIntent/handlers/sameChainSameToken.ts

@@ -24,6 +24,7 @@ import {
   buildSameChainSameTokenTransactionParams,
   quoteIntent,
   commitIntent,
+  sendOriginTransaction,
 } from "../../intents.js"
 import { estimateGasLimit } from "../../estimate.js"
 import { getNormalizedQuoteObject } from "../quote/normalizeQuote.js"
@@ -31,7 +32,11 @@ import { attemptSwitchChain } from "../../chainSwitch.js"
 import { attemptUserDepositTx } from "../deposits/depositOrchestrator.js"
 import { getIntentArgs } from "../quote/quoteHelpers.js"
 import { TradeType } from "../types.js"
-import { trackPaymentCompleted, trackPaymentError } from "../../analytics.js"
+import {
+  trackPaymentCompleted,
+  trackPaymentError,
+  trackTransactionConfirmed,
+} from "../../analytics.js"
 import { updatePersistentToast } from "../../toast.js"
 import { getChainInfo } from "../../chains.js"
 import { getTransactionStateFromReceipt } from "../execution/transactionState.js"
@@ -135,6 +140,301 @@ export async function handleSameChainSameToken({
 
   const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
 
+  // Check if this is a native token transfer - if so, skip intents and do direct transfer
+  const isNative = isNativeToken(effectiveOriginTokenAddress)
+
+  if (isNative) {
+    logger.console.log(
+      "[trails-sdk] Same-chain same-token native transfer detected, using direct transfer (no intents)",
+      {
+        originChainId: effectiveOriginChainId,
+        tokenAddress: effectiveOriginTokenAddress,
+        amount: swapAmount,
+        recipient,
+        hasCustomCalldata,
+      },
+    )
+
+    // Build transaction params for direct native transfer
+    const originCallParamsBase = buildSameChainSameTokenTransactionParams({
+      hasCustomCalldata,
+      recipient,
+      effectiveOriginTokenAddress,
+      destinationCalldata,
+      swapAmount,
+      effectiveOriginChainId,
+      effectiveOriginChain,
+    })
+
+    // Estimate gas limit
+    const estimatedGasLimitForQuote = await estimateGasLimit(
+      effectivePublicClient,
+      {
+        account: account.address,
+        to: originCallParamsBase.to,
+        data: originCallParamsBase.data,
+        value: BigInt(originCallParamsBase.value),
+      },
+      "quote",
+    )
+
+    logger.console.log(
+      "[trails-sdk][gas-estimation] Estimated gas limit for direct native transfer:",
+      estimatedGasLimitForQuote,
+    )
+
+    // Create minimal quote without intent addresses (using recipient as both addresses)
+    const quote = await getNormalizedQuoteObject({
+      originDepositAddress: recipient, // Direct transfer, no intent address
+      destinationDepositAddress: recipient, // Direct transfer, no intent address
+      destinationAddress: recipient,
+      destinationCalldata,
+      originAmount: swapAmount,
+      destinationAmount: swapAmount,
+      originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
+      destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
+      originTokenAddress: effectiveOriginTokenAddress,
+      destinationTokenAddress: effectiveOriginTokenAddress,
+      transactionStates,
+      originChainId: effectiveOriginChainId,
+      destinationChainId: effectiveOriginChainId,
+      originNativeTokenPriceUsd,
+      slippageTolerance,
+      quoteProvider: quoteProvider || "direct",
+      noSufficientBalance,
+      estimatedGasLimit: estimatedGasLimitForQuote,
+      // No intent for direct transfers
+    })
+
+    // Call onCheckoutQuote callback if provided
+    if (checkoutOnHandlers?.triggerCheckoutQuote) {
+      checkoutOnHandlers.triggerCheckoutQuote(quote)
+    }
+
+    // Return PrepareSendReturn with direct send function
+    return {
+      quote,
+      feeOptions: undefined, // No fee options for direct native transfers
+      send: async ({
+        onOriginSend,
+      }: {
+        onOriginSend?: () => void
+        selectedFeeOption?: FeeOption | null
+      }): Promise<SendReturn> => {
+        try {
+          // Check balance before sending
+          const { hasEnoughBalance, balanceError } = await checkAccountBalance({
+            account,
+            tokenAddress: effectiveOriginTokenAddress,
+            depositAmount: swapAmount,
+            publicClient: effectivePublicClient,
+          })
+
+          if (!hasEnoughBalance) {
+            throw balanceError
+          }
+
+          const depositAmountFormatted = Number(
+            formatUnits(BigInt(swapAmount), originTokenDecimals),
+          )
+          const depositAmountUsd = calcAmountUsdPrice({
+            amount: depositAmountFormatted,
+            usdPrice: sourceTokenPriceUsd,
+          })
+
+          // Build transaction params
+          logger.console.log(
+            "[trails-sdk] Building same-chain same-token transaction params:",
+            {
+              recipient,
+              hasCustomCalldata,
+              effectiveOriginTokenAddress,
+              swapAmount,
+              accountAddress: account.address,
+            },
+          )
+
+          const originCallParams = buildSameChainSameTokenTransactionParams({
+            hasCustomCalldata,
+            recipient,
+            effectiveOriginTokenAddress,
+            destinationCalldata,
+            swapAmount,
+            effectiveOriginChainId,
+            effectiveOriginChain,
+          })
+
+          logger.console.log(
+            "[trails-sdk] origin call params",
+            originCallParams,
+          )
+
+          let originUserTxReceipt: TransactionReceipt | null = null
+
+          if (!dryMode) {
+            // Update transaction state to pending
+            try {
+              onTransactionStateChange([
+                {
+                  transactionHash: "",
+                  explorerUrl: "",
+                  chainId: effectiveOriginChainId,
+                  state: "pending",
+                  label: "Execute",
+                },
+              ])
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error calling onTransactionStateChange:",
+                error,
+              )
+            }
+
+            // Show persistent toast for checkout flow
+            updatePersistentToast(
+              "Payment Started",
+              "Waiting for wallet confirmation...",
+              "info",
+            )
+
+            logger.console.log(
+              "[trails-sdk] origin call params",
+              originCallParams,
+            )
+
+            // Use sendOriginTransaction helper which handles gas estimation, fee boosting, and tracking
+            const txHash = await sendOriginTransaction(
+              account,
+              walletClient,
+              originCallParams as any,
+              {
+                depositTokenAmountUsd: depositAmountUsd?.toString(),
+              },
+            )
+
+            logger.console.log("[trails-sdk] origin tx", txHash)
+
+            if (onOriginSend) {
+              onOriginSend()
+            }
+
+            // Wait for transaction receipt
+            const receipt =
+              await effectivePublicClient.waitForTransactionReceipt({
+                hash: txHash,
+              })
+            logger.console.log("[trails-sdk] receipt", receipt)
+            originUserTxReceipt = receipt
+
+            // Track transaction confirmation
+            trackTransactionConfirmed({
+              transactionHash: txHash,
+              chainId: effectiveOriginChainId,
+              userAddress: account.address,
+              blockNumber: Number(receipt.blockNumber),
+              originTokenAddress: effectiveOriginTokenAddress,
+              depositTokenAmountUsd: depositAmountUsd?.toString(),
+            })
+
+            // Remove persistent toast and show success
+            const chainInfo = getChainInfo(effectiveOriginChainId)
+            updatePersistentToast(
+              "Transfer Confirmed",
+              `Your transaction on ${(chainInfo as any)?.name || "chain"} has been confirmed`,
+              "info",
+            )
+
+            // Update transaction state to completed
+            try {
+              onTransactionStateChange([
+                getTransactionStateFromReceipt(
+                  originUserTxReceipt,
+                  effectiveOriginChainId,
+                  transactionStates[0]?.label || "Execute",
+                ),
+              ])
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error calling onTransactionStateChange:",
+                error,
+              )
+            }
+
+            // Track payment completion for same-chain same-token transaction
+            if (
+              originUserTxReceipt &&
+              originUserTxReceipt.status === "success"
+            ) {
+              trackPaymentCompleted({
+                userAddress: account.address,
+                originTxHash: originUserTxReceipt.transactionHash,
+                originChainId: effectiveOriginChainId,
+                mode,
+                fundMethod,
+                originTokenAddress: effectiveOriginTokenAddress,
+                depositTokenAmountUsd: depositAmountUsd?.toString(),
+                destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
+              })
+
+              // Call onCheckoutComplete callback if provided
+              if (checkoutOnHandlers?.triggerCheckoutComplete) {
+                checkoutOnHandlers.triggerCheckoutComplete(
+                  "success",
+                  account.address,
+                )
+              }
+            } else if (originUserTxReceipt) {
+              trackPaymentError({
+                error: "Transaction failed",
+                userAddress: account.address,
+                mode,
+                fundMethod,
+                originTokenAddress: effectiveOriginTokenAddress,
+              })
+
+              // Call onCheckoutError callback if provided
+              if (checkoutOnHandlers?.triggerCheckoutError) {
+                checkoutOnHandlers.triggerCheckoutError("Transaction failed")
+              }
+            }
+          }
+
+          return {
+            depositUserTxnReceipt: originUserTxReceipt,
+            originIntentTransaction: null, // No intent for direct transfers
+            destinationIntentTransaction: null, // No intent for direct transfers
+          }
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error
+              ? error.message
+              : "Unknown error occurred during transaction"
+          logger.console.error(
+            "[trails-sdk] Error in direct native transfer:",
+            error,
+          )
+
+          // Track payment error
+          trackPaymentError({
+            error: errorMessage,
+            userAddress: account.address,
+            mode,
+            fundMethod,
+            originTokenAddress: effectiveOriginTokenAddress,
+          })
+
+          // Call onCheckoutError callback if provided
+          if (checkoutOnHandlers?.triggerCheckoutError) {
+            checkoutOnHandlers.triggerCheckoutError(errorMessage)
+          }
+
+          // Re-throw the error so caller can handle if needed
+          throw error
+        }
+      },
+    }
+  }
+
   // For same-chain transactions, use Intent flow to support gasless deposits
   const salt = Date.now().toString()
   const intentArgs = await getIntentArgs(
@@ -304,6 +604,17 @@ export async function handleSameChainSameToken({
         const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
 
         // Build origin call params (reusing the same logic as quote estimation)
+        logger.console.log(
+          "[trails-sdk] Building same-chain same-token transaction params (intent flow):",
+          {
+            recipient,
+            hasCustomCalldata,
+            effectiveOriginTokenAddress,
+            swapAmount,
+            accountAddress: account.address,
+          },
+        )
+
         const originCallParamsBase = buildSameChainSameTokenTransactionParams({
           hasCustomCalldata,
           recipient,

package/src/utils.ts

@@ -104,5 +104,20 @@ export function isNativeToken(
   return addresses.includes(normalizedAddress)
 }
 
+/**
+ * Checks if an address is the zero address (0x0000...0000)
+ * Use this for recipient/account addresses, not for token addresses.
+ * For token addresses, use isNativeToken() instead.
+ * @param address - The address to check
+ * @returns True if the address is the zero address
+ */
+export function isZeroAccount(address?: string | null): boolean {
+  if (!address) {
+    return false
+  }
+
+  return address.toLowerCase() === zeroAddress.toLowerCase()
+}
+
 export const normalizeAddress = (address?: string | null): string =>
   (address ?? "").toLowerCase()