queries.graphql

fragment ProductFields on Product {
  __typename
  id
  name
  kind
  markUsd
}

fragment MarketFields on Market {
  __typename
  venue {
    id
    name
  }
  exchangeSymbol
  id
  cmeProductGroupInfo {
    productName
    securityType
    category
    subCategory
    mainFraction
    priceBand
  }
  kind {
    ... on ExchangeMarketKind {
      __typename
      base {
        ...ProductFields
      }
      quote {
        ...ProductFields
      }
    }
    ... on PoolMarketKind {
      __typename
      products {
        ...ProductFields
      }
    }
  }
  name
  tickSize
  stepSize
  minOrderQuantity
  minOrderQuantityUnit
  route {
    id
    name
  }
  isFavorite
}


fragment OrderFields on Order {
  id
  marketId
  market {
    ...MarketFields
  }
  dir
  quantity
  accountId
  orderType {
    __typename
    ... on LimitOrderType {
      limitPrice
      postOnly
    }
    ... on StopLossLimitOrderType {
      limitPrice
      triggerPrice
    }
    ... on TakeProfitLimitOrderType {
      limitPrice
      triggerPrice
    }
  }
  timeInForce {
    instruction
    goodTilDate
  }
  quoteId
  source
}


fragment MarketSnapshotFields on MarketSnapshot {
  __typename
  marketId
  market {
    name
  }
  high24h
  lastPrice
  low24h
  volume24h
  open24h
  bidPrice
  askPrice
}

fragment CandleFields on CandleV1 {
  time
  open
  high
  low
  close
  volume
}

fragment OrderLogFields on OrderLog {
  __typename
  timestamp
  order {
    id
    market {
      ...MarketFields
    }
    dir
    quantity
    orderType {
      __typename
      ... on LimitOrderType {
        limitPrice
      }
      ... on StopLossLimitOrderType {
        limitPrice
        triggerPrice
      }
      ... on TakeProfitLimitOrderType {
        limitPrice
        triggerPrice
      }
    }
    timeInForce {
      instruction
      goodTilDate
    }
  }
  orderState
  filledQty
  avgFillPrice
  rejectReason
}

fragment AccountSummariesFields on AccountSummaries {
  snapshotTs
  byAccount {
    account {
      id
      name
    }
    balances {
      product {
        ...ProductFields
      }
      account {
        id
        name
      }
      venue {
        id
        name
      }
      amount
      totalMargin
      positionMargin
      purchasingPower
      cashExcess
      yesterdayBalance
    }
    positions {
      account {
        id
        name
      }
      venue {
        id
        name
      }
      market {
        ...MarketFields
      }
      dir
      quantity
      averagePrice
      tradeDate
      tradeTime
    }
  }
}

query GetMarket($id: MarketId!) {
  market(id: $id) {
    ...MarketFields
  }
}

query GetMarkets($ids: [MarketId!]!) {
  markets(id: $ids) {
    ...MarketFields
  }
}

# [2024-09-23] deprecated in favor of SearchMarkets
query GetFilteredMarkets(
  $venue: Str
  $base: Str
  $quote: Str
  $underlying: Str
  $maxResults: Int
  $resultsOffset: Int
  $searchString: Str
  $onlyFavorites: Boolean
  $sortByVolumeDesc: Boolean
) {
  filterMarkets(
    filter: {
      venue: $venue
      base: $base
      quote: $quote
      underlying: $underlying
      maxResults: $maxResults
      resultsOffset: $resultsOffset
      searchString: $searchString
      onlyFavorites: $onlyFavorites
      sortByVolumeDesc: $sortByVolumeDesc
    }
  ) {
    ...MarketFields
  }
}

query SearchMarkets(
  $venue: Str
  $base: Str
  $quote: Str
  $underlying: Str
  $maxResults: Int
  $resultsOffset: Int
  $searchString: Str
  $onlyFavorites: Boolean
  $sortByVolumeDesc: Boolean
) {
  filterMarkets(
    filter: {
      venue: $venue
      base: $base
      quote: $quote
      underlying: $underlying
      maxResults: $maxResults
      resultsOffset: $resultsOffset
      searchString: $searchString
      onlyFavorites: $onlyFavorites
      sortByVolumeDesc: $sortByVolumeDesc
    }
  ) {
    ...MarketFields
  }
}

query GetFirstNoticeDate($id: MarketId!) {
  market(id: $id) {
    firstNoticeDate
  }
}

query GetMarketSnapshot($id: MarketId!) {
  marketSnapshot(market: $id) {
    ...MarketSnapshotFields
  }
}

query GetAllMarketSnapshots {
  marketsSnapshots {
    ...MarketSnapshotFields
  }
}

query GetAccountSummaries {
  accountSummaries {
    ...AccountSummariesFields
  }
}

query GetAccountSummariesForCpty($venue: VenueId!, $route: RouteId!) {
  accountSummariesForCpty(venue: $venue, route: $route) {
    ...AccountSummariesFields
  }
}

# [2024-07-01] deprecated in favor of GetAccountSummariesForCpty
query GetBalancesForCpty($venue: VenueId!, $route: RouteId!) {
  accountSummariesForCpty(venue: $venue, route: $route) {
    snapshotTs
    byAccount {
      balances {
        product {
          ...ProductFields
        }
        amount
      }
    }
  }
}

query GetAllOpenOrders {
  openOrders {
    ...OrderLogFields
  }
}

query GetOutOrders($fromInclusive: DateTime!, $toExclusive: DateTime!) {
  outedOrders(fromInclusive: $fromInclusive, toExclusive: $toExclusive) {
    ...OrderLogFields
  }
}

query GetOrder($orderId: OrderId!) {
  order(orderId: $orderId) {
    ...OrderLogFields
  }
}

query GetAlgoStatus($orderId: OrderId!) {
  algoStatus(orderId: $orderId) {
    orderId
    order {
      orderId
      trader
      account
      algo
      parentOrderId
      markets
    }
    creationTime
    status
    lastStatusChange
    fractionComplete
  }
}

query GetAlgoOrder($orderId: OrderId!) {
  algoOrder(orderId: $orderId) {
    orderId
    trader
    account
    algo
    parentOrderId
    markets
  }
}


query GetTwapStatus($orderId: OrderId!) {
  twapStatus(orderId: $orderId) {
    orderId
    order {
      name
      orderId
      marketId
      dir
      quantity
      endTime
      accountId
      intervalMs
      rejectLockoutMs
      takeThroughFrac
    }
    creationTime
    status
    fractionComplete
    realizedTwap
    quantityFilled
  }
}

query GetTwapOrder($orderId: OrderId!) {
  twapOrder(orderId: $orderId) {
    name
    orderId
    marketId
    dir
    quantity
    endTime
    accountId
    intervalMs
    rejectLockoutMs
    takeThroughFrac
  }
}

query GetPovStatus($orderId: OrderId!) {
  povStatus(orderId: $orderId) {
    orderId
    order {
      name
      orderId
      marketId
      dir
      targetVolumeFrac
      minOrderQuantity
      maxQuantity
      endTime
      accountId
      takeThroughFrac
    }
    creationTime
    status
    fractionComplete
    realizedVolumeFrac
    marketVolume
    quantityFilled
  }
}

query GetPovOrder($orderId: OrderId!) {
  povOrder(orderId: $orderId) {
    name
    orderId
    marketId
    dir
    targetVolumeFrac
    minOrderQuantity
    maxQuantity
    endTime
    accountId
    takeThroughFrac
  }
}


query GetSmartOrderRouterStatus($orderId: OrderId!) {
  smartOrderRouterStatus(orderId: $orderId) {
    status {
      orderId
      order {
        orderId
        trader
        account
        algo
        parentOrderId
        markets
      }
      creationTime
      status
      lastStatusChange
      fractionComplete
    }
    order {
      orderId
      markets {
        id
      }
      # base
      # quote
      dir
      limitPrice
      targetSize
      executionTimeLimitMs
      parentOrderId
    }
  }
}


query GetSmartOrderRouterOrder($orderId: OrderId!) {
  smartOrderRouterOrder(orderId: $orderId) {
    orderId
    markets {
      id
    }
    # base
    # quote
    dir
    limitPrice
    targetSize
    executionTimeLimitMs
    parentOrderId
  }
}


query GetMmStatus($orderId: OrderId!) {
  mmAlgoStatus(orderId: $orderId) {
    orderId
    order {
      name
      orderId
      marketId
      # market
      quantityBuy
      quantitySell
      minPosition
      maxPosition
      maxImproveBbo
      positionTilt
      referencePrice
      refDistFrac
      toleranceFrac
      account
    }
    creationTime
    status
    position
    hedgePosition
    missRatio
    effectiveSpread
    buyStatus {
      # lastDecision
      lastOrderTime
      lastFillTime
      lastRejectTime
      openOrder {
        orderId
        price
        quantity
        cancelPending
      }
      referencePrice
    }
    sellStatus {
      # lastDecision
      lastOrderTime
      lastFillTime
      lastRejectTime
      openOrder {
        orderId
        price
        quantity
        cancelPending
      }
      referencePrice
    }
    kind
  }
}


query GetMmOrder($orderId: OrderId!) {
  mmAlgoOrder(orderId: $orderId) {
    name
    orderId
    marketId
    quantityBuy
    quantitySell
    minPosition
    maxPosition
    maxImproveBbo
    positionTilt
    referencePrice
    refDistFrac
    toleranceFrac
    account
  }
}


query GetSpreadStatus($orderId: OrderId!) {
  spreadAlgoStatus(orderId: $orderId) {
    orderId
    order {
      name
      orderId
      marketId
      # market
      quantityBuy
      quantitySell
      minPosition
      maxPosition
      maxImproveBbo
      positionTilt
      referencePrice
      refDistFrac
      toleranceFrac
      account
    }
    creationTime
    status
    position
    hedgePosition
    missRatio
    effectiveSpread
    buyStatus {
      # lastDecision
      lastOrderTime
      lastFillTime
      lastRejectTime
      openOrder {
        orderId
        price
        quantity
        cancelPending
      }
      referencePrice
    }
    sellStatus {
      # lastDecision
      lastOrderTime
      lastFillTime
      lastRejectTime
      openOrder {
        orderId
        price
        quantity
        cancelPending
      }
      referencePrice
    }
    kind
  }
}


query GetSpreadOrder($orderId: OrderId!) {
  spreadAlgoOrder(orderId: $orderId) {
    name
    orderId
    marketId
    quantityBuy
    quantitySell
    minPosition
    maxPosition
    maxImproveBbo
    positionTilt
    referencePrice
    refDistFrac
    toleranceFrac
    account
  }
}


query GetFills($venue: VenueId, $route: RouteId, $base: ProductId, $quote: ProductId) {
  fills(venue: $venue, route: $route, base: $base, quote: $quote) {
    normal {
      kind
      fillId
      orderId
      market {
        ...MarketFields
      }
      dir
      price
      quantity
      recvTime
      tradeTime
    }
  }
}

subscription SubscribeTrades($market: MarketId!) {
  trades(market: $market) {
    time
    price
    size
    direction
  }
}

subscription SubscribeCandles($id: MarketId!, $width: CandleWidth!) {
  candles(market: $id, candleWidth: $width) {
    ...CandleFields
  }
}

subscription FillsSubscription {
  fills {
    dir
    fillId
    kind
    marketId
    orderId
    price
    quantity
    recvTime
    tradeTime
    market {
      ...MarketFields
    }
  }
}

subscription SubscribeBook($id: MarketId!, $precision: Decimal) {
  book(market: $id, precision: $precision) {
    bids {
      price
      amount
      total
    }
    asks {
      price
      amount
      total
    }
    timestamp
  }
}

subscription SubscribeExchangeSpecific($markets: [MarketId!]!, $fields: [String!]!) {
  exchangeSpecific(markets: $markets, fields: $fields) {
    market {
      ...MarketFields
    }
    field
    value
  }
}

mutation SendOrder($order: CreateOrder!) {
  createOrder(order: $order)
}

mutation SendOrders($orders: [CreateOrder!]!) {
  createOrders(orders: $orders)
}

mutation SendTwapAlgoRequest($algo: CreateTwapAlgo!) {
  createTwapAlgo(twapAlgo: $algo)
}

mutation SendPovAlgoRequest($algo: CreatePovAlgo!) {
  createPovAlgo(povAlgo: $algo)
}

mutation PreviewSmartOrderRouterAlgoRequest($algo: CreateSmartOrderRouterAlgo!) {
  previewSmartOrderRouterAlgo(algo: $algo) {
    orders {
      ...OrderFields
    }
  }
}

mutation SendSmartOrderRouterAlgoRequest($algo: CreateSmartOrderRouterAlgo!) {
  createSmartOrderRouterAlgo(algo: $algo)
}


mutation SendMmAlgoRequest($algo: CreateMMAlgo!) {
  createMmAlgo(mmAlgo: $algo)
}

mutation SendSpreadAlgoRequest($algo: CreateSpreadAlgo!) {
  createSpreadAlgo(spreadAlgo: $algo)
}


mutation CancelOrder($orderId: OrderId!) {
  cancelOrder(orderId: $orderId)
}

mutation CancelOrders($orderIds: [OrderId!]!) {
  cancelOrders(orderIds: $orderIds)
}

# mutation CancelAllOrders($venue: VenueId) {
#   cancelAllOrders(venueId: $venue)
# }

mutation RemoveTelegramApiKeys {
  removeTelegramApiKeys
}


subscription SubscribeOrderflow {
  orderflow {
    __typename
    ... on Order {
      id
      marketId
      dir
      quantity
      accountId
      orderType {
        ... on LimitOrderType {
          limitPrice
          postOnly
        }
        ... on StopLossLimitOrderType {
          limitPrice
          triggerPrice
        }
        ... on TakeProfitLimitOrderType {
          limitPrice
          triggerPrice
        }
      }
      timeInForce {
        instruction
        goodTilDate
      }
      quoteId
      source
    }
    ... on Ack {
      orderId
    }
    ... on Reject {
      orderId
      reason
    }
    ... on OmsOrderUpdate {
      orderId
      orderState: state
      filledQty
      avgFillPrice
    }
    ... on Fill {
      fillOrderId: orderId
      fillKind: kind
      marketId
      dir
      price
      quantity
      tradeTime
    }
    ... on Out {
      orderId
    }
  }
}

query GetBookSnapshot($market: MarketId!, $numLevels: Int!, $precision: Decimal, $retainSeconds: Int) {
  bookSnapshot(market: $market, numLevels: $numLevels, precision: $precision, retainSubscriptionForNSeconds: $retainSeconds) {
    timestamp
    bids {
      price
      amount
      total
    }
    asks {
      price
      amount
      total
    }
  }
}

query GetAccounts {
  accounts {
    id
    name
  }
}

mutation CreateJwt {
  createJwt
}