ocean-subgraph/schema.graphql

type PoolFactory @entity {
    id: ID!
    totalValueLocked: [TokenValue]                    # total value locked represented in the base token                           
    totalLiquidity: [TokenValue]                      # total liquidity for each base token 
    totalSwapVolume: [TokenValue]                     # total swap volume for each base token
    totalSwapFee: [TokenValue]                        # All the swap fee in Ocean

    poolCount: Int!                                       # Number of pools
    finalizedPoolCount: Int!                              # Number of finalized pools
    orderCount: BigInt                                    # Number of total consumes
    totalOrderVolume: BigDecimal                          # probably remove due to inconsistencies and imposibility to calculate
   
    pools: [Pool!] @derivedFrom(field: "factoryID")
}


type Global @entity {
    id: ID!

    totalValueLocked: [TokenValuePair]                    # total value locked represented in the base token 
    totalLiquidity: [TokenValuePair]                      # total liquidity for each base token 
    totalSwapVolume: [TokenValuePair]                     # total swap volume for each base token. pools and fre             
    
    totalOrderVolume: BigDecimal
     
    orderCount: BigInt                                    # Number of total consumes, pools + fre

    poolCount: Int!                                       # Number of pools for all factories
    finalizedPoolCount: Int!                              # Number of finalized pools for all factories
}


type TokenValue @entity {

   token : Token!
   value : BigDecimal!

}


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

    factory: DatatokenFactory                             #

    creator: String                                       # TODO:
    publisher: String                                     # TODO:
    minter: String                                        # TODO:
    editor: String                                        # TODO:

    holderCount: BigInt                                   # Number of addresses holding a balance of datatoken
    orderCount: BigInt                                    # Number of orders executed for this datatoken

    createTime: Int                                       # Block time datatoken was created
    tx: Bytes                                             # Datatoken creation transaction id
    block: Int                                            # Block number when it was created
}

type Pool @entity {
    id: ID!                                             # Pool address
    poolFactory: PoolFactory!                           # Pool factory
    controller: Bytes!                                  # Controller address
    isPublicSwap: Boolean!                              # TODO : what is this?
    isFinalized: Boolean!                               # only finalized pools are relevant to us
    
    symbol: String                                      # Pool token symbol
    name: String                                        # Pool token name
    cap: BigInt                                         # Maximum supply if any
    isActive: Boolean!                                  # 
    swapFee: BigDecimal!                                # Swap Fees

    totalWeight: BigDecimal!                            # TODO: What is this?
    totalShares: BigDecimal!                            # Total pool token shares
    totalSwapVolume: BigDecimal!                        # Total swap volume in main token
    totalSwapFee: BigDecimal!                           # TODO: is this correct ? Total swap fee in main token 

    totalValueLocked: BigDecimal!                            # value locked in pool expressed in main token (captures both Ocean and Datatoken)

    spotPrice: BigDecimal!
    consumePrice: BigDecimal!                           # TODO: still need?

    // what is the point of the counts, we never used them => remove
    joinCount: BigInt!                                 # liquidity has been added
    exitCount: BigInt!                                 # liquidity has been removed
    swapCount: BigInt!
    transactionCount: BigInt!                          # Number of transactions in this pool involving liquidity changes
    
    // remove
    datatokenAddress: String!
   
    createTime: Int!                                    # Block time pool was created
    tx: Bytes                                           # Pool creation transaction id
    block

    tokens: [PoolToken!] @derivedFrom(field: "poolId")
    shares: [PoolShare!] @derivedFrom(field: "poolId")
    transactions: [PoolTransaction!] @derivedFrom(field: "pool")
}

//PoolToken - all good as it is

type PoolToken @entity {
    id: ID!                                             # poolId + token address
    pool: Pool!                                         # 
    isDatatoken: Boolean!                               # if the token is a datatoken , not sure if this makes sense since it is duplicate information found on token
    token: Token!
    balance: BigDecimal!                                # balance of the token in this pool
    denormWeight: BigDecimal!                       
    symbol: String                                      # should we keep this, it is found on token?
    name: String                                        # should we keep this, it is found on token?
    decimals: Int                                       # should we keep this, it is found on token?
}

type PoolShare @entity {
  id: ID!                                                 # poolId + userAddress
  user: User!
  pool: Pool!
  balance: BigDecimal!
}

// Will be replaced with a generic PoolTokenValue WIP


type PoolTransaction @entity {
  id: ID!                                                    # pool tx
  pool: Pool                                                 # Pool related to this tx
  user: User                                                 # User that initiates the swap

  sharesTransferAmount: BigDecimal!                          # Number of shares transfered
  sharesBalance: BigDecimal!                                 # TODO: what is this?


  tx: Bytes!
  event: String
  block: Int!
  timestamp: Int!
  gasUsed: BigDecimal!
  gasPrice: BigDecimal!

  tokens: [TokenValue!]                                      # tokens transfered 
}


type DatatokenFactory @entity {
  id: ID!
  tokenCount: Int! # Number of datatokens
  datatokens: [Tokens!] @derivedFrom(field: "factory")
}


type MetadataUpdate @entity {
  id: ID! # update tx +  datatokenAddress
  datatokenId: Datatoken!

  datatokenAddress: String!
  userAddress: String!

//all fields from the market edit
name 
description
author
links
timeout


  block: Int!
  timestamp: Int!
  tx: Bytes!
}

type Asset {

did
name 
description
author
services ? [ access, compute ] ?

datatoken : Datatoken
}



type TokenOrder @entity {
  id: ID! # datatokenId + userAddress + tx
  datatokenId: Datatoken!

  consumer: User!
  payer: User!
  amount: BigDecimal!
  serviceId: Int!
  marketFeeCollector: User
  marketFee: BigDecimal!

  timestamp: Int!
  tx: Bytes
  block: Int!
}

type TokenBalance @entity {
  id: ID! # datatokenId + userAddress
  userAddress: User!
  datatokenId: Datatoken!
  balance: BigDecimal!
}

type TokenTransaction @entity {
  id: ID! # Log ID
  event: String
  datatokenAddress: Datatoken
  userAddress: User

  block: Int!
  gasUsed: BigDecimal!
  gasPrice: BigDecimal!
  timestamp: Int!
  tx: Bytes!
}

type User @entity {
  id: ID!

  sharesOwned: [PoolShare!] @derivedFrom(field: "userAddress")
  tokenBalancesOwned: [TokenBalance!] @derivedFrom(field: "userAddress")
  tokensOwned: [Datatoken!] @derivedFrom(field: "minter")
  poolTransactions: [PoolTransaction!] @derivedFrom(field: "userAddress")
  poolTransactionsTokenValues: [PoolTransactionTokenValues!]
    @derivedFrom(field: "userAddress")
  tokenTransactions: [TokenTransaction!] @derivedFrom(field: "userAddress")
  orders: [TokenOrder!] @derivedFrom(field: "payer")
  freSwaps: [FixedRateExchangeSwap!] @derivedFrom(field: "by")
}

type FixedRateExchange @entity {
  id: ID! # fixed rate exchange id
  exchangeOwner: User!
  datatoken: Datatoken!
  // will be a token not just an address
  baseToken: String!
  // no need for this, since it will be on token
  baseTokenSymbol: String!
  rate: BigDecimal!
  active: Boolean!
  updates: [FixedRateExchangeUpdate!] @derivedFrom(field: "exchangeId")
  swaps: [FixedRateExchangeSwap!] @derivedFrom(field: "exchangeId")
}

type FixedRateExchangeUpdate @entity {
  id: ID!
  exchangeId: FixedRateExchange!
  oldRate: BigDecimal!
  newRate: BigDecimal!
  oldActive: Boolean!
  newActive: Boolean!
  block: Int!
  timestamp: Int!
  tx: Bytes!
}

type FixedRateExchangeSwap @entity {
  id: ID!
  exchangeId: FixedRateExchange!
  by: User!
  baseTokenAmount: BigDecimal!
  dataTokenAmount: BigDecimal!
  block: Int!
  timestamp: Int!
  tx: Bytes!
}

type Dispenser @entity {
  id: ID! # dispenser datatoken
  active: Boolean!
  owner: User!
  minterApproved: Boolean!
  isTrueMinter: Boolean!
  maxTokens: BigDecimal!
  maxBalance: BigDecimal!
  balance: BigDecimal!
  datatoken: Datatoken!
  dispenses: [DispenserTransaction!] @derivedFrom(field: "dispenserId")
}

type DispenserTransaction @entity {
  id: ID!
  dispenserId: Dispenser!
  datatoken: Datatoken!
  user: User!
  amount: BigDecimal!
  block: Int!
  timestamp: Int!
  tx: Bytes!
  type: String!
}


type PoolSnapshotTokenValue @entity {
  id: ID! # pool tx +  tokenAddress
  tokenAddress: String!
  value: BigDecimal!
  tokenReserve: BigDecimal!
  feeValue: BigDecimal! # Swap fee value in OCEAN
  type: String!
  poolSnapshot: PoolSnapshot! 
}


type PoolSnapshot @entity {
  id: ID!
  pool: Pool!
  totalShares: BigDecimal!
  swapVolume: BigDecimal!
  swapFees: BigDecimal!
  timestamp: Int!
  tokens: [PoolSnapshotTokenValue!] @derivedFrom(field: "poolSnapshot")
}