useConditionsState

The useConditionsState hook is used for maintain updated states for a conditions.

Conditions have a state field that indicates their current state. ConditionState.Active signifies the condition is available for betting, while ConditionState.Stopped indicates it is not accepting bets right now. This hook keeps those states live over the socket and returns them keyed by condition ID — compare against ConditionState.Active to know whether a bet can be placed. For a single condition, useConditionState returns a ready-made isLocked flag.

Usage

import {
  ChainProvider,
  FeedSocketProvider,
  ConditionUpdatesProvider,
} from '@azuro-org/sdk'
import { polygonAmoy } from 'viem/chains'
 
function Providers(props: { children: React.ReactNode }) {
  const { children } = props
 
  return (
    <ChainProvider initialChainId={polygonAmoy.id}>
      <FeedSocketProvider>
        <ConditionUpdatesProvider>
          {children}
        </ConditionUpdatesProvider>
      </FeedSocketProvider>
    </ChainProvider>
  )
}

import { useConditionsState } from '@azuro-org/sdk'
 
// conditions: ConditionDetailedData[] from useConditions
const { data: states, conditionsMap } = useConditionsState({ conditions })
 
// drop the conditions the feed isn't offering
const visibleConditions = conditions.filter(({ conditionId }) => !conditionsMap[conditionId]?.hidden)

import { useConditionsState } from '@azuro-org/sdk'
import { ConditionState } from '@azuro-org/toolkit'
import { useMemo } from 'react'
 
const items = [{...}]
 
const { data: states, isFetching: isStatesFetching } = useConditionsState({
  conditionIds: items.map(({ conditionId }) => conditionId),
})
 
const isConditionsInActiveState = useMemo(() => {
  return Object.values(states).every(state => state === ConditionState.Active)
}, [ states ])

Props

Two signatures are supported:

Option A — pass full condition objects (preferred for game markets):

{
  conditions: Pick<ConditionDetailedData, 'conditionId' | 'state' | 'hidden'>[]
}

Option B — pass IDs only (betslip / ID-only scenarios):

{
  conditionIds: string[]
  initialStates?: Record<string, ConditionState> // key is conditionId
}

enum ConditionState {
  Active = 'Active',
  Stopped = 'Stopped',
}

Return Value

{
  data: Record<string, ConditionState> // key is conditionId
  conditionsMap: Record<string, {      // key is conditionId
    state: ConditionState
    hidden?: boolean // undefined until the feed has reported it
  }>
  isFetching: boolean // flag indicates initial states fetching
}

state is taken from every update, so a condition locks and unlocks in real time.

How hidden behaves

hidden says whether the feed is offering this condition right now — as opposed to state, which says whether it is taking bets. It starts from what the fetch reported and then follows two rules.

It is revealed by an update reporting hidden: false — not by an update arriving. The feed sends the condition’s own hidden flag on every message and that flag is what the hook reads. An update arriving proves nothing: a market the provider has parked keeps streaming odds for the rest of its life, so treating any message as a sign of life puts dead markets back in the grid.

It is latched one way, by design. Once a condition has been reported visible it stays visible, and nothing hides it again. A market that stops therefore stays in the list, locked, rather than vanishing and returning as the provider suspends and re-prices it — a grid that reflows while a bettor is reading it, moving the market under their cursor, is worse than one that keeps a market slightly longer than it had to. Render the lock from state instead.

import { type ConditionOutcomeData, type ConditionUpdatedData } from '@azuro-org/sdk'
 
type ConditionUpdatedData = {
  conditionId: string
  state: ConditionState
  /** whether the feed is offering this condition right now */
  hidden: boolean
  gameId: string
  isLiveEnabled: boolean
  isPrematchEnabled: boolean
  isCashoutEnabled: boolean
  /** per-outcome payload: outcomeId (a number here, a string in REST), title, currentOdds,
   * turnover, potentialLoss, state, hidden */
  outcomes: ConditionOutcomeData[]
}