0xtrails 0.12.0 → 0.12.2

package/src/transactionIntent/handlers/intentHandler.ts

@@ -45,10 +45,6 @@ import { formatRawAmount, rawAmountToNumber } from "../../utils/format.js"
 import { invalidateTokenBalancesCache } from "../../query/balance.queries.js"
 import { calcAmountUsdPrice } from "../../prices.js"
 import { checkAccountBalance } from "../utils/balanceChecker.js"
-import {
-  fetchCachedGasLimit,
-  createGasEstimationParams,
-} from "../../useGasEstimation.js"
 import { queryClient as defaultQueryClient } from "../../query/client.js"
 import {
   getFeesFromIntent,
@@ -63,7 +59,7 @@ import {
   trackPaymentError,
   trackTransactionConfirmed,
 } from "../../analytics.js"
-import { getFullErrorMessage } from "../../error.js"
+import { getFullErrorMessage, getIsAlreadyExecutingError } from "../../error.js"
 import { getIsCustomCalldata } from "../../contractUtils.js"
 import { isNativeToken } from "../../utils/address.js"
 import { ensureErc20Approval } from "../utils/erc20Approval.js"
@@ -109,6 +105,8 @@ export interface IntentHandlerParams {
   tradeType?: TradeType
   swapProvider?: RouteProvider | null
   bridgeProvider?: RouteProvider | null
+  swapProviderFallback?: boolean
+  bridgeProviderFallback?: boolean
   fundMethod?: FundMethod
   mode?: "pay" | "fund" | "earn" | "swap" | "withdraw"
   checkoutOnHandlers?: Partial<CheckoutOnHandlers>
@@ -132,10 +130,33 @@ export interface IntentHandlerParams {
   refundAddress?: string
 }
 
+function isFeeSelectionPassthroughEligible(params: {
+  selectedFeeOption: FeeOption | null | undefined
+  gasFeeOptions: GasFeeOptions | undefined
+}): boolean {
+  const { selectedFeeOption, gasFeeOptions } = params
+
+  // Undefined means no explicit user selection yet: stay conservative and use intent flow.
+  if (selectedFeeOption === undefined) {
+    return false
+  }
+
+  // Null means "native fee selected". This is only passthrough-safe if the native fee option
+  // advertised by backend is explicitly marked passthrough-eligible.
+  if (selectedFeeOption === null) {
+    const nativeFeeOption = gasFeeOptions?.feeOptions?.find((option) =>
+      isNativeToken(option.tokenAddress),
+    )
+    return nativeFeeOption?.isPassthroughEligible === true
+  }
+
+  return selectedFeeOption.isPassthroughEligible === true
+}
+
 /**
  * Execute a passthrough transaction (direct transfer, no intents).
  *
- * Used for same-chain same-token transfers with native gas payment.
+ * Used when backend marks quote passthrough-eligible and client-side fee gating allows it.
  * Handles ERC20 approval if needed for custom calldata scenarios (S4c).
  * See SPEC.md for flow decision details.
  */
@@ -556,18 +577,7 @@ async function executeIntent(
         })
       } catch (executeError: unknown) {
         // If intent is already executing, that's fine - it means the system picked it up
-        const errorMessage =
-          executeError instanceof Error ? executeError.message : ""
-        const errorCause =
-          typeof executeError === "object" &&
-          executeError !== null &&
-          "cause" in executeError
-            ? String((executeError as { cause?: unknown }).cause)
-            : ""
-        if (
-          errorMessage.includes("EXECUTING") ||
-          errorCause.includes("EXECUTING")
-        ) {
+        if (getIsAlreadyExecutingError(executeError)) {
           logger.console.log(
             "[trails-sdk] Intent already executing, continuing...",
           )
@@ -655,24 +665,28 @@ async function executeIntent(
             intentId: intent.intentId,
             depositTransactionHash: depositUserTxnReceipt.transactionHash,
           })
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling executeIntent:",
-            error,
-          )
+        } catch (executeError: unknown) {
+          // If intent is already executing (e.g. from early executeIntent call), that's fine
+          if (getIsAlreadyExecutingError(executeError)) {
+            logger.console.log(
+              "[trails-sdk] Intent already executing after deposit, continuing...",
+            )
+          } else {
+            logger.console.error(
+              "[trails-sdk] Error calling executeIntent:",
+              executeError,
+            )
+          }
         }
       }
     }
   }
-
   // Start polling for intent completion to update transaction states
   let finalReceipt: Awaited<ReturnType<typeof pollIntentReceipt>> = null
   if (intent.intentId) {
-    // Determine max wait time based on route provider
-    // OFT routes (LayerZero OFT and Stargate) can take 5-10+ minutes to complete
-    const isOFTRoute = intent.quote?.routeProviders?.some(
-      (p) => p === "LZ_OFT" || p === "LZ_STARGATE",
-    )
+    // Determine max wait time based on route provider.
+    // OFT routes (LayerZero OFT) can take 5-10+ minutes to complete.
+    const isOFTRoute = intent.quote?.routeProviders?.some((p) => p === "LZ_OFT")
     const maxWaitTime = isOFTRoute ? HOUR_MS : 10 * 60 * 1000 // 1 hour for OFT, 10 min for others
 
     logger.console.log("[trails-sdk] Intent polling configuration:", {
@@ -1082,11 +1096,10 @@ export async function handleIntent(
   params: IntentHandlerParams,
 ): Promise<PrepareSendReturn> {
   const {
-    queryClient: paramQueryClient,
     mainSignerAddress,
     originChainId,
     originTokenAddress,
-    // originTokenBalance not destructured — balance is checked via checkAccountBalance
+    originTokenBalance,
     originTokenDecimals,
     originTokenSymbol,
     destinationChainId,
@@ -1107,6 +1120,8 @@ export async function handleIntent(
     tradeType = TradeType.EXACT_INPUT,
     swapProvider: initialSwapProvider,
     bridgeProvider: initialBridgeProvider,
+    swapProviderFallback,
+    bridgeProviderFallback,
     fundMethod: fundMethodFromParams,
     mode,
     checkoutOnHandlers,
@@ -1123,7 +1138,6 @@ export async function handleIntent(
 
   logger.console.log("[trails-sdk] handleIntent called")
 
-  const effectiveQueryClient = paramQueryClient ?? defaultQueryClient
   const effectiveFundMethod = fundMethodFromParams ?? "wallet"
   const effectiveOriginChain = chain
   const effectiveOriginTokenAddress = originTokenAddress
@@ -1165,6 +1179,8 @@ export async function handleIntent(
     tradeType,
     swapProvider,
     bridgeProvider,
+    swapProviderFallback,
+    bridgeProviderFallback,
     undefined,
     walletId,
     isSmartWallet,
@@ -1212,30 +1228,6 @@ export async function handleIntent(
     throw new Error("Invalid intent")
   }
 
-  // Estimate gas using depositTransaction from API
-  // Use passthrough depositTransaction if available, otherwise use intent depositTransaction
-  const depositTxForGasEstimate =
-    passthrough?.passthroughTransaction ?? intent.depositTransaction
-  let estimatedGasLimit: bigint | undefined
-  if (depositTxForGasEstimate) {
-    try {
-      estimatedGasLimit = await fetchCachedGasLimit(
-        effectiveQueryClient,
-        effectivePublicClient,
-        createGasEstimationParams(
-          account.address,
-          depositTxForGasEstimate.to,
-          depositTxForGasEstimate.data ?? "0x",
-          BigInt(depositTxForGasEstimate.value ?? "0"),
-        ),
-        "intent-quote",
-      )
-    } catch (error) {
-      logger.console.warn("[trails-sdk] Gas estimation failed:", error)
-      estimatedGasLimit = undefined
-    }
-  }
-
   // Determine if passthrough should be used
   // SPEC: Only same-chain same-token with wallet fund method may use passthrough (C9b/C10/C11b/C12/D9b/D10/D11b/D12).
   // SPEC: Cross-chain (A/B), different-token (C1-C8/D1-D8), non-wallet (C13/C14/D13/D14), and gasless (G1-G20) must always use intents.
@@ -1243,21 +1235,22 @@ export async function handleIntent(
   // Backend sets passthrough.eligible, but we enforce structural invariants client-side as a safety net.
   // For ERC20 passthrough with custom calldata, the SDK handles approval if insufficient (see executePassthrough).
   const usePassthrough =
-    isSameChainSameToken &&
     effectiveFundMethod === "wallet" &&
     passthrough?.eligible === true &&
-    // NOTE: `selectedFeeOption` being `undefined` (unset) intentionally fails this check,
-    // conservatively falling back to the intent flow. Only an explicit `null` (native gas selected)
-    // or an explicit fee option selection with `isPassthroughEligible === true` enables passthrough.
-    (selectedFeeOption === null ||
-      selectedFeeOption?.isPassthroughEligible === true)
+    !!passthrough?.passthroughTransaction &&
+    isFeeSelectionPassthroughEligible({
+      selectedFeeOption,
+      gasFeeOptions,
+    })
 
   logger.console.log("[trails-sdk] Passthrough decision:", {
     usePassthrough,
     isSameChainSameToken,
     fundMethod: effectiveFundMethod,
     passthroughEligible: passthrough?.eligible,
+    hasPassthroughTransaction: !!passthrough?.passthroughTransaction,
     feeOptionPassthroughEligible: selectedFeeOption?.isPassthroughEligible,
+    selectedFeeOption,
   })
 
   // Use passthrough-specific deposit transaction and states when doing passthrough
@@ -1270,27 +1263,6 @@ export async function handleIntent(
   const quoteToAmount = intent.quote.toAmount.toString()
   const quoteToAmountMin = intent.quote.toAmountMin.toString() || quoteToAmount
 
-  // Now do the balance check with the actual deposit amount from the intent API
-  // This is the correct amount needed in origin token units
-  if (effectiveFundMethod === "wallet") {
-    const { hasEnoughBalance } = await checkAccountBalance({
-      account,
-      tokenAddress: originTokenAddress,
-      depositAmount: depositAmount,
-      publicClient: effectivePublicClient,
-    })
-    noSufficientBalance = !hasEnoughBalance
-    logger.console.log(
-      "[trails-sdk] Balance check with actual deposit amount:",
-      {
-        depositAmount,
-        originTokenAddress,
-        hasEnoughBalance,
-        noSufficientBalance,
-      },
-    )
-  }
-
   // Compute transaction states for both passthrough and intent flows
   // This allows the UI to switch between them based on fee option selection
   // SPEC: Passthrough-capable scenarios (C9b/C10/C11b/C12/D9b/D10/D11b/D12) expose passthrough transaction states; other scenarios use intent-flow states.
@@ -1311,51 +1283,78 @@ export async function handleIntent(
     ? passthroughTransactionStates
     : intentTransactionStates
 
-  // Build the normalized quote object
-  const quote = await getNormalizedQuoteObject({
-    originDepositAddress: usePassthrough
-      ? recipient
-      : intent.originIntentAddress,
-    destinationDepositAddress: usePassthrough
-      ? recipient
-      : intent.destinationIntentAddress,
-    destinationAddress: recipient,
-    trailsApiKey: trailsApiKey || "",
-    trailsApiUrl: trailsApiUrl || "",
-    sequenceMetadataUrl: sequenceMetadataUrl || "",
-    destinationCalldata,
-    originAmount: depositAmount,
-    destinationAmount: quoteToAmount,
-    originAmountMin: depositAmount,
-    destinationAmountMin: quoteToAmountMin,
-    originTokenAddress,
-    destinationTokenAddress,
-    originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
-    destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
-    fees: isSameChainSameToken
-      ? undefined
-      : getFeesFromIntent(intent, {
-          tradeType,
-          fromAmountUsd: calcAmountUsdPrice({
-            amount: rawAmountToNumber(depositAmount, originTokenDecimals),
-            usdPrice: sourceTokenPriceUsd,
-          }),
-          toAmountUsd: calcAmountUsdPrice({
-            amount: rawAmountToNumber(quoteToAmount, destinationTokenDecimals),
-            usdPrice: destinationTokenPriceUsd,
+  // Run balance check and quote normalization in parallel to reduce latency
+  const [balanceResult, quote] = await Promise.all([
+    effectiveFundMethod === "wallet"
+      ? checkAccountBalance({
+          account,
+          tokenAddress: originTokenAddress,
+          depositAmount: depositAmount,
+          publicClient: effectivePublicClient,
+          knownBalance: originTokenBalance,
+          decimals: originTokenDecimals,
+        })
+      : Promise.resolve({ hasEnoughBalance: true }),
+    getNormalizedQuoteObject({
+      originDepositAddress: usePassthrough
+        ? recipient
+        : intent.originIntentAddress,
+      destinationDepositAddress: usePassthrough
+        ? recipient
+        : intent.destinationIntentAddress,
+      destinationAddress: recipient,
+      trailsApiKey: trailsApiKey || "",
+      trailsApiUrl: trailsApiUrl || "",
+      sequenceMetadataUrl: sequenceMetadataUrl || "",
+      destinationCalldata,
+      originAmount: depositAmount,
+      destinationAmount: quoteToAmount,
+      originAmountMin: depositAmount,
+      destinationAmountMin: quoteToAmountMin,
+      originTokenAddress,
+      destinationTokenAddress,
+      originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
+      destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
+      fees: isSameChainSameToken
+        ? undefined
+        : getFeesFromIntent(intent, {
+            tradeType,
+            fromAmountUsd: calcAmountUsdPrice({
+              amount: rawAmountToNumber(depositAmount, originTokenDecimals),
+              usdPrice: sourceTokenPriceUsd,
+            }),
+            toAmountUsd: calcAmountUsdPrice({
+              amount: rawAmountToNumber(
+                quoteToAmount,
+                destinationTokenDecimals,
+              ),
+              usdPrice: destinationTokenPriceUsd,
+            }),
           }),
-        }),
-    originChainId,
-    destinationChainId,
-    slippageTolerance,
-    priceImpact: getPriceImpactFromIntent(intent),
-    priceImpactUsd: getPriceImpactUsdFromIntent(intent),
-    transactionStates,
-    originNativeTokenPriceUsd,
-    noSufficientBalance,
-    estimatedGasLimit,
-    intent: usePassthrough ? undefined : intent,
-  })
+      originChainId,
+      destinationChainId,
+      slippageTolerance,
+      priceImpact: getPriceImpactFromIntent(intent),
+      priceImpactUsd: getPriceImpactUsdFromIntent(intent),
+      transactionStates,
+      originNativeTokenPriceUsd,
+      intent: usePassthrough ? undefined : intent,
+    }),
+  ])
+
+  noSufficientBalance = !balanceResult.hasEnoughBalance
+  quote.noSufficientBalance = noSufficientBalance
+  if (effectiveFundMethod === "wallet") {
+    logger.console.log(
+      "[trails-sdk] Balance check with actual deposit amount:",
+      {
+        depositAmount,
+        originTokenAddress,
+        hasEnoughBalance: balanceResult.hasEnoughBalance,
+        noSufficientBalance,
+      },
+    )
+  }
 
   // Add passthrough-specific fields to the quote
   // This allows the UI to switch between passthrough and intent states based on fee option
@@ -1379,25 +1378,22 @@ export async function handleIntent(
       const { skipCommit, commitOnly, skipIntentMonitoring } = options
 
       try {
-        // Recalculate passthrough decision at send time based on fee option
-        // This allows the user to change fee option after getting the quote
-        // SPEC: All passthrough-capable scenarios (C9b/C10/C11b/C12/D9b/D10/D11b/D12) can switch to intent flow when a gasless fee option is selected.
+        // Recalculate passthrough decision at send time based on fee option.
+        // This allows switching between passthrough and intent flow after quote.
         const sendFeeOption = options.selectedFeeOption
-        // SPEC: Only same-chain same-token + wallet may passthrough (C9b/C10/C11b/C12/D9b/D10/D11b/D12).
-        // When selectedFeeOption is null, it means native token is selected (which is passthrough eligible)
         const sendUsePassthrough =
-          isSameChainSameToken &&
           effectiveFundMethod === "wallet" &&
           passthrough?.eligible === true &&
-          // NOTE: `sendFeeOption` being `undefined` (unset) intentionally fails this check,
-          // conservatively falling back to the intent flow. Only an explicit `null` (native gas selected)
-          // or a fee option with `isPassthroughEligible === true` enables passthrough.
-          (sendFeeOption === null ||
-            sendFeeOption?.isPassthroughEligible === true)
+          !!passthrough?.passthroughTransaction &&
+          isFeeSelectionPassthroughEligible({
+            selectedFeeOption: sendFeeOption,
+            gasFeeOptions,
+          })
 
         logger.console.log("[trails-sdk] Send passthrough decision:", {
           sendUsePassthrough,
           passthroughEligible: passthrough?.eligible,
+          hasPassthroughTransaction: !!passthrough?.passthroughTransaction,
           sendFeeOptionPassthroughEligible:
             sendFeeOption?.isPassthroughEligible,
           sendFeeOption,

package/src/transactionIntent/quote/normalizeQuote.ts

@@ -22,25 +22,22 @@ import { getZeroFees } from "./feeExtractors.js"
 import { formatDuration } from "../../utils/time.js"
 import { IntentProtocolVersion } from "@0xtrails/api"
 
-// TODO: make this dyanamic
-function isOFTRoute(routeProviders?: string[]): boolean {
-  return (
-    routeProviders?.some((p) => p === "LZ_OFT" || p === "LZ_STARGATE") ?? false
-  )
-}
-
 export function getCompletionEstimateSeconds({
   originChainId,
   destinationChainId,
-  routeProviders,
+  esimatedDurationSeconds,
 }: {
   originChainId: number
   destinationChainId: number
-  routeProviders?: string[]
+  esimatedDurationSeconds?: number | null
 }): number {
-  // OFT routes can take significantly longer than standard routes.
-  if (isOFTRoute(routeProviders)) {
-    return 20 * 60
+  // Prefer provider-estimated route duration from QuoteIntent API when available.
+  if (
+    esimatedDurationSeconds != null &&
+    Number.isFinite(esimatedDurationSeconds) &&
+    esimatedDurationSeconds >= 0
+  ) {
+    return Math.round(esimatedDurationSeconds)
   }
 
   if (originChainId === mainnet.id && destinationChainId === mainnet.id) {
@@ -57,25 +54,35 @@ export function getCompletionEstimateSeconds({
 function getCompletionEstimateDisplay({
   originChainId,
   destinationChainId,
-  routeProviders,
+  esimatedDurationSeconds,
 }: {
   originChainId: number
   destinationChainId: number
-  routeProviders?: string[]
+  esimatedDurationSeconds?: number | null
 }): string {
-  if (isOFTRoute(routeProviders)) {
-    return "5-20 min"
-  }
-
   return formatDuration(
     getCompletionEstimateSeconds({
       originChainId,
       destinationChainId,
-      routeProviders,
+      esimatedDurationSeconds,
     }),
   )
 }
 
+function getEsimatedDurationSeconds(intent?: Intent): number | undefined {
+  if (!intent?.quote) return undefined
+
+  const quote = intent.quote as { estimatedDuration?: unknown }
+  if (
+    typeof quote.estimatedDuration === "number" &&
+    Number.isFinite(quote.estimatedDuration)
+  ) {
+    return quote.estimatedDuration
+  }
+
+  return undefined
+}
+
 export async function getNormalizedQuoteObject({
   originDepositAddress,
   destinationDepositAddress,
@@ -253,7 +260,7 @@ export async function getNormalizedQuoteObject({
   let gasCost: string = "0"
   let gasCostFormatted: string = "0"
   try {
-    if (originNativeTokenPriceUsd) {
+    if (originNativeTokenPriceUsd && (estimatedGasLimit || providedFeeData)) {
       // Use the actual estimated gas limit if provided, otherwise use default
       // This ensures the quote gas cost matches what will be used in the actual transaction
       const gasLimitForCost = estimatedGasLimit || DEFAULT_MIN_GASLIMIT
@@ -414,10 +421,12 @@ export async function getNormalizedQuoteObject({
     },
   )
 
+  const esimatedDurationSeconds = getEsimatedDurationSeconds(intent)
+
   const completionEstimateSeconds = getCompletionEstimateSeconds({
     originChainId,
     destinationChainId,
-    routeProviders: intent?.quote?.routeProviders,
+    esimatedDurationSeconds,
   })
 
   return {
@@ -465,7 +474,7 @@ export async function getNormalizedQuoteObject({
     completionEstimateDisplay: getCompletionEstimateDisplay({
       originChainId,
       destinationChainId,
-      routeProviders: intent?.quote?.routeProviders,
+      esimatedDurationSeconds,
     }),
     transactionStates: transactionStates || [],
     gasCostUsd,

package/src/transactionIntent/quote/quoteHelpers.ts

@@ -9,6 +9,13 @@ import {
 import { TradeType } from "../types.js"
 import { logger } from "../../logger.js"
 
+type QuoteIntentRequestOptionsWithFallback = NonNullable<
+  QuoteIntentRequest["options"]
+> & {
+  swapProviderFallback?: boolean
+  bridgeProviderFallback?: boolean
+}
+
 export async function getIntentArgs(
   mainSignerAddress: string,
   originChainId: number,
@@ -24,6 +31,8 @@ export async function getIntentArgs(
   tradeType: TradeType,
   swapProvider?: RouteProvider | null,
   bridgeProvider?: RouteProvider | null,
+  swapProviderFallback?: boolean,
+  bridgeProviderFallback?: boolean,
   connector?: Connector | undefined,
   walletId?: string | undefined,
   isSmartWallet?: boolean,
@@ -73,6 +82,20 @@ export async function getIntentArgs(
     )
   }
 
+  const options: QuoteIntentRequestOptionsWithFallback = {
+    // When slippageTolerance is null (AUTO mode), don't send it so backend calculates optimal slippage
+    slippageTolerance:
+      slippageTolerance !== null ? Number(slippageTolerance) : undefined,
+    swapProvider: swapProvider || undefined,
+    bridgeProvider: bridgeProvider || undefined,
+  }
+  if (swapProviderFallback !== undefined) {
+    options.swapProviderFallback = swapProviderFallback
+  }
+  if (bridgeProviderFallback !== undefined) {
+    options.bridgeProviderFallback = bridgeProviderFallback
+  }
+
   const intentArgs: QuoteIntentRequest = {
     ownerAddress: mainSignerAddress,
     originChainId,
@@ -86,13 +109,7 @@ export async function getIntentArgs(
     destinationCallData: hasCustomCalldata ? destinationCalldata : "0x",
     destinationCallValue: BigInt("0"),
     onlyNativeGasFee,
-    options: {
-      // When slippageTolerance is null (AUTO mode), don't send it so backend calculates optimal slippage
-      slippageTolerance:
-        slippageTolerance !== null ? Number(slippageTolerance) : undefined,
-      swapProvider: swapProvider || undefined,
-      bridgeProvider: bridgeProvider || undefined,
-    },
+    options,
     tradeType,
   }
 

package/src/transactionIntent/types.ts

@@ -80,6 +80,8 @@ export type PrepareSendOptions = {
   originNativeTokenPriceUsd?: number | null
   swapProvider?: RouteProvider | null
   bridgeProvider?: RouteProvider | null
+  swapProviderFallback?: boolean
+  bridgeProviderFallback?: boolean
   fundMethod?: FundMethod
   mode?: "pay" | "fund" | "earn" | "swap" | "withdraw"
   originPublicClient?: PublicClient

package/src/transactionIntent/utils/balanceChecker.ts

@@ -13,11 +13,15 @@ export async function checkAccountBalance({
   tokenAddress,
   depositAmount,
   publicClient,
+  knownBalance,
+  decimals: knownDecimals,
 }: {
   account: Account
   tokenAddress: string
   depositAmount: string
   publicClient: PublicClient
+  knownBalance?: string
+  decimals?: number
 }): Promise<{
   hasEnoughBalance: boolean
   balance: bigint
@@ -29,11 +33,11 @@ export async function checkAccountBalance({
   try {
     let balance: bigint
 
-    if (isNativeToken(tokenAddress)) {
-      // Native token balance
+    if (knownBalance !== undefined) {
+      balance = BigInt(knownBalance)
+    } else if (isNativeToken(tokenAddress)) {
       balance = await publicClient.getBalance({ address: account.address })
     } else {
-      // ERC20 token balance
       balance = await publicClient.readContract({
         address: tokenAddress as `0x${string}`,
         abi: erc20Abi,
@@ -54,8 +58,10 @@ export async function checkAccountBalance({
     if (isNativeToken(tokenAddress)) {
       balanceFormatted = formatUnits(balance, 18)
       requiredAmountFormatted = formatUnits(requiredAmount, 18)
+    } else if (knownDecimals !== undefined) {
+      balanceFormatted = formatUnits(balance, knownDecimals)
+      requiredAmountFormatted = formatUnits(requiredAmount, knownDecimals)
     } else {
-      // ERC20 token balance
       const decimals = await publicClient.readContract({
         address: tokenAddress as `0x${string}`,
         abi: erc20Abi,