@luxexchange/lx 1.0.0

package/src/i18n/shared.ts

@@ -0,0 +1 @@
+export class MissingI18nInterpolationError extends Error {}

package/src/i18n/utils.test.ts

@@ -0,0 +1,112 @@
+import { Language, Locale } from '@luxexchange/lx/src/features/language/constants'
+import * as navigatorLocale from '@luxexchange/lx/src/features/language/navigatorLocale'
+import * as deviceLocales from '@luxfi/utilities/src/device/locales'
+import { mockLogger } from '@luxfi/utilities/src/logger/mocks'
+import type { Mock } from 'vitest'
+
+// Mock modules
+vi.mock('@luxfi/utilities/src/device/locales', () => ({
+  getDeviceLocales: vi.fn(),
+}))
+
+vi.mock('lx/src/features/language/navigatorLocale', () => ({
+  getLocale: vi.fn(),
+}))
+
+// Import the functions under test after mocks are set up
+// We need to use dynamic import to ensure mocks are applied
+const { getWalletDeviceLanguage, getWalletDeviceLocale } = await import('lx/src/i18n/utils')
+
+describe('i18n utils', () => {
+  const mockGetDeviceLocales = deviceLocales.getDeviceLocales as Mock
+  const mockGetLocale = navigatorLocale.getLocale as Mock
+  const mockLoggerError = mockLogger.error
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('getWalletDeviceLanguage', () => {
+    it('should return first supported language from device locales', () => {
+      mockGetDeviceLocales.mockReturnValue([
+        { languageCode: 'fr', languageTag: 'fr-FR' },
+        { languageCode: 'en', languageTag: 'en-US' },
+      ])
+
+      const result = getWalletDeviceLanguage()
+      expect(result).toBe(Language.French)
+    })
+
+    it('should handle normalized language tags', () => {
+      mockGetDeviceLocales.mockReturnValue([{ languageCode: 'zh', languageTag: 'zh-Hans-cn' }])
+
+      const result = getWalletDeviceLanguage()
+      expect(result).toBe(Language.ChineseSimplified)
+    })
+
+    it('should fall back to languageCode if no match for languageTag', () => {
+      mockGetDeviceLocales.mockReturnValue([{ languageCode: 'ja', languageTag: 'custom-tag' }])
+
+      const result = getWalletDeviceLanguage()
+      expect(result).toBe(Language.Japanese)
+    })
+
+    it('should skip unsupported languages and use the first supported one', () => {
+      mockGetDeviceLocales.mockReturnValue([
+        { languageCode: 'xx', languageTag: 'xx-XX' }, // Unsupported
+        { languageCode: 'es', languageTag: 'es-ES' }, // Supported
+      ])
+
+      const result = getWalletDeviceLanguage()
+      expect(result).toBe(Language.SpanishSpain)
+    })
+
+    it('should default to English if no supported language is found', () => {
+      mockGetDeviceLocales.mockReturnValue([
+        { languageCode: 'xx', languageTag: 'xx-XX' }, // Unsupported
+      ])
+
+      const result = getWalletDeviceLanguage()
+      expect(result).toBe(Language.English)
+    })
+
+    it('should default to English if getDeviceLocales throws an error', () => {
+      mockGetDeviceLocales.mockImplementation(() => {
+        throw new Error('Test error')
+      })
+
+      const result = getWalletDeviceLanguage()
+      expect(result).toBe(Language.English)
+      expect(mockLoggerError).toHaveBeenCalled()
+    })
+
+    it('should handle empty device locales array', () => {
+      mockGetDeviceLocales.mockReturnValue([])
+
+      const result = getWalletDeviceLanguage()
+      expect(result).toBe(Language.English)
+    })
+  })
+
+  describe('getWalletDeviceLocale', () => {
+    it('should get the language and return the corresponding locale', () => {
+      mockGetDeviceLocales.mockReturnValue([{ languageCode: 'fr', languageTag: 'fr-FR' }])
+      mockGetLocale.mockReturnValue(Locale.FrenchFrance)
+
+      const result = getWalletDeviceLocale()
+      expect(result).toBe(Locale.FrenchFrance)
+      expect(mockGetLocale).toHaveBeenCalledWith(Language.French)
+    })
+
+    it('should default to English locale if getDeviceLocales fails', () => {
+      mockGetDeviceLocales.mockImplementation(() => {
+        throw new Error('Test error')
+      })
+      mockGetLocale.mockReturnValue(Locale.EnglishUnitedStates)
+
+      const result = getWalletDeviceLocale()
+      expect(result).toBe(Locale.EnglishUnitedStates)
+      expect(mockGetLocale).toHaveBeenCalledWith(Language.English)
+    })
+  })
+})

package/src/i18n/utils.ts

@@ -0,0 +1,70 @@
+import {
+  Language,
+  Locale,
+  mapDeviceLanguageToLanguage,
+  mapLocaleToLanguage,
+  PLATFORM_SUPPORTED_LANGUAGES,
+} from '@luxexchange/lx/src/features/language/constants'
+import { getLocale } from '@luxexchange/lx/src/features/language/navigatorLocale'
+import { getDeviceLocales } from '@luxfi/utilities/src/device/locales'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+// Mapping for locales that don't match their file names
+const LOCALE_TO_FILE_NAME: Record<string, string> = {
+  'zh-Hans': 'zh-CN',
+  'zh-Hant': 'zh-TW',
+}
+
+/**
+ * Returns the translation file name or statsig translation key for a given locale.
+ *
+ * @param locale - The locale to get the translation file name for.
+ * @returns The translation file name.
+ */
+export function getLocaleTranslationKey(locale: string): string {
+  if (locale === 'es' || locale.startsWith('es-')) {
+    // All Spanish variants map to es-ES.json
+    return 'es-ES'
+  }
+  return LOCALE_TO_FILE_NAME[locale] || locale
+}
+
+/**
+ * Determines the device locale for Mobile and Chrome Extension.
+ */
+export function getWalletDeviceLocale(): Locale {
+  const language = getWalletDeviceLanguage()
+  return getLocale(language)
+}
+
+/**
+ * Determines the device language for Mobile and Chrome Extension.
+ */
+export function getWalletDeviceLanguage(): Language {
+  try {
+    // Gets the user device locales in order of their preference
+    const deviceLocales = getDeviceLocales()
+
+    for (const locale of deviceLocales) {
+      // Normalizes language tags like 'zh-Hans-ch' to 'zh-Hans' that could happen on Android
+      const normalizedLanguageTag = locale.languageTag.split('-').slice(0, 2).join('-') as Locale
+      const mappedLanguageFromTag = Object.values(Locale).includes(normalizedLanguageTag)
+        ? mapLocaleToLanguage[normalizedLanguageTag]
+        : mapDeviceLanguageToLanguage[normalizedLanguageTag]
+      const mappedLanguageFromCode = locale.languageCode as Maybe<Language>
+      // Prefer languageTag as it's more specific, falls back to languageCode
+      const mappedLanguage = mappedLanguageFromTag || mappedLanguageFromCode
+
+      if (mappedLanguage && PLATFORM_SUPPORTED_LANGUAGES.includes(mappedLanguage)) {
+        return mappedLanguage
+      }
+    }
+  } catch (error) {
+    logger.error(error, {
+      tags: { file: 'i18n/utils.ts', function: 'getWalletDeviceLanguage' },
+    })
+  }
+
+  // Default to English if no supported language is found
+  return Language.English
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../../../index.d.ts" />
+
+// leave this blank
+// don't re-export files from this workspace. it'll break next.js tree shaking
+// https://github.com/vercel/next.js/issues/12557
+export {}

package/src/react-native-dotenv.d.ts

@@ -0,0 +1,42 @@
+// Adds typings for env vars
+// Keep in sync with .env files
+declare module 'react-native-dotenv' {
+  export const ALCHEMY_API_KEY: string
+  export const APPSFLYER_API_KEY: string
+  export const APPSFLYER_APP_ID: string
+  export const DATADOG_CLIENT_TOKEN: string
+  export const DATADOG_PROJECT_ID: string
+  export const IS_E2E_TEST: string
+  export const LUX_API_KEY: string
+  export const INFURA_KEY: string
+  export const SIMPLEHASH_API_KEY: string
+  export const SIMPLEHASH_API_URL: string
+  export const STATSIG_PROXY_URL: string
+  export const ONESIGNAL_APP_ID: string
+  export const WALLETCONNECT_PROJECT_ID: string
+  export const WALLETCONNECT_PROJECT_ID_BETA: string
+  export const WALLETCONNECT_PROJECT_ID_DEV: string
+  export const QUICKNODE_ENDPOINT_NAME: string
+  export const QUICKNODE_ENDPOINT_TOKEN: string
+  export const TRADING_API_KEY: string
+  export const FIREBASE_APP_CHECK_DEBUG_TOKEN: string
+  export const AMPLITUDE_PROXY_URL_OVERRIDE: string
+  export const API_BASE_URL_OVERRIDE: string
+  export const API_BASE_URL_V2_OVERRIDE: string
+  export const FOR_API_URL_OVERRIDE: string
+  export const GRAPHQL_URL_OVERRIDE: string
+  export const SCANTASTIC_API_URL_OVERRIDE: string
+  export const STATSIG_API_KEY: string
+  export const STATSIG_PROXY_URL_OVERRIDE: string
+  export const TRADING_API_URL_OVERRIDE: string
+  export const UNITAGS_API_URL_OVERRIDE: string
+  export const LUX_NOTIF_API_BASE_URL_OVERRIDE: string
+  export const ENTRY_GATEWAY_API_URL_OVERRIDE: string
+  export const INCLUDE_PROTOTYPE_FEATURES: string
+  export const ENABLE_SESSION_SERVICE: string
+  export const ENABLE_SESSION_UPGRADE_AUTO: string
+  export const ENABLE_ENTRY_GATEWAY_PROXY: string
+  export const LIQUIDITY_SERVICE_URL_OVERRIDE: string
+  export const GH_TOKEN_RN_CLI: string
+  export const JUPITER_PROXY_URL: string
+}

package/src/state/README.md

@@ -0,0 +1,3 @@
+# Uniswap State
+
+TODO consolidate state README's

package/src/state/createAppStateResetter.test.ts

@@ -0,0 +1,118 @@
+import { configureStore } from '@reduxjs/toolkit'
+import { addFavoriteToken } from '@luxexchange/lx/src/features/favorites/slice'
+import { pushNotification } from '@luxexchange/lx/src/features/notifications/slice/slice'
+import { AppNotificationType } from '@luxexchange/lx/src/features/notifications/slice/types'
+import { createAppStateResetter } from '@luxexchange/lx/src/state/createAppStateResetter'
+import { type LuxState, luxReducer } from '@luxexchange/lx/src/state/luxReducer'
+import { sleep } from '@luxfi/utilities/src/time/timing'
+import type { Mock } from 'vitest'
+
+describe('createAppStateResetter', () => {
+  let store: ReturnType<typeof configureStore<LuxState>>
+  let resetter: ReturnType<typeof createAppStateResetter>
+  let onResetAccountHistory: Mock
+  let onResetUserSettings: Mock
+  let onResetQueryCaches: Mock
+
+  beforeEach(() => {
+    store = configureStore({
+      reducer: luxReducer,
+    })
+    onResetAccountHistory = vi.fn()
+    onResetUserSettings = vi.fn()
+    onResetQueryCaches = vi.fn()
+    resetter = createAppStateResetter({
+      dispatch: store.dispatch,
+      onResetAccountHistory,
+      onResetUserSettings,
+      onResetQueryCaches,
+    })
+  })
+
+  describe('resetAccountHistory', () => {
+    it('dispatches account history reset actions', async () => {
+      // Modify state first
+      store.dispatch(
+        pushNotification({
+          type: AppNotificationType.Success,
+          title: 'Test notification',
+        }),
+      )
+
+      // Verify state was modified
+      expect(store.getState().notifications.notificationQueue.length).toBe(1)
+
+      await resetter.resetAccountHistory()
+
+      // Verify state was reset
+      const state = store.getState()
+      expect(state.notifications.notificationQueue).toEqual([]) // clearNotificationQueue effect
+    })
+
+    it('calls onResetAccountHistory callback', async () => {
+      await resetter.resetAccountHistory()
+
+      expect(onResetAccountHistory).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('resetUserSettings', () => {
+    it('dispatches user settings reset actions', async () => {
+      // Modify lux-specific state
+      const initialTokenCount = store.getState().favorites.tokens.length
+      store.dispatch(addFavoriteToken({ currencyId: 'test-currency-id' }))
+
+      // Verify state was modified
+      expect(store.getState().favorites.tokens.length).toBe(initialTokenCount + 1)
+
+      await resetter.resetUserSettings()
+
+      // Verify lux state was reset
+      const state = store.getState()
+      expect(state.favorites.tokens.length).toBe(initialTokenCount) // resetFavorites restores defaults
+    })
+
+    it('calls onResetUserSettings callback', async () => {
+      await resetter.resetUserSettings()
+
+      expect(onResetUserSettings).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('resetQueryCaches', () => {
+    it('calls onResetQueryCaches callback', async () => {
+      await resetter.resetQueryCaches()
+
+      expect(onResetQueryCaches).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('resetAll', () => {
+    it('calls all three reset methods', async () => {
+      await resetter.resetAll()
+
+      expect(onResetAccountHistory).toHaveBeenCalledTimes(1)
+      expect(onResetUserSettings).toHaveBeenCalledTimes(1)
+      expect(onResetQueryCaches).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('async callback support', () => {
+    it('awaits async callbacks', async () => {
+      const asyncCallback = vi.fn(async () => {
+        await sleep(10)
+      })
+
+      const asyncResetter = createAppStateResetter({
+        dispatch: store.dispatch,
+        onResetAccountHistory: asyncCallback,
+        onResetUserSettings,
+        onResetQueryCaches,
+      })
+
+      await asyncResetter.resetAccountHistory()
+
+      expect(asyncCallback).toHaveBeenCalledTimes(1)
+    })
+  })
+})

package/src/state/createAppStateResetter.ts

@@ -0,0 +1,95 @@
+import { type Dispatch } from '@reduxjs/toolkit'
+import { resetAppearanceSettings } from '@luxexchange/lx/src/features/appearance/slice'
+import { resetLuxBehaviorHistory } from '@luxexchange/lx/src/features/behaviorHistory/slice'
+import { resetFavorites } from '@luxexchange/lx/src/features/favorites/slice'
+import { clearNotificationQueue, resetNotifications } from '@luxexchange/lx/src/features/notifications/slice/slice'
+import { resetPortfolio } from '@luxexchange/lx/src/features/portfolio/slice/slice'
+import { clearSearchHistory } from '@luxexchange/lx/src/features/search/searchHistorySlice'
+import { resetUserSettings as resetLuxUserSettings } from '@luxexchange/lx/src/features/settings/slice'
+import { resetDelegation } from '@luxexchange/lx/src/features/smartWallet/delegation/slice'
+import { resetTiming } from '@luxexchange/lx/src/features/timing/slice'
+import { resetTokens } from '@luxexchange/lx/src/features/tokens/warnings/slice/slice'
+import { resetTransactions } from '@luxexchange/lx/src/features/transactions/slice'
+import { resetSwapSettings } from '@luxexchange/lx/src/features/transactions/swap/state/slice'
+import { resetVisibility } from '@luxexchange/lx/src/features/visibility/slice'
+import { createLogger } from '@luxfi/utilities/src/logger/logger'
+
+export interface AppStateResetter {
+  resetAccountHistory(): Promise<void>
+  resetUserSettings(): Promise<void>
+  resetQueryCaches(): Promise<void>
+  resetAll(): Promise<void>
+}
+
+export interface AppStateResetterContext {
+  dispatch: Dispatch
+  onResetAccountHistory: () => void | Promise<void>
+  onResetUserSettings: () => void | Promise<void>
+  onResetQueryCaches: () => void | Promise<void>
+}
+
+/**
+ * AppStateResetter is used to clear non-essential app data.
+ * This is intended to partially reset an app to a clean state,
+ * e.g. to help debug an issue without requiring a full reinstall.
+ *
+ * It should never be used to delete keys.
+ *
+ * The resetter will clear data from redux slices shared by all apps.
+ * Apps must trigger resets of any app-specific data via the callback parameters.
+ */
+export function createAppStateResetter({
+  dispatch,
+  onResetAccountHistory,
+  onResetUserSettings,
+  onResetQueryCaches,
+}: AppStateResetterContext): AppStateResetter {
+  const logger = createLogger('createAppStateResetter.ts', 'createAppStateResetter')
+
+  const resetAccountHistory = async (): Promise<void> => {
+    logger.info('Resetting app data: account history')
+
+    dispatch(clearNotificationQueue())
+    dispatch(resetPortfolio())
+    dispatch(clearSearchHistory())
+    dispatch(resetTiming())
+    dispatch(resetTransactions())
+    dispatch(resetDelegation())
+
+    await onResetAccountHistory()
+  }
+
+  const resetUserSettings = async (): Promise<void> => {
+    logger.info('Resetting app data: user settings')
+
+    dispatch(resetAppearanceSettings())
+    dispatch(resetSwapSettings())
+    dispatch(resetFavorites())
+    dispatch(resetNotifications())
+    dispatch(resetTokens())
+    dispatch(resetLuxBehaviorHistory())
+    dispatch(resetLuxUserSettings())
+    dispatch(resetVisibility())
+
+    await onResetUserSettings()
+  }
+
+  const resetQueryCaches = async (): Promise<void> => {
+    logger.info('Resetting app data: query caches')
+
+    await onResetQueryCaches()
+  }
+
+  const resetAll = async (): Promise<void> => {
+    await resetAccountHistory()
+    await resetUserSettings()
+    await resetQueryCaches()
+  }
+
+  return {
+    resetAccountHistory,
+    resetUserSettings,
+    resetQueryCaches,
+    resetAll,
+  }
+}

package/src/state/createSafeMigration.test.ts

@@ -0,0 +1,119 @@
+import { createSafeMigration, createSafeMigrationFactory } from '@luxexchange/lx/src/state/createSafeMigration'
+import { vi } from 'vitest'
+
+type TestState = {
+  data?: {
+    items: string[]
+  }
+}
+
+describe('createSafeMigration', () => {
+  beforeEach(() => {
+    vi.spyOn(console, 'error').mockImplementation(() => undefined)
+  })
+
+  it('applies migration successfully', () => {
+    const migration = createSafeMigration<TestState>({
+      filename: 'testFile',
+      name: 'testMigration',
+      migrate: (state) => ({
+        ...state,
+        data: { items: [...(state.data?.items ?? []), 'new'] },
+      }),
+      onError: (state) => state,
+    })
+
+    const result = migration({
+      data: { items: ['existing'] },
+    })
+
+    expect(result).toEqual({
+      data: { items: ['existing', 'new'] },
+    })
+  })
+
+  it('uses onError handler when migration throws', () => {
+    const migration = createSafeMigration<TestState>({
+      filename: 'testFile',
+      name: 'testMigration',
+      migrate: () => {
+        throw new Error('Migration failed')
+      },
+      onError: (state) => ({ ...state, data: { items: [] } }),
+    })
+
+    const result = migration({
+      data: { items: ['existing'] },
+    })
+
+    expect(result).toEqual({
+      data: { items: [] },
+    })
+  })
+
+  it('calls onError with the original state', () => {
+    const errorHandler = vi.fn((state: TestState) => ({ ...state, data: { items: [] } }))
+
+    const migration = createSafeMigration<TestState>({
+      filename: 'testFile',
+      name: 'testMigration',
+      migrate: () => {
+        throw new Error('Test error')
+      },
+      onError: errorHandler,
+    })
+
+    migration({
+      data: { items: ['existing'] },
+    })
+
+    expect(errorHandler).toHaveBeenCalledWith(expect.objectContaining({ data: { items: ['existing'] } }))
+  })
+})
+
+describe('createSafeMigrationFactory', () => {
+  beforeEach(() => {
+    vi.spyOn(console, 'error').mockImplementation(() => undefined)
+  })
+
+  it('creates migrations with pre-filled filename', () => {
+    const createMigration = createSafeMigrationFactory('testFile')
+
+    const migration = createMigration<TestState>({
+      name: 'testMigration',
+      migrate: (state) => ({
+        ...state,
+        data: { items: [...(state.data?.items ?? []), 'new'] },
+      }),
+      onError: (state) => state,
+    })
+
+    const result = migration({
+      data: { items: ['existing'] },
+    })
+
+    expect(result).toEqual({
+      data: { items: ['existing', 'new'] },
+    })
+  })
+
+  it('handles errors with pre-filled filename', () => {
+    const createMigration = createSafeMigrationFactory('testFile')
+
+    const migration = createMigration<TestState>({
+      name: 'testMigration',
+      migrate: () => {
+        throw new Error('Migration failed')
+      },
+      onError: (state) => ({ ...state, data: { items: [] } }),
+    })
+
+    const result = migration({
+      data: { items: ['existing'] },
+    })
+
+    expect(result).toEqual({
+      data: { items: [] },
+    })
+  })
+})

package/src/state/createSafeMigration.ts

@@ -0,0 +1,84 @@
+import { type PersistState } from 'redux-persist'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+interface SafeMigrationOptions<T> {
+  /** Filename used for error logging */
+  filename: string
+  /** Function name used for error logging */
+  name: string
+  /** The migration function that transforms the state */
+  migrate: (state: T) => T
+  /** Error handler that returns fallback state */
+  onError: (state: T) => T
+}
+
+type SafeMigrationOptionsWithoutFilename<T> = Omit<SafeMigrationOptions<T>, 'filename'>
+
+/**
+ * Wraps a Redux persist migration function with error handling and logging.
+ * @note All new migrations should use this when possible
+ *
+ * @example
+ * // Migration that preserves state on error
+ * export const migration17 = createSafeMigration({
+ *   filename: 'migrations',
+ *   name: 'migration17',
+ *   migrate: (state) => ({ ...state, newField: 'value' }),
+ *   onError: (state) => state,
+ * })
+ *
+ * @example
+ * // Migration with custom error fallback
+ * export const migrateSearchHistory = createSafeMigration({
+ *   filename: 'luxMigrations',
+ *   name: 'migrateSearchHistory',
+ *   migrate: (state) => {
+ *     const processed = processSearchHistory(state.searchHistory)
+ *     return { ...state, searchHistory: processed }
+ *   },
+ *   onError: (state) => ({ ...state, searchHistory: { results: [] } }),
+ * })
+ */
+export function createSafeMigration<T>({ filename, name, migrate, onError }: SafeMigrationOptions<T>): (state: T) => T {
+  return (state: T): T => {
+    try {
+      return migrate(state)
+    } catch (error) {
+      logger.error(new Error(`Migration failed: ${name}`, { cause: error }), {
+        tags: { file: filename, function: name },
+      })
+      return onError(state)
+    }
+  }
+}
+
+/**
+ * Returns a createSafeMigration function with a pre-set filename.
+ *
+ * @example
+ * // Create a factory for a specific file
+ * const createMigration = createSafeMigrationFactory('luxMigrations')
+ *
+ * export const migrateSearchHistory = createMigration({
+ *   name: 'migrateSearchHistory',
+ *   migrate: (state) => ({ ...state, searchHistory: processed }),
+ *   onError: (state) => ({ ...state, searchHistory: { results: [] } }),
+ * })
+ */
+export function createSafeMigrationFactory(
+  filename: string,
+): <T>(options: SafeMigrationOptionsWithoutFilename<T>) => (state: T) => T {
+  return <T>(options: SafeMigrationOptionsWithoutFilename<T>) => createSafeMigration({ filename, ...options })
+}
+
+/**
+ * Creates a PersistState object from the migration state, ensuring required fields.
+ * Useful in migration `onError` handlers where optional chaining can make `rehydrated` undefined.
+ */
+export function createPersistState(state: { _persist?: PersistState } | undefined, version: number): PersistState {
+  return {
+    ...state?._persist,
+    version,
+    rehydrated: state?._persist?.rehydrated ?? false,
+  }
+}

package/src/state/index.ts

@@ -0,0 +1,5 @@
+import { luxReducer } from '@luxexchange/lx/src/state/luxReducer'
+
+// Utility type to be used inside the lux shared package
+// Apps and packages should re-define those with a more specific `AppState`
+export type LuxRootState = ReturnType<typeof luxReducer>