@luxexchange/lx 1.0.0

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

@@ -0,0 +1,212 @@
+import { TradingApi } from '@luxexchange/api'
+import { Platform } from '@luxexchange/lx/src/features/platforms/types/Platform'
+import { chainIdToPlatform } from '@luxexchange/lx/src/features/platforms/utils/chains'
+import { LuxEventName } from '@luxexchange/lx/src/features/telemetry/constants'
+import { sendAnalyticsEvent } from '@luxexchange/lx/src/features/telemetry/send'
+import type { SwapRedirectFn } from '@luxexchange/lx/src/features/transactions/components/TransactionModal/TransactionModalContext'
+import { TransactionScreen } from '@luxexchange/lx/src/features/transactions/components/TransactionModal/TransactionModalContext'
+import { prefetchPlan } from '@luxexchange/lx/src/features/transactions/swap/plan/prefetchedPlanStore'
+import type { WarningService } from '@luxexchange/lx/src/features/transactions/swap/services/warningService'
+import type { SwapFormState } from '@luxexchange/lx/src/features/transactions/swap/stores/swapFormStore/types'
+import type { DerivedSwapInfo } from '@luxexchange/lx/src/features/transactions/swap/types/derivedSwapInfo'
+import type { Trade } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+import { CurrencyField } from '@luxexchange/lx/src/types/currency'
+import { createTransactionId } from '@luxexchange/lx/src/utils/createTransactionId'
+import type { logger } from '@luxfi/utilities/src/logger/logger'
+
+// this will be in swapService
+export function createPrepareSwap(
+  ctx: HandleEventActionContext & GetActionContext & { warningService: WarningService; logger?: typeof logger },
+): () => void {
+  function prepareSwap(): void {
+    try {
+      const getAction = createGetAction(ctx)
+      const handleEventAction = createHandleEventAction(ctx)
+
+      const action = getAction({
+        skipBridgingWarning: ctx.warningService.getSkipBridgingWarning(),
+        skipMaxTransferWarning: ctx.warningService.getSkipMaxTransferWarning(),
+        skipTokenProtectionWarning: ctx.warningService.getSkipTokenProtectionWarning(),
+        skipBridgedAssetWarning: ctx.warningService.getSkipBridgedAssetWarning(),
+      })
+
+      handleEventAction(action)
+    } catch (error) {
+      ctx.logger?.error(error, {
+        tags: {
+          file: 'useOnReviewPress',
+          function: 'prepareSwap',
+        },
+      })
+    }
+    // always reset the warning service after the action is handled
+    ctx.warningService.reset()
+  }
+  return prepareSwap
+}
+
+interface GetActionContext {
+  swapRedirectCallback?: SwapRedirectFn
+  isConnected: boolean
+  onConnectWallet?: (platform?: Platform) => void
+  isViewOnlyWallet: boolean
+  currencies: DerivedSwapInfo['currencies']
+  exactAmountToken?: string
+  exactCurrencyField: CurrencyField
+  chainId: number
+  needsTokenProtectionWarning: boolean
+  needsBridgingWarning: boolean
+  needsLowNativeBalanceWarning: boolean
+  needsBridgedAssetWarning: boolean
+}
+
+const ReviewActionType = {
+  REDIRECT: 'REDIRECT' as const,
+  CONNECT_WALLET: 'CONNECT_WALLET' as const,
+  SHOW_VIEW_ONLY: 'SHOW_VIEW_ONLY' as const,
+  SHOW_TOKEN_WARNING: 'SHOW_TOKEN_WARNING' as const,
+  SHOW_BRIDGING_WARNING: 'SHOW_BRIDGING_WARNING' as const,
+  SHOW_LOW_BALANCE: 'SHOW_LOW_BALANCE' as const,
+  PROCEED_TO_REVIEW: 'PROCEED_TO_REVIEW' as const,
+  SHOW_BRIDGED_ASSET_WARNING: 'SHOW_BRIDGED_ASSET_WARNING' as const,
+}
+
+type RedirectActionPayload = Parameters<SwapRedirectFn>[0]
+
+type LowBalanceActionPayload = {
+  location: 'swap' | 'send'
+}
+
+type ConnectWalletActionPayload = {
+  platform?: Platform
+}
+
+type ReviewAction =
+  | { type: typeof ReviewActionType.REDIRECT; payload: RedirectActionPayload }
+  | { type: typeof ReviewActionType.CONNECT_WALLET; payload: ConnectWalletActionPayload }
+  | { type: typeof ReviewActionType.SHOW_VIEW_ONLY }
+  | { type: typeof ReviewActionType.SHOW_TOKEN_WARNING }
+  | { type: typeof ReviewActionType.SHOW_BRIDGING_WARNING }
+  | { type: typeof ReviewActionType.SHOW_LOW_BALANCE; payload: LowBalanceActionPayload }
+  | { type: typeof ReviewActionType.PROCEED_TO_REVIEW }
+  | { type: typeof ReviewActionType.SHOW_BRIDGED_ASSET_WARNING }
+
+type CallbackArgs = Record<
+  'skipBridgingWarning' | 'skipTokenProtectionWarning' | 'skipMaxTransferWarning' | 'skipBridgedAssetWarning',
+  boolean
+>
+
+function createGetAction(ctx: GetActionContext): (args: CallbackArgs) => ReviewAction {
+  const {
+    swapRedirectCallback,
+    isConnected,
+    onConnectWallet,
+    isViewOnlyWallet,
+    currencies,
+    exactAmountToken,
+    exactCurrencyField,
+    chainId,
+    needsTokenProtectionWarning,
+    needsBridgingWarning,
+    needsLowNativeBalanceWarning,
+    needsBridgedAssetWarning,
+  } = ctx
+  function getAction(args: CallbackArgs): ReviewAction {
+    if (swapRedirectCallback) {
+      const redirectPayload: RedirectActionPayload = {
+        inputCurrency: currencies[CurrencyField.INPUT]?.currency,
+        outputCurrency: currencies[CurrencyField.OUTPUT]?.currency,
+        typedValue: exactAmountToken,
+        independentField: exactCurrencyField,
+        chainId,
+      }
+      return {
+        type: ReviewActionType.REDIRECT,
+        payload: redirectPayload,
+      }
+    } else if (!isConnected && onConnectWallet) {
+      return { type: ReviewActionType.CONNECT_WALLET, payload: { platform: chainIdToPlatform(chainId) } }
+    } else if (isViewOnlyWallet) {
+      return { type: ReviewActionType.SHOW_VIEW_ONLY }
+    } else if (needsTokenProtectionWarning && !args.skipTokenProtectionWarning) {
+      return { type: ReviewActionType.SHOW_TOKEN_WARNING }
+    } else if (needsBridgingWarning && !args.skipBridgingWarning) {
+      return { type: ReviewActionType.SHOW_BRIDGING_WARNING }
+    } else if (needsLowNativeBalanceWarning && !args.skipMaxTransferWarning) {
+      const lowBalancePayload: LowBalanceActionPayload = { location: 'swap' }
+      return {
+        type: ReviewActionType.SHOW_LOW_BALANCE,
+        payload: lowBalancePayload,
+      }
+    } else if (needsBridgedAssetWarning && !args.skipBridgedAssetWarning) {
+      return { type: ReviewActionType.SHOW_BRIDGED_ASSET_WARNING }
+    }
+    return { type: ReviewActionType.PROCEED_TO_REVIEW }
+  }
+
+  return getAction
+}
+
+interface HandleEventActionContext {
+  handleShowViewOnlyModal: () => void
+  handleShowTokenWarningModal: () => void
+  handleShowBridgingWarningModal: () => void
+  handleShowMaxNativeTransferModal: () => void
+  handleShowBridgedAssetModal: () => void
+  swapRedirectCallback?: SwapRedirectFn
+  onConnectWallet?: (platform?: Platform) => void
+  updateSwapForm: (newState: Partial<SwapFormState>) => void
+  setScreen: (screen: TransactionScreen) => void
+  trade?: Trade
+  walletExecutionContext?: TradingApi.WalletExecutionContext
+}
+
+function createHandleEventAction(ctx: HandleEventActionContext): (action: ReviewAction) => void {
+  const {
+    handleShowViewOnlyModal,
+    handleShowTokenWarningModal,
+    handleShowBridgingWarningModal,
+    handleShowMaxNativeTransferModal,
+    handleShowBridgedAssetModal,
+    swapRedirectCallback,
+    onConnectWallet,
+    updateSwapForm,
+    setScreen,
+    trade,
+    walletExecutionContext,
+  } = ctx
+  function handleEventAction(action: ReviewAction): void {
+    switch (action.type) {
+      case ReviewActionType.REDIRECT:
+        swapRedirectCallback?.(action.payload)
+        break
+      case ReviewActionType.CONNECT_WALLET:
+        onConnectWallet?.(action.payload.platform)
+        break
+      case ReviewActionType.SHOW_VIEW_ONLY:
+        handleShowViewOnlyModal()
+        break
+      case ReviewActionType.SHOW_TOKEN_WARNING:
+        handleShowTokenWarningModal()
+        break
+      case ReviewActionType.SHOW_BRIDGING_WARNING:
+        handleShowBridgingWarningModal()
+        break
+      case ReviewActionType.SHOW_LOW_BALANCE:
+        handleShowMaxNativeTransferModal()
+        sendAnalyticsEvent(LuxEventName.LowNetworkTokenInfoModalOpened, action.payload)
+        break
+      case ReviewActionType.SHOW_BRIDGED_ASSET_WARNING:
+        handleShowBridgedAssetModal()
+        break
+      case ReviewActionType.PROCEED_TO_REVIEW:
+        updateSwapForm({ txId: createTransactionId() })
+        setScreen(TransactionScreen.Review)
+        if (trade) {
+          prefetchPlan(trade, walletExecutionContext)
+        }
+        break
+    }
+  }
+  return handleEventAction
+}

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

@@ -0,0 +1,218 @@
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import type { GetQuoteRequestResult } from '@luxexchange/lx/src/features/transactions/swap/hooks/useTrade/createGetQuoteRequestArgs'
+import type {
+  IndicativeQuoteRequest,
+  TradeRepository,
+} from '@luxexchange/lx/src/features/transactions/swap/services/tradeService/tradeRepository'
+import {
+  TradeService,
+  TradeWithGasEstimates,
+} from '@luxexchange/lx/src/features/transactions/swap/services/tradeService/tradeService'
+import {
+  createBuildQuoteRequest,
+  flattenQuoteRequestResult,
+  parseTradeInputForTradingApiQuote,
+  UNCONNECTED_ADDRESS,
+  type ValidatedTradeInput,
+  validateParsedInput,
+} from '@luxexchange/lx/src/features/transactions/swap/services/tradeService/transformations/buildQuoteRequest'
+import { transformQuoteToTrade } from '@luxexchange/lx/src/features/transactions/swap/services/tradeService/transformations/transformQuoteToTrade'
+import {
+  IndicativeTrade,
+  type UseTradeArgs,
+  validateIndicativeQuoteResponse,
+} from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+import { getIdentifierForQuote } from '@luxexchange/lx/src/features/transactions/swap/utils/getIdForQuote'
+import {
+  createGetProtocolsForChain,
+  DEFAULT_PROTOCOL_OPTIONS,
+} from '@luxexchange/lx/src/features/transactions/swap/utils/protocols'
+import {
+  createGetQuoteRoutingParams,
+  createGetQuoteSlippageParams,
+} from '@luxexchange/lx/src/features/transactions/swap/utils/tradingApi'
+import type { Logger } from '@luxfi/utilities/src/logger/logger'
+
+interface EVMTradeServiceContext {
+  // Core dependencies
+  tradeRepository: TradeRepository
+  logger?: Logger
+
+  // Configuration dependencies
+  getIsDEXSupported?: (chainId?: number) => boolean
+  getEnabledChains: () => UniverseChainId[]
+  getIsL2ChainId: (chainId?: UniverseChainId) => boolean
+  getMinAutoSlippageToleranceL2: () => number
+}
+
+export function createEVMTradeService(ctx: EVMTradeServiceContext): TradeService {
+  const { tradeRepository, getIsDEXSupported, getEnabledChains, getIsL2ChainId, getMinAutoSlippageToleranceL2 } =
+    ctx
+
+  // Create protocols filter
+  const getProtocolsForChain = createGetProtocolsForChain({
+    getIsDEXSupported,
+    getEnabledChains,
+  })
+
+  return {
+    prepareTradeInput: prepareTradingApiTradeInput,
+    prepareIndicativeTradeInput,
+    async getTrade(input: UseTradeArgs): Promise<TradeWithGasEstimates> {
+      let quoteRequestArgs: GetQuoteRequestResult | undefined
+
+      try {
+        // Create routing params getter for this specific request
+        const getRoutingParams = createGetQuoteRoutingParams({
+          getProtocols: () =>
+            getProtocolsForChain(
+              input.selectedProtocols ?? DEFAULT_PROTOCOL_OPTIONS,
+              input.amountSpecified?.currency.chainId,
+            ),
+          getIsV4HookPoolsEnabled: () => input.isV4HookPoolsEnabled ?? true,
+        })
+
+        // Create slippage params getter for this specific request
+        const getSlippageParams = createGetQuoteSlippageParams({
+          getIsL2ChainId,
+          getMinAutoSlippageToleranceL2,
+          getCustomSlippageTolerance: () => input.customSlippageTolerance,
+        })
+
+        // Create the quote request builder with these params
+        const buildQuoteRequest = createBuildQuoteRequest({
+          getRoutingParams,
+          getSlippageParams,
+        })
+
+        // Step 1: Prepare trade input
+        const validatedInput = prepareTradingApiTradeInput(input)
+
+        // Step 2: Early exit if input is null
+        if (!validatedInput) {
+          return { trade: null }
+        }
+
+        // Step 3: Build quote request with all params
+        const quoteRequestParams = buildQuoteRequest(validatedInput)
+        quoteRequestArgs = flattenQuoteRequestResult(quoteRequestParams)
+
+        // Step 4: Fetch quote from API
+        const quoteResponse = await tradeRepository.fetchQuote(quoteRequestArgs)
+
+        const quoteHash = getIdentifierForQuote(quoteRequestArgs)
+
+        // Step 5: Transform quote to trade
+        const result = transformQuoteToTrade({
+          quote: quoteResponse,
+          amountSpecified: validatedInput.amount,
+          quoteCurrencyData: {
+            currencyIn: validatedInput.currencyIn,
+            currencyOut: validatedInput.currencyOut,
+            requestTradeType: validatedInput.requestTradeType,
+          },
+        })
+        // Return trade with gas estimates
+        return {
+          quoteHash,
+          trade: result?.trade ?? null,
+          gasEstimate: result?.gasEstimate,
+        }
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error('Unknown error')
+        quoteRequestArgs = undefined
+        throw error
+      }
+    },
+    async getIndicativeTrade(input: UseTradeArgs): Promise<IndicativeTrade | null> {
+      // Step 1: validate indicative quote request
+      const validatedInput = prepareIndicativeTradeInput(input)
+      if (!validatedInput) {
+        return null
+      }
+
+      // Step 2: build indicative quote request
+      const indicativeRequest = validatedIndicativeQuoteRequest(validatedInput)
+
+      try {
+        // Step 3: Fetch indicative quote from API
+        const quoteResponse = await tradeRepository.fetchIndicativeQuote(indicativeRequest)
+
+        // Step 4: Validate and transform to IndicativeTrade
+        const validatedResponse = validateIndicativeQuoteResponse(quoteResponse)
+        if (!validatedResponse) {
+          return null
+        }
+
+        const trade = new IndicativeTrade({
+          quote: validatedResponse,
+          currencyIn: validatedInput.currencyIn,
+          currencyOut: validatedInput.currencyOut,
+        })
+
+        return trade
+      } catch (error) {
+        ctx.logger?.error(error, {
+          tags: { file: 'tradeService.ts', function: 'getIndicativeTrade' },
+        })
+        // Indicative trade errors should not block regular trades
+        return null
+      }
+    },
+  }
+}
+
+/**
+ * Prepares the trade input
+ * @param input - UseTradeArgs: the input to prepare the trade input for
+ * @returns The validated trade input, or null if the input is falsy, skipped, or USD quote
+ */
+export function prepareTradingApiTradeInput(input?: UseTradeArgs): ValidatedTradeInput | null {
+  // Step 1: Early exit if skipped
+  if (!input || input.skip) {
+    return null
+  }
+
+  // Step 2: Parse input into structured format
+  const parsedInput = parseTradeInputForTradingApiQuote(input)
+
+  // Step 3: Validate all required fields are present
+  const validatedInput = validateParsedInput(parsedInput)
+  if (!validatedInput) {
+    return null
+  }
+
+  return validatedInput
+}
+/**
+ * Prepares the indicative trade input
+ * @param input - UseTradeArgs: the input to prepare the indicative trade input for
+ * @returns The validated indicative trade input, or null if the input is falsy, skipped, or USD quote
+ */
+function prepareIndicativeTradeInput(input?: UseTradeArgs): ValidatedTradeInput | null {
+  // Early exit if input is falsy, skipped, or USD quote
+  if (!input || input.skip || input.isUSDQuote) {
+    return null
+  }
+
+  return prepareTradingApiTradeInput(input)
+}
+
+/**
+ * Validates the input and returns a minimal indicative quote request
+ * @param validatedInput - ValidatedTradeInput: the validated input to build the indicative quote request for
+ * @returns A minimal indicative quote request
+ */
+function validatedIndicativeQuoteRequest(validatedInput: ValidatedTradeInput): IndicativeQuoteRequest {
+  const indicativeRequest: IndicativeQuoteRequest = {
+    type: validatedInput.requestTradeType,
+    amount: validatedInput.amount.quotient.toString(),
+    tokenInChainId: validatedInput.tokenInChainId,
+    tokenOutChainId: validatedInput.tokenOutChainId,
+    tokenIn: validatedInput.tokenInAddress,
+    tokenOut: validatedInput.tokenOutAddress,
+    swapper: validatedInput.activeAccountAddress || UNCONNECTED_ADDRESS,
+  }
+
+  return indicativeRequest
+}

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

@@ -0,0 +1,93 @@
+import { TradeType } from '@uniswap/sdk-core'
+import { FetchError, type JupiterOrderUrlParams } from '@luxfi/api'
+import { JupiterApiClient } from '@luxexchange/lx/src/data/apiClients/jupiterApi/JupiterFetchClient'
+import { isSVMChain } from '@luxexchange/lx/src/features/platforms/utils/chains'
+import {
+  areCurrenciesEqual,
+  isZeroAmount,
+} from '@luxexchange/lx/src/features/transactions/swap/hooks/useTrade/parseQuoteCurrencies'
+import {
+  TradeService,
+  TradeWithGasEstimates,
+} from '@luxexchange/lx/src/features/transactions/swap/services/tradeService/tradeService'
+import { createSolanaTrade } from '@luxexchange/lx/src/features/transactions/swap/types/solana'
+import { UseTradeArgs } from '@luxexchange/lx/src/features/transactions/swap/types/trade'
+
+class JupiterOrderError extends Error {
+  name = 'JupiterOrderError'
+}
+
+function prepareJupiterTradeInput(args: UseTradeArgs): JupiterOrderUrlParams | null {
+  const input = args.tradeType === TradeType.EXACT_INPUT ? args.amountSpecified?.currency : args.otherCurrency
+  const output = args.tradeType === TradeType.EXACT_OUTPUT ? args.amountSpecified?.currency : args.otherCurrency
+  const slippageBps = args.customSlippageTolerance ? (args.customSlippageTolerance * 100).toString() : undefined
+  const swapMode = args.tradeType === TradeType.EXACT_INPUT ? 'ExactIn' : 'ExactOut'
+
+  if (
+    !input ||
+    !output ||
+    !isSVMChain(input.chainId) ||
+    !isSVMChain(output.chainId) ||
+    !args.amountSpecified ||
+    isZeroAmount(args.amountSpecified) ||
+    areCurrenciesEqual(input, output)
+  ) {
+    return null
+  }
+
+  return {
+    inputMint: input.wrapped.address,
+    outputMint: output.wrapped.address,
+    amount: args.amountSpecified.quotient.toString(),
+    taker: args.account?.address,
+    slippageBps,
+    swapMode,
+  }
+}
+
+export function createSolanaTradeService(): TradeService {
+  return {
+    async getTrade(args: UseTradeArgs): Promise<TradeWithGasEstimates> {
+      let quoteRequestArgs: JupiterOrderUrlParams | undefined
+      try {
+        // Step 1: Prepare trade input
+        const input = args.tradeType === TradeType.EXACT_INPUT ? args.amountSpecified?.currency : args.otherCurrency
+        const output = args.tradeType === TradeType.EXACT_OUTPUT ? args.amountSpecified?.currency : args.otherCurrency
+
+        // Step 2: Early exit if quote args are null
+        const validatedInput = prepareJupiterTradeInput(args)
+
+        if (!validatedInput || !input || !output) {
+          return { trade: null }
+        }
+
+        // Step 3: Build quote request with all params
+        quoteRequestArgs = validatedInput
+
+        // Step 4: Fetch quote from API
+        const quote = await JupiterApiClient.fetchOrder(quoteRequestArgs)
+
+        // Step 5: Transform quote to trade
+        const trade = createSolanaTrade({ quote, inputToken: input, outputToken: output })
+
+        return { trade, gasEstimate: undefined } // `gasEstimate` is used for our Gas Experiment, which we don't conduct on Solana
+      } catch (e) {
+        let error = e instanceof Error ? e : new Error('Unknown error')
+
+        // Translate FetchErrors into JupiterOrderError; FetchErrors are ignored in parts of logging
+        // However since the Jupiter proxy currently does not have backend monitoring, we want
+        // fetch related errors here to alert the frontend
+        if (error instanceof FetchError) {
+          error = new JupiterOrderError(String(error.data.error))
+        }
+
+        quoteRequestArgs = undefined
+        throw error
+      }
+    },
+    prepareTradeInput: prepareJupiterTradeInput,
+    // No indicative quotes on Jupiter
+    prepareIndicativeTradeInput: () => null,
+    getIndicativeTrade: () => Promise.resolve(null),
+  }
+}