0xtrails 0.13.2 → 0.14.0

package/src/estimate.ts

@@ -1,480 +0,0 @@
-import { type PublicClient, formatUnits } from "viem"
-import { getChainInfo, getChainRpcClient } from "./chains.js"
-import { logger } from "./logger.js"
-import {
-  isValidNumber,
-  isPositiveNumber,
-  isNonNegativeNumber,
-} from "./utils/validation.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
-// Use a higher multiplier on Ethereum mainnet due to higher congestion
-export const MAINNET_PRIORITY_FEE_MULTIPLIER = 3.0
-
-function getPriorityFeeMultiplier(chainId?: number): number {
-  if (chainId === 1) {
-    return MAINNET_PRIORITY_FEE_MULTIPLIER
-  }
-  return PRIORITY_FEE_MULTIPLIER
-}
-
-/**
- * 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
-}> {
-  const chainId = publicClient.chain?.id
-  const multiplier = getPriorityFeeMultiplier(chainId)
-
-  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) * 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,
-          chainId,
-        },
-      )
-
-      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) * multiplier))
-
-    logger.console.log(
-      "[trails-sdk][gas-estimation] Boosting legacy gas price for faster processing:",
-      {
-        originalGasPrice: gasPrice,
-        boostedGasPrice,
-        multiplier,
-        chainId,
-      },
-    )
-
-    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
- */
-export async function estimateGasCost(
-  publicClient: PublicClient,
-  gasLimit: bigint = 100_000n,
-): Promise<bigint> {
-  try {
-    const feeData = await getFeeData(publicClient)
-
-    // Use maxFeePerGas for EIP-1559, otherwise use legacy gas price
-    const effectiveGasPrice = feeData.maxFeePerGas || feeData.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) {
-    throw new Error(`Failed to estimate gas cost: ${error}`)
-  }
-}
-
-/**
- * Estimates gas cost and returns it formatted as a string
- * @param publicClient - Viem public client for the chain
- * @param gasLimit - Gas limit in wei (defaults to 100,000)
- * @param decimals - Number of decimals for formatting (defaults to 18)
- * @returns Promise<string> - Formatted gas cost string
- */
-export async function estimateGasCostFormatted(
-  publicClient: PublicClient,
-  gasLimit: bigint = 100_000n,
-  decimals: number = 18,
-): Promise<string> {
-  const gasCost = await estimateGasCost(publicClient, gasLimit)
-  return formatUnits(gasCost, decimals)
-}
-
-/**
- * Estimates gas cost in USD (requires price feed)
- * @param publicClient - Viem public client for the chain
- * @param nativeTokenPriceUSD - Price of native token in USD
- * @param gasLimit - Gas limit in wei (defaults to 100,000)
- * @returns Promise<number> - Estimated gas cost in USD
- */
-export async function estimateGasCostUsd(
-  publicClient: PublicClient,
-  nativeTokenPriceUsd: number,
-  gasLimit: bigint = 100_000n,
-): Promise<number> {
-  const gasCost = await estimateGasCost(publicClient, gasLimit)
-  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 (!isPositiveNumber(balance)) {
-      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 (!isNonNegativeNumber(gasCost)) {
-      return userBalanceFormatted
-    }
-
-    // If gas cost is zero, return full balance
-    if (gasCost === 0) {
-      return userBalanceFormatted
-    }
-
-    // Validate buffer percentage
-    const safeBufferPercentage =
-      typeof bufferPercentage === "number" &&
-      isNonNegativeNumber(bufferPercentage) &&
-      bufferPercentage <= 100
-        ? bufferPercentage
-        : 50
-
-    // Add buffer to gas cost (default 50% to handle gas price spikes)
-    const gasWithBuffer = gasCost * (1 + safeBufferPercentage / 100)
-
-    // Check for overflow
-    if (!isValidNumber(gasWithBuffer)) {
-      return "0"
-    }
-
-    // Calculate max amount
-    const maxAmount = balance - gasWithBuffer
-
-    // Check for invalid result
-    if (!isValidNumber(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 (!isPositiveNumber(balanceNum)) {
-      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 = getChainRpcClient(chain.id)
-
-          // 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/explorer.ts

@@ -1,38 +0,0 @@
-import { getChainInfo } from "./chains.js"
-
-export type ExplorerUrlParams = {
-  txHash: string
-  chainId: number
-}
-
-export type ExplorerUrlForAddressParams = {
-  address: string
-  chainId: number
-}
-
-export function getBaseExplorerUrl(chainId: number): string {
-  const chain = getChainInfo(chainId)
-  if (chain) {
-    return `${chain.blockExplorers?.default?.url}`
-  }
-  return ""
-}
-
-export function getExplorerUrl({ txHash, chainId }: ExplorerUrlParams): string {
-  if (!txHash) {
-    return ""
-  }
-  const baseExplorerUrl = getBaseExplorerUrl(chainId)
-  return `${baseExplorerUrl}/tx/${txHash}`
-}
-
-export function getExplorerUrlForAddress({
-  address,
-  chainId,
-}: ExplorerUrlForAddressParams): string {
-  if (!address) {
-    return ""
-  }
-  const baseExplorerUrl = getBaseExplorerUrl(chainId)
-  return `${baseExplorerUrl}/address/${address}`
-}