@luxexchange/lx 1.0.0

package/src/data/apiClients/tradingApi/TradingApiClient.ts

@@ -0,0 +1,227 @@
+import { createTradingApiClient, TradingApi, type TradingApiClient as TradingApiClientType } from '@luxexchange/api'
+import { TRADING_API_PATHS } from '@luxexchange/api/src/clients/trading/createTradingApiClient'
+import {
+  EthAsErc20DEXProperties,
+  Experiments,
+  FeatureFlags,
+  getExperimentValue,
+  getFeatureFlag,
+} from '@luxexchange/gating'
+import { config } from '@luxexchange/lx/src/config'
+import { tradingApiVersionPrefix, luxUrls } from '@luxexchange/lx/src/constants/urls'
+import { createLuxFetchClient } from '@luxexchange/lx/src/data/apiClients/createLuxFetchClient'
+import { filterChainIdsByPlatform } from '@luxexchange/lx/src/features/chains/utils'
+import { Platform } from '@luxexchange/lx/src/features/platforms/types/Platform'
+
+const TradingFetchClient = createLuxFetchClient({
+  baseUrl: luxUrls.tradingApiUrl,
+  additionalHeaders: {
+    'x-api-key': config.tradingApiKey,
+  },
+})
+
+/**
+ * Helper to add a header only if enabled.
+ */
+function addHeaderIfEnabled(params: { headers: Record<string, string>; key: string; enabled: boolean }): void {
+  const { headers, key, enabled } = params
+  if (enabled) {
+    headers[key] = 'true'
+  }
+}
+
+export enum TradingApiHeaders {
+  UniversalRouterVersion = 'x-universal-router-version',
+  UniquoteEnabled = 'x-uniquote-enabled',
+  ViemProviderEnabled = 'x-viem-provider-enabled',
+  Erc20EthEnabled = 'x-erc20eth-enabled',
+  ChainedActionsEnabled = 'x-chained-actions-enabled',
+  UnirouteEnabled = 'x-uniroute-enabled',
+  UniroutePulumiEnabled = 'x-uniroute-pulumi-enabled',
+  DisableLuxInterfaceFees = 'x-disable-lux-interface-fees',
+}
+
+/**
+ * Returns the headers for the trading API client that are based on feature flags
+ *
+ * NOTE: Be sure to confirm that adding this header does not cause a CORS issue
+ * with the web environments.
+ */
+export const getFeatureFlaggedHeaders = (
+  tradingApiPath: (typeof TRADING_API_PATHS)[keyof typeof TRADING_API_PATHS],
+): HeadersInit => {
+  const headers: Record<string, string> = {
+    [TradingApiHeaders.UniversalRouterVersion]: TradingApi.UniversalRouterVersion._2_0,
+  }
+  const uniquoteEnabled = getFeatureFlag(FeatureFlags.UniquoteEnabled)
+  const viemProviderEnabled = getFeatureFlag(FeatureFlags.ViemProviderEnabled)
+  addHeaderIfEnabled({ headers, key: TradingApiHeaders.UniquoteEnabled, enabled: uniquoteEnabled })
+  addHeaderIfEnabled({ headers, key: TradingApiHeaders.ViemProviderEnabled, enabled: viemProviderEnabled })
+
+  const chainedActionsEnabled = getFeatureFlag(FeatureFlags.ChainedActions)
+  const unirouteEnabled = getFeatureFlag(FeatureFlags.UnirouteEnabled)
+  const uniroutePulumiEnabled = getFeatureFlag(FeatureFlags.UniroutePulumiEnabled)
+  const ethAsErc20DEXEnabled = getExperimentValue({
+    experiment: Experiments.EthAsErc20DEX,
+    param: EthAsErc20DEXProperties.EthAsErc20DEXEnabled,
+    defaultValue: false,
+  })
+  const disableLuxInterfaceFees = getFeatureFlag(FeatureFlags.NoLuxInterfaceFees)
+  switch (tradingApiPath) {
+    case TRADING_API_PATHS.quote:
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.UnirouteEnabled, enabled: unirouteEnabled })
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.UniroutePulumiEnabled, enabled: uniroutePulumiEnabled })
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.Erc20EthEnabled, enabled: ethAsErc20DEXEnabled })
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.ChainedActionsEnabled, enabled: chainedActionsEnabled })
+      addHeaderIfEnabled({
+        headers,
+        key: TradingApiHeaders.DisableLuxInterfaceFees,
+        enabled: disableLuxInterfaceFees,
+      })
+      break
+    case TRADING_API_PATHS.plan:
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.ChainedActionsEnabled, enabled: chainedActionsEnabled })
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.Erc20EthEnabled, enabled: ethAsErc20DEXEnabled })
+      break
+    case TRADING_API_PATHS.order:
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.Erc20EthEnabled, enabled: ethAsErc20DEXEnabled })
+      break
+    case TRADING_API_PATHS.swap7702:
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.UnirouteEnabled, enabled: unirouteEnabled })
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.UniroutePulumiEnabled, enabled: uniroutePulumiEnabled })
+      addHeaderIfEnabled({ headers, key: TradingApiHeaders.Erc20EthEnabled, enabled: ethAsErc20DEXEnabled })
+      break
+  }
+  return headers
+}
+
+/**
+ * NOTE: Be sure to confirm that adding this header does not cause a CORS issue
+ * with the web environments
+ */
+export const getQuoteHeaders = (): Record<string, string> => {
+  const headers: Record<string, string> = {}
+  const unirouteEnabled = getFeatureFlag(FeatureFlags.UnirouteEnabled)
+  const uniroutePulumiEnabled = getFeatureFlag(FeatureFlags.UniroutePulumiEnabled)
+  addHeaderIfEnabled({ headers, key: 'x-uniroute-enabled', enabled: unirouteEnabled })
+  addHeaderIfEnabled({ headers, key: 'x-uniroute-pulumi-enabled', enabled: uniroutePulumiEnabled })
+  return headers
+}
+
+// Narrowed to `TradingApiClientType` type safety to ensure we are only using the plan endpoints with sessions, until full migration
+export const TradingApiClient: TradingApiClientType = createTradingApiClient({
+  fetchClient: TradingFetchClient,
+  getFeatureFlagHeaders: getFeatureFlaggedHeaders,
+  getApiPathPrefix: () => tradingApiVersionPrefix,
+})
+
+// Default maximum amount of combinations wallet<>chainId per check delegation request
+const DEFAULT_CHECK_VALIDATIONS_BATCH_THRESHOLD = 140
+
+// Utility function to chunk wallet addresses for batching
+function chunkWalletAddresses(params: {
+  walletAddresses: Address[]
+  chainIds: TradingApi.ChainId[]
+  batchThreshold: number
+}): Address[][] {
+  const { walletAddresses, chainIds, batchThreshold } = params
+  const totalCombinations = walletAddresses.length * chainIds.length
+
+  if (totalCombinations <= batchThreshold) {
+    return [walletAddresses]
+  }
+
+  const maxWalletsPerBatch = Math.floor(batchThreshold / chainIds.length)
+  const chunks: Address[][] = []
+
+  for (let i = 0; i < walletAddresses.length; i += maxWalletsPerBatch) {
+    chunks.push(walletAddresses.slice(i, i + maxWalletsPerBatch))
+  }
+
+  return chunks
+}
+
+function mergeDelegationResponses(
+  responses: TradingApi.WalletCheckDelegationResponseBody[],
+): TradingApi.WalletCheckDelegationResponseBody {
+  if (responses.length === 0) {
+    throw new Error('No responses to merge')
+  }
+
+  const firstResponse = responses[0]
+  if (!firstResponse) {
+    throw new Error('First response is undefined')
+  }
+
+  if (responses.length === 1) {
+    return firstResponse
+  }
+
+  const mergedDelegationDetails: Record<string, TradingApi.ChainDelegationMap> = {}
+
+  for (const response of responses) {
+    for (const [walletAddress, chainDelegationMap] of Object.entries(response.delegationDetails)) {
+      mergedDelegationDetails[walletAddress] = chainDelegationMap
+    }
+  }
+
+  return {
+    requestId: firstResponse.requestId,
+    delegationDetails: mergedDelegationDetails,
+  }
+}
+
+export type CheckWalletDelegation = (
+  params: TradingApi.WalletCheckDelegationRequestBody,
+) => Promise<TradingApi.WalletCheckDelegationResponseBody>
+
+export async function checkWalletDelegation(
+  params: TradingApi.WalletCheckDelegationRequestBody,
+  batchThreshold: number = DEFAULT_CHECK_VALIDATIONS_BATCH_THRESHOLD,
+): Promise<TradingApi.WalletCheckDelegationResponseBody> {
+  const { walletAddresses, chainIds } = params
+
+  // Filter out SVM chains - check_delegation only supports EVM chains
+  const evmChainIds = filterChainIdsByPlatform(chainIds, Platform.EVM)
+
+  // If no wallet addresses provided or if no EVM chains after filtering, return empty response
+  if (!walletAddresses || walletAddresses.length === 0 || evmChainIds.length === 0) {
+    return {
+      requestId: '',
+      delegationDetails: {},
+    }
+  }
+
+  // Ensure batchThreshold is at least the number of chain IDs
+  const effectiveBatchThreshold = Math.max(batchThreshold, evmChainIds.length)
+
+  const totalCombinations = walletAddresses.length * evmChainIds.length
+
+  // If under threshold, make a single request
+  if (totalCombinations <= effectiveBatchThreshold) {
+    return await TradingApiClient.checkWalletDelegationWithoutBatching({
+      walletAddresses,
+      chainIds: evmChainIds,
+    })
+  }
+
+  // Split into batches
+  const walletChunks = chunkWalletAddresses({
+    walletAddresses,
+    chainIds: evmChainIds,
+    batchThreshold: effectiveBatchThreshold,
+  })
+
+  // Make batched requests
+  const batchPromises = walletChunks.map((chunk) =>
+    TradingApiClient.checkWalletDelegationWithoutBatching({
+      walletAddresses: chunk,
+      chainIds: evmChainIds,
+    }),
+  )
+
+  const responses = await Promise.all(batchPromises)
+
+  // Merge all responses
+  return mergeDelegationResponses(responses)
+}

package/src/data/apiClients/tradingApi/TradingApiSessionClient.ts

@@ -0,0 +1,73 @@
+import { createFetchClient, createTradingApiClient, getEntryGatewayUrl, provideSessionService } from '@luxexchange/api'
+import type { PlanEndpoints } from '@luxexchange/api/src/clients/trading/createTradingApiClient'
+import { reinitializeSession } from '@luxexchange/api/src/components/ApiInit'
+import { createWithSessionRetry } from '@luxexchange/api/src/session/createWithSessionRetry'
+import { getConfig } from '@luxexchange/config'
+import { FeatureFlags, getFeatureFlag } from '@luxexchange/gating'
+import { BASE_LUX_HEADERS } from '@luxexchange/lx/src/data/apiClients/createLuxFetchClient'
+import { getFeatureFlaggedHeaders } from '@luxexchange/lx/src/data/apiClients/tradingApi/TradingApiClient'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+function getHeaders(): HeadersInit {
+  // Use API key auth instead of session auth, if the flag is enabled.
+  if (getFeatureFlag(FeatureFlags.DisableSessionsForPlan)) {
+    return {
+      ...BASE_LUX_HEADERS,
+      'x-api-key': getConfig().tradingApiKey,
+    }
+  }
+  return BASE_LUX_HEADERS
+}
+
+const withSessionRetry = createWithSessionRetry({
+  reinitializeSession: () => {
+    if (getFeatureFlag(FeatureFlags.DisableSessionsForPlan)) {
+      return Promise.resolve() // API key auth — session re-init won't help
+    }
+    logger.warn('TradingApiSessionClient', 'reinitializeSession', 'Reinitializing session during plan')
+    return reinitializeSession()
+  },
+  onReinitializationFailed: () => {
+    logger.warn('TradingApiSessionClient', 'onReinitializationFailed', 'Reinitialization failed during plan')
+  },
+})
+
+const entryGatewayTradingFetchClientWithSession = createFetchClient({
+  getBaseUrl: getEntryGatewayUrl,
+  getHeaders,
+  getSessionService: () =>
+    provideSessionService({
+      getBaseUrl: getEntryGatewayUrl,
+      // Sessions are currently required for plans, so this is enabled by default. The flag exists as a safety net to disable sessions for plan if needed.
+      getIsSessionServiceEnabled: () => !getFeatureFlag(FeatureFlags.DisableSessionsForPlan),
+    }),
+  defaultOptions: {
+    credentials: 'include',
+  },
+})
+
+const BaseTradingApiSessionClient: PlanEndpoints = createTradingApiClient({
+  fetchClient: entryGatewayTradingFetchClientWithSession,
+  getFeatureFlagHeaders: getFeatureFlaggedHeaders,
+  getApiPathPrefix: () => '',
+})
+
+const TradingApiSessionClientWithRetry: PlanEndpoints = {
+  createNewPlan(params) {
+    return withSessionRetry(() => BaseTradingApiSessionClient.createNewPlan(params))
+  },
+  fetchPlan(params) {
+    return withSessionRetry(() => BaseTradingApiSessionClient.fetchPlan(params))
+  },
+  updateExistingPlan(params) {
+    return withSessionRetry(() => BaseTradingApiSessionClient.updateExistingPlan(params))
+  },
+  getExistingPlan(params) {
+    return withSessionRetry(() => BaseTradingApiSessionClient.getExistingPlan(params))
+  },
+  refreshExistingPlan(params) {
+    return withSessionRetry(() => BaseTradingApiSessionClient.refreshExistingPlan(params))
+  },
+}
+
+export const TradingApiSessionClient: PlanEndpoints = TradingApiSessionClientWithRetry

package/src/data/apiClients/tradingApi/dex/client.ts

@@ -0,0 +1,195 @@
+/**
+ * Lux DEX Gateway - Advanced Trading Client
+ *
+ * HTTP client for the DEX gateway's CLOB, perpetual, margin,
+ * and vault endpoints. Connects to the same gateway as LuxGatewayClient
+ * but exposes the advanced trading surface.
+ */
+import { luxUrls } from '@luxexchange/lx/src/constants/urls'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+import type {
+  CancelAllOrdersRequest,
+  CancelOrderRequest,
+  CollateralAsset,
+  DepositVaultRequest,
+  DexApiResponse,
+  FundingPayment,
+  FundingRate,
+  MarginAccount,
+  Market,
+  MarketStats,
+  Order,
+  OrderBook,
+  PaginatedResponse,
+  PerpPosition,
+  PlaceOrderRequest,
+  RecentTrade,
+  SetLeverageRequest,
+  SetMarginModeRequest,
+  Vault,
+  VaultPosition,
+  WithdrawVaultRequest,
+} from './types'
+
+const LOG_TAG = 'LuxDexClient'
+
+function getBaseUrl(): string {
+  return luxUrls.luxGatewayUrl
+}
+
+async function request<T>(method: string, path: string, body?: unknown): Promise<T> {
+  const url = `${getBaseUrl()}${path}`
+
+  logger.debug(LOG_TAG, method, `${method} ${path}`, { url })
+
+  const response = await fetch(url, {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+    ...(body ? { body: JSON.stringify(body) } : {}),
+  })
+
+  if (!response.ok) {
+    const errorText = await response.text()
+    logger.error(new Error(`DEX API error: ${response.status}`), {
+      tags: { file: LOG_TAG, function: method },
+      extra: { status: response.status, error: errorText, path },
+    })
+    throw new Error(`DEX API ${path}: ${response.status} - ${errorText}`)
+  }
+
+  const json: DexApiResponse<T> = await response.json()
+  if (!json.success) {
+    throw new Error(`DEX API error: ${json.error ?? 'Unknown error'}`)
+  }
+  return json.data
+}
+
+// ─── Markets ─────────────────────────────────────────────────────────
+
+export async function getMarkets(chainId: number): Promise<Market[]> {
+  return request<Market[]>('GET', `/api/markets?chainId=${chainId}`)
+}
+
+export async function getMarketStats(symbol: string): Promise<MarketStats> {
+  return request<MarketStats>('GET', `/api/stats?symbol=${encodeURIComponent(symbol)}`)
+}
+
+// ─── Order Book ──────────────────────────────────────────────────────
+
+export async function getOrderBook(symbol: string, depth = 50): Promise<OrderBook> {
+  return request<OrderBook>('GET', `/api/orderbook?symbol=${encodeURIComponent(symbol)}&depth=${depth}`)
+}
+
+export async function getRecentTrades(symbol: string, limit = 100): Promise<RecentTrade[]> {
+  return request<RecentTrade[]>('GET', `/api/trades?symbol=${encodeURIComponent(symbol)}&limit=${limit}`)
+}
+
+// ─── Orders ──────────────────────────────────────────────────────────
+
+export async function placeOrder(req: PlaceOrderRequest): Promise<Order> {
+  return request<Order>('POST', '/api/order', req)
+}
+
+export async function cancelOrder(req: CancelOrderRequest): Promise<{ cancelled: boolean }> {
+  return request<{ cancelled: boolean }>('DELETE', `/api/order/${req.orderId}`, req)
+}
+
+export async function cancelAllOrders(req?: CancelAllOrdersRequest): Promise<{ cancelledCount: number }> {
+  return request<{ cancelledCount: number }>('DELETE', '/api/orders', req)
+}
+
+export async function getOpenOrders(symbol?: string): Promise<Order[]> {
+  const qs = symbol ? `?symbol=${encodeURIComponent(symbol)}` : ''
+  return request<Order[]>('GET', `/api/orders${qs}`)
+}
+
+export async function getOrderHistory(params?: {
+  symbol?: string
+  limit?: number
+  offset?: number
+}): Promise<PaginatedResponse<Order>> {
+  const qs = new URLSearchParams()
+  if (params?.symbol) {
+    qs.set('symbol', params.symbol)
+  }
+  if (params?.limit) {
+    qs.set('limit', String(params.limit))
+  }
+  if (params?.offset) {
+    qs.set('offset', String(params.offset))
+  }
+  const query = qs.toString()
+  return request<PaginatedResponse<Order>>('GET', `/api/orders/history${query ? `?${query}` : ''}`)
+}
+
+// ─── Perpetual Positions ─────────────────────────────────────────────
+
+export async function getPositions(symbol?: string): Promise<PerpPosition[]> {
+  const qs = symbol ? `?symbol=${encodeURIComponent(symbol)}` : ''
+  return request<PerpPosition[]>('GET', `/api/positions${qs}`)
+}
+
+export async function closePosition(symbol: string): Promise<Order> {
+  return request<Order>('POST', '/api/positions/close', { symbol })
+}
+
+export async function setLeverage(req: SetLeverageRequest): Promise<{ leverage: number }> {
+  return request<{ leverage: number }>('POST', '/api/leverage', req)
+}
+
+export async function setMarginMode(req: SetMarginModeRequest): Promise<{ mode: string }> {
+  return request<{ mode: string }>('POST', '/api/margin-mode', req)
+}
+
+// ─── Margin Account ──────────────────────────────────────────────────
+
+export async function getMarginAccount(): Promise<MarginAccount> {
+  return request<MarginAccount>('GET', '/api/account/margin')
+}
+
+export async function getCollateral(): Promise<CollateralAsset[]> {
+  return request<CollateralAsset[]>('GET', '/api/account/collateral')
+}
+
+// ─── Funding ─────────────────────────────────────────────────────────
+
+export async function getFundingRate(symbol: string): Promise<FundingRate> {
+  return request<FundingRate>('GET', `/api/funding/rate?symbol=${encodeURIComponent(symbol)}`)
+}
+
+export async function getFundingHistory(symbol: string, limit = 100): Promise<FundingPayment[]> {
+  return request<FundingPayment[]>(
+    'GET',
+    `/api/funding/history?symbol=${encodeURIComponent(symbol)}&limit=${limit}`,
+  )
+}
+
+// ─── Vaults ──────────────────────────────────────────────────────────
+
+export async function getVaults(): Promise<Vault[]> {
+  return request<Vault[]>('GET', '/api/vaults')
+}
+
+export async function getVault(vaultId: string): Promise<Vault> {
+  return request<Vault>('GET', `/api/vaults/${vaultId}`)
+}
+
+export async function getVaultPositions(): Promise<VaultPosition[]> {
+  return request<VaultPosition[]>('GET', '/api/vaults/positions')
+}
+
+export async function depositVault(req: DepositVaultRequest): Promise<VaultPosition> {
+  return request<VaultPosition>('POST', `/api/vaults/${req.vaultId}/deposit`, req)
+}
+
+export async function withdrawVault(req: WithdrawVaultRequest): Promise<VaultPosition> {
+  return request<VaultPosition>('POST', `/api/vaults/${req.vaultId}/withdraw`, req)
+}
+
+// ─── WebSocket ───────────────────────────────────────────────────────
+
+export function createDexWebSocket(): WebSocket {
+  const wsUrl = getBaseUrl().replace(/^http/, 'ws') + '/ws'
+  return new WebSocket(wsUrl)
+}