schema.graphql

enum SnapshotType {
  DEFAULT
  HOUR
  DAY
  MONTH
  BLOCK
}

enum PayeeType {
  STAKED
  STASH
  CONTROLLER
  ACCOUNT
  NONE
}

enum HistoryElementType {
  CALL
  EVENT
}

interface ISnapshot {
  id: ID!
  timestamp: Int!
  type: SnapshotType!
}

type NetworkStats @entity {
  id: ID!
  totalFees: BigInt!
  totalAccounts: Int!
  totalTransactions: Int!
  totalBridgeIncomingTransactions: Int!
  totalBridgeOutgoingTransactions: Int!
}

type NetworkSnapshot implements ISnapshot @entity {
  id: ID!
  type: SnapshotType!
  timestamp: Int!
  accounts: Int!
  transactions: Int!
  fees: BigInt!
  liquidityUSD: String!
  volumeUSD: String!
  bridgeIncomingTransactions: Int!
  bridgeOutgoingTransactions: Int!
}

type AssetOwner @entity {
  id: ID! # accountId-sbtAssetId (of issuer)
  sbtAccesses: [AssetOwnerAccount!]!
}

type AssetOwnerAccount @jsonField {
  accountAddress: String! # address that has been given access to
  expiresAt: Int!
}

type UpdatesStream @entity {
  id: ID!
  block: Int!
  data: String! # stringified JSON
}

type AssetPrice @jsonField {
  open: String!
  close: String!
  high: String!
  low: String!
}

type AssetVolume @jsonField {
  amount: String!
  amountUSD: String!
}

type Asset @entity {
  id: ID!
  priceUSD: String!
  supply: BigInt!
  liquidity: BigInt # locked in pools (in tokens)
  liquidityBooks: BigInt # locked in order books (in tokens)
  priceChangeDay: Float
  priceChangeWeek: Float
  volumeDayUSD: Float
  volumeWeekUSD: Float
  velocity: Float # calculated in week
  data: [AssetSnapshot!]! @derivedFrom(field: "asset")
  # poolXYK: [PoolXYK] @derivedFrom(field: "targetAsset")
}

type AssetSnapshot implements ISnapshot @entity @compositeIndexes(fields: [["asset", "type"]]) {
  id: ID!
  asset: Asset! @index #relation to Asset
  timestamp: Int!
  type: SnapshotType!
  priceUSD: AssetPrice
  volume: AssetVolume
  supply: BigInt!
  mint: BigInt!
  burn: BigInt!
}

type PoolXYK @entity {
  id: ID!
  baseAssetId: String!
  targetAssetId: String!
  # baseAsset: Asset! @index
  # targetAsset: Asset! @index
  baseAssetReserves: BigInt! # (base + chameleon) reserves
  targetAssetReserves: BigInt! # target reserves
  chameleonAssetReserves: BigInt # chameleon reserves only
  multiplier: Int!
  priceUSD: String
  strategicBonusApy: String
  poolTokenSupply: BigInt
  poolTokenPriceUSD: String
  liquidityUSD: String
  data: [PoolSnapshot!]! @derivedFrom(field: "pool")
  # accountLiquidities: [AccountLiquidity] @derivedFrom(field: "pool")
}

type PoolSnapshot implements ISnapshot @entity @compositeIndexes(fields: [["pool", "type"]]) {
  id: ID!
  pool: PoolXYK! @index #relation to PoolXYK
  timestamp: Int!
  type: SnapshotType!
  priceUSD: AssetPrice! # price of target asset
  baseAssetReserves: BigInt! # (base + chameleon) reserves
  targetAssetReserves: BigInt! # target reserves
  chameleonAssetReserves: BigInt! # chameleon reserves only
  baseAssetVolume: String!
  targetAssetVolume: String!
  chameleonAssetVolume: String!
  poolTokenSupply: BigInt!
  poolTokenPriceUSD: String!
  liquidityUSD: String!
  volumeUSD: String!
}

type AccountLiquidity @entity {
  id: ID! # account id - pool id
  accountId: String!
  poolId: String!
  # account: Account! @index #relation to Account
  # pool: PoolXYK! @index #relation to PoolXYK
  poolTokens: BigInt! # pool tokens
  liquidityUSD: String!
  data: [AccountLiquiditySnapshot!]! @derivedFrom(field: "accountLiquidity")
}

type AccountLiquiditySnapshot implements ISnapshot @entity {
  id: ID!
  timestamp: Int!
  type: SnapshotType!
  accountLiquidity: AccountLiquidity! @index #relation to AccountLiquidity
  poolTokens: BigInt! # pool tokens
  liquidityUSD: String!
}

type Account @entity {
  id: ID!
  latestHistoryElement: HistoryElement # for subscription support
  lastLiquidation: VaultEvent # for subscription support
  # liquidities: [AccountLiquidity] @derivedFrom(field: "account")
}

type AccountPointSystem @entity {
  id: ID! # accountId - version
  accountId: String!
  version: Int! # 1 or 2
  startedAtBlock: Int! # block
  # points
  xorFees: AssetVolume!
  xorBurned: AssetVolume!
  xorStakingValRewards: AssetVolume!
  orderBook: AccountMetaEventCounter!
  vault: AccountMetaEventCounter!
  governance: AccountMetaGovernance!
  deposit: AccountMetaDeposit!
}

type AccountMeta @entity {
  id: ID!
  # account: Account! @index #relation to Account
  createdAtTimestamp: Int! # timestamp
  createdAtBlock: Int! # block
  xorFees: AssetVolume!
  xorBurned: AssetVolume!
  xorStakingValRewards: AssetVolume!
  orderBook: AccountMetaEventCounter!
  vault: AccountMetaEventCounter!
  governance: AccountMetaGovernance!
  deposit: AccountMetaDeposit!
}

type AccountMetaEventCounter @jsonField {
  created: Int!
  closed: Int!
  amountUSD: String!
}

type AccountMetaGovernance @jsonField {
  votes: Int!
  amount: String!
  amountUSD: String!
}

type AccountMetaDeposit @jsonField {
  incomingUSD: String!
  outgoingUSD: String!
}

type HistoryElement @entity {
  id: ID!
  type: HistoryElementType!
  blockHeight: Int!
  blockHash: String! @index
  module: String! @index
  method: String! @index
  address: String! @index
  networkFee: String!
  execution: ExecutionResult!
  timestamp: Int!
  data: HistoryElementDetails
  dataTo: String @index
  dataFrom: String @index
  dataAssets: [String]
  calls: [HistoryElementCall!]! @derivedFrom(field: "historyElement")
  callNames: [String]!
  updatedAtBlock: Int!
}

type HistoryElementDetails @jsonField {
  data: String # API is implemented by bypassing the scheme - `data` in all mappings is an object, not a String. See https://github.com/subquery/subql/issues/522.
}

type HistoryElementCall @entity {
  id: ID!
  historyElement: HistoryElement! @index
  module: String!
  method: String!
  hash: String! @index
  data: HistoryElementCallDetails
  updatedAtBlock: Int!
}

type HistoryElementCallDetails @jsonField {
  data: String # API is implemented by bypassing the scheme - `data` in all mappings is an object, not a String. See https://github.com/subquery/subql/issues/522.
}

type ExecutionResult @jsonField {
  success: Boolean!
  error: Error
}

type Error @jsonField {
  moduleErrorId: Int
  moduleErrorIndex: Int
  nonModuleErrorMessage: String
}

type ReferrerReward @entity {
  id: ID!
  referral: String! @index
  referrer: String!
  updated: Int!
  amount: BigInt!
}

type StakingStaker @entity {
  id: ID!
  eraValidators: [StakingEraValidator!]! @derivedFrom(field: "staker")
  eraNominators: [StakingEraNominator!]! @derivedFrom(field: "staker")
  payeeType: PayeeType!
  payee: String
  controller: String
}

type StakingValidator @entity {
  id: ID!
  bond: BigInt!
}

type StakingEraNominator @entity {
  id: ID!
  era: StakingEra!
  bond: BigInt!
  staker: StakingStaker!
  nominations: [StakingEraNomination!]! @derivedFrom(field: "nominator")
}

type StakingEraNomination @entity {
  id: ID!
  era: StakingEra!
  amount: BigInt!
  validator: StakingEraValidator!
  nominator: StakingEraNominator!
}

type StakingEraValidator @entity {
  id: ID!
  era: StakingEra!
  validator: StakingValidator!
  nominations: [StakingEraNomination!]! @derivedFrom(field: "validator")
  ownBond: BigInt!
  totalBond: BigInt!
  rewardAmount: BigInt!
  staker: StakingStaker!
}

type StakingEra @entity {
  id: ID!
  index: Int! @index
  start: BigInt! @index
  validators: [StakingEraValidator!]! @derivedFrom(field: "era")
  nominators: [StakingEraNominator!]! @derivedFrom(field: "era")
  nominations: [StakingEraNomination!]! @derivedFrom(field: "era")
}

enum OrderBookStatus {
  Trade
  PlaceAndCancel
  OnlyCancel
  Stop
}

enum OrderStatus {
  Active
  Aligned
  Canceled
  Expired
  Filled
}

enum OrderType {
  Limit
  Market
}

interface IOrderBookDeal {
  timestamp: Int! # created (and could be executed) at block timestamp
  isBuy: Boolean! # buy or sell
  amount: String! # number like formatted
  price: String! # number like formatted
}

type OrderBookDeal implements IOrderBookDeal @jsonField {
  orderId: Int!
  timestamp: Int!
  isBuy: Boolean!
  amount: String!
  price: String!
}

type OrderBook @entity {
  id: ID!
  dexId: Int! @index
  baseAssetId: String!
  quoteAssetId: String!
  # baseAsset: Asset! @index
  # quoteAsset: Asset! @index
  baseAssetReserves: BigInt!
  quoteAssetReserves: BigInt!
  status: OrderBookStatus!
  price: String
  priceChangeDay: Float
  volumeDayUSD: String
  lastDeals: String
  updatedAtBlock: Int!
  data: [OrderBookSnapshot!]! @derivedFrom(field: "orderBook")
  orders: [OrderBookOrder!]! @derivedFrom(field: "orderBook")
}

type OrderBookSnapshot @entity @compositeIndexes(fields: [["orderBook", "type"]]) {
  id: ID!
  orderBook: OrderBook! @index
  timestamp: Int!
  type: SnapshotType!
  price: AssetPrice!
  baseAssetVolume: String!
  quoteAssetVolume: String!
  volumeUSD: String!
  liquidityUSD: String!
}

type OrderBookOrder implements IOrderBookDeal @entity {
  id: ID!
  type: OrderType!
  orderId: Int
  orderBook: OrderBook! @index
  account: Account! @index
  createdAtBlock: Int!
  timestamp: Int!
  isBuy: Boolean!
  amount: String!
  price: String!
  lifetime: Int!
  expiresAt: Int!
  amountFilled: String!
  status: OrderStatus!
  updatedAtBlock: Int!
}

# CdpType
enum VaultType {
  # Pays stability fee in underlying collateral, cannot be liquidated.
  Type1
  # Pays stability fee in stable coins, can be liquidated. (by default ??)
  Type2
}

enum VaultStatus {
  Opened
  Closed
  Liquidated # returned collateral amount === 0
}

type Vault @entity {
  id: ID!
  type: VaultType!
  status: VaultStatus!
  owner: Account! @index
  collateralAsset: Asset! @index
  debtAsset: Asset! @index
  collateralAmountReturned: String
  createdAtBlock: Int!
  updatedAtBlock: Int! # updated or closed
  events: [VaultEvent!]! @derivedFrom(field: "vault")
}

enum VaultEventType {
  Created
  Closed
  CollateralDeposit
  DebtIncreased
  DebtPayment
  Liquidated
}

type VaultEvent @entity {
  id: ID!
  type: VaultEventType!
  vault: Vault! @index # relation to Vault
  timestamp: Int!
  block: Int!
  amount: String
}