useOutcomeState

The useOutcomeState hook is used for maintain updated state for an outcome.

Outcomes within a condition have a state field that indicates their current state. For instance, OutcomeState.Active signifies the outcome is available for betting, while OutcomeState.Stopped indicates it has temporarily stopped accepting bets. This hook monitors this state and returns an isLocked flag, indicating whether placing a bet on this outcome is currently possible or not.

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 { useOutcomeState } from '@azuro-org/sdk'
import { type MarketOutcome } from '@azuro-org/toolkit'
 
type OutcomeButtonProps = {
  outcome: MarketOutcome
}
 
const OutcomeButton: React.FC<OutcomeButtonProps> = (props) => {
  const { outcome } = props
  const { conditionId, outcomeId, state: initialState, hidden } = outcome
 
  const { state, odds, turnover, isLocked, isHidden } = useOutcomeState({
    conditionId,
    outcomeId,
    initialState,
    isInitiallyHidden: hidden,
    initialOdds: outcome.odds,
  })
 
  if (isHidden) {
    return null
  }
 
  return (
    <button disabled={isLocked}>
      {outcome.selectionName} {odds}
    </button>
  )
}

Props

{
  conditionId: string
  outcomeId: string
  initialState?: OutcomeState
  isInitiallyHidden?: boolean // pass outcome.hidden from MarketOutcome
  initialOdds?: number // pass outcome.odds from MarketOutcome
}

enum OutcomeState {
  Active = 'Active',
  Canceled = 'Canceled',
  Stopped = 'Stopped',
  Won = 'Won',
  Lost = 'Lost'
}

Return Value

{
  state: OutcomeState
  odds: number // live odds (0 until known); updated on every socket update
  turnover: string // empty ('') until a live update arrives — not returned by REST
  isHidden?: boolean // undefined until the feed has reported it
  isLocked: boolean // true when outcome is not Active
  isFetching: boolean // flag indicates initial state fetching
}

What is taken from an update

odds and turnover are taken from every update. They are real in every message. turnover is only ever populated by live updates ('' until the first one arrives — the state endpoint doesn’t return it).

state and isHidden are taken only from updates whose condition is Active. An update for an inactive condition reports every one of its outcomes as Stopped, whatever they had actually settled to — so trusting it would un-settle a won, lost or voided outcome each time its condition is suspended. Such an update leaves state and isHidden alone and schedules a re-read from the state endpoint, which is authoritative for per-outcome state. The re-read is limited to the messages that can carry news: the move into an inactive state, and every report of a settled condition.

How isHidden behaves

isHidden says whether the feed is offering this outcome right now, independently of its condition’s own hidden flag — a condition can be on offer with one of its outcomes withdrawn. It starts from isInitiallyHidden — and from it again whenever the hook is pointed at another outcome — and is latched one way, by design: once the outcome has been reported visible it stays visible, and nothing hides it again, so it doesn’t flicker in and out of the market as its condition is suspended and re-priced. Render the lock from isLocked instead.

Pointing the hook at another outcome

Reusing one component instance across outcomes is safe — you don’t need a key to force a remount. When conditionId or outcomeId changes, the hook re-seeds from the new props: state from initialState, isHidden from isInitiallyHidden, odds from initialOdds. turnover starts empty again, isFetching follows the new props, and the new outcome gets its own state-read attempts. The subscription follows conditionId, so pointing the hook at an outcome of a different condition moves it too.

This is what makes isHidden trustworthy on a reused instance. Visibility is latched, so a reveal the previous outcome had earned would otherwise carry over to the new one permanently, with nothing able to take it back. state is exposed the same way: because state and isHidden are ignored on updates whose condition is not Active (see What is taken from an update), the first message about the new outcome cannot be relied on to correct a carried-over value.