@luxexchange/api 1.0.0

package/.depcheckrc

@@ -0,0 +1,17 @@
+ignores: [
+    # Dependencies that depcheck thinks are unused but are actually used
+    "openapi-typescript-codegen",
+    "typescript",
+    "@typescript/native-preview",
+    "depcheck",
+    "graphql",
+    "@graphql-codegen/*",
+    "get-graphql-schema",
+    "@vitest/coverage-v8",
+    # Dependencies that depcheck thinks are missing but are actually present
+    ## Internal packages / workspaces
+    "@universe/api",
+    "@universe/config",
+    "tsconfig",
+    "utilities",
+  ]

package/.eslintrc.js

@@ -0,0 +1,30 @@
+const { reactNative: reactNativeImports } = require('@luxfi/eslint-config/restrictedImports')
+
+module.exports = {
+  extends: ['@luxfi/eslint-config/lib'],
+  ignorePatterns: ['graphql.config.ts', 'stubs/**'],
+  parserOptions: {
+    tsconfigRootDir: __dirname,
+  },
+  overrides: [
+    {
+      files: ['**/*.{ts,tsx}'],
+      excludedFiles: ['**/*.native.*', '**/*.ios.*', '**/*.android.*'],
+      rules: {
+        '@typescript-eslint/no-restricted-imports': ['error', reactNativeImports],
+      },
+    },
+    {
+      files: ['*.ts', '*.tsx'],
+      rules: {
+        'no-relative-import-paths/no-relative-import-paths': [
+          'error',
+          {
+            allowSameFolder: false,
+            prefix: '@luxfi/api',
+          },
+        ],
+      },
+    },
+  ],
+}

package/README.md

@@ -0,0 +1,5 @@
+# `@universe/api` Package
+
+This package contains utilities and logic related to data fetching for the applications.
+
+// TODO: Add documentation for available utilities and usage examples.

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@luxexchange/api",
+  "version": "1.0.0",
+  "scripts": {
+    "lint:biome": "nx lint:biome api",
+    "lint:biome:fix": "nx lint:biome:fix api",
+    "lint:eslint": "nx lint:eslint api",
+    "lint:eslint:fix": "nx lint:eslint:fix api",
+    "lint": "nx lint api",
+    "lint:fix": "nx lint:fix api",
+    "typecheck": "nx typecheck api",
+    "typecheck:tsgo": "nx typecheck:tsgo api",
+    "prepare": "nx prepare api",
+    "test": "nx test api",
+    "test:coverage": "nx test:coverage api",
+    "graphql:generate": "nx graphql:generate api",
+    "graphql:schema": "nx graphql:schema api",
+    "tradingapi:schema": "nx tradingapi:schema api",
+    "tradingapi:generate:openapi": "nx tradingapi:generate:openapi api",
+    "tradingapi:generate": "nx tradingapi:generate api"
+  },
+  "nx": {
+    "includedScripts": []
+  },
+  "dependencies": {
+    "@apollo/client": "3.11.10",
+    "@bufbuild/protobuf": "1.10.0",
+    "@connectrpc/connect": "1.5.0",
+    "@connectrpc/connect-web": "1.5.0",
+    "@ethersproject/providers": "5.7.2",
+    "@tanstack/react-query": "5.90.20",
+    "@uniswap/client-data-api": "0.0.51",
+    "@uniswap/client-embeddedwallet": "0.0.16",
+    "@uniswap/client-explore": "0.0.17",
+    "@uniswap/client-for": "0.1.5",
+    "@uniswap/client-liquidity": "0.0.23",
+    "@uniswap/client-notification-service": "0.0.11",
+    "@luxexchange/config": "^1.0.0",
+    "@luxexchange/sessions": "^1.0.0",
+    "expo-secure-store": "14.0.1",
+    "graphql": "16.6.0",
+    "react": "19.0.3",
+    "@luxfi/utilities": "^1.0.0"
+  },
+  "devDependencies": {
+    "@graphql-codegen/cli": "3.3.1",
+    "@graphql-codegen/typescript": "3.0.4",
+    "@graphql-codegen/typescript-operations": "3.0.4",
+    "@graphql-codegen/typescript-react-apollo": "3.3.7",
+    "@graphql-codegen/typescript-resolvers": "3.2.1",
+    "@testing-library/react": "16.3.0",
+    "@types/chrome": "0.0.304",
+    "@types/node": "22.13.1",
+    "@types/react": "19.0.10",
+    "@typescript/native-preview": "7.0.0-dev.20260108.1",
+    "@luxfi/eslint-config": "^1.0.0",
+    "@vitest/coverage-v8": "3.2.1",
+    "depcheck": "1.4.7",
+    "eslint": "8.57.1",
+    "get-graphql-schema": "2.1.2",
+    "openapi-typescript-codegen": "0.27.0",
+    "ts-morph": "23.0.0",
+    "typescript": "5.8.3",
+    "viem": "2.30.5",
+    "vitest": "3.2.1",
+    "zod": "4.3.6"
+  },
+  "optionalDependencies": {
+    "@uniswap/client-privy-embedded-wallet": "0.0.2"
+  },
+  "main": "src/index.ts",
+  "private": false,
+  "sideEffects": false
+}

package/project.json

@@ -0,0 +1,94 @@
+{
+  "name": "@luxfi/api",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "pkgs/api/src",
+  "projectType": "library",
+  "tags": ["scope:api", "type:lib"],
+  "targets": {
+    "lint:biome": {},
+    "lint:biome:fix": {},
+    "lint:eslint": {},
+    "lint:eslint:fix": {},
+    "lint": {},
+    "lint:fix": {},
+    "typecheck": {},
+    "typecheck:tsgo": {},
+    "prepare": {
+      "executor": "nx:run-commands",
+      "options": {
+        "commands": ["nx graphql:generate api", "nx tradingapi:generate api"],
+        "parallel": false
+      },
+      "cache": true,
+      "inputs": [],
+      "outputs": []
+    },
+    "check:deps:usage": {},
+    "test": {
+      "command": "vitest run",
+      "options": {
+        "cwd": "{projectRoot}"
+      }
+    },
+    "test:coverage": {
+      "command": "vitest run --coverage",
+      "options": {
+        "cwd": "{projectRoot}"
+      }
+    },
+    "tradingapi:schema": {
+      "command": "curl https://trading-api-labs.interface.gateway.lux.exchange/v1/api.json -o ./src/clients/trading/api.json",
+      "options": {
+        "cwd": "{projectRoot}"
+      }
+    },
+    "tradingapi:generate:openapi": {
+      "command": "openapi --input ./src/clients/trading/api.json --output ./src/clients/trading/__generated__ --useOptions --exportServices true --exportModels true",
+      "options": {
+        "cwd": "{projectRoot}"
+      },
+      "cache": true,
+      "inputs": ["{projectRoot}/src/clients/trading/api.json"],
+      "outputs": ["{projectRoot}/src/clients/trading/__generated__"]
+    },
+    "tradingapi:generate": {
+      "command": "node --no-warnings=ExperimentalWarning --loader ts-node/esm ./scripts/modifyTradingApiTypes.mts",
+      "options": {
+        "cwd": "{projectRoot}"
+      },
+      "cache": true,
+      "inputs": [
+        "{projectRoot}/scripts/modifyTradingApiTypes.mts",
+        "{projectRoot}/src/clients/trading/types.ts",
+        {
+          "runtime": "node -v"
+        },
+        {
+          "dependentTasksOutputFiles": "**/*.ts"
+        }
+      ],
+      "outputs": ["{projectRoot}/src/clients/trading/__generated__/models"],
+      "dependsOn": ["tradingapi:generate:openapi"]
+    },
+    "graphql:schema": {
+      "command": "get-graphql-schema https://api.lux.exchange/v1/graphql -h Origin=https://app.lux.exchange > ./src/clients/graphql/schema.graphql",
+      "options": {
+        "cwd": "{projectRoot}"
+      }
+    },
+    "graphql:generate": {
+      "command": "graphql-codegen --config ./src/clients/graphql/codegen.config.ts && node --no-warnings=ExperimentalWarning --loader ts-node/esm ./scripts/fixGraphQLApiTypes.mts",
+      "options": {
+        "cwd": "{projectRoot}"
+      },
+      "cache": true,
+      "inputs": [
+        "{projectRoot}/src/clients/graphql/codegen.config.ts",
+        "{projectRoot}/src/**/*.graphql",
+        "{projectRoot}/src/**/*.gql",
+        "{projectRoot}/scripts/fixGraphQLApiTypes.mts"
+      ],
+      "outputs": ["{projectRoot}/src/clients/graphql/__generated__"]
+    }
+  }
+}

package/scripts/fixGraphQLApiTypes.mts

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * Post-processing script to fix imports in generated GraphQL files
+ * Uses TypeScript AST to extract exports and add proper re-exports
+ */
+import { Project } from 'ts-morph'
+import path from 'path'
+
+const genDir = path.join(process.cwd(), 'src/clients/graphql/__generated__')
+
+// Create a ts-morph project
+const project = new Project({
+  tsConfigFilePath: path.join(process.cwd(), 'tsconfig.json'),
+})
+
+/**
+ * Extract all exported type/interface/enum/const names from a TypeScript file
+ */
+function extractExports(filePath: string): string[] {
+  const sourceFile = project.addSourceFileAtPath(filePath)
+  const exports: string[] = []
+
+  // Get all exported declarations
+  sourceFile.getExportedDeclarations().forEach((declarations, name) => {
+    exports.push(name)
+  })
+
+  // Remove the source file from project to avoid conflicts
+  project.removeSourceFile(sourceFile)
+
+  return exports
+}
+
+/**
+ * Add import statement to a file
+ */
+function addImport(filePath: string, fromFile: string, exportNames: string[]): void {
+  if (exportNames.length === 0) {
+    return
+  }
+
+  const sourceFile = project.addSourceFileAtPath(filePath)
+
+  // Check if import already exists
+  const existingImports = sourceFile.getImportDeclarations()
+  const alreadyExists = existingImports.some(
+    imp => imp.getModuleSpecifierValue() === fromFile
+  )
+
+  if (!alreadyExists) {
+    // Add import at the top (after any existing imports)
+    const importDeclarations = sourceFile.getImportDeclarations()
+    const insertIndex = importDeclarations.length
+
+    sourceFile.insertImportDeclaration(insertIndex, {
+      moduleSpecifier: fromFile,
+      namedImports: exportNames.map(name => ({ name, isTypeOnly: true })),
+    })
+
+    sourceFile.saveSync()
+  }
+
+  project.removeSourceFile(sourceFile)
+}
+
+// Step 1: Extract all exports from schema-types.ts
+const schemaTypesPath = path.join(genDir, 'schema-types.ts')
+const schemaExports = extractExports(schemaTypesPath)
+console.log(`Found ${schemaExports.length} exports in schema-types.ts`)
+
+// Step 2: Add imports to resolvers.ts from schema-types.ts
+const resolversPath = path.join(genDir, 'resolvers.ts')
+addImport(resolversPath, './schema-types', schemaExports)
+console.log('✓ Added imports to resolvers.ts')
+
+// Step 3: Add imports to operations.ts from schema-types.ts
+const operationsPath = path.join(genDir, 'operations.ts')
+addImport(operationsPath, './schema-types', schemaExports)
+console.log('✓ Added imports to operations.ts')
+
+// Step 4: Extract all exports from operations.ts
+const operationsExports = extractExports(operationsPath)
+console.log(`Found ${operationsExports.length} exports in operations.ts`)
+
+// Step 5: Add imports to react-hooks.ts from operations.ts
+const hooksPath = path.join(genDir, 'react-hooks.ts')
+addImport(hooksPath, './operations', operationsExports)
+console.log('✓ Added imports to react-hooks.ts')
+
+
+console.log('\n✓ GraphQL codegen post-processing complete!')

package/scripts/modifyTradingApiTypes.mts

@@ -0,0 +1,232 @@
+import { Project, SourceFile, TypeLiteralNode } from 'ts-morph'
+
+const project = new Project()
+
+const path = './src/clients/trading/__generated__/models'
+
+// Request types
+const approvalRequestFile = project.addSourceFileAtPath(`${path}/ApprovalRequest.ts`)
+const createSendRequestFile = project.addSourceFileAtPath(`${path}/CreateSendRequest.ts`)
+const createSwapRequestFile = project.addSourceFileAtPath(`${path}/CreateSwapRequest.ts`)
+const quoteRequestFile = project.addSourceFileAtPath(`${path}/QuoteRequest.ts`)
+const requestFiles = [approvalRequestFile, createSendRequestFile, createSwapRequestFile, quoteRequestFile]
+
+// Response types
+const approvalResponseFile = project.addSourceFileAtPath(`${path}/ApprovalResponse.ts`)
+const createSwapResponseFile = project.addSourceFileAtPath(`${path}/CreateSwapResponse.ts`)
+const createSendResponseFile = project.addSourceFileAtPath(`${path}/CreateSendResponse.ts`)
+const classicQuoteFile = project.addSourceFileAtPath(`${path}/ClassicQuote.ts`)
+const chainedQuoteFile = project.addSourceFileAtPath(`${path}/ChainedQuote.ts`)
+const responseFiles = [approvalResponseFile, createSwapResponseFile, createSendResponseFile, classicQuoteFile]
+
+const planResponseFile = project.addSourceFileAtPath(`${path}/PlanResponse.ts`)
+
+
+const nullablePermitFile = project.addSourceFileAtPath(`${path}/NullablePermit.ts`)
+const planStepFile = project.addSourceFileAtPath(`${path}/PlanStep.ts`)
+
+
+// Enums
+const routingFile = project.addSourceFileAtPath(`${path}/Routing.ts`)
+const orderTypeFile = project.addSourceFileAtPath(`${path}/OrderType.ts`)
+const orderStatusFile = project.addSourceFileAtPath(`${path}/OrderStatus.ts`)
+
+function addImport(params: { file: SourceFile, importName: string, importPath?: string }): void {
+  const { file, importName, importPath = '../../types' } = params
+  if (!file.getImportDeclaration((imp) => imp.getModuleSpecifierValue() === importPath)) {
+    file.addImportDeclaration({
+      namedImports: [importName],
+      moduleSpecifier: importPath,
+    })
+  } else {
+    const existingImport = file.getImportDeclaration((imp) => imp.getModuleSpecifierValue() === importPath)
+    if (
+      existingImport &&
+      !existingImport.getNamedImports().some((namedImport) => namedImport.getName() === importName)
+    ) {
+      existingImport.addNamedImport(importName)
+    }
+  }
+}
+
+function saveFiles(params: { files: (SourceFile | SourceFile[])[] }) {
+  params.files.forEach((file) => {
+    if (Array.isArray(file)) {
+      file.forEach((f) => f.saveSync())
+    } else {
+      file.saveSync()
+    }
+  })
+}
+
+function modifyType(params: {
+  file: SourceFile,
+  typeName: string,
+  newProperties: { name: string; type: string; isOptional?: boolean }[],
+  replace?: boolean,
+}): void {
+  const { file, typeName, newProperties, replace = false } = params
+  const typeAlias = file.getTypeAlias(typeName)
+  if (typeAlias) {
+    const typeNode = typeAlias.getTypeNode()
+    if (typeNode && TypeLiteralNode.isTypeLiteral(typeNode)) {
+      newProperties.forEach((prop) => {
+        const existingProperty = typeNode.getProperty(prop.name)
+        if (!existingProperty) {
+          typeNode.addProperty({
+            name: prop.name,
+            type: prop.type,
+            hasQuestionToken: prop.isOptional,
+          })
+          console.log(`Added property ${prop.name} to ${typeName}`)
+        } else {
+          console.log(`Property ${prop.name} already exists in ${typeName}`)
+          if (replace) {
+            existingProperty.remove()
+            typeNode.addProperty({
+              name: prop.name,
+              type: prop.type,
+              hasQuestionToken: prop.isOptional,
+            })
+            console.log(`Replaced property ${prop.name} in ${typeName}`)
+          }
+        }
+      })
+    } else {
+      console.log(`Type ${typeName} is not an object type`)
+    }
+  } else {
+    console.log(`Type ${typeName} not found`)
+  }
+}
+
+function addToTypeAlias(params: { file: SourceFile, typeName: string, typeToAdd: string }): void {
+  const { file, typeName, typeToAdd } = params
+  const typeAlias = file.getTypeAlias(typeName)
+  if (typeAlias) {
+    const typeNode = typeAlias.getTypeNode()
+    if (typeNode && TypeLiteralNode.isTypeLiteral(typeNode)) {
+      // Note: this isn't the best matcher for the incoming type but until we need more complex matching, this will do.
+      if (!typeNode.getText().includes(typeToAdd)) {
+        typeAlias.setType(`${typeNode.getText()} ${typeToAdd}`)
+        console.log(`Added ${typeToAdd} to ${typeName}`)
+      } else {
+        console.log(`${typeToAdd} already exists in ${typeName}`)
+      }
+    }
+  } else {
+    console.log(`Type ${typeName} not found`)
+  }
+}
+
+function addEnumMember(params: {
+  file: SourceFile,
+  enumName: string,
+  newMember: { name: string; value: string }
+  deprecated?: boolean
+}): void {
+  const { file, enumName, newMember, deprecated } = params
+  const enumDecl = file.getEnum(enumName)
+
+  if (!enumDecl) {
+    console.log(`Enum ${enumName} not found in ${file.getBaseName()}`)
+    return
+  }
+
+  const existing = enumDecl.getMember(newMember.name)
+
+  if (existing) {
+    console.log(`Enum member ${newMember.name} already exists in ${enumName}`)
+    return
+  }
+
+  enumDecl.addMember({
+    name: newMember.name,
+    initializer: `"${newMember.value}"`,
+    docs: deprecated ? [{ description: '@deprecated Deprecation flag added via modifyTradingApiTypes.mts in order to not break existing code.' }] : undefined,
+  })
+
+  console.log(`Added enum member ${newMember.name} = "${newMember.value}" to ${enumName}`)
+}
+
+
+function main() {
+  // Modify the request interfaces
+  requestFiles.forEach((file) => {
+    addImport({ file, importName: 'GasStrategy' })
+    modifyType({
+      file,
+      typeName: file.getBaseName().replace('.ts', ''),
+      newProperties: [
+        { name: 'gasStrategies', type: 'GasStrategy[]', isOptional: true },
+      ],
+    })
+  })
+
+  // Modify the response interfaces
+  responseFiles.forEach((file) => {
+    addImport({ file, importName: 'GasEstimate' })
+    modifyType({
+      file,
+      typeName: file.getBaseName().replace('.ts', ''),
+      newProperties: [
+        { name: 'gasEstimates', type: 'GasEstimate[]', isOptional: true },
+      ],
+    })
+  })
+  addImport({ file: chainedQuoteFile, importName: 'GasEstimate' })
+  addImport({ file: chainedQuoteFile, importName: 'slippageTolerance', importPath: './slippageTolerance' })
+  modifyType({
+    file: chainedQuoteFile,
+    typeName: 'ChainedQuote',
+    newProperties: [
+      { name: 'gasEstimates', type: 'GasEstimate[]', isOptional: true },
+      { name: 'slippage', type: 'slippageTolerance', isOptional: true },
+    ],
+    replace: true,
+  })
+
+  // TODO: NullablePermit is marked as nullable in api.json but not in the generated types.
+  addToTypeAlias({
+    file: nullablePermitFile,
+    typeName: 'NullablePermit',
+    typeToAdd: '| null',
+  })
+
+  
+  modifyType({
+    file: planResponseFile,
+    typeName: 'PlanResponse',
+    newProperties: [
+      { name: 'lastUserActionAt', type: 'string', isOptional: true },
+    ],
+  })
+
+  // Add new enum member
+  addEnumMember({ file: routingFile, enumName: 'Routing', newMember: { name: 'JUPITER', value: 'JUPITER' } })
+
+  // TODO: Check if this was removed from the API. Leaving it in to not break existing code.
+  addEnumMember({ file: routingFile, enumName: 'Routing', newMember: { name: 'DUTCH_LIMIT', value: 'DUTCH_LIMIT' }, deprecated: true })
+  addEnumMember({ file: orderTypeFile, enumName: 'OrderType', newMember: { name: 'DUTCH', value: 'DUTCH' }, deprecated: true })
+  addEnumMember({ file: orderTypeFile, enumName: 'OrderType', newMember: { name: 'DUTCH_LIMIT', value: 'DUTCH_LIMIT' }, deprecated: true })
+  addEnumMember({ file: orderStatusFile, enumName: 'OrderStatus', newMember: { name: 'UNVERIFIED', value: 'unverified' }, deprecated: true })
+
+
+  saveFiles({
+    files: [
+      requestFiles,
+      responseFiles,
+      planResponseFile,
+      routingFile,
+      nullablePermitFile,
+      orderTypeFile,
+      orderStatusFile,
+      chainedQuoteFile,
+      planStepFile,
+    ]
+
+  })
+  console.log('Trading API types have been updated')
+}
+
+main()

package/src/client.ts

@@ -0,0 +1,66 @@
+import { QueryClient } from '@tanstack/react-query'
+
+/**
+ * Create a React Query client with Lux Exchange defaults
+ */
+export function createQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        // 30 seconds stale time by default
+        staleTime: 30_000,
+        // 5 minutes cache time
+        gcTime: 5 * 60 * 1000,
+        // Retry failed queries once
+        retry: 1,
+        // Don't refetch on window focus by default
+        refetchOnWindowFocus: false,
+      },
+      mutations: {
+        // Retry mutations once
+        retry: 1,
+      },
+    },
+  })
+}
+
+/**
+ * API base URLs
+ */
+export const API_URLS = {
+  // Token list API
+  TOKEN_LIST: 'https://tokens.lux.network',
+
+  // Price API
+  PRICE_API: 'https://api.lux.network/prices',
+
+  // Analytics API
+  ANALYTICS_API: 'https://api.lux.network/analytics',
+
+  // Subgraph endpoints
+  V2_SUBGRAPH: 'https://api.lux.network/subgraphs/exchange-v2',
+  V3_SUBGRAPH: 'https://api.lux.network/subgraphs/exchange-v3',
+} as const
+
+/**
+ * Fetch with timeout
+ */
+export async function fetchWithTimeout(
+  url: string,
+  options: RequestInit & { timeout?: number } = {}
+): Promise<Response> {
+  const { timeout = 10_000, ...fetchOptions } = options
+
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), timeout)
+
+  try {
+    const response = await fetch(url, {
+      ...fetchOptions,
+      signal: controller.signal,
+    })
+    return response
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}

package/src/clients/auctions/createAuctionServiceClient.ts

@@ -0,0 +1,44 @@
+import { PromiseClient } from '@connectrpc/connect'
+import { AuctionService } from '@uniswap/client-data-api/dist/data/v1/auction_connect'
+import {
+  GetAuctionActivityRequest,
+  GetAuctionActivityResponse,
+  GetAuctionRequest,
+  GetAuctionResponse,
+  GetBidsByWalletRequest,
+  GetBidsByWalletResponse,
+  GetBidsRequest,
+  GetBidsResponse,
+  GetClearingPriceHistoryRequest,
+  GetClearingPriceHistoryResponse,
+  GetLatestCheckpointRequest,
+  GetLatestCheckpointResponse,
+  ListTopAuctionsRequest,
+  ListTopAuctionsResponse,
+} from '@uniswap/client-data-api/dist/data/v1/auction_pb'
+
+interface AuctionServiceClientContext {
+  rpcClient: PromiseClient<typeof AuctionService>
+}
+
+export interface AuctionServiceClient {
+  getAuction: (params: GetAuctionRequest) => Promise<GetAuctionResponse>
+  getAuctionActivity: (params: GetAuctionActivityRequest) => Promise<GetAuctionActivityResponse>
+  getBids: (params: GetBidsRequest) => Promise<GetBidsResponse>
+  getBidsByWallet: (params: GetBidsByWalletRequest) => Promise<GetBidsByWalletResponse>
+  getClearingPriceHistory: (params: GetClearingPriceHistoryRequest) => Promise<GetClearingPriceHistoryResponse>
+  getLatestCheckpoint: (params: GetLatestCheckpointRequest) => Promise<GetLatestCheckpointResponse>
+  listTopAuctions: (params: ListTopAuctionsRequest) => Promise<ListTopAuctionsResponse>
+}
+
+export function createAuctionServiceClient({ rpcClient }: AuctionServiceClientContext): AuctionServiceClient {
+  return {
+    getAuction: (params) => rpcClient.getAuction(params),
+    getAuctionActivity: (params) => rpcClient.getAuctionActivity(params),
+    getBids: (params) => rpcClient.getBids(params),
+    getBidsByWallet: (params) => rpcClient.getBidsByWallet(params),
+    getClearingPriceHistory: (params) => rpcClient.getClearingPriceHistory(params),
+    getLatestCheckpoint: (params) => rpcClient.getLatestCheckpoint(params),
+    listTopAuctions: (params) => rpcClient.listTopAuctions(params),
+  }
+}

package/src/clients/base/SharedQueryClient.ts

@@ -0,0 +1,25 @@
+import { QueryClient } from '@tanstack/react-query'
+import { FetchError } from '@luxfi/api/src/clients/base/errors'
+import { hashKey } from '@luxfi/utilities/src/reactQuery/hashKey'
+import { ONE_DAY_MS, ONE_SECOND_MS } from '@luxfi/utilities/src/time/time'
+
+export const SharedQueryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      // Ideally, these default values should never be used.
+      // Each query should set its own `staleTime` and `gcTime` depending on how often the data is expected to change,
+      // and how important it is to keep the data fresh every time a component mounts.
+      staleTime: 15 * ONE_SECOND_MS,
+      gcTime: ONE_DAY_MS,
+      // Retry once, only if the error is a 500 fetch error.
+      retry: (failureCount, error): boolean => {
+        if (failureCount < 2 && error instanceof FetchError && error.response.status === 500) {
+          return true
+        }
+
+        return false
+      },
+      queryKeyHashFn: hashKey,
+    },
+  },
+})