@luxexchange/lx 1.0.0

package/src/features/portfolio/portfolioUpdates/rest/refetchRestQueriesViaOnchainOverrideVariantSaga.ts

@@ -0,0 +1,308 @@
+import { ApolloClient, NormalizedCacheObject } from '@apollo/client'
+import { GetPortfolioResponse } from '@uniswap/client-data-api/dist/data/v1/api_pb'
+import { Balance } from '@uniswap/client-data-api/dist/data/v1/types_pb'
+import { Portfolio } from '@uniswap/client-data-api/dist/data/v1/types_pb.d'
+import { GQLQueries, SharedQueryClient } from '@luxfi/api'
+import { all, call, delay, put } from 'typed-redux-saga'
+import { getNativeAddress } from '@luxexchange/lx/src/constants/addresses'
+import { normalizeCurrencyIdForMapLookup } from '@luxexchange/lx/src/data/cache'
+import { doesGetPortfolioQueryMatchAddress, getPortfolioQueriesToUpdate } from '@luxexchange/lx/src/data/rest/getPortfolio'
+import { chainIdToPlatform } from '@luxexchange/lx/src/features/platforms/utils/chains'
+import { getCurrenciesWithExpectedUpdates } from '@luxexchange/lx/src/features/portfolio/portfolioUpdates/getCurrenciesWithExpectedUpdates'
+import {
+  fetchOnChainBalancesRest,
+  OnChainMapRest,
+} from '@luxexchange/lx/src/features/portfolio/portfolioUpdates/rest/fetchOnChainBalancesRest'
+import { addTokensToBalanceOverride } from '@luxexchange/lx/src/features/portfolio/slice/slice'
+import { TransactionDetails } from '@luxexchange/lx/src/features/transactions/types/transactionDetails'
+import { CurrencyId } from '@luxexchange/lx/src/types/currency'
+import { buildCurrencyId, isNativeCurrencyAddress } from '@luxexchange/lx/src/utils/currencyId'
+import { createLogger } from '@luxfi/utilities/src/logger/logger'
+import { ONE_SECOND_MS } from '@luxfi/utilities/src/time/time'
+
+// This delay is arbitrary but enough time for our endpoints to reflect updated balances
+const REFETCH_DELAY = ONE_SECOND_MS * 3
+const FILE_NAME = 'refetchRestQueriesViaOnchainOverrideVariantSaga.ts'
+
+export function getCurrenciesToUpdate(
+  transaction: TransactionDetails,
+  activeAddress: string | null,
+): Set<CurrencyId> | null {
+  if (transaction.from !== activeAddress) {
+    return null
+  }
+
+  const currenciesWithBalanceToUpdate = getCurrenciesWithExpectedUpdates(transaction)
+  return currenciesWithBalanceToUpdate && currenciesWithBalanceToUpdate.size > 0 ? currenciesWithBalanceToUpdate : null
+}
+
+export function mergeOnChainBalances(
+  portfolioData: GetPortfolioResponse | undefined,
+  onchainBalancesByCurrencyId: OnChainMapRest,
+): GetPortfolioResponse | undefined {
+  if (!portfolioData?.portfolio?.balances || onchainBalancesByCurrencyId.size === 0) {
+    return portfolioData
+  }
+
+  const log = createLogger(FILE_NAME, 'mergeOnChainBalances', '[REST-ITBU]')
+  log.debug('Processing cached balances', {
+    balanceCount: portfolioData.portfolio.balances.length,
+    onchainBalancesCount: onchainBalancesByCurrencyId.size,
+  })
+
+  // Track which currencies we've updated
+  const updatedCurrencyIds = new Set<CurrencyId>()
+
+  // Must return a new object for cache to be updated
+  const updatedData = portfolioData.clone()
+
+  // Track balances to remove
+  const balancesToRemove: Balance[] = []
+
+  // Update balances in the cloned data
+  updatedData.portfolio?.balances.forEach((balance) => {
+    if (!balance.token?.chainId || !balance.token.address) {
+      return
+    }
+
+    const chainId = balance.token.chainId
+    const tokenAddress = balance.token.address
+    const address = isNativeCurrencyAddress(chainId, tokenAddress) ? getNativeAddress(chainId) : tokenAddress
+
+    const currencyId = normalizeCurrencyIdForMapLookup(buildCurrencyId(chainId, address))
+    const onchainBalance = onchainBalancesByCurrencyId.get(currencyId)
+
+    if (balance.amount && onchainBalance?.amount?.amount !== undefined) {
+      const oldQuantity = balance.amount.amount || 0
+      const newQuantity = onchainBalance.amount.amount
+      const rawBalance = onchainBalance.amount.raw || ''
+
+      // Update the balance amount
+      balance.amount.amount = newQuantity
+      balance.amount.raw = rawBalance
+
+      // Update USD value proportionally if we had a previous value
+      if (oldQuantity > 0 && balance.valueUsd) {
+        balance.valueUsd = (balance.valueUsd * newQuantity) / oldQuantity
+      }
+
+      // If balance is now zero, mark it for removal
+      if (newQuantity <= 0) {
+        balancesToRemove.push(balance)
+        log.debug(`Marking balance for removal ${currencyId}`, {
+          oldQuantity,
+          newQuantity,
+        })
+      }
+
+      updatedCurrencyIds.add(currencyId)
+      onchainBalancesByCurrencyId.delete(currencyId)
+
+      log.debug(`Updated balance for ${currencyId}`, {
+        oldQuantity,
+        newQuantity,
+        newValueUsd: balance.valueUsd,
+      })
+    }
+  })
+
+  // Remove any balances that have become zero
+  if (balancesToRemove.length > 0 && updatedData.portfolio) {
+    updatedData.portfolio.balances = updatedData.portfolio.balances.filter(
+      (balance) => !balancesToRemove.includes(balance),
+    )
+    log.debug(`Removed ${balancesToRemove.length} balance(s) from portfolio`)
+  }
+
+  // If there are any tokens left in `onchainBalancesByCurrencyId`, it means the user swapped for a new token so we need to create new balance entries.
+  if (onchainBalancesByCurrencyId.size > 0) {
+    log.debug('New token balance creation', {
+      updatedCurrencies: updatedCurrencyIds.size,
+      remainingCurrencies: onchainBalancesByCurrencyId.size,
+    })
+
+    const newBalances: Balance[] = []
+
+    Array.from(onchainBalancesByCurrencyId).forEach(([currencyId, onchainBalance]) => {
+      const onchainQuantity = onchainBalance.amount?.amount
+
+      if (onchainQuantity === undefined) {
+        log.warn('No `onchainBalance.quantity` found for token', { currencyId })
+        return
+      }
+
+      // Skip zero-balance tokens — these are tokens the user fully swapped out of
+      if (onchainQuantity <= 0) {
+        log.debug(`Skipping new balance for ${currencyId} with zero/negative quantity`, { onchainQuantity })
+        return
+      }
+
+      const newBalance = new Balance(onchainBalance)
+      newBalances.push(newBalance)
+    })
+
+    // Add new balances to the portfolio
+    if (newBalances.length > 0 && updatedData.portfolio) {
+      updatedData.portfolio.balances = [...updatedData.portfolio.balances, ...newBalances]
+
+      log.debug(`Added ${newBalances.length} new balances to portfolio`)
+    }
+  }
+
+  return updatedData
+}
+
+export async function fetchAndMergeOnchainBalances({
+  cachedPortfolio,
+  accountAddress,
+  currencyIds,
+}: {
+  cachedPortfolio: Portfolio
+  accountAddress: string
+  currencyIds: Set<CurrencyId>
+}): Promise<GetPortfolioResponse | undefined> {
+  const log = createLogger(FILE_NAME, 'fetchAndMergeOnchainBalances', '[REST-ITBU]')
+  log.debug(`Fetching onchain balances for ${currencyIds.size} currencies`, {
+    accountAddress,
+    currencyIds: Array.from(currencyIds),
+  })
+
+  try {
+    const onchainBalancesByCurrencyId = await fetchOnChainBalancesRest({
+      cachedPortfolio,
+      accountAddress,
+      currencyIds,
+    })
+
+    log.debug('On-chain balance fetching completed', { fetchedBalances: onchainBalancesByCurrencyId.size })
+
+    if (onchainBalancesByCurrencyId.size === 0) {
+      log.debug('No onchain balances fetched, returning undefined')
+      return undefined
+    }
+
+    // Wrap the portfolio in a GetPortfolioResponse
+    const portfolioResponse = new GetPortfolioResponse({
+      portfolio: cachedPortfolio,
+    })
+
+    // Merge onchain balances into the portfolio data
+    const mergedData = mergeOnChainBalances(portfolioResponse, onchainBalancesByCurrencyId)
+
+    log.debug('Successfully merged onchain balances into portfolio data')
+
+    return mergedData
+  } catch (error) {
+    log.error(error, {
+      accountAddress,
+      currencyIds: Array.from(currencyIds),
+      message: 'Error fetching and merging onchain balances',
+    })
+    return undefined
+  }
+}
+
+export function* refetchRestQueriesViaOnchainOverrideVariant({
+  transaction,
+  activeAddress,
+  apolloClient,
+}: {
+  transaction: TransactionDetails
+  activeAddress: string | null
+  // Only pass `null` for Solana where we don't need to refetch GQL queries
+  apolloClient: ApolloClient<NormalizedCacheObject> | null
+}): Generator {
+  const currenciesWithBalanceToUpdate = getCurrenciesToUpdate(transaction, activeAddress)
+
+  if (!activeAddress || !currenciesWithBalanceToUpdate) {
+    return
+  }
+
+  const log = createLogger(FILE_NAME, 'refetchRestQueriesViaOnchainOverrideVariant', '[REST-ITBU]')
+  log.debug('Currencies to update detected', {
+    currencyIds: Array.from(currenciesWithBalanceToUpdate),
+    count: currenciesWithBalanceToUpdate.size,
+  })
+
+  // Save to Redux so that subsequent queries will apply overrides
+  yield* put(
+    addTokensToBalanceOverride({
+      ownerAddress: activeAddress,
+      currencyIds: Array.from(currenciesWithBalanceToUpdate),
+    }),
+  )
+
+  const platform = chainIdToPlatform(transaction.chainId)
+
+  // Find all active portfolio queries that match this address
+  const portfolioQueriesToUpdate = getPortfolioQueriesToUpdate({ address: activeAddress, platform })
+
+  log.debug(`Found ${portfolioQueriesToUpdate.length} matching portfolio queries`, {
+    portfolioQueriesToUpdate,
+    address: activeAddress,
+    platform,
+  })
+
+  // Update the cache with fresh on-chain balances for each query in parallel
+  yield* all(
+    portfolioQueriesToUpdate.map((query) =>
+      call(updatePortfolioCache, {
+        ownerAddress: activeAddress,
+        currencyIds: currenciesWithBalanceToUpdate,
+        queryKey: query.queryKey,
+      }),
+    ),
+  )
+
+  // Wait before invalidating and refetching queries
+  yield* delay(REFETCH_DELAY)
+
+  // Once NFTs are migrated to REST we won't need to do this
+  if (apolloClient) {
+    yield* call([apolloClient, apolloClient.refetchQueries], { include: [GQLQueries.NftsTab] })
+  } else {
+    log.debug(`Ignoring NFT GQL refetch for ${platform} because apolloClient is null`)
+  }
+
+  // Invalidate all portfolio queries that match this address
+  yield* call([SharedQueryClient, SharedQueryClient.invalidateQueries], {
+    predicate: (query: { queryKey: readonly unknown[] }) =>
+      doesGetPortfolioQueryMatchAddress({ queryKey: query.queryKey, address: activeAddress, platform }),
+  })
+}
+
+function* updatePortfolioCache({
+  ownerAddress,
+  currencyIds,
+  queryKey,
+}: {
+  ownerAddress: string
+  currencyIds: Set<CurrencyId>
+  queryKey: readonly unknown[]
+}) {
+  const log = createLogger(FILE_NAME, 'updatePortfolioCache', '[REST-ITBU]')
+  log.debug(`updatePortfolioCache with ${currencyIds.size} currencyIds`, { currencyIds })
+
+  const cachedPortfolioData = SharedQueryClient.getQueryData<GetPortfolioResponse>(queryKey)
+
+  if (!cachedPortfolioData?.portfolio) {
+    log.warn('No cached portfolio data found')
+    return
+  }
+
+  const mergedData = yield* call(fetchAndMergeOnchainBalances, {
+    cachedPortfolio: cachedPortfolioData.portfolio,
+    accountAddress: ownerAddress,
+    currencyIds,
+  })
+
+  if (mergedData) {
+    log.debug('Updating cached portfolio balances')
+    SharedQueryClient.setQueryData(queryKey, () => mergedData)
+    log.debug('Successfully updated react-query cache with fresh balances')
+  } else {
+    log.debug('No balance updates to apply')
+  }
+
+  log.debug('Cache update completed', { ownerAddress, currencyIds: Array.from(currencyIds) })
+}

package/src/features/portfolio/slice/selectors.ts

@@ -0,0 +1,18 @@
+import { createSelector, Selector } from '@reduxjs/toolkit'
+import { normalizeTokenAddressForCache } from '@luxexchange/lx/src/data/cache'
+import { PortfolioState, TokenBalanceOverride } from '@luxexchange/lx/src/features/portfolio/slice/slice'
+import { LuxState } from '@luxexchange/lx/src/state/luxReducer'
+
+export const selectTokenBalanceOverrides = (state: LuxState): PortfolioState['tokenBalanceOverrides'] =>
+  state.portfolio.tokenBalanceOverrides
+
+export const makeSelectTokenBalanceOverridesForWalletAddress = (): Selector<
+  LuxState,
+  undefined | TokenBalanceOverride,
+  [Address]
+> =>
+  createSelector(
+    selectTokenBalanceOverrides,
+    (_: LuxState, walletAddress: Address) => walletAddress,
+    (tokenBalanceOverrides, walletAddress) => tokenBalanceOverrides[normalizeTokenAddressForCache(walletAddress)],
+  )

package/src/features/portfolio/slice/slice.test.ts

@@ -0,0 +1,183 @@
+import { UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import {
+  addTokensToBalanceOverride,
+  initialPortfolioState,
+  portfolioReducer,
+  removeExpiredBalanceOverrides,
+  removeTokenFromBalanceOverride,
+} from '@luxexchange/lx/src/features/portfolio/slice/slice'
+import { buildCurrencyId } from '@luxexchange/lx/src/utils/currencyId'
+
+const TEST_ADDRESS1 = '0x1234567890123456789012345678901234567890'
+const TEST_ADDRESS2 = '0x0987654321098765432109876543210987654321'
+const TEST_TOKEN_ADDRESS = '0xabcdef0123456789abcdef0123456789abcdef01'
+const TEST_CHAIN_ID = UniverseChainId.Mainnet
+
+describe(portfolioReducer, () => {
+  describe(addTokensToBalanceOverride, () => {
+    it('adds token overrides for a valid address', () => {
+      const currencyId = buildCurrencyId(TEST_CHAIN_ID, TEST_TOKEN_ADDRESS)
+
+      const state = portfolioReducer(
+        initialPortfolioState,
+        addTokensToBalanceOverride({
+          ownerAddress: TEST_ADDRESS1,
+          currencyIds: [currencyId],
+        }),
+      )
+
+      expect(state.tokenBalanceOverrides[TEST_ADDRESS1]).toBeDefined()
+      expect(state.tokenBalanceOverrides[TEST_ADDRESS1]?.[currencyId]).toBeDefined()
+      expect(state.tokenBalanceOverrides[TEST_ADDRESS1]?.[currencyId]?.updatedAt).toBeGreaterThan(0)
+    })
+
+    it('ignores invalid addresses', () => {
+      const currencyId = buildCurrencyId(TEST_CHAIN_ID, TEST_TOKEN_ADDRESS)
+
+      const state = portfolioReducer(
+        initialPortfolioState,
+        addTokensToBalanceOverride({
+          ownerAddress: 'invalid-address',
+          currencyIds: [currencyId],
+        }),
+      )
+
+      expect(state).toEqual(initialPortfolioState)
+    })
+
+    it('updates existing overrides', () => {
+      vi.useFakeTimers()
+
+      const currencyId = buildCurrencyId(TEST_CHAIN_ID, TEST_TOKEN_ADDRESS)
+
+      let state = portfolioReducer(
+        initialPortfolioState,
+        addTokensToBalanceOverride({
+          ownerAddress: TEST_ADDRESS1,
+          currencyIds: [currencyId],
+        }),
+      )
+
+      const firstTimestamp = state.tokenBalanceOverrides[TEST_ADDRESS1]![currencyId]!.updatedAt
+
+      // Wait a small amount to ensure different timestamps
+      vi.advanceTimersByTime(1000)
+
+      state = portfolioReducer(
+        state,
+        addTokensToBalanceOverride({
+          ownerAddress: TEST_ADDRESS1,
+          currencyIds: [currencyId],
+        }),
+      )
+
+      expect(state.tokenBalanceOverrides[TEST_ADDRESS1]![currencyId]!.updatedAt).toBeGreaterThan(firstTimestamp)
+
+      vi.useRealTimers()
+    })
+  })
+
+  describe(removeTokenFromBalanceOverride, () => {
+    it('removes token override for valid address', () => {
+      const currencyId = buildCurrencyId(TEST_CHAIN_ID, TEST_TOKEN_ADDRESS)
+
+      let state = portfolioReducer(
+        initialPortfolioState,
+        addTokensToBalanceOverride({
+          ownerAddress: TEST_ADDRESS1,
+          currencyIds: [currencyId],
+        }),
+      )
+
+      expect(state.tokenBalanceOverrides[TEST_ADDRESS1]).toBeDefined()
+
+      state = portfolioReducer(
+        state,
+        removeTokenFromBalanceOverride({
+          ownerAddress: TEST_ADDRESS1,
+          chainId: TEST_CHAIN_ID,
+          tokenAddress: TEST_TOKEN_ADDRESS,
+        }),
+      )
+
+      expect(state.tokenBalanceOverrides[TEST_ADDRESS1]).toBeUndefined()
+    })
+
+    it('ignores invalid addresses', () => {
+      const initialState = {
+        ...initialPortfolioState,
+        tokenBalanceOverrides: {
+          [TEST_ADDRESS1]: {
+            [buildCurrencyId(TEST_CHAIN_ID, TEST_TOKEN_ADDRESS)]: {
+              updatedAt: Date.now(),
+            },
+          },
+        },
+      }
+
+      const state = portfolioReducer(
+        initialState,
+        removeTokenFromBalanceOverride({
+          ownerAddress: 'invalid-address',
+          chainId: TEST_CHAIN_ID,
+          tokenAddress: TEST_TOKEN_ADDRESS,
+        }),
+      )
+
+      expect(state).toEqual(initialState)
+    })
+  })
+
+  describe(removeExpiredBalanceOverrides, () => {
+    it('removes expired overrides', () => {
+      const now = Date.now()
+      const currencyId = buildCurrencyId(TEST_CHAIN_ID, TEST_TOKEN_ADDRESS)
+
+      const initialState = {
+        ...initialPortfolioState,
+        tokenBalanceOverrides: {
+          [TEST_ADDRESS1]: {
+            [currencyId]: {
+              updatedAt: now - 31 * 60 * 1000, // 31 minutes ago (expired)
+            },
+          },
+          [TEST_ADDRESS2]: {
+            [currencyId]: {
+              updatedAt: now - 29 * 60 * 1000, // 29 minutes ago (not expired)
+            },
+          },
+        },
+      }
+
+      const state = portfolioReducer(initialState, removeExpiredBalanceOverrides())
+
+      expect(state.tokenBalanceOverrides[TEST_ADDRESS1]).toBeUndefined()
+      expect(state.tokenBalanceOverrides[TEST_ADDRESS2]).toBeDefined()
+    })
+
+    it('removes account entry when all overrides are expired', () => {
+      const now = Date.now()
+      const currencyId1 = buildCurrencyId(TEST_CHAIN_ID, TEST_TOKEN_ADDRESS)
+      const currencyId2 = buildCurrencyId(TEST_CHAIN_ID, TEST_ADDRESS2)
+
+      const initialState = {
+        ...initialPortfolioState,
+        tokenBalanceOverrides: {
+          [TEST_ADDRESS1]: {
+            [currencyId1]: {
+              updatedAt: now - 31 * 60 * 1000, // expired
+            },
+            [currencyId2]: {
+              updatedAt: now - 31 * 60 * 1000, // expired
+            },
+          },
+        },
+      }
+
+      const state = portfolioReducer(initialState, removeExpiredBalanceOverrides())
+
+      expect(state.tokenBalanceOverrides[TEST_ADDRESS1]).toBeUndefined()
+      expect(Object.keys(state.tokenBalanceOverrides)).toHaveLength(0)
+    })
+  })
+})

package/src/features/portfolio/slice/slice.ts

@@ -0,0 +1,115 @@
+import { createSlice, type PayloadAction } from '@reduxjs/toolkit'
+import { normalizeCurrencyIdForMapLookup } from '@luxexchange/lx/src/data/cache'
+import { type UniverseChainId } from '@luxexchange/lx/src/features/chains/types'
+import { Platform } from '@luxexchange/lx/src/features/platforms/types/Platform'
+import { type CurrencyId } from '@luxexchange/lx/src/types/currency'
+import { getValidAddress } from '@luxexchange/lx/src/utils/addresses'
+import { buildCurrencyId } from '@luxexchange/lx/src/utils/currencyId'
+import { isEVMAddressWithChecksum } from '@luxfi/utilities/src/addresses/evm/evm'
+import { logger } from '@luxfi/utilities/src/logger/logger'
+
+const OVERRIDE_MAX_AGE = 30 * 60 * 1000 // 30 minutes
+
+export type TokenBalanceOverride = Record<CurrencyId, { updatedAt: number }>
+
+export type PortfolioState = {
+  tokenBalanceOverrides: Record<Address, TokenBalanceOverride>
+}
+
+export const initialPortfolioState: PortfolioState = {
+  tokenBalanceOverrides: {},
+}
+
+const slice = createSlice({
+  name: 'portfolio',
+  initialState: initialPortfolioState,
+  reducers: {
+    addTokensToBalanceOverride: (state, action: PayloadAction<{ ownerAddress: Address; currencyIds: string[] }>) => {
+      const { ownerAddress, currencyIds } = action.payload
+
+      const accountId = getValidAddress({
+        address: ownerAddress,
+        platform: isEVMAddressWithChecksum(ownerAddress) ? Platform.EVM : Platform.SVM,
+      })
+
+      if (!accountId) {
+        logger.error(new Error('Unexpected call to `addTokensToBalanceOverride` with an invalid address'), {
+          tags: { file: 'portfolio/slice/slice.ts', function: 'addTokensToBalanceOverride' },
+          extra: { ownerAddress, currencyIds },
+        })
+        return
+      }
+
+      const accountOverrides = state.tokenBalanceOverrides[accountId] ?? {}
+
+      const now = new Date().getTime()
+      currencyIds.forEach((currencyId) => {
+        accountOverrides[currencyId] = {
+          updatedAt: now,
+        }
+      })
+
+      state.tokenBalanceOverrides[accountId] = accountOverrides
+    },
+    removeTokenFromBalanceOverride: (
+      state,
+      action: PayloadAction<{ ownerAddress: Address; chainId: UniverseChainId; tokenAddress: Address }>,
+    ) => {
+      const { ownerAddress, chainId, tokenAddress } = action.payload
+
+      const accountId = getValidAddress({ address: ownerAddress, chainId })
+
+      if (!accountId) {
+        logger.error(new Error('Unexpected call to `removeTokenFromBalanceOverride` with an invalid address'), {
+          tags: { file: 'portfolio/slice/slice.ts', function: 'removeTokenFromBalanceOverride' },
+          extra: { ownerAddress, chainId, tokenAddress },
+        })
+        return
+      }
+
+      const currencyId = normalizeCurrencyIdForMapLookup(buildCurrencyId(chainId, tokenAddress))
+
+      delete state.tokenBalanceOverrides[accountId]?.[currencyId]
+
+      if (Object.keys(state.tokenBalanceOverrides[accountId] ?? {}).length === 0) {
+        delete state.tokenBalanceOverrides[accountId]
+      }
+    },
+    removeExpiredBalanceOverrides: (state) => {
+      Object.keys(state.tokenBalanceOverrides).forEach((accountId) => {
+        // biome-ignore lint/style/noNonNullAssertion: array access is safe here
+        const accountOverrides = state.tokenBalanceOverrides[accountId]!
+
+        const now = Date.now()
+
+        Object.keys(accountOverrides).forEach((currencyId) => {
+          // biome-ignore lint/style/noNonNullAssertion: array access is safe here
+          if (now - accountOverrides[currencyId]!.updatedAt > OVERRIDE_MAX_AGE) {
+            logger.warn(
+              'portfolio/slice/slice.ts',
+              'removeExpiredBalanceOverrides',
+              `[ITBU] Removing expired token balance override for ${accountId}: ${currencyId}`,
+            )
+
+            delete accountOverrides[currencyId]
+          }
+        })
+
+        // If the account has no overrides left, remove the account entry.
+        if (Object.keys(accountOverrides).length === 0) {
+          delete state.tokenBalanceOverrides[accountId]
+        }
+      })
+    },
+    resetPortfolio: () => initialPortfolioState,
+  },
+})
+
+export const {
+  addTokensToBalanceOverride,
+  removeTokenFromBalanceOverride,
+  removeExpiredBalanceOverrides,
+  resetPortfolio,
+} = slice.actions
+
+export const portfolioReducer = slice.reducer

package/src/features/portfolio/types.ts

@@ -0,0 +1,9 @@
+import { CurrencyId } from '@luxexchange/lx/src/types/currency'
+
+export const HIDDEN_TOKEN_BALANCES_ROW = 'HIDDEN_TOKEN_BALANCES_ROW' as const
+
+export function isHiddenTokenBalancesRow(row: string): row is typeof HIDDEN_TOKEN_BALANCES_ROW {
+  return row === HIDDEN_TOKEN_BALANCES_ROW
+}
+
+export type TokenBalanceListRow = CurrencyId | typeof HIDDEN_TOKEN_BALANCES_ROW

package/src/features/prices/TokenPriceContext.tsx

@@ -0,0 +1,62 @@
+import type { Currency, CurrencyAmount, Price } from '@uniswap/sdk-core'
+import { FeatureFlags, useFeatureFlag } from '@luxexchange/gating'
+import { createContext, type ReactNode, useContext } from 'react'
+import type { PollingInterval } from '@luxexchange/lx/src/constants/misc'
+import { useTokenSpotPrice as useTokenSpotPriceLegacy } from '@luxexchange/lx/src/features/dataApi/tokenDetails/useTokenDetailsData'
+import { useTokenSpotPriceCentralized } from '@luxexchange/lx/src/features/dataApi/tokenDetails/useTokenSpotPriceCentralized'
+import {
+  useUSDCPrice as useUSDCPriceLegacy,
+  useUSDCValue as useUSDCValueLegacy,
+  useUSDCValueWithStatus as useUSDCValueWithStatusLegacy,
+} from '@luxexchange/lx/src/features/transactions/hooks/useUSDCPrice'
+import {
+  useUSDCPriceCentralized,
+  useUSDCValueCentralized,
+  useUSDCValueWithStatusCentralized,
+} from '@luxexchange/lx/src/features/transactions/hooks/useUSDCPriceCentralized'
+import type { CurrencyId } from '@luxexchange/lx/src/types/currency'
+
+export interface TokenPriceHooks {
+  useUSDCPrice: (
+    currency?: Currency,
+    pollInterval?: PollingInterval,
+  ) => { price: Price<Currency, Currency> | undefined; isLoading: boolean }
+
+  useUSDCValue: (
+    currencyAmount: CurrencyAmount<Currency> | undefined | null,
+    pollInterval?: PollingInterval,
+  ) => CurrencyAmount<Currency> | null
+
+  useUSDCValueWithStatus: (currencyAmount: CurrencyAmount<Currency> | undefined | null) => {
+    value: CurrencyAmount<Currency> | null
+    isLoading: boolean
+  }
+
+  useTokenSpotPrice: (currencyId: CurrencyId) => number | undefined
+}
+
+const LEGACY_HOOKS: TokenPriceHooks = {
+  useUSDCPrice: useUSDCPriceLegacy,
+  useUSDCValue: useUSDCValueLegacy,
+  useUSDCValueWithStatus: useUSDCValueWithStatusLegacy,
+  useTokenSpotPrice: useTokenSpotPriceLegacy,
+}
+
+const CENTRALIZED_HOOKS: TokenPriceHooks = {
+  useUSDCPrice: useUSDCPriceCentralized,
+  useUSDCValue: useUSDCValueCentralized,
+  useUSDCValueWithStatus: useUSDCValueWithStatusCentralized,
+  useTokenSpotPrice: useTokenSpotPriceCentralized,
+}
+
+const TokenPriceContext = createContext<TokenPriceHooks>(LEGACY_HOOKS)
+
+export function TokenPriceProvider({ children }: { children: ReactNode }): JSX.Element {
+  const useCentralized = useFeatureFlag(FeatureFlags.CentralizedPrices)
+  const hooks = useCentralized ? CENTRALIZED_HOOKS : LEGACY_HOOKS
+  return <TokenPriceContext.Provider value={hooks}>{children}</TokenPriceContext.Provider>
+}
+
+export function useTokenPriceHooks(): TokenPriceHooks {
+  return useContext(TokenPriceContext)
+}