ocean-subgraph/schema.graphql

type Token @entity {
    id: ID!                                               # 
    symbol: String                                        #
    name: String                                          #
    decimals: Int!                                        #
    address: String!                                      #
    cap: BigDecimal                                       #
    supply: BigDecimal                                    #
    isDatatoken: Boolean!                                 #
    
    owner: String                                         # address of ERC721 that owns the token, valid only for datatokens
    minter: [User!]                                       # array of addresses with minter role, can be user wallet address, dispenser etc.
    feeManager: String                                    # TODO: maybe we change name , depends on audit results . It's the address that collects the payments (NOT fees)
    publishMarketFeeAddress: String                       # address of the market where the datatoken was created. This address collects market fees.
    publishMarketFeeToken: String                         # adreess of fee token (can be Ocean, ETH, etc.)
    publishMarketFeeAmmount: BigDecimal                   # fee amount. Fixed value, expressed in wei in contracts, needs conversion in decimals.                     
    templateId: Int                                       # template ID of the datatoken
    
    holderCount: BigInt                                   # Number of addresses holding a balance of datatoken , TODO: can we actually calculate this? what happens when users trade the dts
    orderCount: BigInt                                    # Number of orders executed for this datatoken

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

type TokenValuePair @entity {
   id : ID!
   token : Token!
   value : BigDecimal!
}

type Nft @entity{
    id: ID!                                                # nft address
    symbol: String!                                        #
    name: String!                                          #
    tokenUri: String!                                      #
    owner: String!                                         # owner of the nft
    address: String!                                       #
    providerUrl: String                                    # provider url that can decrypt the ddo 
    assetState: Int!                                       # state of the asset (described in docs)

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

    template: String!                                       # template address
    createdTimestamp: Int!                                        # Block time pool was created
    tx: Bytes                                               # Pool creation transaction id
    block: Int                                              # Block number when it was created
}

type Pool @entity {
    id: ID!                                                 # Pool address
    owner: String!                                          # Owner address, pool controller

    isPublicSwap: Boolean!                                  # if swap/trade is activated, probably always true
    isFinalized: Boolean!                                   # only finalized pools are relevant to us
    
    symbol: String                                          # Pool token symbol
    name: String                                            # Pool token name
    cap: BigDecimal                                         # Maximum supply if any, converted from wei
    isActive: Boolean!                                      # pool is active

    baseToken: PoolToken! @derivedFrom(field: "pool")
    datatoken: PoolToken! @derivedFrom(field: "pool")
    poolFee: BigDecimal!                                    # Pool Fee percent, fee goes to all liquidity providers : SWAP, JOIN , EXIT
    opfFee: BigDecimal!                                     # OPF Fee percent, fee that goes to Ocean Protocol Foundation : SWAP
    marketFee: BigDecimal!                                  # Market fee percent, fee that goes to the market where the pool was created : SWAP
    totalPoolFee: [TokenValuePair!]!                            # actual value of fee collected in both tokens
    totalOpfFee: [TokenValuePair!]!                             # actual value of fee collected in both tokens
    totalMarketFee: [TokenValuePair!]!                          # actual value of fee collected in both tokens  

    currentOpfFee: [TokenValuePair!]!                           # fee after collection totalFee - colectedFee
    currentMarketFee: [TokenValuePair!]!                        # fee after collection totalFee - colectedFee  

    totalWeight: BigDecimal!                                # it's always 100 
    totalShares: BigDecimal!                                # Total pool token shares
    totalSwapVolume: [TokenValuePair!]!                         # total tokens that were swaped

    spotPrice: BigDecimal!                                  # spot price

    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
   
    createdTimestamp: Int!                                        # Block time pool was created
    tx: Bytes                                               # Pool creation transaction id
    block: Int                                              # Block number when it was created

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

# should not pe @entity
type PoolToken @entity {
    id: ID!                                                 # poolId + token address
    pool: Pool!                                             # 
    token: Token!
    balance: BigDecimal!                                    # balance of the token in this pool
    denormWeight: BigDecimal!                               # weight of token in the pool (50% for our pools)
}

# we will need to track pool share tx between users -  bpool transfer tx event
type PoolShare @entity {
  id: ID!                                                   # poolId + userAddress
  user: User!
  pool: Pool!
  balance: BigDecimal!
}


type PoolTransaction @entity {
  id: ID!                                                    # tx + caller
  pool: Pool!                                                # Pool related to this tx
  user: User!                                                # User that initiates the tx
  type: Int                                                  # 0 - JOIN, 1 - EXIT , 2 - SWAP, maybe change to enum
  
  sharesTransferAmount: BigDecimal                           # Number of shares transfered
 
  poolFee: BigDecimal!                                       # Pool Fee percent, fee goes to all liquidity providers : SWAP, JOIN , EXIT
  opfFee: BigDecimal!                                        # OPF Fee percent, fee that goes to Ocean Protocol Foundation : SWAP
  marketFee: BigDecimal!  
  
  event: String                                              # TODO: what is this?

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

  gasLimit: BigDecimal!                                      
  gasPrice: BigDecimal!                                      # in eth

  # change to baseToken and dataToken
  baseToken: TokenValuePair                               # tokens transfered , if value is negative it means it was removed, 
  datatoken: TokenValuePair
}

type Order @entity {                                         # renamed from TokenOrder to Order
  id: ID!                                                    # datatokenId + userAddress + tx
  token: Token!

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


  # the fees will be updated from an event that will be created after (todo)
  publishingMarketAddress: User
  publishingMarketToken: Token                                #
  publishingMarketAmmount: BigDecimal                         #call contract to get fee ammount

  consumerMarketAddress: User
  consumerMarketToken: Token                                  #
  consumerMarketAmmount: BigDecimal                           #call contract to get fee ammount

  createdTimestamp: Int!
  tx: Bytes
  block: Int!
}

# to be removed, mabye for pool shares only 
type TokenTransaction @entity {
  id: ID! # Log ID
  event: String
  token: Token
  user: User

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

type User @entity {
  id: ID!
  sharesOwned: [PoolShare!] @derivedFrom(field: "user")
  tokenBalancesOwned: [TokenValuePair!]
  tokensOwned: [Token!] @derivedFrom(field: "minter")
  poolTransactions: [PoolTransaction!] @derivedFrom(field: "user")
  orders: [Order!] @derivedFrom(field: "payer")
  freSwaps: [FixedRateExchangeSwap!] @derivedFrom(field: "by")
}

type FixedRateExchange @entity {
  id: ID!                                                    # fixed rate exchange id
  owner: User!
  datatoken: Token!
  baseToken: Token!
  price: BigDecimal!
  active: Boolean!
  totalSwapValue: BigDecimal!                                # amount of total basetokens spent
  allowedSwapper: String                                     # address that is allowed to  swap tokens
  supply: BigInt!
  withMint: Boolean                                          # if the owner allowes the fre to mint
  isMinter: Boolean                                          # if the fre has the minter role on the datatoken 

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

  createdTimestamp: Int!
  tx: Bytes
  block: Int!
}

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

  oldPrice: BigDecimal
  newPrice: BigDecimal

  oldActive: Boolean
  newActive: Boolean

  oldAllowedSwapper: String
  newAllowedSwapper: String

  block: Int!
  createdTimestamp: Int!
  tx: Bytes!
}

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

# since in the template that we will use minterApproved is sort of "bundled" with isTrueMinter i think we should have only one field here to easily check if dispenser cand mint

type Dispenser @entity {
  id: ID!                                                      # it's the datatoken address
  active: Boolean!                            
  owner: User!
  datatoken: Token!

  allowedSwapper: String
  isMinter: Boolean                                            # if the fre has the minter role on the datatoken 
  maxTokens: BigDecimal!                                       # max tokens that can be dispensed
  maxBalance: BigDecimal!                                      # max balance of requester. If the balance is higher, the dispense is rejected
  balance: BigDecimal!                                         # how many tokens are left
  
  dispenses: [DispenserTransaction!] @derivedFrom(field: "dispenser")
}

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

  block: Int!
  createdTimestamp: Int!
  tx: Bytes!
}

type PoolSnapshot @entity {
  id: ID!
  pool: Pool!
  totalShares: BigDecimal!
  swapVolume: BigDecimal!                                             # swap value 24h
  swapFees: BigDecimal!                                               # swap fee value 24h  
  createdTimestamp: Int!                                                     # date without time
  spotPrice: BigDecimal!                                              # TODO: last spot price or first one?
  tokens: [PoolSnapshotTokenValue!] @derivedFrom(field: "poolSnapshot")
}

type PoolSnapshotTokenValue @entity {
  id: ID!                                                            # pool tx +  tokenAddress
  token: Token!
  value: BigDecimal!                                            
  tokenReserve: BigDecimal!                                          # how many tokens are left in pool
  poolSnapshot: PoolSnapshot! 
}

type Global @entity {
    id: ID!

    totalValueLocked: [TokenValuePair!]                      # total value locked represented in the base token , basically 2x liqudity for each base token
    totalLiquidity: [TokenValuePair!]                        # total liquidity for each base token 
    totalSwapVolume: [TokenValuePair!]                       # total swap volume for each base token. pools and fre             
     
    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
    totalOrderVolume: BigDecimal                            # probably remove due to inconsistencies and imposibility to calculate
}


type MetadataUpdate @entity {
  id: ID! # update tx +  datatokenAddress
  datatoken: Token!

  datatokenAddress: String!
  userAddress: String!

  block: Int!
  createdTimestamp: Int!
  tx: Bytes!
}