0xtrails 0.2.4 → 0.2.6

package/src/estimate.ts

@@ -1,7 +1,156 @@
-import { type PublicClient, formatUnits } from "viem"
+import { type PublicClient, formatUnits, createPublicClient, http } from "viem"
+import { getChainInfo } from "./chains.js"
+import { logger } from "./logger.js"
+
+// Default minimum gas limit for deposit transactions
+// Used as fallback when gas estimation is not available
+// Buffer is only added when dynamically estimating gas, not when using this default
+export const DEFAULT_MIN_GASLIMIT = 250_000n
+
+// Buffer added to estimated gas (only applied when gas is dynamically estimated)
+export const GAS_BUFFER = 50_000n
+
+// Fee multiplier for faster transaction processing (similar to MetaMask's "Aggressive" mode)
+// 2x priority fee increases likelihood of quick inclusion
+export const PRIORITY_FEE_MULTIPLIER = 2.0
+
+/**
+ * Estimate gas limit for a transaction with consistent logic
+ * Buffer is only applied when gas is dynamically estimated (not when using DEFAULT_MIN_GASLIMIT)
+ * @param publicClient - Viem public client for the chain
+ * @param params - Transaction parameters for gas estimation
+ * @param logContext - Context string for logging (e.g., "quote", "deposit")
+ * @returns Gas limit as bigint, or undefined if estimation fails
+ */
+export async function estimateGasLimit(
+  publicClient: PublicClient,
+  params: {
+    account: string
+    to: string | bigint | number
+    data: string | bigint | number
+    value: bigint | string | number
+  },
+  logContext: string = "transaction",
+): Promise<bigint | undefined> {
+  try {
+    const estimatedGasLimit = await publicClient.estimateGas({
+      account: params.account as `0x${string}`,
+      to: params.to as `0x${string}`,
+      data: params.data as `0x${string}`,
+      value:
+        typeof params.value === "bigint" ? params.value : BigInt(params.value),
+    })
+
+    // Only add buffer when we actually estimated gas (estimatedGasLimit > DEFAULT_MIN_GASLIMIT)
+    // If estimation is below default, just use default without buffer
+    let gasLimit: bigint
+    if (estimatedGasLimit > DEFAULT_MIN_GASLIMIT) {
+      // Dynamic estimation - add buffer for safety
+      gasLimit = estimatedGasLimit + GAS_BUFFER
+      logger.console.log(
+        `[trails-sdk][gas-estimation] estimated gasLimit for ${logContext}:`,
+        gasLimit,
+        "(estimated:",
+        estimatedGasLimit,
+        "buffer:",
+        GAS_BUFFER,
+        ")",
+      )
+    } else {
+      // Use default minimum without buffer
+      gasLimit = DEFAULT_MIN_GASLIMIT
+      logger.console.log(
+        `[trails-sdk][gas-estimation] using default gasLimit for ${logContext}:`,
+        gasLimit,
+        "(estimated was:",
+        estimatedGasLimit,
+        "which is below default)",
+      )
+    }
+
+    return gasLimit
+  } catch (error) {
+    logger.console.error(
+      `[trails-sdk][gas-estimation] Error estimating gas limit for ${logContext}:`,
+      error,
+    )
+    return undefined
+  }
+}
+
+/**
+ * Get fee parameters (EIP-1559 or legacy) from a public client
+ * Applies PRIORITY_FEE_MULTIPLIER for faster transaction processing
+ * @param publicClient - Viem public client for the chain
+ * @returns Promise<FeeData> - Fee data including maxFeePerGas and maxPriorityFeePerGas if available
+ */
+export async function getFeeData(publicClient: PublicClient): Promise<{
+  maxFeePerGas?: bigint
+  maxPriorityFeePerGas?: bigint
+  gasPrice?: bigint
+}> {
+  try {
+    // Try to get EIP-1559 fee data
+    const feeData = await publicClient.estimateFeesPerGas()
+
+    if (feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
+      // EIP-1559 chain - apply multiplier for faster processing
+      // Increase priority fee by multiplier (e.g., 2x)
+      const boostedPriorityFee = BigInt(
+        Math.floor(
+          Number(feeData.maxPriorityFeePerGas) * PRIORITY_FEE_MULTIPLIER,
+        ),
+      )
+
+      // Calculate additional fee to add to maxFeePerGas
+      const additionalFee = boostedPriorityFee - feeData.maxPriorityFeePerGas
+      const boostedMaxFee = feeData.maxFeePerGas + additionalFee
+
+      logger.console.log(
+        "[trails-sdk][gas-estimation] Boosting fees for faster processing:",
+        {
+          originalMaxFee: feeData.maxFeePerGas,
+          originalPriorityFee: feeData.maxPriorityFeePerGas,
+          boostedMaxFee,
+          boostedPriorityFee,
+          multiplier: PRIORITY_FEE_MULTIPLIER,
+        },
+      )
+
+      return {
+        maxFeePerGas: boostedMaxFee,
+        maxPriorityFeePerGas: boostedPriorityFee,
+      }
+    }
+  } catch (_error) {
+    // EIP-1559 not supported, fall through to legacy
+  }
+
+  // Fallback to legacy gas price - also apply multiplier
+  try {
+    const gasPrice = await publicClient.getGasPrice()
+    const boostedGasPrice = BigInt(
+      Math.floor(Number(gasPrice) * PRIORITY_FEE_MULTIPLIER),
+    )
+
+    logger.console.log(
+      "[trails-sdk][gas-estimation] Boosting legacy gas price for faster processing:",
+      {
+        originalGasPrice: gasPrice,
+        boostedGasPrice,
+        multiplier: PRIORITY_FEE_MULTIPLIER,
+      },
+    )
+
+    return { gasPrice: boostedGasPrice }
+  } catch (error) {
+    throw new Error(`Failed to get fee data: ${error}`)
+  }
+}
 
 /**
  * Estimates gas cost for a transaction on a given chain
+ * Properly handles EIP-1559 fees (uses maxFeePerGas) on supported chains
  * @param publicClient - Viem public client for the chain
  * @param gasLimit - Gas limit in wei (defaults to 100,000)
  * @returns Promise<bigint> - Estimated gas cost in wei
@@ -11,11 +160,17 @@ export async function estimateGasCost(
   gasLimit: bigint = 100_000n,
 ): Promise<bigint> {
   try {
-    // Get current gas price from the chain
-    const gasPrice = await publicClient.getGasPrice()
+    const feeData = await getFeeData(publicClient)
+
+    // Use maxFeePerGas for EIP-1559, otherwise use legacy gas price
+    const effectiveGasPrice = feeData.maxFeePerGas || feeData.gasPrice
 
-    // Calculate gas cost: gas limit * gas price
-    const gasCost = gasLimit * gasPrice
+    if (!effectiveGasPrice) {
+      throw new Error("Could not determine gas price")
+    }
+
+    // Calculate gas cost: gas limit * effective gas price
+    const gasCost = gasLimit * effectiveGasPrice
 
     return gasCost
   } catch (error) {
@@ -55,3 +210,259 @@ export async function estimateGasCostUsd(
   const gasCostInEth = parseFloat(formatUnits(gasCost, 18))
   return gasCostInEth * nativeTokenPriceUsd
 }
+
+/**
+ * Calculate maximum amount for native token considering gas costs
+ * @param userBalanceFormatted - User's balance as formatted string (e.g., "1.5")
+ * @param gasCostFormatted - Gas cost in native token from quote (e.g., "0.001")
+ * @param bufferPercentage - Safety buffer % (default 50% for gas price volatility)
+ * @returns Maximum usable amount as formatted string (never throws, returns "0" on error)
+ */
+export function calculateMaxNativeAmount(
+  userBalanceFormatted: string,
+  gasCostFormatted?: string,
+  bufferPercentage: number = 50,
+): string {
+  logger.console.log(
+    "[trails-sdk][gas-estimation] calculateMaxNativeAmount called with:",
+    { userBalanceFormatted, gasCostFormatted, bufferPercentage },
+  )
+  try {
+    // Validate inputs
+    if (!userBalanceFormatted || typeof userBalanceFormatted !== "string") {
+      logger.console.log(
+        "[trails-sdk][gas-estimation] Invalid userBalanceFormatted, returning 0",
+      )
+      return "0"
+    }
+
+    const balance = parseFloat(userBalanceFormatted)
+
+    // Check for invalid balance
+    if (Number.isNaN(balance) || !Number.isFinite(balance) || balance <= 0) {
+      return "0"
+    }
+
+    // If no gas estimate, return full balance
+    if (!gasCostFormatted || typeof gasCostFormatted !== "string") {
+      return userBalanceFormatted
+    }
+
+    const gasCost = parseFloat(gasCostFormatted)
+
+    // Check for invalid gas cost
+    if (Number.isNaN(gasCost) || !Number.isFinite(gasCost) || gasCost < 0) {
+      return userBalanceFormatted
+    }
+
+    // If gas cost is zero, return full balance
+    if (gasCost === 0) {
+      return userBalanceFormatted
+    }
+
+    // Validate buffer percentage
+    const safeBufferPercentage =
+      typeof bufferPercentage === "number" &&
+      Number.isFinite(bufferPercentage) &&
+      bufferPercentage >= 0
+        ? bufferPercentage
+        : 50
+
+    // Add buffer to gas cost (default 50% to handle gas price spikes)
+    const gasWithBuffer = gasCost * (1 + safeBufferPercentage / 100)
+
+    // Check for overflow
+    if (!Number.isFinite(gasWithBuffer)) {
+      return "0"
+    }
+
+    // Calculate max amount
+    const maxAmount = balance - gasWithBuffer
+
+    // Check for invalid result
+    if (Number.isNaN(maxAmount) || !Number.isFinite(maxAmount)) {
+      return "0"
+    }
+
+    // If not enough for gas, return 0
+    if (maxAmount <= 0) {
+      return "0"
+    }
+
+    // Return with reasonable precision (6 decimals)
+    const result = maxAmount.toFixed(6)
+
+    // Final validation of result
+    if (!result || typeof result !== "string") {
+      return "0"
+    }
+
+    logger.console.log(
+      "[trails-sdk][gas-estimation] calculateMaxNativeAmount result:",
+      { balance, gasCost, gasWithBuffer, maxAmount, result },
+    )
+
+    return result
+  } catch (error) {
+    // Catch any unexpected errors and return safe default
+    logger.console.error(
+      "[trails-sdk][gas-estimation] Error in calculateMaxNativeAmount:",
+      error,
+    )
+    return "0"
+  }
+}
+
+/**
+ * Calculate a conservative default gas cost using real gas price
+ * Buffer is only added when gas is dynamically estimated above DEFAULT_MIN_GASLIMIT
+ * Properly handles EIP-1559 fees (maxFeePerGas + maxPriorityFee) on supported chains
+ * Falls back to 1% of balance if gas price fetch fails
+ *
+ * @param balance - User's balance as formatted string
+ * @param chainId - Chain ID to fetch gas price from
+ * @param account - Account address for gas estimation (optional)
+ * @param to - Transaction recipient address (optional)
+ * @param data - Transaction data (optional)
+ * @param value - Transaction value (optional)
+ * @returns Promise<string> - Estimated gas cost in native token units
+ */
+export async function getDefaultGasCostEstimate(
+  balance: string,
+  chainId?: number,
+  account?: string,
+  to?: string,
+  data?: string,
+  value?: string,
+): Promise<string> {
+  logger.console.log(
+    "[trails-sdk][gas-estimation] getDefaultGasCostEstimate called with:",
+    {
+      balance,
+      chainId,
+      hasAccount: !!account,
+      hasTo: !!to,
+      hasData: !!data,
+      hasValue: !!value,
+    },
+  )
+  try {
+    const balanceNum = parseFloat(balance)
+    if (Number.isNaN(balanceNum) || balanceNum <= 0) {
+      logger.console.log(
+        "[trails-sdk][gas-estimation] Invalid balance, returning 0",
+      )
+      return "0"
+    }
+
+    // Try to get real gas price if chainId is provided
+    if (chainId) {
+      try {
+        const chain = getChainInfo(chainId)
+        if (chain) {
+          const publicClient = createPublicClient({
+            chain,
+            transport: http(),
+          })
+
+          // Try to estimate gas if we have transaction details
+          let gasLimit = DEFAULT_MIN_GASLIMIT
+          if (account && to && data !== undefined && value !== undefined) {
+            try {
+              const estimatedGas = await publicClient.estimateGas({
+                account: account as `0x${string}`,
+                to: to as `0x${string}`,
+                data: data as `0x${string}`,
+                value: BigInt(value),
+              })
+              // Only add buffer when dynamically estimating gas above default
+              if (estimatedGas > DEFAULT_MIN_GASLIMIT) {
+                gasLimit = estimatedGas + GAS_BUFFER
+                logger.console.log(
+                  "[trails-sdk][gas-estimation] Using estimated gas + buffer for max button:",
+                  { estimatedGas, buffer: GAS_BUFFER, gasLimit },
+                )
+              } else {
+                gasLimit = DEFAULT_MIN_GASLIMIT
+                logger.console.log(
+                  "[trails-sdk][gas-estimation] Using default gas limit for max button (estimated was below default):",
+                  { estimatedGas, gasLimit },
+                )
+              }
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk][gas-estimation] Error estimating gas for max button, using default:",
+                error,
+              )
+              // Use default if estimation fails (no buffer)
+            }
+          }
+
+          // Get gas price - use getFeeData which applies the speed multiplier
+          let effectiveGasPrice: bigint
+          try {
+            const feeData = await getFeeData(publicClient)
+            effectiveGasPrice = feeData.maxFeePerGas || feeData.gasPrice || 0n
+
+            if (effectiveGasPrice === 0n) {
+              throw new Error("Could not determine gas price")
+            }
+
+            logger.console.log(
+              "[trails-sdk][gas-estimation] Using boosted fee data for max button:",
+              {
+                maxFeePerGas: feeData.maxFeePerGas,
+                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+                gasPrice: feeData.gasPrice,
+                effectiveGasPrice,
+              },
+            )
+          } catch (_error) {
+            // If getFeeData fails, fall back to basic gas price with manual multiplier
+            logger.console.log(
+              "[trails-sdk][gas-estimation] getFeeData failed, using fallback with multiplier",
+            )
+            const basicGasPrice = await publicClient.getGasPrice()
+            effectiveGasPrice = BigInt(
+              Math.floor(Number(basicGasPrice) * PRIORITY_FEE_MULTIPLIER),
+            )
+          }
+
+          // Calculate gas cost: gasLimit × effectiveGasPrice
+          const gasCostWei = gasLimit * effectiveGasPrice
+
+          // Convert to native token units (always 18 decimals)
+          const gasCostFormatted = formatUnits(gasCostWei, 18)
+
+          logger.console.log(
+            "[trails-sdk][gas-estimation] Calculated gas cost for max button:",
+            { gasLimit, effectiveGasPrice, gasCostWei, gasCostFormatted },
+          )
+
+          return gasCostFormatted
+        }
+      } catch (error) {
+        logger.console.error(
+          "[trails-sdk][gas-estimation] Error fetching gas price for max button:",
+          error,
+        )
+        // Fall through to percentage-based fallback
+      }
+    }
+
+    // Fallback: Reserve 1% of balance for gas
+    // This works for any native token and any chain
+    const defaultGasCost = balanceNum * 0.01
+    logger.console.log(
+      "[trails-sdk][gas-estimation] Using fallback 1% gas cost estimate:",
+      { balance: balanceNum, defaultGasCost: defaultGasCost.toFixed(6) },
+    )
+    return defaultGasCost.toFixed(6)
+  } catch (error) {
+    logger.console.error(
+      "[trails-sdk][gas-estimation] Error in getDefaultGasCostEstimate:",
+      error,
+    )
+    return "0"
+  }
+}

package/src/fees.ts

@@ -0,0 +1,199 @@
+import type { GetIntentCallsPayloadsReturn } from "./intents.js"
+import { getTokenInfo } from "./tokens.js"
+import { formatRawAmount, formatUsdAmountDisplay } from "./tokenBalances.js"
+import { zeroAddress } from "viem"
+
+export interface FeeItem {
+  amount: string
+  tokenSymbol: string
+  tokenAddress: string
+  chainId: number
+  usdValue: string
+}
+
+export interface TrailsFeeBreakdown {
+  originRelayFee?: FeeItem
+  destinationRelayFee?: FeeItem
+  providerFee?: FeeItem
+  trailsFee?: FeeItem
+  totalUsdValue?: string
+  originChainId?: number
+  destinationChainId?: number
+}
+
+// Helper function to format token amounts with proper decimal conversion
+async function formatTokenAmount(
+  amount: string | number | undefined,
+  tokenAddress: string,
+  chainId: number,
+): Promise<string> {
+  if (!amount) return "0"
+  const num = typeof amount === "string" ? parseFloat(amount) : amount
+  if (num === 0) return "0"
+
+  // Get token info to determine decimals
+  const tokenInfo = await getTokenInfo(chainId, tokenAddress)
+  if (!tokenInfo?.decimals) {
+    throw new Error(
+      `Token decimals not found for token ${tokenAddress} on chain ${chainId}`,
+    )
+  }
+
+  // Use existing formatRawAmount utility
+  const formatted = formatRawAmount(BigInt(Math.floor(num)), tokenInfo.decimals)
+
+  // Handle very small amounts
+  const numFormatted = parseFloat(formatted)
+  if (numFormatted < 0.000001 && numFormatted > 0) return "<0.000001"
+
+  return formatted
+}
+
+// Extract fee breakdown from intent data
+export async function extractTrailsFeeBreakdown(
+  intent: GetIntentCallsPayloadsReturn,
+): Promise<TrailsFeeBreakdown | null> {
+  const trailsFee = intent.payloads?.trailsFee
+  if (!trailsFee?.executeQuote?.chainQuotes) {
+    return null
+  }
+
+  const chainQuotes = trailsFee.executeQuote.chainQuotes
+
+  // Get chain IDs from the calls array to determine origin and destination chains
+  const calls = intent.payloads?.calls || []
+  const originChainId = calls[0]?.chainId // First call is origin chain
+  const destinationChainId = calls[1]?.chainId // Second call is destination chain
+
+  // Find quotes by chainId
+  const originChainQuote = chainQuotes.find(
+    (quote: any) => quote.chainId === originChainId,
+  )
+  const destinationChainQuote = chainQuotes.find(
+    (quote: any) => quote.chainId === destinationChainId,
+  )
+
+  // If we can't find any chain quotes, return null
+  if (!originChainQuote && !destinationChainQuote) {
+    console.warn(
+      "[trails-sdk] Could not find any chain quotes for fee breakdown",
+      {
+        originChainId,
+        destinationChainId,
+        availableChainIds: chainQuotes.map((q: any) => q.chainId),
+      },
+    )
+    return null
+  }
+
+  const breakdown: TrailsFeeBreakdown = {}
+
+  // Extract origin relay fee if available
+  if (originChainQuote) {
+    const originTokenSymbol = originChainQuote.nativeTokenSymbol || "ETH"
+    const originChainIdNum = parseInt(originChainId || "0", 10)
+    const nativeTokenAddress = zeroAddress
+
+    breakdown.originRelayFee = {
+      amount: await formatTokenAmount(
+        originChainQuote.totalFeeAmount,
+        nativeTokenAddress,
+        originChainIdNum,
+      ),
+      tokenSymbol: originTokenSymbol,
+      tokenAddress: nativeTokenAddress,
+      chainId: originChainIdNum,
+      usdValue: formatUsdAmountDisplay(originChainQuote.totalFeeUSD),
+    }
+    breakdown.originChainId = originChainIdNum
+  }
+
+  // Extract destination relay fee if available
+  if (destinationChainQuote) {
+    const destinationTokenSymbol =
+      destinationChainQuote.nativeTokenSymbol || "ETH"
+    const destinationChainIdNum = parseInt(destinationChainId || "0", 10)
+    const nativeTokenAddress = zeroAddress
+
+    breakdown.destinationRelayFee = {
+      amount: await formatTokenAmount(
+        destinationChainQuote.totalFeeAmount,
+        nativeTokenAddress,
+        destinationChainIdNum,
+      ),
+      tokenSymbol: destinationTokenSymbol,
+      tokenAddress: nativeTokenAddress,
+      chainId: destinationChainIdNum,
+      usdValue: formatUsdAmountDisplay(destinationChainQuote.totalFeeUSD),
+    }
+    breakdown.destinationChainId = destinationChainIdNum
+  }
+
+  // Extract provider fee from crossChainFee if available
+  const providerFeeAmount = trailsFee.crossChainFee?.providerFeeUSD
+  const providerFeeRawAmount = trailsFee.crossChainFee?.providerFee
+  if (providerFeeAmount !== undefined || providerFeeRawAmount !== undefined) {
+    const feeTokenAddress = trailsFee.feeToken || zeroAddress
+    const originChainIdNum = parseInt(originChainId || "0", 10)
+
+    // Get token info to determine the actual token symbol
+    const feeTokenInfo = await getTokenInfo(originChainIdNum, feeTokenAddress)
+    if (!feeTokenInfo?.symbol) {
+      throw new Error(
+        `Token symbol not found for provider fee token ${feeTokenAddress} on chain ${originChainIdNum}`,
+      )
+    }
+
+    breakdown.providerFee = {
+      amount: await formatTokenAmount(
+        providerFeeRawAmount,
+        feeTokenAddress,
+        originChainIdNum,
+      ),
+      tokenSymbol: feeTokenInfo.symbol,
+      tokenAddress: feeTokenAddress,
+      chainId: originChainIdNum,
+      usdValue: formatUsdAmountDisplay(providerFeeAmount),
+    }
+  }
+
+  // Extract Trails platform fee from crossChainFee if available
+  const trailsFeeAmount = trailsFee.crossChainFee?.trailsSwapFeeUSD
+  const trailsFeeRawAmount = trailsFee.crossChainFee?.trailsSwapFee
+  if (trailsFeeAmount !== undefined || trailsFeeRawAmount !== undefined) {
+    const feeTokenAddress = trailsFee.feeToken || zeroAddress
+    const originChainIdNum = parseInt(originChainId || "0", 10)
+
+    // Get token info to determine the actual token symbol
+    const feeTokenInfo = await getTokenInfo(originChainIdNum, feeTokenAddress)
+    if (!feeTokenInfo?.symbol) {
+      throw new Error(
+        `Token symbol not found for trails fee token ${feeTokenAddress} on chain ${originChainIdNum}`,
+      )
+    }
+
+    breakdown.trailsFee = {
+      amount: await formatTokenAmount(
+        trailsFeeRawAmount,
+        feeTokenAddress,
+        originChainIdNum,
+      ),
+      tokenSymbol: feeTokenInfo.symbol,
+      tokenAddress: feeTokenAddress,
+      chainId: originChainIdNum,
+      usdValue: formatUsdAmountDisplay(trailsFeeAmount),
+    }
+  }
+
+  // Calculate total USD value from the actual data
+  const originUsd = parseFloat(originChainQuote?.totalFeeUSD || "0")
+  const destinationUsd = parseFloat(destinationChainQuote?.totalFeeUSD || "0")
+  const providerUsd =
+    typeof providerFeeAmount === "number" ? providerFeeAmount : 0
+  const trailsUsd = typeof trailsFeeAmount === "number" ? trailsFeeAmount : 0
+  const totalUsd = originUsd + destinationUsd + providerUsd + trailsUsd
+
+  breakdown.totalUsdValue = formatUsdAmountDisplay(totalUsd)
+
+  return breakdown
+}