ocean-subgraph/schema.graphql

type PoolFactory @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
    totalSwapFee: [TokenValuePair]                        # 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 TokenValuePair @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
    factoryID --> poolFactory: PoolFactory!         
    controller: Bytes!                                  # Controller address
    publicSwap --> isPublicSwap: Boolean!                                # isPublicSwap
    finalized --> isFinalized: Boolean!                                  # isFinalized
    
    // will be able to change in v4, set by market or maybe by user
    symbol: String                                      # Pool token symbol
    // will be a user inputed name
    name: String                                        # Pool token name
    cap: BigInt                                         # Maximum supply if any
    active --> isActive: Boolean!                                    # isActive
    swapFee: BigDecimal!                                # Swap Fees

    totalWeight: BigDecimal!
    totalShares: BigDecimal!                            # Total pool token shares
    totalSwapVolume: BigDecimal!                        # Total swap volume in main token
    totalSwapFee: BigDecimal!                           # Total swap fee in main token

    valueLocked: BigDecimal!                            # value locked in pool expressed in main token (captures both Ocean and Datatoken)
    //will be on token
    datatokenReserve: BigDecimal!                       # Total pool reserve of Datatoken
    // will be on token
    mainTokenReserve: BigDecimal!                       # Total pool reserve of main token

    spotPrice: BigDecimal!
    consumePrice: BigDecimal!

    // remove
    tokenCount: BigInt!                                # Number of tokens in the pool
    // remove
    holderCount: BigInt!                               # Number of addresses holding a positive balance of pool shares

    // 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: "poolAddress")
    //this doesn't make sens, probably here because we had to link to pool
    transactionsTokenValues: [PoolTransactionTokenValues!] @derivedFrom(field: "poolAddress")
}





//PoolToken - all good as it is

type PoolToken @entity {
    id: ID!                                             # poolId + token address
    // can be on multiple pools, should remove
    poolId: Pool!
    isDatatoken: Boolean!
    address: String
    tokenId: Datatoken
    tokenAddress: String
    balance: BigDecimal!
    denormWeight: BigDecimal!
    symbol: String
    name: String
    decimals: Int
}

// not sure if we should keep both PoolToken and Datatoken
type Datatoken @entity {
    id: ID!                                             # token address
    factoryID: DatatokenFactory!

    symbol: String
    name: String
    decimals: Int!
    address: String!
    cap: BigDecimal!
    supply: BigDecimal!
    minter: String!
    publisher: String!

    // do we care about this?
    holderCount: BigInt!                               # Number of addresses holding a balance of datatoken
    orderCount: BigInt!                                 # Number of orders executed for this dataset

    // remove, doesn't make any sense, especially in v4
    metadataUpdateCount: BigInt!
    
    // array 
    orderVolume: BigDecimal
    createTime: Int!                                    # Block time datatoken was created
    tx: Bytes                                           # Datatoken creation transaction id

    balances: [TokenBalance!] @derivedFrom(field: "datatokenId")
    orders: [TokenOrder!] @derivedFrom(field: "datatokenId")
    updates: [MetadataUpdate!] @derivedFrom(field: "datatokenId")  # list of MetadataUpdate objects
}

// if we have 2 ,we can check if union works
union Token = PoolToken | Datatoken


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

// Will be replaced with a generic PoolTokenValue WIP

type PoolTransactionTokenValues @entity {
  id: ID! # pool tx +  tokenAddress
  txId: PoolTransaction!

  // should be an array of PoolToken
  poolToken: PoolToken!
  // not sure if needed
  poolAddress: Pool!
  //not sure if needed
  userAddress: User!

  // we will have the poolToken array, what will this be?
  tokenAddress: String!

  // value of what?
  value: BigDecimal!

  // should be an array if we keep this
  tokenReserve: BigDecimal!
  feeValue: BigDecimal! # Swap fee value in OCEAN
  type: String!
}

type PoolTransaction @entity {
  id: ID! # pool tx
  poolAddress --> pool: Pool
  userAddress --> user: User                                                         # User address that initiates the swap
  poolAddressStr --> poolAddress: String!
  userAddressStr --> userAddress: String!

  sharesTransferAmount: BigDecimal! #
  sharesBalance: BigDecimal!

  spotPrice: BigDecimal!
  // should not be here
  consumePrice: BigDecimal!
  tx: Bytes!
  event: String
  block: Int!
  timestamp: Int!
  gasUsed: BigDecimal!
  gasPrice: BigDecimal!

// should be an array, we will not have only ocean, it will be the tokens array
  oceanReserve: BigDecimal!
  datatokenReserve: BigDecimal!

  tokens: [PoolTransactionTokenValues!] @derivedFrom(field: "txId")
}


// we will have 2 dt factories ?
type DatatokenFactory @entity {
  id: ID!

  tokenCount: Int! # Number of datatokens
  datatokens: [Datatoken!] @derivedFrom(field: "factoryID")
}


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!
}