All money fields follow one convention: raw USDC with 6 decimals. In-memory values are bigint; values inside relayer JSON responses are decimal strings (convert with BigInt(...)). Odds and probabilities are basis points (10000 = 1.00x / 100%).

​
TakerConfig

type TakerConfig = {
  relayerUrl: string;        // parlays.live relayer base URL
  escrow: Address;           // ParlayEscrow address on the host chain
  collateralToken: Address;  // USDC (6 decimals) the escrow pulls stakes in
  chainId: number;           // 998 HyperEVM testnet / 999 mainnet
};

​
PickLeg

type PickLeg = {marketId: number; outcome: number}; // outcome: 0 NO / 1 YES
The slip’s map form is Picks = Record<number, number> (marketId to outcome); toLegs(picks) converts.

​
QuoteResponse

Returned by client.quote and stored as lastQuote by useSubmitParlay.
​
order
Record<string, unknown>
The serialized ParlayOrder (bigints as strings): taker, maker, stake, makerCollateral, makerNonce, takerNonce, deadline (unix seconds, quote + 600s), protocolFeeBps, builderFeeBps, builder, legs. Pass it untouched to takerSigningPayload and submit; both signatures cover it byte-for-byte.
​
makerSig
Hex
The vault quoter’s EIP-712 signature over the order.
​
quote
object
The economics, all strings raw USDC unless noted:
​
correlation
object | undefined
How the joint price was built. See Pricing for semantics.
​
margin
Record<string, unknown> | null
How capacity was charged; null under isolated accounting. Under cross mode: {mode: "cross", isolatedAfter, effectiveAfter, securedCredit, exact} (or {mode: "cross", degraded: true}). See Margin.

​
SubmitResponse

type SubmitResponse = {txHash: Hex; parlayId: string};

​
CashoutQuote

Returned by client.cashoutQuote / useCashOut().getQuote. All string amounts raw USDC.
​
cashValue
string
What the taker receives now.
​
quoterNonce
string
Single-use nonce inside the signed message.
​
deadline
string
Unix seconds; the signature expires 120s after issuance.
​
sig
Hex
Quoter EIP-712 signature the escrow verifies.
​
pot
string
What the position would pay at settlement (net of fees) if all legs hit.
​
jointProbBps
string
Live probability all remaining legs win, bps.

​
MarginState

Returned by client.margin(detail?). See Margin for what the numbers mean.
​
mode
"isolated" | "cross"
Which accounting the /quote utilization check is actually charging.
​
creditHaircutBps
number
Haircut kept from the netting relief (default 2000 = 20%).
​
vault
object
totalAssets, locked (raw USDC strings), utilizationCapBps, capacity (NAV times the cap).
​
book
object
positions (count), isolatedLocked, worstCaseLocked, relief, securedCredit, effectiveLocked (raw USDC strings), nettedComponents, exact (whether the worst case was solved exactly).
​
headroom
object
Remaining quoting capacity under each mode: {isolated: string, cross: string}.
​
positions
array | undefined
Only with detail=1: {id, makerCollateral, legs}[] for every open parlay.
​
clusters
number[][] | undefined
Only with detail=1: netting clusters as arrays of parlay ids.

​
RelayerHealth

type RelayerHealth = {
  ok: boolean;                        // ready to quote and submit
  paused: boolean;                    // admin kill switch engaged
  quoterAuthorized: boolean | null;   // any configured quoter key authorized on the vault (null = not checked)
  checks: Record<string, boolean>;    // configured / rpc / hl / vault
};

​
ParlayRow

The canonical position row from useParlayPositions and fetchParlays. 
type ParlayRow = {
  id: number;
  taker: Address;
  maker: Address;
  stake: bigint;            // raw USDC
  makerCollateral: bigint;  // raw USDC
  settled: boolean;
  legCount: number;         // always populated, even while legs load
  legs: PickLeg[];          // may be empty for a cycle while leg reads resolve
};
Derived helpers (pure, exported from @parlays-live/taker): 
potOf(row);         // stake + makerCollateral (bigint)
bookedOddsBps(row); // pot * 10000 / stake (bigint, 0n when stake is 0)

​
ParlayEvent

The analytics union fired through ParlayCallbacks.onEvent. Full definition and PostHog mapping in Analytics.

​
Re-exported from @parlays-live/sdk

So hosts depend on one package:
ExportDescription
formatUsdc(v: bigint): stringRaw 6dp to display string, e.g. 25000000n to "25.00"
formatUsdcCompact(v: bigint): stringCompact display for large amounts
parseUsdc(s: string): bigint"25" / "25.50" to raw 6dp
BPS = 10000n, USDC = 1000000nDenominator constants
loadCards(testnet: boolean)Live HL market data: {cards: MarketCardData[], info: Map<number, MarketInfo>, graph: MarketGraph}
MarketInfoPer-market render lookup: {id, title, context, sideLabels: [string, string], probBps: [number, number]} (index 0 = YES side, 1 = NO side)
MarketCardDataRenderable card: {kind: "binary", sides: [CardOption, CardOption]} or {kind: "multi", options: CardOption[]}, each with title, sub, category
MarketGraphMarket clustering metadata used by the correlation engine