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"
    owner: String    

    "array of addresses with minter role, can be user wallet address, dispenser etc."                                 
    minter: [User!] 

    "TODO: maybe we change name , depends on audit results . It's the address that collects the payments (NOT fees)"                                      
    feeManager: 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, expressed in wei in contracts, needs conversion in decimals."             
    publishMarketFeeAmmount: 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                                    

    "block time datatoken was created"
    createdTimestamp: Int        

    "datatoken creation transaction id"                         
    tx: Bytes        

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

"utility type"
type TokenValuePair @entity {
   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: String!     

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


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

type Pool @entity {
    "pool address"
    id: ID!    

    "owner address, pool controller"                                   
    owner: String!

    "only finalized pools are relevant to us"                             
    isFinalized: Boolean!                                   
    
    "pool token symbol"
    symbol: String      

    "pool token name"                                    
    name: String    

    "maximum supply if any, converted from wei"                                        
    cap: BigDecimal                                              

    baseToken: PoolToken! 
    datatoken: PoolToken!

    "pool Fee percent, fee goes to all liquidity providers : SWAP, JOIN , EXIT"
    poolFee: BigDecimal! 

    "OPF Fee percent, fee that goes to Ocean Protocol Foundation : SWAP"                                    
    opfFee: BigDecimal!   

    "market fee percent, fee that goes to the market where the pool was created : SWAP"                                  
    marketFee: BigDecimal!     

    "actual value of fee collected in both tokens"                             
    totalPoolFee: [TokenValuePair!]!  

    "actual value of fee collected in both tokens"                          
    totalOpfFee: [TokenValuePair!]!   

    "actual value of fee collected in both tokens"                          
    totalMarketFee: [TokenValuePair!]!                            

    "fee after collection =  totalFee - colectedFee"
    availableOpfFee: [TokenValuePair!]!     

    "fee after collection totalFee - colectedFee"                      
    availableMarketFee: [TokenValuePair!]!                        

    "total pool token shares"                           
    totalShares: BigDecimal!   

    "total tokens that were swaped"                             
    totalSwapVolume: [TokenValuePair!]!                         

    spotPrice: BigDecimal!                                  

    "count for when liquidity has been added"
    joinCount: BigInt!             

    "count for when liquidity has been removed"                     
    exitCount: BigInt!              

    "count for when tokens were swapped"                             
    swapCount: BigInt!

    "number of transactions in this pool involving liquidity changes"
    transactionCount: BigInt!                               
   
    "block time when pool was created"
    createdTimestamp: Int!      
    "pool creation transaction id"                            
    tx: Bytes    
    "block number when it was created"                                          
    block: Int                                              

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

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

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

 enum PoolTransactionType {
  JOIN,
  EXIT,
  SWAP,
  SETUP
}

type PoolTransaction @entity {
  "tx address + caller address" 
  id: ID!        
  "pool related to this tx"                                            
  pool: Pool!   
  "user that initiates the tx"                                             
  user: User!                                              
  type: PoolTransactionType                                                  
  
  "number of shares transfered"
  sharesTransferAmount: BigDecimal                           
 
  "pool fee percent, fee goes to all liquidity providers : SWAP, JOIN , EXIT"
  poolFee: BigDecimal!     

  "OPF Fee percent, fee that goes to Ocean Protocol Foundation : SWAP"                                  
  opfFee: BigDecimal!        

  "fee that goes to the publishing market"                                
  marketFee: BigDecimal!  

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

  gasLimit: BigDecimal!  
  "price expressed in eth"                                    
  gasPrice: BigDecimal!                                      

  "base tokens transfered"
  baseToken: TokenValuePair 

  "number of tokens transfered"       
  baseTokenValue: BigDecimal

  "datatokens transfered , if value is negative it means it was removed"                        
  datatoken: TokenValuePair

  "number of tokens transfered, if value is negative it means it was removed"
  datatokenValue: BigDecimal
}

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: [PoolShares!] @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 {
  "fixed rate exchange id"
  id: ID!                                                    
  owner: User!
  datatoken: Token!
  baseToken: Token!
  price: BigDecimal!
  active: Boolean!
  "amount of total basetokens spent"
  totalSwapValue: BigDecimal!  
  "address that is allowed to  swap tokens"                              
  allowedSwapper: String                                     
  supply: BigInt!
  "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: 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!
}


type Dispenser @entity {
  "datatoken address"
  id: ID!                                                      
  active: Boolean!                            
  owner: User!
  datatoken: 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!                                         
  
  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!
  "swap value 24h"
  swapVolume: BigDecimal!   
  "swap fee value 24h"                                          
  swapFees: BigDecimal! 
  "date without time"                                              
  createdTimestamp: Int!                                          
  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 GlobalStats @entity {
    id: ID!

    "total value locked represented in the base token , basically 2x liqudity for each base token"
    totalValueLocked: [TokenValuePair!]    
    "total liquidity for each base token"                  
    totalLiquidity: [TokenValuePair!]                        
    "total swap volume for each base token. pools and fre"
    totalSwapVolume: [TokenValuePair!]                                
     
    "number of total consumes, pools + fre"
    orderCount: BigInt                                     

    "number of pools for all factories"
    poolCount: Int!       
    "number of finalized pools for all factories"                                  
    finalizedPoolCount: Int!                   
    "probably remove due to inconsistencies and imposibility to calculate"             
    totalOrderVolume: BigDecimal                            
}


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

  datatokenAddress: String!
  userAddress: String!

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