460 lines
14 KiB
GraphQL
460 lines
14 KiB
GraphQL
type Token @entity {
|
|
id: ID!
|
|
symbol: String
|
|
name: String
|
|
decimals: Int!
|
|
address: String!
|
|
cap: BigDecimal
|
|
supply: BigDecimal
|
|
isDatatoken: Boolean!
|
|
|
|
"address of ERC721 that owns the token, valid only for datatokens"
|
|
nft: Nft
|
|
|
|
"array of addresses with minter role, can be user wallet address, dispenser etc."
|
|
minter: [User!]
|
|
|
|
"TODO: maybe we change name , depends on audit results . It's the address that collects the payments (NOT fees)"
|
|
feeManager: String
|
|
|
|
"address of the market where the datatoken was created. This address collects market fees."
|
|
publishMarketFeeAddress: String
|
|
|
|
"adreess of fee token (can be Ocean, ETH, etc.)"
|
|
publishMarketFeeToken: String
|
|
|
|
"fee amount. Fixed value, expressed in wei in contracts, needs conversion in decimals."
|
|
publishMarketFeeAmmount: BigDecimal
|
|
|
|
"template ID of the datatoken"
|
|
templateId: Int
|
|
|
|
"number of addresses holding a balance of datatoken , TODO: can we actually calculate this? what happens when users trade the dts"
|
|
holderCount: BigInt!
|
|
|
|
"number of orders executed for this datatoken"
|
|
orderCount: BigInt!
|
|
|
|
"orders created with the datatoken, only available for datatokens"
|
|
orders: [Order!] @derivedFrom(field:"datatoken")
|
|
|
|
"fixed rate exchanges, only available for datatokens"
|
|
fixedRateExchanges: [FixedRateExchange!] @derivedFrom(field:"datatoken")
|
|
|
|
"dispensers using this token"
|
|
dispensers: [Dispenser!] @derivedFrom(field:"token")
|
|
|
|
"pools, only available for datatokens"
|
|
pools: [Pool!] @derivedFrom(field:"datatoken")
|
|
|
|
"block time datatoken was created"
|
|
createdTimestamp: Int!
|
|
|
|
"datatoken creation transaction id"
|
|
tx: String!
|
|
|
|
"block number when it was created"
|
|
block: Int!
|
|
}
|
|
|
|
"utility type"
|
|
type TokenValuePair @entity {
|
|
id : ID!
|
|
token : Token!
|
|
value : BigDecimal!
|
|
}
|
|
|
|
type Nft @entity{
|
|
"nft address"
|
|
id: ID!
|
|
symbol: String!
|
|
name: String!
|
|
tokenUri: String!
|
|
|
|
"address of the owner of the nft"
|
|
owner: String!
|
|
|
|
"same as id, it's just for easy discoverability"
|
|
address: String!
|
|
|
|
"provider url that can decrypt the ddo"
|
|
providerUrl: String
|
|
|
|
"state of the asset (described in docs)"
|
|
assetState: Int!
|
|
|
|
managerRole: [String!]
|
|
erc20DeployerRole: [String!]
|
|
storeUpdateRole: [String!]
|
|
"addresses that can update the metadata"
|
|
metadataRole: [String!]
|
|
|
|
"template address"
|
|
template: String!
|
|
|
|
|
|
"block time nft was created"
|
|
createdTimestamp: Int!
|
|
"nft creation transaction id"
|
|
tx: String!
|
|
"block number when it was created"
|
|
block: Int
|
|
}
|
|
|
|
type Pool @entity {
|
|
"pool address"
|
|
id: ID!
|
|
|
|
"owner address, pool controller"
|
|
controller: String!
|
|
|
|
"only finalized pools are relevant to us"
|
|
isFinalized: Boolean!
|
|
|
|
"pool token symbol"
|
|
symbol: String
|
|
|
|
"pool token name"
|
|
name: String
|
|
|
|
"maximum supply if any, converted from wei"
|
|
cap: BigDecimal
|
|
|
|
baseToken: Token!
|
|
baseTokenLiquidity: BigDecimal!
|
|
baseTokenWeight: BigDecimal!
|
|
|
|
datatoken: Token!
|
|
datatokenLiquidity: BigDecimal!
|
|
datatokenWeight: BigDecimal!
|
|
|
|
"pool Fee percent, fee goes to all liquidity providers : SWAP, JOIN , EXIT"
|
|
poolFee: BigDecimal!
|
|
|
|
"OPF Fee percent, fee that goes to Ocean Protocol Foundation : SWAP"
|
|
opfFee: BigDecimal!
|
|
|
|
"market fee percent, fee that goes to the market where the pool was created : SWAP"
|
|
marketFee: BigDecimal!
|
|
|
|
"actual value of fee collected in both tokens"
|
|
totalPoolFee: [TokenValuePair!]!
|
|
|
|
"actual value of fee collected in both tokens"
|
|
totalOpfFee: [TokenValuePair!]!
|
|
|
|
"actual value of fee collected in both tokens"
|
|
totalMarketFee: [TokenValuePair!]!
|
|
|
|
"fee after collection = totalFee - colectedFee"
|
|
availableOpfFee: [TokenValuePair!]!
|
|
|
|
"fee after collection totalFee - colectedFee"
|
|
availableMarketFee: [TokenValuePair!]!
|
|
|
|
"total pool token shares"
|
|
totalShares: BigDecimal!
|
|
|
|
"total tokens that were swaped"
|
|
totalSwapVolume: [TokenValuePair!]!
|
|
|
|
spotPrice: BigDecimal!
|
|
|
|
"count for when liquidity has been added"
|
|
joinCount: BigInt!
|
|
|
|
"count for when liquidity has been removed"
|
|
exitCount: BigInt!
|
|
|
|
"count for when tokens were swapped"
|
|
swapCount: BigInt!
|
|
|
|
"number of transactions in this pool involving liquidity changes"
|
|
transactionCount: BigInt!
|
|
|
|
"block time when pool was created"
|
|
createdTimestamp: Int!
|
|
"pool creation transaction id"
|
|
tx: String!
|
|
"block number when it was created"
|
|
block: Int
|
|
|
|
shares: [PoolShare!] @derivedFrom(field: "pool")
|
|
transactions: [PoolTransaction!] @derivedFrom(field: "pool")
|
|
}
|
|
|
|
# we will need to track pool share tx between users - bpool transfer tx event
|
|
type PoolShare @entity {
|
|
"poolAddress + userAddress"
|
|
id: ID!
|
|
user: User!
|
|
pool: Pool!
|
|
shares: BigDecimal!
|
|
}
|
|
|
|
enum PoolTransactionType {
|
|
JOIN,
|
|
EXIT,
|
|
SWAP,
|
|
SETUP
|
|
}
|
|
|
|
type PoolTransaction @entity {
|
|
"tx address + caller address"
|
|
id: ID!
|
|
"pool related to this tx"
|
|
pool: Pool!
|
|
"user that initiates the tx"
|
|
user: User!
|
|
type: PoolTransactionType!
|
|
|
|
"number of shares transfered"
|
|
sharesTransferAmount: BigDecimal!
|
|
|
|
"pool fee value, fee goes to all liquidity providers : SWAP, JOIN , EXIT"
|
|
poolFee: BigDecimal!
|
|
|
|
"OPF Fee value, fee that goes to Ocean Protocol Foundation : SWAP"
|
|
opfFee: BigDecimal!
|
|
|
|
"market fee value, fee that goes to the publishing market"
|
|
marketFee: BigDecimal!
|
|
|
|
"block time when pool was created"
|
|
timestamp: Int!
|
|
"pool creation transaction id"
|
|
tx: String!
|
|
"block number when it was created"
|
|
block: Int
|
|
|
|
gasLimit: BigDecimal!
|
|
"price expressed in eth"
|
|
gasPrice: BigDecimal!
|
|
|
|
"base tokens transfered"
|
|
baseToken: Token
|
|
|
|
"number of base tokens transfered, if value is negative it means it was removed"
|
|
baseTokenValue: BigDecimal
|
|
|
|
"datatokens transfered"
|
|
datatoken: Token
|
|
|
|
"number of datatokens transfered, if value is negative it means it was removed"
|
|
datatokenValue: BigDecimal
|
|
}
|
|
|
|
type Order @entity {
|
|
"transaction hash - token address - from address"
|
|
id: ID!
|
|
datatoken: Token!
|
|
|
|
consumer: User!
|
|
payer: User!
|
|
amount: BigDecimal!
|
|
serviceIndex: Int!
|
|
|
|
|
|
# the fees will be updated from an event that will be created after (todo)
|
|
publishingMarket: User
|
|
publishingMarketToken: Token #
|
|
publishingMarketAmmount: BigDecimal #call contract to get fee amount
|
|
|
|
consumerMarket: User
|
|
consumerMarketToken: Token #
|
|
consumerMarketAmmount: BigDecimal #call contract to get fee amount
|
|
|
|
createdTimestamp: Int!
|
|
tx: String!
|
|
block: Int!
|
|
}
|
|
|
|
# to be removed, mabye for pool shares only
|
|
type TokenTransaction @entity {
|
|
id: ID! # Log ID
|
|
event: String
|
|
token: Token
|
|
user: User
|
|
|
|
block: Int!
|
|
gasUsed: BigDecimal!
|
|
gasPrice: BigDecimal!
|
|
createdTimestamp: Int!
|
|
tx: String!
|
|
}
|
|
|
|
type User @entity {
|
|
id: ID!
|
|
sharesOwned: [PoolShare!] @derivedFrom(field: "user")
|
|
tokenBalancesOwned: [TokenValuePair!]
|
|
tokensOwned: [Token!] @derivedFrom(field: "minter")
|
|
poolTransactions: [PoolTransaction!] @derivedFrom(field: "user")
|
|
orders: [Order!] @derivedFrom(field: "payer")
|
|
freSwaps: [FixedRateExchangeSwap!] @derivedFrom(field: "by")
|
|
}
|
|
|
|
type FixedRateExchange @entity {
|
|
"fixed rate exchange id"
|
|
id: ID!
|
|
owner: User!
|
|
datatoken: Token!
|
|
baseToken: Token!
|
|
"amount of datatokens available to be sold, this is relevant if the exchange is not able to mint"
|
|
datatokenBalance: BigDecimal!
|
|
"amount of basetokens available to be collected by the owner"
|
|
baseTokenBalance: BigDecimal!
|
|
price: BigDecimal!
|
|
active: Boolean!
|
|
"amount of total basetokens spent"
|
|
totalSwapValue: BigDecimal!
|
|
"address that is allowed to swap tokens"
|
|
allowedSwapper: String
|
|
"if the owner allowes the fre to mint"
|
|
withMint: Boolean
|
|
"if the fre has the minter role on the datatoken"
|
|
isMinter: Boolean
|
|
|
|
updates: [FixedRateExchangeUpdate!] @derivedFrom(field: "exchangeId")
|
|
swaps: [FixedRateExchangeSwap!] @derivedFrom(field: "exchangeId")
|
|
|
|
createdTimestamp: Int!
|
|
tx: String!
|
|
block: Int!
|
|
}
|
|
|
|
type FixedRateExchangeUpdate @entity {
|
|
id: ID!
|
|
exchangeId: FixedRateExchange!
|
|
|
|
oldPrice: BigDecimal
|
|
newPrice: BigDecimal
|
|
|
|
oldActive: Boolean
|
|
newActive: Boolean
|
|
|
|
oldAllowedSwapper: String
|
|
newAllowedSwapper: String
|
|
|
|
block: Int!
|
|
createdTimestamp: Int!
|
|
tx: String!
|
|
}
|
|
|
|
type FixedRateExchangeSwap @entity {
|
|
id: ID!
|
|
exchangeId: FixedRateExchange!
|
|
by: User!
|
|
baseTokenAmount: BigDecimal!
|
|
dataTokenAmount: BigDecimal!
|
|
block: Int!
|
|
createdTimestamp: Int!
|
|
tx: String!
|
|
}
|
|
|
|
|
|
type Dispenser @entity {
|
|
"token address"
|
|
id: ID!
|
|
active: Boolean!
|
|
"if using the enterprise template the owner will always be the erc721 factory, for normal template it will a user"
|
|
owner: String
|
|
token: Token!
|
|
|
|
allowedSwapper: String
|
|
isMinter: Boolean
|
|
"max tokens that can be dispensed"
|
|
maxTokens: BigDecimal!
|
|
"max balance of requester. If the balance is higher, the dispense is rejected"
|
|
maxBalance: BigDecimal!
|
|
"how many tokens are left"
|
|
balance: BigDecimal!
|
|
|
|
|
|
block: Int!
|
|
createdTimestamp: Int!
|
|
tx: String!
|
|
|
|
dispenses: [DispenserTransaction!] @derivedFrom(field: "dispenser")
|
|
}
|
|
|
|
type DispenserTransaction @entity {
|
|
id: ID!
|
|
dispenser: Dispenser!
|
|
user: User!
|
|
amount: BigDecimal!
|
|
|
|
block: Int!
|
|
createdTimestamp: Int!
|
|
tx: String!
|
|
}
|
|
|
|
type PoolSnapshot @entity {
|
|
id: ID!
|
|
pool: Pool!
|
|
"total pool shares at the end of the 24h interval"
|
|
totalShares: BigDecimal!
|
|
"swap value 24h"
|
|
swapVolume: BigDecimal!
|
|
"swap fee value 24h"
|
|
swapFees: BigDecimal!
|
|
"date without time"
|
|
date: Int!
|
|
"last spot price in the 24h interval"
|
|
spotPrice: BigDecimal!
|
|
|
|
baseToken: Token!
|
|
baseTokenLiquidity: BigDecimal!
|
|
|
|
datatoken: Token!
|
|
datatokenLiquidity: BigDecimal!
|
|
|
|
}
|
|
type GlobalStats @entity {
|
|
id: ID!
|
|
|
|
"total liquidity for each base token"
|
|
totalLiquidity: [TokenValuePair!]!
|
|
"total swap volume for each base token. pools and fre"
|
|
totalSwapVolume: [TokenValuePair!]!
|
|
|
|
"number of total consumes, pools + fre+ free"
|
|
orderCount: BigInt!
|
|
|
|
"total nfts created"
|
|
nftCount: BigInt!
|
|
"total datatokens created"
|
|
datatokenCount:BigInt!
|
|
"number of pools"
|
|
poolCount: Int!
|
|
}
|
|
|
|
|
|
enum NftUpdateType {
|
|
METADATA_CREATED,
|
|
METADATA_UPDATED,
|
|
STATE_UPDATED,
|
|
TOKENURI_UPDATED
|
|
}
|
|
|
|
type NftUpdate @entity {
|
|
id: ID! # update tx + nft address
|
|
tokenUri: String!
|
|
nft: Nft!
|
|
|
|
"provider url that can decrypt the ddo"
|
|
providerUrl: String
|
|
|
|
"user that made the update"
|
|
userAddress: String!
|
|
|
|
"state of the asset in this update"
|
|
assetState: Int!
|
|
|
|
"type of the update: metadata created, metadata update, state update, token uri update"
|
|
type: NftUpdateType!
|
|
|
|
block: Int!
|
|
timestamp: Int!
|
|
tx: String!
|
|
}
|