schema.graphql

"""
The Comptroller type has protocol level variables stored
"""
type Comptroller @entity {
  "ID is set to 1"
  id: ID!
  "Oracle which gives the price of any given asset"
  priceOracle: String!
  "The percent, ranging from 0% to 100%, of a liquidatable account's borrow that can be repaid in a single liquidate transaction"
  closeFactor: BigDecimal!
  "The percent bonus liquidators get for liquidating. If the liquidation incentive is 1.1, liquidators receive an extra 10% of the borrowers collateral for every unit they close."
  liquidationIncentive: BigDecimal!
  "Listed markets"
  _markets: [Market!]!
}

"""
Market stores all high level variables for a cToken market
"""
type Market @entity {
  "CToken address"
  id: ID!

  "Array of AccountCTokens related to this market"
  accountCTokens: [AccountCToken!]! @derivedFrom(field: "market")

  "Name of the cToken"
  name: String!

  "CToken symbol"
  symbol: String!

  "Underlying token address"
  underlyingAddress: String!

  "Underlying token name"
  underlyingName: String!

  "Underlying price of token in ETH (ex. 0.007 DAI)"
  underlyingPrice: BigDecimal!

  "Underlying token symbol"
  underlyingSymbol: String!

  "Underlying token price in USD"
  underlyingPriceUSD: BigDecimal!

  "Underlying token decimal length"
  underlyingDecimals: Int!

  "Borrows in the market"
  totalBorrows: BigDecimal!

  "CToken supply."
  totalSupply: BigDecimal!

  "Bad debt."
  badDebt: BigDecimal!

  "Reserves stored in the contract"
  reserves: BigDecimal!

  "The cToken contract balance of ERC20 or ETH"
  cash: BigDecimal!

  "Yearly supply rate."
  supplyRate: BigDecimal!

  "Yearly borrow rate."
  borrowRate: BigDecimal!

  "Collateral factor determining how much one can borrow"
  collateralFactor: BigDecimal!

  "Exchange rate of tokens / cTokens"
  exchangeRate: BigDecimal!

  "The history of the markets borrow index return (Think S&P 500)"
  borrowIndex: BigInt!

  borrowCap: BigInt!

  "The factor determining interest that goes to reserves"
  reserveFactor: BigInt!

  "Block the market is updated to"
  accrualBlockTimestamp: Int!

  "Timestamp the market was most recently updated"
  blockTimestamp: Int!

  "Address of the interest rate model"
  interestRateModelAddress: String!

  borrowerCount: Int!
  supplierCount: Int!

  mintPaused: Boolean!
  borrowPaused: Boolean!

  " Price feed address "
  _feed: String!
}

"""
Account is an ETH address, with a list of all cToken markets the account has
participated in, along with liquidation information.
"""
type Account @entity {
  "User ETH address"
  id: ID!
  "Array of CTokens user is in"
  tokens: [AccountCToken!]! @derivedFrom(field: "account")
  "Count user has been liquidated"
  countLiquidated: Int!
  "Count user has liquidated others"
  countLiquidator: Int!
  "True if user has ever borrowed"
  hasBorrowed: Boolean!
}

"""
AccountCToken is a single account within a single cToken market, with data such
as interest earned or paid
"""
type AccountCToken @entity {
  "Concatenation of CToken address and user address"
  id: ID!
  "Relation to market"
  market: Market!
  "Symbol of the cToken"
  symbol: String!
  "Relation to user"
  account: Account!
  "Transactions data"
  transactions: [AccountCTokenTransaction!]! @derivedFrom(field: "account")
  "Block number this asset was updated at in the contract"
  accrualBlockNumber: BigInt!
  "True if user is entered, false if they are exited"
  enteredMarket: Boolean!

  "CToken balance of the user"
  cTokenBalance: BigDecimal!
  "Total amount of underlying supplied"
  totalUnderlyingSupplied: BigDecimal!
  "Total amount of underling redeemed"
  totalUnderlyingRedeemed: BigDecimal!
  "The value of the borrow index upon users last interaction"
  accountBorrowIndex: BigInt!
  "Total amount underlying borrowed, exclusive of interest"
  totalUnderlyingBorrowed: BigDecimal!
  "Total amount underlying repaid"
  totalUnderlyingRepaid: BigDecimal!
  "Current borrow balance stored in contract (exclusive of interest since accrualBlockNumber)"
  storedBorrowBalance: BigDecimal!
}

"""
Auxiliary entity for AccountCToken
"""
type AccountCTokenTransaction @entity {
  id: ID!

  account: AccountCToken!

  tx_hash: String!

  timestamp: BigInt!

  block: BigInt!

  logIndex: BigInt!
}

type Governor @entity {
  id: ID!
  proposalCount: Int!
  quorumVotes: BigInt!
  proposalThreshold: BigInt!
  votingDelay: Int!
  proposalMaxOperations: Int!
  votingPeriod: Int!
  breakGlassGuardian: Bytes!
}

type Proposal @entity {
  # proposal id
  id: ID!
  # add this because we want to support range query by proposal id, and the `id` field doesn't support this as it is String
  proposalID: Int!
  proposer: Proposer!
  targets: [Bytes!]!
  values: [BigInt!]!
  signatures: [String!]!
  calldatas: [Bytes!]!
  startTimestamp: BigInt!
  endTimestamp: BigInt!
  startBlock: BigInt!
  canceled: Boolean!
  executed: Boolean!
  forVotes: BigInt!
  againstVotes: BigInt!
  abstainVotes: BigInt!
  totalVotes: BigInt!
  description: String!
  stateChanges: [ProposalStateChange!]! @derivedFrom(field: "proposal")
}

enum ProposalState {
  CREATED
  CANCELED
  EXECUTED
  QUEUED
}

type ProposalStateChange @entity {
  # {txn hash}-{log index}
  id: ID!
  proposal: Proposal!
  txnHash: Bytes!
  blockNumber: BigInt!
  newState: ProposalState!
  queueEta: BigInt # only set this field when newState == QUEUED
}

type Vote @entity {
  # {txn hash}-{log index}
  id: ID!
  txnHash: Bytes!
  blockNumber: BigInt!
  voter: Voter!
  proposal: Proposal!
  voteValue: Int!
  votes: BigInt!
}

type Proposer @entity {
  id: ID!
  proposals: [Proposal!]! @derivedFrom(field: "proposer")
}

type Voter @entity {
  id: ID!
  votes: [Vote!]! @derivedFrom(field: "voter")
}

"""
An interface for a transfer of any cToken. TransferEvent, MintEvent,
RedeemEvent, and LiquidationEvent all use this interface
"""
interface CTokenTransfer {
  "Transaction hash concatenated with log index"
  id: ID!
  "cTokens transferred"
  amount: BigDecimal!
  "Account that received tokens"
  to: String!
  "Account that sent tokens"
  from: String!
  "Block number"
  blockNumber: Int!
  "Block time"
  blockTime: Int!
  "Symbol of the cToken transferred"
  cTokenSymbol: String!
}

"""
TransferEvent will be stored for every mint, redeem, liquidation, and any normal
transfer between two accounts.
"""
type TransferEvent implements CTokenTransfer @entity {
  "Transaction hash concatenated with log index"
  id: ID!
  "cTokens transferred"
  amount: BigDecimal!
  "Account that received tokens"
  to: String!
  "Account that sent tokens"
  from: String!
  "Block number"
  blockNumber: Int!
  "Block time"
  blockTime: Int!
  "Symbol of the cToken transferred"
  cTokenSymbol: String!
  "Underlying symbol of the cToken transferred"
  underlyingSymbol: String!
}

"""
MintEvent stores information for mints. From address will always be a cToken
market address
"""
type MintEvent implements CTokenTransfer @entity {
  "Transaction hash concatenated with log index"
  id: ID!
  "cTokens transferred"
  amount: BigDecimal!
  "Account that received tokens (minter)"
  to: String!
  "Account that sent tokens (CToken contract)"
  from: String!
  "Block number"
  blockNumber: Int!
  "Block time"
  blockTime: Int!
  "Symbol of the cToken transferred"
  cTokenSymbol: String!
  "Underlying symbol of the cToken transferred"
  underlyingSymbol: String!
  "Underlying token amount transferred"
  underlyingAmount: BigDecimal
}

"""
RedeemEvent stores information for redeems. To address will always be a
cToken market address
"""
type RedeemEvent implements CTokenTransfer @entity {
  "Transaction hash concatenated with log index"
  id: ID!
  "cTokens transferred"
  amount: BigDecimal!
  "Account that received tokens (CToken contract)"
  to: String!
  "Account that sent tokens (redeemer)"
  from: String!
  "Block number"
  blockNumber: Int!
  "Block time"
  blockTime: Int!
  "Symbol of the cToken transferred"
  cTokenSymbol: String!
  "Underlying symbol of the cToken transferred"
  underlyingSymbol: String!
  "Underlying token amount transferred"
  underlyingAmount: BigDecimal
}

"""
LiquidationEvent stores information for liquidations. The event is emitted from
the cToken market address.
"""
type LiquidationEvent implements CTokenTransfer @entity {
  "Transaction hash concatenated with log index"
  id: ID!
  "cTokens seized"
  amount: BigDecimal!
  "Liquidator receiving tokens"
  to: String!
  "Account being liquidated (borrower)"
  from: String!
  "Block number"
  blockNumber: Int!
  "Block time"
  blockTime: Int!
  "cToken that was sezied as collateral"
  cTokenSymbol: String!
  "Symbol of the underlying asset repaid through liquidation"
  underlyingSymbol: String!
  "Underlying cToken amount that was repaid by liquidator"
  underlyingRepayAmount: BigDecimal!
}

"""
Underlying transfers are transfers of underlying collateral for both borrows
and repays
"""
interface UnderlyingTransfer {
  "Transaction hash concatenated with log index"
  id: ID!
  "Amount of underlying borrowed"
  amount: BigDecimal!
  "Total borrows of this asset the account has"
  accountBorrows: BigDecimal!
  "Account that borrowed the tokens"
  borrower: String!
  "Block number"
  blockNumber: Int!
  "Block time"
  blockTime: Int!
  "Symbol of the borrowed underlying asset"
  underlyingSymbol: String!
}

"""
BorrowEvent stores information for borrows
"""
type BorrowEvent implements UnderlyingTransfer @entity {
  "Transaction hash concatenated with log index"
  id: ID!
  "Amount of underlying borrowed"
  amount: BigDecimal!
  "Total borrows of this asset the account has"
  accountBorrows: BigDecimal!
  "Account that borrowed the tokens"
  borrower: String!
  "Block number"
  blockNumber: Int!
  "Block time"
  blockTime: Int!
  "Symbol of the borrowed underlying asset"
  underlyingSymbol: String!
}

"""
RepayEvent stores information for repays. Payer is not always the same as
borrower, such as in the event of a Liquidation
"""
type RepayEvent implements UnderlyingTransfer @entity {
  "Transaction hash concatenated with log index"
  id: ID!
  "Amount of underlying repaid"
  amount: BigDecimal!
  "Total borrows of this asset the account has"
  accountBorrows: BigDecimal!
  "Account that borrowed the tokens"
  borrower: String!
  "Block number"
  blockNumber: Int!
  "Block time"
  blockTime: Int!
  "Symbol of the borrowed underlying asset"
  underlyingSymbol: String!
  "Payer of the borrow funds"
  payer: String!
}

type MarketDailySnapshot @entity {
  " {market smart contract address}-{epoch days} "
  id: ID!
  market: Market!

  totalBorrows: BigDecimal!
  totalSupplies: BigDecimal!
  totalBorrowsUSD: BigDecimal!
  totalSuppliesUSD: BigDecimal!
}

type AccountCTokenDailySnapshot @entity {
  " {accountID}-{marketID}-{epoch days} "
  id: ID!
  account: Account!
  market: Market!

  totalBorrows: BigDecimal!
  totalSupplies: BigDecimal!
  totalBorrowsUSD: BigDecimal!
  totalSuppliesUSD: BigDecimal!
  collateralFactor: BigDecimal!
  collateralValueUSD: BigDecimal!
}

type AccountDailySnapshot @entity {
  " {accountID}-{epoch days} "
  id: ID!
  account: Account!

  totalBorrowsUSD: BigDecimal!
  totalSuppliesUSD: BigDecimal!
  collateralValueUSD: BigDecimal!
}

type StakingDailySnapshot @entity {
  " {staking smart contract address}-{epoch days} "
  id: ID!

  stakedToken: String!
  totalStaked: BigDecimal!
  totalStakedUSD: BigDecimal!
}