schema.graphql

type SwaapProtocol @entity {
    id: ID!
    poolCount: Int!                                     # Number of pools
    finalizedPoolCount: Int!                            # Number of finalized pools
    crpCount: Int!                                      # Number of CRP
    pools: [Pool!] @derivedFrom(field: "factoryID")
    txCount: BigInt!                                    # Number of txs
    totalLiquidity: BigDecimal!                         # All the pools liquidity value in USD
    totalSwapVolume: BigDecimal!                        # All the swap volume in USD
    totalSwapFee: BigDecimal!                           # All the swap fee in USD
}

type Pool @entity {
    id: ID!                                             # Pool address
    controller: Bytes!                                  # Controller address
    publicSwap: Boolean!                                # isPublicSwap
    finalized: Boolean!                                 # isFinalized
    crp: Boolean!                                       # Is configurable rights pool
    crpController: Bytes                                # CRP controller address
    symbol: String                                      # Pool token symbol
    name: String                                        # Pool token name
    rights: [String!]!                                  # List of rights (for CRP)
    cap: BigInt                                         # Maximum supply if any (for CRP)
    active: Boolean!                                    # isActive
    swapFee: BigDecimal!                                # Swap Fees
    totalWeight: BigDecimal!
    totalShares: BigDecimal!                            # Total pool token shares
    totalSwapVolume: BigDecimal!                        # Total swap volume in USD
    totalSwapFee: BigDecimal!                           # Total swap fee in USD
    liquidity: BigDecimal!                              # Pool liquidity value in USD
    tokensList: [Bytes!]!                               # Temp workaround until graph supports filtering on derived field
    tokens: [PoolToken!] @derivedFrom(field: "poolId")
    shares: [PoolShare!] @derivedFrom(field: "poolId")
    createTime: Int!                                    # Block time pool was created
    tokensCount: BigInt!                                # Number of tokens in the pool
    holdersCount: BigInt!                               # Number of addresses holding a positive balance of SPT
    joinsCount: BigInt!                                 # liquidity has been added
    exitsCount: BigInt!                                 # liquidity has been removed
    swapsCount: BigInt!
    factoryID: SwaapProtocol!
    tx: Bytes                                           # Pool creation transaction id
    swaps: [Swap!] @derivedFrom(field: "poolAddress")
    dailyActivity: DailyActivity
    priceStatisticsLookbackInRound: Int!
    priceStatisticsLookbackStepInRound: Int!
    dynamicCoverageFeesZ: BigDecimal!
    dynamicCoverageFeesHorizon: BigDecimal!
    priceStatisticsLookbackInSec: BigInt!
    maxPriceUnpegRatio: BigDecimal!
    initialShares: BigDecimal!
    initialTokensBalance: [PoolTokenBalance!] @derivedFrom(field: "poolId")
    lpTokenPrices: [LPTokenPrice!] @derivedFrom(field: "poolId")
}

type PoolToken @entity {
    id: ID!                              # poolId + token address
    poolId: Pool!
    symbol: String
    name: String
    decimals: Int!
    address: String!
    balance: BigDecimal!
    denormWeight: BigDecimal!
    oracleInitialState: PoolOracleState!
}

type LPTokenPrice @entity {
    id: ID!              # poolId-$key ('initial' or 'current')
    poolId: Pool!        # poolId
    price: BigDecimal!
}

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

type User @entity {
    id: ID!
    sharesOwned: [PoolShare!]  @derivedFrom(field: "userAddress")
    txs: [Transaction!]  @derivedFrom(field: "userAddress")
    swaps: [Swap!]  @derivedFrom(field: "userAddress")
}

type Swap @entity {
    id: ID!                                 #
    caller: Bytes!                          #
    tokenIn: Bytes!                         #
    tokenInSym: String!                     #
    tokenOut: Bytes!                        #
    tokenOutSym: String!                    #
    tokenAmountIn: BigDecimal!              #
    tokenAmountOut: BigDecimal!             #
    poolAddress: Pool
    userAddress: User                       # User address that initiates the swap
    value: BigDecimal!                      # Swap value in USD
    spread: BigDecimal!                     # Parameter modifying the final fees
    taxBaseIn: BigDecimal!                  # TokenIn tax base
    feeValue: BigDecimal!                   # Swap fee value in USD, from feeValue, spread, poolFees
    poolTotalSwapVolume: BigDecimal!        # Total pool swap volume in USD
    poolTotalSwapFee: BigDecimal!           # Total pool swap fee in USD
    poolLiquidity: BigDecimal!              # Pool liquidity value in USD
    timestamp: Int!
}

type Transaction @entity {
    id: ID!                         # Log ID
    tx: Bytes!
    event: String
    block: Int!
    timestamp: Int!
    gasUsed: BigDecimal!
    gasPrice: BigDecimal!
    poolAddress: Pool
    userAddress: User
    action: SwapType
    sender: Bytes
}

type TokenPrice @entity {
    id: ID!             # token address + oracle address
    symbol: String
    name: String
    decimals: Int!
    price: BigDecimal!
    poolTokenId: String
}

enum SwapType {
    swapExactAmountIn,
    swapExactAmountOut,
    joinswapExternAmountIn,
    joinswapPoolAmountOut,
    exitswapPoolAmountIn,
    exitswapExternAmountOut
}


type DailyActivity @entity{
    id: ID!
    poolAddress: Pool!
    dailyFees: BigDecimal!
    dailyVolume: BigDecimal!
    swapCount:Int!
    todayTimestamps: [Int!]!
    todayFees: [BigDecimal!]!
    todayVolumes: [BigDecimal!]!
    yesterdayTimestamps: [Int!]!
    yesterdayFees: [BigDecimal!]!
    yesterdayVolumes: [BigDecimal!]!
    last: Int!
}

type PoolOracleState @entity {
    id: ID!                  # poolId + token address
    proxy: String!
    description: String!
    fixedPointPrice: BigInt!
    decimals: Int!
    poolToken: PoolToken!    @derivedFrom(field: "oracleInitialState")
}

type PoolTokenBalance @entity {
    id: ID!                  # poolId + token address
    poolId: Pool!
    balance: BigDecimal!
}