@luxexchange/prices 1.0.1 → 1.0.3

package/.depcheckrc

@@ -0,0 +1,14 @@
+ignores: [
+    # Dependencies that depcheck incorrectly marks as unused
+    "typescript",
+    "@typescript/native-preview",
+    "depcheck",
+
+    # Internal packages / workspaces
+    "prices",
+    "@universe/prices",
+
+    # TODO: remove once used in tests
+    "@testing-library/react",
+    "@vitest/coverage-v8",
+  ]

package/.eslintrc.js

@@ -0,0 +1,20 @@
+module.exports = {
+  extends: ['@luxamm/eslint-config/lib'],
+  parserOptions: {
+    tsconfigRootDir: __dirname,
+  },
+  overrides: [
+    {
+      files: ['*.ts', '*.tsx'],
+      rules: {
+        'no-relative-import-paths/no-relative-import-paths': [
+          'error',
+          {
+            allowSameFolder: false,
+            prefix: '@luxexchange/prices',
+          },
+        ],
+      },
+    },
+  ],
+}

package/README.md

@@ -0,0 +1,3 @@
+# @universe/prices
+
+// TODO

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@luxexchange/prices",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "dependencies": {
     "@tanstack/react-query": "5.90.20",
-    "@uniswap/sdk-core": "7.10.1",
+    "@luxamm/sdk-core": "7.12.3",
     "@luxexchange/api": "workspace:^",
     "@luxexchange/websocket": "workspace:^",
     "@luxfi/utilities": "workspace:^"
@@ -14,7 +14,7 @@
   "devDependencies": {
     "@testing-library/react": "16.3.0",
     "@types/node": "22.13.1",
-    "@typescript/native-preview": "7.0.0-dev.20260108.1",
+    "@typescript/native-preview": "7.0.0-dev.20260311.1",
     "@luxfi/eslint-config": "workspace:^",
     "@vitest/coverage-v8": "3.2.1",
     "depcheck": "1.4.7",
@@ -25,7 +25,6 @@
   },
   "scripts": {
     "test": "nx test prices",
-    "test:coverage": "nx test:coverage prices",
     "typecheck": "nx typecheck prices",
     "typecheck:tsgo": "nx typecheck:tsgo prices",
     "lint": "nx lint prices",

package/project.json

@@ -1,7 +1,7 @@
 {
-  "name": "@universe/prices",
+  "name": "@luxexchange/prices",
   "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/prices/src",
+  "sourceRoot": "pkgs/prices/src",
   "projectType": "library",
   "tags": [],
   "targets": {
@@ -9,10 +9,6 @@
       "command": "vitest run --passWithNoTests",
       "options": { "cwd": "{projectRoot}" }
     },
-    "test:coverage": {
-      "command": "vitest run --coverage --passWithNoTests",
-      "options": { "cwd": "{projectRoot}" }
-    },
     "typecheck": {},
     "typecheck:tsgo": {},
     "lint:biome": {},

package/src/context/PriceServiceContext.test.tsx

@@ -2,9 +2,9 @@
 
 import type { QueryClient } from '@tanstack/react-query'
 import { renderHook } from '@testing-library/react'
-import { PriceServiceProvider, usePricesContext } from '@universe/prices/src/context/PriceServiceContext'
-import type { TokenPriceMessage, TokenSubscriptionParams } from '@universe/prices/src/types'
-import type { WebSocketClient } from '@universe/websocket'
+import { PriceServiceProvider, usePricesContext } from '@luxexchange/prices/src/context/PriceServiceContext'
+import type { TokenPriceMessage, TokenSubscriptionParams } from '@luxexchange/prices/src/types'
+import type { WebSocketClient } from '@luxexchange/websocket'
 import type { ReactNode } from 'react'
 import { describe, expect, it, vi } from 'vitest'
 

package/src/context/PriceServiceContext.tsx

@@ -1,11 +1,13 @@
 import type { QueryClient } from '@tanstack/react-query'
-import type { TokenPriceMessage, TokenSubscriptionParams } from '@universe/prices/src/types'
-import type { WebSocketClient } from '@universe/websocket'
-import { createContext, type ReactElement, type ReactNode, useContext } from 'react'
+import type { RestPriceBatcher } from '@luxexchange/prices/src/sources/rest/RestPriceBatcher'
+import type { TokenPriceMessage, TokenSubscriptionParams } from '@luxexchange/prices/src/types'
+import type { WebSocketClient } from '@luxexchange/websocket'
+import { createContext, type ReactElement, type ReactNode, useContext, useMemo } from 'react'
 
 interface PricesContextValue {
   wsClient: WebSocketClient<TokenSubscriptionParams, TokenPriceMessage['data']>
   queryClient: QueryClient
+  restBatcher?: RestPriceBatcher
 }
 
 const PricesContext = createContext<PricesContextValue | null>(null)
@@ -13,13 +15,16 @@ const PricesContext = createContext<PricesContextValue | null>(null)
 export function PriceServiceProvider({
   wsClient,
   queryClient,
+  restBatcher,
   children,
 }: {
   wsClient: WebSocketClient<TokenSubscriptionParams, TokenPriceMessage['data']>
   queryClient: QueryClient
+  restBatcher?: RestPriceBatcher
   children: ReactNode
 }): ReactElement {
-  return <PricesContext.Provider value={{ wsClient, queryClient }}>{children}</PricesContext.Provider>
+  const value = useMemo(() => ({ wsClient, queryClient, restBatcher }), [wsClient, queryClient, restBatcher])
+  return <PricesContext.Provider value={value}>{children}</PricesContext.Provider>
 }
 
 export function usePricesContext(): PricesContextValue {

package/src/hooks/useConnectionStatus.ts

@@ -1,5 +1,5 @@
-import { usePricesContext } from '@universe/prices/src/context/PriceServiceContext'
-import type { ConnectionStatus } from '@universe/websocket'
+import { usePricesContext } from '@luxexchange/prices/src/context/PriceServiceContext'
+import type { ConnectionStatus } from '@luxexchange/websocket'
 import { useSyncExternalStore } from 'react'
 
 /**

package/src/hooks/usePrice.ts

@@ -1,8 +1,8 @@
-import { queryOptions, skipToken, useQuery } from '@tanstack/react-query'
-import { usePricesContext } from '@universe/prices/src/context/PriceServiceContext'
-import { priceKeys } from '@universe/prices/src/queries/priceKeys'
-import { tokenPriceQueryOptions } from '@universe/prices/src/queries/tokenPriceQueryOptions'
-import type { TokenPriceData } from '@universe/prices/src/types'
+import { queryOptions, skipToken, useQuery, useQueryClient } from '@tanstack/react-query'
+import { usePricesContext } from '@luxexchange/prices/src/context/PriceServiceContext'
+import { priceKeys } from '@luxexchange/prices/src/queries/priceKeys'
+import { tokenPriceQueryOptions } from '@luxexchange/prices/src/queries/tokenPriceQueryOptions'
+import type { TokenPriceData } from '@luxexchange/prices/src/types'
 import { useEffect } from 'react'
 
 interface UsePriceOptions {
@@ -14,20 +14,23 @@ interface UsePriceOptions {
 /**
  * Hook to get the live price for a token.
  * Reads from React Query cache and auto-subscribes via websocket.
+ * Falls back to REST polling when WS data goes stale (if restBatcher is provided).
  *
  * Requires a PriceServiceProvider in the tree.
  */
 export function usePrice(options: UsePriceOptions): number | undefined {
   const { chainId, address, live = true } = options
-  const { wsClient } = usePricesContext()
+  const { wsClient, restBatcher } = usePricesContext()
+  const queryClient = useQueryClient()
 
   const enabled = chainId !== undefined && !!address
 
   // Data is populated externally via queryClient.setQueryData from WS messages.
+  // When restBatcher is provided, queryFn fires as a fallback when WS data goes stale.
   const { data } = useQuery(
     enabled
-      ? tokenPriceQueryOptions(chainId, address)
-      : queryOptions<TokenPriceData>({ queryKey: priceKeys.all, queryFn: skipToken, enabled: false }),
+      ? tokenPriceQueryOptions({ chainId, address, restBatcher, queryClient })
+      : queryOptions<TokenPriceData | null>({ queryKey: priceKeys.all, queryFn: skipToken, enabled: false }),
   )
 
   useEffect(() => {
@@ -40,5 +43,6 @@ export function usePrice(options: UsePriceOptions): number | undefined {
     })
   }, [enabled, live, chainId, address, wsClient])
 
-  return enabled ? (data?.price ?? undefined) : undefined
+  const price: number | undefined = enabled ? (data?.price ?? undefined) : undefined
+  return price
 }

package/src/index.ts

@@ -5,9 +5,9 @@ export {
   isRawTokenPriceMessage,
   parseConnectionMessage,
   parseTokenPriceMessage,
-} from '@universe/prices/src/sources/websocket/messageParser'
+} from '@luxexchange/prices/src/sources/websocket/messageParser'
 // Internals (testing / custom setups)
-export { createPriceSubscriptionHandler } from '@universe/prices/src/sources/websocket/subscriptionApi'
+export { createPriceSubscriptionHandler } from '@luxexchange/prices/src/sources/websocket/subscriptionApi'
 export type {
   ConnectionEstablishedMessage,
   Logger,
@@ -19,7 +19,7 @@ export type {
   TokenPriceData,
   TokenPriceMessage,
   TokenSubscriptionParams,
-} from '@universe/prices/src/types'
+} from '@luxexchange/prices/src/types'
 export {
   createPriceKey,
   createPriceKeyFromToken,
@@ -29,8 +29,8 @@ export {
   normalizeToken,
   parsePriceKey,
   toSubscriptionParams,
-} from '@universe/prices/src/utils/tokenIdentifier'
-export type { ConnectionStatus } from '@universe/websocket'
+} from '@luxexchange/prices/src/utils/tokenIdentifier'
+export type { ConnectionStatus } from '@luxexchange/websocket'
 export { PriceServiceProvider, usePricesContext } from './context/PriceServiceContext'
 export { useConnectionStatus } from './hooks/useConnectionStatus'
 // Consumer hooks
@@ -39,3 +39,7 @@ export { usePrice, usePrice as useLivePrice } from './hooks/usePrice'
 // Query utilities (advanced / UDL)
 export { priceKeys } from './queries/priceKeys'
 export { tokenPriceQueryOptions } from './queries/tokenPriceQueryOptions'
+export { REST_POLL_INTERVAL_MS } from './sources/rest/constants'
+// REST fallback
+export { RestPriceBatcher } from './sources/rest/RestPriceBatcher'
+export type { RestPriceClient } from './sources/rest/types'

package/src/queries/priceKeys.test.ts

@@ -1,4 +1,4 @@
-import { priceKeys } from '@universe/prices/src/queries/priceKeys'
+import { priceKeys } from '@luxexchange/prices/src/queries/priceKeys'
 import { ReactQueryCacheKey } from 'utilities/src/reactQuery/cache'
 import { describe, expect, it } from 'vitest'
 

package/src/queries/tokenPriceQueryOptions.ts

@@ -1,15 +1,41 @@
-import { queryOptions, skipToken } from '@tanstack/react-query'
-import { priceKeys } from '@universe/prices/src/queries/priceKeys'
-import type { TokenPriceData } from '@universe/prices/src/types'
+import { type QueryClient, queryOptions, skipToken } from '@tanstack/react-query'
+import { priceKeys } from '@luxexchange/prices/src/queries/priceKeys'
+import { REST_POLL_INTERVAL_MS } from '@luxexchange/prices/src/sources/rest/constants'
+import type { RestPriceBatcher } from '@luxexchange/prices/src/sources/rest/RestPriceBatcher'
+import type { TokenPriceData } from '@luxexchange/prices/src/types'
+
+export interface TokenPriceQueryOptionsParams {
+  chainId: number
+  address: string
+  restBatcher?: RestPriceBatcher
+  queryClient?: QueryClient
+}
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-export function tokenPriceQueryOptions(chainId: number, address: string) {
-  return queryOptions<TokenPriceData>({
-    queryKey: priceKeys.token(chainId, address),
-    queryFn: skipToken,
+export function tokenPriceQueryOptions({ chainId, address, restBatcher, queryClient }: TokenPriceQueryOptionsParams) {
+  const key = priceKeys.token(chainId, address)
+  return queryOptions<TokenPriceData | null>({
+    queryKey: key,
+    queryFn: restBatcher
+      ? async (): Promise<TokenPriceData | null> => {
+          const fresh = await restBatcher.fetch({ chainId, address: address.toLowerCase() })
+          if (!fresh) {
+            return null
+          }
+          // Guard against REST responses overwriting newer WebSocket data.
+          // refetchInterval fires independently of staleTime, so without this
+          // check a 30s-old REST response could clobber a sub-second WS update.
+          const existing = queryClient?.getQueryData<TokenPriceData>(key)
+          if (existing && existing.timestamp >= fresh.timestamp) {
+            return existing
+          }
+          return fresh
+        }
+      : skipToken,
     staleTime: Infinity,
     refetchOnWindowFocus: false,
     refetchOnMount: false,
     structuralSharing: false,
+    refetchInterval: restBatcher ? REST_POLL_INTERVAL_MS : false,
   })
 }

package/src/sources/rest/RestPriceBatcher.test.ts

@@ -0,0 +1,223 @@
+import { BATCH_DELAY_MS, MAX_BATCH_SIZE } from '@luxexchange/prices/src/sources/rest/constants'
+import { RestPriceBatcher } from '@luxexchange/prices/src/sources/rest/RestPriceBatcher'
+import type { RestPriceClient } from '@luxexchange/prices/src/sources/rest/types'
+import type { TokenPriceData } from '@luxexchange/prices/src/types'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+function createMockClient(
+  handler: (tokens: { chainId: number; address: string }[]) => Promise<Map<string, TokenPriceData>>,
+): RestPriceClient {
+  return { getTokenPrices: vi.fn(handler) }
+}
+
+function priceData(price: number, timestamp = Date.now()): TokenPriceData {
+  return { price, timestamp }
+}
+
+describe('RestPriceBatcher', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('batches multiple fetch calls within the batching window', async () => {
+    const client = createMockClient(async (tokens) => {
+      const result = new Map<string, TokenPriceData>()
+      for (const t of tokens) {
+        result.set(`${t.chainId}-${t.address}`, priceData(100 + t.chainId))
+      }
+      return result
+    })
+
+    const batcher = new RestPriceBatcher(client)
+
+    // Fire multiple fetches synchronously (same batching window)
+    const p1 = batcher.fetch({ chainId: 1, address: '0xaaa' })
+    const p2 = batcher.fetch({ chainId: 42161, address: '0xbbb' })
+
+    // Advance past the batch delay to trigger flush
+    vi.advanceTimersByTime(BATCH_DELAY_MS)
+
+    const [r1, r2] = await Promise.all([p1, p2])
+
+    expect(r1).toEqual(priceData(101, r1!.timestamp))
+    expect(r2).toEqual(priceData(42261, r2!.timestamp))
+    expect(client.getTokenPrices).toHaveBeenCalledTimes(1)
+    expect(client.getTokenPrices).toHaveBeenCalledWith([
+      { chainId: 1, address: '0xaaa' },
+      { chainId: 42161, address: '0xbbb' },
+    ])
+  })
+
+  it('deduplicates tokens within the same batch', async () => {
+    const client = createMockClient(async (tokens) => {
+      const result = new Map<string, TokenPriceData>()
+      for (const t of tokens) {
+        result.set(`${t.chainId}-${t.address}`, priceData(50))
+      }
+      return result
+    })
+
+    const batcher = new RestPriceBatcher(client)
+
+    const p1 = batcher.fetch({ chainId: 1, address: '0xAAA' })
+    const p2 = batcher.fetch({ chainId: 1, address: '0xaaa' }) // Same after lowercase
+
+    vi.advanceTimersByTime(BATCH_DELAY_MS)
+
+    const [r1, r2] = await Promise.all([p1, p2])
+
+    expect(r1).toEqual(priceData(50, r1!.timestamp))
+    expect(r2).toEqual(priceData(50, r2!.timestamp))
+    // Only 1 unique token sent to the client
+    expect(client.getTokenPrices).toHaveBeenCalledWith([{ chainId: 1, address: '0xaaa' }])
+  })
+
+  it('chunks large batches to respect MAX_BATCH_SIZE', async () => {
+    const client = createMockClient(async (tokens) => {
+      const result = new Map<string, TokenPriceData>()
+      for (const t of tokens) {
+        result.set(`${t.chainId}-${t.address}`, priceData(1))
+      }
+      return result
+    })
+
+    const batcher = new RestPriceBatcher(client)
+
+    // Create MAX_BATCH_SIZE + 10 unique tokens
+    const count = MAX_BATCH_SIZE + 10
+    const promises = Array.from({ length: count }, (_, i) =>
+      batcher.fetch({ chainId: 1, address: `0x${i.toString(16).padStart(40, '0')}` }),
+    )
+
+    vi.advanceTimersByTime(BATCH_DELAY_MS)
+
+    const results = await Promise.all(promises)
+
+    expect(results).toHaveLength(count)
+    expect(results.every((r) => r !== undefined)).toBe(true)
+    // Should have been split into 2 REST calls
+    expect(client.getTokenPrices).toHaveBeenCalledTimes(2)
+  })
+
+  it('propagates errors to all pending promises', async () => {
+    const error = new Error('network failure')
+    const client = createMockClient(async () => {
+      throw error
+    })
+
+    const batcher = new RestPriceBatcher(client)
+
+    const p1 = batcher.fetch({ chainId: 1, address: '0xaaa' })
+    const p2 = batcher.fetch({ chainId: 42161, address: '0xbbb' })
+
+    vi.advanceTimersByTime(BATCH_DELAY_MS)
+
+    await expect(p1).rejects.toThrow('network failure')
+    await expect(p2).rejects.toThrow('network failure')
+  })
+
+  it('returns undefined for tokens not in REST response', async () => {
+    const client = createMockClient(async () => {
+      // Return empty map (no prices available)
+      return new Map<string, TokenPriceData>()
+    })
+
+    const batcher = new RestPriceBatcher(client)
+
+    const promise = batcher.fetch({ chainId: 1, address: '0xaaa' })
+
+    vi.advanceTimersByTime(BATCH_DELAY_MS)
+
+    const result = await promise
+
+    expect(result).toBeUndefined()
+  })
+
+  it('processes sequential batches independently', async () => {
+    let callCount = 0
+    const client = createMockClient(async (tokens) => {
+      callCount++
+      const result = new Map<string, TokenPriceData>()
+      for (const t of tokens) {
+        result.set(`${t.chainId}-${t.address}`, priceData(callCount * 100))
+      }
+      return result
+    })
+
+    const batcher = new RestPriceBatcher(client)
+
+    // First batch
+    const p1 = batcher.fetch({ chainId: 1, address: '0xaaa' })
+    vi.advanceTimersByTime(BATCH_DELAY_MS)
+    const r1 = await p1
+    expect(r1?.price).toBe(100)
+
+    // Second batch (new timer window)
+    const p2 = batcher.fetch({ chainId: 1, address: '0xbbb' })
+    vi.advanceTimersByTime(BATCH_DELAY_MS)
+    const r2 = await p2
+    expect(r2?.price).toBe(200)
+
+    expect(client.getTokenPrices).toHaveBeenCalledTimes(2)
+  })
+
+  it('lowercases addresses for deduplication', async () => {
+    const client = createMockClient(async (tokens) => {
+      const result = new Map<string, TokenPriceData>()
+      for (const t of tokens) {
+        result.set(`${t.chainId}-${t.address}`, priceData(42))
+      }
+      return result
+    })
+
+    const batcher = new RestPriceBatcher(client)
+
+    const promise = batcher.fetch({ chainId: 1, address: '0xAbCdEf' })
+
+    vi.advanceTimersByTime(BATCH_DELAY_MS)
+
+    const result = await promise
+
+    expect(result?.price).toBe(42)
+    expect(client.getTokenPrices).toHaveBeenCalledWith([{ chainId: 1, address: '0xabcdef' }])
+  })
+
+  it('batches requests arriving in separate macrotasks within the delay window', async () => {
+    const client = createMockClient(async (tokens) => {
+      const result = new Map<string, TokenPriceData>()
+      for (const t of tokens) {
+        result.set(`${t.chainId}-${t.address}`, priceData(99))
+      }
+      return result
+    })
+
+    const batcher = new RestPriceBatcher(client)
+
+    // First request starts the timer
+    const p1 = batcher.fetch({ chainId: 1, address: '0xaaa' })
+
+    // Advance partway through the delay (simulating a second macrotask arriving)
+    vi.advanceTimersByTime(BATCH_DELAY_MS / 2)
+
+    // Second request arrives before the timer fires
+    const p2 = batcher.fetch({ chainId: 10, address: '0xbbb' })
+
+    // Now advance past the delay to flush
+    vi.advanceTimersByTime(BATCH_DELAY_MS)
+
+    const [r1, r2] = await Promise.all([p1, p2])
+
+    expect(r1?.price).toBe(99)
+    expect(r2?.price).toBe(99)
+    // Both should be in a single batch
+    expect(client.getTokenPrices).toHaveBeenCalledTimes(1)
+    expect(client.getTokenPrices).toHaveBeenCalledWith([
+      { chainId: 1, address: '0xaaa' },
+      { chainId: 10, address: '0xbbb' },
+    ])
+  })
+})

package/src/sources/rest/RestPriceBatcher.ts

@@ -0,0 +1,110 @@
+import { BATCH_DELAY_MS, MAX_BATCH_SIZE } from '@luxexchange/prices/src/sources/rest/constants'
+import type { RestPriceClient } from '@luxexchange/prices/src/sources/rest/types'
+import type { TokenIdentifier, TokenPriceData } from '@luxexchange/prices/src/types'
+import { createPriceKey } from '@luxexchange/prices/src/utils/tokenIdentifier'
+
+interface PendingRequest {
+  token: TokenIdentifier
+  resolve: (value: TokenPriceData | undefined) => void
+  reject: (error: unknown) => void
+}
+
+/**
+ * Timer-based batcher for REST price fetches.
+ *
+ * Individual `fetch(token)` calls are coalesced into a single batch REST
+ * request within a short delay window (BATCH_DELAY_MS ≈ one frame). This
+ * ensures requests from separate macrotasks (e.g. React Query refetchInterval
+ * callbacks) are grouped together. Duplicate tokens share the same result.
+ * Batches exceeding MAX_BATCH_SIZE are chunked into parallel requests.
+ */
+export class RestPriceBatcher {
+  private readonly client: RestPriceClient
+  private pending: PendingRequest[] = []
+  private flushTimer: ReturnType<typeof setTimeout> | null = null
+
+  constructor(client: RestPriceClient) {
+    this.client = client
+  }
+
+  /**
+   * Request a price for a single token. Multiple calls within the same
+   * batching window (BATCH_DELAY_MS) are batched into one REST request.
+   *
+   * @returns The price data, or undefined if the token has no price.
+   */
+  fetch(token: TokenIdentifier): Promise<TokenPriceData | undefined> {
+    return new Promise<TokenPriceData | undefined>((resolve, reject) => {
+      this.pending.push({
+        token: { chainId: token.chainId, address: token.address.toLowerCase() },
+        resolve,
+        reject,
+      })
+
+      if (this.flushTimer === null) {
+        this.flushTimer = setTimeout(() => this.flush(), BATCH_DELAY_MS)
+      }
+    })
+  }
+
+  private async flush(): Promise<void> {
+    const batch = this.pending
+    this.pending = []
+    this.flushTimer = null
+
+    if (batch.length === 0) {
+      return
+    }
+
+    // Group resolvers by price key (deduplication)
+    const resolversByKey = new Map<string, PendingRequest[]>()
+    const uniqueTokens = new Map<string, TokenIdentifier>()
+
+    for (const request of batch) {
+      const key = createPriceKey(request.token.chainId, request.token.address)
+      const existing = resolversByKey.get(key)
+      if (existing) {
+        existing.push(request)
+      } else {
+        resolversByKey.set(key, [request])
+        uniqueTokens.set(key, request.token)
+      }
+    }
+
+    const tokens = Array.from(uniqueTokens.values())
+
+    // Chunk into batches of MAX_BATCH_SIZE
+    const chunks: TokenIdentifier[][] = []
+    for (let i = 0; i < tokens.length; i += MAX_BATCH_SIZE) {
+      chunks.push(tokens.slice(i, i + MAX_BATCH_SIZE))
+    }
+
+    try {
+      // Fetch all chunks in parallel
+      const results = await Promise.all(chunks.map((chunk) => this.client.getTokenPrices(chunk)))
+
+      // Merge all chunk results
+      const merged = new Map<string, TokenPriceData>()
+      for (const chunkResult of results) {
+        for (const [key, value] of chunkResult) {
+          merged.set(key, value)
+        }
+      }
+
+      // Resolve all pending requests
+      for (const [key, requests] of resolversByKey) {
+        const data = merged.get(key)
+        for (const request of requests) {
+          request.resolve(data)
+        }
+      }
+    } catch (error) {
+      // On error, reject all pending promises (React Query retries individually)
+      for (const requests of resolversByKey.values()) {
+        for (const request of requests) {
+          request.reject(error)
+        }
+      }
+    }
+  }
+}

package/src/sources/rest/constants.ts

@@ -0,0 +1,9 @@
+/** How often to poll REST as a fallback for fresh prices */
+export const REST_POLL_INTERVAL_MS = 30_000
+
+/** Maximum tokens per REST request (backend limit) */
+export const MAX_BATCH_SIZE = 100
+
+/** Delay before flushing a batch (~one frame). Allows requests from separate
+ *  macrotasks (e.g. React Query refetchInterval callbacks) to be grouped. */
+export const BATCH_DELAY_MS = 16

package/src/sources/rest/types.ts

@@ -0,0 +1,13 @@
+import type { TokenIdentifier, TokenPriceData } from '@luxexchange/prices/src/types'
+
+/**
+ * Contract for fetching token prices via REST.
+ * Implementations handle the actual transport (ConnectRPC, fetch, etc.).
+ */
+export interface RestPriceClient {
+  /**
+   * Fetches prices for a batch of tokens.
+   * @returns Map keyed by price key ("chainId-address"), missing tokens omitted.
+   */
+  getTokenPrices(tokens: TokenIdentifier[]): Promise<Map<string, TokenPriceData>>
+}

package/src/sources/websocket/messageParser.ts

@@ -1,5 +1,5 @@
-import type { ConnectionEstablishedMessage, RawTokenPriceMessage, TokenPriceMessage } from '@universe/prices/src/types'
-import { createPriceKey } from '@universe/prices/src/utils/tokenIdentifier'
+import type { ConnectionEstablishedMessage, RawTokenPriceMessage, TokenPriceMessage } from '@luxexchange/prices/src/types'
+import { createPriceKey } from '@luxexchange/prices/src/utils/tokenIdentifier'
 
 /**
  * Type guard for RawTokenPriceMessage

package/src/sources/websocket/subscriptionApi.ts

@@ -1,6 +1,6 @@
-import type { FetchClient } from '@universe/api'
-import type { TokenSubscriptionParams } from '@universe/prices/src/types'
-import type { SubscriptionHandler } from '@universe/websocket'
+import type { FetchClient } from '@luxexchange/api'
+import type { TokenSubscriptionParams } from '@luxexchange/prices/src/types'
+import type { SubscriptionHandler } from '@luxexchange/websocket'
 
 const EVENT_SUBSCRIPTION_TYPE_TOKEN_PRICE = 'EVENT_SUBSCRIPTION_TYPE_TOKEN_PRICE'
 
@@ -11,7 +11,7 @@ export interface SubscriptionApiOptions {
 
 /**
  * Creates a subscription handler for token price subscriptions.
- * This implements the SubscriptionHandler interface from @universe/websocket.
+ * This implements the SubscriptionHandler interface from @luxexchange/websocket.
  */
 export function createPriceSubscriptionHandler(
   options: SubscriptionApiOptions,
@@ -20,7 +20,7 @@ export function createPriceSubscriptionHandler(
 
   async function subscribe(connectionId: string, params: TokenSubscriptionParams): Promise<void> {
     try {
-      await client.post('/lux.notificationservice.v1.EventSubscriptionService/Subscribe', {
+      await client.post('/uniswap.notificationservice.v1.EventSubscriptionService/Subscribe', {
         body: JSON.stringify({
           eventSubscriptionType: EVENT_SUBSCRIPTION_TYPE_TOKEN_PRICE,
           connectionId,
@@ -34,7 +34,7 @@ export function createPriceSubscriptionHandler(
 
   async function unsubscribe(connectionId: string, params: TokenSubscriptionParams): Promise<void> {
     try {
-      await client.post('/lux.notificationservice.v1.EventSubscriptionService/Unsubscribe', {
+      await client.post('/uniswap.notificationservice.v1.EventSubscriptionService/Unsubscribe', {
         body: JSON.stringify({
           eventSubscriptionType: EVENT_SUBSCRIPTION_TYPE_TOKEN_PRICE,
           connectionId,
@@ -52,7 +52,7 @@ export function createPriceSubscriptionHandler(
     }
 
     try {
-      await client.post('/lux.notificationservice.v1.EventSubscriptionService/Subscribe', {
+      await client.post('/uniswap.notificationservice.v1.EventSubscriptionService/Subscribe', {
         body: JSON.stringify({
           eventSubscriptionType: EVENT_SUBSCRIPTION_TYPE_TOKEN_PRICE,
           connectionId,
@@ -70,7 +70,7 @@ export function createPriceSubscriptionHandler(
     }
 
     try {
-      await client.post('/lux.notificationservice.v1.EventSubscriptionService/Unsubscribe', {
+      await client.post('/uniswap.notificationservice.v1.EventSubscriptionService/Unsubscribe', {
         body: JSON.stringify({
           eventSubscriptionType: EVENT_SUBSCRIPTION_TYPE_TOKEN_PRICE,
           connectionId,
@@ -84,7 +84,7 @@ export function createPriceSubscriptionHandler(
 
   async function refreshSession(connectionId: string): Promise<void> {
     try {
-      await client.post('/lux.notificationservice.v1.EventSubscriptionService/RefreshSession', {
+      await client.post('/uniswap.notificationservice.v1.EventSubscriptionService/RefreshSession', {
         body: JSON.stringify({
           eventSubscriptionType: EVENT_SUBSCRIPTION_TYPE_TOKEN_PRICE,
           connectionId,

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { Currency } from '@uniswap/sdk-core'
+import type { Currency } from '@luxamm/sdk-core'
 
 /**
  * A token identifier with chain and address.
@@ -28,7 +28,7 @@ export interface TokenPriceData {
 /**
  * Key used to identify a token price in the store.
  * Format: "chainId-address" (e.g., "1-0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")
- * Matches CurrencyId convention from lx/src/utils/currencyId.ts
+ * Matches CurrencyId convention from uniswap/src/utils/currencyId.ts
  */
 export type PriceKey = string
 

package/src/utils/tokenIdentifier.test.ts

@@ -1,5 +1,5 @@
-import { Token } from '@uniswap/sdk-core'
-import type { TokenIdentifier } from '@universe/prices'
+import { Ether, Token } from '@luxamm/sdk-core'
+import type { TokenIdentifier } from '@luxexchange/prices'
 import {
   createPriceKey,
   createPriceKeyFromToken,
@@ -9,7 +9,7 @@ import {
   normalizeToken,
   parsePriceKey,
   toSubscriptionParams,
-} from '@universe/prices'
+} from '@luxexchange/prices'
 import { describe, expect, it } from 'vitest'
 
 const WETH_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
@@ -50,6 +50,15 @@ describe('tokenIdentifier utilities', () => {
       })
     })
 
+    it('normalizes native currency to zero address', () => {
+      const eth = Ether.onChain(1)
+      const result = normalizeToken(eth)
+      expect(result).toEqual({
+        chainId: 1,
+        address: '0x0000000000000000000000000000000000000000',
+      })
+    })
+
     it('normalizes Token instance', () => {
       const token = new Token(1, WETH_ADDRESS, 18, 'WETH', 'Wrapped Ether')
       const result = normalizeToken(token)

package/src/utils/tokenIdentifier.ts

@@ -1,12 +1,12 @@
-import type { Currency, Token } from '@uniswap/sdk-core'
-import type { PriceKey, TokenIdentifier, TokenInput, TokenSubscriptionParams } from '@universe/prices'
+import type { Currency, Token } from '@luxamm/sdk-core'
+import type { PriceKey, TokenIdentifier, TokenInput, TokenSubscriptionParams } from '@luxexchange/prices'
 import { isEVMAddress } from 'utilities/src/addresses/evm/evm'
 
 /** Address that represents native currencies on ETH, Arbitrum, etc. */
-const DEFAULT_NATIVE_ADDRESS_LEGACY = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
+const DEFAULT_NATIVE_ADDRESS = '0x0000000000000000000000000000000000000000'
 
 /**
- * Type guard to check if input is a Currency object (from @uniswap/sdk-core).
+ * Type guard to check if input is a Currency object (from @luxamm/sdk-core).
  * Currency objects have isNative and isToken properties from the SDK.
  */
 export function isCurrency(token: TokenInput): token is Currency {
@@ -50,7 +50,7 @@ export function normalizeToken(token: TokenInput): TokenIdentifier {
   if (currency.isNative) {
     return {
       chainId: currency.chainId,
-      address: DEFAULT_NATIVE_ADDRESS_LEGACY,
+      address: DEFAULT_NATIVE_ADDRESS,
     }
   }
 

package/tsconfig.json

@@ -1,7 +1,17 @@
 {
   "extends": "../../config/tsconfig/app.json",
-  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.json", "src/global.d.ts"],
-  "exclude": ["src/**/*.spec.ts", "src/**/*.spec.tsx", "src/**/*.test.ts", "src/**/*.test.tsx"],
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.json",
+    "src/global.d.ts"
+  ],
+  "exclude": [
+    "src/**/*.spec.ts",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.ts",
+    "src/**/*.test.tsx"
+  ],
   "compilerOptions": {
     "noEmit": false,
     "emitDeclarationOnly": true,
@@ -17,6 +27,9 @@
     },
     {
       "path": "../api"
+    },
+    {
+      "path": "../eslint-config"
     }
   ]
 }

package/tsconfig.lint.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "preserveSymlinks": true
+  },
+  "include": ["**/*.ts", "**/*.tsx", "**/*.json"],
+  "exclude": ["node_modules"]
+}

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    server: {
+      deps: {
+        inline: ['@tanstack/react-query', 'partysocket'],
+      },
+    },
+    coverage: {
+      exclude: [
+        '**/__generated__/**',
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/*.config.*',
+        '**/scripts/**',
+        '**/.eslintrc.*',
+      ],
+    },
+  },
+})