0xtrails 0.13.2 → 0.15.0

package/src/intents.ts

@@ -1,1133 +0,0 @@
-import type {
-  AbortIntentRequest,
-  AbortIntentResponse,
-  CommitIntentResponse,
-  DepositSignature,
-  ExecuteIntentRequest,
-  ExecuteIntentResponse,
-  GasFeeOptions,
-  GetIntentRequest,
-  GetIntentResponse,
-  Intent,
-  IntentStatus,
-  IntentCalls,
-  PassthroughInfo,
-  QuoteIntentRequest,
-  TrailsApi,
-  TrailsContracts,
-  TransactionStateInfo,
-} from "@0xtrails/api"
-import { logger } from "./logger.js"
-import { IntentProtocolVersion, JsonEncode } from "@0xtrails/api"
-import type { TrailsClient } from "./trailsClient.js"
-import type { KeyMachineClient } from "./keyMachineClient.js"
-import { getIntentStatusFromError } from "./error.js"
-
-import { Config, type Context, Payload } from "@0xsequence/wallet-primitives"
-import { Address, Bytes, ContractAddress, Hash, Hex } from "ox"
-import {
-  type Account,
-  type Chain,
-  encodeFunctionData,
-  erc20Abi,
-  type WalletClient,
-} from "viem"
-import {
-  trackIntentCommitCompleted,
-  trackIntentCommitError,
-  trackIntentCommitStarted,
-  trackIntentQuoteError,
-  trackIntentQuoteReceived,
-  trackIntentQuoteRequested,
-  trackTransactionError,
-  trackTransactionStarted,
-  trackTransactionSubmitted,
-} from "./analytics.js"
-import { getChainInfo, getChainRpcClient } from "./chains.js"
-import { attemptSwitchChain } from "./chainSwitch.js"
-import { SEQUENCE_V3_CONTRACT_ADDRESSES } from "./constants.js"
-import { getFullErrorMessage } from "./error.js"
-import { getFeeData } from "./estimate.js"
-import { zeroAddress } from "viem"
-import { addressEqual, isNativeToken } from "./utils/address.js"
-import { sendWalletTransaction } from "./walletUtils.js"
-
-export type IntentRequestParams = {
-  userAddress: string
-  originChainId: number
-  originTokenAddress: string
-  originTokenAmount: string
-  destinationChainId: number
-  destinationToAddress: string
-  destinationTokenAddress: string
-  destinationTokenAmount: string
-  destinationCallData: string
-  destinationCallValue: string
-}
-
-export interface MetaTxnFeeDetail {
-  metaTxnID: string
-  estimatedGasLimit: string
-  feeNative: string
-}
-
-export interface ChainExecuteQuote {
-  chainId: string
-  totalGasLimit: string
-  gasPrice: string
-  totalFeeAmount: string
-  nativeTokenSymbol: string
-  nativeTokenPrice?: string
-  metaTxnFeeDetails: Array<MetaTxnFeeDetail>
-  totalFeeUSD?: string
-}
-
-export interface ExecuteQuote {
-  chainQuotes: Array<ChainExecuteQuote>
-}
-
-export interface CrossChainFee {
-  providerFee: string
-  trailsSwapFee: string
-  providerFeeUSD: number
-  trailsSwapFeeUSD: number
-  totalFeeAmount: string
-  totalFeeUSD: number
-}
-
-export interface TrailsFee {
-  executeQuote: ExecuteQuote
-  crossChainFee?: CrossChainFee
-  trailsFixedFeeUSD?: number
-  feeToken?: string
-  originTokenTotalAmount?: string
-  totalFeeAmount?: string
-  totalFeeUSD?: string
-}
-
-export type { Intent }
-
-export type OriginCallParams = {
-  to: `0x${string}` | null
-  data: Hex.Hex | null
-  value: bigint | null
-  chainId: number | null
-  error?: string
-}
-
-export type SendOriginCallTxArgs = {
-  to: string
-  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 quoteIntent(
-  trailsClient: TrailsApi,
-  args: QuoteIntentRequest,
-  additionalTrackingProps: Record<string, string> = {},
-  abortSignal?: AbortSignal,
-): Promise<{
-  intent: Intent
-  gasFeeOptions?: GasFeeOptions
-  trailsContracts: TrailsContracts
-  passthrough?: PassthroughInfo
-  transactionStates?: TransactionStateInfo[]
-}> {
-  // Track intent quote request
-  trackIntentQuoteRequested({
-    originChainId: args.originChainId || 0,
-    destinationChainId: args.destinationChainId || 0,
-    originTokenAddress: args.originTokenAddress,
-    destinationTokenAddress: args.destinationTokenAddress,
-    userAddress: args.ownerAddress,
-    ...additionalTrackingProps,
-  })
-
-  try {
-    logger.console.log("[trails-sdk] quote intent args:", args)
-
-    type QuoteIntentResponse = Awaited<ReturnType<TrailsApi["quoteIntent"]>>
-
-    // Create a promise that rejects when the abort signal fires
-    let response: QuoteIntentResponse
-    if (abortSignal) {
-      const abortPromise = new Promise((_, reject) => {
-        if (abortSignal.aborted) {
-          reject(new Error("Request aborted"))
-        }
-        abortSignal.addEventListener("abort", () => {
-          reject(new Error("Request aborted"))
-        })
-      })
-
-      // Race between the API call and the abort signal
-      response = (await Promise.race([
-        trailsClient.quoteIntent(args, {}, abortSignal),
-        abortPromise,
-      ])) as QuoteIntentResponse
-    } else {
-      response = await trailsClient.quoteIntent(args)
-    }
-
-    if (!response || !(response as QuoteIntentResponse).intent) {
-      logger.console.error("[trails-sdk] No result from quoteIntent")
-      throw new Error("No result from quoteIntent")
-    }
-
-    const result = (response as QuoteIntentResponse).intent
-
-    // Extract precondition amounts from origin and destination preconditions
-    const originPrecondition = result.originPrecondition
-    const destinationPrecondition = result.destinationPrecondition
-
-    // Track successful intent quote received
-    const providerFeeUSD =
-      result.quote?.routeProvidersFeeUsd &&
-      Array.isArray(result.quote.routeProvidersFeeUsd) &&
-      result.quote.routeProvidersFeeUsd.length > 0
-        ? result.quote.routeProvidersFeeUsd.reduce(
-            (sum: number, fee: number) => sum + fee,
-            0,
-          )
-        : 0
-
-    trackIntentQuoteReceived({
-      quoteId: result.originIntentAddress || "unknown",
-      totalFeeUSD: result.fees?.totalFeeUsd?.toString(),
-      crossChainFeeTotalUSD: result.fees?.provider?.totalFeeUsd,
-      providerFeeUSD,
-      trailsSwapFeeUSD: result.fees?.provider?.trailsFeeUsd,
-      gasFeesPerChainUSD: [
-        typeof result.fees?.originGas?.totalFeeUsd === "string"
-          ? parseFloat(result.fees.originGas.totalFeeUsd)
-          : result.fees?.originGas?.totalFeeUsd || 0,
-        typeof result.fees?.destinationGas?.totalFeeUsd === "string"
-          ? parseFloat(result.fees.destinationGas.totalFeeUsd)
-          : result.fees?.destinationGas?.totalFeeUsd || 0,
-      ],
-      originTokenTotalAmount: undefined, // This field no longer exists in IntentFees
-      totalFeeAmount: result.fees?.totalFeeAmount?.toString(),
-      provider: result.quote?.routeProviders
-        ? result.quote.routeProviders.join(",")
-        : undefined,
-      swapProvider: result.quote?.routeProviders?.[0] || undefined,
-      bridgeProvider: result.quote?.routeProviders?.[1] || undefined,
-      feeToken: result.fees?.feeTokenAddress,
-      userAddress: args.ownerAddress,
-      intentAddress: result.originIntentAddress,
-      originPreconditionAmount: originPrecondition?.minAmount?.toString(),
-      destinationPreconditionAmount:
-        destinationPrecondition?.minAmount?.toString(),
-      fromAmount: result.quote?.fromAmount?.toString(),
-      fromAmountMin: result.quote?.fromAmountMin?.toString(),
-      toAmount: result.quote?.toAmount?.toString(),
-      toAmountMin: result.quote?.toAmountMin?.toString(),
-      ...additionalTrackingProps,
-    })
-
-    return {
-      intent: result,
-      gasFeeOptions: response.gasFeeOptions,
-      trailsContracts: result.trailsContracts,
-      passthrough: response.passthrough,
-      transactionStates: response.transactionStates,
-    }
-  } catch (error) {
-    logger.console.error("[trails-sdk] Error in getIntent", error)
-    // Track intent quote error
-    trackIntentQuoteError({
-      error: getFullErrorMessage(error),
-      userAddress: args.ownerAddress,
-      originChainId: args.originChainId || 0,
-      destinationChainId: args.destinationChainId || 0,
-      originTokenAddress: args.originTokenAddress,
-      destinationTokenAddress: args.destinationTokenAddress,
-      ...additionalTrackingProps,
-    })
-    throw error
-  }
-}
-
-export async function getIntentConfigurationFromAddress(
-  keyMachineClient: KeyMachineClient,
-  intentAddress: Address.Address,
-): Promise<{
-  address: Address.Address
-  imageHash: Hex.Hex
-  config: Config.Config
-}> {
-  const deployConfig = await keyMachineClient.getDeploy(intentAddress)
-  if (!deployConfig) {
-    throw new Error("Deploy config not found")
-  }
-  const { imageHash, context } = deployConfig
-  const config = await keyMachineClient.getConfiguration(imageHash)
-  if (!config) {
-    throw new Error("Configuration not found")
-  }
-  // Construct the address from the configuration as a double check
-  const derivedImageHash = Config.hashConfiguration(config)
-  const derivedAddress = calculateIntentAddressFromImageHash(
-    context,
-    derivedImageHash,
-  )
-  if (!Address.isEqual(derivedAddress, intentAddress)) {
-    throw new Error("Derived address does not match intent address")
-  }
-  return {
-    address: derivedAddress,
-    imageHash: Bytes.toHex(derivedImageHash),
-    config,
-  }
-}
-
-export async function getIntentConfigurationFromCalls(
-  _trailsClient: TrailsClient,
-  _intentId: string,
-  intentProtocol: IntentProtocolVersion,
-  mainSigner: string,
-  checkpoint: number,
-  calls: IntentCalls,
-  isOrigin: boolean,
-  context?: Context.Context,
-): Promise<{
-  address: `0x${string}`
-  imageHash: `0x${string}`
-  config: Config.Config
-}> {
-  logger.console.log(
-    "[trails-sdk] [intent-protocol] === Intent Configuration Calculation ===",
-    {
-      intentProtocol,
-      mainSigner,
-      checkpoint,
-      callsCount: calls?.calls?.length ?? 0,
-      isOrigin,
-      calculationMethod:
-        intentProtocol === IntentProtocolVersion.v1
-          ? "client-side (Merkle tree)"
-          : "(NOT IMPLEMENTED)",
-    },
-  )
-  if (intentProtocol === IntentProtocolVersion.v1) {
-    logger.console.log(
-      "[trails-sdk] [intent-protocol] v1: Calculating intent config client-side (deprecated)",
-      {
-        intentProtocol,
-        method: "buildMerkleTreeFromMembers + counterfactual address",
-      },
-    )
-    return getIntentConfigurationFromCallsV1(mainSigner, calls, context)
-  }
-
-  throw new Error(
-    "Intent protocol v1.5 configuration derivation is not implemented",
-  )
-}
-
-// @deprecated - v1 only
-function getIntentConfigurationFromCallsV1(
-  mainSigner: string,
-  calls: IntentCalls,
-  context?: Context.Context,
-): {
-  address: `0x${string}`
-  imageHash: `0x${string}`
-  config: Config.Config
-} {
-  logger.console.log(
-    "[trails-sdk] [intent-protocol] v1: Building Merkle tree client-side",
-    {
-      mainSigner,
-      callsCount: calls?.calls?.length ?? 0,
-    },
-  )
-
-  const sequenceContext = context || SEQUENCE_V3_CONTRACT_ADDRESSES
-
-  const config = createIntentConfigurationV1(Address.from(mainSigner), [calls])
-  const imageHash = Config.hashConfiguration(config)
-  const calculatedAddress = calculateIntentAddressFromImageHash(
-    sequenceContext,
-    imageHash,
-  )
-
-  logger.console.log("[trails-sdk] Final calculated configuration:", {
-    address: calculatedAddress.toString() as `0x${string}`,
-    imageHash: Bytes.toHex(imageHash) as `0x${string}`,
-  })
-
-  return {
-    address: calculatedAddress.toString() as `0x${string}`,
-    imageHash: Bytes.toHex(imageHash) as `0x${string}`,
-    config,
-  }
-}
-
-function calculateIntentAddressFromImageHash(
-  context: Context.Context,
-  imageHash: Bytes.Bytes,
-): Address.Address {
-  const hash = imageHash
-
-  logger.console.log(
-    "[trails-sdk] calculateIntentConfigurationAddress imageHash:",
-    Bytes.toHex(hash),
-  )
-
-  // Log context for debugging
-  logger.console.log("[trails-sdk] Context values:", {
-    factory: context.factory,
-    creationCode: context.creationCode,
-    stage1: context.stage1,
-  })
-
-  // Calculate the counterfactual address using the image hash and context
-  const address = ContractAddress.fromCreate2({
-    from: context.factory,
-    bytecodeHash: Hash.keccak256(
-      Bytes.concat(
-        Bytes.from(context.creationCode),
-        Bytes.padLeft(Bytes.from(context.stage1), 32),
-      ),
-      { as: "Bytes" },
-    ),
-    salt: hash,
-  })
-
-  logger.console.log("[trails-sdk] Final calculated address:", address)
-  return address
-}
-
-export async function calculateOriginAndDestinationIntentAddresses(
-  trailsClient: TrailsClient,
-  intentId: string,
-  intentProtocol: IntentProtocolVersion,
-  mainSigner: string,
-  checkpoint: number,
-  calls: Array<IntentCalls>,
-): Promise<{
-  originIntentAddress: Address.Address
-  destinationIntentAddress: Address.Address
-}> {
-  const originChainId = calls[0]?.chainId
-  const destinationChainId = calls[1]?.chainId || originChainId
-
-  logger.console.log("[trails-sdk] originChainId:", originChainId)
-  logger.console.log("[trails-sdk] destinationChainId:", destinationChainId)
-
-  // Different origin and destination chains: cross-chain execution.
-  const originCalls = calls.filter((c) => c.chainId === originChainId)
-  const destinationCalls = calls.filter((c) => c.chainId === destinationChainId)
-
-  logger.console.log("[trails-sdk] originCalls:", originCalls)
-  logger.console.log("[trails-sdk] destinationCalls:", destinationCalls)
-
-  if (originCalls.length !== 1) {
-    // This should never happen
-    logger.console.log("[trails-sdk] calls length incorrect")
-    throw new Error("origin calls length incorrect")
-  }
-
-  const { address: originIntentAddress } =
-    await getIntentConfigurationFromCalls(
-      trailsClient,
-      intentId,
-      intentProtocol,
-      mainSigner,
-      checkpoint,
-      originCalls[0]!,
-      true,
-    )
-  let destinationIntentAddress = originIntentAddress
-
-  // Calculate separate destination intent address if:
-  // 1. Cross-chain scenario (different chain IDs), OR
-  // 2. Same-chain with multiple payloads (e.g., custom calldata creates separate origin/destination payloads)
-  if (originChainId !== destinationChainId || calls.length > 1) {
-    if (destinationCalls.length !== 1) {
-      // This should never happen
-      logger.console.log("[trails-sdk] destination calls length incorrect")
-      throw new Error("destination calls length incorrect")
-    }
-    const { address } = await getIntentConfigurationFromCalls(
-      trailsClient,
-      intentId,
-      intentProtocol,
-      mainSigner,
-      checkpoint,
-      originCalls[0]!,
-      false,
-    )
-    destinationIntentAddress = address
-  }
-
-  logger.console.log("[trails-sdk] originIntentAddress:", originIntentAddress)
-  logger.console.log(
-    "[trails-sdk] destinationIntentAddress:",
-    destinationIntentAddress,
-  )
-
-  return { originIntentAddress, destinationIntentAddress }
-}
-
-export async function commitIntent(
-  trailsClient: TrailsClient,
-  intent: Intent,
-  additionalTrackingProps: Record<string, string> = {},
-): Promise<CommitIntentResponse> {
-  // Build arrays for logging
-  const originIntentCalls = intent.originCalls
-  const destinationIntentCalls = intent.destinationCalls
-  const calls = []
-  if (originIntentCalls) calls.push(originIntentCalls)
-  if (destinationIntentCalls) calls.push(destinationIntentCalls)
-
-  const originPre = intent.originPrecondition
-  const destinationPre = intent.destinationPrecondition
-  const preconditions = []
-  if (originPre) preconditions.push(originPre)
-  if (destinationPre) preconditions.push(destinationPre)
-
-  logger.console.log("[trails-sdk] commitIntent inputs:", {
-    intentId: intent.intentId,
-    ownerAddress: intent.ownerAddress,
-    originIntentAddress: intent.originIntentAddress,
-    destinationIntentAddress: intent.destinationIntentAddress,
-    calls,
-    preconditions,
-  })
-
-  // Additional detailed precondition logging
-  logger.console.log("[trails-sdk] Detailed preconditions:", preconditions)
-
-  // Log each precondition individually for easier reading
-  preconditions.forEach((precondition, index) => {
-    logger.console.log(`[trails-sdk] Precondition ${index}:`, {
-      type: precondition.type,
-      chainId: precondition.chainId,
-      ownerAddress: precondition.ownerAddress,
-      tokenAddress: precondition.tokenAddress,
-      minAmount: precondition.minAmount?.toString(),
-    })
-  })
-
-  logger.console.log(
-    "[trails-sdk] originIntentAddress:",
-    intent.originIntentAddress,
-  )
-  logger.console.log(
-    "[trails-sdk] destinationIntentAddress:",
-    intent.destinationIntentAddress,
-  )
-
-  const originChainIdStr = intent.quoteRequest.originChainId.toString()
-  const destinationChainIdStr =
-    intent.quoteRequest.destinationChainId.toString()
-
-  // Get the origin precondition owner address directly
-  const receivedAddress = originPre?.ownerAddress
-
-  logger.console.log("[trails-sdk] Address comparison:", {
-    receivedAddress,
-    calculatedAddress: intent.originIntentAddress,
-    match:
-      receivedAddress &&
-      addressEqual(receivedAddress, intent.originIntentAddress),
-  })
-
-  try {
-    // Track intent commit start
-    trackIntentCommitStarted({
-      intentAddress: intent.originIntentAddress,
-      userAddress: intent.ownerAddress,
-      originChainId: originChainIdStr ? Number(originChainIdStr) : undefined,
-      destinationChainId: destinationChainIdStr
-        ? Number(destinationChainIdStr)
-        : undefined,
-      ...additionalTrackingProps,
-    })
-
-    // Commit the intent that was returned from quoteIntent
-    const response = await trailsClient.commitIntent({
-      intent,
-    })
-
-    logger.console.log("[trails-sdk] commitIntent response:", response)
-
-    // Track successful intent commit
-    trackIntentCommitCompleted({
-      intentAddress: intent.originIntentAddress,
-      userAddress: intent.ownerAddress,
-      originChainId: originChainIdStr ? Number(originChainIdStr) : undefined,
-      destinationChainId: destinationChainIdStr
-        ? Number(destinationChainIdStr)
-        : undefined,
-      ...additionalTrackingProps,
-    })
-
-    return response
-  } catch (error) {
-    // Track intent commit error
-    trackIntentCommitError({
-      error: getFullErrorMessage(error),
-      userAddress: intent.ownerAddress,
-      intentAddress: intent.originIntentAddress,
-      originChainId: originChainIdStr ? Number(originChainIdStr) : undefined,
-      destinationChainId: destinationChainIdStr
-        ? Number(destinationChainIdStr)
-        : undefined,
-      ...additionalTrackingProps,
-    })
-    throw error
-  }
-}
-
-export async function executeIntent(
-  trailsClient: TrailsClient,
-  intentId: string,
-  depositTransactionHash?: string,
-  depositSignature?: DepositSignature,
-): Promise<ExecuteIntentResponse> {
-  logger.console.log("[trails-sdk] executeIntent inputs:", {
-    intentId,
-    providedDepositTransactionHash: depositTransactionHash,
-    hasDepositSignature: !!depositSignature,
-  })
-
-  const request: ExecuteIntentRequest = {
-    intentId,
-    depositSignature,
-  }
-
-  logger.console.log("[trails-sdk] executeIntent request:", request)
-
-  try {
-    const response = await trailsClient.executeIntent(request)
-    logger.console.log("[trails-sdk] executeIntent response:", response)
-
-    return response
-  } catch (error) {
-    const intentStatus = getIntentStatusFromError(error)
-
-    if (intentStatus) {
-      logger.console.log(
-        "[trails-sdk] executeIntent returned terminal/non-committed status, treating as current state",
-        {
-          intentId,
-          intentStatus,
-        },
-      )
-
-      return {
-        intentId,
-        intentStatus: intentStatus as IntentStatus,
-      }
-    }
-
-    throw error
-  }
-}
-
-export async function sendOriginTransaction(
-  account: Account,
-  walletClient: WalletClient,
-  originParams: SendOriginCallTxArgs,
-  additionalTrackingProps: Record<string, string> = {},
-): Promise<`0x${string}`> {
-  await attemptSwitchChain({
-    walletClient,
-    desiredChainId: originParams.chain.id,
-  })
-
-  // Track transaction start
-  trackTransactionStarted({
-    transactionType: "origin_call",
-    chainId: originParams.chain.id,
-    userAddress: account.address,
-    ...additionalTrackingProps,
-  })
-
-  const chainInfo = getChainInfo(originParams.chain.id)
-  if (!chainInfo) {
-    throw new Error(`Chain ${originParams.chain.id} not found`)
-  }
-  const publicClient = getChainRpcClient(chainInfo.id)
-
-  // Use provided gasLimit if available, otherwise let the wallet estimate
-  let gasLimit: bigint | undefined
-  if (originParams.gasLimit) {
-    gasLimit = originParams.gasLimit
-    logger.console.log(
-      "[trails-sdk][gas-estimation] using provided gasLimit:",
-      gasLimit,
-    )
-  } else {
-    logger.console.log(
-      "[trails-sdk][gas-estimation] no gasLimit provided, let wallet estimate",
-    )
-  }
-
-  // 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 sendWalletTransaction()",
-  )
-  const id = Date.now()
-  logger.console.time(`[trails-sdk] sendWalletTransaction-${id}`)
-
-  try {
-    // 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,
-    }
-    if (gasLimit) {
-      txParams.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 sendWalletTransaction(walletClient, txParams)
-    logger.console.timeEnd(`[trails-sdk] sendWalletTransaction-${id}`)
-    logger.console.log("[trails-sdk] done sending, origin tx hash", hash)
-
-    // Track successful transaction submission (pseudonymize() is called inside analytics)
-    trackTransactionSubmitted({
-      transactionHash: hash,
-      chainId: originParams.chain.id,
-      userAddress: account.address,
-      ...additionalTrackingProps,
-    })
-
-    if (!hash) {
-      throw new Error("No transaction hash returned from sendWalletTransaction")
-    }
-
-    return hash
-  } catch (error) {
-    logger.console.timeEnd(`[trails-sdk] sendWalletTransaction-${id}`)
-
-    // Track failed transaction
-    trackTransactionError({
-      transactionHash: "",
-      error: getFullErrorMessage(error),
-      userAddress: account.address,
-      ...additionalTrackingProps,
-    })
-
-    throw error
-  }
-}
-
-// @deprecated - v1 only
-function createIntentConfigurationV1(
-  mainSigner: Address.Address,
-  calls: IntentCalls[],
-): Config.Config {
-  const mainSignerLeaf: Config.SignerLeaf = {
-    type: "signer",
-    address: mainSigner,
-    weight: 1n,
-  }
-
-  logger.console.log("[trails-sdk] mainSignerLeaf:", mainSignerLeaf)
-
-  // Log detailed call information for debugging configuration mismatch
-  logger.console.log(
-    "[trails-sdk] calls:",
-    calls.map((call) => ({
-      chainId: call.chainId,
-      space: call.space,
-      nonce: call.nonce,
-      callsCount: call.calls.length,
-    })),
-  )
-
-  const subdigestLeaves: Config.AnyAddressSubdigestLeaf[] = calls.map(
-    (call) => {
-      const spaceValue = BigInt(call.space || 0)
-      const nonceValue = BigInt(call.nonce || 0)
-
-      logger.console.log(
-        `[trails-sdk] Processing call - chainId: ${call.chainId}, space: ${call.space} -> ${spaceValue}, nonce: ${call.nonce} -> ${nonceValue}`,
-      )
-
-      const payloadForHashing = {
-        type: "call" as const,
-        chainId: Number(call.chainId),
-        space: spaceValue,
-        nonce: nonceValue,
-        calls: call.calls.map((call) => ({
-          type: "call" as const,
-          to: call.to as `0x${string}`,
-          value: BigInt(call.value?.toString() || "0"),
-          data: Bytes.toHex(Bytes.from((call.data as Hex.Hex) || "0x")),
-          gasLimit: BigInt(call.gasLimit?.toString() || "0"),
-          delegateCall: !!call.delegateCall,
-          onlyFallback: !!call.onlyFallback,
-          behaviorOnError: (call.behaviorOnError === 0
-            ? "ignore"
-            : call.behaviorOnError === 1
-              ? "revert"
-              : "abort") as "ignore" | "revert" | "abort",
-        })),
-      }
-
-      logger.console.log(
-        "[DEBUG CREATION] Payload being hashed:",
-        payloadForHashing,
-      )
-      logger.console.log("[DEBUG CREATION] Chain ID:", Number(call.chainId))
-      logger.console.log(
-        "[DEBUG CREATION] Using zero address as verifying contract",
-      )
-
-      const digest = Payload.hash(
-        Address.from(zeroAddress),
-        Number(call.chainId),
-        payloadForHashing,
-      )
-      logger.console.log("[trails-sdk] digest:", Bytes.toHex(digest))
-      return {
-        type: "any-address-subdigest",
-        digest: Bytes.toHex(digest),
-      } as Config.AnyAddressSubdigestLeaf
-    },
-  )
-
-  logger.console.log("[trails-sdk] calls:", calls)
-  logger.console.log("[trails-sdk] subdigestLeaves:", subdigestLeaves)
-
-  const otherLeaves: Config.Topology[] = [...subdigestLeaves]
-
-  if (otherLeaves.length === 0) {
-    throw new Error(
-      "Intent configuration must have at least one call or LiFi information.",
-    )
-  }
-
-  let secondaryTopologyNode: Config.Topology
-
-  if (otherLeaves.length === 1) {
-    secondaryTopologyNode = otherLeaves[0]!
-  } else {
-    secondaryTopologyNode = buildMerkleTreeFromMembers(otherLeaves)
-  }
-
-  // Print the topology
-  logger.console.log(
-    "[trails-sdk] Topology:",
-    JsonEncode([mainSignerLeaf, secondaryTopologyNode]),
-  )
-
-  return {
-    threshold: 1n,
-    checkpoint: 0n,
-    topology: [mainSignerLeaf, secondaryTopologyNode] as Config.Node,
-  }
-}
-
-// @deprecated - v1 only
-// Renamed and generalized from createSubdigestTree
-function buildMerkleTreeFromMembers(
-  members: Config.Topology[],
-): Config.Topology {
-  if (members.length === 0) {
-    throw new Error("Cannot create a tree from empty members")
-  }
-  if (members.length === 1) {
-    return members[0]! // Returns a single Leaf or a Node
-  }
-
-  let currentLevel = [...members]
-  while (currentLevel.length > 1) {
-    const nextLevel: Config.Topology[] = []
-    for (let i = 0; i < currentLevel.length; i += 2) {
-      const left = currentLevel[i]!
-      if (i + 1 < currentLevel.length) {
-        const right = currentLevel[i + 1]!
-        nextLevel.push([left, right] as Config.Node)
-      } else {
-        // Odd one out, carries over to the next level
-        nextLevel.push(left)
-      }
-    }
-    currentLevel = nextLevel
-  }
-  return currentLevel[0]!
-}
-
-function _fromServiceConfig(config: any): Config.Config {
-  if (config.checkpointer !== undefined) {
-    Address.assert(config.checkpointer)
-  }
-
-  return {
-    threshold: BigInt(config.threshold),
-    checkpoint: BigInt(config.checkpoint),
-    checkpointer: config.checkpointer,
-    topology: fromServiceConfigTree(config.tree),
-  }
-}
-
-function fromServiceConfigTree(tree: any): Config.Topology {
-  logger.console.log("fromServiceConfigTree", tree)
-  switch (typeof tree) {
-    case "string":
-      Hex.assert(tree)
-      return tree
-
-    case "object":
-      if (Array.isArray(tree)) {
-        return [fromServiceConfigTree(tree[0]), fromServiceConfigTree(tree[1])]
-      }
-
-      if ("weight" in tree) {
-        if ("address" in tree) {
-          Address.assert(tree.address)
-
-          if (tree.imageHash) {
-            Hex.assert(tree.imageHash)
-            return {
-              type: "sapient-signer",
-              address: tree.address,
-              weight: BigInt(tree.weight),
-              imageHash: tree.imageHash,
-            }
-          } else {
-            return {
-              type: "signer",
-              address: tree.address,
-              weight: BigInt(tree.weight),
-            }
-          }
-        }
-
-        if ("tree" in tree) {
-          return {
-            type: "nested",
-            weight: BigInt(tree.weight),
-            threshold: BigInt(tree.threshold),
-            tree: fromServiceConfigTree(tree.tree),
-          }
-        }
-      }
-
-      if ("subdigest" in tree) {
-        Hex.assert(tree.subdigest)
-        return {
-          type: tree.isAnyAddress ? "any-address-subdigest" : "subdigest",
-          digest: tree.subdigest,
-        }
-      }
-  }
-
-  throw new Error(`unknown config tree ${JSON.stringify(tree)}`)
-}
-
-/**
- * Fetches intent data from the Trails API
- * @param trailsClient - TrailsClient instance
- * @param intentId - The intent ID to fetch
- * @returns Promise resolving to the intent data
- */
-export async function getIntent(
-  trailsClient: TrailsClient,
-  intentId: string,
-): Promise<GetIntentResponse> {
-  const request: GetIntentRequest = {
-    intentId,
-  }
-
-  return await trailsClient.getIntent(request)
-}
-
-/**
- * Abort an intent after a successful recovery
- * This should be called after the recover function executes successfully
- *
- * @param trailsClient - The Trails API client
- * @param intentId - The ID of the intent to abort
- * @param chainId - The chain ID where the recovery transaction was executed
- * @param abortTransactionHash - The transaction hash from the recovery
- * @returns Promise resolving to the abort response with intent status
- */
-export async function abortIntent(
-  trailsClient: TrailsClient,
-  intentId: string,
-  chainId: number,
-  abortTransactionHash: string,
-): Promise<AbortIntentResponse> {
-  logger.console.log("[trails-sdk] Aborting intent after recovery:", {
-    intentId,
-    chainId,
-    abortTransactionHash,
-  })
-
-  try {
-    const request: AbortIntentRequest = {
-      intentId,
-      chainId,
-      abortTransactionHash,
-    }
-
-    const response = await trailsClient.abortIntent(request)
-
-    logger.console.log("[trails-sdk] Intent aborted successfully:", {
-      intentId,
-      status: response.status,
-    })
-
-    return response
-  } catch (error) {
-    logger.console.error("[trails-sdk] Failed to abort intent:", {
-      intentId,
-      chainId,
-      abortTransactionHash,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    throw error
-  }
-}
-
-export function buildSameChainSameTokenTransactionParams({
-  hasCustomCalldata,
-  recipient,
-  effectiveOriginTokenAddress,
-  destinationCalldata,
-  swapAmount,
-  effectiveOriginChainId,
-  effectiveOriginChain,
-}: {
-  hasCustomCalldata: boolean
-  recipient: string
-  effectiveOriginTokenAddress: string
-  destinationCalldata?: string
-  swapAmount: string
-  effectiveOriginChainId: number
-  effectiveOriginChain: Chain
-}) {
-  const isNative = isNativeToken(effectiveOriginTokenAddress)
-
-  // Determine transaction data based on token type and calldata
-  let data: string
-  let to: string
-
-  if (hasCustomCalldata) {
-    // Custom calldata provided - use it directly
-    to = recipient
-    data = destinationCalldata || "0x"
-  } else if (isNative) {
-    // Native token transfer - no data needed
-    to = recipient
-    data = "0x"
-  } else {
-    // ERC20 token transfer - encode transfer function call
-    to = effectiveOriginTokenAddress
-    data = encodeFunctionData({
-      abi: erc20Abi,
-      functionName: "transfer",
-      args: [recipient as `0x${string}`, BigInt(swapAmount)],
-    })
-  }
-
-  return {
-    to,
-    data,
-    value: isNative ? BigInt(swapAmount) : "0",
-    chainId: effectiveOriginChainId,
-    chain: effectiveOriginChain,
-  }
-}
-
-/**
- * Build transaction parameters for cross-chain deposit transactions
- * Uses backend-provided transaction fields directly
- */
-export function buildCrossChainDepositParams({
-  depositTransaction,
-  chain,
-}: {
-  depositTransaction: {
-    to: string
-    data: string
-    value?: string | bigint
-    chainId: number
-  }
-  chain: Chain
-}) {
-  // Validate required backend-provided transaction fields
-  if (
-    !depositTransaction?.to ||
-    !depositTransaction?.data ||
-    !depositTransaction?.chainId ||
-    depositTransaction?.value == null
-  ) {
-    throw new Error(
-      "Backend did not provide required transaction fields (to, data, value, chainId) in depositTransaction.",
-    )
-  }
-
-  // Sanity check: compare local chain object chainId with API chainId
-  if (chain.id !== depositTransaction.chainId) {
-    throw new Error(
-      `Chain ID mismatch: local chain object has chainId ${chain.id} but depositTransaction has chainId ${depositTransaction.chainId}`,
-    )
-  }
-
-  return {
-    to: depositTransaction.to,
-    data: depositTransaction.data as Hex.Hex,
-    value: BigInt(depositTransaction.value ?? 0),
-    chainId: depositTransaction.chainId,
-    chain,
-  }
-}