ocean-subgraph/schema.graphql

type Token @entity {
  id: ID!
  symbol: String
  name: String
  decimals: Int!
  address: String!
  cap: BigDecimal
  supply: BigDecimal
  isDatatoken: Boolean!

  "address of ERC721 that owns the token, valid only for datatokens"
  nft: Nft

  "array of addresses with minter role"
  minter: [String!]

  "array of addresses with payment manager minter role"
  paymentManager: [String!]

  "address that collects the payments (NOT fees)"
  paymentCollector: String

  "address of the market where the datatoken was created. This address collects market fees."
  publishMarketFeeAddress: String

  "adreess of fee token (can be Ocean, ETH, etc.)"
  publishMarketFeeToken: String

  "fee amount. Fixed value."
  publishMarketFeeAmount: BigDecimal

  "template ID of the datatoken"
  templateId: Int

  "number of addresses holding a balance of datatoken , TODO: can we actually calculate this? what happens when users trade the dts"
  holderCount: BigInt!

  "number of orders executed for this datatoken"
  orderCount: BigInt!

  "orders created with the datatoken, only available for datatokens"
  orders: [Order!] @derivedFrom(field: "datatoken")

  "fixed rate exchanges, only available for datatokens"
  fixedRateExchanges: [FixedRateExchange!] @derivedFrom(field: "datatoken")

  "dispensers using this token"
  dispensers: [Dispenser!] @derivedFrom(field: "token")

  "block time datatoken was created"
  createdTimestamp: Int!

  "datatoken creation transaction id"
  tx: String!

  "block number when it was created"
  block: Int!

  lastPriceToken: Token
  lastPriceValue: BigDecimal!
}

"utility type"
type TokenValuePair @entity {
  "address of the token"
  id: ID!
  token: Token!
  value: BigDecimal!
}

type Nft @entity {
  "nft address"
  id: ID!
  symbol: String!
  name: String!
  tokenUri: String

  "address of the owner of the nft"
  owner: User!
  "address of the creator of the nft"
  creator: User!

  "same as id, it's just for easy discoverability"
  address: String!

  "provider url that can decrypt the ddo"
  providerUrl: String

  "state of the asset (described in docs)"
  assetState: Int!

  managerRole: [String!]
  erc20DeployerRole: [String!]
  storeUpdateRole: [String!]
  "addresses that can update the metadata"
  metadataRole: [String!]

  "template address"
  template: String!

  "set if NFT is transferable"
  transferable: Boolean!

  "block time nft was created"
  createdTimestamp: Int!
  "nft creation transaction id"
  tx: String!
  "block number when it was created"
  block: Int

  "number of orders executed for all underlying datatokens"
  orderCount: BigInt!

  "has metadata"
  hasMetadata: Boolean!

  nftData: [NftData!] @derivedFrom(field: "nft")
  transferHistory: [NftTransferHistory!] @derivedFrom(field: "nft")
}

type NftData @entity {
  "nft address+key"
  id: ID!
  nft: Nft!
  key: Bytes
  value: Bytes
}

type OrderReuse @entity {
  id: ID!
  order: Order!
  caller: String!
  createdTimestamp: Int!
  tx: String!
  block: Int!
  providerFee: String
  providerFeeValidUntil: BigInt
  "gas price in Wei"
  gasPrice: BigInt
  gasUsed: BigDecimal
}

type Order @entity {
  "transaction hash - token address - from address"
  id: ID!
  datatoken: Token!

  consumer: User!
  payer: User!
  amount: BigDecimal!
  serviceIndex: Int!
  nftOwner: User!

  # the fees will be updated from an event that will be created after (todo)
  publishingMarket: User
  publishingMarketToken: Token #
  publishingMarketAmmount: BigDecimal #call contract to get fee amount
  providerFee: String
  providerFeeValidUntil: BigInt

  consumerMarket: User
  consumerMarketToken: Token #
  consumerMarketAmmount: BigDecimal #call contract to get fee amount
  reuses: [OrderReuse!] @derivedFrom(field: "order")

  createdTimestamp: Int!
  tx: String!
  block: Int!

  lastPriceToken: Token
  lastPriceValue: BigDecimal!
  estimatedUSDValue: BigDecimal!
  gasUsed: BigDecimal
  "gas price in Wei"
  gasPrice: BigInt
}

type User @entity {
  id: ID!
  tokenBalancesOwned: [TokenValuePair!]
  orders: [Order!] @derivedFrom(field: "payer")
  freSwaps: [FixedRateExchangeSwap!] @derivedFrom(field: "by")

  "total number of orders made by this user"
  totalOrders: BigInt!

  "total number of orders made on assets owned by this user"
  totalSales: BigInt!
}

type FixedRateExchange @entity {
  "fixed rate exchange id"
  id: ID!
  contract: String!
  exchangeId: String!
  owner: User!
  datatoken: Token!
  baseToken: Token!
  "amount of datatokens available to be sold, this is relevant if the exchange is not able to mint"
  datatokenSupply: BigDecimal!
  "amount of basetokens available to be collected by the owner"
  baseTokenSupply: BigDecimal!
  datatokenBalance: BigDecimal!
  baseTokenBalance: BigDecimal!
  price: BigDecimal!
  active: Boolean!
  "amount of total basetokens spent"
  totalSwapValue: BigDecimal!
  "address that is allowed to  swap tokens"
  allowedSwapper: String
  "if the owner allowes the fre to mint"
  withMint: Boolean
  "if the fre has the minter role on the datatoken"
  isMinter: Boolean

  updates: [FixedRateExchangeUpdate!] @derivedFrom(field: "exchangeId")
  swaps: [FixedRateExchangeSwap!] @derivedFrom(field: "exchangeId")

  createdTimestamp: Int!
  tx: String!
  block: Int!

  "address of the market where the datatoken was created. This address collects market fees."
  publishMarketFeeAddress: String

  "fee amount. Fixed value"
  publishMarketSwapFee: BigDecimal
}

type FixedRateExchangeUpdate @entity {
  id: ID!
  exchangeId: FixedRateExchange!

  oldPrice: BigDecimal
  newPrice: BigDecimal

  oldActive: Boolean
  newActive: Boolean

  oldAllowedSwapper: String
  newAllowedSwapper: String

  block: Int!
  createdTimestamp: Int!
  tx: String!
}

type FixedRateExchangeSwap @entity {
  id: ID!
  exchangeId: FixedRateExchange!
  by: User!
  baseTokenAmount: BigDecimal!
  dataTokenAmount: BigDecimal!
  block: Int!
  createdTimestamp: Int!
  tx: String!
  oceanFeeAmount: BigDecimal!
  marketFeeAmount: BigDecimal!
  consumeMarketFeeAmount: BigDecimal!
}

type Dispenser @entity {
  "token address"
  id: ID!
  contract: String!
  active: Boolean!
  "if using the enterprise template the owner will always be the erc721 factory, for normal template it will a user"
  owner: String
  token: Token!

  allowedSwapper: String
  isMinter: Boolean
  "max tokens that can be dispensed"
  maxTokens: BigDecimal!
  "max balance of requester. If the balance is higher, the dispense is rejected"
  maxBalance: BigDecimal!
  "how many tokens are left"
  balance: BigDecimal!

  block: Int!
  createdTimestamp: Int!
  tx: String!

  dispenses: [DispenserTransaction!] @derivedFrom(field: "dispenser")
}

type DispenserTransaction @entity {
  id: ID!
  dispenser: Dispenser!
  user: User!
  amount: BigDecimal!

  block: Int!
  createdTimestamp: Int!
  tx: String!
}

"utility type"
type GlobalTotalLiquidityPair @entity {
  "address of the token"
  id: ID!
  globalStatistic: GlobalStatistic!
  token: Token!
  value: BigDecimal!
}

"utility type"
type GlobalTotalFixedSwapPair @entity {
  "address of the token"
  id: ID!
  globalStatistic: GlobalStatistic!
  token: Token!
  value: BigDecimal!
  count: BigInt!
}
type GlobalStatistic @entity {
  id: ID!

  "total swap volume for each base token in fixed rate exchanges"
  totalFixedSwapVolume: [GlobalTotalFixedSwapPair!]
    @derivedFrom(field: "globalStatistic")

  "number of total orders. fixed rate exchange orders + dispenser orders"
  orderCount: Int!

  "total nfts(erc721) created"
  nftCount: Int!
  "total datatokens (tokens with isDatatoken = true) created"
  datatokenCount: Int!

  "number of fixed rate exchanges"
  fixedCount: Int!

  "number of dispensers created"
  dispenserCount: Int!

  "total ocean locked in veOcean"
  totalOceanLocked: BigDecimal!

  "current version"
  version: String
}

type OPC @entity {
  id: ID!
  "fee in percent for swaps involving OPC approved tokens"
  swapOceanFee: BigDecimal
  "fee in percent for swaps involving non OPC approved tokens"
  swapNonOceanFee: BigDecimal
  "fee in percent taken by OPC from orderFees"
  orderFee: BigDecimal
  "fee in percent taken by OPC from providerFees"
  providerFee: BigDecimal
  approvedTokens: [Token!]
}

enum NftUpdateType {
  METADATA_CREATED
  METADATA_UPDATED
  STATE_UPDATED
  TOKENURI_UPDATED
}

type NftUpdate @entity {
  id: ID! # update tx +  nft address
  tokenUri: String
  nft: Nft!

  "provider url that can decrypt the ddo"
  providerUrl: String

  "user that made the update"
  userAddress: String!

  "state of the asset in this update"
  assetState: Int!

  "type of the update: metadata created, metadata update, state update, token uri update"
  type: NftUpdateType!

  block: Int!
  timestamp: Int!
  tx: String!
}

type Template @entity {
  id: ID!
  fixedRateTemplates: [String!]
  dispenserTemplates: [String!]
  ssTemplates: [String!]
}

# Not tracking allocationToId or idToAllocation
type VeAllocateUser @entity {
  "id = {user}"
  id: ID!

  veAllocation: [VeAllocation!] @derivedFrom(field: "allocationUser")
  allocatedTotal: BigDecimal!

  block: Int!
  firstContact: Int!
  lastContact: Int!
  tx: String!
  veOcean: VeOCEAN!
}

type VeAllocateId @entity {
  "id = {DataNFT Address}-{chain id}"
  id: ID!
  nftAddress: String!
  chainId: BigInt!

  veAllocation: [VeAllocation!] @derivedFrom(field: "allocationId")
  allocatedTotal: BigDecimal!

  block: Int!
  firstContact: Int!
  lastContact: Int!
  tx: String!
}

# we need to track allocation of user to id
type VeAllocation @entity {
  "id = {user}-{DataNFT Address}-{chain id}"
  id: ID!

  allocationUser: VeAllocateUser!
  allocationId: VeAllocateId!

  updates: [VeAllocationUpdate!] @derivedFrom(field: "veAllocation")
  allocated: BigDecimal!
  chainId: BigInt!
  nftAddress: String!

  block: Int!
  firstContact: Int!
  lastContact: Int!
  tx: String!
}

enum veAllocationUpdateType {
  SET
  REMOVED
}

type VeAllocationUpdate @entity {
  "{tx}-{VeAllocation id}"
  id: ID!

  veAllocation: VeAllocation!
  type: veAllocationUpdateType!
  allocatedTotal: BigDecimal!

  block: Int!
  timestamp: Int!
  tx: String!
}

type VeDelegation @entity {
  "id = VeDelegation contract + tokenId"
  id: ID!
  delegator: VeOCEAN!
  receiver: VeOCEAN!
  tokenId: BigInt!
  amount: BigDecimal!
  lockedAmount: BigDecimal!
  timeLeftUnlock: Int!
  cancelTime: BigInt!
  expireTime: BigInt!
  updates: [VeDelegationUpdate!] @derivedFrom(field: "veDelegation")
}

type VeDelegationUpdate @entity {
  "id = {tx}-{eventIndex}"
  id: ID!
  block: Int!
  timestamp: Int!
  tx: String!
  sender: String!
  amount: BigDecimal!
  cancelTime: BigInt!
  expireTime: BigInt!
  "type: CREATE_BOOST = 0, EXTEND_BOOST = 1, BURN_BOOST = 2"
  type: Int!
  veDelegation: VeDelegation!
}

type VeOCEAN @entity {
  "id = {user address}"
  id: ID!
  "total amount of locked tokens"
  lockedAmount: BigDecimal!
  "unlock timestamp"
  unlockTime: BigInt!
  delegation: [VeDelegation!] @derivedFrom(field: "delegator")
  delegates: [VeDelegation!] @derivedFrom(field: "receiver")
  deposits: [VeDeposit!] @derivedFrom(field: "veOcean")
  claims: [VeClaim!] @derivedFrom(field: "veOcean")
  allocation: VeAllocateUser @derivedFrom(field: "veOcean")
  block: Int!
}

type VeDeposit @entity {
  "id = {user address}-{tx}-{eventIndex}"
  id: ID!
  "veOcean holder"
  provider: String!
  "who initiated the tx"
  sender: String!
  "amount of tokens locked"
  value: BigDecimal!
  "unlock timestamp"
  unlockTime: BigInt!
  "deposit type: DEPOSIT_FOR = 0, CREATE_LOCK_TYPE = 1,INCREASE_LOCK_AMOUNT = 2,INCREASE_UNLOCK_TIME = 3, WITHDRAW = 4"
  type: BigInt!
  timestamp: BigInt!
  block: Int!
  tx: String!
  veOcean: VeOCEAN!
  totalOceanLocked: BigDecimal!
}

type VeFeeDistributor @entity {
  "id = contract address"
  id: ID!
  "token used by FeeDistributor"
  token: Token!
  claims: [VeClaim!] @derivedFrom(field: "VeFeeDistributor")
  checkpoints: [VeFeeDistributorCheckPoint!]
    @derivedFrom(field: "VeFeeDistributor")
}

type VeFeeDistributorCheckPoint @entity {
  "id = {tx}-{eventno}"
  id: ID!
  "amount of tokens for rewards"
  tokens: BigDecimal!
  "who initiated the tx"
  sender: String!
  VeFeeDistributor: VeFeeDistributor!
  timestamp: BigInt!
  block: Int!
  tx: String!
}

type VeClaim @entity {
  "id = {tx}-{eventno}"
  id: ID!
  "amount of tokens claimed"
  amount: BigDecimal!
  "claim epoch"
  claim_epoch: BigInt
  "max_epoch"
  max_epoch: BigInt
  timestamp: BigInt!
  block: Int!
  tx: String!
  veOcean: VeOCEAN!
  VeFeeDistributor: VeFeeDistributor!
}

enum DFHistoryType {
  Allocated
  Claimed
}

type DFAvailableClaim @entity {
  "id = {userId}-{tokenId}"
  id: ID!
  receiver: DFReward!
  amount: BigDecimal!
  token: Token!
}

type DFHistory @entity {
  "id = {user-id}-{txId}-{eventId}"
  id: ID!
  receiver: DFReward!
  amount: BigDecimal!
  token: Token!
  type: DFHistoryType!
  timestamp: BigInt!
  block: Int!
  tx: String!
}

type DFReward @entity {
  "id = {user address}"
  id: ID!
  receiver: User!
  availableClaims: [DFAvailableClaim!] @derivedFrom(field: "receiver")
  history: [DFHistory!] @derivedFrom(field: "receiver")
}

type NftTransferHistory @entity {
  # ID = hash(nftAddress+txId+eventNumber)
  id: ID!
  nft: Nft!
  oldOwner: User!
  newOwner: User!
  txId: String
  timestamp: Int!
  block: Int!
}