Market

const market = client.market(address)

const summary = await market.summary()
// or market.summary({ rpcOnly: true })
// or market.summary({ requireFactory: false })

// returns
Promise<{
  address: Address
  marketName: string
  outcomes: string[]
  resolver: Address
  resolverKind: "admin" | "committee"
  marketAdmin: Address
  threshold: number | null
  resolutionMode: number
  conditionId: `0x${string}`
  resolved: boolean
  winningOutcome: number | null
  wrappedTokens: Address[]
  numOutcomes: number
  imageUri: string | null
  outcomeImageUris: (string | null)[]
  outcomeStats?: Array<{
    index: number
    impliedPct: number | null
    liquidityCollateral: bigint | null
    volumeCollateral: bigint | null
  }>
} | null>

const points = await market.priceHistory({ from: Math.floor(Date.now() / 1000) - 86400 })

// returns
Promise<Array<{
  outcomeIndex: number
  priceCt: number
  impliedPct: number | null
  timestamp: string
  source: string
}>>

const { rows, source } = await market.prices()

// returns
Promise<{
  rows: Array<{
    index: number
    label: string
    token: Address
    priceCt: number | null
    impliedPct: number | null
  }>
  source: "indexer" | "rpc"
}>

const { rows, source } = await market.metrics()

// returns
Promise<{
  rows: Array<{
    index: number
    liquidity: bigint | null
    volumeCollateral: bigint | null
  }>
  source: "indexer" | "rpc"
}>

const status = await market.seedStatus()

// returns
Promise<"none" | "partial" | "seeded">

const ok = await market.canResolve(user)

// returns
Promise<boolean>

const result = await market.seed({
  outcomeTokens: summary.wrappedTokens.slice(0, summary.numOutcomes),
  seedWei,
  oddsBps,
  owner,
})

// returns
Promise<{
  plan: {
    splitAmount: bigint
    poolCollateral: bigint
    totalCollateral: bigint
    legs: Array<{
      index: number
      priceBps: bigint
      sqrtPriceX96: bigint
      outcomeAmount: bigint
      collateralAmount: bigint
      token0: Address
      token1: Address
      amount0: bigint
      amount1: bigint
    }>
  }
  splitResult: unknown
  outcomeResults: unknown[]
  splitHashes: Hash[]
  outcomeHashes: Hash[][]
}>

const result = await market.resolve({ outcomeIndex: 0 })

// returns
Promise<unknown>

const result = await market.merge({ amount, owner })

// returns
Promise<unknown>

const result = await market.addLiquidity({
  credits,
  owner,
})

// returns
Promise<{
  splitAmount: bigint
  pairCollateral: bigint
  shareCollateral: bigint
  splitResult: unknown
  outcomeResults: Array<{ index: number; result: unknown } | null>
}>

type ResolveParams = { outcomeIndex: number }

type MergeParams = {
  amount: bigint
  owner: Address
  forceApprovals?: boolean
  wrappedTokens?: Address[]
}