Client

class VoizMarketsClient {
  readonly chainId: number
  readonly addresses: ChainAddresses
  readonly publicClient?: PublicClient
  readonly walletClient?: WalletClient

  constructor(config?: ClientConfig)
}

type ClientConfig = {
  chainId?: number
  addresses?: AddressOverrides
  publicClient?: PublicClient
  walletClient?: WalletClient
  /**
   * Optional custom sender. When set, high-level write methods use it
   * instead of sequential `walletClient.sendTransaction`.
   */
  sendCalls?: SendCalls
}

const staging = client.withAddresses({ hook: STAGING_HOOK })

// returns
VoizMarketsClient

const market = client.market(marketAddress)

// returns
VoizMarket

const pool = client.pool(outcomeToken)
// or client.pool(outcomeToken, collateralToken)

// returns
VoizPool

const user = client.user(walletAddress)

// returns
VoizUser

const addresses = await client.listMarketAddresses()

// returns
Promise<Address[]>

const ok = await client.isMarket(marketAddress)

// returns
Promise<boolean>

const { markets, source, usedFallback } = await client.listMarkets()

// returns
Promise<{
  markets: Array<{
    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
    }>
  }>
  source: "indexer" | "rpc"
  usedFallback: boolean
}>

type ListMarketsResult = {
  markets: MarketSummary[]
  source: "indexer" | "rpc"
  /** True when ponder was attempted and failed, so RPC was used. */
  usedFallback: boolean
}

const bal = await client.getErc20Balance(token, owner)

// returns
Promise<bigint>

const bal = await client.getCollateralBalance(owner)

// returns
Promise<bigint>

const { result, hashes, marketAddress } = await client.createMarket({
  marketName: "Will it rain?",
  outcomes: ["Yes", "No"],
  resolverKind: "admin",
  marketAdmin: admin,
})

// returns
Promise<{
  result: unknown // opaque sender result
  hashes: Hash[]
  marketAddress?: Address
}>

const { result, hashes } = await client.redeem({
  marketAddress,
  outcomeTokens,
  indexes,
  amounts,
  owner,
})

// returns
Promise<{
  result: unknown // opaque sender result
  hashes: Hash[]
}>

const { result, hashes } = await client.burn({
  tokenId,
  outcomeToken,
  recipient: owner,
})

// returns
Promise<{
  result: unknown // opaque sender result
  hashes: Hash[]
}>