0xtrails 0.2.4 → 0.2.6

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" } }> {

package/src/morpho.ts

@@ -1,5 +1,6 @@
 import { useMemo, useState, useEffect } from "react"
 import type { Address, PublicClient } from "viem"
+import { encodeFunctionData } from "viem"
 import { logger } from "./logger.js"
 
 type AccrualPosition = any
@@ -425,4 +426,35 @@ export async function getAllVaults(
   return transformedVaults
 }
 
+/**
+ * Generate Morpho vault withdraw calldata
+ * @param asset - The address of the underlying asset to withdraw
+ * @param amount - The amount to withdraw in wei (or max uint256 for full balance)
+ * @param to - The address that will receive the underlying tokens
+ * @returns Encoded calldata for Morpho withdraw function
+ */
+export function generateMorphoWithdrawCalldata(
+  asset: string,
+  amount: bigint,
+  to: string,
+): `0x${string}` {
+  return encodeFunctionData({
+    abi: [
+      {
+        name: "withdraw",
+        type: "function",
+        stateMutability: "nonpayable",
+        inputs: [
+          { name: "asset", type: "address" },
+          { name: "amount", type: "uint256" },
+          { name: "to", type: "address" },
+        ],
+        outputs: [{ type: "uint256" }],
+      },
+    ],
+    functionName: "withdraw",
+    args: [asset as `0x${string}`, amount, to as `0x${string}`],
+  })
+}
+
 export default useMorphoVaults