schema.graphql

"""
Transaction data, including hash and timestamp
"""
type Transaction @entity {
  """
  ID is transaction hash
  """
  id: ID!
  blockNumber: Int!
  """
  The timestamp the transaction was confirmed
  """
  timestamp: Int!
  gasPrice: BigInt!
  """
  The index of this transaction within the block
  """
  index: Int!
  """
  The account that initiated this transaction. This must be an Account and not a Contract.
  """
  from: User!
  """
  The contract the user interacted with
  """
  to: Bytes
  value: BigInt!
  gasLimit: BigInt!
  functionSignature: String!
}

type User @entity {
  id: ID!
  createdAt: Int!
}

"""
This is an event emitted from the staking contract when tokens are staked, either by a user or by a vesting contract
If tokens are staked by a vesting contract, there may be multiple tokens staked event per transaction (eg if tokensa are vested over 10 months, there would be 10 TokensStaked events each with a different lockedUntil date)
We have improvements planned to better represent staking on our subgraph.
"""
type TokensStaked @entity {
  """
  ID is transaction hash + log index
  """
  id: ID!
  """
  If tokens were staked by a vesting contract, user property will be null
  """
  user: User
  """
  The staker is either a user address or a vesting contract address
  """
  staker: Bytes! # address
  """
  The amount of SOV staked in this event (as mentioned above, there can be multiple TokensStaked events per transaction)
  """
  amount: BigDecimal! # uint256
  """
  The date when these tokens will unlock
  A user/vesting contract can have multiple stakes with different lockedUntil dates
  """
  lockedUntil: Int! # uint256
  """
  The total amount staked for this specific user until this specific lockedUntil date
  """
  totalStaked: BigDecimal! # uint256
  timestamp: Int!
  emittedBy: Bytes! #address
  transaction: Transaction!
  """
  If this is false, the tokens were staked by a vesting contract, and not voluntarily by a user
  """
  isUserStaked: Boolean!
}

"""
This entity holds the voluntary staking history (ie not staking by a vesting contract) of one user
"""
type UserStakeHistory @entity {
  """
  ID is the user address
  """
  id: ID! # id is user
  user: User!
  """
  Granular history of the user's voluntary staking activity
  """
  stakeHistory: [StakeHistoryItem!] @derivedFrom(field: "user")
  """
  totalStaked is the total amount the user has EVER staked (over all time).
  Eg if they stake 10 SOV and then withdraw it and stake it again, totalStaked is 20 SOV
  """
  totalStaked: BigDecimal!
  """
  totalWithdrawn is the total amount the user has ever withdrawn from voluntary staking (over all time)
  """
  totalWithdrawn: BigDecimal!
  """
  totalRemaining is the amount the user currently has staked.
  It should be the same as the result of calling the balanceOf(USER_ADDRESS) method on the staking contract.
  """
  totalRemaining: BigDecimal!
}

type Stake @entity {
  id: ID! # ID is the user address + lockedUntil date. ID can change
  user: User
  amount: BigDecimal
  vestingAmount: BigDecimal!
  delegatedAmount: BigDecimal!
  lockedUntil: Int
}

enum StakeHistoryAction {
  """
  Voluntarily staking SOV (ie not staked through a vesting contract)
  """
  Stake
  """
  Increasing the amount of an existing stake. The lockedUntil date of this stake remains the same, but amount increases.
  """
  IncreaseStake
  """
  Extending an existing stake. The amount of the stake remains the same, but the lockedUntil date increases.
  """
  ExtendStake
  """
  When a user delegates voting power to another user. This can also be for voting power that the user has through a vesting contract.
  """
  Delegate
  DelegateVested
  """
  Unstake is early unstaking, when a user withdraws staked SOV before the lockedUntil date and incurs a slashing penalty.
  """
  Unstake
  """
  WithdrawStaked is when a user withdraws SOV from the staking contract after the unlock date, when the funds are no longer staked or locked
  """
  WithdrawStaked
  """
  When a user withdraws their share of the Protocol fees that is shared amongst stakers
  """
  FeeWithdrawn
}

"""
This entity is the granular history of user actions related to voluntary staking
"""
type StakeHistoryItem @entity {
  id: ID! # transaction hash
  user: UserStakeHistory!
  action: StakeHistoryAction!
  timestamp: Int!
  transaction: Transaction!
  amount: BigDecimal
  token: String
  lockedUntil: Int
  delegatee: User
  emittedBy: Bytes!
}

# This event is emitted when tokens are transferred to the Protocol contract as fees
# It is needed because this is a flag for if staked tokens were unstaked early

type FeeSharingTokensTransferred @entity {
  id: ID! # ID is tx hash - it can't be tx hash + log index because we need to load on tx hash
  sender: Bytes!
  token: Bytes!
  amount: BigDecimal!
}


"""
Voluntary staked tokens grouped by lockedUntil date
"""
type V2Stake @entity {
  """
  ID is the user address + lockedUntil date.
  """
  id: ID!
  """
  The user who staked the tokens
  """
  user: User!
  """
  The total amount staked for this specific user until this specific lockedUntil date
  """
  amount: BigDecimal!
  """
  The date when these tokens will unlock
  """
  lockedUntil: Int!
  """
  If tokens delegated to another user, this is the address of the delegatee
  """
  delegate: User
  """
  Timestamp of a date when the stake was created
  """
  timestamp: Int!
}

"""
This event is emitted when tokens are staked, either by a user or by a vesting contract.
"""
type V2TokensStaked @entity {
  id: ID!
  """
  The user who staked the tokens (if tokens were staked by a vesting contract, user will be staking contract)
  """
  user: User!
  """
  Amount of SOV staked in this event
  """
  amount: BigDecimal!
  """
  The date when these tokens will unlock
  """
  lockedUntil: Int!
  """
  The total amount staked for this specific user until this specific lockedUntil date. As of the time of this event.
  """
  totalStaked: BigDecimal!
  """
  Timestamp of the transaction
  """
  timestamp: Int!
}

"""
Event is emitted when voluntary staked token lockedUntil date is extended
"""
type V2ExtendedStakingDuration @entity {
  id: ID!
  """
  The user who staked the tokens
  """
  user: User!
  """
  LockedUntil date of original stake
  """
  previousDate: Int!
  """
  New lockedUntil date
  """
  newDate: Int!
  """
  Amount that was moved to the new lockedUntil date
  """
  amountStaked: BigDecimal!
  """
  Timestamp of the transaction
  """
  timestamp: Int!
}

"""
Event is emitted when voluntary or vested staked tokens are withdrawn
"""
type V2StakingWithdrawn @entity {
  id: ID!
  """
  The user who staked the tokens (owner of tokens)
  """
  user: User!
  """
  Address who received the tokens
  """
  receiver: User
  """
  Amount of tokens withdrawn (does not include slashed amount)
  """
  amount: BigDecimal!
  """
  lockedUntil date of the stake from which tokens were withdrawn
  """
  until: Int!
  """
  Timestamp of the transaction
  """
  timestamp: Int!
  """
  If this is true, tokens were withdrawn by governance (eg revoked vesting contract)
  """
  isGovernance: Boolean!
}

"""
Event is emitted when stake owner delegates voting power to another user
"""
type V2DelegateChanged @entity {
  id: ID!
  """
  The user who staked the tokens
  """
  user: User!
  """
  lockedUntil date of the stake
  """
  lockedUntil: Int!
  """
  Address of the new delegatee
  """
  delegate: User
  """
  Address of the previous delegatee
  """
  previousDelegate: User
  """
  Timestamp of the transaction
  """
  timestamp: Int!
}

# Vesting Registry

enum VestingContractType {
  """
  Vesting contracts for investors who participated in the Sovryn Origin sale
  """
  Origins
  """
  Vesting contracts for investors who participated in the Sovryn Genesis sale
  """
  Genesis
  """
  FISH (Babelfish governance token) vesting contracts
  """
  Fish
  """
  Babelfish team vesting contracts
  """
  FishTeam
  """
  Sovryn team vesting contracts
  """
  Team
  """
  Vesting contracts for vested rewards
  """
  Rewards
  """
  Vesting contracts for strategic investors with a four-year lockup
  """
  FourYearVesting
  """
  Vesting contracts for early strategic investors
  """
  Strategic
}

"""
This entity represents one vesting contract
A User can have multiple vesting contracts
"""
type VestingContract @entity {
  """
  ID is the vesting contract address
  """
  id: ID! # vesting contract id
  """
  The owner of the vesting contract
  """
  user: User!
  """
  Date that the vesting contract was created
  """
  createdAtTimestamp: Int!
  """
  The cliff is the period (in seconds) until the first tokens become liquid on this contract
  """
  cliff: Int # uint256
  """
  The total duration of the vesting contract, including the cliff, in seconds.
  For example, a 9 month vesting contract with a 1 month cliff would have a duration of 26280000 (10 months in seconds)
  """
  duration: Int # uint256
  """
  The initial balance when this contract was created. This is often 0, as tokens can be added to the contract after contract creation
  """
  startingBalance: BigDecimal! # uint256
  """
  Current balance of tokens on the contract, including locked and liquid tokens that have not been withdrawn.
  Incremented on TokensStaked actions, decremented on TokensWithdrawn actions
  """
  currentBalance: BigDecimal!
  """
  Type of contract (see VestingContractType docs for more details)
  """
  type: VestingContractType!
  emittedBy: Bytes!
  createdAtTransaction: Transaction!
  """
  A granular history of every action involving this vesting contract
  """
  stakeHistory: [VestingHistoryItem!] @derivedFrom(field: "staker")
  """
  Delegated too
  """
  delegate: User
  """
  Staking contract address
  """
  staking: Bytes! #address
  """
  Token staked in this vesting contract
  """
  token: Bytes! #address
}

enum VestingHistoryItemAction {
  """
  Tokens are staked by the Vesting contract. This happens when the Vesting contract receives funds.
  """
  TokensStaked
  """
  This is only relevant to Team tokens. For Team contracts, a vesting contract can be revoked by governance if a team member leaves the project.
  If this happens, all tokens still locked are returned to the exchequer.
  This is ONLY possible with Team or FishTeam vesting contracts.
  """
  TeamTokensRevoked
  """
  When a user withdraws unlocked tokens from the vesting contract
  """
  TokensWithdrawn
  """
  When a user delegates their vesting contract to another user
  """
  DelegateChanged
}

"""
Granular data for each vesting contract, and any actions involving that contract
"""
type VestingHistoryItem @entity {
  """
  ID is transaction hash + "-" + log index
  For TokensStaked actions, there can be multiple actions per transactions, and each will create a new entity
  """
  id: ID!
  action: VestingHistoryItemAction!
  """
  The staker here will always be the vesting contract
  """
  staker: VestingContract!
  """
  Delegated too
  """
  delegatee: User
  """
  Amount being staked
  """
  amount: BigDecimal! # uint256
  """
  The date when the tokens become unlocked
  """
  lockedUntil: Int # uint256
  """
  Total number of tokens staked until this lockedUntil date
  """
  totalStaked: BigDecimal! # uint256
  timestamp: Int!
  emittedBy: Bytes! #address
  transaction: Transaction!
}