@luxexchange/lx 1.0.0

package/src/features/transactions/swap/review/hooks/useTokenApprovalInfo.ts

@@ -0,0 +1,190 @@
+import { Currency, CurrencyAmount } from '@uniswap/sdk-core'
+import { GasFeeResult, TradingApi } from '@luxexchange/api'
+import { useMemo } from 'react'
+import { useLuxContextSelector } from '@luxexchange/lx/src/contexts/LuxContext'
+import { useCheckApprovalQuery } from '@luxexchange/lx/src/data/apiClients/tradingApi/useCheckApprovalQuery'
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { convertGasFeeToDisplayValue, useActiveGasStrategy } from '@luxexchange/lx/src/features/gas/hooks'
+import { ApprovalAction, TokenApprovalInfo } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+import { isDEX } from '@luxexchange/lx/src/features/transactions/swap/utils/routing'
+import {
+  getTokenAddressForApi,
+  toTradingApiSupportedChainId,
+} from '@luxexchange/lx/src/features/transactions/swap/utils/tradingApi'
+import { WrapType } from '@luxexchange/lx/src/features/transactions/types/wrap'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+import { ONE_MINUTE_MS, ONE_SECOND_MS } from '@luxfi/utilities/src/time/time'
+
+export interface TokenApprovalInfoParams {
+  chainId: UniverseChainId
+  wrapType: WrapType
+  currencyInAmount: Maybe<CurrencyAmount<Currency>>
+  currencyOutAmount?: Maybe<CurrencyAmount<Currency>>
+  routing: TradingApi.Routing | undefined
+  address?: string
+}
+
+export type ApprovalTxInfo = {
+  tokenApprovalInfo: TokenApprovalInfo
+  approvalGasFeeResult: GasFeeResult
+  revokeGasFeeResult: GasFeeResult
+}
+
+function useApprovalWillBeBatchedWithSwap(chainId: UniverseChainId, routing: TradingApi.Routing | undefined): boolean {
+  const canBatchTransactions = useLuxContextSelector((ctx) => ctx.getCanBatchTransactions?.(chainId))
+  const swapDelegationInfo = useLuxContextSelector((ctx) => ctx.getSwapDelegationInfo?.(chainId))
+
+  const isBatchableFlow = Boolean(routing && !isDEX({ routing }))
+
+  return Boolean((canBatchTransactions || swapDelegationInfo?.delegationAddress) && isBatchableFlow)
+}
+
+export function useTokenApprovalInfo(params: TokenApprovalInfoParams): ApprovalTxInfo {
+  const { address, chainId, wrapType, currencyInAmount, currencyOutAmount, routing } = params
+
+  const isWrap = wrapType !== WrapType.NotApplicable
+  /** Approval is included elsewhere for Chained Actions so it can be skipped */
+  const isChained = routing === TradingApi.Routing.CHAINED
+
+  const currencyIn = currencyInAmount?.currency
+  const amount = currencyInAmount?.quotient.toString()
+
+  const tokenInAddress = getTokenAddressForApi(currencyIn)
+
+  // Only used for bridging
+  const isBridge = routing === TradingApi.Routing.BRIDGE
+  const currencyOut = currencyOutAmount?.currency
+  const tokenOutAddress = getTokenAddressForApi(currencyOut)
+
+  const gasStrategy = useActiveGasStrategy(chainId, 'general')
+
+  const approvalRequestArgs: TradingApi.ApprovalRequest | undefined = useMemo(() => {
+    const tokenInChainId = toTradingApiSupportedChainId(chainId)
+    const tokenOutChainId = toTradingApiSupportedChainId(currencyOut?.chainId)
+
+    if (!address || !amount || !currencyIn || !tokenInAddress || !tokenInChainId) {
+      return undefined
+    }
+    if (isBridge && !tokenOutAddress && !tokenOutChainId) {
+      return undefined
+    }
+
+    return {
+      walletAddress: address,
+      token: tokenInAddress,
+      amount,
+      chainId: tokenInChainId,
+      includeGasInfo: true,
+      tokenOut: tokenOutAddress,
+      tokenOutChainId,
+      gasStrategies: [gasStrategy],
+    }
+  }, [
+    gasStrategy,
+    address,
+    amount,
+    chainId,
+    currencyIn,
+    currencyOut?.chainId,
+    isBridge,
+    tokenInAddress,
+    tokenOutAddress,
+  ])
+
+  const approvalWillBeBatchedWithSwap = useApprovalWillBeBatchedWithSwap(chainId, routing)
+  const shouldSkip = !approvalRequestArgs || isWrap || !address || approvalWillBeBatchedWithSwap || isChained
+
+  const { data, isLoading, error } = useCheckApprovalQuery({
+    params: shouldSkip ? undefined : approvalRequestArgs,
+    staleTime: 15 * ONE_SECOND_MS,
+    immediateGcTime: ONE_MINUTE_MS,
+  })
+
+  const tokenApprovalInfo: TokenApprovalInfo = useMemo(() => {
+    if (error) {
+      logger.error(error, {
+        tags: { file: 'useTokenApprovalInfo', function: 'useTokenApprovalInfo' },
+        extra: {
+          approvalRequestArgs,
+        },
+      })
+    }
+
+    // Approval is N/A for wrap transactions or unconnected state.
+    if (isWrap || !address || approvalWillBeBatchedWithSwap || isChained) {
+      return {
+        action: ApprovalAction.None,
+        txRequest: null,
+        cancelTxRequest: null,
+      }
+    }
+
+    if (data && !error) {
+      // API returns null if no approval is required
+
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (data.approval === null) {
+        return {
+          action: ApprovalAction.None,
+          txRequest: null,
+          cancelTxRequest: null,
+        }
+      }
+
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (data.approval) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (data.cancel) {
+          return {
+            action: ApprovalAction.RevokeAndPermit2Approve,
+            txRequest: data.approval,
+            cancelTxRequest: data.cancel,
+          }
+        }
+
+        return {
+          action: ApprovalAction.Permit2Approve,
+          txRequest: data.approval,
+          cancelTxRequest: null,
+        }
+      }
+    }
+
+    // No valid approval type found
+    return {
+      action: ApprovalAction.Unknown,
+      txRequest: null,
+      cancelTxRequest: null,
+    }
+  }, [address, approvalRequestArgs, approvalWillBeBatchedWithSwap, data, error, isWrap, isChained])
+
+  return useMemo(() => {
+    const gasEstimate = data?.gasEstimates?.[0]
+    const noApprovalNeeded = tokenApprovalInfo.action === ApprovalAction.None
+    const noRevokeNeeded =
+      tokenApprovalInfo.action === ApprovalAction.Permit2Approve || tokenApprovalInfo.action === ApprovalAction.None
+    const approvalFee = noApprovalNeeded ? '0' : data?.gasFee
+    const revokeFee = noRevokeNeeded ? '0' : data?.cancelGasFee
+
+    const unknownApproval = tokenApprovalInfo.action === ApprovalAction.Unknown
+    const isGasLoading = unknownApproval && isLoading
+    const approvalGasError = unknownApproval && !isLoading ? new Error('Approval action unknown') : null
+
+    return {
+      tokenApprovalInfo,
+      approvalGasFeeResult: {
+        value: approvalFee,
+        displayValue: convertGasFeeToDisplayValue(approvalFee, gasStrategy),
+        isLoading: isGasLoading,
+        error: approvalGasError,
+        gasEstimate,
+      },
+      revokeGasFeeResult: {
+        value: revokeFee,
+        displayValue: convertGasFeeToDisplayValue(revokeFee, gasStrategy),
+        isLoading: isGasLoading,
+        error: approvalGasError,
+      },
+    }
+  }, [gasStrategy, data?.cancelGasFee, data?.gasEstimates, data?.gasFee, isLoading, tokenApprovalInfo])
+}

package/src/features/transactions/swap/review/services/swapTxAndGasInfoService/bridge/bridgeSwapTxAndGasInfoService.ts

@@ -0,0 +1,25 @@
+import type { GasStrategy } from '@luxfi/api'
+import type { TransactionSettings } from '@luxexchange/lx/src/features/transactions/components/settings/types'
+import type { EVMSwapInstructionsService } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/evm/evmSwapInstructionsService'
+import { createGetEVMSwapTransactionRequestInfo } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/evm/utils'
+import type { SwapTxAndGasInfoService } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/swapTxAndGasInfoService'
+import { getBridgeSwapTxAndGasInfo } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/utils'
+import type { BridgeTrade } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+
+export function createBridgeSwapTxAndGasInfoService(ctx: {
+  instructionService: EVMSwapInstructionsService
+  gasStrategy: GasStrategy
+  transactionSettings: TransactionSettings
+  v4SwapEnabled: boolean
+}): SwapTxAndGasInfoService<BridgeTrade> {
+  const getEVMSwapTransactionRequestInfo = createGetEVMSwapTransactionRequestInfo(ctx)
+
+  const service: SwapTxAndGasInfoService<BridgeTrade> = {
+    async getSwapTxAndGasInfo(params) {
+      const swapTxInfo = await getEVMSwapTransactionRequestInfo(params)
+      return getBridgeSwapTxAndGasInfo({ ...params, swapTxInfo })
+    },
+  }
+
+  return service
+}

package/src/features/transactions/swap/review/services/swapTxAndGasInfoService/chained/chainedActionTxSwapAndGasInfoService.ts

@@ -0,0 +1,114 @@
+import { type GasFeeResult, type GasStrategy, TradingApi } from '@luxexchange/api'
+import type { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { convertGasFeeToDisplayValue } from '@luxexchange/lx/src/features/gas/hooks'
+import type { SwapDelegationInfo } from '@luxexchange/lx/src/features/smartWallet/delegation/types'
+import { getPlanCompoundSlippageTolerance } from '@luxexchange/lx/src/features/transactions/swap/plan/slippage'
+import type { SwapTxAndGasInfoService } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/swapTxAndGasInfoService'
+import { type ChainedSwapTxAndGasInfo } from '@luxexchange/lx/src/features/transactions/swap/types/swapTxAndGasInfo'
+import type { ChainedActionTrade } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+import { tradingApiToUniverseChainId } from '@luxexchange/lx/src/features/transactions/swap/utils/tradingApi'
+
+const UNUSED_CHAINED_ACTIONS_FIELDS: Pick<
+  ChainedSwapTxAndGasInfo,
+  'approveTxRequest' | 'revocationTxRequest' | 'txRequests'
+> = {
+  approveTxRequest: undefined,
+  revocationTxRequest: undefined,
+  txRequests: undefined,
+}
+/**
+ * Creates a SwapTxAndGasInfoService for Chained Action trades. Since creating a trade is a non trivial
+ * operation we only create 1 trade per quote. When the quote changes, we request a new trade plan,
+ * otherwise the existing trade plan is refreshed.
+ *
+ * @returns SwapTxAndGasInfoService for Chained Action trades
+ */
+export function createChainedActionSwapTxAndGasInfoService(ctx?: {
+  getSwapDelegationInfo?: (chainId?: UniverseChainId) => SwapDelegationInfo
+}): SwapTxAndGasInfoService<ChainedActionTrade> {
+  let planId: string | undefined
+  let prevQuoteHash: string | undefined
+  const service: SwapTxAndGasInfoService<ChainedActionTrade> = {
+    async getSwapTxAndGasInfo(params) {
+      const { trade, derivedSwapInfo } = params
+      const newQuote = trade.quote.quote
+
+      const newQuoteHash = derivedSwapInfo.trade.quoteHash
+
+      if (newQuoteHash !== prevQuoteHash) {
+        planId = undefined
+      }
+
+      prevQuoteHash = newQuoteHash
+
+      // We're skipping the plan creation for now until we decide on whether we
+      // want the quote to pass a metaroute to createOrGetPlan()
+      //
+      // const skip = getSwapInputExceedsBalance({ derivedSwapInfo })
+      //
+      // const tradeResponse = skip
+      //   ? undefined
+      //   : await createOrGetPlan({
+      //       inputPlanId: planId,
+      //       quote: trade.quote.quote,
+      //       routing: TradingApi.Routing.CHAINED,
+      //     })
+      // // Preserve tradeId if previous fetch was skipped
+      // planId = tradeResponse?.planId ?? planId
+
+      const gasStrategy: GasStrategy | undefined = newQuote.gasEstimates?.[0]
+        ? { ...newQuote.gasEstimates[0].strategy, displayLimitInflationFactor: 1 }
+        : undefined
+
+      const gasFee: GasFeeResult = {
+        value: newQuote.gasFee,
+        displayValue: convertGasFeeToDisplayValue(newQuote.gasFee, gasStrategy),
+        isLoading: false,
+        error: null,
+      }
+
+      return {
+        ...UNUSED_CHAINED_ACTIONS_FIELDS,
+        routing: TradingApi.Routing.CHAINED,
+        trade,
+        gasFee,
+        gasFeeEstimation: {},
+        includesDelegation: getIncludesDelegationForChainedQuote(newQuote, ctx?.getSwapDelegationInfo),
+        planId,
+        slippageTolerance: getPlanCompoundSlippageTolerance(newQuote.steps),
+      }
+    },
+  }
+
+  return service
+}
+
+function getIncludesDelegationForChainedQuote(
+  quote: TradingApi.ChainedQuote,
+  getSwapDelegationInfo?: (chainId?: UniverseChainId) => SwapDelegationInfo,
+): boolean {
+  if (!getSwapDelegationInfo) {
+    return false
+  }
+
+  const chainIds = new Set<TradingApi.ChainId>()
+  for (const step of quote.steps ?? []) {
+    if (step.tokenInChainId !== undefined) {
+      chainIds.add(step.tokenInChainId)
+    }
+  }
+
+  // Fallback to top-level chain ID if steps don't specify chain IDs
+  if (chainIds.size === 0) {
+    chainIds.add(quote.tokenInChainId)
+  }
+
+  for (const apiChainId of chainIds) {
+    const universeChainId = tradingApiToUniverseChainId(apiChainId)
+    if (universeChainId && getSwapDelegationInfo(universeChainId).delegationInclusion) {
+      return true
+    }
+  }
+
+  return false
+}

package/src/features/transactions/swap/review/services/swapTxAndGasInfoService/classic/classicSwapTxAndGasInfoService.ts

@@ -0,0 +1,30 @@
+import type { GasStrategy } from '@luxfi/api'
+import type { TransactionSettings } from '@luxexchange/lx/src/features/transactions/components/settings/types'
+import type { EVMSwapInstructionsService } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/evm/evmSwapInstructionsService'
+import { createGetEVMSwapTransactionRequestInfo } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/evm/utils'
+import type { SwapTxAndGasInfoService } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/swapTxAndGasInfoService'
+import {
+  createGetPermitTxInfo,
+  getClassicSwapTxAndGasInfo,
+} from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/utils'
+import type { ClassicTrade } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+
+export function createClassicSwapTxAndGasInfoService(ctx: {
+  instructionService: EVMSwapInstructionsService
+  gasStrategy: GasStrategy
+  transactionSettings: TransactionSettings
+}): SwapTxAndGasInfoService<ClassicTrade> {
+  const getEVMSwapTransactionRequestInfo = createGetEVMSwapTransactionRequestInfo(ctx)
+  const getPermitTxInfo = createGetPermitTxInfo(ctx)
+
+  const service: SwapTxAndGasInfoService<ClassicTrade> = {
+    async getSwapTxAndGasInfo(params) {
+      const swapTxInfo = await getEVMSwapTransactionRequestInfo(params)
+      const permitTxInfo = getPermitTxInfo(params.trade)
+
+      return getClassicSwapTxAndGasInfo({ ...params, swapTxInfo, permitTxInfo })
+    },
+  }
+
+  return service
+}

package/src/features/transactions/swap/review/services/swapTxAndGasInfoService/constants.ts

@@ -0,0 +1,18 @@
+export class UnknownSimulationError extends Error {
+  constructor() {
+    super('Unknown gas simulation error')
+    this.name = 'UnknownSimulationError'
+  }
+}
+
+export class SlippageTooLowError extends Error {
+  constructor() {
+    super('Slippage too low')
+    this.name = 'SlippageTooLowError'
+  }
+}
+
+// TODO(DEX): add fallback gas limits per chain? l2s have higher costs
+export const WRAP_FALLBACK_GAS_LIMIT_IN_GWEI = 45_000
+
+export const FALLBACK_SWAP_REQUEST_POLL_INTERVAL_MS = 1000

package/src/features/transactions/swap/review/services/swapTxAndGasInfoService/dex/dexSwapTxAndGasInfoService.ts

@@ -0,0 +1,19 @@
+import { SwapTxAndGasInfoService } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/swapTxAndGasInfoService'
+import {
+  getDEXSwapTxAndGasInfo,
+  processDEXResponse,
+} from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/dex/utils'
+import { DEXTrade } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+
+export function createDEXSwapTxAndGasInfoService(): SwapTxAndGasInfoService<DEXTrade> {
+  const service: SwapTxAndGasInfoService<DEXTrade> = {
+    async getSwapTxAndGasInfo(params) {
+      const permitData = params.trade.quote.permitData
+
+      const swapTxInfo = processDEXResponse({ permitData })
+      return getDEXSwapTxAndGasInfo({ ...params, swapTxInfo })
+    },
+  }
+
+  return service
+}

package/src/features/transactions/swap/review/services/swapTxAndGasInfoService/dex/utils.test.tsx

@@ -0,0 +1,28 @@
+import { processDEXResponse } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/dex/utils'
+import { createMockPermitData } from '@luxexchange/lx/src/test/fixtures/transactions/swap'
+
+describe('processDEXResponse', () => {
+  it('should return swapTxAndGasInfo with zero gas fee', () => {
+    // Given
+    const permitData = createMockPermitData('USDC')
+
+    // When
+    const result = processDEXResponse({
+      permitData,
+    })
+
+    // Then
+    expect(result).toEqual({
+      gasFeeResult: {
+        value: '0',
+        displayValue: '0',
+        error: null,
+        isLoading: false,
+      },
+      gasEstimate: {},
+      transactionRequest: undefined,
+      swapRequestArgs: undefined,
+      permitData,
+    })
+  })
+})

package/src/features/transactions/swap/review/services/swapTxAndGasInfoService/dex/utils.ts

@@ -0,0 +1,69 @@
+import { TradingApi } from '@luxfi/api'
+import type { ApprovalTxInfo } from '@luxexchange/lx/src/features/transactions/swap/review/hooks/useTokenApprovalInfo'
+import type { TransactionRequestInfo } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/utils'
+import {
+  createApprovalFields,
+  createGasFields,
+} from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/utils'
+import type {
+  DEXGasBreakdown,
+  DEXSwapTxAndGasInfo,
+} from '@luxexchange/lx/src/features/transactions/swap/types/swapTxAndGasInfo'
+import { PermitMethod } from '@luxexchange/lx/src/features/transactions/swap/types/swapTxAndGasInfo'
+import type { DEXTrade } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+import { validatePermit } from '@luxexchange/lx/src/features/transactions/swap/utils/trade'
+
+export function processDEXResponse({
+  permitData,
+}: {
+  permitData: TradingApi.NullablePermit | undefined
+}): TransactionRequestInfo {
+  return {
+    gasFeeResult: { value: '0', displayValue: '0', error: null, isLoading: false }, // There is no gas fee for DEX swap
+    gasEstimate: {},
+    txRequests: undefined,
+    swapRequestArgs: undefined,
+    permitData,
+  }
+}
+
+function createDEXGasBreakdown({
+  trade,
+  approvalTxInfo,
+  swapTxInfo,
+}: {
+  trade: DEXTrade
+  approvalTxInfo: ApprovalTxInfo
+  swapTxInfo: TransactionRequestInfo
+}): { gasFeeBreakdown: DEXGasBreakdown } {
+  const { approvalGasFeeResult } = approvalTxInfo
+  const gasFeeBreakdown = {
+    classicGasUseEstimateUSD: trade.quote.quote.classicGasUseEstimateUSD,
+    approvalCost: approvalGasFeeResult.displayValue,
+    wrapCost: swapTxInfo.gasFeeResult.displayValue,
+    inputTokenSymbol: trade.inputAmount.currency.symbol,
+  }
+
+  return { gasFeeBreakdown }
+}
+
+export function getDEXSwapTxAndGasInfo({
+  trade,
+  swapTxInfo,
+  approvalTxInfo,
+}: {
+  trade: DEXTrade
+  swapTxInfo: TransactionRequestInfo
+  approvalTxInfo: ApprovalTxInfo
+}): DEXSwapTxAndGasInfo {
+  const permit = validatePermit(swapTxInfo.permitData)
+
+  return {
+    routing: trade.routing,
+    trade,
+    ...createGasFields({ swapTxInfo, approvalTxInfo }),
+    ...createApprovalFields({ approvalTxInfo }),
+    ...createDEXGasBreakdown({ trade, approvalTxInfo, swapTxInfo }),
+    permit: permit ? { method: PermitMethod.TypedData, typedData: permit } : undefined,
+  }
+}

package/src/features/transactions/swap/review/services/swapTxAndGasInfoService/evm/evmSwapInstructionsService.ts

@@ -0,0 +1,147 @@
+import type {
+  BridgeQuoteResponse,
+  ClassicQuoteResponse,
+  GasStrategy,
+  TradingApi,
+  UnwrapQuoteResponse,
+  WrapQuoteResponse,
+} from '@luxfi/api'
+import type { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import type { SwapDelegationInfo } from '@luxexchange/lx/src/features/smartWallet/delegation/types'
+import type { TransactionSettings } from '@luxexchange/lx/src/features/transactions/components/settings/types'
+import type {
+  EVMSwapRepository,
+  SwapData,
+} from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/evm/evmSwapRepository'
+import {
+  create5792EVMSwapRepository,
+  create7702EVMSwapRepository,
+  createLegacyEVMSwapRepository,
+} from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/evm/evmSwapRepository'
+import type { PresignPermitFn } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/evm/hooks'
+import { createPrepareSwapRequestParams } from '@luxexchange/lx/src/features/transactions/swap/review/services/swapTxAndGasInfoService/utils'
+import { ApprovalAction } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+import { tradingApiToUniverseChainId } from '@luxexchange/lx/src/features/transactions/swap/utils/tradingApi'
+
+type SwapInstructions =
+  | { response: SwapData; unsignedPermit: null; swapRequestParams: null }
+  | { response: null; unsignedPermit: TradingApi.Permit; swapRequestParams: TradingApi.CreateSwapRequest }
+
+/** A service utility capable of fetching swap instructions or returning unsigned permit data when instructions cannot yet be fetched. */
+export interface EVMSwapInstructionsService {
+  getSwapInstructions: (params: {
+    swapQuoteResponse: ClassicQuoteResponse | BridgeQuoteResponse | WrapQuoteResponse | UnwrapQuoteResponse
+    transactionSettings: TransactionSettings
+    approvalAction: ApprovalAction
+  }) => Promise<SwapInstructions>
+}
+
+interface EVMSwapInstructionsServiceContext {
+  v4SwapEnabled: boolean
+  gasStrategy: GasStrategy
+  /** A function that should be provided in wallet environments that support signing permits without prompting the user. Allows fetching swap instructions earlier for some flows.*/
+  presignPermit?: PresignPermitFn
+  getCanBatchTransactions?: (chainId: UniverseChainId | undefined) => boolean
+  getSwapDelegationInfo?: (chainId: UniverseChainId | undefined) => SwapDelegationInfo
+}
+
+function createLegacyEVMSwapInstructionsService(
+  ctx: Omit<EVMSwapInstructionsServiceContext, 'swapDelegationAddress'> & { swapRepository: EVMSwapRepository },
+): EVMSwapInstructionsService {
+  const { gasStrategy, swapRepository } = ctx
+
+  const prepareSwapRequestParams = createPrepareSwapRequestParams({
+    gasStrategy,
+  })
+
+  const service: EVMSwapInstructionsService = {
+    getSwapInstructions: async ({ swapQuoteResponse, transactionSettings, approvalAction }) => {
+      const { permitData, permitTransaction } = swapQuoteResponse
+      const signature = permitData ? await ctx.presignPermit?.(permitData) : undefined
+      const signatureMissing = permitData && !signature
+
+      const alreadyApproved = approvalAction === ApprovalAction.None && !permitTransaction
+
+      const swapRequestParams = prepareSwapRequestParams({
+        swapQuoteResponse,
+        signature,
+        transactionSettings,
+        alreadyApproved,
+      })
+
+      if (signatureMissing) {
+        return { response: null, unsignedPermit: permitData, swapRequestParams }
+      }
+
+      const response = await swapRepository.fetchSwapData(swapRequestParams)
+      return { response, unsignedPermit: null, swapRequestParams: null }
+    },
+  }
+
+  return service
+}
+
+function createBatchedEVMSwapInstructionsService(
+  ctx: Omit<EVMSwapInstructionsServiceContext, 'presignPermit'> & { swapRepository: EVMSwapRepository },
+): EVMSwapInstructionsService {
+  const { gasStrategy, swapRepository } = ctx
+
+  const prepareSwapRequestParams = createPrepareSwapRequestParams({
+    gasStrategy,
+  })
+
+  const service: EVMSwapInstructionsService = {
+    getSwapInstructions: async ({ swapQuoteResponse, transactionSettings, approvalAction }) => {
+      const swapRequestParams = prepareSwapRequestParams({
+        swapQuoteResponse,
+        signature: undefined,
+        transactionSettings,
+        alreadyApproved: approvalAction === ApprovalAction.None,
+        overrideSimulation: true, // always simulate for batched transactions
+      })
+
+      const response = await swapRepository.fetchSwapData(swapRequestParams)
+      return { response, unsignedPermit: null, swapRequestParams: null }
+    },
+  }
+
+  return service
+}
+
+export function createEVMSwapInstructionsService(ctx: EVMSwapInstructionsServiceContext): EVMSwapInstructionsService {
+  const { getSwapDelegationInfo } = ctx
+  const smartContractWalletInstructionService = getSwapDelegationInfo
+    ? createBatchedEVMSwapInstructionsService({
+        ...ctx,
+        swapRepository: create7702EVMSwapRepository({ getSwapDelegationInfo }),
+      })
+    : undefined
+
+  const batchedInstructionsService = createBatchedEVMSwapInstructionsService({
+    ...ctx,
+    swapRepository: create5792EVMSwapRepository(),
+  })
+
+  const legacyInstructionsService = createLegacyEVMSwapInstructionsService({
+    ...ctx,
+    swapRepository: createLegacyEVMSwapRepository(),
+  })
+
+  const service: EVMSwapInstructionsService = {
+    getSwapInstructions: async (params) => {
+      const chainId = tradingApiToUniverseChainId(params.swapQuoteResponse.quote.chainId)
+
+      if (smartContractWalletInstructionService && ctx.getSwapDelegationInfo?.(chainId).delegationAddress) {
+        return smartContractWalletInstructionService.getSwapInstructions(params)
+      }
+
+      if (ctx.getCanBatchTransactions?.(chainId)) {
+        return batchedInstructionsService.getSwapInstructions(params)
+      }
+
+      return legacyInstructionsService.getSwapInstructions(params)
+    },
+  }
+
+  return service
+}