schema.graphql

# -------------
# Actions
# -------------

enum ActionType {
  Buy
  Sell
  Resell
  Mint
  Unmint
  AddLiquidity
  RemoveLiquidity
  Exercise
  Withdraw
  TransferFrom
  TransferTo
}

enum FeePoolType {
  A
  B
}

# -------------
# Elements
# -------------

type Metadata @entity {
  id: ID!
  optionsMintedAndSold: BigInt
  feeA: Fee
  feeB: Fee
}

type Action @entity {
  "unique identifier resolving to the hash of the transaction (custom suffix for TransferFrom)"
  id: ID!
  "enum describing the type of transaction (e.g. Buy, Sell)"
  type: ActionType!
  "user entity triggering the action"
  user: User!
  "option entity for which the action is triggered"
  option: Option!
  "pool entity for which the action is triggered"
  pool: Pool

  "address of the caller"
  from: Bytes!
  "transaction hash"
  hash: Bytes!
  "amount resolving to the unix timestamp (millis) of the block that includes the action"
  timestamp: Int!

  "type (put/call) cloned from the option for filtering"
  optionType: Int!

  "amount resolving to an input for side A of the pool, the option tokens | for some cases it can hold the underlying amount for the action -- see readme"
  inputTokenA: BigInt!
  "amount resolving to an input for side B of the pool, the stablecoins | for some cases it can hold the strike or premium amount for the action -- see readme"
  inputTokenB: BigInt!
  "amount resolving to an output for side A of the pool, the option tokens"
  outputTokenA: BigInt!
  "amount resolving to an output for side B of the pool, the stablecoins"
  outputTokenB: BigInt!
  "structure (holding an amount) resolving to the spot price at the time of the action or trade"
  spotPrice: SpotPrice
  "special structure holding custom metadata on a case-by-case basis"
  metadata: Metadata!

  ##### NEXT VALUES POST-ACTION ####

  "amount tracking the implied volatility post-action"
  nextIV: BigInt

  "amount tracking the theoretical Black-Scholes price/premium for 1 option post-action"
  nextABPrice: BigInt

  "amount tracking the selling price for 1 option post-action"
  nextSellingPrice: BigInt
  "amount tracking the buying price for 1 option post-action"
  nextBuyingPrice: BigInt
  "amount tracking the selling price for the same amount of options as the current action, post-action (e.g. try to sell the same amount again)"
  nextDynamicSellingPrice: BigInt
  "amount tracking the buying price for the same amount of options as the current action, post-action (e.g. try to sell the same amount again)"
  nextDynamicBuyingPrice: BigInt

  "amount tracking this user's liquidity for side A of the pool, post-action"
  nextUserTokenALiquidity: BigInt
  "amount tracking this user's liquidity for side B of the pool, post-action"
  nextUserTokenBLiquidity: BigInt

  "amount tracking the total liquidity for side A of the pool, post-action"
  nextTBA: BigInt
  "amount tracking the total liquidity for side B of the pool, post-action"
  nextTBB: BigInt

  "amount tracking the deamortized balance for side A of the pool, post-action"
  nextDBA: BigInt
  "amount tracking the deamortized balance for side B of the pool, post-action"
  nextDBB: BigInt

  "amount *denominated in tokenB* tracking the balance of fees for side A of the pool, post-action"
  nextFeesA: BigInt
  "amount *denominated in tokenB* tracking the balance of fees for side B of the pool, post-action"
  nextFeesB: BigInt

  nextCollateralTVL: BigInt
  nextPoolTokenATVL: BigInt
  nextPoolTokenBTVL: BigInt

  nextUserSnapshotFIMP: BigInt
  nextUserTokenAOriginalBalance: BigInt
  nextUserTokenBOriginalBalance: BigInt
}

type SpotPrice @entity {
  id: ID!
  "amount resolving to the spot price for the volatile asset at the time of the action"
  value: BigInt!
  action: Action
}

type FeePool @entity {
  id: ID!
  address: Bytes!
  type: FeePoolType!
  pool: Pool!
}

type Fee @entity {
  id: ID!
  feePool: FeePool!
  value: BigInt!

  metadata: Metadata
  action: Action
}

type Manager @entity {
  id: ID!
  "entity array for all historical manager configurations"
  configurations: [Configuration!]! @derivedFrom(field: "manager")
  "entity storing the latest manager configuration that is actively used"
  configuration: Configuration!
}

type Configuration @entity {
  id: ID!
  manager: Manager!

  owner: Bytes!
  optionFactory: OptionFactory
  optionHelper: OptionHelper
  poolFactory: PoolFactory

  timestamp: Int!
}

type OptionFactory @entity {
  id: ID!
  options: [Option!] @derivedFrom(field: "factory")
}

type OptionHelper @entity {
  id: ID!
}

type PoolFactory @entity {
  id: ID!
  pools: [Pool!] @derivedFrom(field: "factory")
}

type Option @entity {
  "unique identifier resolving to the option address"
  id: ID!
  "address of the option token"
  address: Bytes!
  "address of the deployer"
  from: Bytes!

  "binary type resolving to 0 for PUT and 1 for CALL"
  type: Int!
  "binary type resolving to 0 for European and 1 for American"
  exerciseType: Int!
  "decimals of the ERC20 option token, usually 18"
  decimals: BigInt!
  "symbol for the ERC20 option token"
  symbol: String!

  "address of the underlying ERC20 token"
  underlyingAsset: Bytes!
  "address of the strike ERC20 token"
  strikeAsset: Bytes!

  "decimals of the underlying ERC20 token"
  underlyingAssetDecimals: BigInt!
  "decimals of the strike ERC20 token"
  strikeAssetDecimals: BigInt!

  "symbol of the underlying ERC20 token"
  underlyingAssetSymbol: String!
  "symbol of the strike ERC20 token"
  strikeAssetSymbol: String!

  "amount used as strike price, padded with decimals"
  strikePrice: BigInt!

  "amount resolving to the unix timestamp (millis) used as expiration"
  expiration: Int!
  "amount resolving to the duration (millis) used for the window of exercise"
  exerciseWindowSize: Int!

  # Generated or Bound
  "actions such as Buy, Sell, Mint, ... linked to the option or the connected pool"
  actions: [Action!]! @derivedFrom(field: "option")
  "positions of the users (with >= 1 action) linked to the option or the connected pool"
  positions: [Position!] @derivedFrom(field: "option")

  "pool connected to the option 1:1"
  pool: Pool
  "amount resolving to the unix timestamp (millis) used as start moment for the window of exercise"
  exerciseStart: Int
  "factory (option factory) creating the option"
  factory: OptionFactory!

  "address of the inferred collateral ERC20 token (strike for PUT, underlying for CALL)"
  collateralAsset: Bytes!
  "decimals of the inferred collateral ERC20 token"
  collateralAssetDecimals: BigInt!
  "symbol of the inferred collateral ERC20 token"
  collateralAssetSymbol: String!

  # Series Data #
  "amount *denominated in tokenB/strke* tracking the volume of fees (normally, removing liq. causes fees to be redeemed)"
  seriesFeeVolume: BigInt!
}

type Pool @entity {
  # Created
  "unique identifier resolving to the option address"
  id: ID!
  "address of the option token"
  address: Bytes!
  "address of the deployer"
  from: Bytes!

  "option connected to the pool 1:1"
  option: Option!
  "factory (pool factory) creating the option"
  factory: PoolFactory!

  "address of the ERC20 token for side A of the pool, the option token"
  tokenA: Bytes!
  "address of the ERC20 token for side B of the pool, the stable token"
  tokenB: Bytes!

  "decimals of the ERC20 token for side A of the pool"
  tokenADecimals: BigInt!
  "decimals of the ERC20 token for side B of the pool"
  tokenBDecimals: BigInt!

  "symbol of the ERC20 token for side A of the pool"
  tokenASymbol: String!
  "symbol of the ERC20 token for side B of the pool"
  tokenBSymbol: String!

  "FeePool storing LP fees (accruing for side A of the pool)"
  feePoolA: FeePool!

  "FeePool storing LP fees (accruing for side B of the pool)"
  feePoolB: FeePool!
}

type User @entity {
  id: ID!
  address: Bytes!
  # Generated or Bound
  actions: [Action!] @derivedFrom(field: "user")
  positions: [Position!] @derivedFrom(field: "user")
}

type Position @entity {
  id: ID!
  user: User!
  option: Option!
  "expiration chosen as sortable param *cloned* from the option"
  expiration: Int!
  "Type chosen as sortable param *cloned* from the option"
  optionType: Int!

  # # # # # # # # #
  "amount resolving to the total premium paid buying options"
  premiumPaid: BigInt!
  "amount resolving to the total premium received while selling or reselling options"
  premiumReceived: BigInt!
  #
  # Buyer's cover
  optionsBought: BigInt!
  # Seller's goods
  optionsSold: BigInt!
  # Reseller's goods
  optionsResold: BigInt!
  #
  # Minter's lock
  optionsMinted: BigInt!
  # Minter's release
  optionsUnminted: BigInt!
  #
  # Exerciser options
  optionsExercised: BigInt!
  # Withdraw amounts
  underlyingWithdrawn: BigInt!
  strikeWithdrawn: BigInt!
  #
  # LP's input amounts
  "amount resolving to the volume of option tokens provided by the user over the lifetime of the pool"
  initialOptionsProvided: BigInt!
  "amount resolving to the volume of stablecoins provided by the user over the lifetime of the pool"
  initialTokensProvided: BigInt!
  #
  # LP's output/exit amounts
  "amount resolving to the volume of option tokens removed by the user over the lifetime of the pool"
  finalOptionsRemoved: BigInt!
  "amount resolving to the volume of stablecoins removed by the user over the lifetime of the pool"
  finalTokensRemoved: BigInt!
  #
  # LP's remaining amounts (changes after each addLiquidity, removeLiquidity, withdraw)
  "amount resolving to the amount of option tokens currently available to remove from the pool"
  remainingOptionsProvided: BigInt!
  "amount resolving to the amount of stablecoins currently available to remove from the pool"
  remainingTokensProvided: BigInt!
  # Transfers
  optionsSent: BigInt! # TransferFrom
  optionsReceived: BigInt! # TransferTo
}