0xtrails 0.2.4 → 0.2.5

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/intents.ts

@@ -53,6 +53,9 @@ import {
 } from "./analytics.js"
 import { getQueryParam } from "./queryParams.js"
 import { getFullErrorMessage } from "./error.js"
+import { GAS_BUFFER, getFeeData } from "./estimate.js"
+import { getERC20TransferData } from "./encoders.js"
+import { zeroAddress } from "viem"
 
 export type IntentRequestParams = {
   userAddress: string
@@ -126,6 +129,9 @@ export type SendOriginCallTxArgs = {
   data: Hex.Hex
   value: bigint
   chain: Chain
+  gasLimit?: bigint // Optional: if provided, skip gas estimation
+  maxFeePerGas?: bigint // Optional: EIP-1559 max fee per gas
+  maxPriorityFeePerGas?: bigint // Optional: EIP-1559 max priority fee per gas
 }
 
 export async function getLocalClientIfEnabled(
@@ -486,17 +492,67 @@ export async function sendOriginTransaction(
     transport: http(),
   })
 
-  const estimatedGasLimit = await publicClient.estimateGas({
-    account: account,
-    to: originParams.to as `0x${string}`,
-    data: originParams.data as `0x${string}`,
-    value: BigInt(originParams.value),
-  })
+  // Use provided gasLimit if available, otherwise estimate
+  let gasLimit: bigint
+  if (originParams.gasLimit) {
+    gasLimit = originParams.gasLimit
+    logger.console.log(
+      "[trails-sdk][gas-estimation] using provided gasLimit:",
+      gasLimit,
+    )
+  } else {
+    const estimatedGasLimit = await publicClient.estimateGas({
+      account: account,
+      to: originParams.to as `0x${string}`,
+      data: originParams.data as `0x${string}`,
+      value: BigInt(originParams.value),
+    })
 
-  const gsaBuffer = BigInt(50_000)
-  const gasLimit = estimatedGasLimit + gsaBuffer
+    gasLimit = estimatedGasLimit + GAS_BUFFER
+    logger.console.log(
+      "[trails-sdk][gas-estimation] estimated gasLimit in sendOriginTransaction:",
+      gasLimit,
+      "(estimated:",
+      estimatedGasLimit,
+      "buffer:",
+      GAS_BUFFER,
+      ")",
+    )
+  }
 
-  logger.console.log("[trails-sdk] estimated gasLimit:", gasLimit)
+  // Get fee parameters - try EIP-1559 first, then fall back to legacy
+  // Use provided fees if available, otherwise fetch and boost them for faster processing
+  let maxFeePerGas: bigint | undefined = originParams.maxFeePerGas
+  let maxPriorityFeePerGas: bigint | undefined =
+    originParams.maxPriorityFeePerGas
+  let gasPrice: bigint | undefined
+
+  if (!maxFeePerGas) {
+    try {
+      // Use getFeeData which applies the PRIORITY_FEE_MULTIPLIER
+      const feeData = await getFeeData(publicClient)
+
+      if (feeData.maxFeePerGas) {
+        maxFeePerGas = feeData.maxFeePerGas
+        maxPriorityFeePerGas = feeData.maxPriorityFeePerGas
+        logger.console.log(
+          "[trails-sdk][gas-estimation] Using boosted EIP-1559 fees in sendOriginTransaction:",
+          { maxFeePerGas, maxPriorityFeePerGas },
+        )
+      } else if (feeData.gasPrice) {
+        gasPrice = feeData.gasPrice
+        logger.console.log(
+          "[trails-sdk][gas-estimation] Using boosted legacy gas price in sendOriginTransaction:",
+          { gasPrice },
+        )
+      }
+    } catch (_error) {
+      // Fee data fetch failed, will use wallet default
+      logger.console.log(
+        "[trails-sdk][gas-estimation] Fee data fetch failed in sendOriginTransaction, wallet will use default",
+      )
+    }
+  }
 
   logger.console.log(
     "[trails-sdk] sending origin tx with walletClient.sendTransaction()",
@@ -505,14 +561,27 @@ export async function sendOriginTransaction(
   logger.console.time(`[trails-sdk] walletClient.sendTransaction-${id}`)
 
   try {
-    const hash = await walletClient.sendTransaction({
+    // Build transaction parameters - EIP-1559 and legacy are mutually exclusive
+    const txParams: any = {
       account: account,
       to: originParams.to as `0x${string}`,
       data: originParams.data as `0x${string}`,
       value: BigInt(originParams.value),
       chain: originParams.chain,
       gas: gasLimit,
-    })
+    }
+
+    // Add fee parameters based on transaction type
+    if (maxFeePerGas && maxPriorityFeePerGas) {
+      // EIP-1559 transaction
+      txParams.maxFeePerGas = maxFeePerGas
+      txParams.maxPriorityFeePerGas = maxPriorityFeePerGas
+    } else if (gasPrice) {
+      // Legacy transaction
+      txParams.gasPrice = gasPrice
+    }
+
+    const hash = await walletClient.sendTransaction(txParams)
     logger.console.timeEnd(`[trails-sdk] walletClient.sendTransaction-${id}`)
     logger.console.log("[trails-sdk] done sending, origin tx hash", hash)
 
@@ -807,3 +876,84 @@ function buildMerkleTreeFromMembers(
   }
   return currentLevel[0]!
 }
+
+/**
+ * Build transaction parameters for same-chain same-token transactions
+ * Centralizes the logic for determining transaction destination, data, and value
+ */
+export function buildSameChainTransactionParams({
+  hasCustomCalldata,
+  recipient,
+  effectiveOriginTokenAddress,
+  destinationCalldata,
+  swapAmount,
+  effectiveOriginChainId,
+  effectiveOriginChain,
+}: {
+  hasCustomCalldata: boolean
+  recipient: string
+  effectiveOriginTokenAddress: string
+  destinationCalldata?: string
+  swapAmount: string
+  effectiveOriginChainId: number
+  effectiveOriginChain: Chain
+}) {
+  return {
+    to: hasCustomCalldata
+      ? recipient
+      : effectiveOriginTokenAddress === zeroAddress
+        ? recipient
+        : effectiveOriginTokenAddress,
+    data: hasCustomCalldata
+      ? destinationCalldata || "0x"
+      : effectiveOriginTokenAddress === zeroAddress
+        ? "0x"
+        : getERC20TransferData({
+            recipient,
+            amount: BigInt(swapAmount),
+          }),
+    value:
+      effectiveOriginTokenAddress === zeroAddress ? BigInt(swapAmount) : "0",
+    chainId: effectiveOriginChainId,
+    chain: effectiveOriginChain,
+  }
+}
+
+/**
+ * Build transaction parameters for cross-chain deposit transactions
+ * Centralizes the logic for determining transaction destination, data, and value for deposits
+ */
+export function buildCrossChainDepositParams({
+  originTokenAddress,
+  originIntentAddress,
+  depositAmount,
+  fee,
+  originChainId,
+  chain,
+}: {
+  originTokenAddress: string
+  originIntentAddress: string
+  depositAmount: string
+  fee: string
+  originChainId: number
+  chain: Chain
+}) {
+  const totalAmount = BigInt(depositAmount) + BigInt(fee)
+
+  return {
+    to:
+      originTokenAddress === zeroAddress
+        ? originIntentAddress
+        : originTokenAddress,
+    data:
+      originTokenAddress === zeroAddress
+        ? "0x"
+        : getERC20TransferData({
+            recipient: originIntentAddress,
+            amount: totalAmount,
+          }),
+    value: originTokenAddress === zeroAddress ? totalAmount : "0",
+    chainId: originChainId,
+    chain,
+  }
+}

package/src/metaTxnMonitor.ts

@@ -5,7 +5,7 @@ import type {
   RelayerOperationStatus,
   RelayerOperationUnknownStatus,
 } from "./relayer.js"
-import type { RpcRelayer } from "@0xsequence/relayer"
+import type { Relayer } from "@0xsequence/relayer"
 import { type Query, useQueries } from "@tanstack/react-query"
 import { useMemo } from "react"
 import type { Hex } from "viem"
@@ -26,7 +26,7 @@ export type MetaTxnStatus = {
 const POLL_INTERVAL = 3_000 // 3 seconds
 
 export const getMetaTxStatus = async (
-  relayer: RpcRelayer.RpcRelayer,
+  relayer: Relayer.RpcRelayer,
   metaTxId: string,
   chainId: number,
 ): Promise<RelayerOperationStatus> => {
@@ -35,7 +35,7 @@ export const getMetaTxStatus = async (
 
 export const useMetaTxnsMonitor = (
   metaTxns: MetaTxn[] | undefined,
-  getRelayer: (chainId: number) => RpcRelayer.RpcRelayer,
+  getRelayer: (chainId: number) => Relayer.RpcRelayer,
 ) => {
   const results = useQueries({
     queries: (metaTxns || []).map((metaTxn) => {

package/src/metaTxns.ts

@@ -1,13 +1,11 @@
+import type { Relayer } from "@0xsequence/relayer"
 import type { IntentPrecondition } from "@0xsequence/trails-api"
 import type { Hex } from "viem"
 import type { MetaTxn } from "./metaTxnMonitor.js"
-import type { RpcRelayer } from "@0xsequence/relayer"
-
 import { logger } from "./logger.js"
-import type { Relayer } from "@0xsequence/relayer"
 
 export async function relayerSendMetaTx(
-  relayer: RpcRelayer.RpcRelayer,
+  relayer: Relayer.RpcRelayer,
   metaTx: MetaTxn,
   preconditions: IntentPrecondition[],
   feeQuote?: Relayer.FeeQuote,
@@ -25,7 +23,7 @@ export async function relayerSendMetaTx(
 }
 
 export async function getMetaTxnReceipt(
-  relayer: RpcRelayer.RpcRelayer,
+  relayer: Relayer.RpcRelayer,
   metaTxId: string,
   chainId: number,
 ): Promise<{ receipt: { status: "confirmed" | "failed" | "pending" } }> {