LockupStream

No description

type LockupStream {
  id: String!
  alias: String!
  chainId: BigInt!
  subgraphId: BigInt!
  tokenId: BigInt!
  hash: Bytes!
  timestamp: BigInt!
  actions(
    skip: Int = 0
    first: Int = 100
    orderBy: LockupAction_orderBy
    orderDirection: OrderDirection
    where: LockupAction_filter
  ): [LockupAction!]!
  asset: Asset!
  assetDecimalsValue: BigInt!
  batch: LockupBatch!
  category: LockupStreamCategory!
  contract: Bytes!
  position: BigInt!
  recipient: Bytes!
  sender: Bytes!
  startTime: BigInt!
  transferable: Boolean!
  version: String!
  withdrawnAmount: BigInt!
  canceledAction: LockupAction
  renounceAction: LockupAction
  cancelable: Boolean!
  canceled: Boolean!
  canceledTime: BigInt
  depositAmount: BigInt!
  duration: BigInt!
  endTime: BigInt!
  funder: Bytes!
  intactAmount: BigInt!
  depleted: Boolean!
  proxender: Bytes
  proxied: Boolean!
  renounceTime: BigInt
  shape: String
  shapeSource: ShapeSource
  cliff: Boolean
  cliffAmount: BigInt
  cliffTime: BigInt
  granularity: BigInt
  initial: Boolean
  initialAmount: BigInt
  segments(
    skip: Int = 0
    first: Int = 100
    orderBy: Segment_orderBy
    orderDirection: OrderDirection
    where: Segment_filter
  ): [Segment!]!
  tranches(
    skip: Int = 0
    first: Int = 100
    orderBy: Tranche_orderBy
    orderDirection: OrderDirection
    where: Tranche_filter
  ): [Tranche!]!
}

Fields

`LockupStream.id` ● `String!` non-null scalar

Unique identifier: \{contractAddress\}-\{chainId\}-\{tokenId\}

`LockupStream.alias` ● `String!` non-null scalar

Like the id: {contractAlias}-{chainId}-{tokenId}

`LockupStream.chainId` ● `BigInt!` non-null scalar

The chain ID where the stream was created (e.g., 137 for Polygon).

`LockupStream.subgraphId` ● `BigInt!` non-null scalar

Unique global id as tracked by the Watcher entity. ኆ80 This may change if new data sources are added and the chronological order of streams changes.

`LockupStream.tokenId` ● `BigInt!` non-null scalar

The id provided by the NFT contract. It's the ERC-721 tokenId.

`LockupStream.hash` ● `Bytes!` non-null scalar

Hash of the Ethereum transaction that created this stream.

`LockupStream.timestamp` ● `BigInt!` non-null scalar

Unix timestamp of the Ethereum transaction that created this stream.

`LockupStream.actions` ● `[LockupAction!]!` non-null object

Actions triggered by this stream.

`LockupStream.actions.skip` ● `Int` scalar

`LockupStream.actions.first` ● `Int` scalar

`LockupStream.actions.orderBy` ● `LockupAction_orderBy` enum

`LockupStream.actions.orderDirection` ● `OrderDirection` enum

`LockupStream.actions.where` ● `LockupAction_filter` input

`LockupStream.asset` ● `Asset!` non-null object

ERC-20 token distributed via this stream.

`LockupStream.assetDecimalsValue` ● `BigInt!` non-null scalar

ERC-20 token decimals. Stored here to avoid loading the asset entity on each stream. Note: the "Value" suffix is added because of a bug in GraphQL Code Generator.

`LockupStream.batch` ● `LockupBatch!` non-null object

The batch the stream may be part of. Note: this is available only when created within a batch create transaction.

`LockupStream.category` ● `LockupStreamCategory!` non-null enum

Category used for sorting.

`LockupStream.contract` ● `Bytes!` non-null scalar

The address of the contract the stream originates from.

`LockupStream.position` ● `BigInt!` non-null scalar

Position in the batch, if available.

`LockupStream.recipient` ● `Bytes!` non-null scalar

Current recipient of the stream, with permission to withdraw funds to any third-party address. Note: the recipient can change on NFT transfer.

`LockupStream.sender` ● `Bytes!` non-null scalar

Manager of the stream, with ability to cancel the stream.

`LockupStream.startTime` ● `BigInt!` non-null scalar

Unix timestamp for the start of the stream.

`LockupStream.transferable` ● `Boolean!` non-null scalar

Flag indicating the transferability of the stream. This is set when the stream is created, and cannot be changed later.

`LockupStream.version` ● `String!` non-null scalar

Version of contract, e.g., v1.0.

`LockupStream.withdrawnAmount` ● `BigInt!` non-null scalar

The sum of all withdrawn amounts.

`LockupStream.canceledAction` ● `LockupAction` object

Action in which the stream was canceled.

`LockupStream.renounceAction` ● `LockupAction` object

Action in which the stream was made non-cancelable. Note: if the stream was made non-cancelable from the get-go, this is the same as the Create action.

`LockupStream.cancelable` ● `Boolean!` non-null scalar

Flag indicating the cancelability of the stream.

`LockupStream.canceled` ● `Boolean!` non-null scalar

Flag indicating if the stream was canceled.

`LockupStream.canceledTime` ● `BigInt` scalar

Unix timestamp for the when the stream was canceled.

`LockupStream.depositAmount` ● `BigInt!` non-null scalar

The amount deposited when the stream was created.

`LockupStream.duration` ● `BigInt!` non-null scalar

Snapshot of the duration in seconds (the difference between end and start time).

`LockupStream.endTime` ● `BigInt!` non-null scalar

Unix timestamp for the end of the stream.

`LockupStream.funder` ● `Bytes!` non-null scalar

The account that funded the stream, which can be different from the sender.

`LockupStream.intactAmount` ● `BigInt!` non-null scalar

The amount that is still held by the stream regardless of whether if was fully vested or not. This is the difference between the deposit amount and all withdrawn amounts.

`LockupStream.depleted` ● `Boolean!` non-null scalar

Flag indicating if the stream has been fully withdrawn (intactAmount is zero).

`LockupStream.proxender` ● `Bytes` scalar

Owner of the proxy when the stream is created through a PRBProxy (https://github.com/PaulRBerg/prb-proxy) Note that proxy = stream sender, and proxender = owner of proxy