@luxexchange/lx 1.0.0

package/src/features/transactions/swap/services/tradeService/tradeRepository.test.ts

@@ -0,0 +1,224 @@
+import type { DiscriminatedQuoteResponse } from '@luxfi/api'
+import { TradingApi } from '@luxfi/api'
+import { logSwapQuoteFetch } from '@luxexchange/lx/src/features/transactions/swap/analytics'
+import {
+  createTradeRepository,
+  type TradeRepository,
+} from '@luxexchange/lx/src/features/transactions/swap/services/tradeService/tradeRepository'
+import type { Logger } from '@luxfi/utilities/src/logger/logger'
+
+// Mock dependencies
+vi.mock('lx/src/features/transactions/swap/analytics')
+
+describe('TradeRepository', () => {
+  // Minimal test params
+  const mockParams = {
+    tokenInChainId: 1,
+    tokenOutChainId: 1,
+    type: TradingApi.TradeType.EXACT_INPUT,
+    amount: '1000000',
+    tokenIn: '0x1234',
+    tokenOut: '0x5678',
+    swapper: '0xabcd',
+    v4Enabled: false,
+  }
+
+  // Minimal mock result
+  const mockResult = {
+    quote: {},
+    routing: TradingApi.Routing.CLASSIC,
+    requestId: '123',
+  }
+
+  // Setup mocks
+  const mockFetchQuote = vi.fn().mockResolvedValue(mockResult as DiscriminatedQuoteResponse)
+  const mockFetchIndicativeQuote = vi.fn().mockResolvedValue(mockResult as DiscriminatedQuoteResponse)
+  const mockLogger = { info: vi.fn(), error: vi.fn() } as Partial<Logger> as Logger
+
+  // Helper for repository creation
+  const createTestRepo = (options = {}): TradeRepository =>
+    createTradeRepository({
+      fetchQuote: mockFetchQuote,
+      fetchIndicativeQuote: mockFetchIndicativeQuote,
+      ...options,
+    })
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('fetchQuote', () => {
+    it('calls the underlying fetchQuote with the same parameters', async () => {
+      const repository = createTestRepo()
+      await repository.fetchQuote(mockParams)
+      expect(mockFetchQuote).toHaveBeenCalledWith(mockParams)
+    })
+
+    it('returns the result from the underlying fetchQuote', async () => {
+      const repository = createTestRepo()
+      const result = await repository.fetchQuote(mockParams)
+      expect(result).toBe(mockResult)
+    })
+
+    describe('analytics', () => {
+      it('logs swap quote fetch with chainId, isUSDQuote, and quoteSource', async () => {
+        const repository = createTestRepo()
+        await repository.fetchQuote(mockParams)
+        expect(logSwapQuoteFetch).toHaveBeenCalledWith({
+          chainId: mockParams.tokenInChainId,
+          isUSDQuote: undefined,
+          quoteSource: 'trading_api',
+        })
+      })
+
+      it('logs swap quote fetch with isUSDQuote=true when specified', async () => {
+        const repository = createTestRepo()
+        await repository.fetchQuote({ ...mockParams, isUSDQuote: true })
+        expect(logSwapQuoteFetch).toHaveBeenCalledWith({
+          chainId: mockParams.tokenInChainId,
+          isUSDQuote: true,
+          quoteSource: 'trading_api',
+        })
+      })
+    })
+
+    describe('latency logging', () => {
+      beforeEach(() => vi.clearAllMocks())
+
+      it('does not log latency when no logger provided', async () => {
+        const repository = createTestRepo()
+        await repository.fetchQuote(mockParams)
+
+        expect(mockLogger.info).not.toHaveBeenCalled()
+        expect(mockFetchQuote).toHaveBeenCalledTimes(1)
+      })
+
+      it('logs USD Quote Latency for USD quotes when logger is provided', async () => {
+        const dateSpy = vi
+          .spyOn(Date, 'now')
+          .mockReturnValueOnce(100) // First call - start time
+          .mockReturnValueOnce(300) // Second call - end time (200ms later)
+
+        const repository = createTestRepo({ logger: mockLogger })
+        await repository.fetchQuote({ ...mockParams, isUSDQuote: true })
+
+        expect(mockLogger.info).toHaveBeenCalledWith('tradeRepository', 'fetchQuote', 'USD Quote Latency', {
+          quoteLatency: 200,
+          chainIdIn: mockParams.tokenInChainId,
+          chainIdOut: mockParams.tokenOutChainId,
+          isUSDQuote: true,
+        })
+
+        dateSpy.mockRestore()
+      })
+
+      it('logs latency with all required fields when conditions are met', async () => {
+        // Create a spy on Date.now that returns controlled values
+        const dateSpy = vi
+          .spyOn(Date, 'now')
+          .mockReturnValueOnce(100) // First call - start time
+          .mockReturnValueOnce(300) // Second call - end time (200ms later)
+
+        const repository = createTestRepo({ logger: mockLogger })
+        await repository.fetchQuote(mockParams)
+
+        expect(mockLogger.info).toHaveBeenCalledWith('useTrade', 'useTrade', 'Quote Latency', {
+          quoteLatency: 200,
+          chainIdIn: mockParams.tokenInChainId,
+          chainIdOut: mockParams.tokenOutChainId,
+          isBridging: false,
+        })
+
+        // Restore the original implementation
+        dateSpy.mockRestore()
+      })
+
+      it('logs latency with isBridging=true when chain IDs differ', async () => {
+        const bridgingParams = { ...mockParams, tokenOutChainId: 10 }
+        const repository = createTestRepo({ logger: mockLogger })
+        await repository.fetchQuote(bridgingParams)
+
+        expect(mockLogger.info).toHaveBeenCalledWith(
+          'useTrade',
+          'useTrade',
+          'Quote Latency',
+          expect.objectContaining({
+            isBridging: true,
+          }),
+        )
+      })
+    })
+
+    describe('error handling', () => {
+      it('propagates errors from the underlying fetchQuote', async () => {
+        const expectedError = new Error('Failed to fetch quote')
+        mockFetchQuote.mockRejectedValueOnce(expectedError)
+
+        const repository = createTestRepo()
+        await expect(repository.fetchQuote(mockParams)).rejects.toThrow(expectedError)
+      })
+    })
+  })
+
+  describe('fetchIndicativeQuote', () => {
+    const indicativeParams = {
+      type: TradingApi.TradeType.EXACT_INPUT,
+      amount: '1000000',
+      tokenInChainId: 1,
+      tokenOutChainId: 1,
+      tokenIn: '0x1234',
+      tokenOut: '0x5678',
+      swapper: '0xabcd',
+    }
+
+    it('calls the underlying fetchIndicativeQuote with the same parameters', async () => {
+      const repository = createTestRepo()
+      await repository.fetchIndicativeQuote(indicativeParams)
+      expect(mockFetchIndicativeQuote).toHaveBeenCalledWith(indicativeParams)
+    })
+
+    it('returns the result from the underlying fetchIndicativeQuote', async () => {
+      const repository = createTestRepo()
+      const result = await repository.fetchIndicativeQuote(indicativeParams)
+      expect(result).toBe(mockResult)
+    })
+
+    it('logs swap quote fetch with isQuickRoute: true', async () => {
+      const repository = createTestRepo()
+      await repository.fetchIndicativeQuote(indicativeParams)
+      expect(logSwapQuoteFetch).toHaveBeenCalledWith({
+        chainId: indicativeParams.tokenInChainId,
+        isQuickRoute: true,
+      })
+    })
+
+    it('logs indicative quote latency when logger is provided', async () => {
+      const dateSpy = vi.spyOn(Date, 'now').mockReturnValueOnce(100).mockReturnValueOnce(300)
+
+      const repository = createTestRepo({ logger: mockLogger })
+      await repository.fetchIndicativeQuote(indicativeParams)
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        'tradeRepository',
+        'fetchIndicativeQuote',
+        'Indicative Quote Latency',
+        {
+          quoteLatency: 200,
+          chainIdIn: indicativeParams.tokenInChainId,
+          chainIdOut: indicativeParams.tokenOutChainId,
+          isBridging: false,
+        },
+      )
+
+      dateSpy.mockRestore()
+    })
+
+    it('propagates errors from the underlying fetchIndicativeQuote', async () => {
+      const expectedError = new Error('Failed to fetch indicative quote')
+      mockFetchIndicativeQuote.mockRejectedValueOnce(expectedError)
+
+      const repository = createTestRepo()
+      await expect(repository.fetchIndicativeQuote(indicativeParams)).rejects.toThrow(expectedError)
+    })
+  })
+})

package/src/features/transactions/swap/services/tradeService/tradeRepository.ts

@@ -0,0 +1,99 @@
+import { type DiscriminatedQuoteResponse, type TradingApi, type TradingApiClient } from '@luxfi/api'
+import { logSwapQuoteFetch } from '@luxexchange/lx/src/features/transactions/swap/analytics'
+import { type Logger } from '@luxfi/utilities/src/logger/logger'
+
+// Minimal parameters needed for indicative quotes
+export interface IndicativeQuoteRequest {
+  type: TradingApi.TradeType
+  amount: string
+  tokenInChainId: number
+  tokenOutChainId: number
+  tokenIn: string
+  tokenOut: string
+  swapper: string
+}
+
+// Type for the indicative quote fetcher function
+export type FetchIndicativeQuote = (params: IndicativeQuoteRequest) => Promise<DiscriminatedQuoteResponse>
+
+export interface TradeRepository {
+  fetchQuote: TradingApiClient['fetchQuote']
+  fetchIndicativeQuote: FetchIndicativeQuote
+}
+
+export function createTradeRepository(ctx: {
+  fetchQuote: TradingApiClient['fetchQuote']
+  fetchIndicativeQuote: FetchIndicativeQuote
+  logger?: Logger
+}): TradeRepository {
+  return {
+    fetchQuote: async ({ isUSDQuote, ...params }): Promise<DiscriminatedQuoteResponse> => {
+      logSwapQuoteFetch({ chainId: params.tokenInChainId, isUSDQuote, quoteSource: 'trading_api' })
+
+      const startTime = ctx.logger ? Date.now() : undefined
+
+      const result = await ctx.fetchQuote(params)
+
+      // Log if API returned an empty quote response
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- checking for empty quote outside type expectations
+      if (ctx.logger && !result.quote) {
+        ctx.logger.error(new Error('Unexpected empty Trading API response'), {
+          tags: { file: 'tradeRepository', function: 'fetchQuote' },
+          extra: {
+            params,
+            routing: result.routing,
+            requestId: result.requestId,
+          },
+        })
+      }
+
+      if (startTime && ctx.logger) {
+        const quoteLatency = Date.now() - startTime
+
+        if (isUSDQuote) {
+          ctx.logger.info('tradeRepository', 'fetchQuote', 'USD Quote Latency', {
+            quoteLatency,
+            chainIdIn: params.tokenInChainId,
+            chainIdOut: params.tokenOutChainId,
+            isUSDQuote: true,
+          })
+        } else {
+          // keep the log name details the same for historical reasons
+          ctx.logger.info('useTrade', 'useTrade', 'Quote Latency', {
+            quoteLatency,
+            chainIdIn: params.tokenInChainId,
+            chainIdOut: params.tokenOutChainId,
+            isBridging: isBridging(params.tokenInChainId, params.tokenOutChainId),
+          })
+        }
+      }
+
+      return result
+    },
+    fetchIndicativeQuote: async (params): Promise<DiscriminatedQuoteResponse> => {
+      logSwapQuoteFetch({ chainId: params.tokenInChainId, isQuickRoute: true })
+
+      const startTime = ctx.logger ? Date.now() : undefined
+
+      const result = await ctx.fetchIndicativeQuote(params)
+
+      // log latency for indicative quotes
+      if (startTime && ctx.logger) {
+        const quoteLatency = Date.now() - startTime
+
+        ctx.logger.info('tradeRepository', 'fetchIndicativeQuote', 'Indicative Quote Latency', {
+          quoteLatency,
+          chainIdIn: params.tokenInChainId,
+          chainIdOut: params.tokenOutChainId,
+          isBridging: isBridging(params.tokenInChainId, params.tokenOutChainId),
+        })
+      }
+
+      return result
+    },
+  }
+}
+
+function isBridging(tokenInChainId?: number, tokenOutChainId?: number): boolean {
+  return Boolean(tokenInChainId && tokenOutChainId && tokenInChainId !== tokenOutChainId)
+}

package/src/features/transactions/swap/services/tradeService/tradeService.ts

@@ -0,0 +1,50 @@
+import { GasEstimate } from '@luxfi/api'
+import type { JupiterOrderUrlParams } from '@luxfi/api/src/clients/jupiter/types'
+import { Platform } from '@luxexchange/lx/src/features/platforms/types/Platform'
+import { chainIdToPlatform } from '@luxexchange/lx/src/features/platforms/utils/chains'
+import { type ValidatedTradeInput } from '@luxexchange/lx/src/features/transactions/swap/services/tradeService/transformations/buildQuoteRequest'
+import { IndicativeTrade, Trade, type UseTradeArgs } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+export interface TradeWithGasEstimates {
+  quoteHash?: string
+  trade: Trade | null
+  gasEstimate?: GasEstimate
+}
+
+export interface TradeService {
+  getTrade(input: UseTradeArgs): Promise<TradeWithGasEstimates>
+  prepareTradeInput(input?: UseTradeArgs): ValidatedTradeInput | JupiterOrderUrlParams | null // TODO(SWAP-383): Remove JupiterOrderUrlParams from union once Solana trade repo is implemented
+  getIndicativeTrade(input: UseTradeArgs): Promise<IndicativeTrade | null>
+  prepareIndicativeTradeInput(input?: UseTradeArgs): ValidatedTradeInput | null
+}
+
+export function createTradeService(ctx: { serviceByPlatform: Record<Platform, TradeService> }): TradeService {
+  function selectServiceFromArgs(args: UseTradeArgs): TradeService {
+    const chainId = args.amountSpecified?.currency.chainId
+    if (!chainId) {
+      return ctx.serviceByPlatform[Platform.EVM]
+    }
+    return ctx.serviceByPlatform[chainIdToPlatform(chainId)]
+  }
+
+  const service: TradeService = {
+    prepareTradeInput(args) {
+      if (!args) {
+        return null
+      }
+      return selectServiceFromArgs(args).prepareTradeInput(args)
+    },
+    prepareIndicativeTradeInput(args) {
+      if (!args) {
+        return null
+      }
+      return selectServiceFromArgs(args).prepareIndicativeTradeInput(args)
+    },
+    async getTrade(args) {
+      return selectServiceFromArgs(args).getTrade(args)
+    },
+    async getIndicativeTrade(args) {
+      return selectServiceFromArgs(args).getIndicativeTrade(args)
+    },
+  }
+  return service
+}

package/src/features/transactions/swap/services/tradeService/transformations/buildQuoteRequest.ts

@@ -0,0 +1,180 @@
+import { Currency, CurrencyAmount } from '@uniswap/sdk-core'
+import { GasStrategy, TradingApi } from '@luxexchange/api'
+import { getActiveGasStrategy } from '@luxexchange/lx/src/features/gas/utils'
+import {
+  isZeroAmount,
+  parseQuoteCurrencies,
+} from '@luxexchange/lx/src/features/transactions/swap/hooks/useTrade/parseQuoteCurrencies'
+import type { UseTradeArgs } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+import {
+  GetQuoteRoutingParams,
+  GetQuoteSlippageParams,
+  getTokenAddressForApi,
+  QuoteRoutingParamsResult,
+  QuoteSlippageParamsResult,
+  SWAP_GAS_URGENCY_OVERRIDE,
+  toTradingApiSupportedChainId,
+} from '@luxexchange/lx/src/features/transactions/swap/utils/tradingApi'
+
+// The TradingAPI requires an address for the swapper field; we supply a placeholder address if no account is connected.
+// Note: This address was randomly generated.
+export const UNCONNECTED_ADDRESS = '0xAAAA44272dc658575Ba38f43C438447dDED45358'
+
+export interface QuoteRequestResult {
+  amount: string
+  generatePermitAsTransaction?: boolean
+  gasStrategies: GasStrategy[]
+  isUSDQuote?: boolean
+  swapper: string
+  tokenIn: string
+  tokenInChainId: number
+  tokenOut: string
+  tokenOutChainId: number
+  type: TradingApi.TradeType
+  urgency?: TradingApi.Urgency
+  routingParams: QuoteRoutingParamsResult
+  slippageParams: QuoteSlippageParamsResult
+}
+
+// all required fields are guaranteed to be present
+export interface ValidatedTradeInput {
+  currencyIn: Currency
+  currencyOut: Currency
+  amount: CurrencyAmount<Currency>
+  requestTradeType: TradingApi.TradeType
+  activeAccountAddress: string | undefined
+  tokenInChainId: number
+  tokenOutChainId: number
+  tokenInAddress: string
+  tokenOutAddress: string
+  generatePermitAsTransaction?: boolean
+  isUSDQuote?: boolean
+}
+
+interface BuildQuoteRequestContext {
+  getRoutingParams: GetQuoteRoutingParams
+  getSlippageParams: GetQuoteSlippageParams
+}
+
+export function createBuildQuoteRequest(
+  ctx: BuildQuoteRequestContext,
+): (validatedInput: ValidatedTradeInput) => QuoteRequestResult {
+  const { getRoutingParams, getSlippageParams } = ctx
+
+  return function buildQuoteRequest(validatedInput: ValidatedTradeInput): QuoteRequestResult {
+    const routingParams = getRoutingParams({
+      isUSDQuote: validatedInput.isUSDQuote,
+    })
+
+    const slippageParams = getSlippageParams({
+      tokenInChainId: validatedInput.tokenInChainId,
+      tokenOutChainId: validatedInput.tokenOutChainId,
+      isUSDQuote: validatedInput.isUSDQuote,
+    })
+
+    return {
+      amount: validatedInput.amount.quotient.toString(),
+      generatePermitAsTransaction: validatedInput.generatePermitAsTransaction,
+      gasStrategies: [getActiveGasStrategy({ chainId: validatedInput.tokenInChainId, type: 'swap' })],
+      isUSDQuote: validatedInput.isUSDQuote,
+      swapper: validatedInput.activeAccountAddress ?? UNCONNECTED_ADDRESS,
+      tokenIn: validatedInput.tokenInAddress,
+      tokenInChainId: validatedInput.tokenInChainId,
+      tokenOut: validatedInput.tokenOutAddress,
+      tokenOutChainId: validatedInput.tokenOutChainId,
+      type: validatedInput.requestTradeType,
+      urgency: SWAP_GAS_URGENCY_OVERRIDE,
+      routingParams,
+      slippageParams,
+    }
+  }
+}
+
+// Helper type for flattening the result with routing and slippage params
+export type FlattenedQuoteRequestResult = Omit<QuoteRequestResult, 'routingParams' | 'slippageParams'> &
+  QuoteRoutingParamsResult &
+  QuoteSlippageParamsResult
+
+export function flattenQuoteRequestResult(result: QuoteRequestResult): FlattenedQuoteRequestResult {
+  const { routingParams, slippageParams, ...rest } = result
+  return {
+    ...rest,
+    ...routingParams,
+    ...slippageParams,
+  }
+}
+
+// Parse trade input specifically for quote request building
+export interface ParsedTradeInput {
+  currencyIn: Maybe<Currency>
+  currencyOut: Maybe<Currency>
+  amount: Maybe<CurrencyAmount<Currency>>
+  requestTradeType: TradingApi.TradeType
+  activeAccountAddress: string | undefined
+  tokenInChainId?: number
+  tokenOutChainId?: number
+  tokenInAddress?: string
+  tokenOutAddress?: string
+  generatePermitAsTransaction?: boolean
+  isUSDQuote?: boolean
+}
+
+export function parseTradeInputForTradingApiQuote(input: UseTradeArgs): ParsedTradeInput {
+  const { currencyIn, currencyOut, requestTradeType } = parseQuoteCurrencies(input)
+  return {
+    currencyIn,
+    currencyOut,
+    amount: input.amountSpecified,
+    requestTradeType,
+    activeAccountAddress: input.account?.address,
+    tokenInChainId: toTradingApiSupportedChainId(currencyIn?.chainId),
+    tokenOutChainId: toTradingApiSupportedChainId(currencyOut?.chainId),
+    tokenInAddress: getTokenAddressForApi(currencyIn),
+    tokenOutAddress: getTokenAddressForApi(currencyOut),
+    generatePermitAsTransaction: input.generatePermitAsTransaction,
+    isUSDQuote: input.isUSDQuote ?? false,
+  }
+}
+
+// Single source of truth for validation
+// Takes parsed input and returns validated input or undefined
+export function validateParsedInput(input: ParsedTradeInput): ValidatedTradeInput | undefined {
+  // Check all conditions that would make the input invalid
+  if (
+    !input.tokenInChainId ||
+    !input.tokenOutChainId ||
+    !input.tokenInAddress ||
+    !input.tokenOutAddress ||
+    !input.amount ||
+    !input.currencyIn ||
+    !input.currencyOut ||
+    isZeroAmount(input.amount) ||
+    areCurrenciesEqual(input.currencyIn, input.currencyOut)
+  ) {
+    return undefined
+  }
+
+  // If we get here, all required fields are present
+  // Return a validated object with explicit field mapping
+  return {
+    currencyIn: input.currencyIn,
+    currencyOut: input.currencyOut,
+    amount: input.amount,
+    requestTradeType: input.requestTradeType,
+    activeAccountAddress: input.activeAccountAddress,
+    tokenInChainId: input.tokenInChainId,
+    tokenOutChainId: input.tokenOutChainId,
+    tokenInAddress: input.tokenInAddress,
+    tokenOutAddress: input.tokenOutAddress,
+    generatePermitAsTransaction: input.generatePermitAsTransaction,
+    isUSDQuote: input.isUSDQuote,
+  }
+}
+
+// Helper to check if currencies are equal
+function areCurrenciesEqual(currencyIn?: Currency | null, currencyOut?: Currency | null): boolean {
+  if (!currencyIn || !currencyOut) {
+    return false
+  }
+  return currencyIn.equals(currencyOut)
+}

package/src/features/transactions/swap/services/tradeService/transformations/estimateGas.ts

@@ -0,0 +1,9 @@
+import { type DiscriminatedQuoteResponse, type GasEstimate } from '@luxfi/api'
+
+export function getGasEstimate(data: DiscriminatedQuoteResponse | null): GasEstimate | undefined {
+  if (!data?.quote || !('gasEstimates' in data.quote) || !data.quote.gasEstimates) {
+    return undefined
+  }
+
+  return data.quote.gasEstimates[0]
+}

package/src/features/transactions/swap/services/tradeService/transformations/transformQuoteToTrade.ts

@@ -0,0 +1,64 @@
+import { type Currency, type CurrencyAmount, TradeType as SdkTradeType } from '@luxfi/amm-core'
+import { type DiscriminatedQuoteResponse, type GasEstimate, TradingApi } from '@luxfi/api'
+import { type QuoteCurrencyData } from '@luxexchange/lx/src/features/transactions/swap/hooks/useTrade/parseQuoteCurrencies'
+import { getGasEstimate } from '@luxexchange/lx/src/features/transactions/swap/services/tradeService/transformations/estimateGas'
+import {
+  transformTradingApiResponseToTrade,
+  validateTrade,
+} from '@luxexchange/lx/src/features/transactions/swap/utils/tradingApi'
+import { CurrencyField } from '@luxexchange/lx/src/types/currency'
+import { inXMinutesUnix } from '@luxfi/utilities/src/time/time'
+
+const DEFAULT_SWAP_VALIDITY_TIME_MINS = 30
+
+export type QuoteWithTradeAndGasEstimate =
+  | (DiscriminatedQuoteResponse & {
+      gasEstimate: GasEstimate | undefined
+      trade: NonNullable<ReturnType<typeof validateTrade>> | null
+    })
+  | null
+
+export function transformQuoteToTrade(input: {
+  quote: DiscriminatedQuoteResponse | null
+  amountSpecified: Maybe<CurrencyAmount<Currency>>
+  quoteCurrencyData: QuoteCurrencyData
+}): QuoteWithTradeAndGasEstimate {
+  if (!input.quote) {
+    return null
+  }
+
+  const quoteCurrencyData = input.quoteCurrencyData
+  const { currencyIn, currencyOut, requestTradeType } = quoteCurrencyData
+  const exactCurrencyField =
+    requestTradeType === TradingApi.TradeType.EXACT_INPUT ? CurrencyField.INPUT : CurrencyField.OUTPUT
+  const tradeType =
+    requestTradeType === TradingApi.TradeType.EXACT_INPUT ? SdkTradeType.EXACT_INPUT : SdkTradeType.EXACT_OUTPUT
+  const gasEstimate = getGasEstimate(input.quote)
+
+  const formattedTrade =
+    currencyIn && currencyOut
+      ? transformTradingApiResponseToTrade({
+          currencyIn,
+          currencyOut,
+          tradeType,
+          deadline: inXMinutesUnix(DEFAULT_SWAP_VALIDITY_TIME_MINS), // TODO(MOB-3050): set deadline as `quoteRequestArgs.deadline`
+          data: input.quote,
+        })
+      : null
+
+  const trade = formattedTrade
+    ? validateTrade({
+        trade: formattedTrade,
+        currencyIn,
+        currencyOut,
+        exactAmount: input.amountSpecified,
+        exactCurrencyField,
+      })
+    : null
+
+  return {
+    ...input.quote,
+    gasEstimate,
+    trade,
+  }
+}

package/src/features/transactions/swap/services/warningService.ts

@@ -0,0 +1,11 @@
+export interface WarningService {
+  getSkipBridgingWarning: () => boolean
+  getSkipMaxTransferWarning: () => boolean
+  getSkipTokenProtectionWarning: () => boolean
+  getSkipBridgedAssetWarning: () => boolean
+  setSkipBridgedAssetWarning: (skip: boolean) => void
+  setSkipBridgingWarning: (skip: boolean) => void
+  setSkipMaxTransferWarning: (skip: boolean) => void
+  setSkipTokenProtectionWarning: (skip: boolean) => void
+  reset: () => void
+}

package/src/features/transactions/swap/state/selectors.ts

@@ -0,0 +1,5 @@
+import type { SwapSettingsState } from '@luxexchange/lx/src/features/transactions/swap/state/slice'
+import type { LuxRootState } from '@luxexchange/lx/src/state'
+
+export const selectFilteredChainIds = (state: LuxRootState): SwapSettingsState['filteredChainIds'] =>
+  state.swapSettings.filteredChainIds

package/src/features/transactions/swap/state/slice.ts

@@ -0,0 +1,31 @@
+import type { PayloadAction } from '@reduxjs/toolkit'
+import { createSlice } from '@reduxjs/toolkit'
+import type { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import type { CurrencyField } from '@luxexchange/lx/src/types/currency'
+
+export interface SwapSettingsState {
+  filteredChainIds: { [key in CurrencyField]?: UniverseChainId } | undefined
+}
+
+const initialSwapSettingsState: SwapSettingsState = {
+  filteredChainIds: undefined,
+}
+
+const slice = createSlice({
+  name: 'swapSettings',
+  initialState: initialSwapSettingsState,
+  reducers: {
+    updateFilteredChainIds: (
+      state,
+      {
+        payload: { filteredChainIds },
+      }: PayloadAction<{ filteredChainIds: { [key in CurrencyField]?: UniverseChainId } }>,
+    ) => {
+      state.filteredChainIds = { ...filteredChainIds }
+    },
+    resetSwapSettings: () => initialSwapSettingsState,
+  },
+})
+
+export const { updateFilteredChainIds, resetSwapSettings } = slice.actions
+export const { reducer: swapSettingsReducer } = slice