diff --git a/Cargo.lock b/Cargo.lock index 09adf45e3..0b98afaf3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -301,7 +301,7 @@ dependencies = [ "futures-utils-wasm", "lru", "pin-project", - "reqwest", + "reqwest 0.12.5", "serde", "serde_json", "tokio", @@ -365,7 +365,7 @@ dependencies = [ "alloy-transport-ws", "futures", "pin-project", - "reqwest", + "reqwest 0.12.5", "serde", "serde_json", "tokio", @@ -569,7 +569,7 @@ checksum = "2437d145d80ea1aecde8574d2058cceb8b3c9cba05f6aea8e67907c660d46698" dependencies = [ "alloy-json-rpc", "alloy-transport", - "reqwest", + "reqwest 0.12.5", "serde_json", "tower", "tracing", @@ -605,7 +605,7 @@ dependencies = [ "alloy-transport", "futures", "http 1.1.0", - "rustls", + "rustls 0.23.12", "serde_json", "tokio", "tokio-tungstenite 0.23.1", @@ -2538,6 +2538,15 @@ dependencies = [ "serde", ] +[[package]] +name = "graphql-introspection-query" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f2a4732cf5140bd6c082434494f785a19cfb566ab07d1382c3671f5812fed6d" +dependencies = [ + "serde", +] + [[package]] name = "graphql-parser" version = "0.4.0" @@ -2548,6 +2557,46 @@ dependencies = [ "thiserror", ] +[[package]] +name = "graphql_client" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a50cfdc7f34b7f01909d55c2dcb71d4c13cbcbb4a1605d6c8bd760d654c1144b" +dependencies = [ + "graphql_query_derive", + "reqwest 0.11.27", + "serde", + "serde_json", +] + +[[package]] +name = "graphql_client_codegen" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e27ed0c2cf0c0cc52c6bcf3b45c907f433015e580879d14005386251842fb0a" +dependencies = [ + "graphql-introspection-query", + "graphql-parser", + "heck 0.4.1", + "lazy_static", + "proc-macro2", + "quote", + "serde", + "serde_json", + "syn 1.0.109", +] + +[[package]] +name = "graphql_query_derive" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83febfa838f898cfa73dfaa7a8eb69ff3409021ac06ee94cfb3d622f6eeb1a97" +dependencies = [ + "graphql_client_codegen", + "proc-macro2", + "syn 1.0.109", +] + [[package]] name = "group" version = "0.13.0" @@ -2852,6 +2901,20 @@ dependencies = [ "want", ] +[[package]] +name = "hyper-rustls" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" +dependencies = [ + "futures-util", + "http 0.2.12", + "hyper 0.14.30", + "rustls 0.21.12", + "tokio", + "tokio-rustls 0.24.1", +] + [[package]] name = "hyper-rustls" version = "0.27.2" @@ -2863,10 +2926,10 @@ dependencies = [ "hyper 1.4.1", "hyper-util", "log", - "rustls", + "rustls 0.23.12", "rustls-pki-types", "tokio", - "tokio-rustls", + "tokio-rustls 0.26.0", "tower-service", ] @@ -2979,10 +3042,11 @@ dependencies = [ "build-info", "env_logger", "eventuals", + "graphql_client", "lazy_static", "prometheus", "regex", - "reqwest", + "reqwest 0.12.5", "serde", "serde_json", "sqlx", @@ -3039,7 +3103,7 @@ dependencies = [ "indexer-config", "lazy_static", "prometheus", - "reqwest", + "reqwest 0.12.5", "serde", "serde_json", "sqlx", @@ -3064,13 +3128,14 @@ dependencies = [ "eventuals", "futures", "futures-util", + "graphql_client", "indexer-common", "indexer-config", "jsonrpsee 0.24.5", "lazy_static", "prometheus", "ractor", - "reqwest", + "reqwest 0.12.5", "ruint", "serde", "serde_json", @@ -3303,11 +3368,11 @@ dependencies = [ "base64 0.22.1", "http-body 1.0.1", "hyper 1.4.1", - "hyper-rustls", + "hyper-rustls 0.27.2", "hyper-util", "jsonrpsee-core 0.24.5", "jsonrpsee-types 0.24.5", - "rustls", + "rustls 0.23.12", "rustls-platform-verifier", "serde", "serde_json", @@ -4561,6 +4626,47 @@ dependencies = [ "bytecheck", ] +[[package]] +name = "reqwest" +version = "0.11.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" +dependencies = [ + "base64 0.21.7", + "bytes", + "encoding_rs", + "futures-core", + "futures-util", + "h2 0.3.26", + "http 0.2.12", + "http-body 0.4.6", + "hyper 0.14.30", + "hyper-rustls 0.24.2", + "ipnet", + "js-sys", + "log", + "mime", + "once_cell", + "percent-encoding", + "pin-project-lite", + "rustls 0.21.12", + "rustls-pemfile 1.0.4", + "serde", + "serde_json", + "serde_urlencoded", + "sync_wrapper 0.1.2", + "system-configuration", + "tokio", + "tokio-rustls 0.24.1", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "webpki-roots 0.25.4", + "winreg 0.50.0", +] + [[package]] name = "reqwest" version = "0.12.5" @@ -4577,7 +4683,7 @@ dependencies = [ "http-body 1.0.1", "http-body-util", "hyper 1.4.1", - "hyper-rustls", + "hyper-rustls 0.27.2", "hyper-tls", "hyper-util", "ipnet", @@ -4588,7 +4694,7 @@ dependencies = [ "once_cell", "percent-encoding", "pin-project-lite", - "rustls-pemfile", + "rustls-pemfile 2.1.3", "serde", "serde_json", "serde_urlencoded", @@ -4601,7 +4707,7 @@ dependencies = [ "wasm-bindgen", "wasm-bindgen-futures", "web-sys", - "winreg", + "winreg 0.52.0", ] [[package]] @@ -4824,6 +4930,18 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "rustls" +version = "0.21.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e" +dependencies = [ + "log", + "ring", + "rustls-webpki 0.101.7", + "sct", +] + [[package]] name = "rustls" version = "0.23.12" @@ -4834,7 +4952,7 @@ dependencies = [ "once_cell", "ring", "rustls-pki-types", - "rustls-webpki", + "rustls-webpki 0.102.6", "subtle", "zeroize", ] @@ -4846,12 +4964,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a88d6d420651b496bdd98684116959239430022a115c1240e6c3993be0b15fba" dependencies = [ "openssl-probe", - "rustls-pemfile", + "rustls-pemfile 2.1.3", "rustls-pki-types", "schannel", "security-framework", ] +[[package]] +name = "rustls-pemfile" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" +dependencies = [ + "base64 0.21.7", +] + [[package]] name = "rustls-pemfile" version = "2.1.3" @@ -4879,13 +5006,13 @@ dependencies = [ "jni", "log", "once_cell", - "rustls", + "rustls 0.23.12", "rustls-native-certs", "rustls-platform-verifier-android", - "rustls-webpki", + "rustls-webpki 0.102.6", "security-framework", "security-framework-sys", - "webpki-roots", + "webpki-roots 0.26.3", "winapi", ] @@ -4895,6 +5022,16 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f" +[[package]] +name = "rustls-webpki" +version = "0.101.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" +dependencies = [ + "ring", + "untrusted", +] + [[package]] name = "rustls-webpki" version = "0.102.6" @@ -4966,6 +5103,16 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" +[[package]] +name = "sct" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" +dependencies = [ + "ring", + "untrusted", +] + [[package]] name = "seahash" version = "4.1.0" @@ -5865,7 +6012,7 @@ dependencies = [ "alloy-sol-types", "bs58", "indoc", - "reqwest", + "reqwest 0.12.5", "serde", "serde_json", "serde_with", @@ -5882,7 +6029,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "db48c0cb52c4d960017b8354340c509ef61bfa843cb1a4ff2fed34daa5e6f7a3" dependencies = [ "async-trait", - "reqwest", + "reqwest 0.12.5", "serde", "serde_json", "thiserror", @@ -6021,13 +6168,23 @@ dependencies = [ "tokio", ] +[[package]] +name = "tokio-rustls" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" +dependencies = [ + "rustls 0.21.12", + "tokio", +] + [[package]] name = "tokio-rustls" version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4" dependencies = [ - "rustls", + "rustls 0.23.12", "rustls-pki-types", "tokio", ] @@ -6064,12 +6221,12 @@ checksum = "c6989540ced10490aaf14e6bad2e3d33728a2813310a0c71d1574304c49631cd" dependencies = [ "futures-util", "log", - "rustls", + "rustls 0.23.12", "rustls-pki-types", "tokio", - "tokio-rustls", + "tokio-rustls 0.26.0", "tungstenite 0.23.0", - "webpki-roots", + "webpki-roots 0.26.3", ] [[package]] @@ -6337,7 +6494,7 @@ dependencies = [ "httparse", "log", "rand 0.8.5", - "rustls", + "rustls 0.23.12", "rustls-pki-types", "sha1", "thiserror", @@ -6625,6 +6782,12 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "webpki-roots" +version = "0.25.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1" + [[package]] name = "webpki-roots" version = "0.26.3" @@ -6856,6 +7019,16 @@ dependencies = [ "memchr", ] +[[package]] +name = "winreg" +version = "0.50.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" +dependencies = [ + "cfg-if", + "windows-sys 0.48.0", +] + [[package]] name = "winreg" version = "0.52.0" diff --git a/Cargo.toml b/Cargo.toml index 39b7f05c9..9b1865f45 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -47,3 +47,4 @@ thegraph-core = { git = "https://github.com/edgeandnode/toolshed", rev = "85ee00 "subgraph-client", ] } thegraph-graphql-http = "0.2.0" +graphql_client = { version = "0.14.0", features = ["reqwest-rustls"] } diff --git a/common/Cargo.toml b/common/Cargo.toml index ee4cdf664..2a7d8e1c1 100644 --- a/common/Cargo.toml +++ b/common/Cargo.toml @@ -20,6 +20,7 @@ axum.workspace = true lazy_static.workspace = true thegraph-graphql-http.workspace = true build-info.workspace = true +graphql_client.workspace = true serde = { workspace = true, features = ["derive"] } serde_json = { workspace = true } diff --git a/common/src/allocations/monitor.rs b/common/src/allocations/monitor.rs index 95dd8e5f4..8252f59ae 100644 --- a/common/src/allocations/monitor.rs +++ b/common/src/allocations/monitor.rs @@ -3,16 +3,58 @@ use std::{ collections::HashMap, + str::FromStr, time::{Duration, SystemTime, UNIX_EPOCH}, }; use super::Allocation; use crate::prelude::SubgraphClient; +use alloy::primitives::{TxHash, B256, U256}; use eventuals::{timer, Eventual, EventualExt}; -use thegraph_core::Address; +use graphql_client::GraphQLQuery; +use thegraph_core::{Address, DeploymentId}; use tokio::time::sleep; use tracing::warn; +type BigInt = U256; +type Bytes = B256; + +#[derive(GraphQLQuery)] +#[graphql( + schema_path = "../graphql/network.schema.graphql", + query_path = "../graphql/allocations.query.graphql", + response_derives = "Debug", + variables_derives = "Clone" +)] +pub struct AllocationsQuery; + +impl TryFrom for Allocation { + type Error = anyhow::Error; + + fn try_from( + value: allocations_query::AllocationsQueryAllocations, + ) -> Result { + Ok(Self { + id: Address::from_str(&value.id)?, + status: super::AllocationStatus::Null, + subgraph_deployment: super::SubgraphDeployment { + id: DeploymentId::from_str(&value.subgraph_deployment.id)?, + denied_at: Some(value.subgraph_deployment.denied_at as u64), + }, + indexer: Address::from_str(&value.indexer.id)?, + allocated_tokens: value.allocated_tokens, + created_at_epoch: value.created_at_epoch as u64, + created_at_block_hash: value.created_at_block_hash.to_string(), + closed_at_epoch: value.closed_at_epoch.map(|v| v as u64), + closed_at_epoch_start_block_hash: None, + previous_epoch_start_block_hash: None, + poi: None, + query_fee_rebates: None, + query_fees_collected: None, + }) + } +} + /// An always up-to-date list of an indexer's active and recently closed allocations. pub fn indexer_allocations( network_subgraph: &'static SubgraphClient, @@ -56,49 +98,46 @@ pub async fn get_allocations( .expect("Time went backwards"); let closed_at_threshold = since_the_epoch - recently_closed_allocation_buffer; - let query = format!( - r#" - allocations( - block: $block - orderBy: id - orderDirection: asc - first: $first - where: {{ - and: [ - {{ id_gt: $last }} - {{ indexer_: {{ id: "{}" }} }} - {{ - or: [ - {{ status: Active }} - {{ and: [{{ status: Closed, closedAt_gte: {} }}] }} - ] - }} - ] - }} - ) {{ - id - indexer {{ - id - }} - allocatedTokens - createdAtBlockHash - createdAtEpoch - closedAtEpoch - subgraphDeployment {{ - id - deniedAt - }} - }} - "#, - indexer_address.to_string().to_ascii_lowercase(), - closed_at_threshold.as_secs(), - ); - let responses = network_subgraph - .paginated_query::(query, 200) - .await - .map_err(|e| anyhow::anyhow!(e.to_string()))?; + let mut hash: Option = None; + let mut last: Option = None; + let mut responses = vec![]; + let page_size = 200; + loop { + let result = network_subgraph + .query::(allocations_query::Variables { + indexer: indexer_address.to_string().to_ascii_lowercase(), + closed_at_threshold: closed_at_threshold.as_secs() as i64, + first: page_size, + last: last.unwrap_or_default(), + block: hash.map(|hash| allocations_query::Block_height { + hash: Some(hash), + number: None, + number_gte: None, + }), + }) + .await + .map_err(|e| anyhow::anyhow!(e.to_string()))?; + + let mut data = result?; + let page_len = data.allocations.len(); + + hash = data.meta.and_then(|meta| meta.block.hash); + last = data.allocations.last().map(|entry| entry.id.to_string()); + + responses.append(&mut data.allocations); + if (page_len as i64) < page_size { + break; + } + } + let responses = responses + .into_iter() + .map(|allocation| allocation.try_into()) + .collect::, _>>()?; - Ok(HashMap::from_iter(responses.into_iter().map(|a| (a.id, a)))) + Ok(responses + .into_iter() + .map(|allocation| (allocation.id, allocation)) + .collect()) } #[cfg(test)] diff --git a/common/src/attestations/dispute_manager.rs b/common/src/attestations/dispute_manager.rs index f53920188..7c64c6e02 100644 --- a/common/src/attestations/dispute_manager.rs +++ b/common/src/attestations/dispute_manager.rs @@ -4,41 +4,32 @@ use std::time::Duration; use eventuals::{timer, Eventual, EventualExt}; -use serde::Deserialize; +use graphql_client::GraphQLQuery; use thegraph_core::Address; use tokio::time::sleep; use tracing::warn; -use crate::subgraph_client::{Query, SubgraphClient}; +use crate::subgraph_client::SubgraphClient; + +type Bytes = Address; + +#[derive(GraphQLQuery)] +#[graphql( + schema_path = "../graphql/network.schema.graphql", + query_path = "../graphql/dispute.query.graphql", + response_derives = "Debug", + variables_derives = "Clone" +)] +struct DisputeManager; pub fn dispute_manager( network_subgraph: &'static SubgraphClient, interval: Duration, ) -> Eventual
{ - #[derive(Deserialize)] - #[serde(rename_all = "camelCase")] - struct DisputeManagerResponse { - graph_network: Option, - } - - #[derive(Deserialize)] - #[serde(rename_all = "camelCase")] - struct GraphNetwork { - dispute_manager: Address, - } - timer(interval).map_with_retry( move |_| async move { let response = network_subgraph - .query::(Query::new( - r#" - query network { - graphNetwork(id: 1) { - disputeManager - } - } - "#, - )) + .query::(dispute_manager::Variables {}) .await .map_err(|e| e.to_string())?; @@ -49,7 +40,7 @@ pub fn dispute_manager( }) }, move |err: String| { - warn!("Failed to query dispute manager for network: {}", err,); + warn!("Failed to query dispute manager: {}", err); // Sleep for a bit before we retry sleep(interval.div_f32(2.0)) diff --git a/common/src/escrow_accounts.rs b/common/src/escrow_accounts.rs index 49d940ffc..6a29cefed 100644 --- a/common/src/escrow_accounts.rs +++ b/common/src/escrow_accounts.rs @@ -8,15 +8,15 @@ use std::{ }; use alloy::primitives::U256; -use anyhow::Result; +use anyhow::{anyhow, Result}; use eventuals::{timer, Eventual, EventualExt}; -use serde::Deserialize; +use graphql_client::GraphQLQuery; use thegraph_core::Address; use thiserror::Error; use tokio::time::sleep; use tracing::{error, warn}; -use crate::prelude::{Query, SubgraphClient}; +use crate::prelude::SubgraphClient; #[derive(Error, Debug)] pub enum EscrowAccountsError { @@ -89,130 +89,28 @@ impl EscrowAccounts { } } +type BigInt = String; + +#[derive(GraphQLQuery)] +#[graphql( + schema_path = "../graphql/tap.schema.graphql", + query_path = "../graphql/escrow_account.query.graphql", + response_derives = "Debug", + variables_derives = "Clone" +)] +pub struct EscrowAccountQuery; + pub fn escrow_accounts( escrow_subgraph: &'static SubgraphClient, indexer_address: Address, interval: Duration, reject_thawing_signers: bool, ) -> Eventual { - // Types for deserializing the network subgraph response - #[derive(Deserialize)] - #[serde(rename_all = "camelCase")] - struct EscrowAccountsResponse { - escrow_accounts: Vec, - } - // Note that U256's serde implementation is based on serializing the internal bytes, not the string decimal - // representation. This is why we deserialize them as strings below. - #[derive(Deserialize)] - #[serde(rename_all = "camelCase")] - struct EscrowAccount { - balance: String, - total_amount_thawing: String, - sender: Sender, - } - #[derive(Deserialize)] - #[serde(rename_all = "camelCase")] - struct Sender { - id: Address, - signers: Vec, - } - #[derive(Deserialize)] - #[serde(rename_all = "camelCase")] - struct Signer { - id: Address, - } - - // thawEndTimestamp == 0 means that the signer is not thawing. This also means - // that we don't wait for the thawing period to end before stopping serving - // queries for this signer. - // isAuthorized == true means that the signer is still authorized to sign - // payments in the name of the sender. - let query = if reject_thawing_signers { - r#" - query ($indexer: ID!) { - escrowAccounts(where: {receiver_: {id: $indexer}}) { - balance - totalAmountThawing - sender { - id - signers( - where: {thawEndTimestamp: "0", isAuthorized: true} - ) { - id - } - } - } - } - "# - } else { - r#" - query ($indexer: ID!) { - escrowAccounts(where: {receiver_: {id: $indexer}}) { - balance - totalAmountThawing - sender { - id - signers( - where: {isAuthorized: true} - ) { - id - } - } - } - } - "# - }; - timer(interval).map_with_retry( move |_| async move { - let response = escrow_subgraph - .query::(Query::new_with_variables( - query, - [("indexer", format!("{:x?}", indexer_address).into())], - )) + get_escrow_accounts(escrow_subgraph, indexer_address, reject_thawing_signers) .await - .map_err(|e| e.to_string())?; - - let response = response.map_err(|e| e.to_string())?; - - let senders_balances = response - .escrow_accounts - .iter() - .map(|account| { - let balance = U256::checked_sub( - U256::from_str(&account.balance)?, - U256::from_str(&account.total_amount_thawing)?, - ) - .unwrap_or_else(|| { - warn!( - "Balance minus total amount thawing underflowed for account {}. \ - Setting balance to 0, no queries will be served for this sender.", - account.sender.id - ); - U256::from(0) - }); - - Ok((account.sender.id, balance)) - }) - .collect::, anyhow::Error>>() - .map_err(|e| format!("{}", e))?; - - let senders_to_signers = response - .escrow_accounts - .iter() - .map(|account| { - let sender = account.sender.id; - let signers = account - .sender - .signers - .iter() - .map(|signer| signer.id) - .collect(); - (sender, signers) - }) - .collect(); - - Ok(EscrowAccounts::new(senders_balances, senders_to_signers)) + .map_err(|e| e.to_string()) }, move |err: String| { error!( @@ -225,6 +123,69 @@ pub fn escrow_accounts( ) } +async fn get_escrow_accounts( + escrow_subgraph: &'static SubgraphClient, + indexer_address: Address, + reject_thawing_signers: bool, +) -> Result { + // thawEndTimestamp == 0 means that the signer is not thawing. This also means + // that we don't wait for the thawing period to end before stopping serving + // queries for this signer. + // isAuthorized == true means that the signer is still authorized to sign + // payments in the name of the sender. + let response = escrow_subgraph + .query::(escrow_account_query::Variables { + indexer: format!("{:x?}", indexer_address), + thaw_end_timestamp: if reject_thawing_signers { + U256::ZERO.to_string() + } else { + U256::MAX.to_string() + }, + }) + .await?; + + let response = response?; + + let senders_balances: HashMap = response + .escrow_accounts + .iter() + .map(|account| { + let balance = U256::checked_sub( + U256::from_str(&account.balance)?, + U256::from_str(&account.total_amount_thawing)?, + ) + .unwrap_or_else(|| { + warn!( + "Balance minus total amount thawing underflowed for account {}. \ + Setting balance to 0, no queries will be served for this sender.", + account.sender.id + ); + U256::from(0) + }); + + Ok((Address::from_str(&account.sender.id)?, balance)) + }) + .collect::, anyhow::Error>>()?; + + let senders_to_signers = response + .escrow_accounts + .into_iter() + .map(|account| { + let sender = Address::from_str(&account.sender.id)?; + let signers = account + .sender + .signers + .ok_or(anyhow!("Could not find any signers for sender {sender}"))? + .iter() + .map(|signer| Address::from_str(&signer.id)) + .collect::, _>>()?; + Ok((sender, signers)) + }) + .collect::, anyhow::Error>>()?; + + Ok(EscrowAccounts::new(senders_balances, senders_to_signers)) +} + #[cfg(test)] mod tests { use test_log::test; diff --git a/common/src/subgraph_client/client.rs b/common/src/subgraph_client/client.rs index 63419067e..b83f5df45 100644 --- a/common/src/subgraph_client/client.rs +++ b/common/src/subgraph_client/client.rs @@ -5,15 +5,14 @@ use super::monitor::{monitor_deployment_status, DeploymentStatus}; use anyhow::anyhow; use axum::body::Bytes; use eventuals::Eventual; +use graphql_client::GraphQLQuery; use reqwest::{header, Url}; -use serde::de::Deserialize; use serde_json::{Map, Value}; -use thegraph_core::{client::Client as GraphCoreSubgraphClient, DeploymentId}; +use thegraph_core::DeploymentId; use thegraph_graphql_http::{ graphql::{Document, IntoDocument}, http::request::{IntoRequestParameters, RequestParameters}, }; -use tokio::sync::Mutex; use tracing::warn; #[derive(Clone)] @@ -22,6 +21,8 @@ pub struct Query { pub variables: Map, } +pub type ResponseResult = Result; + impl Query { pub fn new(query: &str) -> Self { Self { @@ -121,21 +122,14 @@ impl DeploymentDetails { struct DeploymentClient { pub http_client: reqwest::Client, - pub subgraph_client: Mutex, pub status: Option>, pub query_url: Url, } impl DeploymentClient { pub fn new(http_client: reqwest::Client, details: DeploymentDetails) -> Self { - let subgraph_client = Mutex::new( - GraphCoreSubgraphClient::builder(http_client.clone(), details.query_url.clone()) - .with_auth_token(details.query_auth_token) - .build(), - ); Self { http_client, - subgraph_client, status: details .deployment .zip(details.status_url) @@ -144,10 +138,10 @@ impl DeploymentClient { } } - pub async fn query Deserialize<'de>>( + pub async fn query( &self, - query: impl IntoRequestParameters + Send, - ) -> Result, anyhow::Error> { + variables: T::Variables, + ) -> Result, anyhow::Error> { if let Some(ref status) = self.status { let deployment_status = status.value().await.expect("reading deployment status"); @@ -158,47 +152,23 @@ impl DeploymentClient { )); } } - Ok(self - .subgraph_client - .lock() - .await - .query::(query) - .await - .inspect_err(|err| { - warn!( - "Failed to query subgraph deployment `{}`: {}", - self.query_url, err - ); - })) - } - pub async fn paginated_query Deserialize<'de>>( - &self, - query: String, - items_per_page: usize, - ) -> Result, anyhow::Error> { - if let Some(ref status) = self.status { - let deployment_status = status.value().await.expect("reading deployment status"); - - if !deployment_status.synced || &deployment_status.health != "healthy" { - return Err(anyhow!( - "Deployment `{}` is not ready or healthy to be queried", - self.query_url - )); - } - } - self.subgraph_client - .lock() - .await - .paginated_query::(query, items_per_page) - .await - .map_err(|err| { - warn!( - "Failed to query subgraph deployment `{}`: {}", - self.query_url, err - ); - anyhow!(err) - }) + let body = T::build_query(variables); + let reqwest_response = self + .http_client + .post(self.query_url.as_ref()) + .header(header::USER_AGENT, "indexer-common") + .json(&body) + .send() + .await?; + let response: graphql_client::Response = reqwest_response.json().await?; + + // TODO handle partial responses + Ok(match (response.data, response.errors) { + (Some(data), None) => Ok(data), + (_, Some(errors)) => Err(anyhow!("{errors:?}")), + (_, _) => Err(anyhow!("Invalid error")), + }) } pub async fn query_raw(&self, body: Bytes) -> Result { @@ -242,14 +212,18 @@ impl SubgraphClient { } } - pub async fn query Deserialize<'de>>( + pub async fn query( &self, - query: impl IntoRequestParameters + Send + Clone, - ) -> Result, anyhow::Error> { + variables: Q::Variables, + ) -> Result, anyhow::Error> + where + Q: GraphQLQuery, + V: Clone, + { // Try the local client first; if that fails, log the error and move on // to the remote client if let Some(ref local_client) = self.local_client { - match local_client.query(query.clone()).await { + match local_client.query::(variables.clone()).await { Ok(response) => return Ok(response), Err(err) => warn!( "Failed to query local subgraph deployment `{}`, trying remote deployment next: {}", @@ -259,13 +233,17 @@ impl SubgraphClient { } // Try the remote client - self.remote_client.query::(query).await.map_err(|err| { - warn!( - "Failed to query remote subgraph deployment `{}`: {}", - self.remote_client.query_url, err - ); - err - }) + self.remote_client + .query::(variables) + .await + .map_err(|err| { + warn!( + "Failed to query remote subgraph deployment `{}`: {}", + self.remote_client.query_url, err + ); + + err + }) } pub async fn query_raw(&self, query: Bytes) -> Result { @@ -291,35 +269,6 @@ impl SubgraphClient { err }) } - - pub async fn paginated_query Deserialize<'de>>( - &self, - query: String, - items_per_page: usize, - ) -> Result, anyhow::Error> { - // Try the local client first; if that fails, log the error and move on - // to the remote client - if let Some(ref local_client) = self.local_client { - match local_client.paginated_query::(query.clone(), items_per_page).await { - Ok(response) => return Ok(response), - Err(err) => warn!( - "Failed to query local subgraph deployment `{}`, trying remote deployment next: {}", - local_client.query_url, err - ), - } - } - // Try the remote client - self.remote_client - .paginated_query::(query, 1000) - .await - .map_err(|err| { - warn!( - "Failed to query remote subgraph deployment `{}`: {}", - self.remote_client.query_url, err - ); - anyhow!(err) - }) - } } #[cfg(test)] @@ -369,6 +318,15 @@ mod test { ) } + #[derive(GraphQLQuery)] + #[graphql( + schema_path = "../graphql/network.schema.graphql", + query_path = "../graphql/epoch.query.graphql", + response_derives = "Debug", + variables_derives = "Clone" + )] + struct CurrentEpoch; + #[tokio::test] #[ignore = "depends on the defunct hosted-service"] async fn test_network_query() { @@ -376,21 +334,22 @@ mod test { // Check that the response is valid JSON let result = network_subgraph_client() - .query::(Query::new( - r#" - query { - graphNetwork(id: 1) { - currentEpoch - } - } - "#, - )) + .query::(current_epoch::Variables {}) .await .unwrap(); assert!(result.is_ok()); } + #[derive(GraphQLQuery)] + #[graphql( + schema_path = "../graphql/test.schema.graphql", + query_path = "../graphql/user.query.graphql", + response_derives = "Debug", + variables_derives = "Clone" + )] + struct UserQuery; + #[tokio::test] async fn test_uses_local_deployment_if_healthy_and_synced() { let deployment = @@ -463,12 +422,12 @@ mod test { // Query the subgraph let data = client - .query::(Query::new("{ user(id: 1} { name } }")) + .query::(user_query::Variables {}) .await .expect("Query should succeed") .expect("Query result should have a value"); - assert_eq!(data, json!({ "user": { "name": "local" } })); + assert_eq!(data.user.name, "local".to_string()); } #[tokio::test] @@ -543,12 +502,12 @@ mod test { // Query the subgraph let data = client - .query::(Query::new("{ user(id: 1} { name } }")) + .query::(user_query::Variables {}) .await .expect("Query should succeed") .expect("Query result should have a value"); - assert_eq!(data, json!({ "user": { "name": "remote" } })); + assert_eq!(data.user.name, "remote".to_string()); } #[tokio::test] @@ -623,11 +582,11 @@ mod test { // Query the subgraph let data = client - .query::(Query::new("{ user(id: 1} { name } }")) + .query::(user_query::Variables {}) .await .expect("Query should succeed") .expect("Query result should have a value"); - assert_eq!(data, json!({ "user": { "name": "remote" } })); + assert_eq!(data.user.name, "remote".to_string()); } } diff --git a/graphql/allocations.query.graphql b/graphql/allocations.query.graphql new file mode 100644 index 000000000..ac155c914 --- /dev/null +++ b/graphql/allocations.query.graphql @@ -0,0 +1,51 @@ +query AllocationsQuery( + $indexer: ID!, + $closedAtThreshold: Int!, + $block: Block_height, + $first: Int!, + $last: ID!, + ) { + meta: _meta(block: $block) { block { number hash timestamp } } + allocations( + block: $block + orderBy: id + orderDirection: asc + first: $first + where: { + and: [ + { id_gt: $last } + { indexer_: { id: $indexer } } + { + or: [ + { status: Active } + { + and: [ + { + status: Closed + closedAt_gte: $closedAtThreshold + } + ] + } + ] + } + ] + } + ) { + ...AllocationFragment + } +} + +fragment AllocationFragment on Allocation { + id + indexer { + id + } + allocatedTokens + createdAtBlockHash + createdAtEpoch + closedAtEpoch + subgraphDeployment { + id + deniedAt + } +} diff --git a/graphql/dispute.query.graphql b/graphql/dispute.query.graphql new file mode 100644 index 000000000..ff6e0522e --- /dev/null +++ b/graphql/dispute.query.graphql @@ -0,0 +1,5 @@ +query DisputeManager { + graphNetwork(id: 1) { + disputeManager + } +} diff --git a/graphql/epoch.query.graphql b/graphql/epoch.query.graphql new file mode 100644 index 000000000..24016e95b --- /dev/null +++ b/graphql/epoch.query.graphql @@ -0,0 +1,5 @@ +query CurrentEpoch { + graphNetwork(id: 1) { + currentEpoch + } +} diff --git a/graphql/escrow_account.query.graphql b/graphql/escrow_account.query.graphql new file mode 100644 index 000000000..8372d7272 --- /dev/null +++ b/graphql/escrow_account.query.graphql @@ -0,0 +1,15 @@ +query EscrowAccountQuery($indexer: ID!, $thawEndTimestamp: BigInt!) { + escrowAccounts(where: { receiver_: { id: $indexer } }) { + balance + totalAmountThawing + sender { + id + signers(where: { + thawEndTimestamp_lte: $thawEndTimestamp + isAuthorized: true + }) { + id + } + } + } +} diff --git a/graphql/network.schema.graphql b/graphql/network.schema.graphql new file mode 100644 index 000000000..c203e5517 --- /dev/null +++ b/graphql/network.schema.graphql @@ -0,0 +1,12392 @@ +""" +Marks the GraphQL type as indexable entity. Each type that should be an entity +is required to be annotated with this directive. +""" +directive @entity on OBJECT + +"""Defined a Subgraph ID for an object type""" +directive @subgraphId(id: String!) on OBJECT + +""" +creates a virtual field on the entity that may be queried but cannot be set manually through the mappings API. +""" +directive @derivedFrom(field: String!) on FIELD_DEFINITION + +type _Block_ { + """The hash of the block""" + hash: Bytes + + """The block number""" + number: Int! + + """Integer representation of the timestamp stored in blocks for the chain""" + timestamp: Int + + """The hash of the parent block""" + parentHash: Bytes +} + +"""The type for the top-level _meta field""" +type _Meta_ { + """ + Information about a specific subgraph block. The hash of the block + will be null if the _meta field has a block constraint that asks for + a block number. It will be filled if the _meta field has no block constraint + and therefore asks for the latest block + + """ + block: _Block_! + + """The deployment ID""" + deployment: String! + + """If `true`, the subgraph encountered indexing errors at some past block""" + hasIndexingErrors: Boolean! +} + +enum _SubgraphErrorPolicy_ { + """Data will be returned even if the subgraph has indexing errors""" + allow + + """ + If the subgraph has indexing errors, data will be omitted. The default. + """ + deny +} + +enum Aggregation_interval { + hour + day +} + +""" +A state channel Allocation representing a single Indexer-SubgraphDeployment stake + +""" +type Allocation { + """Channel Address""" + id: ID! + + """Indexer of this allocation""" + indexer: Indexer! + + """Creator of the allocation - can be the operator or the indexer""" + creator: Bytes! + + """ + If the Allocation is active it shows the indexer. If closed, it is null + """ + activeForIndexer: Indexer + + """Subgraph deployment that is being allocated to""" + subgraphDeployment: SubgraphDeployment! + + """Tokens allocation in this allocation""" + allocatedTokens: BigInt! + + """[DEPRECATED] Effective allocation that is realized upon closing""" + effectiveAllocation: BigInt! + + """Epoch this allocation was created""" + createdAtEpoch: Int! + + """Block at which this allocation was created""" + createdAtBlockHash: Bytes! + + """Block number at which this allocation was created""" + createdAtBlockNumber: Int! + + """Epoch this allocation was closed in""" + closedAtEpoch: Int + + """Block hash at which this allocation was closed""" + closedAtBlockHash: Bytes + + """Block number at which this allocation was closed""" + closedAtBlockNumber: Int + + """ + Fees this allocation collected from query fees upon closing. Excludes curator reward and protocol tax + """ + queryFeesCollected: BigInt! + + """ + Query fee rebate amount claimed from the protocol through rebates mechanism. Does not include portion given to delegators + """ + queryFeeRebates: BigInt! + + """ + Query fee rebates collected from the protocol. Can differ from queryFeeRebates + if multiple vouchers per allocation are allowed. + """ + distributedRebates: BigInt! + + """Curator rewards deposited to the curating bonding curve""" + curatorRewards: BigInt! + + """ + Indexing rewards earned by this allocation. Includes delegator and indexer rewards + """ + indexingRewards: BigInt! + + """Indexing rewards earned by this allocation by indexers""" + indexingIndexerRewards: BigInt! + + """Indexing rewards earned by this allocation by delegators""" + indexingDelegatorRewards: BigInt! + + """[DEPRECATED] Pool in which this allocation was closed""" + poolClosedIn: Pool + + """Fees paid out to delegators""" + delegationFees: BigInt! + + """Status of the allocation""" + status: AllocationStatus! + + """Timestamp this allocation was created at""" + createdAt: Int! + + """Timestamp this allocation was closed at""" + closedAt: Int + + """POI submitted with a closed allocation""" + poi: Bytes + indexingRewardCutAtStart: Int! + indexingRewardEffectiveCutAtStart: BigDecimal! + queryFeeCutAtStart: Int! + queryFeeEffectiveCutAtStart: BigDecimal! + indexingRewardCutAtClose: Int + indexingRewardEffectiveCutAtClose: BigDecimal + queryFeeCutAtClose: Int + queryFeeEffectiveCutAtClose: BigDecimal + + """NOT IMPLEMENTED - Return for this allocation""" + totalReturn: BigDecimal! + + """NOT IMPLEMENTED - Yearly annualzied return""" + annualizedReturn: BigDecimal! +} + +input Allocation_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + indexer: String + indexer_not: String + indexer_gt: String + indexer_lt: String + indexer_gte: String + indexer_lte: String + indexer_in: [String!] + indexer_not_in: [String!] + indexer_contains: String + indexer_contains_nocase: String + indexer_not_contains: String + indexer_not_contains_nocase: String + indexer_starts_with: String + indexer_starts_with_nocase: String + indexer_not_starts_with: String + indexer_not_starts_with_nocase: String + indexer_ends_with: String + indexer_ends_with_nocase: String + indexer_not_ends_with: String + indexer_not_ends_with_nocase: String + indexer_: Indexer_filter + creator: Bytes + creator_not: Bytes + creator_gt: Bytes + creator_lt: Bytes + creator_gte: Bytes + creator_lte: Bytes + creator_in: [Bytes!] + creator_not_in: [Bytes!] + creator_contains: Bytes + creator_not_contains: Bytes + activeForIndexer: String + activeForIndexer_not: String + activeForIndexer_gt: String + activeForIndexer_lt: String + activeForIndexer_gte: String + activeForIndexer_lte: String + activeForIndexer_in: [String!] + activeForIndexer_not_in: [String!] + activeForIndexer_contains: String + activeForIndexer_contains_nocase: String + activeForIndexer_not_contains: String + activeForIndexer_not_contains_nocase: String + activeForIndexer_starts_with: String + activeForIndexer_starts_with_nocase: String + activeForIndexer_not_starts_with: String + activeForIndexer_not_starts_with_nocase: String + activeForIndexer_ends_with: String + activeForIndexer_ends_with_nocase: String + activeForIndexer_not_ends_with: String + activeForIndexer_not_ends_with_nocase: String + activeForIndexer_: Indexer_filter + subgraphDeployment: String + subgraphDeployment_not: String + subgraphDeployment_gt: String + subgraphDeployment_lt: String + subgraphDeployment_gte: String + subgraphDeployment_lte: String + subgraphDeployment_in: [String!] + subgraphDeployment_not_in: [String!] + subgraphDeployment_contains: String + subgraphDeployment_contains_nocase: String + subgraphDeployment_not_contains: String + subgraphDeployment_not_contains_nocase: String + subgraphDeployment_starts_with: String + subgraphDeployment_starts_with_nocase: String + subgraphDeployment_not_starts_with: String + subgraphDeployment_not_starts_with_nocase: String + subgraphDeployment_ends_with: String + subgraphDeployment_ends_with_nocase: String + subgraphDeployment_not_ends_with: String + subgraphDeployment_not_ends_with_nocase: String + subgraphDeployment_: SubgraphDeployment_filter + allocatedTokens: BigInt + allocatedTokens_not: BigInt + allocatedTokens_gt: BigInt + allocatedTokens_lt: BigInt + allocatedTokens_gte: BigInt + allocatedTokens_lte: BigInt + allocatedTokens_in: [BigInt!] + allocatedTokens_not_in: [BigInt!] + effectiveAllocation: BigInt + effectiveAllocation_not: BigInt + effectiveAllocation_gt: BigInt + effectiveAllocation_lt: BigInt + effectiveAllocation_gte: BigInt + effectiveAllocation_lte: BigInt + effectiveAllocation_in: [BigInt!] + effectiveAllocation_not_in: [BigInt!] + createdAtEpoch: Int + createdAtEpoch_not: Int + createdAtEpoch_gt: Int + createdAtEpoch_lt: Int + createdAtEpoch_gte: Int + createdAtEpoch_lte: Int + createdAtEpoch_in: [Int!] + createdAtEpoch_not_in: [Int!] + createdAtBlockHash: Bytes + createdAtBlockHash_not: Bytes + createdAtBlockHash_gt: Bytes + createdAtBlockHash_lt: Bytes + createdAtBlockHash_gte: Bytes + createdAtBlockHash_lte: Bytes + createdAtBlockHash_in: [Bytes!] + createdAtBlockHash_not_in: [Bytes!] + createdAtBlockHash_contains: Bytes + createdAtBlockHash_not_contains: Bytes + createdAtBlockNumber: Int + createdAtBlockNumber_not: Int + createdAtBlockNumber_gt: Int + createdAtBlockNumber_lt: Int + createdAtBlockNumber_gte: Int + createdAtBlockNumber_lte: Int + createdAtBlockNumber_in: [Int!] + createdAtBlockNumber_not_in: [Int!] + closedAtEpoch: Int + closedAtEpoch_not: Int + closedAtEpoch_gt: Int + closedAtEpoch_lt: Int + closedAtEpoch_gte: Int + closedAtEpoch_lte: Int + closedAtEpoch_in: [Int!] + closedAtEpoch_not_in: [Int!] + closedAtBlockHash: Bytes + closedAtBlockHash_not: Bytes + closedAtBlockHash_gt: Bytes + closedAtBlockHash_lt: Bytes + closedAtBlockHash_gte: Bytes + closedAtBlockHash_lte: Bytes + closedAtBlockHash_in: [Bytes!] + closedAtBlockHash_not_in: [Bytes!] + closedAtBlockHash_contains: Bytes + closedAtBlockHash_not_contains: Bytes + closedAtBlockNumber: Int + closedAtBlockNumber_not: Int + closedAtBlockNumber_gt: Int + closedAtBlockNumber_lt: Int + closedAtBlockNumber_gte: Int + closedAtBlockNumber_lte: Int + closedAtBlockNumber_in: [Int!] + closedAtBlockNumber_not_in: [Int!] + queryFeesCollected: BigInt + queryFeesCollected_not: BigInt + queryFeesCollected_gt: BigInt + queryFeesCollected_lt: BigInt + queryFeesCollected_gte: BigInt + queryFeesCollected_lte: BigInt + queryFeesCollected_in: [BigInt!] + queryFeesCollected_not_in: [BigInt!] + queryFeeRebates: BigInt + queryFeeRebates_not: BigInt + queryFeeRebates_gt: BigInt + queryFeeRebates_lt: BigInt + queryFeeRebates_gte: BigInt + queryFeeRebates_lte: BigInt + queryFeeRebates_in: [BigInt!] + queryFeeRebates_not_in: [BigInt!] + distributedRebates: BigInt + distributedRebates_not: BigInt + distributedRebates_gt: BigInt + distributedRebates_lt: BigInt + distributedRebates_gte: BigInt + distributedRebates_lte: BigInt + distributedRebates_in: [BigInt!] + distributedRebates_not_in: [BigInt!] + curatorRewards: BigInt + curatorRewards_not: BigInt + curatorRewards_gt: BigInt + curatorRewards_lt: BigInt + curatorRewards_gte: BigInt + curatorRewards_lte: BigInt + curatorRewards_in: [BigInt!] + curatorRewards_not_in: [BigInt!] + indexingRewards: BigInt + indexingRewards_not: BigInt + indexingRewards_gt: BigInt + indexingRewards_lt: BigInt + indexingRewards_gte: BigInt + indexingRewards_lte: BigInt + indexingRewards_in: [BigInt!] + indexingRewards_not_in: [BigInt!] + indexingIndexerRewards: BigInt + indexingIndexerRewards_not: BigInt + indexingIndexerRewards_gt: BigInt + indexingIndexerRewards_lt: BigInt + indexingIndexerRewards_gte: BigInt + indexingIndexerRewards_lte: BigInt + indexingIndexerRewards_in: [BigInt!] + indexingIndexerRewards_not_in: [BigInt!] + indexingDelegatorRewards: BigInt + indexingDelegatorRewards_not: BigInt + indexingDelegatorRewards_gt: BigInt + indexingDelegatorRewards_lt: BigInt + indexingDelegatorRewards_gte: BigInt + indexingDelegatorRewards_lte: BigInt + indexingDelegatorRewards_in: [BigInt!] + indexingDelegatorRewards_not_in: [BigInt!] + poolClosedIn: String + poolClosedIn_not: String + poolClosedIn_gt: String + poolClosedIn_lt: String + poolClosedIn_gte: String + poolClosedIn_lte: String + poolClosedIn_in: [String!] + poolClosedIn_not_in: [String!] + poolClosedIn_contains: String + poolClosedIn_contains_nocase: String + poolClosedIn_not_contains: String + poolClosedIn_not_contains_nocase: String + poolClosedIn_starts_with: String + poolClosedIn_starts_with_nocase: String + poolClosedIn_not_starts_with: String + poolClosedIn_not_starts_with_nocase: String + poolClosedIn_ends_with: String + poolClosedIn_ends_with_nocase: String + poolClosedIn_not_ends_with: String + poolClosedIn_not_ends_with_nocase: String + poolClosedIn_: Pool_filter + delegationFees: BigInt + delegationFees_not: BigInt + delegationFees_gt: BigInt + delegationFees_lt: BigInt + delegationFees_gte: BigInt + delegationFees_lte: BigInt + delegationFees_in: [BigInt!] + delegationFees_not_in: [BigInt!] + status: AllocationStatus + status_not: AllocationStatus + status_in: [AllocationStatus!] + status_not_in: [AllocationStatus!] + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + closedAt: Int + closedAt_not: Int + closedAt_gt: Int + closedAt_lt: Int + closedAt_gte: Int + closedAt_lte: Int + closedAt_in: [Int!] + closedAt_not_in: [Int!] + poi: Bytes + poi_not: Bytes + poi_gt: Bytes + poi_lt: Bytes + poi_gte: Bytes + poi_lte: Bytes + poi_in: [Bytes!] + poi_not_in: [Bytes!] + poi_contains: Bytes + poi_not_contains: Bytes + indexingRewardCutAtStart: Int + indexingRewardCutAtStart_not: Int + indexingRewardCutAtStart_gt: Int + indexingRewardCutAtStart_lt: Int + indexingRewardCutAtStart_gte: Int + indexingRewardCutAtStart_lte: Int + indexingRewardCutAtStart_in: [Int!] + indexingRewardCutAtStart_not_in: [Int!] + indexingRewardEffectiveCutAtStart: BigDecimal + indexingRewardEffectiveCutAtStart_not: BigDecimal + indexingRewardEffectiveCutAtStart_gt: BigDecimal + indexingRewardEffectiveCutAtStart_lt: BigDecimal + indexingRewardEffectiveCutAtStart_gte: BigDecimal + indexingRewardEffectiveCutAtStart_lte: BigDecimal + indexingRewardEffectiveCutAtStart_in: [BigDecimal!] + indexingRewardEffectiveCutAtStart_not_in: [BigDecimal!] + queryFeeCutAtStart: Int + queryFeeCutAtStart_not: Int + queryFeeCutAtStart_gt: Int + queryFeeCutAtStart_lt: Int + queryFeeCutAtStart_gte: Int + queryFeeCutAtStart_lte: Int + queryFeeCutAtStart_in: [Int!] + queryFeeCutAtStart_not_in: [Int!] + queryFeeEffectiveCutAtStart: BigDecimal + queryFeeEffectiveCutAtStart_not: BigDecimal + queryFeeEffectiveCutAtStart_gt: BigDecimal + queryFeeEffectiveCutAtStart_lt: BigDecimal + queryFeeEffectiveCutAtStart_gte: BigDecimal + queryFeeEffectiveCutAtStart_lte: BigDecimal + queryFeeEffectiveCutAtStart_in: [BigDecimal!] + queryFeeEffectiveCutAtStart_not_in: [BigDecimal!] + indexingRewardCutAtClose: Int + indexingRewardCutAtClose_not: Int + indexingRewardCutAtClose_gt: Int + indexingRewardCutAtClose_lt: Int + indexingRewardCutAtClose_gte: Int + indexingRewardCutAtClose_lte: Int + indexingRewardCutAtClose_in: [Int!] + indexingRewardCutAtClose_not_in: [Int!] + indexingRewardEffectiveCutAtClose: BigDecimal + indexingRewardEffectiveCutAtClose_not: BigDecimal + indexingRewardEffectiveCutAtClose_gt: BigDecimal + indexingRewardEffectiveCutAtClose_lt: BigDecimal + indexingRewardEffectiveCutAtClose_gte: BigDecimal + indexingRewardEffectiveCutAtClose_lte: BigDecimal + indexingRewardEffectiveCutAtClose_in: [BigDecimal!] + indexingRewardEffectiveCutAtClose_not_in: [BigDecimal!] + queryFeeCutAtClose: Int + queryFeeCutAtClose_not: Int + queryFeeCutAtClose_gt: Int + queryFeeCutAtClose_lt: Int + queryFeeCutAtClose_gte: Int + queryFeeCutAtClose_lte: Int + queryFeeCutAtClose_in: [Int!] + queryFeeCutAtClose_not_in: [Int!] + queryFeeEffectiveCutAtClose: BigDecimal + queryFeeEffectiveCutAtClose_not: BigDecimal + queryFeeEffectiveCutAtClose_gt: BigDecimal + queryFeeEffectiveCutAtClose_lt: BigDecimal + queryFeeEffectiveCutAtClose_gte: BigDecimal + queryFeeEffectiveCutAtClose_lte: BigDecimal + queryFeeEffectiveCutAtClose_in: [BigDecimal!] + queryFeeEffectiveCutAtClose_not_in: [BigDecimal!] + totalReturn: BigDecimal + totalReturn_not: BigDecimal + totalReturn_gt: BigDecimal + totalReturn_lt: BigDecimal + totalReturn_gte: BigDecimal + totalReturn_lte: BigDecimal + totalReturn_in: [BigDecimal!] + totalReturn_not_in: [BigDecimal!] + annualizedReturn: BigDecimal + annualizedReturn_not: BigDecimal + annualizedReturn_gt: BigDecimal + annualizedReturn_lt: BigDecimal + annualizedReturn_gte: BigDecimal + annualizedReturn_lte: BigDecimal + annualizedReturn_in: [BigDecimal!] + annualizedReturn_not_in: [BigDecimal!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Allocation_filter] + or: [Allocation_filter] +} + +enum Allocation_orderBy { + id + indexer + indexer__id + indexer__createdAt + indexer__url + indexer__geoHash + indexer__defaultDisplayName + indexer__stakedTokens + indexer__allocatedTokens + indexer__unstakedTokens + indexer__lockedTokens + indexer__tokensLockedUntil + indexer__allocationCount + indexer__totalAllocationCount + indexer__queryFeesCollected + indexer__queryFeeRebates + indexer__rewardsEarned + indexer__indexerIndexingRewards + indexer__delegatorIndexingRewards + indexer__indexerRewardsOwnGenerationRatio + indexer__transferredToL2 + indexer__firstTransferredToL2At + indexer__firstTransferredToL2AtBlockNumber + indexer__firstTransferredToL2AtTx + indexer__lastTransferredToL2At + indexer__lastTransferredToL2AtBlockNumber + indexer__lastTransferredToL2AtTx + indexer__stakedTokensTransferredToL2 + indexer__idOnL2 + indexer__idOnL1 + indexer__delegatedCapacity + indexer__tokenCapacity + indexer__availableStake + indexer__delegatedTokens + indexer__ownStakeRatio + indexer__delegatedStakeRatio + indexer__delegatorShares + indexer__delegationExchangeRate + indexer__indexingRewardCut + indexer__indexingRewardEffectiveCut + indexer__overDelegationDilution + indexer__delegatorQueryFees + indexer__queryFeeCut + indexer__queryFeeEffectiveCut + indexer__delegatorParameterCooldown + indexer__lastDelegationParameterUpdate + indexer__forcedClosures + indexer__totalReturn + indexer__annualizedReturn + indexer__stakingEfficiency + creator + activeForIndexer + activeForIndexer__id + activeForIndexer__createdAt + activeForIndexer__url + activeForIndexer__geoHash + activeForIndexer__defaultDisplayName + activeForIndexer__stakedTokens + activeForIndexer__allocatedTokens + activeForIndexer__unstakedTokens + activeForIndexer__lockedTokens + activeForIndexer__tokensLockedUntil + activeForIndexer__allocationCount + activeForIndexer__totalAllocationCount + activeForIndexer__queryFeesCollected + activeForIndexer__queryFeeRebates + activeForIndexer__rewardsEarned + activeForIndexer__indexerIndexingRewards + activeForIndexer__delegatorIndexingRewards + activeForIndexer__indexerRewardsOwnGenerationRatio + activeForIndexer__transferredToL2 + activeForIndexer__firstTransferredToL2At + activeForIndexer__firstTransferredToL2AtBlockNumber + activeForIndexer__firstTransferredToL2AtTx + activeForIndexer__lastTransferredToL2At + activeForIndexer__lastTransferredToL2AtBlockNumber + activeForIndexer__lastTransferredToL2AtTx + activeForIndexer__stakedTokensTransferredToL2 + activeForIndexer__idOnL2 + activeForIndexer__idOnL1 + activeForIndexer__delegatedCapacity + activeForIndexer__tokenCapacity + activeForIndexer__availableStake + activeForIndexer__delegatedTokens + activeForIndexer__ownStakeRatio + activeForIndexer__delegatedStakeRatio + activeForIndexer__delegatorShares + activeForIndexer__delegationExchangeRate + activeForIndexer__indexingRewardCut + activeForIndexer__indexingRewardEffectiveCut + activeForIndexer__overDelegationDilution + activeForIndexer__delegatorQueryFees + activeForIndexer__queryFeeCut + activeForIndexer__queryFeeEffectiveCut + activeForIndexer__delegatorParameterCooldown + activeForIndexer__lastDelegationParameterUpdate + activeForIndexer__forcedClosures + activeForIndexer__totalReturn + activeForIndexer__annualizedReturn + activeForIndexer__stakingEfficiency + subgraphDeployment + subgraphDeployment__id + subgraphDeployment__ipfsHash + subgraphDeployment__createdAt + subgraphDeployment__deniedAt + subgraphDeployment__originalName + subgraphDeployment__stakedTokens + subgraphDeployment__indexingRewardAmount + subgraphDeployment__indexingIndexerRewardAmount + subgraphDeployment__indexingDelegatorRewardAmount + subgraphDeployment__queryFeesAmount + subgraphDeployment__queryFeeRebates + subgraphDeployment__curatorFeeRewards + subgraphDeployment__signalledTokens + subgraphDeployment__unsignalledTokens + subgraphDeployment__signalAmount + subgraphDeployment__pricePerShare + subgraphDeployment__reserveRatio + subgraphDeployment__subgraphCount + subgraphDeployment__activeSubgraphCount + subgraphDeployment__deprecatedSubgraphCount + subgraphDeployment__transferredToL2 + subgraphDeployment__transferredToL2At + subgraphDeployment__transferredToL2AtBlockNumber + subgraphDeployment__transferredToL2AtTx + subgraphDeployment__signalledTokensSentToL2 + subgraphDeployment__signalledTokensReceivedOnL2 + allocatedTokens + effectiveAllocation + createdAtEpoch + createdAtBlockHash + createdAtBlockNumber + closedAtEpoch + closedAtBlockHash + closedAtBlockNumber + queryFeesCollected + queryFeeRebates + distributedRebates + curatorRewards + indexingRewards + indexingIndexerRewards + indexingDelegatorRewards + poolClosedIn + poolClosedIn__id + poolClosedIn__allocation + poolClosedIn__totalQueryFees + poolClosedIn__claimedFees + poolClosedIn__curatorRewards + delegationFees + status + createdAt + closedAt + poi + indexingRewardCutAtStart + indexingRewardEffectiveCutAtStart + queryFeeCutAtStart + queryFeeEffectiveCutAtStart + indexingRewardCutAtClose + indexingRewardEffectiveCutAtClose + queryFeeCutAtClose + queryFeeEffectiveCutAtClose + totalReturn + annualizedReturn +} + +enum AllocationStatus { + Null + Active + Closed + Finalized + Claimed +} + +""" +Attestation of a dispute + +""" +type Attestation { + """Concatenation of the requestCID and responseCID""" + id: ID! + + """Subgraph deployment being disputed""" + subgraphDeployment: SubgraphDeployment! + + """RequestCID""" + requestCID: String! + + """ResponseCID""" + responseCID: String! + + """NOT IMPLEMENTED - Gas used by the attested query""" + gasUsed: BigInt + + """NOT IMPLEMENTED - Bytes of attested query""" + responseNumBytes: BigInt + + """V of the indexers signature""" + v: Int! + + """R of the indexers signature""" + r: String! + + """S of the indexers signature""" + s: String! +} + +input Attestation_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + subgraphDeployment: String + subgraphDeployment_not: String + subgraphDeployment_gt: String + subgraphDeployment_lt: String + subgraphDeployment_gte: String + subgraphDeployment_lte: String + subgraphDeployment_in: [String!] + subgraphDeployment_not_in: [String!] + subgraphDeployment_contains: String + subgraphDeployment_contains_nocase: String + subgraphDeployment_not_contains: String + subgraphDeployment_not_contains_nocase: String + subgraphDeployment_starts_with: String + subgraphDeployment_starts_with_nocase: String + subgraphDeployment_not_starts_with: String + subgraphDeployment_not_starts_with_nocase: String + subgraphDeployment_ends_with: String + subgraphDeployment_ends_with_nocase: String + subgraphDeployment_not_ends_with: String + subgraphDeployment_not_ends_with_nocase: String + subgraphDeployment_: SubgraphDeployment_filter + requestCID: String + requestCID_not: String + requestCID_gt: String + requestCID_lt: String + requestCID_gte: String + requestCID_lte: String + requestCID_in: [String!] + requestCID_not_in: [String!] + requestCID_contains: String + requestCID_contains_nocase: String + requestCID_not_contains: String + requestCID_not_contains_nocase: String + requestCID_starts_with: String + requestCID_starts_with_nocase: String + requestCID_not_starts_with: String + requestCID_not_starts_with_nocase: String + requestCID_ends_with: String + requestCID_ends_with_nocase: String + requestCID_not_ends_with: String + requestCID_not_ends_with_nocase: String + responseCID: String + responseCID_not: String + responseCID_gt: String + responseCID_lt: String + responseCID_gte: String + responseCID_lte: String + responseCID_in: [String!] + responseCID_not_in: [String!] + responseCID_contains: String + responseCID_contains_nocase: String + responseCID_not_contains: String + responseCID_not_contains_nocase: String + responseCID_starts_with: String + responseCID_starts_with_nocase: String + responseCID_not_starts_with: String + responseCID_not_starts_with_nocase: String + responseCID_ends_with: String + responseCID_ends_with_nocase: String + responseCID_not_ends_with: String + responseCID_not_ends_with_nocase: String + gasUsed: BigInt + gasUsed_not: BigInt + gasUsed_gt: BigInt + gasUsed_lt: BigInt + gasUsed_gte: BigInt + gasUsed_lte: BigInt + gasUsed_in: [BigInt!] + gasUsed_not_in: [BigInt!] + responseNumBytes: BigInt + responseNumBytes_not: BigInt + responseNumBytes_gt: BigInt + responseNumBytes_lt: BigInt + responseNumBytes_gte: BigInt + responseNumBytes_lte: BigInt + responseNumBytes_in: [BigInt!] + responseNumBytes_not_in: [BigInt!] + v: Int + v_not: Int + v_gt: Int + v_lt: Int + v_gte: Int + v_lte: Int + v_in: [Int!] + v_not_in: [Int!] + r: String + r_not: String + r_gt: String + r_lt: String + r_gte: String + r_lte: String + r_in: [String!] + r_not_in: [String!] + r_contains: String + r_contains_nocase: String + r_not_contains: String + r_not_contains_nocase: String + r_starts_with: String + r_starts_with_nocase: String + r_not_starts_with: String + r_not_starts_with_nocase: String + r_ends_with: String + r_ends_with_nocase: String + r_not_ends_with: String + r_not_ends_with_nocase: String + s: String + s_not: String + s_gt: String + s_lt: String + s_gte: String + s_lte: String + s_in: [String!] + s_not_in: [String!] + s_contains: String + s_contains_nocase: String + s_not_contains: String + s_not_contains_nocase: String + s_starts_with: String + s_starts_with_nocase: String + s_not_starts_with: String + s_not_starts_with_nocase: String + s_ends_with: String + s_ends_with_nocase: String + s_not_ends_with: String + s_not_ends_with_nocase: String + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Attestation_filter] + or: [Attestation_filter] +} + +enum Attestation_orderBy { + id + subgraphDeployment + subgraphDeployment__id + subgraphDeployment__ipfsHash + subgraphDeployment__createdAt + subgraphDeployment__deniedAt + subgraphDeployment__originalName + subgraphDeployment__stakedTokens + subgraphDeployment__indexingRewardAmount + subgraphDeployment__indexingIndexerRewardAmount + subgraphDeployment__indexingDelegatorRewardAmount + subgraphDeployment__queryFeesAmount + subgraphDeployment__queryFeeRebates + subgraphDeployment__curatorFeeRewards + subgraphDeployment__signalledTokens + subgraphDeployment__unsignalledTokens + subgraphDeployment__signalAmount + subgraphDeployment__pricePerShare + subgraphDeployment__reserveRatio + subgraphDeployment__subgraphCount + subgraphDeployment__activeSubgraphCount + subgraphDeployment__deprecatedSubgraphCount + subgraphDeployment__transferredToL2 + subgraphDeployment__transferredToL2At + subgraphDeployment__transferredToL2AtBlockNumber + subgraphDeployment__transferredToL2AtTx + subgraphDeployment__signalledTokensSentToL2 + subgraphDeployment__signalledTokensReceivedOnL2 + requestCID + responseCID + gasUsed + responseNumBytes + v + r + s +} + +""" +Authorized functions for the Manager + +""" +type AuthorizedFunction { + """Function signature (string)""" + id: ID! + + """ + The contract address that is authorized to have this function called on itself + """ + target: Bytes! + + """Hash of the function signature""" + sigHash: Bytes! + + """Token lock Manager""" + manager: TokenManager! +} + +input AuthorizedFunction_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + target: Bytes + target_not: Bytes + target_gt: Bytes + target_lt: Bytes + target_gte: Bytes + target_lte: Bytes + target_in: [Bytes!] + target_not_in: [Bytes!] + target_contains: Bytes + target_not_contains: Bytes + sigHash: Bytes + sigHash_not: Bytes + sigHash_gt: Bytes + sigHash_lt: Bytes + sigHash_gte: Bytes + sigHash_lte: Bytes + sigHash_in: [Bytes!] + sigHash_not_in: [Bytes!] + sigHash_contains: Bytes + sigHash_not_contains: Bytes + manager: String + manager_not: String + manager_gt: String + manager_lt: String + manager_gte: String + manager_lte: String + manager_in: [String!] + manager_not_in: [String!] + manager_contains: String + manager_contains_nocase: String + manager_not_contains: String + manager_not_contains_nocase: String + manager_starts_with: String + manager_starts_with_nocase: String + manager_not_starts_with: String + manager_not_starts_with_nocase: String + manager_ends_with: String + manager_ends_with_nocase: String + manager_not_ends_with: String + manager_not_ends_with_nocase: String + manager_: TokenManager_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [AuthorizedFunction_filter] + or: [AuthorizedFunction_filter] +} + +enum AuthorizedFunction_orderBy { + id + target + sigHash + manager + manager__id + manager__masterCopy + manager__tokens + manager__tokenLockCount +} + +scalar BigDecimal + +scalar BigInt + +input Block_height { + hash: Bytes + number: Int + number_gte: Int +} + +input BlockChangedFilter { + number_gte: Int! +} + +""" +All relevant data for a bridge deposit Transaction in The Graph Network + +""" +type BridgeDepositTransaction implements Transaction { + id: ID! + blockNumber: Int! + timestamp: Int! + signer: GraphAccount! + type: TransactionType! + + """ + txHash refers to the tx on the chain corresponding to this subgraph deployment + """ + txHash: Bytes! + from: Bytes + to: Bytes + amount: BigInt + l1Token: Bytes + + """ + retryableTicketId is the unique value that allows matching an L2 transaction with its L1 counterpart + """ + retryableTicketId: String + + """ + Whether the deposit was initiated through Arbitrum's gateway router (Only available on L1 networks) + """ + routed: Boolean +} + +input BridgeDepositTransaction_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + blockNumber: Int + blockNumber_not: Int + blockNumber_gt: Int + blockNumber_lt: Int + blockNumber_gte: Int + blockNumber_lte: Int + blockNumber_in: [Int!] + blockNumber_not_in: [Int!] + timestamp: Int + timestamp_not: Int + timestamp_gt: Int + timestamp_lt: Int + timestamp_gte: Int + timestamp_lte: Int + timestamp_in: [Int!] + timestamp_not_in: [Int!] + signer: String + signer_not: String + signer_gt: String + signer_lt: String + signer_gte: String + signer_lte: String + signer_in: [String!] + signer_not_in: [String!] + signer_contains: String + signer_contains_nocase: String + signer_not_contains: String + signer_not_contains_nocase: String + signer_starts_with: String + signer_starts_with_nocase: String + signer_not_starts_with: String + signer_not_starts_with_nocase: String + signer_ends_with: String + signer_ends_with_nocase: String + signer_not_ends_with: String + signer_not_ends_with_nocase: String + signer_: GraphAccount_filter + type: TransactionType + type_not: TransactionType + type_in: [TransactionType!] + type_not_in: [TransactionType!] + txHash: Bytes + txHash_not: Bytes + txHash_gt: Bytes + txHash_lt: Bytes + txHash_gte: Bytes + txHash_lte: Bytes + txHash_in: [Bytes!] + txHash_not_in: [Bytes!] + txHash_contains: Bytes + txHash_not_contains: Bytes + from: Bytes + from_not: Bytes + from_gt: Bytes + from_lt: Bytes + from_gte: Bytes + from_lte: Bytes + from_in: [Bytes!] + from_not_in: [Bytes!] + from_contains: Bytes + from_not_contains: Bytes + to: Bytes + to_not: Bytes + to_gt: Bytes + to_lt: Bytes + to_gte: Bytes + to_lte: Bytes + to_in: [Bytes!] + to_not_in: [Bytes!] + to_contains: Bytes + to_not_contains: Bytes + amount: BigInt + amount_not: BigInt + amount_gt: BigInt + amount_lt: BigInt + amount_gte: BigInt + amount_lte: BigInt + amount_in: [BigInt!] + amount_not_in: [BigInt!] + l1Token: Bytes + l1Token_not: Bytes + l1Token_gt: Bytes + l1Token_lt: Bytes + l1Token_gte: Bytes + l1Token_lte: Bytes + l1Token_in: [Bytes!] + l1Token_not_in: [Bytes!] + l1Token_contains: Bytes + l1Token_not_contains: Bytes + retryableTicketId: String + retryableTicketId_not: String + retryableTicketId_gt: String + retryableTicketId_lt: String + retryableTicketId_gte: String + retryableTicketId_lte: String + retryableTicketId_in: [String!] + retryableTicketId_not_in: [String!] + retryableTicketId_contains: String + retryableTicketId_contains_nocase: String + retryableTicketId_not_contains: String + retryableTicketId_not_contains_nocase: String + retryableTicketId_starts_with: String + retryableTicketId_starts_with_nocase: String + retryableTicketId_not_starts_with: String + retryableTicketId_not_starts_with_nocase: String + retryableTicketId_ends_with: String + retryableTicketId_ends_with_nocase: String + retryableTicketId_not_ends_with: String + retryableTicketId_not_ends_with_nocase: String + routed: Boolean + routed_not: Boolean + routed_in: [Boolean!] + routed_not_in: [Boolean!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [BridgeDepositTransaction_filter] + or: [BridgeDepositTransaction_filter] +} + +enum BridgeDepositTransaction_orderBy { + id + blockNumber + timestamp + signer + signer__id + signer__createdAt + signer__defaultDisplayName + signer__balance + signer__balanceReceivedFromL1Signalling + signer__balanceReceivedFromL1Delegation + signer__curationApproval + signer__stakingApproval + signer__gnsApproval + signer__developerCreatedAt + signer__subgraphQueryFees + type + txHash + from + to + amount + l1Token + retryableTicketId + routed +} + +""" +All relevant data for a bridge withdrawal Transaction in The Graph Network + +""" +type BridgeWithdrawalTransaction implements Transaction { + id: ID! + blockNumber: Int! + timestamp: Int! + signer: GraphAccount! + type: TransactionType! + + """ + txHash refers to the tx on the chain corresponding to this subgraph deployment + """ + txHash: Bytes + from: Bytes + to: Bytes + amount: BigInt + l1Token: Bytes + + """ + transactionIndex is the unique value that allows matching an L2 transaction with its L1 counterpart + """ + transactionIndex: BigInt +} + +input BridgeWithdrawalTransaction_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + blockNumber: Int + blockNumber_not: Int + blockNumber_gt: Int + blockNumber_lt: Int + blockNumber_gte: Int + blockNumber_lte: Int + blockNumber_in: [Int!] + blockNumber_not_in: [Int!] + timestamp: Int + timestamp_not: Int + timestamp_gt: Int + timestamp_lt: Int + timestamp_gte: Int + timestamp_lte: Int + timestamp_in: [Int!] + timestamp_not_in: [Int!] + signer: String + signer_not: String + signer_gt: String + signer_lt: String + signer_gte: String + signer_lte: String + signer_in: [String!] + signer_not_in: [String!] + signer_contains: String + signer_contains_nocase: String + signer_not_contains: String + signer_not_contains_nocase: String + signer_starts_with: String + signer_starts_with_nocase: String + signer_not_starts_with: String + signer_not_starts_with_nocase: String + signer_ends_with: String + signer_ends_with_nocase: String + signer_not_ends_with: String + signer_not_ends_with_nocase: String + signer_: GraphAccount_filter + type: TransactionType + type_not: TransactionType + type_in: [TransactionType!] + type_not_in: [TransactionType!] + txHash: Bytes + txHash_not: Bytes + txHash_gt: Bytes + txHash_lt: Bytes + txHash_gte: Bytes + txHash_lte: Bytes + txHash_in: [Bytes!] + txHash_not_in: [Bytes!] + txHash_contains: Bytes + txHash_not_contains: Bytes + from: Bytes + from_not: Bytes + from_gt: Bytes + from_lt: Bytes + from_gte: Bytes + from_lte: Bytes + from_in: [Bytes!] + from_not_in: [Bytes!] + from_contains: Bytes + from_not_contains: Bytes + to: Bytes + to_not: Bytes + to_gt: Bytes + to_lt: Bytes + to_gte: Bytes + to_lte: Bytes + to_in: [Bytes!] + to_not_in: [Bytes!] + to_contains: Bytes + to_not_contains: Bytes + amount: BigInt + amount_not: BigInt + amount_gt: BigInt + amount_lt: BigInt + amount_gte: BigInt + amount_lte: BigInt + amount_in: [BigInt!] + amount_not_in: [BigInt!] + l1Token: Bytes + l1Token_not: Bytes + l1Token_gt: Bytes + l1Token_lt: Bytes + l1Token_gte: Bytes + l1Token_lte: Bytes + l1Token_in: [Bytes!] + l1Token_not_in: [Bytes!] + l1Token_contains: Bytes + l1Token_not_contains: Bytes + transactionIndex: BigInt + transactionIndex_not: BigInt + transactionIndex_gt: BigInt + transactionIndex_lt: BigInt + transactionIndex_gte: BigInt + transactionIndex_lte: BigInt + transactionIndex_in: [BigInt!] + transactionIndex_not_in: [BigInt!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [BridgeWithdrawalTransaction_filter] + or: [BridgeWithdrawalTransaction_filter] +} + +enum BridgeWithdrawalTransaction_orderBy { + id + blockNumber + timestamp + signer + signer__id + signer__createdAt + signer__defaultDisplayName + signer__balance + signer__balanceReceivedFromL1Signalling + signer__balanceReceivedFromL1Delegation + signer__curationApproval + signer__stakingApproval + signer__gnsApproval + signer__developerCreatedAt + signer__subgraphQueryFees + type + txHash + from + to + amount + l1Token + transactionIndex +} + +scalar Bytes + +""" +Curator with all Signals and metrics + +""" +type Curator { + """Eth address of the Curator""" + id: ID! + + """Time this curator was created""" + createdAt: Int! + + """Graph account of this curator""" + account: GraphAccount! + + """CUMULATIVE tokens signalled on all the subgraphs""" + totalSignalledTokens: BigInt! + + """CUMULATIVE tokens unsignalled on all the subgraphs""" + totalUnsignalledTokens: BigInt! + + """Subgraphs the curator is curating""" + signals(skip: Int = 0, first: Int = 100, orderBy: Signal_orderBy, orderDirection: OrderDirection, where: Signal_filter): [Signal!]! + + """ + Default display name is the current default name. Used for filtered queries + """ + defaultDisplayName: String + + """CUMULATIVE tokens signalled on all names""" + totalNameSignalledTokens: BigInt! + + """CUMULATIVE tokens unsignalled on all names""" + totalNameUnsignalledTokens: BigInt! + + """CUMULATIVE withdrawn tokens from deprecated subgraphs""" + totalWithdrawnTokens: BigInt! + + """Subgraphs the curator is curating""" + nameSignals(skip: Int = 0, first: Int = 100, orderBy: NameSignal_orderBy, orderDirection: OrderDirection, where: NameSignal_filter): [NameSignal!]! + + """NOT IMPLEMENTED - Summation of realized rewards from all Signals""" + realizedRewards: BigInt! + + """NOT IMPLEMENTED - Annualized rate of return on curator signal""" + annualizedReturn: BigDecimal! + + """NOT IMPLEMENTED - Total return of the curator""" + totalReturn: BigDecimal! + + """NOT IMPLEMENTED - Signaling efficiency of the curator""" + signalingEfficiency: BigDecimal! + + """CURRENT summed name signal for all bonding curves""" + totalNameSignal: BigDecimal! + + """ + Total curator cost basis of all shares of name pools purchased on all bonding curves + """ + totalNameSignalAverageCostBasis: BigDecimal! + + """totalNameSignalAverageCostBasis / totalNameSignal""" + totalAverageCostBasisPerNameSignal: BigDecimal! + + """CURRENT summed signal for all bonding curves""" + totalSignal: BigDecimal! + + """ + Total curator cost basis of all version signal shares purchased on all bonding + curves. Includes those purchased through GNS name pools + """ + totalSignalAverageCostBasis: BigDecimal! + + """totalSignalAverageCostBasis / totalSignal""" + totalAverageCostBasisPerSignal: BigDecimal! + + """Total amount of signals created by this user""" + signalCount: Int! + + """Amount of active signals for this user""" + activeSignalCount: Int! + + """Total amount of name signals created by this user""" + nameSignalCount: Int! + + """Amount of active name signals for this user""" + activeNameSignalCount: Int! + + """ + Total amount of name signals and signals created by this user. signalCount + nameSignalCount + """ + combinedSignalCount: Int! + + """ + Amount of active name signals and signals for this user. signalCount + nameSignalCount + """ + activeCombinedSignalCount: Int! +} + +input Curator_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + account: String + account_not: String + account_gt: String + account_lt: String + account_gte: String + account_lte: String + account_in: [String!] + account_not_in: [String!] + account_contains: String + account_contains_nocase: String + account_not_contains: String + account_not_contains_nocase: String + account_starts_with: String + account_starts_with_nocase: String + account_not_starts_with: String + account_not_starts_with_nocase: String + account_ends_with: String + account_ends_with_nocase: String + account_not_ends_with: String + account_not_ends_with_nocase: String + account_: GraphAccount_filter + totalSignalledTokens: BigInt + totalSignalledTokens_not: BigInt + totalSignalledTokens_gt: BigInt + totalSignalledTokens_lt: BigInt + totalSignalledTokens_gte: BigInt + totalSignalledTokens_lte: BigInt + totalSignalledTokens_in: [BigInt!] + totalSignalledTokens_not_in: [BigInt!] + totalUnsignalledTokens: BigInt + totalUnsignalledTokens_not: BigInt + totalUnsignalledTokens_gt: BigInt + totalUnsignalledTokens_lt: BigInt + totalUnsignalledTokens_gte: BigInt + totalUnsignalledTokens_lte: BigInt + totalUnsignalledTokens_in: [BigInt!] + totalUnsignalledTokens_not_in: [BigInt!] + signals_: Signal_filter + defaultDisplayName: String + defaultDisplayName_not: String + defaultDisplayName_gt: String + defaultDisplayName_lt: String + defaultDisplayName_gte: String + defaultDisplayName_lte: String + defaultDisplayName_in: [String!] + defaultDisplayName_not_in: [String!] + defaultDisplayName_contains: String + defaultDisplayName_contains_nocase: String + defaultDisplayName_not_contains: String + defaultDisplayName_not_contains_nocase: String + defaultDisplayName_starts_with: String + defaultDisplayName_starts_with_nocase: String + defaultDisplayName_not_starts_with: String + defaultDisplayName_not_starts_with_nocase: String + defaultDisplayName_ends_with: String + defaultDisplayName_ends_with_nocase: String + defaultDisplayName_not_ends_with: String + defaultDisplayName_not_ends_with_nocase: String + totalNameSignalledTokens: BigInt + totalNameSignalledTokens_not: BigInt + totalNameSignalledTokens_gt: BigInt + totalNameSignalledTokens_lt: BigInt + totalNameSignalledTokens_gte: BigInt + totalNameSignalledTokens_lte: BigInt + totalNameSignalledTokens_in: [BigInt!] + totalNameSignalledTokens_not_in: [BigInt!] + totalNameUnsignalledTokens: BigInt + totalNameUnsignalledTokens_not: BigInt + totalNameUnsignalledTokens_gt: BigInt + totalNameUnsignalledTokens_lt: BigInt + totalNameUnsignalledTokens_gte: BigInt + totalNameUnsignalledTokens_lte: BigInt + totalNameUnsignalledTokens_in: [BigInt!] + totalNameUnsignalledTokens_not_in: [BigInt!] + totalWithdrawnTokens: BigInt + totalWithdrawnTokens_not: BigInt + totalWithdrawnTokens_gt: BigInt + totalWithdrawnTokens_lt: BigInt + totalWithdrawnTokens_gte: BigInt + totalWithdrawnTokens_lte: BigInt + totalWithdrawnTokens_in: [BigInt!] + totalWithdrawnTokens_not_in: [BigInt!] + nameSignals_: NameSignal_filter + realizedRewards: BigInt + realizedRewards_not: BigInt + realizedRewards_gt: BigInt + realizedRewards_lt: BigInt + realizedRewards_gte: BigInt + realizedRewards_lte: BigInt + realizedRewards_in: [BigInt!] + realizedRewards_not_in: [BigInt!] + annualizedReturn: BigDecimal + annualizedReturn_not: BigDecimal + annualizedReturn_gt: BigDecimal + annualizedReturn_lt: BigDecimal + annualizedReturn_gte: BigDecimal + annualizedReturn_lte: BigDecimal + annualizedReturn_in: [BigDecimal!] + annualizedReturn_not_in: [BigDecimal!] + totalReturn: BigDecimal + totalReturn_not: BigDecimal + totalReturn_gt: BigDecimal + totalReturn_lt: BigDecimal + totalReturn_gte: BigDecimal + totalReturn_lte: BigDecimal + totalReturn_in: [BigDecimal!] + totalReturn_not_in: [BigDecimal!] + signalingEfficiency: BigDecimal + signalingEfficiency_not: BigDecimal + signalingEfficiency_gt: BigDecimal + signalingEfficiency_lt: BigDecimal + signalingEfficiency_gte: BigDecimal + signalingEfficiency_lte: BigDecimal + signalingEfficiency_in: [BigDecimal!] + signalingEfficiency_not_in: [BigDecimal!] + totalNameSignal: BigDecimal + totalNameSignal_not: BigDecimal + totalNameSignal_gt: BigDecimal + totalNameSignal_lt: BigDecimal + totalNameSignal_gte: BigDecimal + totalNameSignal_lte: BigDecimal + totalNameSignal_in: [BigDecimal!] + totalNameSignal_not_in: [BigDecimal!] + totalNameSignalAverageCostBasis: BigDecimal + totalNameSignalAverageCostBasis_not: BigDecimal + totalNameSignalAverageCostBasis_gt: BigDecimal + totalNameSignalAverageCostBasis_lt: BigDecimal + totalNameSignalAverageCostBasis_gte: BigDecimal + totalNameSignalAverageCostBasis_lte: BigDecimal + totalNameSignalAverageCostBasis_in: [BigDecimal!] + totalNameSignalAverageCostBasis_not_in: [BigDecimal!] + totalAverageCostBasisPerNameSignal: BigDecimal + totalAverageCostBasisPerNameSignal_not: BigDecimal + totalAverageCostBasisPerNameSignal_gt: BigDecimal + totalAverageCostBasisPerNameSignal_lt: BigDecimal + totalAverageCostBasisPerNameSignal_gte: BigDecimal + totalAverageCostBasisPerNameSignal_lte: BigDecimal + totalAverageCostBasisPerNameSignal_in: [BigDecimal!] + totalAverageCostBasisPerNameSignal_not_in: [BigDecimal!] + totalSignal: BigDecimal + totalSignal_not: BigDecimal + totalSignal_gt: BigDecimal + totalSignal_lt: BigDecimal + totalSignal_gte: BigDecimal + totalSignal_lte: BigDecimal + totalSignal_in: [BigDecimal!] + totalSignal_not_in: [BigDecimal!] + totalSignalAverageCostBasis: BigDecimal + totalSignalAverageCostBasis_not: BigDecimal + totalSignalAverageCostBasis_gt: BigDecimal + totalSignalAverageCostBasis_lt: BigDecimal + totalSignalAverageCostBasis_gte: BigDecimal + totalSignalAverageCostBasis_lte: BigDecimal + totalSignalAverageCostBasis_in: [BigDecimal!] + totalSignalAverageCostBasis_not_in: [BigDecimal!] + totalAverageCostBasisPerSignal: BigDecimal + totalAverageCostBasisPerSignal_not: BigDecimal + totalAverageCostBasisPerSignal_gt: BigDecimal + totalAverageCostBasisPerSignal_lt: BigDecimal + totalAverageCostBasisPerSignal_gte: BigDecimal + totalAverageCostBasisPerSignal_lte: BigDecimal + totalAverageCostBasisPerSignal_in: [BigDecimal!] + totalAverageCostBasisPerSignal_not_in: [BigDecimal!] + signalCount: Int + signalCount_not: Int + signalCount_gt: Int + signalCount_lt: Int + signalCount_gte: Int + signalCount_lte: Int + signalCount_in: [Int!] + signalCount_not_in: [Int!] + activeSignalCount: Int + activeSignalCount_not: Int + activeSignalCount_gt: Int + activeSignalCount_lt: Int + activeSignalCount_gte: Int + activeSignalCount_lte: Int + activeSignalCount_in: [Int!] + activeSignalCount_not_in: [Int!] + nameSignalCount: Int + nameSignalCount_not: Int + nameSignalCount_gt: Int + nameSignalCount_lt: Int + nameSignalCount_gte: Int + nameSignalCount_lte: Int + nameSignalCount_in: [Int!] + nameSignalCount_not_in: [Int!] + activeNameSignalCount: Int + activeNameSignalCount_not: Int + activeNameSignalCount_gt: Int + activeNameSignalCount_lt: Int + activeNameSignalCount_gte: Int + activeNameSignalCount_lte: Int + activeNameSignalCount_in: [Int!] + activeNameSignalCount_not_in: [Int!] + combinedSignalCount: Int + combinedSignalCount_not: Int + combinedSignalCount_gt: Int + combinedSignalCount_lt: Int + combinedSignalCount_gte: Int + combinedSignalCount_lte: Int + combinedSignalCount_in: [Int!] + combinedSignalCount_not_in: [Int!] + activeCombinedSignalCount: Int + activeCombinedSignalCount_not: Int + activeCombinedSignalCount_gt: Int + activeCombinedSignalCount_lt: Int + activeCombinedSignalCount_gte: Int + activeCombinedSignalCount_lte: Int + activeCombinedSignalCount_in: [Int!] + activeCombinedSignalCount_not_in: [Int!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Curator_filter] + or: [Curator_filter] +} + +enum Curator_orderBy { + id + createdAt + account + account__id + account__createdAt + account__defaultDisplayName + account__balance + account__balanceReceivedFromL1Signalling + account__balanceReceivedFromL1Delegation + account__curationApproval + account__stakingApproval + account__gnsApproval + account__developerCreatedAt + account__subgraphQueryFees + totalSignalledTokens + totalUnsignalledTokens + signals + defaultDisplayName + totalNameSignalledTokens + totalNameUnsignalledTokens + totalWithdrawnTokens + nameSignals + realizedRewards + annualizedReturn + totalReturn + signalingEfficiency + totalNameSignal + totalNameSignalAverageCostBasis + totalAverageCostBasisPerNameSignal + totalSignal + totalSignalAverageCostBasis + totalAverageCostBasisPerSignal + signalCount + activeSignalCount + nameSignalCount + activeNameSignalCount + combinedSignalCount + activeCombinedSignalCount +} + +type CurrentSubgraphDeploymentRelation { + """ + Auxiliary entity used to batch update Subgraph entities when signalling on the + deployment changes. ID replicates the deployment ID and adds a counter, to + make it easy to reproduce. + """ + id: ID! + subgraph: Subgraph! + deployment: SubgraphDeployment! + + """ + Indicates whether this relation is active. This means that the deployment is + still the current deployment for the named Subgraph + """ + active: Boolean! +} + +input CurrentSubgraphDeploymentRelation_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + subgraph: String + subgraph_not: String + subgraph_gt: String + subgraph_lt: String + subgraph_gte: String + subgraph_lte: String + subgraph_in: [String!] + subgraph_not_in: [String!] + subgraph_contains: String + subgraph_contains_nocase: String + subgraph_not_contains: String + subgraph_not_contains_nocase: String + subgraph_starts_with: String + subgraph_starts_with_nocase: String + subgraph_not_starts_with: String + subgraph_not_starts_with_nocase: String + subgraph_ends_with: String + subgraph_ends_with_nocase: String + subgraph_not_ends_with: String + subgraph_not_ends_with_nocase: String + subgraph_: Subgraph_filter + deployment: String + deployment_not: String + deployment_gt: String + deployment_lt: String + deployment_gte: String + deployment_lte: String + deployment_in: [String!] + deployment_not_in: [String!] + deployment_contains: String + deployment_contains_nocase: String + deployment_not_contains: String + deployment_not_contains_nocase: String + deployment_starts_with: String + deployment_starts_with_nocase: String + deployment_not_starts_with: String + deployment_not_starts_with_nocase: String + deployment_ends_with: String + deployment_ends_with_nocase: String + deployment_not_ends_with: String + deployment_not_ends_with_nocase: String + deployment_: SubgraphDeployment_filter + active: Boolean + active_not: Boolean + active_in: [Boolean!] + active_not_in: [Boolean!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [CurrentSubgraphDeploymentRelation_filter] + or: [CurrentSubgraphDeploymentRelation_filter] +} + +enum CurrentSubgraphDeploymentRelation_orderBy { + id + subgraph + subgraph__id + subgraph__versionCount + subgraph__createdAt + subgraph__updatedAt + subgraph__active + subgraph__migrated + subgraph__startedTransferToL2 + subgraph__startedTransferToL2At + subgraph__startedTransferToL2AtBlockNumber + subgraph__startedTransferToL2AtTx + subgraph__transferredToL2 + subgraph__transferredToL2At + subgraph__transferredToL2AtBlockNumber + subgraph__transferredToL2AtTx + subgraph__signalledTokensSentToL2 + subgraph__signalledTokensReceivedOnL2 + subgraph__idOnL2 + subgraph__idOnL1 + subgraph__nftID + subgraph__oldID + subgraph__creatorAddress + subgraph__subgraphNumber + subgraph__initializing + subgraph__entityVersion + subgraph__signalledTokens + subgraph__unsignalledTokens + subgraph__currentSignalledTokens + subgraph__nameSignalAmount + subgraph__signalAmount + subgraph__reserveRatio + subgraph__withdrawableTokens + subgraph__withdrawnTokens + subgraph__nameSignalCount + subgraph__metadataHash + deployment + deployment__id + deployment__ipfsHash + deployment__createdAt + deployment__deniedAt + deployment__originalName + deployment__stakedTokens + deployment__indexingRewardAmount + deployment__indexingIndexerRewardAmount + deployment__indexingDelegatorRewardAmount + deployment__queryFeesAmount + deployment__queryFeeRebates + deployment__curatorFeeRewards + deployment__signalledTokens + deployment__unsignalledTokens + deployment__signalAmount + deployment__pricePerShare + deployment__reserveRatio + deployment__subgraphCount + deployment__activeSubgraphCount + deployment__deprecatedSubgraphCount + deployment__transferredToL2 + deployment__transferredToL2At + deployment__transferredToL2AtBlockNumber + deployment__transferredToL2AtTx + deployment__signalledTokensSentToL2 + deployment__signalledTokensReceivedOnL2 + active +} + +""" +Delegator stake for a single Indexer + +""" +type DelegatedStake { + """Concatenation of Delegator address and Indexer address""" + id: ID! + + """Index the stake is delegated to""" + indexer: Indexer! + + """Delegator""" + delegator: Delegator! + + """CUMULATIVE tokens delegated""" + stakedTokens: BigInt! + + """CUMULATIVE tokens undelegated""" + unstakedTokens: BigInt! + + """CURRENT tokens locked""" + lockedTokens: BigInt! + + """Epoch the locked tokens get unlocked""" + lockedUntil: Int! + + """ + Shares owned in the delegator pool. Used to calculate total amount delegated + """ + shareAmount: BigInt! + + """ + The rate this delegator paid for their shares (calculated using average cost basis). Used for rewards calculations + """ + personalExchangeRate: BigDecimal! + + """Realized rewards from undelegating and realizing a reward""" + realizedRewards: BigDecimal! + + """Time this delegator first delegated to an indexer""" + createdAt: Int! + + """Last time this delegator delegated towards this indexer""" + lastDelegatedAt: Int + + """Last time this delegator undelegated from this indexer""" + lastUndelegatedAt: Int + + """Whether the delegation has been transferred from L1 to L2""" + transferredToL2: Boolean! + + """Timestamp for the L1 -> L2 Transfer""" + transferredToL2At: BigInt + + """Block number for the L1 -> L2 Transfer""" + transferredToL2AtBlockNumber: BigInt + + """Transaction hash for the L1 -> L2 Transfer""" + transferredToL2AtTx: String + + """ + Amount of GRT transferred to L2. Only visible from L1, as there's no events for it on L2 + """ + stakedTokensTransferredToL2: BigInt! + + """ID of the delegation on L2. Null if it's not transferred""" + idOnL2: String + + """ID of the delegation on L1. Null if it's not transferred""" + idOnL1: String +} + +input DelegatedStake_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + indexer: String + indexer_not: String + indexer_gt: String + indexer_lt: String + indexer_gte: String + indexer_lte: String + indexer_in: [String!] + indexer_not_in: [String!] + indexer_contains: String + indexer_contains_nocase: String + indexer_not_contains: String + indexer_not_contains_nocase: String + indexer_starts_with: String + indexer_starts_with_nocase: String + indexer_not_starts_with: String + indexer_not_starts_with_nocase: String + indexer_ends_with: String + indexer_ends_with_nocase: String + indexer_not_ends_with: String + indexer_not_ends_with_nocase: String + indexer_: Indexer_filter + delegator: String + delegator_not: String + delegator_gt: String + delegator_lt: String + delegator_gte: String + delegator_lte: String + delegator_in: [String!] + delegator_not_in: [String!] + delegator_contains: String + delegator_contains_nocase: String + delegator_not_contains: String + delegator_not_contains_nocase: String + delegator_starts_with: String + delegator_starts_with_nocase: String + delegator_not_starts_with: String + delegator_not_starts_with_nocase: String + delegator_ends_with: String + delegator_ends_with_nocase: String + delegator_not_ends_with: String + delegator_not_ends_with_nocase: String + delegator_: Delegator_filter + stakedTokens: BigInt + stakedTokens_not: BigInt + stakedTokens_gt: BigInt + stakedTokens_lt: BigInt + stakedTokens_gte: BigInt + stakedTokens_lte: BigInt + stakedTokens_in: [BigInt!] + stakedTokens_not_in: [BigInt!] + unstakedTokens: BigInt + unstakedTokens_not: BigInt + unstakedTokens_gt: BigInt + unstakedTokens_lt: BigInt + unstakedTokens_gte: BigInt + unstakedTokens_lte: BigInt + unstakedTokens_in: [BigInt!] + unstakedTokens_not_in: [BigInt!] + lockedTokens: BigInt + lockedTokens_not: BigInt + lockedTokens_gt: BigInt + lockedTokens_lt: BigInt + lockedTokens_gte: BigInt + lockedTokens_lte: BigInt + lockedTokens_in: [BigInt!] + lockedTokens_not_in: [BigInt!] + lockedUntil: Int + lockedUntil_not: Int + lockedUntil_gt: Int + lockedUntil_lt: Int + lockedUntil_gte: Int + lockedUntil_lte: Int + lockedUntil_in: [Int!] + lockedUntil_not_in: [Int!] + shareAmount: BigInt + shareAmount_not: BigInt + shareAmount_gt: BigInt + shareAmount_lt: BigInt + shareAmount_gte: BigInt + shareAmount_lte: BigInt + shareAmount_in: [BigInt!] + shareAmount_not_in: [BigInt!] + personalExchangeRate: BigDecimal + personalExchangeRate_not: BigDecimal + personalExchangeRate_gt: BigDecimal + personalExchangeRate_lt: BigDecimal + personalExchangeRate_gte: BigDecimal + personalExchangeRate_lte: BigDecimal + personalExchangeRate_in: [BigDecimal!] + personalExchangeRate_not_in: [BigDecimal!] + realizedRewards: BigDecimal + realizedRewards_not: BigDecimal + realizedRewards_gt: BigDecimal + realizedRewards_lt: BigDecimal + realizedRewards_gte: BigDecimal + realizedRewards_lte: BigDecimal + realizedRewards_in: [BigDecimal!] + realizedRewards_not_in: [BigDecimal!] + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + lastDelegatedAt: Int + lastDelegatedAt_not: Int + lastDelegatedAt_gt: Int + lastDelegatedAt_lt: Int + lastDelegatedAt_gte: Int + lastDelegatedAt_lte: Int + lastDelegatedAt_in: [Int!] + lastDelegatedAt_not_in: [Int!] + lastUndelegatedAt: Int + lastUndelegatedAt_not: Int + lastUndelegatedAt_gt: Int + lastUndelegatedAt_lt: Int + lastUndelegatedAt_gte: Int + lastUndelegatedAt_lte: Int + lastUndelegatedAt_in: [Int!] + lastUndelegatedAt_not_in: [Int!] + transferredToL2: Boolean + transferredToL2_not: Boolean + transferredToL2_in: [Boolean!] + transferredToL2_not_in: [Boolean!] + transferredToL2At: BigInt + transferredToL2At_not: BigInt + transferredToL2At_gt: BigInt + transferredToL2At_lt: BigInt + transferredToL2At_gte: BigInt + transferredToL2At_lte: BigInt + transferredToL2At_in: [BigInt!] + transferredToL2At_not_in: [BigInt!] + transferredToL2AtBlockNumber: BigInt + transferredToL2AtBlockNumber_not: BigInt + transferredToL2AtBlockNumber_gt: BigInt + transferredToL2AtBlockNumber_lt: BigInt + transferredToL2AtBlockNumber_gte: BigInt + transferredToL2AtBlockNumber_lte: BigInt + transferredToL2AtBlockNumber_in: [BigInt!] + transferredToL2AtBlockNumber_not_in: [BigInt!] + transferredToL2AtTx: String + transferredToL2AtTx_not: String + transferredToL2AtTx_gt: String + transferredToL2AtTx_lt: String + transferredToL2AtTx_gte: String + transferredToL2AtTx_lte: String + transferredToL2AtTx_in: [String!] + transferredToL2AtTx_not_in: [String!] + transferredToL2AtTx_contains: String + transferredToL2AtTx_contains_nocase: String + transferredToL2AtTx_not_contains: String + transferredToL2AtTx_not_contains_nocase: String + transferredToL2AtTx_starts_with: String + transferredToL2AtTx_starts_with_nocase: String + transferredToL2AtTx_not_starts_with: String + transferredToL2AtTx_not_starts_with_nocase: String + transferredToL2AtTx_ends_with: String + transferredToL2AtTx_ends_with_nocase: String + transferredToL2AtTx_not_ends_with: String + transferredToL2AtTx_not_ends_with_nocase: String + stakedTokensTransferredToL2: BigInt + stakedTokensTransferredToL2_not: BigInt + stakedTokensTransferredToL2_gt: BigInt + stakedTokensTransferredToL2_lt: BigInt + stakedTokensTransferredToL2_gte: BigInt + stakedTokensTransferredToL2_lte: BigInt + stakedTokensTransferredToL2_in: [BigInt!] + stakedTokensTransferredToL2_not_in: [BigInt!] + idOnL2: String + idOnL2_not: String + idOnL2_gt: String + idOnL2_lt: String + idOnL2_gte: String + idOnL2_lte: String + idOnL2_in: [String!] + idOnL2_not_in: [String!] + idOnL2_contains: String + idOnL2_contains_nocase: String + idOnL2_not_contains: String + idOnL2_not_contains_nocase: String + idOnL2_starts_with: String + idOnL2_starts_with_nocase: String + idOnL2_not_starts_with: String + idOnL2_not_starts_with_nocase: String + idOnL2_ends_with: String + idOnL2_ends_with_nocase: String + idOnL2_not_ends_with: String + idOnL2_not_ends_with_nocase: String + idOnL1: String + idOnL1_not: String + idOnL1_gt: String + idOnL1_lt: String + idOnL1_gte: String + idOnL1_lte: String + idOnL1_in: [String!] + idOnL1_not_in: [String!] + idOnL1_contains: String + idOnL1_contains_nocase: String + idOnL1_not_contains: String + idOnL1_not_contains_nocase: String + idOnL1_starts_with: String + idOnL1_starts_with_nocase: String + idOnL1_not_starts_with: String + idOnL1_not_starts_with_nocase: String + idOnL1_ends_with: String + idOnL1_ends_with_nocase: String + idOnL1_not_ends_with: String + idOnL1_not_ends_with_nocase: String + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [DelegatedStake_filter] + or: [DelegatedStake_filter] +} + +enum DelegatedStake_orderBy { + id + indexer + indexer__id + indexer__createdAt + indexer__url + indexer__geoHash + indexer__defaultDisplayName + indexer__stakedTokens + indexer__allocatedTokens + indexer__unstakedTokens + indexer__lockedTokens + indexer__tokensLockedUntil + indexer__allocationCount + indexer__totalAllocationCount + indexer__queryFeesCollected + indexer__queryFeeRebates + indexer__rewardsEarned + indexer__indexerIndexingRewards + indexer__delegatorIndexingRewards + indexer__indexerRewardsOwnGenerationRatio + indexer__transferredToL2 + indexer__firstTransferredToL2At + indexer__firstTransferredToL2AtBlockNumber + indexer__firstTransferredToL2AtTx + indexer__lastTransferredToL2At + indexer__lastTransferredToL2AtBlockNumber + indexer__lastTransferredToL2AtTx + indexer__stakedTokensTransferredToL2 + indexer__idOnL2 + indexer__idOnL1 + indexer__delegatedCapacity + indexer__tokenCapacity + indexer__availableStake + indexer__delegatedTokens + indexer__ownStakeRatio + indexer__delegatedStakeRatio + indexer__delegatorShares + indexer__delegationExchangeRate + indexer__indexingRewardCut + indexer__indexingRewardEffectiveCut + indexer__overDelegationDilution + indexer__delegatorQueryFees + indexer__queryFeeCut + indexer__queryFeeEffectiveCut + indexer__delegatorParameterCooldown + indexer__lastDelegationParameterUpdate + indexer__forcedClosures + indexer__totalReturn + indexer__annualizedReturn + indexer__stakingEfficiency + delegator + delegator__id + delegator__totalStakedTokens + delegator__totalUnstakedTokens + delegator__createdAt + delegator__totalRealizedRewards + delegator__stakesCount + delegator__activeStakesCount + delegator__defaultDisplayName + stakedTokens + unstakedTokens + lockedTokens + lockedUntil + shareAmount + personalExchangeRate + realizedRewards + createdAt + lastDelegatedAt + lastUndelegatedAt + transferredToL2 + transferredToL2At + transferredToL2AtBlockNumber + transferredToL2AtTx + stakedTokensTransferredToL2 + idOnL2 + idOnL1 +} + +""" +Delegator with all their delegated stakes towards Indexers + +""" +type Delegator { + """Delegator address""" + id: ID! + + """Graph account of the delegator""" + account: GraphAccount! + + """Stakes of this delegator""" + stakes(skip: Int = 0, first: Int = 100, orderBy: DelegatedStake_orderBy, orderDirection: OrderDirection, where: DelegatedStake_filter): [DelegatedStake!]! + + """CUMULATIVE staked tokens in DelegatorStakes of this Delegator""" + totalStakedTokens: BigInt! + + """CUMULATIVE unstaked tokens in DelegatorStakes of this Delegator""" + totalUnstakedTokens: BigInt! + + """Time created at""" + createdAt: Int! + + """ + Total realized rewards on all delegated stakes. Realized rewards are added when undelegating and realizing a profit + """ + totalRealizedRewards: BigDecimal! + + """Total DelegatedStake entity count (Active and inactive)""" + stakesCount: Int! + + """ + Active DelegatedStake entity count. Active means it still has GRT delegated + """ + activeStakesCount: Int! + + """ + Default display name is the current default name. Used for filtered queries + """ + defaultDisplayName: String +} + +input Delegator_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + account: String + account_not: String + account_gt: String + account_lt: String + account_gte: String + account_lte: String + account_in: [String!] + account_not_in: [String!] + account_contains: String + account_contains_nocase: String + account_not_contains: String + account_not_contains_nocase: String + account_starts_with: String + account_starts_with_nocase: String + account_not_starts_with: String + account_not_starts_with_nocase: String + account_ends_with: String + account_ends_with_nocase: String + account_not_ends_with: String + account_not_ends_with_nocase: String + account_: GraphAccount_filter + stakes_: DelegatedStake_filter + totalStakedTokens: BigInt + totalStakedTokens_not: BigInt + totalStakedTokens_gt: BigInt + totalStakedTokens_lt: BigInt + totalStakedTokens_gte: BigInt + totalStakedTokens_lte: BigInt + totalStakedTokens_in: [BigInt!] + totalStakedTokens_not_in: [BigInt!] + totalUnstakedTokens: BigInt + totalUnstakedTokens_not: BigInt + totalUnstakedTokens_gt: BigInt + totalUnstakedTokens_lt: BigInt + totalUnstakedTokens_gte: BigInt + totalUnstakedTokens_lte: BigInt + totalUnstakedTokens_in: [BigInt!] + totalUnstakedTokens_not_in: [BigInt!] + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + totalRealizedRewards: BigDecimal + totalRealizedRewards_not: BigDecimal + totalRealizedRewards_gt: BigDecimal + totalRealizedRewards_lt: BigDecimal + totalRealizedRewards_gte: BigDecimal + totalRealizedRewards_lte: BigDecimal + totalRealizedRewards_in: [BigDecimal!] + totalRealizedRewards_not_in: [BigDecimal!] + stakesCount: Int + stakesCount_not: Int + stakesCount_gt: Int + stakesCount_lt: Int + stakesCount_gte: Int + stakesCount_lte: Int + stakesCount_in: [Int!] + stakesCount_not_in: [Int!] + activeStakesCount: Int + activeStakesCount_not: Int + activeStakesCount_gt: Int + activeStakesCount_lt: Int + activeStakesCount_gte: Int + activeStakesCount_lte: Int + activeStakesCount_in: [Int!] + activeStakesCount_not_in: [Int!] + defaultDisplayName: String + defaultDisplayName_not: String + defaultDisplayName_gt: String + defaultDisplayName_lt: String + defaultDisplayName_gte: String + defaultDisplayName_lte: String + defaultDisplayName_in: [String!] + defaultDisplayName_not_in: [String!] + defaultDisplayName_contains: String + defaultDisplayName_contains_nocase: String + defaultDisplayName_not_contains: String + defaultDisplayName_not_contains_nocase: String + defaultDisplayName_starts_with: String + defaultDisplayName_starts_with_nocase: String + defaultDisplayName_not_starts_with: String + defaultDisplayName_not_starts_with_nocase: String + defaultDisplayName_ends_with: String + defaultDisplayName_ends_with_nocase: String + defaultDisplayName_not_ends_with: String + defaultDisplayName_not_ends_with_nocase: String + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Delegator_filter] + or: [Delegator_filter] +} + +enum Delegator_orderBy { + id + account + account__id + account__createdAt + account__defaultDisplayName + account__balance + account__balanceReceivedFromL1Signalling + account__balanceReceivedFromL1Delegation + account__curationApproval + account__stakingApproval + account__gnsApproval + account__developerCreatedAt + account__subgraphQueryFees + stakes + totalStakedTokens + totalUnstakedTokens + createdAt + totalRealizedRewards + stakesCount + activeStakesCount + defaultDisplayName +} + +""" +Dispute of a query. Includes single query, conflicting attestation, and indexing disputes + +""" +type Dispute { + """Dispute ID""" + id: ID! + + """Subgraph deployment being disputed""" + subgraphDeployment: SubgraphDeployment! + + """Fisherman address""" + fisherman: GraphAccount! + + """Fisherman deposit""" + deposit: BigInt! + + """Time dispute was created""" + createdAt: Int! + + """Time dispute was closed at""" + closedAt: Int! + + """Status of the dispute. Accepted means the Indexer was slashed""" + status: DisputeStatus! + + """Total amount of tokens slashed on the dispute""" + tokensSlashed: BigDecimal! + + """Amount of the slashed tokens that was burned""" + tokensBurned: BigDecimal! + + """Amount of the slashed tokens that was payed as reward to the fisherman""" + tokensRewarded: BigInt! + + """Type of dispute""" + type: DisputeType! + + """Indexer disputed""" + indexer: GraphAccount! + + """Attestation. Only for single query and conflicting attestations""" + attestation: Attestation + + """Linked dispute of other Indexer. Only for conflicting attestation""" + linkedDispute: Dispute + + """Allocation ID. Only for Indexing Disputes""" + allocation: Allocation +} + +input Dispute_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + subgraphDeployment: String + subgraphDeployment_not: String + subgraphDeployment_gt: String + subgraphDeployment_lt: String + subgraphDeployment_gte: String + subgraphDeployment_lte: String + subgraphDeployment_in: [String!] + subgraphDeployment_not_in: [String!] + subgraphDeployment_contains: String + subgraphDeployment_contains_nocase: String + subgraphDeployment_not_contains: String + subgraphDeployment_not_contains_nocase: String + subgraphDeployment_starts_with: String + subgraphDeployment_starts_with_nocase: String + subgraphDeployment_not_starts_with: String + subgraphDeployment_not_starts_with_nocase: String + subgraphDeployment_ends_with: String + subgraphDeployment_ends_with_nocase: String + subgraphDeployment_not_ends_with: String + subgraphDeployment_not_ends_with_nocase: String + subgraphDeployment_: SubgraphDeployment_filter + fisherman: String + fisherman_not: String + fisherman_gt: String + fisherman_lt: String + fisherman_gte: String + fisherman_lte: String + fisherman_in: [String!] + fisherman_not_in: [String!] + fisherman_contains: String + fisherman_contains_nocase: String + fisherman_not_contains: String + fisherman_not_contains_nocase: String + fisherman_starts_with: String + fisherman_starts_with_nocase: String + fisherman_not_starts_with: String + fisherman_not_starts_with_nocase: String + fisherman_ends_with: String + fisherman_ends_with_nocase: String + fisherman_not_ends_with: String + fisherman_not_ends_with_nocase: String + fisherman_: GraphAccount_filter + deposit: BigInt + deposit_not: BigInt + deposit_gt: BigInt + deposit_lt: BigInt + deposit_gte: BigInt + deposit_lte: BigInt + deposit_in: [BigInt!] + deposit_not_in: [BigInt!] + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + closedAt: Int + closedAt_not: Int + closedAt_gt: Int + closedAt_lt: Int + closedAt_gte: Int + closedAt_lte: Int + closedAt_in: [Int!] + closedAt_not_in: [Int!] + status: DisputeStatus + status_not: DisputeStatus + status_in: [DisputeStatus!] + status_not_in: [DisputeStatus!] + tokensSlashed: BigDecimal + tokensSlashed_not: BigDecimal + tokensSlashed_gt: BigDecimal + tokensSlashed_lt: BigDecimal + tokensSlashed_gte: BigDecimal + tokensSlashed_lte: BigDecimal + tokensSlashed_in: [BigDecimal!] + tokensSlashed_not_in: [BigDecimal!] + tokensBurned: BigDecimal + tokensBurned_not: BigDecimal + tokensBurned_gt: BigDecimal + tokensBurned_lt: BigDecimal + tokensBurned_gte: BigDecimal + tokensBurned_lte: BigDecimal + tokensBurned_in: [BigDecimal!] + tokensBurned_not_in: [BigDecimal!] + tokensRewarded: BigInt + tokensRewarded_not: BigInt + tokensRewarded_gt: BigInt + tokensRewarded_lt: BigInt + tokensRewarded_gte: BigInt + tokensRewarded_lte: BigInt + tokensRewarded_in: [BigInt!] + tokensRewarded_not_in: [BigInt!] + type: DisputeType + type_not: DisputeType + type_in: [DisputeType!] + type_not_in: [DisputeType!] + indexer: String + indexer_not: String + indexer_gt: String + indexer_lt: String + indexer_gte: String + indexer_lte: String + indexer_in: [String!] + indexer_not_in: [String!] + indexer_contains: String + indexer_contains_nocase: String + indexer_not_contains: String + indexer_not_contains_nocase: String + indexer_starts_with: String + indexer_starts_with_nocase: String + indexer_not_starts_with: String + indexer_not_starts_with_nocase: String + indexer_ends_with: String + indexer_ends_with_nocase: String + indexer_not_ends_with: String + indexer_not_ends_with_nocase: String + indexer_: GraphAccount_filter + attestation: String + attestation_not: String + attestation_gt: String + attestation_lt: String + attestation_gte: String + attestation_lte: String + attestation_in: [String!] + attestation_not_in: [String!] + attestation_contains: String + attestation_contains_nocase: String + attestation_not_contains: String + attestation_not_contains_nocase: String + attestation_starts_with: String + attestation_starts_with_nocase: String + attestation_not_starts_with: String + attestation_not_starts_with_nocase: String + attestation_ends_with: String + attestation_ends_with_nocase: String + attestation_not_ends_with: String + attestation_not_ends_with_nocase: String + attestation_: Attestation_filter + linkedDispute: String + linkedDispute_not: String + linkedDispute_gt: String + linkedDispute_lt: String + linkedDispute_gte: String + linkedDispute_lte: String + linkedDispute_in: [String!] + linkedDispute_not_in: [String!] + linkedDispute_contains: String + linkedDispute_contains_nocase: String + linkedDispute_not_contains: String + linkedDispute_not_contains_nocase: String + linkedDispute_starts_with: String + linkedDispute_starts_with_nocase: String + linkedDispute_not_starts_with: String + linkedDispute_not_starts_with_nocase: String + linkedDispute_ends_with: String + linkedDispute_ends_with_nocase: String + linkedDispute_not_ends_with: String + linkedDispute_not_ends_with_nocase: String + linkedDispute_: Dispute_filter + allocation: String + allocation_not: String + allocation_gt: String + allocation_lt: String + allocation_gte: String + allocation_lte: String + allocation_in: [String!] + allocation_not_in: [String!] + allocation_contains: String + allocation_contains_nocase: String + allocation_not_contains: String + allocation_not_contains_nocase: String + allocation_starts_with: String + allocation_starts_with_nocase: String + allocation_not_starts_with: String + allocation_not_starts_with_nocase: String + allocation_ends_with: String + allocation_ends_with_nocase: String + allocation_not_ends_with: String + allocation_not_ends_with_nocase: String + allocation_: Allocation_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Dispute_filter] + or: [Dispute_filter] +} + +enum Dispute_orderBy { + id + subgraphDeployment + subgraphDeployment__id + subgraphDeployment__ipfsHash + subgraphDeployment__createdAt + subgraphDeployment__deniedAt + subgraphDeployment__originalName + subgraphDeployment__stakedTokens + subgraphDeployment__indexingRewardAmount + subgraphDeployment__indexingIndexerRewardAmount + subgraphDeployment__indexingDelegatorRewardAmount + subgraphDeployment__queryFeesAmount + subgraphDeployment__queryFeeRebates + subgraphDeployment__curatorFeeRewards + subgraphDeployment__signalledTokens + subgraphDeployment__unsignalledTokens + subgraphDeployment__signalAmount + subgraphDeployment__pricePerShare + subgraphDeployment__reserveRatio + subgraphDeployment__subgraphCount + subgraphDeployment__activeSubgraphCount + subgraphDeployment__deprecatedSubgraphCount + subgraphDeployment__transferredToL2 + subgraphDeployment__transferredToL2At + subgraphDeployment__transferredToL2AtBlockNumber + subgraphDeployment__transferredToL2AtTx + subgraphDeployment__signalledTokensSentToL2 + subgraphDeployment__signalledTokensReceivedOnL2 + fisherman + fisherman__id + fisherman__createdAt + fisherman__defaultDisplayName + fisherman__balance + fisherman__balanceReceivedFromL1Signalling + fisherman__balanceReceivedFromL1Delegation + fisherman__curationApproval + fisherman__stakingApproval + fisherman__gnsApproval + fisherman__developerCreatedAt + fisherman__subgraphQueryFees + deposit + createdAt + closedAt + status + tokensSlashed + tokensBurned + tokensRewarded + type + indexer + indexer__id + indexer__createdAt + indexer__defaultDisplayName + indexer__balance + indexer__balanceReceivedFromL1Signalling + indexer__balanceReceivedFromL1Delegation + indexer__curationApproval + indexer__stakingApproval + indexer__gnsApproval + indexer__developerCreatedAt + indexer__subgraphQueryFees + attestation + attestation__id + attestation__requestCID + attestation__responseCID + attestation__gasUsed + attestation__responseNumBytes + attestation__v + attestation__r + attestation__s + linkedDispute + linkedDispute__id + linkedDispute__deposit + linkedDispute__createdAt + linkedDispute__closedAt + linkedDispute__status + linkedDispute__tokensSlashed + linkedDispute__tokensBurned + linkedDispute__tokensRewarded + linkedDispute__type + allocation + allocation__id + allocation__creator + allocation__allocatedTokens + allocation__effectiveAllocation + allocation__createdAtEpoch + allocation__createdAtBlockHash + allocation__createdAtBlockNumber + allocation__closedAtEpoch + allocation__closedAtBlockHash + allocation__closedAtBlockNumber + allocation__queryFeesCollected + allocation__queryFeeRebates + allocation__distributedRebates + allocation__curatorRewards + allocation__indexingRewards + allocation__indexingIndexerRewards + allocation__indexingDelegatorRewards + allocation__delegationFees + allocation__status + allocation__createdAt + allocation__closedAt + allocation__poi + allocation__indexingRewardCutAtStart + allocation__indexingRewardEffectiveCutAtStart + allocation__queryFeeCutAtStart + allocation__queryFeeEffectiveCutAtStart + allocation__indexingRewardCutAtClose + allocation__indexingRewardEffectiveCutAtClose + allocation__queryFeeCutAtClose + allocation__queryFeeEffectiveCutAtClose + allocation__totalReturn + allocation__annualizedReturn +} + +enum DisputeStatus { + Undecided + Accepted + Rejected + Draw +} + +enum DisputeType { + SingleQuery + Conflicting + Indexing +} + +""" +Epoch aggregate data for network statistics on signaling, rewards, and query fees + +""" +type Epoch { + """Epoch number""" + id: ID! + + """Start block of the epoch""" + startBlock: Int! + + """End block of the epoch""" + endBlock: Int! + + """Signaled tokens during this epoch""" + signalledTokens: BigInt! + + """Stake deposited during this epoch""" + stakeDeposited: BigInt! + + """ + Total amount of query fees generated during this epoch (Includes everything) + """ + totalQueryFees: BigInt! + + """ + Amount of query fees generated that were burnt by the 1% protocol tax during this epoch + """ + taxedQueryFees: BigInt! + + """Amount of query fees generated for indexers during this epoch""" + queryFeesCollected: BigInt! + + """ + Amount of query fees generated that are going to curators during this epoch + """ + curatorQueryFees: BigInt! + + """ + Rebate amount claimed from the protocol through rebates mechanism during this epoch + """ + queryFeeRebates: BigInt! + + """ + Total indexing rewards earned in this epoch. Includes both delegator and indexer rewards + """ + totalRewards: BigInt! + + """Total indexing rewards earned in this epoch by indexers""" + totalIndexerRewards: BigInt! + + """Total indexing rewards earned in this epoch by delegators""" + totalDelegatorRewards: BigInt! +} + +input Epoch_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + startBlock: Int + startBlock_not: Int + startBlock_gt: Int + startBlock_lt: Int + startBlock_gte: Int + startBlock_lte: Int + startBlock_in: [Int!] + startBlock_not_in: [Int!] + endBlock: Int + endBlock_not: Int + endBlock_gt: Int + endBlock_lt: Int + endBlock_gte: Int + endBlock_lte: Int + endBlock_in: [Int!] + endBlock_not_in: [Int!] + signalledTokens: BigInt + signalledTokens_not: BigInt + signalledTokens_gt: BigInt + signalledTokens_lt: BigInt + signalledTokens_gte: BigInt + signalledTokens_lte: BigInt + signalledTokens_in: [BigInt!] + signalledTokens_not_in: [BigInt!] + stakeDeposited: BigInt + stakeDeposited_not: BigInt + stakeDeposited_gt: BigInt + stakeDeposited_lt: BigInt + stakeDeposited_gte: BigInt + stakeDeposited_lte: BigInt + stakeDeposited_in: [BigInt!] + stakeDeposited_not_in: [BigInt!] + totalQueryFees: BigInt + totalQueryFees_not: BigInt + totalQueryFees_gt: BigInt + totalQueryFees_lt: BigInt + totalQueryFees_gte: BigInt + totalQueryFees_lte: BigInt + totalQueryFees_in: [BigInt!] + totalQueryFees_not_in: [BigInt!] + taxedQueryFees: BigInt + taxedQueryFees_not: BigInt + taxedQueryFees_gt: BigInt + taxedQueryFees_lt: BigInt + taxedQueryFees_gte: BigInt + taxedQueryFees_lte: BigInt + taxedQueryFees_in: [BigInt!] + taxedQueryFees_not_in: [BigInt!] + queryFeesCollected: BigInt + queryFeesCollected_not: BigInt + queryFeesCollected_gt: BigInt + queryFeesCollected_lt: BigInt + queryFeesCollected_gte: BigInt + queryFeesCollected_lte: BigInt + queryFeesCollected_in: [BigInt!] + queryFeesCollected_not_in: [BigInt!] + curatorQueryFees: BigInt + curatorQueryFees_not: BigInt + curatorQueryFees_gt: BigInt + curatorQueryFees_lt: BigInt + curatorQueryFees_gte: BigInt + curatorQueryFees_lte: BigInt + curatorQueryFees_in: [BigInt!] + curatorQueryFees_not_in: [BigInt!] + queryFeeRebates: BigInt + queryFeeRebates_not: BigInt + queryFeeRebates_gt: BigInt + queryFeeRebates_lt: BigInt + queryFeeRebates_gte: BigInt + queryFeeRebates_lte: BigInt + queryFeeRebates_in: [BigInt!] + queryFeeRebates_not_in: [BigInt!] + totalRewards: BigInt + totalRewards_not: BigInt + totalRewards_gt: BigInt + totalRewards_lt: BigInt + totalRewards_gte: BigInt + totalRewards_lte: BigInt + totalRewards_in: [BigInt!] + totalRewards_not_in: [BigInt!] + totalIndexerRewards: BigInt + totalIndexerRewards_not: BigInt + totalIndexerRewards_gt: BigInt + totalIndexerRewards_lt: BigInt + totalIndexerRewards_gte: BigInt + totalIndexerRewards_lte: BigInt + totalIndexerRewards_in: [BigInt!] + totalIndexerRewards_not_in: [BigInt!] + totalDelegatorRewards: BigInt + totalDelegatorRewards_not: BigInt + totalDelegatorRewards_gt: BigInt + totalDelegatorRewards_lt: BigInt + totalDelegatorRewards_gte: BigInt + totalDelegatorRewards_lte: BigInt + totalDelegatorRewards_in: [BigInt!] + totalDelegatorRewards_not_in: [BigInt!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Epoch_filter] + or: [Epoch_filter] +} + +enum Epoch_orderBy { + id + startBlock + endBlock + signalledTokens + stakeDeposited + totalQueryFees + taxedQueryFees + queryFeesCollected + curatorQueryFees + queryFeeRebates + totalRewards + totalIndexerRewards + totalDelegatorRewards +} + +""" +An account within the graph network. Contains metadata and all relevant data for this accounts +delegating, curating, and indexing. + +""" +type GraphAccount { + """Graph account ID""" + id: ID! + + """All names this graph account has claimed from all name systems""" + names(skip: Int = 0, first: Int = 100, orderBy: GraphAccountName_orderBy, orderDirection: OrderDirection, where: GraphAccountName_filter): [GraphAccountName!]! + + """Default name the graph account has chosen""" + defaultName: GraphAccountName + + """Time the account was created""" + createdAt: Int! + + """ + Default display name is the current default name. Used for filtered queries in the explorer + """ + defaultDisplayName: String + metadata: GraphAccountMeta + + """Operator of other Graph Accounts""" + operatorOf(skip: Int = 0, first: Int = 100, orderBy: GraphAccount_orderBy, orderDirection: OrderDirection, where: GraphAccount_filter): [GraphAccount!]! + + """Operators of this Graph Accounts""" + operators(skip: Int = 0, first: Int = 100, orderBy: GraphAccount_orderBy, orderDirection: OrderDirection, where: GraphAccount_filter): [GraphAccount!]! + + """Graph token balance""" + balance: BigInt! + + """Balance received due to failed signal transfer from L1""" + balanceReceivedFromL1Signalling: BigInt! + + """Balance received due to failed delegation transfer from L1""" + balanceReceivedFromL1Delegation: BigInt! + + """Amount this account has approved staking to transfer their GRT""" + curationApproval: BigInt! + + """Amount this account has approved curation to transfer their GRT""" + stakingApproval: BigInt! + + """Amount this account has approved the GNS to transfer their GRT""" + gnsApproval: BigInt! + + """Subgraphs the graph account owns""" + subgraphs(skip: Int = 0, first: Int = 100, orderBy: Subgraph_orderBy, orderDirection: OrderDirection, where: Subgraph_filter): [Subgraph!]! + + """Time that this graph account became a developer""" + developerCreatedAt: Int + + """ + NOT IMPLEMENTED - Total query fees the subgraphs created by this account have accumulated in GRT + """ + subgraphQueryFees: BigInt! + + """Disputes this graph account has created""" + createdDisputes(skip: Int = 0, first: Int = 100, orderBy: Dispute_orderBy, orderDirection: OrderDirection, where: Dispute_filter): [Dispute!]! + + """Disputes against this graph account""" + disputesAgainst(skip: Int = 0, first: Int = 100, orderBy: Dispute_orderBy, orderDirection: OrderDirection, where: Dispute_filter): [Dispute!]! + + """Curator fields for this GraphAccount. Null if never curated""" + curator: Curator + + """Indexer fields for this GraphAccount. Null if never indexed""" + indexer: Indexer + + """Delegator fields for this GraphAccount. Null if never delegated""" + delegator: Delegator + + """Name signal transactions created by this GraphAccount""" + nameSignalTransactions(skip: Int = 0, first: Int = 100, orderBy: NameSignalTransaction_orderBy, orderDirection: OrderDirection, where: NameSignalTransaction_filter): [NameSignalTransaction!]! + bridgeWithdrawalTransactions(skip: Int = 0, first: Int = 100, orderBy: BridgeWithdrawalTransaction_orderBy, orderDirection: OrderDirection, where: BridgeWithdrawalTransaction_filter): [BridgeWithdrawalTransaction!]! + bridgeDepositTransactions(skip: Int = 0, first: Int = 100, orderBy: BridgeDepositTransaction_orderBy, orderDirection: OrderDirection, where: BridgeDepositTransaction_filter): [BridgeDepositTransaction!]! + tokenLockWallets(skip: Int = 0, first: Int = 100, orderBy: TokenLockWallet_orderBy, orderDirection: OrderDirection, where: TokenLockWallet_filter): [TokenLockWallet!]! +} + +input GraphAccount_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + names_: GraphAccountName_filter + defaultName: String + defaultName_not: String + defaultName_gt: String + defaultName_lt: String + defaultName_gte: String + defaultName_lte: String + defaultName_in: [String!] + defaultName_not_in: [String!] + defaultName_contains: String + defaultName_contains_nocase: String + defaultName_not_contains: String + defaultName_not_contains_nocase: String + defaultName_starts_with: String + defaultName_starts_with_nocase: String + defaultName_not_starts_with: String + defaultName_not_starts_with_nocase: String + defaultName_ends_with: String + defaultName_ends_with_nocase: String + defaultName_not_ends_with: String + defaultName_not_ends_with_nocase: String + defaultName_: GraphAccountName_filter + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + defaultDisplayName: String + defaultDisplayName_not: String + defaultDisplayName_gt: String + defaultDisplayName_lt: String + defaultDisplayName_gte: String + defaultDisplayName_lte: String + defaultDisplayName_in: [String!] + defaultDisplayName_not_in: [String!] + defaultDisplayName_contains: String + defaultDisplayName_contains_nocase: String + defaultDisplayName_not_contains: String + defaultDisplayName_not_contains_nocase: String + defaultDisplayName_starts_with: String + defaultDisplayName_starts_with_nocase: String + defaultDisplayName_not_starts_with: String + defaultDisplayName_not_starts_with_nocase: String + defaultDisplayName_ends_with: String + defaultDisplayName_ends_with_nocase: String + defaultDisplayName_not_ends_with: String + defaultDisplayName_not_ends_with_nocase: String + metadata: String + metadata_not: String + metadata_gt: String + metadata_lt: String + metadata_gte: String + metadata_lte: String + metadata_in: [String!] + metadata_not_in: [String!] + metadata_contains: String + metadata_contains_nocase: String + metadata_not_contains: String + metadata_not_contains_nocase: String + metadata_starts_with: String + metadata_starts_with_nocase: String + metadata_not_starts_with: String + metadata_not_starts_with_nocase: String + metadata_ends_with: String + metadata_ends_with_nocase: String + metadata_not_ends_with: String + metadata_not_ends_with_nocase: String + metadata_: GraphAccountMeta_filter + operatorOf_: GraphAccount_filter + operators: [String!] + operators_not: [String!] + operators_contains: [String!] + operators_contains_nocase: [String!] + operators_not_contains: [String!] + operators_not_contains_nocase: [String!] + operators_: GraphAccount_filter + balance: BigInt + balance_not: BigInt + balance_gt: BigInt + balance_lt: BigInt + balance_gte: BigInt + balance_lte: BigInt + balance_in: [BigInt!] + balance_not_in: [BigInt!] + balanceReceivedFromL1Signalling: BigInt + balanceReceivedFromL1Signalling_not: BigInt + balanceReceivedFromL1Signalling_gt: BigInt + balanceReceivedFromL1Signalling_lt: BigInt + balanceReceivedFromL1Signalling_gte: BigInt + balanceReceivedFromL1Signalling_lte: BigInt + balanceReceivedFromL1Signalling_in: [BigInt!] + balanceReceivedFromL1Signalling_not_in: [BigInt!] + balanceReceivedFromL1Delegation: BigInt + balanceReceivedFromL1Delegation_not: BigInt + balanceReceivedFromL1Delegation_gt: BigInt + balanceReceivedFromL1Delegation_lt: BigInt + balanceReceivedFromL1Delegation_gte: BigInt + balanceReceivedFromL1Delegation_lte: BigInt + balanceReceivedFromL1Delegation_in: [BigInt!] + balanceReceivedFromL1Delegation_not_in: [BigInt!] + curationApproval: BigInt + curationApproval_not: BigInt + curationApproval_gt: BigInt + curationApproval_lt: BigInt + curationApproval_gte: BigInt + curationApproval_lte: BigInt + curationApproval_in: [BigInt!] + curationApproval_not_in: [BigInt!] + stakingApproval: BigInt + stakingApproval_not: BigInt + stakingApproval_gt: BigInt + stakingApproval_lt: BigInt + stakingApproval_gte: BigInt + stakingApproval_lte: BigInt + stakingApproval_in: [BigInt!] + stakingApproval_not_in: [BigInt!] + gnsApproval: BigInt + gnsApproval_not: BigInt + gnsApproval_gt: BigInt + gnsApproval_lt: BigInt + gnsApproval_gte: BigInt + gnsApproval_lte: BigInt + gnsApproval_in: [BigInt!] + gnsApproval_not_in: [BigInt!] + subgraphs_: Subgraph_filter + developerCreatedAt: Int + developerCreatedAt_not: Int + developerCreatedAt_gt: Int + developerCreatedAt_lt: Int + developerCreatedAt_gte: Int + developerCreatedAt_lte: Int + developerCreatedAt_in: [Int!] + developerCreatedAt_not_in: [Int!] + subgraphQueryFees: BigInt + subgraphQueryFees_not: BigInt + subgraphQueryFees_gt: BigInt + subgraphQueryFees_lt: BigInt + subgraphQueryFees_gte: BigInt + subgraphQueryFees_lte: BigInt + subgraphQueryFees_in: [BigInt!] + subgraphQueryFees_not_in: [BigInt!] + createdDisputes_: Dispute_filter + disputesAgainst_: Dispute_filter + curator: String + curator_not: String + curator_gt: String + curator_lt: String + curator_gte: String + curator_lte: String + curator_in: [String!] + curator_not_in: [String!] + curator_contains: String + curator_contains_nocase: String + curator_not_contains: String + curator_not_contains_nocase: String + curator_starts_with: String + curator_starts_with_nocase: String + curator_not_starts_with: String + curator_not_starts_with_nocase: String + curator_ends_with: String + curator_ends_with_nocase: String + curator_not_ends_with: String + curator_not_ends_with_nocase: String + curator_: Curator_filter + indexer: String + indexer_not: String + indexer_gt: String + indexer_lt: String + indexer_gte: String + indexer_lte: String + indexer_in: [String!] + indexer_not_in: [String!] + indexer_contains: String + indexer_contains_nocase: String + indexer_not_contains: String + indexer_not_contains_nocase: String + indexer_starts_with: String + indexer_starts_with_nocase: String + indexer_not_starts_with: String + indexer_not_starts_with_nocase: String + indexer_ends_with: String + indexer_ends_with_nocase: String + indexer_not_ends_with: String + indexer_not_ends_with_nocase: String + indexer_: Indexer_filter + delegator: String + delegator_not: String + delegator_gt: String + delegator_lt: String + delegator_gte: String + delegator_lte: String + delegator_in: [String!] + delegator_not_in: [String!] + delegator_contains: String + delegator_contains_nocase: String + delegator_not_contains: String + delegator_not_contains_nocase: String + delegator_starts_with: String + delegator_starts_with_nocase: String + delegator_not_starts_with: String + delegator_not_starts_with_nocase: String + delegator_ends_with: String + delegator_ends_with_nocase: String + delegator_not_ends_with: String + delegator_not_ends_with_nocase: String + delegator_: Delegator_filter + nameSignalTransactions_: NameSignalTransaction_filter + bridgeWithdrawalTransactions_: BridgeWithdrawalTransaction_filter + bridgeDepositTransactions_: BridgeDepositTransaction_filter + tokenLockWallets: [String!] + tokenLockWallets_not: [String!] + tokenLockWallets_contains: [String!] + tokenLockWallets_contains_nocase: [String!] + tokenLockWallets_not_contains: [String!] + tokenLockWallets_not_contains_nocase: [String!] + tokenLockWallets_: TokenLockWallet_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [GraphAccount_filter] + or: [GraphAccount_filter] +} + +enum GraphAccount_orderBy { + id + names + defaultName + defaultName__id + defaultName__nameSystem + defaultName__name + createdAt + defaultDisplayName + metadata + metadata__id + metadata__isOrganization + metadata__codeRepository + metadata__description + metadata__image + metadata__website + metadata__displayName + operatorOf + operators + balance + balanceReceivedFromL1Signalling + balanceReceivedFromL1Delegation + curationApproval + stakingApproval + gnsApproval + subgraphs + developerCreatedAt + subgraphQueryFees + createdDisputes + disputesAgainst + curator + curator__id + curator__createdAt + curator__totalSignalledTokens + curator__totalUnsignalledTokens + curator__defaultDisplayName + curator__totalNameSignalledTokens + curator__totalNameUnsignalledTokens + curator__totalWithdrawnTokens + curator__realizedRewards + curator__annualizedReturn + curator__totalReturn + curator__signalingEfficiency + curator__totalNameSignal + curator__totalNameSignalAverageCostBasis + curator__totalAverageCostBasisPerNameSignal + curator__totalSignal + curator__totalSignalAverageCostBasis + curator__totalAverageCostBasisPerSignal + curator__signalCount + curator__activeSignalCount + curator__nameSignalCount + curator__activeNameSignalCount + curator__combinedSignalCount + curator__activeCombinedSignalCount + indexer + indexer__id + indexer__createdAt + indexer__url + indexer__geoHash + indexer__defaultDisplayName + indexer__stakedTokens + indexer__allocatedTokens + indexer__unstakedTokens + indexer__lockedTokens + indexer__tokensLockedUntil + indexer__allocationCount + indexer__totalAllocationCount + indexer__queryFeesCollected + indexer__queryFeeRebates + indexer__rewardsEarned + indexer__indexerIndexingRewards + indexer__delegatorIndexingRewards + indexer__indexerRewardsOwnGenerationRatio + indexer__transferredToL2 + indexer__firstTransferredToL2At + indexer__firstTransferredToL2AtBlockNumber + indexer__firstTransferredToL2AtTx + indexer__lastTransferredToL2At + indexer__lastTransferredToL2AtBlockNumber + indexer__lastTransferredToL2AtTx + indexer__stakedTokensTransferredToL2 + indexer__idOnL2 + indexer__idOnL1 + indexer__delegatedCapacity + indexer__tokenCapacity + indexer__availableStake + indexer__delegatedTokens + indexer__ownStakeRatio + indexer__delegatedStakeRatio + indexer__delegatorShares + indexer__delegationExchangeRate + indexer__indexingRewardCut + indexer__indexingRewardEffectiveCut + indexer__overDelegationDilution + indexer__delegatorQueryFees + indexer__queryFeeCut + indexer__queryFeeEffectiveCut + indexer__delegatorParameterCooldown + indexer__lastDelegationParameterUpdate + indexer__forcedClosures + indexer__totalReturn + indexer__annualizedReturn + indexer__stakingEfficiency + delegator + delegator__id + delegator__totalStakedTokens + delegator__totalUnstakedTokens + delegator__createdAt + delegator__totalRealizedRewards + delegator__stakesCount + delegator__activeStakesCount + delegator__defaultDisplayName + nameSignalTransactions + bridgeWithdrawalTransactions + bridgeDepositTransactions + tokenLockWallets +} + +type GraphAccountMeta { + """IPFS hash with account metadata details""" + id: ID! + + """ + Account that reference this metadata file. For compatibility purposes. For the full list use graphAccounts + """ + graphAccount: GraphAccount + + """Accounts that reference this metadata file""" + graphAccounts(skip: Int = 0, first: Int = 100, orderBy: GraphAccount_orderBy, orderDirection: OrderDirection, where: GraphAccount_filter): [GraphAccount!]! + + """True if it is an organization. False if it is an individual""" + isOrganization: Boolean + + """Main repository of code for the graph account""" + codeRepository: String + + """Description of the graph account""" + description: String + + """Image URL""" + image: String + + """Website URL""" + website: String + + """Display name. Not unique""" + displayName: String +} + +input GraphAccountMeta_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + graphAccount_: GraphAccount_filter + graphAccounts_: GraphAccount_filter + isOrganization: Boolean + isOrganization_not: Boolean + isOrganization_in: [Boolean!] + isOrganization_not_in: [Boolean!] + codeRepository: String + codeRepository_not: String + codeRepository_gt: String + codeRepository_lt: String + codeRepository_gte: String + codeRepository_lte: String + codeRepository_in: [String!] + codeRepository_not_in: [String!] + codeRepository_contains: String + codeRepository_contains_nocase: String + codeRepository_not_contains: String + codeRepository_not_contains_nocase: String + codeRepository_starts_with: String + codeRepository_starts_with_nocase: String + codeRepository_not_starts_with: String + codeRepository_not_starts_with_nocase: String + codeRepository_ends_with: String + codeRepository_ends_with_nocase: String + codeRepository_not_ends_with: String + codeRepository_not_ends_with_nocase: String + description: String + description_not: String + description_gt: String + description_lt: String + description_gte: String + description_lte: String + description_in: [String!] + description_not_in: [String!] + description_contains: String + description_contains_nocase: String + description_not_contains: String + description_not_contains_nocase: String + description_starts_with: String + description_starts_with_nocase: String + description_not_starts_with: String + description_not_starts_with_nocase: String + description_ends_with: String + description_ends_with_nocase: String + description_not_ends_with: String + description_not_ends_with_nocase: String + image: String + image_not: String + image_gt: String + image_lt: String + image_gte: String + image_lte: String + image_in: [String!] + image_not_in: [String!] + image_contains: String + image_contains_nocase: String + image_not_contains: String + image_not_contains_nocase: String + image_starts_with: String + image_starts_with_nocase: String + image_not_starts_with: String + image_not_starts_with_nocase: String + image_ends_with: String + image_ends_with_nocase: String + image_not_ends_with: String + image_not_ends_with_nocase: String + website: String + website_not: String + website_gt: String + website_lt: String + website_gte: String + website_lte: String + website_in: [String!] + website_not_in: [String!] + website_contains: String + website_contains_nocase: String + website_not_contains: String + website_not_contains_nocase: String + website_starts_with: String + website_starts_with_nocase: String + website_not_starts_with: String + website_not_starts_with_nocase: String + website_ends_with: String + website_ends_with_nocase: String + website_not_ends_with: String + website_not_ends_with_nocase: String + displayName: String + displayName_not: String + displayName_gt: String + displayName_lt: String + displayName_gte: String + displayName_lte: String + displayName_in: [String!] + displayName_not_in: [String!] + displayName_contains: String + displayName_contains_nocase: String + displayName_not_contains: String + displayName_not_contains_nocase: String + displayName_starts_with: String + displayName_starts_with_nocase: String + displayName_not_starts_with: String + displayName_not_starts_with_nocase: String + displayName_ends_with: String + displayName_ends_with_nocase: String + displayName_not_ends_with: String + displayName_not_ends_with_nocase: String + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [GraphAccountMeta_filter] + or: [GraphAccountMeta_filter] +} + +enum GraphAccountMeta_orderBy { + id + graphAccount + graphAccount__id + graphAccount__createdAt + graphAccount__defaultDisplayName + graphAccount__balance + graphAccount__balanceReceivedFromL1Signalling + graphAccount__balanceReceivedFromL1Delegation + graphAccount__curationApproval + graphAccount__stakingApproval + graphAccount__gnsApproval + graphAccount__developerCreatedAt + graphAccount__subgraphQueryFees + graphAccounts + isOrganization + codeRepository + description + image + website + displayName +} + +""" +A name chosen by a Graph Account from a Name System such as ENS. This allows Graph Accounts to be +recognized by name, rather than just an Ethereum address + +""" +type GraphAccountName { + """Name system concatenated with the unique ID of the name system""" + id: ID! + + """Name system for this name""" + nameSystem: NameSystem! + + """Name from the system""" + name: String! + + """ + The graph account that owned the name when it was linked in the graph network + """ + graphAccount: GraphAccount +} + +input GraphAccountName_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + nameSystem: NameSystem + nameSystem_not: NameSystem + nameSystem_in: [NameSystem!] + nameSystem_not_in: [NameSystem!] + name: String + name_not: String + name_gt: String + name_lt: String + name_gte: String + name_lte: String + name_in: [String!] + name_not_in: [String!] + name_contains: String + name_contains_nocase: String + name_not_contains: String + name_not_contains_nocase: String + name_starts_with: String + name_starts_with_nocase: String + name_not_starts_with: String + name_not_starts_with_nocase: String + name_ends_with: String + name_ends_with_nocase: String + name_not_ends_with: String + name_not_ends_with_nocase: String + graphAccount: String + graphAccount_not: String + graphAccount_gt: String + graphAccount_lt: String + graphAccount_gte: String + graphAccount_lte: String + graphAccount_in: [String!] + graphAccount_not_in: [String!] + graphAccount_contains: String + graphAccount_contains_nocase: String + graphAccount_not_contains: String + graphAccount_not_contains_nocase: String + graphAccount_starts_with: String + graphAccount_starts_with_nocase: String + graphAccount_not_starts_with: String + graphAccount_not_starts_with_nocase: String + graphAccount_ends_with: String + graphAccount_ends_with_nocase: String + graphAccount_not_ends_with: String + graphAccount_not_ends_with_nocase: String + graphAccount_: GraphAccount_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [GraphAccountName_filter] + or: [GraphAccountName_filter] +} + +enum GraphAccountName_orderBy { + id + nameSystem + name + graphAccount + graphAccount__id + graphAccount__createdAt + graphAccount__defaultDisplayName + graphAccount__balance + graphAccount__balanceReceivedFromL1Signalling + graphAccount__balanceReceivedFromL1Delegation + graphAccount__curationApproval + graphAccount__stakingApproval + graphAccount__gnsApproval + graphAccount__developerCreatedAt + graphAccount__subgraphQueryFees +} + +""" +Graph Network global parameters and contract addresses + +""" +type GraphNetwork { + """ID is set to 1""" + id: ID! + + """Controller address""" + controller: Bytes! + + """Graph token address""" + graphToken: Bytes! + + """Epoch manager address""" + epochManager: Bytes! + + """Epoch Manager implementations. Last in the array is current""" + epochManagerImplementations: [Bytes!]! + + """Curation address""" + curation: Bytes! + + """Curation implementations. Last in the array is current""" + curationImplementations: [Bytes!]! + + """Staking address""" + staking: Bytes! + + """Graph token implementations. Last in the array is current""" + stakingImplementations: [Bytes!]! + + """Dispute manager address""" + disputeManager: Bytes! + + """GNS address""" + gns: Bytes! + + """Service registry address""" + serviceRegistry: Bytes! + + """Rewards manager address""" + rewardsManager: Bytes! + + """Rewards Manager implementations. Last in the array is current""" + rewardsManagerImplementations: [Bytes!]! + + """True if the protocol is paused""" + isPaused: Boolean! + + """True if the protocol is partially paused""" + isPartialPaused: Boolean! + + """Governor of the controller (i.e. the whole protocol)""" + governor: Bytes! + + """Pause guardian address""" + pauseGuardian: Bytes! + + """Percentage of fees going to curators. In parts per million""" + curationPercentage: Int! + + """Percentage of fees burn as protocol fee. In parts per million""" + protocolFeePercentage: Int! + + """ + Ratio of max staked delegation tokens to indexers stake that earns rewards + """ + delegationRatio: Int! + + """[DEPRECATED] Epochs to wait before fees can be claimed in rebate pool""" + channelDisputeEpochs: Int! + + """Epochs to wait before delegators can settle""" + maxAllocationEpochs: Int! + + """Time in blocks needed to wait to unstake""" + thawingPeriod: Int! + + """ + Minimum time an Indexer must use for resetting their Delegation parameters + """ + delegationParametersCooldown: Int! + + """Minimum GRT an indexer must stake""" + minimumIndexerStake: BigInt! + + """Contracts that have been approved to be a slasher""" + slashers: [Bytes!] + + """Time in epochs a delegator needs to wait to withdraw delegated stake""" + delegationUnbondingPeriod: Int! + + """[DEPRECATED] Alpha in the cobbs douglas formula""" + rebateRatio: BigDecimal! + + """Alpha in the exponential formula""" + rebateAlpha: BigDecimal! + + """Lambda in the exponential formula""" + rebateLambda: BigDecimal! + + """Tax that delegators pay to deposit. In Parts per million""" + delegationTaxPercentage: Int! + + """Asset holder for the protocol""" + assetHolders: [Bytes!] + + """Total amount of indexer stake transferred to L2""" + totalTokensStakedTransferredToL2: BigInt! + + """Total amount of delegated tokens transferred to L2""" + totalDelegatedTokensTransferredToL2: BigInt! + + """Total amount of delegated tokens transferred to L2""" + totalSignalledTokensTransferredToL2: BigInt! + + """The total amount of GRT staked in the staking contract""" + totalTokensStaked: BigInt! + + """ + NOT IMPLEMENTED - Total tokens that are settled and waiting to be claimed + """ + totalTokensClaimable: BigInt! + + """ + Total tokens that are currently locked or withdrawable in the network from unstaking + """ + totalUnstakedTokensLocked: BigInt! + + """Total GRT currently in allocation""" + totalTokensAllocated: BigInt! + + """Total delegated tokens in the protocol""" + totalDelegatedTokens: BigInt! + + """The total amount of GRT signalled in the Curation contract""" + totalTokensSignalled: BigInt! + + """Total GRT currently curating via the Auto-Migrate function""" + totalTokensSignalledAutoMigrate: BigDecimal! + + """Total GRT currently curating to a specific version""" + totalTokensSignalledDirectly: BigDecimal! + + """Total query fees generated in the network""" + totalQueryFees: BigInt! + + """Total query fees collected by indexers""" + totalIndexerQueryFeesCollected: BigInt! + + """Total query fees rebates claimed by indexers""" + totalIndexerQueryFeeRebates: BigInt! + + """Total query fees rebates claimed by delegators""" + totalDelegatorQueryFeeRebates: BigInt! + + """Total query fees payed to curators""" + totalCuratorQueryFees: BigInt! + + """Total protocol taxes applied to the query fees""" + totalTaxedQueryFees: BigInt! + + """ + Total unclaimed rebates. Includes unclaimed rebates, and rebates lost in rebates mechanism + """ + totalUnclaimedQueryFeeRebates: BigInt! + + """Total indexing rewards minted""" + totalIndexingRewards: BigInt! + + """Total indexing rewards minted to Delegators""" + totalIndexingDelegatorRewards: BigInt! + + """Total indexing rewards minted to Indexers""" + totalIndexingIndexerRewards: BigInt! + + """ + (Deprecated) The issuance rate of GRT per block before GIP-0037. To get annual + rate do (networkGRTIssuance * 10^-18)^(blocksPerYear) + """ + networkGRTIssuance: BigInt! + + """ + The issuance rate of GRT per block after GIP-0037. To get annual rate do (networkGRTIssuancePerBlock * blocksPerYear) + """ + networkGRTIssuancePerBlock: BigInt! + + """Address of the availability oracle""" + subgraphAvailabilityOracle: Bytes! + + """Default reserve ratio for all subgraphs. In parts per million""" + defaultReserveRatio: Int! + + """Minimum amount of tokens needed to start curating""" + minimumCurationDeposit: BigInt! + + """The fee charged when a curator withdraws signal. In parts per million""" + curationTaxPercentage: Int! + + """Percentage of the GNS migration tax payed by the subgraph owner""" + ownerTaxPercentage: Int! + + """Graph Token supply""" + totalSupply: BigInt! + + """NOT IMPLEMENTED - Price of one GRT in USD""" + GRTinUSD: BigDecimal! + + """NOT IMPLEMENTED - Price of one GRT in ETH""" + GRTinETH: BigDecimal + + """Total amount of GRT minted""" + totalGRTMinted: BigInt! + + """Total amount of GRT burned""" + totalGRTBurned: BigInt! + + """Epoch Length in blocks""" + epochLength: Int! + + """Epoch that was last run""" + lastRunEpoch: Int! + + """Epoch when epoch length was last updated""" + lastLengthUpdateEpoch: Int! + + """Block when epoch length was last updated""" + lastLengthUpdateBlock: Int! + + """Current epoch the protocol is in""" + currentEpoch: Int! + + """Total indexers""" + indexerCount: Int! + + """Number of indexers that currently have some stake in the protocol""" + stakedIndexersCount: Int! + + """Total amount of delegators historically""" + delegatorCount: Int! + + """ + Total active delegators. Those that still have at least one active delegation. + """ + activeDelegatorCount: Int! + + """Total amount of delegations historically""" + delegationCount: Int! + + """ + Total active delegations. Those delegations that still have GRT staked towards an indexer + """ + activeDelegationCount: Int! + + """Total amount of curators historically""" + curatorCount: Int! + + """Total amount of curators historically""" + activeCuratorCount: Int! + + """Total amount of Subgraph entities""" + subgraphCount: Int! + + """Amount of active Subgraph entities""" + activeSubgraphCount: Int! + + """Total amount of SubgraphDeployment entities""" + subgraphDeploymentCount: Int! + + """Total epochs""" + epochCount: Int! + + """Total amount of allocations opened""" + allocationCount: Int! + + """Total amount of allocations currently active""" + activeAllocationCount: Int! + + """Dispute arbitrator""" + arbitrator: Bytes! + + """ + Penalty to Indexer on successful disputes for query disputes. In parts per million + """ + querySlashingPercentage: Int! + + """ + Penalty to Indexer on successful disputes for indexing disputes. In parts per million + """ + indexingSlashingPercentage: Int! + + """ + [DEPRECATED] Penalty to Indexer on successful disputes for indexing disputes. In parts per million + """ + slashingPercentage: Int! + + """Minimum deposit to create a dispute""" + minimumDisputeDeposit: BigInt! + + """Reward to Fisherman on successful disputes. In parts per million""" + fishermanRewardPercentage: Int! + + """ + Total amount of GRT deposited to the L1 gateway. Note that the actual amount + claimed in L2 might be lower due to tickets not redeemed. + """ + totalGRTDeposited: BigInt! + + """Total amount of GRT withdrawn from the L2 gateway and claimed in L1.""" + totalGRTWithdrawnConfirmed: BigInt! + + """Total amount of GRT minted by L1 bridge""" + totalGRTMintedFromL2: BigInt! + + """Total amount of GRT deposited to the L1 gateway and redeemed in L2.""" + totalGRTDepositedConfirmed: BigInt! + + """ + Total amount of GRT withdrawn from the L2 gateway. Note that the actual amount + claimed in L1 might be lower due to outbound transactions not finalized. + """ + totalGRTWithdrawn: BigInt! + + """ + Block number for L1. Only implemented for L2 deployments to properly reflect the L1 block used for timings + """ + currentL1BlockNumber: BigInt +} + +input GraphNetwork_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + controller: Bytes + controller_not: Bytes + controller_gt: Bytes + controller_lt: Bytes + controller_gte: Bytes + controller_lte: Bytes + controller_in: [Bytes!] + controller_not_in: [Bytes!] + controller_contains: Bytes + controller_not_contains: Bytes + graphToken: Bytes + graphToken_not: Bytes + graphToken_gt: Bytes + graphToken_lt: Bytes + graphToken_gte: Bytes + graphToken_lte: Bytes + graphToken_in: [Bytes!] + graphToken_not_in: [Bytes!] + graphToken_contains: Bytes + graphToken_not_contains: Bytes + epochManager: Bytes + epochManager_not: Bytes + epochManager_gt: Bytes + epochManager_lt: Bytes + epochManager_gte: Bytes + epochManager_lte: Bytes + epochManager_in: [Bytes!] + epochManager_not_in: [Bytes!] + epochManager_contains: Bytes + epochManager_not_contains: Bytes + epochManagerImplementations: [Bytes!] + epochManagerImplementations_not: [Bytes!] + epochManagerImplementations_contains: [Bytes!] + epochManagerImplementations_contains_nocase: [Bytes!] + epochManagerImplementations_not_contains: [Bytes!] + epochManagerImplementations_not_contains_nocase: [Bytes!] + curation: Bytes + curation_not: Bytes + curation_gt: Bytes + curation_lt: Bytes + curation_gte: Bytes + curation_lte: Bytes + curation_in: [Bytes!] + curation_not_in: [Bytes!] + curation_contains: Bytes + curation_not_contains: Bytes + curationImplementations: [Bytes!] + curationImplementations_not: [Bytes!] + curationImplementations_contains: [Bytes!] + curationImplementations_contains_nocase: [Bytes!] + curationImplementations_not_contains: [Bytes!] + curationImplementations_not_contains_nocase: [Bytes!] + staking: Bytes + staking_not: Bytes + staking_gt: Bytes + staking_lt: Bytes + staking_gte: Bytes + staking_lte: Bytes + staking_in: [Bytes!] + staking_not_in: [Bytes!] + staking_contains: Bytes + staking_not_contains: Bytes + stakingImplementations: [Bytes!] + stakingImplementations_not: [Bytes!] + stakingImplementations_contains: [Bytes!] + stakingImplementations_contains_nocase: [Bytes!] + stakingImplementations_not_contains: [Bytes!] + stakingImplementations_not_contains_nocase: [Bytes!] + disputeManager: Bytes + disputeManager_not: Bytes + disputeManager_gt: Bytes + disputeManager_lt: Bytes + disputeManager_gte: Bytes + disputeManager_lte: Bytes + disputeManager_in: [Bytes!] + disputeManager_not_in: [Bytes!] + disputeManager_contains: Bytes + disputeManager_not_contains: Bytes + gns: Bytes + gns_not: Bytes + gns_gt: Bytes + gns_lt: Bytes + gns_gte: Bytes + gns_lte: Bytes + gns_in: [Bytes!] + gns_not_in: [Bytes!] + gns_contains: Bytes + gns_not_contains: Bytes + serviceRegistry: Bytes + serviceRegistry_not: Bytes + serviceRegistry_gt: Bytes + serviceRegistry_lt: Bytes + serviceRegistry_gte: Bytes + serviceRegistry_lte: Bytes + serviceRegistry_in: [Bytes!] + serviceRegistry_not_in: [Bytes!] + serviceRegistry_contains: Bytes + serviceRegistry_not_contains: Bytes + rewardsManager: Bytes + rewardsManager_not: Bytes + rewardsManager_gt: Bytes + rewardsManager_lt: Bytes + rewardsManager_gte: Bytes + rewardsManager_lte: Bytes + rewardsManager_in: [Bytes!] + rewardsManager_not_in: [Bytes!] + rewardsManager_contains: Bytes + rewardsManager_not_contains: Bytes + rewardsManagerImplementations: [Bytes!] + rewardsManagerImplementations_not: [Bytes!] + rewardsManagerImplementations_contains: [Bytes!] + rewardsManagerImplementations_contains_nocase: [Bytes!] + rewardsManagerImplementations_not_contains: [Bytes!] + rewardsManagerImplementations_not_contains_nocase: [Bytes!] + isPaused: Boolean + isPaused_not: Boolean + isPaused_in: [Boolean!] + isPaused_not_in: [Boolean!] + isPartialPaused: Boolean + isPartialPaused_not: Boolean + isPartialPaused_in: [Boolean!] + isPartialPaused_not_in: [Boolean!] + governor: Bytes + governor_not: Bytes + governor_gt: Bytes + governor_lt: Bytes + governor_gte: Bytes + governor_lte: Bytes + governor_in: [Bytes!] + governor_not_in: [Bytes!] + governor_contains: Bytes + governor_not_contains: Bytes + pauseGuardian: Bytes + pauseGuardian_not: Bytes + pauseGuardian_gt: Bytes + pauseGuardian_lt: Bytes + pauseGuardian_gte: Bytes + pauseGuardian_lte: Bytes + pauseGuardian_in: [Bytes!] + pauseGuardian_not_in: [Bytes!] + pauseGuardian_contains: Bytes + pauseGuardian_not_contains: Bytes + curationPercentage: Int + curationPercentage_not: Int + curationPercentage_gt: Int + curationPercentage_lt: Int + curationPercentage_gte: Int + curationPercentage_lte: Int + curationPercentage_in: [Int!] + curationPercentage_not_in: [Int!] + protocolFeePercentage: Int + protocolFeePercentage_not: Int + protocolFeePercentage_gt: Int + protocolFeePercentage_lt: Int + protocolFeePercentage_gte: Int + protocolFeePercentage_lte: Int + protocolFeePercentage_in: [Int!] + protocolFeePercentage_not_in: [Int!] + delegationRatio: Int + delegationRatio_not: Int + delegationRatio_gt: Int + delegationRatio_lt: Int + delegationRatio_gte: Int + delegationRatio_lte: Int + delegationRatio_in: [Int!] + delegationRatio_not_in: [Int!] + channelDisputeEpochs: Int + channelDisputeEpochs_not: Int + channelDisputeEpochs_gt: Int + channelDisputeEpochs_lt: Int + channelDisputeEpochs_gte: Int + channelDisputeEpochs_lte: Int + channelDisputeEpochs_in: [Int!] + channelDisputeEpochs_not_in: [Int!] + maxAllocationEpochs: Int + maxAllocationEpochs_not: Int + maxAllocationEpochs_gt: Int + maxAllocationEpochs_lt: Int + maxAllocationEpochs_gte: Int + maxAllocationEpochs_lte: Int + maxAllocationEpochs_in: [Int!] + maxAllocationEpochs_not_in: [Int!] + thawingPeriod: Int + thawingPeriod_not: Int + thawingPeriod_gt: Int + thawingPeriod_lt: Int + thawingPeriod_gte: Int + thawingPeriod_lte: Int + thawingPeriod_in: [Int!] + thawingPeriod_not_in: [Int!] + delegationParametersCooldown: Int + delegationParametersCooldown_not: Int + delegationParametersCooldown_gt: Int + delegationParametersCooldown_lt: Int + delegationParametersCooldown_gte: Int + delegationParametersCooldown_lte: Int + delegationParametersCooldown_in: [Int!] + delegationParametersCooldown_not_in: [Int!] + minimumIndexerStake: BigInt + minimumIndexerStake_not: BigInt + minimumIndexerStake_gt: BigInt + minimumIndexerStake_lt: BigInt + minimumIndexerStake_gte: BigInt + minimumIndexerStake_lte: BigInt + minimumIndexerStake_in: [BigInt!] + minimumIndexerStake_not_in: [BigInt!] + slashers: [Bytes!] + slashers_not: [Bytes!] + slashers_contains: [Bytes!] + slashers_contains_nocase: [Bytes!] + slashers_not_contains: [Bytes!] + slashers_not_contains_nocase: [Bytes!] + delegationUnbondingPeriod: Int + delegationUnbondingPeriod_not: Int + delegationUnbondingPeriod_gt: Int + delegationUnbondingPeriod_lt: Int + delegationUnbondingPeriod_gte: Int + delegationUnbondingPeriod_lte: Int + delegationUnbondingPeriod_in: [Int!] + delegationUnbondingPeriod_not_in: [Int!] + rebateRatio: BigDecimal + rebateRatio_not: BigDecimal + rebateRatio_gt: BigDecimal + rebateRatio_lt: BigDecimal + rebateRatio_gte: BigDecimal + rebateRatio_lte: BigDecimal + rebateRatio_in: [BigDecimal!] + rebateRatio_not_in: [BigDecimal!] + rebateAlpha: BigDecimal + rebateAlpha_not: BigDecimal + rebateAlpha_gt: BigDecimal + rebateAlpha_lt: BigDecimal + rebateAlpha_gte: BigDecimal + rebateAlpha_lte: BigDecimal + rebateAlpha_in: [BigDecimal!] + rebateAlpha_not_in: [BigDecimal!] + rebateLambda: BigDecimal + rebateLambda_not: BigDecimal + rebateLambda_gt: BigDecimal + rebateLambda_lt: BigDecimal + rebateLambda_gte: BigDecimal + rebateLambda_lte: BigDecimal + rebateLambda_in: [BigDecimal!] + rebateLambda_not_in: [BigDecimal!] + delegationTaxPercentage: Int + delegationTaxPercentage_not: Int + delegationTaxPercentage_gt: Int + delegationTaxPercentage_lt: Int + delegationTaxPercentage_gte: Int + delegationTaxPercentage_lte: Int + delegationTaxPercentage_in: [Int!] + delegationTaxPercentage_not_in: [Int!] + assetHolders: [Bytes!] + assetHolders_not: [Bytes!] + assetHolders_contains: [Bytes!] + assetHolders_contains_nocase: [Bytes!] + assetHolders_not_contains: [Bytes!] + assetHolders_not_contains_nocase: [Bytes!] + totalTokensStakedTransferredToL2: BigInt + totalTokensStakedTransferredToL2_not: BigInt + totalTokensStakedTransferredToL2_gt: BigInt + totalTokensStakedTransferredToL2_lt: BigInt + totalTokensStakedTransferredToL2_gte: BigInt + totalTokensStakedTransferredToL2_lte: BigInt + totalTokensStakedTransferredToL2_in: [BigInt!] + totalTokensStakedTransferredToL2_not_in: [BigInt!] + totalDelegatedTokensTransferredToL2: BigInt + totalDelegatedTokensTransferredToL2_not: BigInt + totalDelegatedTokensTransferredToL2_gt: BigInt + totalDelegatedTokensTransferredToL2_lt: BigInt + totalDelegatedTokensTransferredToL2_gte: BigInt + totalDelegatedTokensTransferredToL2_lte: BigInt + totalDelegatedTokensTransferredToL2_in: [BigInt!] + totalDelegatedTokensTransferredToL2_not_in: [BigInt!] + totalSignalledTokensTransferredToL2: BigInt + totalSignalledTokensTransferredToL2_not: BigInt + totalSignalledTokensTransferredToL2_gt: BigInt + totalSignalledTokensTransferredToL2_lt: BigInt + totalSignalledTokensTransferredToL2_gte: BigInt + totalSignalledTokensTransferredToL2_lte: BigInt + totalSignalledTokensTransferredToL2_in: [BigInt!] + totalSignalledTokensTransferredToL2_not_in: [BigInt!] + totalTokensStaked: BigInt + totalTokensStaked_not: BigInt + totalTokensStaked_gt: BigInt + totalTokensStaked_lt: BigInt + totalTokensStaked_gte: BigInt + totalTokensStaked_lte: BigInt + totalTokensStaked_in: [BigInt!] + totalTokensStaked_not_in: [BigInt!] + totalTokensClaimable: BigInt + totalTokensClaimable_not: BigInt + totalTokensClaimable_gt: BigInt + totalTokensClaimable_lt: BigInt + totalTokensClaimable_gte: BigInt + totalTokensClaimable_lte: BigInt + totalTokensClaimable_in: [BigInt!] + totalTokensClaimable_not_in: [BigInt!] + totalUnstakedTokensLocked: BigInt + totalUnstakedTokensLocked_not: BigInt + totalUnstakedTokensLocked_gt: BigInt + totalUnstakedTokensLocked_lt: BigInt + totalUnstakedTokensLocked_gte: BigInt + totalUnstakedTokensLocked_lte: BigInt + totalUnstakedTokensLocked_in: [BigInt!] + totalUnstakedTokensLocked_not_in: [BigInt!] + totalTokensAllocated: BigInt + totalTokensAllocated_not: BigInt + totalTokensAllocated_gt: BigInt + totalTokensAllocated_lt: BigInt + totalTokensAllocated_gte: BigInt + totalTokensAllocated_lte: BigInt + totalTokensAllocated_in: [BigInt!] + totalTokensAllocated_not_in: [BigInt!] + totalDelegatedTokens: BigInt + totalDelegatedTokens_not: BigInt + totalDelegatedTokens_gt: BigInt + totalDelegatedTokens_lt: BigInt + totalDelegatedTokens_gte: BigInt + totalDelegatedTokens_lte: BigInt + totalDelegatedTokens_in: [BigInt!] + totalDelegatedTokens_not_in: [BigInt!] + totalTokensSignalled: BigInt + totalTokensSignalled_not: BigInt + totalTokensSignalled_gt: BigInt + totalTokensSignalled_lt: BigInt + totalTokensSignalled_gte: BigInt + totalTokensSignalled_lte: BigInt + totalTokensSignalled_in: [BigInt!] + totalTokensSignalled_not_in: [BigInt!] + totalTokensSignalledAutoMigrate: BigDecimal + totalTokensSignalledAutoMigrate_not: BigDecimal + totalTokensSignalledAutoMigrate_gt: BigDecimal + totalTokensSignalledAutoMigrate_lt: BigDecimal + totalTokensSignalledAutoMigrate_gte: BigDecimal + totalTokensSignalledAutoMigrate_lte: BigDecimal + totalTokensSignalledAutoMigrate_in: [BigDecimal!] + totalTokensSignalledAutoMigrate_not_in: [BigDecimal!] + totalTokensSignalledDirectly: BigDecimal + totalTokensSignalledDirectly_not: BigDecimal + totalTokensSignalledDirectly_gt: BigDecimal + totalTokensSignalledDirectly_lt: BigDecimal + totalTokensSignalledDirectly_gte: BigDecimal + totalTokensSignalledDirectly_lte: BigDecimal + totalTokensSignalledDirectly_in: [BigDecimal!] + totalTokensSignalledDirectly_not_in: [BigDecimal!] + totalQueryFees: BigInt + totalQueryFees_not: BigInt + totalQueryFees_gt: BigInt + totalQueryFees_lt: BigInt + totalQueryFees_gte: BigInt + totalQueryFees_lte: BigInt + totalQueryFees_in: [BigInt!] + totalQueryFees_not_in: [BigInt!] + totalIndexerQueryFeesCollected: BigInt + totalIndexerQueryFeesCollected_not: BigInt + totalIndexerQueryFeesCollected_gt: BigInt + totalIndexerQueryFeesCollected_lt: BigInt + totalIndexerQueryFeesCollected_gte: BigInt + totalIndexerQueryFeesCollected_lte: BigInt + totalIndexerQueryFeesCollected_in: [BigInt!] + totalIndexerQueryFeesCollected_not_in: [BigInt!] + totalIndexerQueryFeeRebates: BigInt + totalIndexerQueryFeeRebates_not: BigInt + totalIndexerQueryFeeRebates_gt: BigInt + totalIndexerQueryFeeRebates_lt: BigInt + totalIndexerQueryFeeRebates_gte: BigInt + totalIndexerQueryFeeRebates_lte: BigInt + totalIndexerQueryFeeRebates_in: [BigInt!] + totalIndexerQueryFeeRebates_not_in: [BigInt!] + totalDelegatorQueryFeeRebates: BigInt + totalDelegatorQueryFeeRebates_not: BigInt + totalDelegatorQueryFeeRebates_gt: BigInt + totalDelegatorQueryFeeRebates_lt: BigInt + totalDelegatorQueryFeeRebates_gte: BigInt + totalDelegatorQueryFeeRebates_lte: BigInt + totalDelegatorQueryFeeRebates_in: [BigInt!] + totalDelegatorQueryFeeRebates_not_in: [BigInt!] + totalCuratorQueryFees: BigInt + totalCuratorQueryFees_not: BigInt + totalCuratorQueryFees_gt: BigInt + totalCuratorQueryFees_lt: BigInt + totalCuratorQueryFees_gte: BigInt + totalCuratorQueryFees_lte: BigInt + totalCuratorQueryFees_in: [BigInt!] + totalCuratorQueryFees_not_in: [BigInt!] + totalTaxedQueryFees: BigInt + totalTaxedQueryFees_not: BigInt + totalTaxedQueryFees_gt: BigInt + totalTaxedQueryFees_lt: BigInt + totalTaxedQueryFees_gte: BigInt + totalTaxedQueryFees_lte: BigInt + totalTaxedQueryFees_in: [BigInt!] + totalTaxedQueryFees_not_in: [BigInt!] + totalUnclaimedQueryFeeRebates: BigInt + totalUnclaimedQueryFeeRebates_not: BigInt + totalUnclaimedQueryFeeRebates_gt: BigInt + totalUnclaimedQueryFeeRebates_lt: BigInt + totalUnclaimedQueryFeeRebates_gte: BigInt + totalUnclaimedQueryFeeRebates_lte: BigInt + totalUnclaimedQueryFeeRebates_in: [BigInt!] + totalUnclaimedQueryFeeRebates_not_in: [BigInt!] + totalIndexingRewards: BigInt + totalIndexingRewards_not: BigInt + totalIndexingRewards_gt: BigInt + totalIndexingRewards_lt: BigInt + totalIndexingRewards_gte: BigInt + totalIndexingRewards_lte: BigInt + totalIndexingRewards_in: [BigInt!] + totalIndexingRewards_not_in: [BigInt!] + totalIndexingDelegatorRewards: BigInt + totalIndexingDelegatorRewards_not: BigInt + totalIndexingDelegatorRewards_gt: BigInt + totalIndexingDelegatorRewards_lt: BigInt + totalIndexingDelegatorRewards_gte: BigInt + totalIndexingDelegatorRewards_lte: BigInt + totalIndexingDelegatorRewards_in: [BigInt!] + totalIndexingDelegatorRewards_not_in: [BigInt!] + totalIndexingIndexerRewards: BigInt + totalIndexingIndexerRewards_not: BigInt + totalIndexingIndexerRewards_gt: BigInt + totalIndexingIndexerRewards_lt: BigInt + totalIndexingIndexerRewards_gte: BigInt + totalIndexingIndexerRewards_lte: BigInt + totalIndexingIndexerRewards_in: [BigInt!] + totalIndexingIndexerRewards_not_in: [BigInt!] + networkGRTIssuance: BigInt + networkGRTIssuance_not: BigInt + networkGRTIssuance_gt: BigInt + networkGRTIssuance_lt: BigInt + networkGRTIssuance_gte: BigInt + networkGRTIssuance_lte: BigInt + networkGRTIssuance_in: [BigInt!] + networkGRTIssuance_not_in: [BigInt!] + networkGRTIssuancePerBlock: BigInt + networkGRTIssuancePerBlock_not: BigInt + networkGRTIssuancePerBlock_gt: BigInt + networkGRTIssuancePerBlock_lt: BigInt + networkGRTIssuancePerBlock_gte: BigInt + networkGRTIssuancePerBlock_lte: BigInt + networkGRTIssuancePerBlock_in: [BigInt!] + networkGRTIssuancePerBlock_not_in: [BigInt!] + subgraphAvailabilityOracle: Bytes + subgraphAvailabilityOracle_not: Bytes + subgraphAvailabilityOracle_gt: Bytes + subgraphAvailabilityOracle_lt: Bytes + subgraphAvailabilityOracle_gte: Bytes + subgraphAvailabilityOracle_lte: Bytes + subgraphAvailabilityOracle_in: [Bytes!] + subgraphAvailabilityOracle_not_in: [Bytes!] + subgraphAvailabilityOracle_contains: Bytes + subgraphAvailabilityOracle_not_contains: Bytes + defaultReserveRatio: Int + defaultReserveRatio_not: Int + defaultReserveRatio_gt: Int + defaultReserveRatio_lt: Int + defaultReserveRatio_gte: Int + defaultReserveRatio_lte: Int + defaultReserveRatio_in: [Int!] + defaultReserveRatio_not_in: [Int!] + minimumCurationDeposit: BigInt + minimumCurationDeposit_not: BigInt + minimumCurationDeposit_gt: BigInt + minimumCurationDeposit_lt: BigInt + minimumCurationDeposit_gte: BigInt + minimumCurationDeposit_lte: BigInt + minimumCurationDeposit_in: [BigInt!] + minimumCurationDeposit_not_in: [BigInt!] + curationTaxPercentage: Int + curationTaxPercentage_not: Int + curationTaxPercentage_gt: Int + curationTaxPercentage_lt: Int + curationTaxPercentage_gte: Int + curationTaxPercentage_lte: Int + curationTaxPercentage_in: [Int!] + curationTaxPercentage_not_in: [Int!] + ownerTaxPercentage: Int + ownerTaxPercentage_not: Int + ownerTaxPercentage_gt: Int + ownerTaxPercentage_lt: Int + ownerTaxPercentage_gte: Int + ownerTaxPercentage_lte: Int + ownerTaxPercentage_in: [Int!] + ownerTaxPercentage_not_in: [Int!] + totalSupply: BigInt + totalSupply_not: BigInt + totalSupply_gt: BigInt + totalSupply_lt: BigInt + totalSupply_gte: BigInt + totalSupply_lte: BigInt + totalSupply_in: [BigInt!] + totalSupply_not_in: [BigInt!] + GRTinUSD: BigDecimal + GRTinUSD_not: BigDecimal + GRTinUSD_gt: BigDecimal + GRTinUSD_lt: BigDecimal + GRTinUSD_gte: BigDecimal + GRTinUSD_lte: BigDecimal + GRTinUSD_in: [BigDecimal!] + GRTinUSD_not_in: [BigDecimal!] + GRTinETH: BigDecimal + GRTinETH_not: BigDecimal + GRTinETH_gt: BigDecimal + GRTinETH_lt: BigDecimal + GRTinETH_gte: BigDecimal + GRTinETH_lte: BigDecimal + GRTinETH_in: [BigDecimal!] + GRTinETH_not_in: [BigDecimal!] + totalGRTMinted: BigInt + totalGRTMinted_not: BigInt + totalGRTMinted_gt: BigInt + totalGRTMinted_lt: BigInt + totalGRTMinted_gte: BigInt + totalGRTMinted_lte: BigInt + totalGRTMinted_in: [BigInt!] + totalGRTMinted_not_in: [BigInt!] + totalGRTBurned: BigInt + totalGRTBurned_not: BigInt + totalGRTBurned_gt: BigInt + totalGRTBurned_lt: BigInt + totalGRTBurned_gte: BigInt + totalGRTBurned_lte: BigInt + totalGRTBurned_in: [BigInt!] + totalGRTBurned_not_in: [BigInt!] + epochLength: Int + epochLength_not: Int + epochLength_gt: Int + epochLength_lt: Int + epochLength_gte: Int + epochLength_lte: Int + epochLength_in: [Int!] + epochLength_not_in: [Int!] + lastRunEpoch: Int + lastRunEpoch_not: Int + lastRunEpoch_gt: Int + lastRunEpoch_lt: Int + lastRunEpoch_gte: Int + lastRunEpoch_lte: Int + lastRunEpoch_in: [Int!] + lastRunEpoch_not_in: [Int!] + lastLengthUpdateEpoch: Int + lastLengthUpdateEpoch_not: Int + lastLengthUpdateEpoch_gt: Int + lastLengthUpdateEpoch_lt: Int + lastLengthUpdateEpoch_gte: Int + lastLengthUpdateEpoch_lte: Int + lastLengthUpdateEpoch_in: [Int!] + lastLengthUpdateEpoch_not_in: [Int!] + lastLengthUpdateBlock: Int + lastLengthUpdateBlock_not: Int + lastLengthUpdateBlock_gt: Int + lastLengthUpdateBlock_lt: Int + lastLengthUpdateBlock_gte: Int + lastLengthUpdateBlock_lte: Int + lastLengthUpdateBlock_in: [Int!] + lastLengthUpdateBlock_not_in: [Int!] + currentEpoch: Int + currentEpoch_not: Int + currentEpoch_gt: Int + currentEpoch_lt: Int + currentEpoch_gte: Int + currentEpoch_lte: Int + currentEpoch_in: [Int!] + currentEpoch_not_in: [Int!] + indexerCount: Int + indexerCount_not: Int + indexerCount_gt: Int + indexerCount_lt: Int + indexerCount_gte: Int + indexerCount_lte: Int + indexerCount_in: [Int!] + indexerCount_not_in: [Int!] + stakedIndexersCount: Int + stakedIndexersCount_not: Int + stakedIndexersCount_gt: Int + stakedIndexersCount_lt: Int + stakedIndexersCount_gte: Int + stakedIndexersCount_lte: Int + stakedIndexersCount_in: [Int!] + stakedIndexersCount_not_in: [Int!] + delegatorCount: Int + delegatorCount_not: Int + delegatorCount_gt: Int + delegatorCount_lt: Int + delegatorCount_gte: Int + delegatorCount_lte: Int + delegatorCount_in: [Int!] + delegatorCount_not_in: [Int!] + activeDelegatorCount: Int + activeDelegatorCount_not: Int + activeDelegatorCount_gt: Int + activeDelegatorCount_lt: Int + activeDelegatorCount_gte: Int + activeDelegatorCount_lte: Int + activeDelegatorCount_in: [Int!] + activeDelegatorCount_not_in: [Int!] + delegationCount: Int + delegationCount_not: Int + delegationCount_gt: Int + delegationCount_lt: Int + delegationCount_gte: Int + delegationCount_lte: Int + delegationCount_in: [Int!] + delegationCount_not_in: [Int!] + activeDelegationCount: Int + activeDelegationCount_not: Int + activeDelegationCount_gt: Int + activeDelegationCount_lt: Int + activeDelegationCount_gte: Int + activeDelegationCount_lte: Int + activeDelegationCount_in: [Int!] + activeDelegationCount_not_in: [Int!] + curatorCount: Int + curatorCount_not: Int + curatorCount_gt: Int + curatorCount_lt: Int + curatorCount_gte: Int + curatorCount_lte: Int + curatorCount_in: [Int!] + curatorCount_not_in: [Int!] + activeCuratorCount: Int + activeCuratorCount_not: Int + activeCuratorCount_gt: Int + activeCuratorCount_lt: Int + activeCuratorCount_gte: Int + activeCuratorCount_lte: Int + activeCuratorCount_in: [Int!] + activeCuratorCount_not_in: [Int!] + subgraphCount: Int + subgraphCount_not: Int + subgraphCount_gt: Int + subgraphCount_lt: Int + subgraphCount_gte: Int + subgraphCount_lte: Int + subgraphCount_in: [Int!] + subgraphCount_not_in: [Int!] + activeSubgraphCount: Int + activeSubgraphCount_not: Int + activeSubgraphCount_gt: Int + activeSubgraphCount_lt: Int + activeSubgraphCount_gte: Int + activeSubgraphCount_lte: Int + activeSubgraphCount_in: [Int!] + activeSubgraphCount_not_in: [Int!] + subgraphDeploymentCount: Int + subgraphDeploymentCount_not: Int + subgraphDeploymentCount_gt: Int + subgraphDeploymentCount_lt: Int + subgraphDeploymentCount_gte: Int + subgraphDeploymentCount_lte: Int + subgraphDeploymentCount_in: [Int!] + subgraphDeploymentCount_not_in: [Int!] + epochCount: Int + epochCount_not: Int + epochCount_gt: Int + epochCount_lt: Int + epochCount_gte: Int + epochCount_lte: Int + epochCount_in: [Int!] + epochCount_not_in: [Int!] + allocationCount: Int + allocationCount_not: Int + allocationCount_gt: Int + allocationCount_lt: Int + allocationCount_gte: Int + allocationCount_lte: Int + allocationCount_in: [Int!] + allocationCount_not_in: [Int!] + activeAllocationCount: Int + activeAllocationCount_not: Int + activeAllocationCount_gt: Int + activeAllocationCount_lt: Int + activeAllocationCount_gte: Int + activeAllocationCount_lte: Int + activeAllocationCount_in: [Int!] + activeAllocationCount_not_in: [Int!] + arbitrator: Bytes + arbitrator_not: Bytes + arbitrator_gt: Bytes + arbitrator_lt: Bytes + arbitrator_gte: Bytes + arbitrator_lte: Bytes + arbitrator_in: [Bytes!] + arbitrator_not_in: [Bytes!] + arbitrator_contains: Bytes + arbitrator_not_contains: Bytes + querySlashingPercentage: Int + querySlashingPercentage_not: Int + querySlashingPercentage_gt: Int + querySlashingPercentage_lt: Int + querySlashingPercentage_gte: Int + querySlashingPercentage_lte: Int + querySlashingPercentage_in: [Int!] + querySlashingPercentage_not_in: [Int!] + indexingSlashingPercentage: Int + indexingSlashingPercentage_not: Int + indexingSlashingPercentage_gt: Int + indexingSlashingPercentage_lt: Int + indexingSlashingPercentage_gte: Int + indexingSlashingPercentage_lte: Int + indexingSlashingPercentage_in: [Int!] + indexingSlashingPercentage_not_in: [Int!] + slashingPercentage: Int + slashingPercentage_not: Int + slashingPercentage_gt: Int + slashingPercentage_lt: Int + slashingPercentage_gte: Int + slashingPercentage_lte: Int + slashingPercentage_in: [Int!] + slashingPercentage_not_in: [Int!] + minimumDisputeDeposit: BigInt + minimumDisputeDeposit_not: BigInt + minimumDisputeDeposit_gt: BigInt + minimumDisputeDeposit_lt: BigInt + minimumDisputeDeposit_gte: BigInt + minimumDisputeDeposit_lte: BigInt + minimumDisputeDeposit_in: [BigInt!] + minimumDisputeDeposit_not_in: [BigInt!] + fishermanRewardPercentage: Int + fishermanRewardPercentage_not: Int + fishermanRewardPercentage_gt: Int + fishermanRewardPercentage_lt: Int + fishermanRewardPercentage_gte: Int + fishermanRewardPercentage_lte: Int + fishermanRewardPercentage_in: [Int!] + fishermanRewardPercentage_not_in: [Int!] + totalGRTDeposited: BigInt + totalGRTDeposited_not: BigInt + totalGRTDeposited_gt: BigInt + totalGRTDeposited_lt: BigInt + totalGRTDeposited_gte: BigInt + totalGRTDeposited_lte: BigInt + totalGRTDeposited_in: [BigInt!] + totalGRTDeposited_not_in: [BigInt!] + totalGRTWithdrawnConfirmed: BigInt + totalGRTWithdrawnConfirmed_not: BigInt + totalGRTWithdrawnConfirmed_gt: BigInt + totalGRTWithdrawnConfirmed_lt: BigInt + totalGRTWithdrawnConfirmed_gte: BigInt + totalGRTWithdrawnConfirmed_lte: BigInt + totalGRTWithdrawnConfirmed_in: [BigInt!] + totalGRTWithdrawnConfirmed_not_in: [BigInt!] + totalGRTMintedFromL2: BigInt + totalGRTMintedFromL2_not: BigInt + totalGRTMintedFromL2_gt: BigInt + totalGRTMintedFromL2_lt: BigInt + totalGRTMintedFromL2_gte: BigInt + totalGRTMintedFromL2_lte: BigInt + totalGRTMintedFromL2_in: [BigInt!] + totalGRTMintedFromL2_not_in: [BigInt!] + totalGRTDepositedConfirmed: BigInt + totalGRTDepositedConfirmed_not: BigInt + totalGRTDepositedConfirmed_gt: BigInt + totalGRTDepositedConfirmed_lt: BigInt + totalGRTDepositedConfirmed_gte: BigInt + totalGRTDepositedConfirmed_lte: BigInt + totalGRTDepositedConfirmed_in: [BigInt!] + totalGRTDepositedConfirmed_not_in: [BigInt!] + totalGRTWithdrawn: BigInt + totalGRTWithdrawn_not: BigInt + totalGRTWithdrawn_gt: BigInt + totalGRTWithdrawn_lt: BigInt + totalGRTWithdrawn_gte: BigInt + totalGRTWithdrawn_lte: BigInt + totalGRTWithdrawn_in: [BigInt!] + totalGRTWithdrawn_not_in: [BigInt!] + currentL1BlockNumber: BigInt + currentL1BlockNumber_not: BigInt + currentL1BlockNumber_gt: BigInt + currentL1BlockNumber_lt: BigInt + currentL1BlockNumber_gte: BigInt + currentL1BlockNumber_lte: BigInt + currentL1BlockNumber_in: [BigInt!] + currentL1BlockNumber_not_in: [BigInt!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [GraphNetwork_filter] + or: [GraphNetwork_filter] +} + +enum GraphNetwork_orderBy { + id + controller + graphToken + epochManager + epochManagerImplementations + curation + curationImplementations + staking + stakingImplementations + disputeManager + gns + serviceRegistry + rewardsManager + rewardsManagerImplementations + isPaused + isPartialPaused + governor + pauseGuardian + curationPercentage + protocolFeePercentage + delegationRatio + channelDisputeEpochs + maxAllocationEpochs + thawingPeriod + delegationParametersCooldown + minimumIndexerStake + slashers + delegationUnbondingPeriod + rebateRatio + rebateAlpha + rebateLambda + delegationTaxPercentage + assetHolders + totalTokensStakedTransferredToL2 + totalDelegatedTokensTransferredToL2 + totalSignalledTokensTransferredToL2 + totalTokensStaked + totalTokensClaimable + totalUnstakedTokensLocked + totalTokensAllocated + totalDelegatedTokens + totalTokensSignalled + totalTokensSignalledAutoMigrate + totalTokensSignalledDirectly + totalQueryFees + totalIndexerQueryFeesCollected + totalIndexerQueryFeeRebates + totalDelegatorQueryFeeRebates + totalCuratorQueryFees + totalTaxedQueryFees + totalUnclaimedQueryFeeRebates + totalIndexingRewards + totalIndexingDelegatorRewards + totalIndexingIndexerRewards + networkGRTIssuance + networkGRTIssuancePerBlock + subgraphAvailabilityOracle + defaultReserveRatio + minimumCurationDeposit + curationTaxPercentage + ownerTaxPercentage + totalSupply + GRTinUSD + GRTinETH + totalGRTMinted + totalGRTBurned + epochLength + lastRunEpoch + lastLengthUpdateEpoch + lastLengthUpdateBlock + currentEpoch + indexerCount + stakedIndexersCount + delegatorCount + activeDelegatorCount + delegationCount + activeDelegationCount + curatorCount + activeCuratorCount + subgraphCount + activeSubgraphCount + subgraphDeploymentCount + epochCount + allocationCount + activeAllocationCount + arbitrator + querySlashingPercentage + indexingSlashingPercentage + slashingPercentage + minimumDisputeDeposit + fishermanRewardPercentage + totalGRTDeposited + totalGRTWithdrawnConfirmed + totalGRTMintedFromL2 + totalGRTDepositedConfirmed + totalGRTWithdrawn + currentL1BlockNumber +} + +""" +Meta for the Indexer along with parameters and staking data + +""" +type Indexer { + """Eth address of Indexer""" + id: ID! + + """Time this indexer was created""" + createdAt: Int! + + """Graph account of this indexer""" + account: GraphAccount! + + """Service registry URL for the indexer""" + url: String + + """ + Geohash of the indexer. Shows where their indexer is located in the world + """ + geoHash: String + + """ + Default display name is the current default name. Used for filtered queries + """ + defaultDisplayName: String + + """ + CURRENT tokens staked in the protocol. Decreases on withdraw, not on lock + """ + stakedTokens: BigInt! + + """CURRENT tokens allocated on all subgraphs""" + allocatedTokens: BigInt! + + """NOT IMPLEMENTED - Tokens that have been unstaked and withdrawn""" + unstakedTokens: BigInt! + + """CURRENT tokens locked""" + lockedTokens: BigInt! + + """The block when the Indexers tokens unlock""" + tokensLockedUntil: Int! + + """Active allocations of stake for this Indexer""" + allocations(skip: Int = 0, first: Int = 100, orderBy: Allocation_orderBy, orderDirection: OrderDirection, where: Allocation_filter): [Allocation!]! + + """All allocations of stake for this Indexer (i.e. closed and active)""" + totalAllocations(skip: Int = 0, first: Int = 100, orderBy: Allocation_orderBy, orderDirection: OrderDirection, where: Allocation_filter): [Allocation!]! + + """Number of active allocations of stake for this Indexer""" + allocationCount: Int! + + """All allocations for this Indexer (i.e. closed and active)""" + totalAllocationCount: BigInt! + + """Total query fees collected. Includes the portion given to delegators""" + queryFeesCollected: BigInt! + + """ + Query fee rebate amount claimed from the protocol through rebates mechanism. Does not include portion given to delegators + """ + queryFeeRebates: BigInt! + + """ + Total indexing rewards earned by this indexer from inflation. Including delegation rewards + """ + rewardsEarned: BigInt! + + """The total amount of indexing rewards the indexer kept""" + indexerIndexingRewards: BigInt! + + """The total amount of indexing rewards given to delegators""" + delegatorIndexingRewards: BigInt! + + """ + Percentage of indexers' own rewards received in relation to its own stake. 1 + (100%) means that the indexer is receiving the exact amount that is generated + by his own stake + """ + indexerRewardsOwnGenerationRatio: BigDecimal! + + """ + Whether the indexer has been transferred from L1 to L2 partially or fully + """ + transferredToL2: Boolean! + + """Timestamp for the FIRST L1 -> L2 Transfer""" + firstTransferredToL2At: BigInt + + """Block number for the FIRST L1 -> L2 Transfer""" + firstTransferredToL2AtBlockNumber: BigInt + + """Transaction hash for the FIRST L1 -> L2 Transfer""" + firstTransferredToL2AtTx: String + + """Timestamp for the latest L1 -> L2 Transfer""" + lastTransferredToL2At: BigInt + + """Block number for the latest L1 -> L2 Transfer""" + lastTransferredToL2AtBlockNumber: BigInt + + """Transaction hash for the latest L1 -> L2 Transfer""" + lastTransferredToL2AtTx: String + + """ + Amount of GRT transferred to L2. Only visible from L1, as there's no events for it on L2 + """ + stakedTokensTransferredToL2: BigInt! + + """ID of the indexer on L2. Null if it's not transferred""" + idOnL2: String + + """ID of the indexer on L1. Null if it's not transferred""" + idOnL1: String + + """Amount of delegated tokens that can be eligible for rewards""" + delegatedCapacity: BigInt! + + """Total token capacity = delegatedCapacity + stakedTokens""" + tokenCapacity: BigInt! + + """ + Stake available to earn rewards. tokenCapacity - allocationTokens - lockedTokens + """ + availableStake: BigInt! + + """Delegators to this Indexer""" + delegators(skip: Int = 0, first: Int = 100, orderBy: DelegatedStake_orderBy, orderDirection: OrderDirection, where: DelegatedStake_filter): [DelegatedStake!]! + + """CURRENT tokens delegated to the indexer""" + delegatedTokens: BigInt! + + """ + Ratio between the amount of the indexers own stake over the total usable stake. + """ + ownStakeRatio: BigDecimal! + + """ + Ratio between the amount of delegated stake over the total usable stake. + """ + delegatedStakeRatio: BigDecimal! + + """Total shares of the delegator pool""" + delegatorShares: BigInt! + + """Exchange rate of of tokens received for each share""" + delegationExchangeRate: BigDecimal! + + """ + The percent of indexing rewards generated by the total stake that the Indexer keeps for itself. In parts per million + """ + indexingRewardCut: Int! + + """ + The percent of indexing rewards generated by the delegated stake that the Indexer keeps for itself + """ + indexingRewardEffectiveCut: BigDecimal! + + """ + The percent of reward dilution delegators experience because of + overdelegation. Overdelegated stake can't be used to generate rewards but + still gets accounted while distributing the generated rewards. This causes + dilution of the rewards for the rest of the pool. + """ + overDelegationDilution: BigDecimal! + + """The total amount of query fees given to delegators""" + delegatorQueryFees: BigInt! + + """ + The percent of query rebate rewards the Indexer keeps for itself. In parts per million + """ + queryFeeCut: Int! + + """ + The percent of query rebate rewards generated by the delegated stake that the Indexer keeps for itself + """ + queryFeeEffectiveCut: BigDecimal! + + """ + Amount of blocks a delegator chooses for the waiting period for changing their params + """ + delegatorParameterCooldown: Int! + + """Block number for the last time the delegator updated their parameters""" + lastDelegationParameterUpdate: Int! + + """ + Count of how many times this indexer has been forced to close an allocation + """ + forcedClosures: Int! + + """NOT IMPLEMENTED - Total return this indexer has earned""" + totalReturn: BigDecimal! + + """NOT IMPLEMENTED - Annualized rate of return for the indexer""" + annualizedReturn: BigDecimal! + + """NOT IMPLEMENTED - Staking efficiency of the indexer""" + stakingEfficiency: BigDecimal! +} + +input Indexer_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + account: String + account_not: String + account_gt: String + account_lt: String + account_gte: String + account_lte: String + account_in: [String!] + account_not_in: [String!] + account_contains: String + account_contains_nocase: String + account_not_contains: String + account_not_contains_nocase: String + account_starts_with: String + account_starts_with_nocase: String + account_not_starts_with: String + account_not_starts_with_nocase: String + account_ends_with: String + account_ends_with_nocase: String + account_not_ends_with: String + account_not_ends_with_nocase: String + account_: GraphAccount_filter + url: String + url_not: String + url_gt: String + url_lt: String + url_gte: String + url_lte: String + url_in: [String!] + url_not_in: [String!] + url_contains: String + url_contains_nocase: String + url_not_contains: String + url_not_contains_nocase: String + url_starts_with: String + url_starts_with_nocase: String + url_not_starts_with: String + url_not_starts_with_nocase: String + url_ends_with: String + url_ends_with_nocase: String + url_not_ends_with: String + url_not_ends_with_nocase: String + geoHash: String + geoHash_not: String + geoHash_gt: String + geoHash_lt: String + geoHash_gte: String + geoHash_lte: String + geoHash_in: [String!] + geoHash_not_in: [String!] + geoHash_contains: String + geoHash_contains_nocase: String + geoHash_not_contains: String + geoHash_not_contains_nocase: String + geoHash_starts_with: String + geoHash_starts_with_nocase: String + geoHash_not_starts_with: String + geoHash_not_starts_with_nocase: String + geoHash_ends_with: String + geoHash_ends_with_nocase: String + geoHash_not_ends_with: String + geoHash_not_ends_with_nocase: String + defaultDisplayName: String + defaultDisplayName_not: String + defaultDisplayName_gt: String + defaultDisplayName_lt: String + defaultDisplayName_gte: String + defaultDisplayName_lte: String + defaultDisplayName_in: [String!] + defaultDisplayName_not_in: [String!] + defaultDisplayName_contains: String + defaultDisplayName_contains_nocase: String + defaultDisplayName_not_contains: String + defaultDisplayName_not_contains_nocase: String + defaultDisplayName_starts_with: String + defaultDisplayName_starts_with_nocase: String + defaultDisplayName_not_starts_with: String + defaultDisplayName_not_starts_with_nocase: String + defaultDisplayName_ends_with: String + defaultDisplayName_ends_with_nocase: String + defaultDisplayName_not_ends_with: String + defaultDisplayName_not_ends_with_nocase: String + stakedTokens: BigInt + stakedTokens_not: BigInt + stakedTokens_gt: BigInt + stakedTokens_lt: BigInt + stakedTokens_gte: BigInt + stakedTokens_lte: BigInt + stakedTokens_in: [BigInt!] + stakedTokens_not_in: [BigInt!] + allocatedTokens: BigInt + allocatedTokens_not: BigInt + allocatedTokens_gt: BigInt + allocatedTokens_lt: BigInt + allocatedTokens_gte: BigInt + allocatedTokens_lte: BigInt + allocatedTokens_in: [BigInt!] + allocatedTokens_not_in: [BigInt!] + unstakedTokens: BigInt + unstakedTokens_not: BigInt + unstakedTokens_gt: BigInt + unstakedTokens_lt: BigInt + unstakedTokens_gte: BigInt + unstakedTokens_lte: BigInt + unstakedTokens_in: [BigInt!] + unstakedTokens_not_in: [BigInt!] + lockedTokens: BigInt + lockedTokens_not: BigInt + lockedTokens_gt: BigInt + lockedTokens_lt: BigInt + lockedTokens_gte: BigInt + lockedTokens_lte: BigInt + lockedTokens_in: [BigInt!] + lockedTokens_not_in: [BigInt!] + tokensLockedUntil: Int + tokensLockedUntil_not: Int + tokensLockedUntil_gt: Int + tokensLockedUntil_lt: Int + tokensLockedUntil_gte: Int + tokensLockedUntil_lte: Int + tokensLockedUntil_in: [Int!] + tokensLockedUntil_not_in: [Int!] + allocations_: Allocation_filter + totalAllocations_: Allocation_filter + allocationCount: Int + allocationCount_not: Int + allocationCount_gt: Int + allocationCount_lt: Int + allocationCount_gte: Int + allocationCount_lte: Int + allocationCount_in: [Int!] + allocationCount_not_in: [Int!] + totalAllocationCount: BigInt + totalAllocationCount_not: BigInt + totalAllocationCount_gt: BigInt + totalAllocationCount_lt: BigInt + totalAllocationCount_gte: BigInt + totalAllocationCount_lte: BigInt + totalAllocationCount_in: [BigInt!] + totalAllocationCount_not_in: [BigInt!] + queryFeesCollected: BigInt + queryFeesCollected_not: BigInt + queryFeesCollected_gt: BigInt + queryFeesCollected_lt: BigInt + queryFeesCollected_gte: BigInt + queryFeesCollected_lte: BigInt + queryFeesCollected_in: [BigInt!] + queryFeesCollected_not_in: [BigInt!] + queryFeeRebates: BigInt + queryFeeRebates_not: BigInt + queryFeeRebates_gt: BigInt + queryFeeRebates_lt: BigInt + queryFeeRebates_gte: BigInt + queryFeeRebates_lte: BigInt + queryFeeRebates_in: [BigInt!] + queryFeeRebates_not_in: [BigInt!] + rewardsEarned: BigInt + rewardsEarned_not: BigInt + rewardsEarned_gt: BigInt + rewardsEarned_lt: BigInt + rewardsEarned_gte: BigInt + rewardsEarned_lte: BigInt + rewardsEarned_in: [BigInt!] + rewardsEarned_not_in: [BigInt!] + indexerIndexingRewards: BigInt + indexerIndexingRewards_not: BigInt + indexerIndexingRewards_gt: BigInt + indexerIndexingRewards_lt: BigInt + indexerIndexingRewards_gte: BigInt + indexerIndexingRewards_lte: BigInt + indexerIndexingRewards_in: [BigInt!] + indexerIndexingRewards_not_in: [BigInt!] + delegatorIndexingRewards: BigInt + delegatorIndexingRewards_not: BigInt + delegatorIndexingRewards_gt: BigInt + delegatorIndexingRewards_lt: BigInt + delegatorIndexingRewards_gte: BigInt + delegatorIndexingRewards_lte: BigInt + delegatorIndexingRewards_in: [BigInt!] + delegatorIndexingRewards_not_in: [BigInt!] + indexerRewardsOwnGenerationRatio: BigDecimal + indexerRewardsOwnGenerationRatio_not: BigDecimal + indexerRewardsOwnGenerationRatio_gt: BigDecimal + indexerRewardsOwnGenerationRatio_lt: BigDecimal + indexerRewardsOwnGenerationRatio_gte: BigDecimal + indexerRewardsOwnGenerationRatio_lte: BigDecimal + indexerRewardsOwnGenerationRatio_in: [BigDecimal!] + indexerRewardsOwnGenerationRatio_not_in: [BigDecimal!] + transferredToL2: Boolean + transferredToL2_not: Boolean + transferredToL2_in: [Boolean!] + transferredToL2_not_in: [Boolean!] + firstTransferredToL2At: BigInt + firstTransferredToL2At_not: BigInt + firstTransferredToL2At_gt: BigInt + firstTransferredToL2At_lt: BigInt + firstTransferredToL2At_gte: BigInt + firstTransferredToL2At_lte: BigInt + firstTransferredToL2At_in: [BigInt!] + firstTransferredToL2At_not_in: [BigInt!] + firstTransferredToL2AtBlockNumber: BigInt + firstTransferredToL2AtBlockNumber_not: BigInt + firstTransferredToL2AtBlockNumber_gt: BigInt + firstTransferredToL2AtBlockNumber_lt: BigInt + firstTransferredToL2AtBlockNumber_gte: BigInt + firstTransferredToL2AtBlockNumber_lte: BigInt + firstTransferredToL2AtBlockNumber_in: [BigInt!] + firstTransferredToL2AtBlockNumber_not_in: [BigInt!] + firstTransferredToL2AtTx: String + firstTransferredToL2AtTx_not: String + firstTransferredToL2AtTx_gt: String + firstTransferredToL2AtTx_lt: String + firstTransferredToL2AtTx_gte: String + firstTransferredToL2AtTx_lte: String + firstTransferredToL2AtTx_in: [String!] + firstTransferredToL2AtTx_not_in: [String!] + firstTransferredToL2AtTx_contains: String + firstTransferredToL2AtTx_contains_nocase: String + firstTransferredToL2AtTx_not_contains: String + firstTransferredToL2AtTx_not_contains_nocase: String + firstTransferredToL2AtTx_starts_with: String + firstTransferredToL2AtTx_starts_with_nocase: String + firstTransferredToL2AtTx_not_starts_with: String + firstTransferredToL2AtTx_not_starts_with_nocase: String + firstTransferredToL2AtTx_ends_with: String + firstTransferredToL2AtTx_ends_with_nocase: String + firstTransferredToL2AtTx_not_ends_with: String + firstTransferredToL2AtTx_not_ends_with_nocase: String + lastTransferredToL2At: BigInt + lastTransferredToL2At_not: BigInt + lastTransferredToL2At_gt: BigInt + lastTransferredToL2At_lt: BigInt + lastTransferredToL2At_gte: BigInt + lastTransferredToL2At_lte: BigInt + lastTransferredToL2At_in: [BigInt!] + lastTransferredToL2At_not_in: [BigInt!] + lastTransferredToL2AtBlockNumber: BigInt + lastTransferredToL2AtBlockNumber_not: BigInt + lastTransferredToL2AtBlockNumber_gt: BigInt + lastTransferredToL2AtBlockNumber_lt: BigInt + lastTransferredToL2AtBlockNumber_gte: BigInt + lastTransferredToL2AtBlockNumber_lte: BigInt + lastTransferredToL2AtBlockNumber_in: [BigInt!] + lastTransferredToL2AtBlockNumber_not_in: [BigInt!] + lastTransferredToL2AtTx: String + lastTransferredToL2AtTx_not: String + lastTransferredToL2AtTx_gt: String + lastTransferredToL2AtTx_lt: String + lastTransferredToL2AtTx_gte: String + lastTransferredToL2AtTx_lte: String + lastTransferredToL2AtTx_in: [String!] + lastTransferredToL2AtTx_not_in: [String!] + lastTransferredToL2AtTx_contains: String + lastTransferredToL2AtTx_contains_nocase: String + lastTransferredToL2AtTx_not_contains: String + lastTransferredToL2AtTx_not_contains_nocase: String + lastTransferredToL2AtTx_starts_with: String + lastTransferredToL2AtTx_starts_with_nocase: String + lastTransferredToL2AtTx_not_starts_with: String + lastTransferredToL2AtTx_not_starts_with_nocase: String + lastTransferredToL2AtTx_ends_with: String + lastTransferredToL2AtTx_ends_with_nocase: String + lastTransferredToL2AtTx_not_ends_with: String + lastTransferredToL2AtTx_not_ends_with_nocase: String + stakedTokensTransferredToL2: BigInt + stakedTokensTransferredToL2_not: BigInt + stakedTokensTransferredToL2_gt: BigInt + stakedTokensTransferredToL2_lt: BigInt + stakedTokensTransferredToL2_gte: BigInt + stakedTokensTransferredToL2_lte: BigInt + stakedTokensTransferredToL2_in: [BigInt!] + stakedTokensTransferredToL2_not_in: [BigInt!] + idOnL2: String + idOnL2_not: String + idOnL2_gt: String + idOnL2_lt: String + idOnL2_gte: String + idOnL2_lte: String + idOnL2_in: [String!] + idOnL2_not_in: [String!] + idOnL2_contains: String + idOnL2_contains_nocase: String + idOnL2_not_contains: String + idOnL2_not_contains_nocase: String + idOnL2_starts_with: String + idOnL2_starts_with_nocase: String + idOnL2_not_starts_with: String + idOnL2_not_starts_with_nocase: String + idOnL2_ends_with: String + idOnL2_ends_with_nocase: String + idOnL2_not_ends_with: String + idOnL2_not_ends_with_nocase: String + idOnL1: String + idOnL1_not: String + idOnL1_gt: String + idOnL1_lt: String + idOnL1_gte: String + idOnL1_lte: String + idOnL1_in: [String!] + idOnL1_not_in: [String!] + idOnL1_contains: String + idOnL1_contains_nocase: String + idOnL1_not_contains: String + idOnL1_not_contains_nocase: String + idOnL1_starts_with: String + idOnL1_starts_with_nocase: String + idOnL1_not_starts_with: String + idOnL1_not_starts_with_nocase: String + idOnL1_ends_with: String + idOnL1_ends_with_nocase: String + idOnL1_not_ends_with: String + idOnL1_not_ends_with_nocase: String + delegatedCapacity: BigInt + delegatedCapacity_not: BigInt + delegatedCapacity_gt: BigInt + delegatedCapacity_lt: BigInt + delegatedCapacity_gte: BigInt + delegatedCapacity_lte: BigInt + delegatedCapacity_in: [BigInt!] + delegatedCapacity_not_in: [BigInt!] + tokenCapacity: BigInt + tokenCapacity_not: BigInt + tokenCapacity_gt: BigInt + tokenCapacity_lt: BigInt + tokenCapacity_gte: BigInt + tokenCapacity_lte: BigInt + tokenCapacity_in: [BigInt!] + tokenCapacity_not_in: [BigInt!] + availableStake: BigInt + availableStake_not: BigInt + availableStake_gt: BigInt + availableStake_lt: BigInt + availableStake_gte: BigInt + availableStake_lte: BigInt + availableStake_in: [BigInt!] + availableStake_not_in: [BigInt!] + delegators_: DelegatedStake_filter + delegatedTokens: BigInt + delegatedTokens_not: BigInt + delegatedTokens_gt: BigInt + delegatedTokens_lt: BigInt + delegatedTokens_gte: BigInt + delegatedTokens_lte: BigInt + delegatedTokens_in: [BigInt!] + delegatedTokens_not_in: [BigInt!] + ownStakeRatio: BigDecimal + ownStakeRatio_not: BigDecimal + ownStakeRatio_gt: BigDecimal + ownStakeRatio_lt: BigDecimal + ownStakeRatio_gte: BigDecimal + ownStakeRatio_lte: BigDecimal + ownStakeRatio_in: [BigDecimal!] + ownStakeRatio_not_in: [BigDecimal!] + delegatedStakeRatio: BigDecimal + delegatedStakeRatio_not: BigDecimal + delegatedStakeRatio_gt: BigDecimal + delegatedStakeRatio_lt: BigDecimal + delegatedStakeRatio_gte: BigDecimal + delegatedStakeRatio_lte: BigDecimal + delegatedStakeRatio_in: [BigDecimal!] + delegatedStakeRatio_not_in: [BigDecimal!] + delegatorShares: BigInt + delegatorShares_not: BigInt + delegatorShares_gt: BigInt + delegatorShares_lt: BigInt + delegatorShares_gte: BigInt + delegatorShares_lte: BigInt + delegatorShares_in: [BigInt!] + delegatorShares_not_in: [BigInt!] + delegationExchangeRate: BigDecimal + delegationExchangeRate_not: BigDecimal + delegationExchangeRate_gt: BigDecimal + delegationExchangeRate_lt: BigDecimal + delegationExchangeRate_gte: BigDecimal + delegationExchangeRate_lte: BigDecimal + delegationExchangeRate_in: [BigDecimal!] + delegationExchangeRate_not_in: [BigDecimal!] + indexingRewardCut: Int + indexingRewardCut_not: Int + indexingRewardCut_gt: Int + indexingRewardCut_lt: Int + indexingRewardCut_gte: Int + indexingRewardCut_lte: Int + indexingRewardCut_in: [Int!] + indexingRewardCut_not_in: [Int!] + indexingRewardEffectiveCut: BigDecimal + indexingRewardEffectiveCut_not: BigDecimal + indexingRewardEffectiveCut_gt: BigDecimal + indexingRewardEffectiveCut_lt: BigDecimal + indexingRewardEffectiveCut_gte: BigDecimal + indexingRewardEffectiveCut_lte: BigDecimal + indexingRewardEffectiveCut_in: [BigDecimal!] + indexingRewardEffectiveCut_not_in: [BigDecimal!] + overDelegationDilution: BigDecimal + overDelegationDilution_not: BigDecimal + overDelegationDilution_gt: BigDecimal + overDelegationDilution_lt: BigDecimal + overDelegationDilution_gte: BigDecimal + overDelegationDilution_lte: BigDecimal + overDelegationDilution_in: [BigDecimal!] + overDelegationDilution_not_in: [BigDecimal!] + delegatorQueryFees: BigInt + delegatorQueryFees_not: BigInt + delegatorQueryFees_gt: BigInt + delegatorQueryFees_lt: BigInt + delegatorQueryFees_gte: BigInt + delegatorQueryFees_lte: BigInt + delegatorQueryFees_in: [BigInt!] + delegatorQueryFees_not_in: [BigInt!] + queryFeeCut: Int + queryFeeCut_not: Int + queryFeeCut_gt: Int + queryFeeCut_lt: Int + queryFeeCut_gte: Int + queryFeeCut_lte: Int + queryFeeCut_in: [Int!] + queryFeeCut_not_in: [Int!] + queryFeeEffectiveCut: BigDecimal + queryFeeEffectiveCut_not: BigDecimal + queryFeeEffectiveCut_gt: BigDecimal + queryFeeEffectiveCut_lt: BigDecimal + queryFeeEffectiveCut_gte: BigDecimal + queryFeeEffectiveCut_lte: BigDecimal + queryFeeEffectiveCut_in: [BigDecimal!] + queryFeeEffectiveCut_not_in: [BigDecimal!] + delegatorParameterCooldown: Int + delegatorParameterCooldown_not: Int + delegatorParameterCooldown_gt: Int + delegatorParameterCooldown_lt: Int + delegatorParameterCooldown_gte: Int + delegatorParameterCooldown_lte: Int + delegatorParameterCooldown_in: [Int!] + delegatorParameterCooldown_not_in: [Int!] + lastDelegationParameterUpdate: Int + lastDelegationParameterUpdate_not: Int + lastDelegationParameterUpdate_gt: Int + lastDelegationParameterUpdate_lt: Int + lastDelegationParameterUpdate_gte: Int + lastDelegationParameterUpdate_lte: Int + lastDelegationParameterUpdate_in: [Int!] + lastDelegationParameterUpdate_not_in: [Int!] + forcedClosures: Int + forcedClosures_not: Int + forcedClosures_gt: Int + forcedClosures_lt: Int + forcedClosures_gte: Int + forcedClosures_lte: Int + forcedClosures_in: [Int!] + forcedClosures_not_in: [Int!] + totalReturn: BigDecimal + totalReturn_not: BigDecimal + totalReturn_gt: BigDecimal + totalReturn_lt: BigDecimal + totalReturn_gte: BigDecimal + totalReturn_lte: BigDecimal + totalReturn_in: [BigDecimal!] + totalReturn_not_in: [BigDecimal!] + annualizedReturn: BigDecimal + annualizedReturn_not: BigDecimal + annualizedReturn_gt: BigDecimal + annualizedReturn_lt: BigDecimal + annualizedReturn_gte: BigDecimal + annualizedReturn_lte: BigDecimal + annualizedReturn_in: [BigDecimal!] + annualizedReturn_not_in: [BigDecimal!] + stakingEfficiency: BigDecimal + stakingEfficiency_not: BigDecimal + stakingEfficiency_gt: BigDecimal + stakingEfficiency_lt: BigDecimal + stakingEfficiency_gte: BigDecimal + stakingEfficiency_lte: BigDecimal + stakingEfficiency_in: [BigDecimal!] + stakingEfficiency_not_in: [BigDecimal!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Indexer_filter] + or: [Indexer_filter] +} + +enum Indexer_orderBy { + id + createdAt + account + account__id + account__createdAt + account__defaultDisplayName + account__balance + account__balanceReceivedFromL1Signalling + account__balanceReceivedFromL1Delegation + account__curationApproval + account__stakingApproval + account__gnsApproval + account__developerCreatedAt + account__subgraphQueryFees + url + geoHash + defaultDisplayName + stakedTokens + allocatedTokens + unstakedTokens + lockedTokens + tokensLockedUntil + allocations + totalAllocations + allocationCount + totalAllocationCount + queryFeesCollected + queryFeeRebates + rewardsEarned + indexerIndexingRewards + delegatorIndexingRewards + indexerRewardsOwnGenerationRatio + transferredToL2 + firstTransferredToL2At + firstTransferredToL2AtBlockNumber + firstTransferredToL2AtTx + lastTransferredToL2At + lastTransferredToL2AtBlockNumber + lastTransferredToL2AtTx + stakedTokensTransferredToL2 + idOnL2 + idOnL1 + delegatedCapacity + tokenCapacity + availableStake + delegators + delegatedTokens + ownStakeRatio + delegatedStakeRatio + delegatorShares + delegationExchangeRate + indexingRewardCut + indexingRewardEffectiveCut + overDelegationDilution + delegatorQueryFees + queryFeeCut + queryFeeEffectiveCut + delegatorParameterCooldown + lastDelegationParameterUpdate + forcedClosures + totalReturn + annualizedReturn + stakingEfficiency +} + +""" +8 bytes signed integer + +""" +scalar Int8 + +""" +Curator Name Signal for a single Subgraph + +""" +type NameSignal { + """Eth address + subgraph ID""" + id: ID! + + """Eth address of the curator""" + curator: Curator! + + """Subgraph being signalled""" + subgraph: Subgraph! + + """CUMULATIVE number of tokens the curator has signalled""" + signalledTokens: BigInt! + + """CUMULATIVE number of tokens the curator has unsignalled""" + unsignalledTokens: BigInt! + + """Tokens the curator has withdrawn from a deprecated name curve""" + withdrawnTokens: BigInt! + + """ + Shares of the name pool (GNS) that the curator has from signaling their GRT + """ + nameSignal: BigInt! + + """ + Actual signal shares that the name pool minted with the GRT provided by the curator + """ + signal: BigDecimal! + + """Amount of GRT transferred to L2""" + signalledTokensSentToL2: BigInt! + + """Amount of GRT received on L2""" + signalledTokensReceivedOnL2: BigInt! + + """ + Whether the name signal has been transferred from L1 to L2. Only applies to + NameSignals that have been transferred, native L2 NameSignal entities will return false + """ + transferredToL2: Boolean! + + """Timestamp for the L1 -> L2 Transfer.""" + transferredToL2At: BigInt + + """Block number for the L1 -> L2 Transfer.""" + transferredToL2AtBlockNumber: BigInt + + """Transaction hash for the L1 -> L2 Transfer.""" + transferredToL2AtTx: String + + """ID of the NameSignal entity on L2. Null if it's not transferred""" + idOnL2: String + + """ID of the NameSignal entity on L1. Null if it's not transferred""" + idOnL1: String + + """Block for which the curator last entered or exited the curve""" + lastNameSignalChange: Int! + + """ + Summation of realized rewards from before the last time the curator entered the curation curve + """ + realizedRewards: BigInt! + + """ + [DEPRECATED] Curator average cost basis for this name signal on this subgraph. + New field for further versions will be nameSignalAverageCostBasis + """ + averageCostBasis: BigDecimal! + + """ + [DEPRECATED] nameSignalAverageCostBasis / nameSignal. New field for further + versions will be nameSignalAverageCostBasisPerSignal + """ + averageCostBasisPerSignal: BigDecimal! + + """Curator average cost basis for this name signal on this subgraph""" + nameSignalAverageCostBasis: BigDecimal! + + """nameSignalAverageCostBasis / nameSignal""" + nameSignalAverageCostBasisPerSignal: BigDecimal! + + """ + Curator average cost basis for the version signal on this subgraph name pool + """ + signalAverageCostBasis: BigDecimal! + + """signalAverageCostBasis / signal""" + signalAverageCostBasisPerSignal: BigDecimal! + entityVersion: Int! + + """ + [DEPRECATED] Used for duplicate entities to enable old IDs from before the subgraph NFT update + """ + linkedEntity: NameSignal +} + +input NameSignal_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + curator: String + curator_not: String + curator_gt: String + curator_lt: String + curator_gte: String + curator_lte: String + curator_in: [String!] + curator_not_in: [String!] + curator_contains: String + curator_contains_nocase: String + curator_not_contains: String + curator_not_contains_nocase: String + curator_starts_with: String + curator_starts_with_nocase: String + curator_not_starts_with: String + curator_not_starts_with_nocase: String + curator_ends_with: String + curator_ends_with_nocase: String + curator_not_ends_with: String + curator_not_ends_with_nocase: String + curator_: Curator_filter + subgraph: String + subgraph_not: String + subgraph_gt: String + subgraph_lt: String + subgraph_gte: String + subgraph_lte: String + subgraph_in: [String!] + subgraph_not_in: [String!] + subgraph_contains: String + subgraph_contains_nocase: String + subgraph_not_contains: String + subgraph_not_contains_nocase: String + subgraph_starts_with: String + subgraph_starts_with_nocase: String + subgraph_not_starts_with: String + subgraph_not_starts_with_nocase: String + subgraph_ends_with: String + subgraph_ends_with_nocase: String + subgraph_not_ends_with: String + subgraph_not_ends_with_nocase: String + subgraph_: Subgraph_filter + signalledTokens: BigInt + signalledTokens_not: BigInt + signalledTokens_gt: BigInt + signalledTokens_lt: BigInt + signalledTokens_gte: BigInt + signalledTokens_lte: BigInt + signalledTokens_in: [BigInt!] + signalledTokens_not_in: [BigInt!] + unsignalledTokens: BigInt + unsignalledTokens_not: BigInt + unsignalledTokens_gt: BigInt + unsignalledTokens_lt: BigInt + unsignalledTokens_gte: BigInt + unsignalledTokens_lte: BigInt + unsignalledTokens_in: [BigInt!] + unsignalledTokens_not_in: [BigInt!] + withdrawnTokens: BigInt + withdrawnTokens_not: BigInt + withdrawnTokens_gt: BigInt + withdrawnTokens_lt: BigInt + withdrawnTokens_gte: BigInt + withdrawnTokens_lte: BigInt + withdrawnTokens_in: [BigInt!] + withdrawnTokens_not_in: [BigInt!] + nameSignal: BigInt + nameSignal_not: BigInt + nameSignal_gt: BigInt + nameSignal_lt: BigInt + nameSignal_gte: BigInt + nameSignal_lte: BigInt + nameSignal_in: [BigInt!] + nameSignal_not_in: [BigInt!] + signal: BigDecimal + signal_not: BigDecimal + signal_gt: BigDecimal + signal_lt: BigDecimal + signal_gte: BigDecimal + signal_lte: BigDecimal + signal_in: [BigDecimal!] + signal_not_in: [BigDecimal!] + signalledTokensSentToL2: BigInt + signalledTokensSentToL2_not: BigInt + signalledTokensSentToL2_gt: BigInt + signalledTokensSentToL2_lt: BigInt + signalledTokensSentToL2_gte: BigInt + signalledTokensSentToL2_lte: BigInt + signalledTokensSentToL2_in: [BigInt!] + signalledTokensSentToL2_not_in: [BigInt!] + signalledTokensReceivedOnL2: BigInt + signalledTokensReceivedOnL2_not: BigInt + signalledTokensReceivedOnL2_gt: BigInt + signalledTokensReceivedOnL2_lt: BigInt + signalledTokensReceivedOnL2_gte: BigInt + signalledTokensReceivedOnL2_lte: BigInt + signalledTokensReceivedOnL2_in: [BigInt!] + signalledTokensReceivedOnL2_not_in: [BigInt!] + transferredToL2: Boolean + transferredToL2_not: Boolean + transferredToL2_in: [Boolean!] + transferredToL2_not_in: [Boolean!] + transferredToL2At: BigInt + transferredToL2At_not: BigInt + transferredToL2At_gt: BigInt + transferredToL2At_lt: BigInt + transferredToL2At_gte: BigInt + transferredToL2At_lte: BigInt + transferredToL2At_in: [BigInt!] + transferredToL2At_not_in: [BigInt!] + transferredToL2AtBlockNumber: BigInt + transferredToL2AtBlockNumber_not: BigInt + transferredToL2AtBlockNumber_gt: BigInt + transferredToL2AtBlockNumber_lt: BigInt + transferredToL2AtBlockNumber_gte: BigInt + transferredToL2AtBlockNumber_lte: BigInt + transferredToL2AtBlockNumber_in: [BigInt!] + transferredToL2AtBlockNumber_not_in: [BigInt!] + transferredToL2AtTx: String + transferredToL2AtTx_not: String + transferredToL2AtTx_gt: String + transferredToL2AtTx_lt: String + transferredToL2AtTx_gte: String + transferredToL2AtTx_lte: String + transferredToL2AtTx_in: [String!] + transferredToL2AtTx_not_in: [String!] + transferredToL2AtTx_contains: String + transferredToL2AtTx_contains_nocase: String + transferredToL2AtTx_not_contains: String + transferredToL2AtTx_not_contains_nocase: String + transferredToL2AtTx_starts_with: String + transferredToL2AtTx_starts_with_nocase: String + transferredToL2AtTx_not_starts_with: String + transferredToL2AtTx_not_starts_with_nocase: String + transferredToL2AtTx_ends_with: String + transferredToL2AtTx_ends_with_nocase: String + transferredToL2AtTx_not_ends_with: String + transferredToL2AtTx_not_ends_with_nocase: String + idOnL2: String + idOnL2_not: String + idOnL2_gt: String + idOnL2_lt: String + idOnL2_gte: String + idOnL2_lte: String + idOnL2_in: [String!] + idOnL2_not_in: [String!] + idOnL2_contains: String + idOnL2_contains_nocase: String + idOnL2_not_contains: String + idOnL2_not_contains_nocase: String + idOnL2_starts_with: String + idOnL2_starts_with_nocase: String + idOnL2_not_starts_with: String + idOnL2_not_starts_with_nocase: String + idOnL2_ends_with: String + idOnL2_ends_with_nocase: String + idOnL2_not_ends_with: String + idOnL2_not_ends_with_nocase: String + idOnL1: String + idOnL1_not: String + idOnL1_gt: String + idOnL1_lt: String + idOnL1_gte: String + idOnL1_lte: String + idOnL1_in: [String!] + idOnL1_not_in: [String!] + idOnL1_contains: String + idOnL1_contains_nocase: String + idOnL1_not_contains: String + idOnL1_not_contains_nocase: String + idOnL1_starts_with: String + idOnL1_starts_with_nocase: String + idOnL1_not_starts_with: String + idOnL1_not_starts_with_nocase: String + idOnL1_ends_with: String + idOnL1_ends_with_nocase: String + idOnL1_not_ends_with: String + idOnL1_not_ends_with_nocase: String + lastNameSignalChange: Int + lastNameSignalChange_not: Int + lastNameSignalChange_gt: Int + lastNameSignalChange_lt: Int + lastNameSignalChange_gte: Int + lastNameSignalChange_lte: Int + lastNameSignalChange_in: [Int!] + lastNameSignalChange_not_in: [Int!] + realizedRewards: BigInt + realizedRewards_not: BigInt + realizedRewards_gt: BigInt + realizedRewards_lt: BigInt + realizedRewards_gte: BigInt + realizedRewards_lte: BigInt + realizedRewards_in: [BigInt!] + realizedRewards_not_in: [BigInt!] + averageCostBasis: BigDecimal + averageCostBasis_not: BigDecimal + averageCostBasis_gt: BigDecimal + averageCostBasis_lt: BigDecimal + averageCostBasis_gte: BigDecimal + averageCostBasis_lte: BigDecimal + averageCostBasis_in: [BigDecimal!] + averageCostBasis_not_in: [BigDecimal!] + averageCostBasisPerSignal: BigDecimal + averageCostBasisPerSignal_not: BigDecimal + averageCostBasisPerSignal_gt: BigDecimal + averageCostBasisPerSignal_lt: BigDecimal + averageCostBasisPerSignal_gte: BigDecimal + averageCostBasisPerSignal_lte: BigDecimal + averageCostBasisPerSignal_in: [BigDecimal!] + averageCostBasisPerSignal_not_in: [BigDecimal!] + nameSignalAverageCostBasis: BigDecimal + nameSignalAverageCostBasis_not: BigDecimal + nameSignalAverageCostBasis_gt: BigDecimal + nameSignalAverageCostBasis_lt: BigDecimal + nameSignalAverageCostBasis_gte: BigDecimal + nameSignalAverageCostBasis_lte: BigDecimal + nameSignalAverageCostBasis_in: [BigDecimal!] + nameSignalAverageCostBasis_not_in: [BigDecimal!] + nameSignalAverageCostBasisPerSignal: BigDecimal + nameSignalAverageCostBasisPerSignal_not: BigDecimal + nameSignalAverageCostBasisPerSignal_gt: BigDecimal + nameSignalAverageCostBasisPerSignal_lt: BigDecimal + nameSignalAverageCostBasisPerSignal_gte: BigDecimal + nameSignalAverageCostBasisPerSignal_lte: BigDecimal + nameSignalAverageCostBasisPerSignal_in: [BigDecimal!] + nameSignalAverageCostBasisPerSignal_not_in: [BigDecimal!] + signalAverageCostBasis: BigDecimal + signalAverageCostBasis_not: BigDecimal + signalAverageCostBasis_gt: BigDecimal + signalAverageCostBasis_lt: BigDecimal + signalAverageCostBasis_gte: BigDecimal + signalAverageCostBasis_lte: BigDecimal + signalAverageCostBasis_in: [BigDecimal!] + signalAverageCostBasis_not_in: [BigDecimal!] + signalAverageCostBasisPerSignal: BigDecimal + signalAverageCostBasisPerSignal_not: BigDecimal + signalAverageCostBasisPerSignal_gt: BigDecimal + signalAverageCostBasisPerSignal_lt: BigDecimal + signalAverageCostBasisPerSignal_gte: BigDecimal + signalAverageCostBasisPerSignal_lte: BigDecimal + signalAverageCostBasisPerSignal_in: [BigDecimal!] + signalAverageCostBasisPerSignal_not_in: [BigDecimal!] + entityVersion: Int + entityVersion_not: Int + entityVersion_gt: Int + entityVersion_lt: Int + entityVersion_gte: Int + entityVersion_lte: Int + entityVersion_in: [Int!] + entityVersion_not_in: [Int!] + linkedEntity: String + linkedEntity_not: String + linkedEntity_gt: String + linkedEntity_lt: String + linkedEntity_gte: String + linkedEntity_lte: String + linkedEntity_in: [String!] + linkedEntity_not_in: [String!] + linkedEntity_contains: String + linkedEntity_contains_nocase: String + linkedEntity_not_contains: String + linkedEntity_not_contains_nocase: String + linkedEntity_starts_with: String + linkedEntity_starts_with_nocase: String + linkedEntity_not_starts_with: String + linkedEntity_not_starts_with_nocase: String + linkedEntity_ends_with: String + linkedEntity_ends_with_nocase: String + linkedEntity_not_ends_with: String + linkedEntity_not_ends_with_nocase: String + linkedEntity_: NameSignal_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [NameSignal_filter] + or: [NameSignal_filter] +} + +enum NameSignal_orderBy { + id + curator + curator__id + curator__createdAt + curator__totalSignalledTokens + curator__totalUnsignalledTokens + curator__defaultDisplayName + curator__totalNameSignalledTokens + curator__totalNameUnsignalledTokens + curator__totalWithdrawnTokens + curator__realizedRewards + curator__annualizedReturn + curator__totalReturn + curator__signalingEfficiency + curator__totalNameSignal + curator__totalNameSignalAverageCostBasis + curator__totalAverageCostBasisPerNameSignal + curator__totalSignal + curator__totalSignalAverageCostBasis + curator__totalAverageCostBasisPerSignal + curator__signalCount + curator__activeSignalCount + curator__nameSignalCount + curator__activeNameSignalCount + curator__combinedSignalCount + curator__activeCombinedSignalCount + subgraph + subgraph__id + subgraph__versionCount + subgraph__createdAt + subgraph__updatedAt + subgraph__active + subgraph__migrated + subgraph__startedTransferToL2 + subgraph__startedTransferToL2At + subgraph__startedTransferToL2AtBlockNumber + subgraph__startedTransferToL2AtTx + subgraph__transferredToL2 + subgraph__transferredToL2At + subgraph__transferredToL2AtBlockNumber + subgraph__transferredToL2AtTx + subgraph__signalledTokensSentToL2 + subgraph__signalledTokensReceivedOnL2 + subgraph__idOnL2 + subgraph__idOnL1 + subgraph__nftID + subgraph__oldID + subgraph__creatorAddress + subgraph__subgraphNumber + subgraph__initializing + subgraph__entityVersion + subgraph__signalledTokens + subgraph__unsignalledTokens + subgraph__currentSignalledTokens + subgraph__nameSignalAmount + subgraph__signalAmount + subgraph__reserveRatio + subgraph__withdrawableTokens + subgraph__withdrawnTokens + subgraph__nameSignalCount + subgraph__metadataHash + signalledTokens + unsignalledTokens + withdrawnTokens + nameSignal + signal + signalledTokensSentToL2 + signalledTokensReceivedOnL2 + transferredToL2 + transferredToL2At + transferredToL2AtBlockNumber + transferredToL2AtTx + idOnL2 + idOnL1 + lastNameSignalChange + realizedRewards + averageCostBasis + averageCostBasisPerSignal + nameSignalAverageCostBasis + nameSignalAverageCostBasisPerSignal + signalAverageCostBasis + signalAverageCostBasisPerSignal + entityVersion + linkedEntity + linkedEntity__id + linkedEntity__signalledTokens + linkedEntity__unsignalledTokens + linkedEntity__withdrawnTokens + linkedEntity__nameSignal + linkedEntity__signal + linkedEntity__signalledTokensSentToL2 + linkedEntity__signalledTokensReceivedOnL2 + linkedEntity__transferredToL2 + linkedEntity__transferredToL2At + linkedEntity__transferredToL2AtBlockNumber + linkedEntity__transferredToL2AtTx + linkedEntity__idOnL2 + linkedEntity__idOnL1 + linkedEntity__lastNameSignalChange + linkedEntity__realizedRewards + linkedEntity__averageCostBasis + linkedEntity__averageCostBasisPerSignal + linkedEntity__nameSignalAverageCostBasis + linkedEntity__nameSignalAverageCostBasisPerSignal + linkedEntity__signalAverageCostBasis + linkedEntity__signalAverageCostBasisPerSignal + linkedEntity__entityVersion +} + +""" +Auxiliary entity to be able to batch update NameSignal entities + +""" +type NameSignalSubgraphRelation { + """Subgraph ID + index""" + id: ID! + nameSignal: NameSignal! + subgraph: Subgraph! +} + +input NameSignalSubgraphRelation_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + nameSignal: String + nameSignal_not: String + nameSignal_gt: String + nameSignal_lt: String + nameSignal_gte: String + nameSignal_lte: String + nameSignal_in: [String!] + nameSignal_not_in: [String!] + nameSignal_contains: String + nameSignal_contains_nocase: String + nameSignal_not_contains: String + nameSignal_not_contains_nocase: String + nameSignal_starts_with: String + nameSignal_starts_with_nocase: String + nameSignal_not_starts_with: String + nameSignal_not_starts_with_nocase: String + nameSignal_ends_with: String + nameSignal_ends_with_nocase: String + nameSignal_not_ends_with: String + nameSignal_not_ends_with_nocase: String + nameSignal_: NameSignal_filter + subgraph: String + subgraph_not: String + subgraph_gt: String + subgraph_lt: String + subgraph_gte: String + subgraph_lte: String + subgraph_in: [String!] + subgraph_not_in: [String!] + subgraph_contains: String + subgraph_contains_nocase: String + subgraph_not_contains: String + subgraph_not_contains_nocase: String + subgraph_starts_with: String + subgraph_starts_with_nocase: String + subgraph_not_starts_with: String + subgraph_not_starts_with_nocase: String + subgraph_ends_with: String + subgraph_ends_with_nocase: String + subgraph_not_ends_with: String + subgraph_not_ends_with_nocase: String + subgraph_: Subgraph_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [NameSignalSubgraphRelation_filter] + or: [NameSignalSubgraphRelation_filter] +} + +enum NameSignalSubgraphRelation_orderBy { + id + nameSignal + nameSignal__id + nameSignal__signalledTokens + nameSignal__unsignalledTokens + nameSignal__withdrawnTokens + nameSignal__nameSignal + nameSignal__signal + nameSignal__signalledTokensSentToL2 + nameSignal__signalledTokensReceivedOnL2 + nameSignal__transferredToL2 + nameSignal__transferredToL2At + nameSignal__transferredToL2AtBlockNumber + nameSignal__transferredToL2AtTx + nameSignal__idOnL2 + nameSignal__idOnL1 + nameSignal__lastNameSignalChange + nameSignal__realizedRewards + nameSignal__averageCostBasis + nameSignal__averageCostBasisPerSignal + nameSignal__nameSignalAverageCostBasis + nameSignal__nameSignalAverageCostBasisPerSignal + nameSignal__signalAverageCostBasis + nameSignal__signalAverageCostBasisPerSignal + nameSignal__entityVersion + subgraph + subgraph__id + subgraph__versionCount + subgraph__createdAt + subgraph__updatedAt + subgraph__active + subgraph__migrated + subgraph__startedTransferToL2 + subgraph__startedTransferToL2At + subgraph__startedTransferToL2AtBlockNumber + subgraph__startedTransferToL2AtTx + subgraph__transferredToL2 + subgraph__transferredToL2At + subgraph__transferredToL2AtBlockNumber + subgraph__transferredToL2AtTx + subgraph__signalledTokensSentToL2 + subgraph__signalledTokensReceivedOnL2 + subgraph__idOnL2 + subgraph__idOnL1 + subgraph__nftID + subgraph__oldID + subgraph__creatorAddress + subgraph__subgraphNumber + subgraph__initializing + subgraph__entityVersion + subgraph__signalledTokens + subgraph__unsignalledTokens + subgraph__currentSignalledTokens + subgraph__nameSignalAmount + subgraph__signalAmount + subgraph__reserveRatio + subgraph__withdrawableTokens + subgraph__withdrawnTokens + subgraph__nameSignalCount + subgraph__metadataHash +} + +""" +All relevant data for a Name Signal Transaction in The Graph Network + +""" +type NameSignalTransaction implements Transaction { + id: ID! + blockNumber: Int! + timestamp: Int! + signer: GraphAccount! + type: TransactionType! + + """Amount of name signal updated""" + nameSignal: BigInt! + + """Amount of version signal updated""" + versionSignal: BigInt! + + """Tokens used""" + tokens: BigInt! + + """Subgraph where name signal was updated""" + subgraph: Subgraph! +} + +input NameSignalTransaction_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + blockNumber: Int + blockNumber_not: Int + blockNumber_gt: Int + blockNumber_lt: Int + blockNumber_gte: Int + blockNumber_lte: Int + blockNumber_in: [Int!] + blockNumber_not_in: [Int!] + timestamp: Int + timestamp_not: Int + timestamp_gt: Int + timestamp_lt: Int + timestamp_gte: Int + timestamp_lte: Int + timestamp_in: [Int!] + timestamp_not_in: [Int!] + signer: String + signer_not: String + signer_gt: String + signer_lt: String + signer_gte: String + signer_lte: String + signer_in: [String!] + signer_not_in: [String!] + signer_contains: String + signer_contains_nocase: String + signer_not_contains: String + signer_not_contains_nocase: String + signer_starts_with: String + signer_starts_with_nocase: String + signer_not_starts_with: String + signer_not_starts_with_nocase: String + signer_ends_with: String + signer_ends_with_nocase: String + signer_not_ends_with: String + signer_not_ends_with_nocase: String + signer_: GraphAccount_filter + type: TransactionType + type_not: TransactionType + type_in: [TransactionType!] + type_not_in: [TransactionType!] + nameSignal: BigInt + nameSignal_not: BigInt + nameSignal_gt: BigInt + nameSignal_lt: BigInt + nameSignal_gte: BigInt + nameSignal_lte: BigInt + nameSignal_in: [BigInt!] + nameSignal_not_in: [BigInt!] + versionSignal: BigInt + versionSignal_not: BigInt + versionSignal_gt: BigInt + versionSignal_lt: BigInt + versionSignal_gte: BigInt + versionSignal_lte: BigInt + versionSignal_in: [BigInt!] + versionSignal_not_in: [BigInt!] + tokens: BigInt + tokens_not: BigInt + tokens_gt: BigInt + tokens_lt: BigInt + tokens_gte: BigInt + tokens_lte: BigInt + tokens_in: [BigInt!] + tokens_not_in: [BigInt!] + subgraph: String + subgraph_not: String + subgraph_gt: String + subgraph_lt: String + subgraph_gte: String + subgraph_lte: String + subgraph_in: [String!] + subgraph_not_in: [String!] + subgraph_contains: String + subgraph_contains_nocase: String + subgraph_not_contains: String + subgraph_not_contains_nocase: String + subgraph_starts_with: String + subgraph_starts_with_nocase: String + subgraph_not_starts_with: String + subgraph_not_starts_with_nocase: String + subgraph_ends_with: String + subgraph_ends_with_nocase: String + subgraph_not_ends_with: String + subgraph_not_ends_with_nocase: String + subgraph_: Subgraph_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [NameSignalTransaction_filter] + or: [NameSignalTransaction_filter] +} + +enum NameSignalTransaction_orderBy { + id + blockNumber + timestamp + signer + signer__id + signer__createdAt + signer__defaultDisplayName + signer__balance + signer__balanceReceivedFromL1Signalling + signer__balanceReceivedFromL1Delegation + signer__curationApproval + signer__stakingApproval + signer__gnsApproval + signer__developerCreatedAt + signer__subgraphQueryFees + type + nameSignal + versionSignal + tokens + subgraph + subgraph__id + subgraph__versionCount + subgraph__createdAt + subgraph__updatedAt + subgraph__active + subgraph__migrated + subgraph__startedTransferToL2 + subgraph__startedTransferToL2At + subgraph__startedTransferToL2AtBlockNumber + subgraph__startedTransferToL2AtTx + subgraph__transferredToL2 + subgraph__transferredToL2At + subgraph__transferredToL2AtBlockNumber + subgraph__transferredToL2AtTx + subgraph__signalledTokensSentToL2 + subgraph__signalledTokensReceivedOnL2 + subgraph__idOnL2 + subgraph__idOnL1 + subgraph__nftID + subgraph__oldID + subgraph__creatorAddress + subgraph__subgraphNumber + subgraph__initializing + subgraph__entityVersion + subgraph__signalledTokens + subgraph__unsignalledTokens + subgraph__currentSignalledTokens + subgraph__nameSignalAmount + subgraph__signalAmount + subgraph__reserveRatio + subgraph__withdrawableTokens + subgraph__withdrawnTokens + subgraph__nameSignalCount + subgraph__metadataHash +} + +enum NameSystem { + ENS +} + +"""Defines the order direction, either ascending or descending""" +enum OrderDirection { + asc + desc +} + +""" +[DEPRECATED] Global pool of query fees for closed state channels. Each Epoch has a single pool, +hence why they share the same IDs. + +""" +type Pool { + """Epoch number of the pool""" + id: ID! + + """ + Total effective allocation tokens from all allocations closed in this epoch + """ + allocation: BigInt! + + """Total query fees collected in this epoch""" + totalQueryFees: BigInt! + + """ + Total query fees claimed in this epoch. Can be smaller than totalFees because of rebates function + """ + claimedFees: BigInt! + + """ + Total rewards from query fees deposited to all curator bonding curves during the epoch + """ + curatorRewards: BigInt! + + """Allocations that were closed during this epoch""" + closedAllocations(skip: Int = 0, first: Int = 100, orderBy: Allocation_orderBy, orderDirection: OrderDirection, where: Allocation_filter): [Allocation!]! +} + +input Pool_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + allocation: BigInt + allocation_not: BigInt + allocation_gt: BigInt + allocation_lt: BigInt + allocation_gte: BigInt + allocation_lte: BigInt + allocation_in: [BigInt!] + allocation_not_in: [BigInt!] + totalQueryFees: BigInt + totalQueryFees_not: BigInt + totalQueryFees_gt: BigInt + totalQueryFees_lt: BigInt + totalQueryFees_gte: BigInt + totalQueryFees_lte: BigInt + totalQueryFees_in: [BigInt!] + totalQueryFees_not_in: [BigInt!] + claimedFees: BigInt + claimedFees_not: BigInt + claimedFees_gt: BigInt + claimedFees_lt: BigInt + claimedFees_gte: BigInt + claimedFees_lte: BigInt + claimedFees_in: [BigInt!] + claimedFees_not_in: [BigInt!] + curatorRewards: BigInt + curatorRewards_not: BigInt + curatorRewards_gt: BigInt + curatorRewards_lt: BigInt + curatorRewards_gte: BigInt + curatorRewards_lte: BigInt + curatorRewards_in: [BigInt!] + curatorRewards_not_in: [BigInt!] + closedAllocations_: Allocation_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Pool_filter] + or: [Pool_filter] +} + +enum Pool_orderBy { + id + allocation + totalQueryFees + claimedFees + curatorRewards + closedAllocations +} + +type Query { + graphNetwork( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): GraphNetwork + graphNetworks( + skip: Int = 0 + first: Int = 100 + orderBy: GraphNetwork_orderBy + orderDirection: OrderDirection + where: GraphNetwork_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [GraphNetwork!]! + graphAccount( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): GraphAccount + graphAccounts( + skip: Int = 0 + first: Int = 100 + orderBy: GraphAccount_orderBy + orderDirection: OrderDirection + where: GraphAccount_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [GraphAccount!]! + graphAccountMeta( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): GraphAccountMeta + graphAccountMetas( + skip: Int = 0 + first: Int = 100 + orderBy: GraphAccountMeta_orderBy + orderDirection: OrderDirection + where: GraphAccountMeta_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [GraphAccountMeta!]! + graphAccountName( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): GraphAccountName + graphAccountNames( + skip: Int = 0 + first: Int = 100 + orderBy: GraphAccountName_orderBy + orderDirection: OrderDirection + where: GraphAccountName_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [GraphAccountName!]! + subgraph( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Subgraph + subgraphs( + skip: Int = 0 + first: Int = 100 + orderBy: Subgraph_orderBy + orderDirection: OrderDirection + where: Subgraph_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Subgraph!]! + subgraphMeta( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphMeta + subgraphMetas( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphMeta_orderBy + orderDirection: OrderDirection + where: SubgraphMeta_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphMeta!]! + currentSubgraphDeploymentRelation( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): CurrentSubgraphDeploymentRelation + currentSubgraphDeploymentRelations( + skip: Int = 0 + first: Int = 100 + orderBy: CurrentSubgraphDeploymentRelation_orderBy + orderDirection: OrderDirection + where: CurrentSubgraphDeploymentRelation_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [CurrentSubgraphDeploymentRelation!]! + subgraphVersion( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphVersion + subgraphVersions( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphVersion_orderBy + orderDirection: OrderDirection + where: SubgraphVersion_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphVersion!]! + subgraphVersionMeta( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphVersionMeta + subgraphVersionMetas( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphVersionMeta_orderBy + orderDirection: OrderDirection + where: SubgraphVersionMeta_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphVersionMeta!]! + subgraphDeployment( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphDeployment + subgraphDeployments( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphDeployment_orderBy + orderDirection: OrderDirection + where: SubgraphDeployment_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphDeployment!]! + subgraphDeploymentSchema( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphDeploymentSchema + subgraphDeploymentSchemas( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphDeploymentSchema_orderBy + orderDirection: OrderDirection + where: SubgraphDeploymentSchema_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphDeploymentSchema!]! + subgraphDeploymentManifest( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphDeploymentManifest + subgraphDeploymentManifests( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphDeploymentManifest_orderBy + orderDirection: OrderDirection + where: SubgraphDeploymentManifest_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphDeploymentManifest!]! + indexer( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Indexer + indexers( + skip: Int = 0 + first: Int = 100 + orderBy: Indexer_orderBy + orderDirection: OrderDirection + where: Indexer_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Indexer!]! + allocation( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Allocation + allocations( + skip: Int = 0 + first: Int = 100 + orderBy: Allocation_orderBy + orderDirection: OrderDirection + where: Allocation_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Allocation!]! + pool( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Pool + pools( + skip: Int = 0 + first: Int = 100 + orderBy: Pool_orderBy + orderDirection: OrderDirection + where: Pool_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Pool!]! + delegator( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Delegator + delegators( + skip: Int = 0 + first: Int = 100 + orderBy: Delegator_orderBy + orderDirection: OrderDirection + where: Delegator_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Delegator!]! + delegatedStake( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): DelegatedStake + delegatedStakes( + skip: Int = 0 + first: Int = 100 + orderBy: DelegatedStake_orderBy + orderDirection: OrderDirection + where: DelegatedStake_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [DelegatedStake!]! + curator( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Curator + curators( + skip: Int = 0 + first: Int = 100 + orderBy: Curator_orderBy + orderDirection: OrderDirection + where: Curator_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Curator!]! + signal( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Signal + signals( + skip: Int = 0 + first: Int = 100 + orderBy: Signal_orderBy + orderDirection: OrderDirection + where: Signal_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Signal!]! + nameSignal( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): NameSignal + nameSignals( + skip: Int = 0 + first: Int = 100 + orderBy: NameSignal_orderBy + orderDirection: OrderDirection + where: NameSignal_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [NameSignal!]! + nameSignalSubgraphRelation( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): NameSignalSubgraphRelation + nameSignalSubgraphRelations( + skip: Int = 0 + first: Int = 100 + orderBy: NameSignalSubgraphRelation_orderBy + orderDirection: OrderDirection + where: NameSignalSubgraphRelation_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [NameSignalSubgraphRelation!]! + dispute( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Dispute + disputes( + skip: Int = 0 + first: Int = 100 + orderBy: Dispute_orderBy + orderDirection: OrderDirection + where: Dispute_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Dispute!]! + attestation( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Attestation + attestations( + skip: Int = 0 + first: Int = 100 + orderBy: Attestation_orderBy + orderDirection: OrderDirection + where: Attestation_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Attestation!]! + epoch( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Epoch + epoches( + skip: Int = 0 + first: Int = 100 + orderBy: Epoch_orderBy + orderDirection: OrderDirection + where: Epoch_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Epoch!]! + nameSignalTransaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): NameSignalTransaction + nameSignalTransactions( + skip: Int = 0 + first: Int = 100 + orderBy: NameSignalTransaction_orderBy + orderDirection: OrderDirection + where: NameSignalTransaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [NameSignalTransaction!]! + signalTransaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SignalTransaction + signalTransactions( + skip: Int = 0 + first: Int = 100 + orderBy: SignalTransaction_orderBy + orderDirection: OrderDirection + where: SignalTransaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SignalTransaction!]! + bridgeWithdrawalTransaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): BridgeWithdrawalTransaction + bridgeWithdrawalTransactions( + skip: Int = 0 + first: Int = 100 + orderBy: BridgeWithdrawalTransaction_orderBy + orderDirection: OrderDirection + where: BridgeWithdrawalTransaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [BridgeWithdrawalTransaction!]! + bridgeDepositTransaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): BridgeDepositTransaction + bridgeDepositTransactions( + skip: Int = 0 + first: Int = 100 + orderBy: BridgeDepositTransaction_orderBy + orderDirection: OrderDirection + where: BridgeDepositTransaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [BridgeDepositTransaction!]! + retryableTicket( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): RetryableTicket + retryableTickets( + skip: Int = 0 + first: Int = 100 + orderBy: RetryableTicket_orderBy + orderDirection: OrderDirection + where: RetryableTicket_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [RetryableTicket!]! + retryableTicketRedeemAttempt( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): RetryableTicketRedeemAttempt + retryableTicketRedeemAttempts( + skip: Int = 0 + first: Int = 100 + orderBy: RetryableTicketRedeemAttempt_orderBy + orderDirection: OrderDirection + where: RetryableTicketRedeemAttempt_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [RetryableTicketRedeemAttempt!]! + tokenManager( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): TokenManager + tokenManagers( + skip: Int = 0 + first: Int = 100 + orderBy: TokenManager_orderBy + orderDirection: OrderDirection + where: TokenManager_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [TokenManager!]! + authorizedFunction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): AuthorizedFunction + authorizedFunctions( + skip: Int = 0 + first: Int = 100 + orderBy: AuthorizedFunction_orderBy + orderDirection: OrderDirection + where: AuthorizedFunction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [AuthorizedFunction!]! + tokenLockWallet( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): TokenLockWallet + tokenLockWallets( + skip: Int = 0 + first: Int = 100 + orderBy: TokenLockWallet_orderBy + orderDirection: OrderDirection + where: TokenLockWallet_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [TokenLockWallet!]! + transaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Transaction + transactions( + skip: Int = 0 + first: Int = 100 + orderBy: Transaction_orderBy + orderDirection: OrderDirection + where: Transaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Transaction!]! + subgraphMetadataSearch( + text: String! + first: Int = 100 + skip: Int = 0 + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + where: SubgraphMeta_filter + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphMeta!]! + curatorSearch( + text: String! + first: Int = 100 + skip: Int = 0 + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + where: Curator_filter + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Curator!]! + delegatorSearch( + text: String! + first: Int = 100 + skip: Int = 0 + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + where: Delegator_filter + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Delegator!]! + + """Access to subgraph metadata""" + _meta(block: Block_height): _Meta_ +} + +""" +All relevant data for arbitrum retryable tickets + +""" +type RetryableTicket { + id: ID! + + """hash of the retryable ticket creation transaction""" + txHash: Bytes + redeemAttempts(skip: Int = 0, first: Int = 100, orderBy: RetryableTicketRedeemAttempt_orderBy, orderDirection: OrderDirection, where: RetryableTicketRedeemAttempt_filter): [RetryableTicketRedeemAttempt!]! + + """The amount of times the ticket has been scheduled for redeeming""" + redeemCount: Int +} + +input RetryableTicket_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + txHash: Bytes + txHash_not: Bytes + txHash_gt: Bytes + txHash_lt: Bytes + txHash_gte: Bytes + txHash_lte: Bytes + txHash_in: [Bytes!] + txHash_not_in: [Bytes!] + txHash_contains: Bytes + txHash_not_contains: Bytes + redeemAttempts_: RetryableTicketRedeemAttempt_filter + redeemCount: Int + redeemCount_not: Int + redeemCount_gt: Int + redeemCount_lt: Int + redeemCount_gte: Int + redeemCount_lte: Int + redeemCount_in: [Int!] + redeemCount_not_in: [Int!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [RetryableTicket_filter] + or: [RetryableTicket_filter] +} + +enum RetryableTicket_orderBy { + id + txHash + redeemAttempts + redeemCount +} + +type RetryableTicketRedeemAttempt { + id: ID! + ticketId: RetryableTicket! + txHash: Bytes + sequenceNumber: Int +} + +input RetryableTicketRedeemAttempt_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + ticketId: String + ticketId_not: String + ticketId_gt: String + ticketId_lt: String + ticketId_gte: String + ticketId_lte: String + ticketId_in: [String!] + ticketId_not_in: [String!] + ticketId_contains: String + ticketId_contains_nocase: String + ticketId_not_contains: String + ticketId_not_contains_nocase: String + ticketId_starts_with: String + ticketId_starts_with_nocase: String + ticketId_not_starts_with: String + ticketId_not_starts_with_nocase: String + ticketId_ends_with: String + ticketId_ends_with_nocase: String + ticketId_not_ends_with: String + ticketId_not_ends_with_nocase: String + ticketId_: RetryableTicket_filter + txHash: Bytes + txHash_not: Bytes + txHash_gt: Bytes + txHash_lt: Bytes + txHash_gte: Bytes + txHash_lte: Bytes + txHash_in: [Bytes!] + txHash_not_in: [Bytes!] + txHash_contains: Bytes + txHash_not_contains: Bytes + sequenceNumber: Int + sequenceNumber_not: Int + sequenceNumber_gt: Int + sequenceNumber_lt: Int + sequenceNumber_gte: Int + sequenceNumber_lte: Int + sequenceNumber_in: [Int!] + sequenceNumber_not_in: [Int!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [RetryableTicketRedeemAttempt_filter] + or: [RetryableTicketRedeemAttempt_filter] +} + +enum RetryableTicketRedeemAttempt_orderBy { + id + ticketId + ticketId__id + ticketId__txHash + ticketId__redeemCount + txHash + sequenceNumber +} + +""" +TokenLockWallet Revocability Enum + +""" +enum Revocability { + NotSet + Enabled + Disabled +} + +""" +Curator Signal for a single SubgraphDeployment + +""" +type Signal { + """Eth address + subgraph deployment ID""" + id: ID! + + """Eth address of the curator""" + curator: Curator! + + """Subgraph being signalled""" + subgraphDeployment: SubgraphDeployment! + + """CUMULATIVE number of tokens the curator has signalled""" + signalledTokens: BigInt! + + """CUMULATIVE number of tokens the curator has unsignalled""" + unsignalledTokens: BigInt! + + """Signal that the curator has from signaling their GRT""" + signal: BigInt! + + """Curator average cost basis for this signal on this subgraph""" + averageCostBasis: BigDecimal! + + """averageCostBasis / signal""" + averageCostBasisPerSignal: BigDecimal! + + """Block for which the curator last entered or exited the curve""" + lastSignalChange: Int! + + """ + Summation of realized rewards from before the last time the curator entered the curation curve + """ + realizedRewards: BigInt! + + """Timetamp when this entity was created""" + createdAt: Int! + + """Timetamp when this entity was last updated""" + lastUpdatedAt: Int! + + """Block number where this entity was created""" + createdAtBlock: Int! + + """Block number where this entity was last updated""" + lastUpdatedAtBlock: Int! +} + +input Signal_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + curator: String + curator_not: String + curator_gt: String + curator_lt: String + curator_gte: String + curator_lte: String + curator_in: [String!] + curator_not_in: [String!] + curator_contains: String + curator_contains_nocase: String + curator_not_contains: String + curator_not_contains_nocase: String + curator_starts_with: String + curator_starts_with_nocase: String + curator_not_starts_with: String + curator_not_starts_with_nocase: String + curator_ends_with: String + curator_ends_with_nocase: String + curator_not_ends_with: String + curator_not_ends_with_nocase: String + curator_: Curator_filter + subgraphDeployment: String + subgraphDeployment_not: String + subgraphDeployment_gt: String + subgraphDeployment_lt: String + subgraphDeployment_gte: String + subgraphDeployment_lte: String + subgraphDeployment_in: [String!] + subgraphDeployment_not_in: [String!] + subgraphDeployment_contains: String + subgraphDeployment_contains_nocase: String + subgraphDeployment_not_contains: String + subgraphDeployment_not_contains_nocase: String + subgraphDeployment_starts_with: String + subgraphDeployment_starts_with_nocase: String + subgraphDeployment_not_starts_with: String + subgraphDeployment_not_starts_with_nocase: String + subgraphDeployment_ends_with: String + subgraphDeployment_ends_with_nocase: String + subgraphDeployment_not_ends_with: String + subgraphDeployment_not_ends_with_nocase: String + subgraphDeployment_: SubgraphDeployment_filter + signalledTokens: BigInt + signalledTokens_not: BigInt + signalledTokens_gt: BigInt + signalledTokens_lt: BigInt + signalledTokens_gte: BigInt + signalledTokens_lte: BigInt + signalledTokens_in: [BigInt!] + signalledTokens_not_in: [BigInt!] + unsignalledTokens: BigInt + unsignalledTokens_not: BigInt + unsignalledTokens_gt: BigInt + unsignalledTokens_lt: BigInt + unsignalledTokens_gte: BigInt + unsignalledTokens_lte: BigInt + unsignalledTokens_in: [BigInt!] + unsignalledTokens_not_in: [BigInt!] + signal: BigInt + signal_not: BigInt + signal_gt: BigInt + signal_lt: BigInt + signal_gte: BigInt + signal_lte: BigInt + signal_in: [BigInt!] + signal_not_in: [BigInt!] + averageCostBasis: BigDecimal + averageCostBasis_not: BigDecimal + averageCostBasis_gt: BigDecimal + averageCostBasis_lt: BigDecimal + averageCostBasis_gte: BigDecimal + averageCostBasis_lte: BigDecimal + averageCostBasis_in: [BigDecimal!] + averageCostBasis_not_in: [BigDecimal!] + averageCostBasisPerSignal: BigDecimal + averageCostBasisPerSignal_not: BigDecimal + averageCostBasisPerSignal_gt: BigDecimal + averageCostBasisPerSignal_lt: BigDecimal + averageCostBasisPerSignal_gte: BigDecimal + averageCostBasisPerSignal_lte: BigDecimal + averageCostBasisPerSignal_in: [BigDecimal!] + averageCostBasisPerSignal_not_in: [BigDecimal!] + lastSignalChange: Int + lastSignalChange_not: Int + lastSignalChange_gt: Int + lastSignalChange_lt: Int + lastSignalChange_gte: Int + lastSignalChange_lte: Int + lastSignalChange_in: [Int!] + lastSignalChange_not_in: [Int!] + realizedRewards: BigInt + realizedRewards_not: BigInt + realizedRewards_gt: BigInt + realizedRewards_lt: BigInt + realizedRewards_gte: BigInt + realizedRewards_lte: BigInt + realizedRewards_in: [BigInt!] + realizedRewards_not_in: [BigInt!] + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + lastUpdatedAt: Int + lastUpdatedAt_not: Int + lastUpdatedAt_gt: Int + lastUpdatedAt_lt: Int + lastUpdatedAt_gte: Int + lastUpdatedAt_lte: Int + lastUpdatedAt_in: [Int!] + lastUpdatedAt_not_in: [Int!] + createdAtBlock: Int + createdAtBlock_not: Int + createdAtBlock_gt: Int + createdAtBlock_lt: Int + createdAtBlock_gte: Int + createdAtBlock_lte: Int + createdAtBlock_in: [Int!] + createdAtBlock_not_in: [Int!] + lastUpdatedAtBlock: Int + lastUpdatedAtBlock_not: Int + lastUpdatedAtBlock_gt: Int + lastUpdatedAtBlock_lt: Int + lastUpdatedAtBlock_gte: Int + lastUpdatedAtBlock_lte: Int + lastUpdatedAtBlock_in: [Int!] + lastUpdatedAtBlock_not_in: [Int!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Signal_filter] + or: [Signal_filter] +} + +enum Signal_orderBy { + id + curator + curator__id + curator__createdAt + curator__totalSignalledTokens + curator__totalUnsignalledTokens + curator__defaultDisplayName + curator__totalNameSignalledTokens + curator__totalNameUnsignalledTokens + curator__totalWithdrawnTokens + curator__realizedRewards + curator__annualizedReturn + curator__totalReturn + curator__signalingEfficiency + curator__totalNameSignal + curator__totalNameSignalAverageCostBasis + curator__totalAverageCostBasisPerNameSignal + curator__totalSignal + curator__totalSignalAverageCostBasis + curator__totalAverageCostBasisPerSignal + curator__signalCount + curator__activeSignalCount + curator__nameSignalCount + curator__activeNameSignalCount + curator__combinedSignalCount + curator__activeCombinedSignalCount + subgraphDeployment + subgraphDeployment__id + subgraphDeployment__ipfsHash + subgraphDeployment__createdAt + subgraphDeployment__deniedAt + subgraphDeployment__originalName + subgraphDeployment__stakedTokens + subgraphDeployment__indexingRewardAmount + subgraphDeployment__indexingIndexerRewardAmount + subgraphDeployment__indexingDelegatorRewardAmount + subgraphDeployment__queryFeesAmount + subgraphDeployment__queryFeeRebates + subgraphDeployment__curatorFeeRewards + subgraphDeployment__signalledTokens + subgraphDeployment__unsignalledTokens + subgraphDeployment__signalAmount + subgraphDeployment__pricePerShare + subgraphDeployment__reserveRatio + subgraphDeployment__subgraphCount + subgraphDeployment__activeSubgraphCount + subgraphDeployment__deprecatedSubgraphCount + subgraphDeployment__transferredToL2 + subgraphDeployment__transferredToL2At + subgraphDeployment__transferredToL2AtBlockNumber + subgraphDeployment__transferredToL2AtTx + subgraphDeployment__signalledTokensSentToL2 + subgraphDeployment__signalledTokensReceivedOnL2 + signalledTokens + unsignalledTokens + signal + averageCostBasis + averageCostBasisPerSignal + lastSignalChange + realizedRewards + createdAt + lastUpdatedAt + createdAtBlock + lastUpdatedAtBlock +} + +""" +All relevant data for a Signal Transaction in The Graph Network + +""" +type SignalTransaction implements Transaction { + id: ID! + blockNumber: Int! + timestamp: Int! + signer: GraphAccount! + type: TransactionType! + + """Amount of signal updated""" + signal: BigInt! + + """Tokens used""" + tokens: BigInt! + + """Subgraph where signal was updated""" + subgraphDeployment: SubgraphDeployment! + + """Withdrawal fees. On minting only""" + withdrawalFees: BigInt! +} + +input SignalTransaction_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + blockNumber: Int + blockNumber_not: Int + blockNumber_gt: Int + blockNumber_lt: Int + blockNumber_gte: Int + blockNumber_lte: Int + blockNumber_in: [Int!] + blockNumber_not_in: [Int!] + timestamp: Int + timestamp_not: Int + timestamp_gt: Int + timestamp_lt: Int + timestamp_gte: Int + timestamp_lte: Int + timestamp_in: [Int!] + timestamp_not_in: [Int!] + signer: String + signer_not: String + signer_gt: String + signer_lt: String + signer_gte: String + signer_lte: String + signer_in: [String!] + signer_not_in: [String!] + signer_contains: String + signer_contains_nocase: String + signer_not_contains: String + signer_not_contains_nocase: String + signer_starts_with: String + signer_starts_with_nocase: String + signer_not_starts_with: String + signer_not_starts_with_nocase: String + signer_ends_with: String + signer_ends_with_nocase: String + signer_not_ends_with: String + signer_not_ends_with_nocase: String + signer_: GraphAccount_filter + type: TransactionType + type_not: TransactionType + type_in: [TransactionType!] + type_not_in: [TransactionType!] + signal: BigInt + signal_not: BigInt + signal_gt: BigInt + signal_lt: BigInt + signal_gte: BigInt + signal_lte: BigInt + signal_in: [BigInt!] + signal_not_in: [BigInt!] + tokens: BigInt + tokens_not: BigInt + tokens_gt: BigInt + tokens_lt: BigInt + tokens_gte: BigInt + tokens_lte: BigInt + tokens_in: [BigInt!] + tokens_not_in: [BigInt!] + subgraphDeployment: String + subgraphDeployment_not: String + subgraphDeployment_gt: String + subgraphDeployment_lt: String + subgraphDeployment_gte: String + subgraphDeployment_lte: String + subgraphDeployment_in: [String!] + subgraphDeployment_not_in: [String!] + subgraphDeployment_contains: String + subgraphDeployment_contains_nocase: String + subgraphDeployment_not_contains: String + subgraphDeployment_not_contains_nocase: String + subgraphDeployment_starts_with: String + subgraphDeployment_starts_with_nocase: String + subgraphDeployment_not_starts_with: String + subgraphDeployment_not_starts_with_nocase: String + subgraphDeployment_ends_with: String + subgraphDeployment_ends_with_nocase: String + subgraphDeployment_not_ends_with: String + subgraphDeployment_not_ends_with_nocase: String + subgraphDeployment_: SubgraphDeployment_filter + withdrawalFees: BigInt + withdrawalFees_not: BigInt + withdrawalFees_gt: BigInt + withdrawalFees_lt: BigInt + withdrawalFees_gte: BigInt + withdrawalFees_lte: BigInt + withdrawalFees_in: [BigInt!] + withdrawalFees_not_in: [BigInt!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [SignalTransaction_filter] + or: [SignalTransaction_filter] +} + +enum SignalTransaction_orderBy { + id + blockNumber + timestamp + signer + signer__id + signer__createdAt + signer__defaultDisplayName + signer__balance + signer__balanceReceivedFromL1Signalling + signer__balanceReceivedFromL1Delegation + signer__curationApproval + signer__stakingApproval + signer__gnsApproval + signer__developerCreatedAt + signer__subgraphQueryFees + type + signal + tokens + subgraphDeployment + subgraphDeployment__id + subgraphDeployment__ipfsHash + subgraphDeployment__createdAt + subgraphDeployment__deniedAt + subgraphDeployment__originalName + subgraphDeployment__stakedTokens + subgraphDeployment__indexingRewardAmount + subgraphDeployment__indexingIndexerRewardAmount + subgraphDeployment__indexingDelegatorRewardAmount + subgraphDeployment__queryFeesAmount + subgraphDeployment__queryFeeRebates + subgraphDeployment__curatorFeeRewards + subgraphDeployment__signalledTokens + subgraphDeployment__unsignalledTokens + subgraphDeployment__signalAmount + subgraphDeployment__pricePerShare + subgraphDeployment__reserveRatio + subgraphDeployment__subgraphCount + subgraphDeployment__activeSubgraphCount + subgraphDeployment__deprecatedSubgraphCount + subgraphDeployment__transferredToL2 + subgraphDeployment__transferredToL2At + subgraphDeployment__transferredToL2AtBlockNumber + subgraphDeployment__transferredToL2AtTx + subgraphDeployment__signalledTokensSentToL2 + subgraphDeployment__signalledTokensReceivedOnL2 + withdrawalFees +} + +""" +The Subgraph entity represents a permanent, unique endpoint. This unique endpoint can resolve to +many different SubgraphVersions over it's lifetime. The Subgraph can also have a name attributed +to it. The owner of the Subgraph can only use a name once, thus making the owner account and the +name chosen a unique combination. When a Curator singals on a Subgraph, they receive "Name Signal". +"Name Signal" resolves into the underlying "Signal" of the SubgraphDeployment. The metadata of the +subgraph is stored on IPFS. + +""" +type Subgraph { + """ + Subgraph ID - which is derived from the Organization/Individual graph accountID + """ + id: ID! + + """Graph account that owns this subgraph""" + owner: GraphAccount! + + """Current version. Null if the subgraph is deprecated""" + currentVersion: SubgraphVersion + + """ + [DEPRECATED] Past versions. Has the same data as 'versions' but keeps the old naming for backwards compatibility + """ + pastVersions(skip: Int = 0, first: Int = 100, orderBy: SubgraphVersion_orderBy, orderDirection: OrderDirection, where: SubgraphVersion_filter): [SubgraphVersion!]! + + """List of all the subgraph versions included the current one""" + versions(skip: Int = 0, first: Int = 100, orderBy: SubgraphVersion_orderBy, orderDirection: OrderDirection, where: SubgraphVersion_filter): [SubgraphVersion!]! + + """Version counter""" + versionCount: BigInt! + + """Creation timestamp""" + createdAt: Int! + + """Updated timestamp""" + updatedAt: Int! + + """Whether the subgraph is active or deprecated""" + active: Boolean! + + """ + Whether the subgraph has been claimed/migrated. Can only be false for + subgraphs created with V1 contracts that have not been claimed/migrated + """ + migrated: Boolean! + + """ + Whether the subgraph has been transferred from L1 to L2. Subgraphs published + on L2 will have this as false unless they were published through a transfer + """ + startedTransferToL2: Boolean! + + """ + Timestamp for the L1 -> L2 Transfer. Null if the transfer hasn't started yet + """ + startedTransferToL2At: BigInt + + """ + Block number for the L1 -> L2 Transfer. Null if the transfer hasn't started yet + """ + startedTransferToL2AtBlockNumber: BigInt + + """ + Transaction hash for the L1 -> L2 Transfer. Null if the transfer hasn't started yet + """ + startedTransferToL2AtTx: String + + """ + Whether the subgraph has been fully transferred from L1 to L2. Subgraphs + published on L2 will have this as false unless they were published through a transfer + """ + transferredToL2: Boolean! + + """ + Timestamp for the L1 -> L2 Transfer. Null if it's not fully transferred or if it's an L1 deployment + """ + transferredToL2At: BigInt + + """ + Block number for the L1 -> L2 Transfer. Null if it's not fully transferred or if it's an L1 deployment + """ + transferredToL2AtBlockNumber: BigInt + + """ + Transaction hash for the L1 -> L2 Transfer. Null if it's not fully transferred or if it's an L1 deployment + """ + transferredToL2AtTx: String + + """Amount of GRT transferred to L2""" + signalledTokensSentToL2: BigInt! + + """Amount of GRT received on L2""" + signalledTokensReceivedOnL2: BigInt! + + """ID of the subgraph on L2. Null if it's not transferred""" + idOnL2: String + + """ID of the subgraph on L1. Null if it's not transferred""" + idOnL1: String + + """ + The actual ID of the subgraph on the contracts subgraph NFT implementation. + BigInt represented as a String. It's only actually valid once the subgraph is + migrated (migrated == true) + """ + nftID: String + + """ + ID of the subgraph that was used on the old version of this The Graph Network + Subgraph. Null for Subgraphs created with the new GNS implementation or for + version 1 entities (since they use the old id) + """ + oldID: String + + """ + Address used to create the ID. Only available for Subgraphs created pre-migration + """ + creatorAddress: Bytes + + """ + Subgraph number used to create the ID. Only available for Subgraphs created pre-migration + """ + subgraphNumber: BigInt + + """ + Auxiliary field to denote whether the subgraph is handling the initialization + order on V2 events. Doesn't matter for V1 events. + """ + initializing: Boolean! + + """ + Version of the entity. Subgraph entities are changing the way their ID is + generated when the new GNS v2 rolls out so we need to differnetiate them + """ + entityVersion: Int! + + """ + [DEPRECATED] Used for duplicate entities to enable old IDs from before the subgraph NFT update + """ + linkedEntity: Subgraph + + """CUMULATIVE signaled tokens on this subgraph all time""" + signalledTokens: BigInt! + + """CUMULATIVE unsignalled tokens on this subgraph all time""" + unsignalledTokens: BigInt! + + """ + CURRENT amount of tokens signalled on this subgraph latest version. Mirrors + the total amount signalled towards the current deployment. + """ + currentSignalledTokens: BigInt! + + """The CURRENT name signal amount for this subgraph""" + nameSignalAmount: BigInt! + + """Current amount of version signal managed by the name pool""" + signalAmount: BigInt! + + """Reserve ratio of the name curation curve. In parts per million""" + reserveRatio: Int! + + """Tokens that can be withdrawn once the Subgraph is deprecated""" + withdrawableTokens: BigInt! + + """Tokens the curators have withdrawn from the deprecated Subgraph""" + withdrawnTokens: BigInt! + + """Curators of this subgraph deployment""" + nameSignals(skip: Int = 0, first: Int = 100, orderBy: NameSignal_orderBy, orderDirection: OrderDirection, where: NameSignal_filter): [NameSignal!]! + + """Total amount of NameSignal entities""" + nameSignalCount: Int! + + """Subgraph metadata""" + metadataHash: Bytes + + """Subgraph metadata ipfs hash and entity""" + metadata: SubgraphMeta + currentVersionRelationEntity: CurrentSubgraphDeploymentRelation +} + +input Subgraph_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + owner: String + owner_not: String + owner_gt: String + owner_lt: String + owner_gte: String + owner_lte: String + owner_in: [String!] + owner_not_in: [String!] + owner_contains: String + owner_contains_nocase: String + owner_not_contains: String + owner_not_contains_nocase: String + owner_starts_with: String + owner_starts_with_nocase: String + owner_not_starts_with: String + owner_not_starts_with_nocase: String + owner_ends_with: String + owner_ends_with_nocase: String + owner_not_ends_with: String + owner_not_ends_with_nocase: String + owner_: GraphAccount_filter + currentVersion: String + currentVersion_not: String + currentVersion_gt: String + currentVersion_lt: String + currentVersion_gte: String + currentVersion_lte: String + currentVersion_in: [String!] + currentVersion_not_in: [String!] + currentVersion_contains: String + currentVersion_contains_nocase: String + currentVersion_not_contains: String + currentVersion_not_contains_nocase: String + currentVersion_starts_with: String + currentVersion_starts_with_nocase: String + currentVersion_not_starts_with: String + currentVersion_not_starts_with_nocase: String + currentVersion_ends_with: String + currentVersion_ends_with_nocase: String + currentVersion_not_ends_with: String + currentVersion_not_ends_with_nocase: String + currentVersion_: SubgraphVersion_filter + pastVersions_: SubgraphVersion_filter + versions_: SubgraphVersion_filter + versionCount: BigInt + versionCount_not: BigInt + versionCount_gt: BigInt + versionCount_lt: BigInt + versionCount_gte: BigInt + versionCount_lte: BigInt + versionCount_in: [BigInt!] + versionCount_not_in: [BigInt!] + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + updatedAt: Int + updatedAt_not: Int + updatedAt_gt: Int + updatedAt_lt: Int + updatedAt_gte: Int + updatedAt_lte: Int + updatedAt_in: [Int!] + updatedAt_not_in: [Int!] + active: Boolean + active_not: Boolean + active_in: [Boolean!] + active_not_in: [Boolean!] + migrated: Boolean + migrated_not: Boolean + migrated_in: [Boolean!] + migrated_not_in: [Boolean!] + startedTransferToL2: Boolean + startedTransferToL2_not: Boolean + startedTransferToL2_in: [Boolean!] + startedTransferToL2_not_in: [Boolean!] + startedTransferToL2At: BigInt + startedTransferToL2At_not: BigInt + startedTransferToL2At_gt: BigInt + startedTransferToL2At_lt: BigInt + startedTransferToL2At_gte: BigInt + startedTransferToL2At_lte: BigInt + startedTransferToL2At_in: [BigInt!] + startedTransferToL2At_not_in: [BigInt!] + startedTransferToL2AtBlockNumber: BigInt + startedTransferToL2AtBlockNumber_not: BigInt + startedTransferToL2AtBlockNumber_gt: BigInt + startedTransferToL2AtBlockNumber_lt: BigInt + startedTransferToL2AtBlockNumber_gte: BigInt + startedTransferToL2AtBlockNumber_lte: BigInt + startedTransferToL2AtBlockNumber_in: [BigInt!] + startedTransferToL2AtBlockNumber_not_in: [BigInt!] + startedTransferToL2AtTx: String + startedTransferToL2AtTx_not: String + startedTransferToL2AtTx_gt: String + startedTransferToL2AtTx_lt: String + startedTransferToL2AtTx_gte: String + startedTransferToL2AtTx_lte: String + startedTransferToL2AtTx_in: [String!] + startedTransferToL2AtTx_not_in: [String!] + startedTransferToL2AtTx_contains: String + startedTransferToL2AtTx_contains_nocase: String + startedTransferToL2AtTx_not_contains: String + startedTransferToL2AtTx_not_contains_nocase: String + startedTransferToL2AtTx_starts_with: String + startedTransferToL2AtTx_starts_with_nocase: String + startedTransferToL2AtTx_not_starts_with: String + startedTransferToL2AtTx_not_starts_with_nocase: String + startedTransferToL2AtTx_ends_with: String + startedTransferToL2AtTx_ends_with_nocase: String + startedTransferToL2AtTx_not_ends_with: String + startedTransferToL2AtTx_not_ends_with_nocase: String + transferredToL2: Boolean + transferredToL2_not: Boolean + transferredToL2_in: [Boolean!] + transferredToL2_not_in: [Boolean!] + transferredToL2At: BigInt + transferredToL2At_not: BigInt + transferredToL2At_gt: BigInt + transferredToL2At_lt: BigInt + transferredToL2At_gte: BigInt + transferredToL2At_lte: BigInt + transferredToL2At_in: [BigInt!] + transferredToL2At_not_in: [BigInt!] + transferredToL2AtBlockNumber: BigInt + transferredToL2AtBlockNumber_not: BigInt + transferredToL2AtBlockNumber_gt: BigInt + transferredToL2AtBlockNumber_lt: BigInt + transferredToL2AtBlockNumber_gte: BigInt + transferredToL2AtBlockNumber_lte: BigInt + transferredToL2AtBlockNumber_in: [BigInt!] + transferredToL2AtBlockNumber_not_in: [BigInt!] + transferredToL2AtTx: String + transferredToL2AtTx_not: String + transferredToL2AtTx_gt: String + transferredToL2AtTx_lt: String + transferredToL2AtTx_gte: String + transferredToL2AtTx_lte: String + transferredToL2AtTx_in: [String!] + transferredToL2AtTx_not_in: [String!] + transferredToL2AtTx_contains: String + transferredToL2AtTx_contains_nocase: String + transferredToL2AtTx_not_contains: String + transferredToL2AtTx_not_contains_nocase: String + transferredToL2AtTx_starts_with: String + transferredToL2AtTx_starts_with_nocase: String + transferredToL2AtTx_not_starts_with: String + transferredToL2AtTx_not_starts_with_nocase: String + transferredToL2AtTx_ends_with: String + transferredToL2AtTx_ends_with_nocase: String + transferredToL2AtTx_not_ends_with: String + transferredToL2AtTx_not_ends_with_nocase: String + signalledTokensSentToL2: BigInt + signalledTokensSentToL2_not: BigInt + signalledTokensSentToL2_gt: BigInt + signalledTokensSentToL2_lt: BigInt + signalledTokensSentToL2_gte: BigInt + signalledTokensSentToL2_lte: BigInt + signalledTokensSentToL2_in: [BigInt!] + signalledTokensSentToL2_not_in: [BigInt!] + signalledTokensReceivedOnL2: BigInt + signalledTokensReceivedOnL2_not: BigInt + signalledTokensReceivedOnL2_gt: BigInt + signalledTokensReceivedOnL2_lt: BigInt + signalledTokensReceivedOnL2_gte: BigInt + signalledTokensReceivedOnL2_lte: BigInt + signalledTokensReceivedOnL2_in: [BigInt!] + signalledTokensReceivedOnL2_not_in: [BigInt!] + idOnL2: String + idOnL2_not: String + idOnL2_gt: String + idOnL2_lt: String + idOnL2_gte: String + idOnL2_lte: String + idOnL2_in: [String!] + idOnL2_not_in: [String!] + idOnL2_contains: String + idOnL2_contains_nocase: String + idOnL2_not_contains: String + idOnL2_not_contains_nocase: String + idOnL2_starts_with: String + idOnL2_starts_with_nocase: String + idOnL2_not_starts_with: String + idOnL2_not_starts_with_nocase: String + idOnL2_ends_with: String + idOnL2_ends_with_nocase: String + idOnL2_not_ends_with: String + idOnL2_not_ends_with_nocase: String + idOnL1: String + idOnL1_not: String + idOnL1_gt: String + idOnL1_lt: String + idOnL1_gte: String + idOnL1_lte: String + idOnL1_in: [String!] + idOnL1_not_in: [String!] + idOnL1_contains: String + idOnL1_contains_nocase: String + idOnL1_not_contains: String + idOnL1_not_contains_nocase: String + idOnL1_starts_with: String + idOnL1_starts_with_nocase: String + idOnL1_not_starts_with: String + idOnL1_not_starts_with_nocase: String + idOnL1_ends_with: String + idOnL1_ends_with_nocase: String + idOnL1_not_ends_with: String + idOnL1_not_ends_with_nocase: String + nftID: String + nftID_not: String + nftID_gt: String + nftID_lt: String + nftID_gte: String + nftID_lte: String + nftID_in: [String!] + nftID_not_in: [String!] + nftID_contains: String + nftID_contains_nocase: String + nftID_not_contains: String + nftID_not_contains_nocase: String + nftID_starts_with: String + nftID_starts_with_nocase: String + nftID_not_starts_with: String + nftID_not_starts_with_nocase: String + nftID_ends_with: String + nftID_ends_with_nocase: String + nftID_not_ends_with: String + nftID_not_ends_with_nocase: String + oldID: String + oldID_not: String + oldID_gt: String + oldID_lt: String + oldID_gte: String + oldID_lte: String + oldID_in: [String!] + oldID_not_in: [String!] + oldID_contains: String + oldID_contains_nocase: String + oldID_not_contains: String + oldID_not_contains_nocase: String + oldID_starts_with: String + oldID_starts_with_nocase: String + oldID_not_starts_with: String + oldID_not_starts_with_nocase: String + oldID_ends_with: String + oldID_ends_with_nocase: String + oldID_not_ends_with: String + oldID_not_ends_with_nocase: String + creatorAddress: Bytes + creatorAddress_not: Bytes + creatorAddress_gt: Bytes + creatorAddress_lt: Bytes + creatorAddress_gte: Bytes + creatorAddress_lte: Bytes + creatorAddress_in: [Bytes!] + creatorAddress_not_in: [Bytes!] + creatorAddress_contains: Bytes + creatorAddress_not_contains: Bytes + subgraphNumber: BigInt + subgraphNumber_not: BigInt + subgraphNumber_gt: BigInt + subgraphNumber_lt: BigInt + subgraphNumber_gte: BigInt + subgraphNumber_lte: BigInt + subgraphNumber_in: [BigInt!] + subgraphNumber_not_in: [BigInt!] + initializing: Boolean + initializing_not: Boolean + initializing_in: [Boolean!] + initializing_not_in: [Boolean!] + entityVersion: Int + entityVersion_not: Int + entityVersion_gt: Int + entityVersion_lt: Int + entityVersion_gte: Int + entityVersion_lte: Int + entityVersion_in: [Int!] + entityVersion_not_in: [Int!] + linkedEntity: String + linkedEntity_not: String + linkedEntity_gt: String + linkedEntity_lt: String + linkedEntity_gte: String + linkedEntity_lte: String + linkedEntity_in: [String!] + linkedEntity_not_in: [String!] + linkedEntity_contains: String + linkedEntity_contains_nocase: String + linkedEntity_not_contains: String + linkedEntity_not_contains_nocase: String + linkedEntity_starts_with: String + linkedEntity_starts_with_nocase: String + linkedEntity_not_starts_with: String + linkedEntity_not_starts_with_nocase: String + linkedEntity_ends_with: String + linkedEntity_ends_with_nocase: String + linkedEntity_not_ends_with: String + linkedEntity_not_ends_with_nocase: String + linkedEntity_: Subgraph_filter + signalledTokens: BigInt + signalledTokens_not: BigInt + signalledTokens_gt: BigInt + signalledTokens_lt: BigInt + signalledTokens_gte: BigInt + signalledTokens_lte: BigInt + signalledTokens_in: [BigInt!] + signalledTokens_not_in: [BigInt!] + unsignalledTokens: BigInt + unsignalledTokens_not: BigInt + unsignalledTokens_gt: BigInt + unsignalledTokens_lt: BigInt + unsignalledTokens_gte: BigInt + unsignalledTokens_lte: BigInt + unsignalledTokens_in: [BigInt!] + unsignalledTokens_not_in: [BigInt!] + currentSignalledTokens: BigInt + currentSignalledTokens_not: BigInt + currentSignalledTokens_gt: BigInt + currentSignalledTokens_lt: BigInt + currentSignalledTokens_gte: BigInt + currentSignalledTokens_lte: BigInt + currentSignalledTokens_in: [BigInt!] + currentSignalledTokens_not_in: [BigInt!] + nameSignalAmount: BigInt + nameSignalAmount_not: BigInt + nameSignalAmount_gt: BigInt + nameSignalAmount_lt: BigInt + nameSignalAmount_gte: BigInt + nameSignalAmount_lte: BigInt + nameSignalAmount_in: [BigInt!] + nameSignalAmount_not_in: [BigInt!] + signalAmount: BigInt + signalAmount_not: BigInt + signalAmount_gt: BigInt + signalAmount_lt: BigInt + signalAmount_gte: BigInt + signalAmount_lte: BigInt + signalAmount_in: [BigInt!] + signalAmount_not_in: [BigInt!] + reserveRatio: Int + reserveRatio_not: Int + reserveRatio_gt: Int + reserveRatio_lt: Int + reserveRatio_gte: Int + reserveRatio_lte: Int + reserveRatio_in: [Int!] + reserveRatio_not_in: [Int!] + withdrawableTokens: BigInt + withdrawableTokens_not: BigInt + withdrawableTokens_gt: BigInt + withdrawableTokens_lt: BigInt + withdrawableTokens_gte: BigInt + withdrawableTokens_lte: BigInt + withdrawableTokens_in: [BigInt!] + withdrawableTokens_not_in: [BigInt!] + withdrawnTokens: BigInt + withdrawnTokens_not: BigInt + withdrawnTokens_gt: BigInt + withdrawnTokens_lt: BigInt + withdrawnTokens_gte: BigInt + withdrawnTokens_lte: BigInt + withdrawnTokens_in: [BigInt!] + withdrawnTokens_not_in: [BigInt!] + nameSignals_: NameSignal_filter + nameSignalCount: Int + nameSignalCount_not: Int + nameSignalCount_gt: Int + nameSignalCount_lt: Int + nameSignalCount_gte: Int + nameSignalCount_lte: Int + nameSignalCount_in: [Int!] + nameSignalCount_not_in: [Int!] + metadataHash: Bytes + metadataHash_not: Bytes + metadataHash_gt: Bytes + metadataHash_lt: Bytes + metadataHash_gte: Bytes + metadataHash_lte: Bytes + metadataHash_in: [Bytes!] + metadataHash_not_in: [Bytes!] + metadataHash_contains: Bytes + metadataHash_not_contains: Bytes + metadata: String + metadata_not: String + metadata_gt: String + metadata_lt: String + metadata_gte: String + metadata_lte: String + metadata_in: [String!] + metadata_not_in: [String!] + metadata_contains: String + metadata_contains_nocase: String + metadata_not_contains: String + metadata_not_contains_nocase: String + metadata_starts_with: String + metadata_starts_with_nocase: String + metadata_not_starts_with: String + metadata_not_starts_with_nocase: String + metadata_ends_with: String + metadata_ends_with_nocase: String + metadata_not_ends_with: String + metadata_not_ends_with_nocase: String + metadata_: SubgraphMeta_filter + currentVersionRelationEntity: String + currentVersionRelationEntity_not: String + currentVersionRelationEntity_gt: String + currentVersionRelationEntity_lt: String + currentVersionRelationEntity_gte: String + currentVersionRelationEntity_lte: String + currentVersionRelationEntity_in: [String!] + currentVersionRelationEntity_not_in: [String!] + currentVersionRelationEntity_contains: String + currentVersionRelationEntity_contains_nocase: String + currentVersionRelationEntity_not_contains: String + currentVersionRelationEntity_not_contains_nocase: String + currentVersionRelationEntity_starts_with: String + currentVersionRelationEntity_starts_with_nocase: String + currentVersionRelationEntity_not_starts_with: String + currentVersionRelationEntity_not_starts_with_nocase: String + currentVersionRelationEntity_ends_with: String + currentVersionRelationEntity_ends_with_nocase: String + currentVersionRelationEntity_not_ends_with: String + currentVersionRelationEntity_not_ends_with_nocase: String + currentVersionRelationEntity_: CurrentSubgraphDeploymentRelation_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Subgraph_filter] + or: [Subgraph_filter] +} + +enum Subgraph_orderBy { + id + owner + owner__id + owner__createdAt + owner__defaultDisplayName + owner__balance + owner__balanceReceivedFromL1Signalling + owner__balanceReceivedFromL1Delegation + owner__curationApproval + owner__stakingApproval + owner__gnsApproval + owner__developerCreatedAt + owner__subgraphQueryFees + currentVersion + currentVersion__id + currentVersion__version + currentVersion__createdAt + currentVersion__metadataHash + currentVersion__entityVersion + pastVersions + versions + versionCount + createdAt + updatedAt + active + migrated + startedTransferToL2 + startedTransferToL2At + startedTransferToL2AtBlockNumber + startedTransferToL2AtTx + transferredToL2 + transferredToL2At + transferredToL2AtBlockNumber + transferredToL2AtTx + signalledTokensSentToL2 + signalledTokensReceivedOnL2 + idOnL2 + idOnL1 + nftID + oldID + creatorAddress + subgraphNumber + initializing + entityVersion + linkedEntity + linkedEntity__id + linkedEntity__versionCount + linkedEntity__createdAt + linkedEntity__updatedAt + linkedEntity__active + linkedEntity__migrated + linkedEntity__startedTransferToL2 + linkedEntity__startedTransferToL2At + linkedEntity__startedTransferToL2AtBlockNumber + linkedEntity__startedTransferToL2AtTx + linkedEntity__transferredToL2 + linkedEntity__transferredToL2At + linkedEntity__transferredToL2AtBlockNumber + linkedEntity__transferredToL2AtTx + linkedEntity__signalledTokensSentToL2 + linkedEntity__signalledTokensReceivedOnL2 + linkedEntity__idOnL2 + linkedEntity__idOnL1 + linkedEntity__nftID + linkedEntity__oldID + linkedEntity__creatorAddress + linkedEntity__subgraphNumber + linkedEntity__initializing + linkedEntity__entityVersion + linkedEntity__signalledTokens + linkedEntity__unsignalledTokens + linkedEntity__currentSignalledTokens + linkedEntity__nameSignalAmount + linkedEntity__signalAmount + linkedEntity__reserveRatio + linkedEntity__withdrawableTokens + linkedEntity__withdrawnTokens + linkedEntity__nameSignalCount + linkedEntity__metadataHash + signalledTokens + unsignalledTokens + currentSignalledTokens + nameSignalAmount + signalAmount + reserveRatio + withdrawableTokens + withdrawnTokens + nameSignals + nameSignalCount + metadataHash + metadata + metadata__id + metadata__description + metadata__image + metadata__nftImage + metadata__codeRepository + metadata__website + metadata__displayName + currentVersionRelationEntity + currentVersionRelationEntity__id + currentVersionRelationEntity__active +} + +""" +The SubgraphDeployment is represented by the immutable subgraph code that is uploaded, and posted +to IPFS. A SubgraphDeployment has a manifest which gives the instructions to the Graph Network on +what to index. The entity stores relevant data for the SubgraphDeployment on how much it is being +staked on and signaled on in the contracts, as well as how it is performing in query fees. It is +related to a SubgraphVersion. + +""" +type SubgraphDeployment { + """ + Subgraph Deployment ID. The IPFS hash with Qm removed to fit into 32 bytes + """ + id: ID! + + """IPFS hash of the subgraph manifest""" + ipfsHash: String! + + """The versions this subgraph deployment relates to""" + versions(skip: Int = 0, first: Int = 100, orderBy: SubgraphVersion_orderBy, orderDirection: OrderDirection, where: SubgraphVersion_filter): [SubgraphVersion!]! + + """Creation timestamp""" + createdAt: Int! + + """ + The block at which this deployment was denied for rewards. Null if not denied + """ + deniedAt: Int! + + """ + [DEPRECATED] The original Subgraph that was deployed through GNS. Can be null + if never created through GNS. Used for filtering in the Explorer. Always null now + """ + originalName: String + + """CURRENT total stake of all indexers on this Subgraph Deployment""" + stakedTokens: BigInt! + + """Allocations created by indexers for this Subgraph""" + indexerAllocations(skip: Int = 0, first: Int = 100, orderBy: Allocation_orderBy, orderDirection: OrderDirection, where: Allocation_filter): [Allocation!]! + + """ + Total rewards accrued all time by this Subgraph Deployment. Includes delegator and indexer rewards + """ + indexingRewardAmount: BigInt! + + """Total rewards accrued all time by indexers""" + indexingIndexerRewardAmount: BigInt! + + """Total rewards accrued all time by delegators""" + indexingDelegatorRewardAmount: BigInt! + + """ + Total query fees earned by this Subgraph Deployment, without curator query fees + """ + queryFeesAmount: BigInt! + + """ + Total query fee rebates earned from the protocol, through the rebates formula. Does not include delegation fees + """ + queryFeeRebates: BigInt! + + """Total curator rewards from fees""" + curatorFeeRewards: BigInt! + + """CURRENT signalled tokens in the bonding curve""" + signalledTokens: BigInt! + + """NOT IMPLEMENTED - CURRENT signalled tokens in the bonding curve""" + unsignalledTokens: BigInt! + + """CURRENT curation signal for this subgraph deployment""" + signalAmount: BigInt! + + """signalledTokens / signalAmount""" + pricePerShare: BigDecimal! + + """Curators of this subgraph deployment""" + curatorSignals(skip: Int = 0, first: Int = 100, orderBy: Signal_orderBy, orderDirection: OrderDirection, where: Signal_filter): [Signal!]! + + """Bonding curve reserve ratio. In parts per million""" + reserveRatio: Int! + + """ + Entity that represents the manifest of the deployment. Filled by File Data Sources + """ + manifest: SubgraphDeploymentManifest + + """ + Total amount of Subgraph entities that used this deployment at some point. + subgraphCount >= activeSubgraphCount + deprecatedSubgraphCount + """ + subgraphCount: Int! + + """ + Amount of active Subgraph entities that are currently using this deployment. Deprecated subgraph entities are not counted + """ + activeSubgraphCount: Int! + + """ + Amount of Subgraph entities that were currently using this deployment when they got deprecated + """ + deprecatedSubgraphCount: Int! + + """ + Whether the deployment has been transferred from L1 to L2. Subgraphs published + on L2 will have this as false unless they were published through a transfer + """ + transferredToL2: Boolean! + + """ + Timestamp for the L1 -> L2 Transfer. Null if it's not fully transferred or if it's an L1 deployment + """ + transferredToL2At: BigInt + + """ + Block number for the L1 -> L2 Transfer. Null if it's not fully transferred or if it's an L1 deployment + """ + transferredToL2AtBlockNumber: BigInt + + """ + Transaction hash for the L1 -> L2 Transfer. Null if it's not fully transferred or if it's an L1 deployment + """ + transferredToL2AtTx: String + + """Amount of GRT transferred to L2""" + signalledTokensSentToL2: BigInt! + + """Amount of GRT received on L2""" + signalledTokensReceivedOnL2: BigInt! +} + +input SubgraphDeployment_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + ipfsHash: String + ipfsHash_not: String + ipfsHash_gt: String + ipfsHash_lt: String + ipfsHash_gte: String + ipfsHash_lte: String + ipfsHash_in: [String!] + ipfsHash_not_in: [String!] + ipfsHash_contains: String + ipfsHash_contains_nocase: String + ipfsHash_not_contains: String + ipfsHash_not_contains_nocase: String + ipfsHash_starts_with: String + ipfsHash_starts_with_nocase: String + ipfsHash_not_starts_with: String + ipfsHash_not_starts_with_nocase: String + ipfsHash_ends_with: String + ipfsHash_ends_with_nocase: String + ipfsHash_not_ends_with: String + ipfsHash_not_ends_with_nocase: String + versions_: SubgraphVersion_filter + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + deniedAt: Int + deniedAt_not: Int + deniedAt_gt: Int + deniedAt_lt: Int + deniedAt_gte: Int + deniedAt_lte: Int + deniedAt_in: [Int!] + deniedAt_not_in: [Int!] + originalName: String + originalName_not: String + originalName_gt: String + originalName_lt: String + originalName_gte: String + originalName_lte: String + originalName_in: [String!] + originalName_not_in: [String!] + originalName_contains: String + originalName_contains_nocase: String + originalName_not_contains: String + originalName_not_contains_nocase: String + originalName_starts_with: String + originalName_starts_with_nocase: String + originalName_not_starts_with: String + originalName_not_starts_with_nocase: String + originalName_ends_with: String + originalName_ends_with_nocase: String + originalName_not_ends_with: String + originalName_not_ends_with_nocase: String + stakedTokens: BigInt + stakedTokens_not: BigInt + stakedTokens_gt: BigInt + stakedTokens_lt: BigInt + stakedTokens_gte: BigInt + stakedTokens_lte: BigInt + stakedTokens_in: [BigInt!] + stakedTokens_not_in: [BigInt!] + indexerAllocations_: Allocation_filter + indexingRewardAmount: BigInt + indexingRewardAmount_not: BigInt + indexingRewardAmount_gt: BigInt + indexingRewardAmount_lt: BigInt + indexingRewardAmount_gte: BigInt + indexingRewardAmount_lte: BigInt + indexingRewardAmount_in: [BigInt!] + indexingRewardAmount_not_in: [BigInt!] + indexingIndexerRewardAmount: BigInt + indexingIndexerRewardAmount_not: BigInt + indexingIndexerRewardAmount_gt: BigInt + indexingIndexerRewardAmount_lt: BigInt + indexingIndexerRewardAmount_gte: BigInt + indexingIndexerRewardAmount_lte: BigInt + indexingIndexerRewardAmount_in: [BigInt!] + indexingIndexerRewardAmount_not_in: [BigInt!] + indexingDelegatorRewardAmount: BigInt + indexingDelegatorRewardAmount_not: BigInt + indexingDelegatorRewardAmount_gt: BigInt + indexingDelegatorRewardAmount_lt: BigInt + indexingDelegatorRewardAmount_gte: BigInt + indexingDelegatorRewardAmount_lte: BigInt + indexingDelegatorRewardAmount_in: [BigInt!] + indexingDelegatorRewardAmount_not_in: [BigInt!] + queryFeesAmount: BigInt + queryFeesAmount_not: BigInt + queryFeesAmount_gt: BigInt + queryFeesAmount_lt: BigInt + queryFeesAmount_gte: BigInt + queryFeesAmount_lte: BigInt + queryFeesAmount_in: [BigInt!] + queryFeesAmount_not_in: [BigInt!] + queryFeeRebates: BigInt + queryFeeRebates_not: BigInt + queryFeeRebates_gt: BigInt + queryFeeRebates_lt: BigInt + queryFeeRebates_gte: BigInt + queryFeeRebates_lte: BigInt + queryFeeRebates_in: [BigInt!] + queryFeeRebates_not_in: [BigInt!] + curatorFeeRewards: BigInt + curatorFeeRewards_not: BigInt + curatorFeeRewards_gt: BigInt + curatorFeeRewards_lt: BigInt + curatorFeeRewards_gte: BigInt + curatorFeeRewards_lte: BigInt + curatorFeeRewards_in: [BigInt!] + curatorFeeRewards_not_in: [BigInt!] + signalledTokens: BigInt + signalledTokens_not: BigInt + signalledTokens_gt: BigInt + signalledTokens_lt: BigInt + signalledTokens_gte: BigInt + signalledTokens_lte: BigInt + signalledTokens_in: [BigInt!] + signalledTokens_not_in: [BigInt!] + unsignalledTokens: BigInt + unsignalledTokens_not: BigInt + unsignalledTokens_gt: BigInt + unsignalledTokens_lt: BigInt + unsignalledTokens_gte: BigInt + unsignalledTokens_lte: BigInt + unsignalledTokens_in: [BigInt!] + unsignalledTokens_not_in: [BigInt!] + signalAmount: BigInt + signalAmount_not: BigInt + signalAmount_gt: BigInt + signalAmount_lt: BigInt + signalAmount_gte: BigInt + signalAmount_lte: BigInt + signalAmount_in: [BigInt!] + signalAmount_not_in: [BigInt!] + pricePerShare: BigDecimal + pricePerShare_not: BigDecimal + pricePerShare_gt: BigDecimal + pricePerShare_lt: BigDecimal + pricePerShare_gte: BigDecimal + pricePerShare_lte: BigDecimal + pricePerShare_in: [BigDecimal!] + pricePerShare_not_in: [BigDecimal!] + curatorSignals_: Signal_filter + reserveRatio: Int + reserveRatio_not: Int + reserveRatio_gt: Int + reserveRatio_lt: Int + reserveRatio_gte: Int + reserveRatio_lte: Int + reserveRatio_in: [Int!] + reserveRatio_not_in: [Int!] + manifest: String + manifest_not: String + manifest_gt: String + manifest_lt: String + manifest_gte: String + manifest_lte: String + manifest_in: [String!] + manifest_not_in: [String!] + manifest_contains: String + manifest_contains_nocase: String + manifest_not_contains: String + manifest_not_contains_nocase: String + manifest_starts_with: String + manifest_starts_with_nocase: String + manifest_not_starts_with: String + manifest_not_starts_with_nocase: String + manifest_ends_with: String + manifest_ends_with_nocase: String + manifest_not_ends_with: String + manifest_not_ends_with_nocase: String + manifest_: SubgraphDeploymentManifest_filter + subgraphCount: Int + subgraphCount_not: Int + subgraphCount_gt: Int + subgraphCount_lt: Int + subgraphCount_gte: Int + subgraphCount_lte: Int + subgraphCount_in: [Int!] + subgraphCount_not_in: [Int!] + activeSubgraphCount: Int + activeSubgraphCount_not: Int + activeSubgraphCount_gt: Int + activeSubgraphCount_lt: Int + activeSubgraphCount_gte: Int + activeSubgraphCount_lte: Int + activeSubgraphCount_in: [Int!] + activeSubgraphCount_not_in: [Int!] + deprecatedSubgraphCount: Int + deprecatedSubgraphCount_not: Int + deprecatedSubgraphCount_gt: Int + deprecatedSubgraphCount_lt: Int + deprecatedSubgraphCount_gte: Int + deprecatedSubgraphCount_lte: Int + deprecatedSubgraphCount_in: [Int!] + deprecatedSubgraphCount_not_in: [Int!] + transferredToL2: Boolean + transferredToL2_not: Boolean + transferredToL2_in: [Boolean!] + transferredToL2_not_in: [Boolean!] + transferredToL2At: BigInt + transferredToL2At_not: BigInt + transferredToL2At_gt: BigInt + transferredToL2At_lt: BigInt + transferredToL2At_gte: BigInt + transferredToL2At_lte: BigInt + transferredToL2At_in: [BigInt!] + transferredToL2At_not_in: [BigInt!] + transferredToL2AtBlockNumber: BigInt + transferredToL2AtBlockNumber_not: BigInt + transferredToL2AtBlockNumber_gt: BigInt + transferredToL2AtBlockNumber_lt: BigInt + transferredToL2AtBlockNumber_gte: BigInt + transferredToL2AtBlockNumber_lte: BigInt + transferredToL2AtBlockNumber_in: [BigInt!] + transferredToL2AtBlockNumber_not_in: [BigInt!] + transferredToL2AtTx: String + transferredToL2AtTx_not: String + transferredToL2AtTx_gt: String + transferredToL2AtTx_lt: String + transferredToL2AtTx_gte: String + transferredToL2AtTx_lte: String + transferredToL2AtTx_in: [String!] + transferredToL2AtTx_not_in: [String!] + transferredToL2AtTx_contains: String + transferredToL2AtTx_contains_nocase: String + transferredToL2AtTx_not_contains: String + transferredToL2AtTx_not_contains_nocase: String + transferredToL2AtTx_starts_with: String + transferredToL2AtTx_starts_with_nocase: String + transferredToL2AtTx_not_starts_with: String + transferredToL2AtTx_not_starts_with_nocase: String + transferredToL2AtTx_ends_with: String + transferredToL2AtTx_ends_with_nocase: String + transferredToL2AtTx_not_ends_with: String + transferredToL2AtTx_not_ends_with_nocase: String + signalledTokensSentToL2: BigInt + signalledTokensSentToL2_not: BigInt + signalledTokensSentToL2_gt: BigInt + signalledTokensSentToL2_lt: BigInt + signalledTokensSentToL2_gte: BigInt + signalledTokensSentToL2_lte: BigInt + signalledTokensSentToL2_in: [BigInt!] + signalledTokensSentToL2_not_in: [BigInt!] + signalledTokensReceivedOnL2: BigInt + signalledTokensReceivedOnL2_not: BigInt + signalledTokensReceivedOnL2_gt: BigInt + signalledTokensReceivedOnL2_lt: BigInt + signalledTokensReceivedOnL2_gte: BigInt + signalledTokensReceivedOnL2_lte: BigInt + signalledTokensReceivedOnL2_in: [BigInt!] + signalledTokensReceivedOnL2_not_in: [BigInt!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [SubgraphDeployment_filter] + or: [SubgraphDeployment_filter] +} + +enum SubgraphDeployment_orderBy { + id + ipfsHash + versions + createdAt + deniedAt + originalName + stakedTokens + indexerAllocations + indexingRewardAmount + indexingIndexerRewardAmount + indexingDelegatorRewardAmount + queryFeesAmount + queryFeeRebates + curatorFeeRewards + signalledTokens + unsignalledTokens + signalAmount + pricePerShare + curatorSignals + reserveRatio + manifest + manifest__id + manifest__schemaIpfsHash + manifest__manifest + manifest__network + manifest__poweredBySubstreams + manifest__startBlock + subgraphCount + activeSubgraphCount + deprecatedSubgraphCount + transferredToL2 + transferredToL2At + transferredToL2AtBlockNumber + transferredToL2AtTx + signalledTokensSentToL2 + signalledTokensReceivedOnL2 +} + +type SubgraphDeploymentManifest { + """IPFS Hash""" + id: ID! + + """Link to SubgraphDeployment entity""" + deployment: SubgraphDeployment + + """Schema entity""" + schema: SubgraphDeploymentSchema + + """Schema ipfs hash""" + schemaIpfsHash: String + + """Contents of the Manifest file""" + manifest: String + + """Network where the contracts that the subgraph indexes are located""" + network: String + + """Whether the subgraph is a SpS/SbS. Null if we can't parse it""" + poweredBySubstreams: Boolean + + """ + Start block for the deployment. It's the lowest startBlock found (0 if some data source doesn't contain a start block) + """ + startBlock: BigInt +} + +input SubgraphDeploymentManifest_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + deployment_: SubgraphDeployment_filter + schema: String + schema_not: String + schema_gt: String + schema_lt: String + schema_gte: String + schema_lte: String + schema_in: [String!] + schema_not_in: [String!] + schema_contains: String + schema_contains_nocase: String + schema_not_contains: String + schema_not_contains_nocase: String + schema_starts_with: String + schema_starts_with_nocase: String + schema_not_starts_with: String + schema_not_starts_with_nocase: String + schema_ends_with: String + schema_ends_with_nocase: String + schema_not_ends_with: String + schema_not_ends_with_nocase: String + schema_: SubgraphDeploymentSchema_filter + schemaIpfsHash: String + schemaIpfsHash_not: String + schemaIpfsHash_gt: String + schemaIpfsHash_lt: String + schemaIpfsHash_gte: String + schemaIpfsHash_lte: String + schemaIpfsHash_in: [String!] + schemaIpfsHash_not_in: [String!] + schemaIpfsHash_contains: String + schemaIpfsHash_contains_nocase: String + schemaIpfsHash_not_contains: String + schemaIpfsHash_not_contains_nocase: String + schemaIpfsHash_starts_with: String + schemaIpfsHash_starts_with_nocase: String + schemaIpfsHash_not_starts_with: String + schemaIpfsHash_not_starts_with_nocase: String + schemaIpfsHash_ends_with: String + schemaIpfsHash_ends_with_nocase: String + schemaIpfsHash_not_ends_with: String + schemaIpfsHash_not_ends_with_nocase: String + manifest: String + manifest_not: String + manifest_gt: String + manifest_lt: String + manifest_gte: String + manifest_lte: String + manifest_in: [String!] + manifest_not_in: [String!] + manifest_contains: String + manifest_contains_nocase: String + manifest_not_contains: String + manifest_not_contains_nocase: String + manifest_starts_with: String + manifest_starts_with_nocase: String + manifest_not_starts_with: String + manifest_not_starts_with_nocase: String + manifest_ends_with: String + manifest_ends_with_nocase: String + manifest_not_ends_with: String + manifest_not_ends_with_nocase: String + network: String + network_not: String + network_gt: String + network_lt: String + network_gte: String + network_lte: String + network_in: [String!] + network_not_in: [String!] + network_contains: String + network_contains_nocase: String + network_not_contains: String + network_not_contains_nocase: String + network_starts_with: String + network_starts_with_nocase: String + network_not_starts_with: String + network_not_starts_with_nocase: String + network_ends_with: String + network_ends_with_nocase: String + network_not_ends_with: String + network_not_ends_with_nocase: String + poweredBySubstreams: Boolean + poweredBySubstreams_not: Boolean + poweredBySubstreams_in: [Boolean!] + poweredBySubstreams_not_in: [Boolean!] + startBlock: BigInt + startBlock_not: BigInt + startBlock_gt: BigInt + startBlock_lt: BigInt + startBlock_gte: BigInt + startBlock_lte: BigInt + startBlock_in: [BigInt!] + startBlock_not_in: [BigInt!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [SubgraphDeploymentManifest_filter] + or: [SubgraphDeploymentManifest_filter] +} + +enum SubgraphDeploymentManifest_orderBy { + id + deployment + deployment__id + deployment__ipfsHash + deployment__createdAt + deployment__deniedAt + deployment__originalName + deployment__stakedTokens + deployment__indexingRewardAmount + deployment__indexingIndexerRewardAmount + deployment__indexingDelegatorRewardAmount + deployment__queryFeesAmount + deployment__queryFeeRebates + deployment__curatorFeeRewards + deployment__signalledTokens + deployment__unsignalledTokens + deployment__signalAmount + deployment__pricePerShare + deployment__reserveRatio + deployment__subgraphCount + deployment__activeSubgraphCount + deployment__deprecatedSubgraphCount + deployment__transferredToL2 + deployment__transferredToL2At + deployment__transferredToL2AtBlockNumber + deployment__transferredToL2AtTx + deployment__signalledTokensSentToL2 + deployment__signalledTokensReceivedOnL2 + schema + schema__id + schema__schema + schemaIpfsHash + manifest + network + poweredBySubstreams + startBlock +} + +type SubgraphDeploymentSchema { + """IPFS Hash""" + id: ID! + + """ + Link to a SubgraphDeploymentManifest entity that references this schema. For + backwards compatibility purposes only, for the full list of manifests use manifests + """ + manifest: SubgraphDeploymentManifest + + """ + Links to SubgraphDeploymentManifest entities that reference this schema + """ + manifests(skip: Int = 0, first: Int = 100, orderBy: SubgraphDeploymentManifest_orderBy, orderDirection: OrderDirection, where: SubgraphDeploymentManifest_filter): [SubgraphDeploymentManifest!]! + + """Contents of the Schema file""" + schema: String +} + +input SubgraphDeploymentSchema_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + manifest_: SubgraphDeploymentManifest_filter + manifests_: SubgraphDeploymentManifest_filter + schema: String + schema_not: String + schema_gt: String + schema_lt: String + schema_gte: String + schema_lte: String + schema_in: [String!] + schema_not_in: [String!] + schema_contains: String + schema_contains_nocase: String + schema_not_contains: String + schema_not_contains_nocase: String + schema_starts_with: String + schema_starts_with_nocase: String + schema_not_starts_with: String + schema_not_starts_with_nocase: String + schema_ends_with: String + schema_ends_with_nocase: String + schema_not_ends_with: String + schema_not_ends_with_nocase: String + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [SubgraphDeploymentSchema_filter] + or: [SubgraphDeploymentSchema_filter] +} + +enum SubgraphDeploymentSchema_orderBy { + id + manifest + manifest__id + manifest__schemaIpfsHash + manifest__manifest + manifest__network + manifest__poweredBySubstreams + manifest__startBlock + manifests + schema +} + +type SubgraphMeta { + """Subgraph metadata ipfs hash""" + id: ID! + + """ + Subgraph that reference this metadata. For compatibility purposes. For the full list use subgraphs + """ + subgraph: Subgraph + + """Subgraphs that reference this metadata""" + subgraphs(skip: Int = 0, first: Int = 100, orderBy: Subgraph_orderBy, orderDirection: OrderDirection, where: Subgraph_filter): [Subgraph!]! + + """Short description of the subgraph""" + description: String + + """Image in string format""" + image: String + + """NFT Image representation""" + nftImage: String + + """Location of the code for this project""" + codeRepository: String + + """Projects website""" + website: String + + """Display name""" + displayName: String + + """Categories that the subgraph belongs to.""" + categories: [String!] +} + +input SubgraphMeta_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + subgraph_: Subgraph_filter + subgraphs_: Subgraph_filter + description: String + description_not: String + description_gt: String + description_lt: String + description_gte: String + description_lte: String + description_in: [String!] + description_not_in: [String!] + description_contains: String + description_contains_nocase: String + description_not_contains: String + description_not_contains_nocase: String + description_starts_with: String + description_starts_with_nocase: String + description_not_starts_with: String + description_not_starts_with_nocase: String + description_ends_with: String + description_ends_with_nocase: String + description_not_ends_with: String + description_not_ends_with_nocase: String + image: String + image_not: String + image_gt: String + image_lt: String + image_gte: String + image_lte: String + image_in: [String!] + image_not_in: [String!] + image_contains: String + image_contains_nocase: String + image_not_contains: String + image_not_contains_nocase: String + image_starts_with: String + image_starts_with_nocase: String + image_not_starts_with: String + image_not_starts_with_nocase: String + image_ends_with: String + image_ends_with_nocase: String + image_not_ends_with: String + image_not_ends_with_nocase: String + nftImage: String + nftImage_not: String + nftImage_gt: String + nftImage_lt: String + nftImage_gte: String + nftImage_lte: String + nftImage_in: [String!] + nftImage_not_in: [String!] + nftImage_contains: String + nftImage_contains_nocase: String + nftImage_not_contains: String + nftImage_not_contains_nocase: String + nftImage_starts_with: String + nftImage_starts_with_nocase: String + nftImage_not_starts_with: String + nftImage_not_starts_with_nocase: String + nftImage_ends_with: String + nftImage_ends_with_nocase: String + nftImage_not_ends_with: String + nftImage_not_ends_with_nocase: String + codeRepository: String + codeRepository_not: String + codeRepository_gt: String + codeRepository_lt: String + codeRepository_gte: String + codeRepository_lte: String + codeRepository_in: [String!] + codeRepository_not_in: [String!] + codeRepository_contains: String + codeRepository_contains_nocase: String + codeRepository_not_contains: String + codeRepository_not_contains_nocase: String + codeRepository_starts_with: String + codeRepository_starts_with_nocase: String + codeRepository_not_starts_with: String + codeRepository_not_starts_with_nocase: String + codeRepository_ends_with: String + codeRepository_ends_with_nocase: String + codeRepository_not_ends_with: String + codeRepository_not_ends_with_nocase: String + website: String + website_not: String + website_gt: String + website_lt: String + website_gte: String + website_lte: String + website_in: [String!] + website_not_in: [String!] + website_contains: String + website_contains_nocase: String + website_not_contains: String + website_not_contains_nocase: String + website_starts_with: String + website_starts_with_nocase: String + website_not_starts_with: String + website_not_starts_with_nocase: String + website_ends_with: String + website_ends_with_nocase: String + website_not_ends_with: String + website_not_ends_with_nocase: String + displayName: String + displayName_not: String + displayName_gt: String + displayName_lt: String + displayName_gte: String + displayName_lte: String + displayName_in: [String!] + displayName_not_in: [String!] + displayName_contains: String + displayName_contains_nocase: String + displayName_not_contains: String + displayName_not_contains_nocase: String + displayName_starts_with: String + displayName_starts_with_nocase: String + displayName_not_starts_with: String + displayName_not_starts_with_nocase: String + displayName_ends_with: String + displayName_ends_with_nocase: String + displayName_not_ends_with: String + displayName_not_ends_with_nocase: String + categories: [String!] + categories_not: [String!] + categories_contains: [String!] + categories_contains_nocase: [String!] + categories_not_contains: [String!] + categories_not_contains_nocase: [String!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [SubgraphMeta_filter] + or: [SubgraphMeta_filter] +} + +enum SubgraphMeta_orderBy { + id + subgraph + subgraph__id + subgraph__versionCount + subgraph__createdAt + subgraph__updatedAt + subgraph__active + subgraph__migrated + subgraph__startedTransferToL2 + subgraph__startedTransferToL2At + subgraph__startedTransferToL2AtBlockNumber + subgraph__startedTransferToL2AtTx + subgraph__transferredToL2 + subgraph__transferredToL2At + subgraph__transferredToL2AtBlockNumber + subgraph__transferredToL2AtTx + subgraph__signalledTokensSentToL2 + subgraph__signalledTokensReceivedOnL2 + subgraph__idOnL2 + subgraph__idOnL1 + subgraph__nftID + subgraph__oldID + subgraph__creatorAddress + subgraph__subgraphNumber + subgraph__initializing + subgraph__entityVersion + subgraph__signalledTokens + subgraph__unsignalledTokens + subgraph__currentSignalledTokens + subgraph__nameSignalAmount + subgraph__signalAmount + subgraph__reserveRatio + subgraph__withdrawableTokens + subgraph__withdrawnTokens + subgraph__nameSignalCount + subgraph__metadataHash + subgraphs + description + image + nftImage + codeRepository + website + displayName + categories +} + +""" +The SubgraphVersion entity represents a version of the Subgraph. A new SubgraphVersion is created +whenever there is an update to the Subgraph triggered by the owner. The new SubgraphVersion can +then point to a new SubgraphDeployment, thus allowing the Subgraph to resolve to a different +deployment, while keeping the same endpoint. The metadata and label are stored on IPFS. The label +is for the developer to provide a semantic version. This is different from the version, which is +just a counter than increases each time a new SubgraphVersion is created for a Subgraph. + +""" +type SubgraphVersion { + """Concatenation of subgraph, subgraph deployment, and version ID""" + id: ID! + + """Subgraph of this version""" + subgraph: Subgraph! + + """Subgraph deployment of this version""" + subgraphDeployment: SubgraphDeployment! + + """Version number""" + version: Int! + + """Creation timestamp""" + createdAt: Int! + metadataHash: Bytes + metadata: SubgraphVersionMeta + entityVersion: Int! + + """ + [DEPRECATED] Used for duplicate entities to enable old IDs from before the subgraph NFT update + """ + linkedEntity: SubgraphVersion +} + +input SubgraphVersion_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + subgraph: String + subgraph_not: String + subgraph_gt: String + subgraph_lt: String + subgraph_gte: String + subgraph_lte: String + subgraph_in: [String!] + subgraph_not_in: [String!] + subgraph_contains: String + subgraph_contains_nocase: String + subgraph_not_contains: String + subgraph_not_contains_nocase: String + subgraph_starts_with: String + subgraph_starts_with_nocase: String + subgraph_not_starts_with: String + subgraph_not_starts_with_nocase: String + subgraph_ends_with: String + subgraph_ends_with_nocase: String + subgraph_not_ends_with: String + subgraph_not_ends_with_nocase: String + subgraph_: Subgraph_filter + subgraphDeployment: String + subgraphDeployment_not: String + subgraphDeployment_gt: String + subgraphDeployment_lt: String + subgraphDeployment_gte: String + subgraphDeployment_lte: String + subgraphDeployment_in: [String!] + subgraphDeployment_not_in: [String!] + subgraphDeployment_contains: String + subgraphDeployment_contains_nocase: String + subgraphDeployment_not_contains: String + subgraphDeployment_not_contains_nocase: String + subgraphDeployment_starts_with: String + subgraphDeployment_starts_with_nocase: String + subgraphDeployment_not_starts_with: String + subgraphDeployment_not_starts_with_nocase: String + subgraphDeployment_ends_with: String + subgraphDeployment_ends_with_nocase: String + subgraphDeployment_not_ends_with: String + subgraphDeployment_not_ends_with_nocase: String + subgraphDeployment_: SubgraphDeployment_filter + version: Int + version_not: Int + version_gt: Int + version_lt: Int + version_gte: Int + version_lte: Int + version_in: [Int!] + version_not_in: [Int!] + createdAt: Int + createdAt_not: Int + createdAt_gt: Int + createdAt_lt: Int + createdAt_gte: Int + createdAt_lte: Int + createdAt_in: [Int!] + createdAt_not_in: [Int!] + metadataHash: Bytes + metadataHash_not: Bytes + metadataHash_gt: Bytes + metadataHash_lt: Bytes + metadataHash_gte: Bytes + metadataHash_lte: Bytes + metadataHash_in: [Bytes!] + metadataHash_not_in: [Bytes!] + metadataHash_contains: Bytes + metadataHash_not_contains: Bytes + metadata: String + metadata_not: String + metadata_gt: String + metadata_lt: String + metadata_gte: String + metadata_lte: String + metadata_in: [String!] + metadata_not_in: [String!] + metadata_contains: String + metadata_contains_nocase: String + metadata_not_contains: String + metadata_not_contains_nocase: String + metadata_starts_with: String + metadata_starts_with_nocase: String + metadata_not_starts_with: String + metadata_not_starts_with_nocase: String + metadata_ends_with: String + metadata_ends_with_nocase: String + metadata_not_ends_with: String + metadata_not_ends_with_nocase: String + metadata_: SubgraphVersionMeta_filter + entityVersion: Int + entityVersion_not: Int + entityVersion_gt: Int + entityVersion_lt: Int + entityVersion_gte: Int + entityVersion_lte: Int + entityVersion_in: [Int!] + entityVersion_not_in: [Int!] + linkedEntity: String + linkedEntity_not: String + linkedEntity_gt: String + linkedEntity_lt: String + linkedEntity_gte: String + linkedEntity_lte: String + linkedEntity_in: [String!] + linkedEntity_not_in: [String!] + linkedEntity_contains: String + linkedEntity_contains_nocase: String + linkedEntity_not_contains: String + linkedEntity_not_contains_nocase: String + linkedEntity_starts_with: String + linkedEntity_starts_with_nocase: String + linkedEntity_not_starts_with: String + linkedEntity_not_starts_with_nocase: String + linkedEntity_ends_with: String + linkedEntity_ends_with_nocase: String + linkedEntity_not_ends_with: String + linkedEntity_not_ends_with_nocase: String + linkedEntity_: SubgraphVersion_filter + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [SubgraphVersion_filter] + or: [SubgraphVersion_filter] +} + +enum SubgraphVersion_orderBy { + id + subgraph + subgraph__id + subgraph__versionCount + subgraph__createdAt + subgraph__updatedAt + subgraph__active + subgraph__migrated + subgraph__startedTransferToL2 + subgraph__startedTransferToL2At + subgraph__startedTransferToL2AtBlockNumber + subgraph__startedTransferToL2AtTx + subgraph__transferredToL2 + subgraph__transferredToL2At + subgraph__transferredToL2AtBlockNumber + subgraph__transferredToL2AtTx + subgraph__signalledTokensSentToL2 + subgraph__signalledTokensReceivedOnL2 + subgraph__idOnL2 + subgraph__idOnL1 + subgraph__nftID + subgraph__oldID + subgraph__creatorAddress + subgraph__subgraphNumber + subgraph__initializing + subgraph__entityVersion + subgraph__signalledTokens + subgraph__unsignalledTokens + subgraph__currentSignalledTokens + subgraph__nameSignalAmount + subgraph__signalAmount + subgraph__reserveRatio + subgraph__withdrawableTokens + subgraph__withdrawnTokens + subgraph__nameSignalCount + subgraph__metadataHash + subgraphDeployment + subgraphDeployment__id + subgraphDeployment__ipfsHash + subgraphDeployment__createdAt + subgraphDeployment__deniedAt + subgraphDeployment__originalName + subgraphDeployment__stakedTokens + subgraphDeployment__indexingRewardAmount + subgraphDeployment__indexingIndexerRewardAmount + subgraphDeployment__indexingDelegatorRewardAmount + subgraphDeployment__queryFeesAmount + subgraphDeployment__queryFeeRebates + subgraphDeployment__curatorFeeRewards + subgraphDeployment__signalledTokens + subgraphDeployment__unsignalledTokens + subgraphDeployment__signalAmount + subgraphDeployment__pricePerShare + subgraphDeployment__reserveRatio + subgraphDeployment__subgraphCount + subgraphDeployment__activeSubgraphCount + subgraphDeployment__deprecatedSubgraphCount + subgraphDeployment__transferredToL2 + subgraphDeployment__transferredToL2At + subgraphDeployment__transferredToL2AtBlockNumber + subgraphDeployment__transferredToL2AtTx + subgraphDeployment__signalledTokensSentToL2 + subgraphDeployment__signalledTokensReceivedOnL2 + version + createdAt + metadataHash + metadata + metadata__id + metadata__description + metadata__label + entityVersion + linkedEntity + linkedEntity__id + linkedEntity__version + linkedEntity__createdAt + linkedEntity__metadataHash + linkedEntity__entityVersion +} + +type SubgraphVersionMeta { + """Subgraph version metadata ipfs hash""" + id: ID! + + """ + SubgraphVersion entity that references this metadata. For compatibility purposes. For the full list use subgraphVersions + """ + subgraphVersion: SubgraphVersion + + """SubgraphVersion entities that reference this metadata""" + subgraphVersions(skip: Int = 0, first: Int = 100, orderBy: SubgraphVersion_orderBy, orderDirection: OrderDirection, where: SubgraphVersion_filter): [SubgraphVersion!]! + + """Short description of the version""" + description: String + + """Semantic versioning label""" + label: String +} + +input SubgraphVersionMeta_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + subgraphVersion_: SubgraphVersion_filter + subgraphVersions_: SubgraphVersion_filter + description: String + description_not: String + description_gt: String + description_lt: String + description_gte: String + description_lte: String + description_in: [String!] + description_not_in: [String!] + description_contains: String + description_contains_nocase: String + description_not_contains: String + description_not_contains_nocase: String + description_starts_with: String + description_starts_with_nocase: String + description_not_starts_with: String + description_not_starts_with_nocase: String + description_ends_with: String + description_ends_with_nocase: String + description_not_ends_with: String + description_not_ends_with_nocase: String + label: String + label_not: String + label_gt: String + label_lt: String + label_gte: String + label_lte: String + label_in: [String!] + label_not_in: [String!] + label_contains: String + label_contains_nocase: String + label_not_contains: String + label_not_contains_nocase: String + label_starts_with: String + label_starts_with_nocase: String + label_not_starts_with: String + label_not_starts_with_nocase: String + label_ends_with: String + label_ends_with_nocase: String + label_not_ends_with: String + label_not_ends_with_nocase: String + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [SubgraphVersionMeta_filter] + or: [SubgraphVersionMeta_filter] +} + +enum SubgraphVersionMeta_orderBy { + id + subgraphVersion + subgraphVersion__id + subgraphVersion__version + subgraphVersion__createdAt + subgraphVersion__metadataHash + subgraphVersion__entityVersion + subgraphVersions + description + label +} + +type Subscription { + graphNetwork( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): GraphNetwork + graphNetworks( + skip: Int = 0 + first: Int = 100 + orderBy: GraphNetwork_orderBy + orderDirection: OrderDirection + where: GraphNetwork_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [GraphNetwork!]! + graphAccount( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): GraphAccount + graphAccounts( + skip: Int = 0 + first: Int = 100 + orderBy: GraphAccount_orderBy + orderDirection: OrderDirection + where: GraphAccount_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [GraphAccount!]! + graphAccountMeta( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): GraphAccountMeta + graphAccountMetas( + skip: Int = 0 + first: Int = 100 + orderBy: GraphAccountMeta_orderBy + orderDirection: OrderDirection + where: GraphAccountMeta_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [GraphAccountMeta!]! + graphAccountName( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): GraphAccountName + graphAccountNames( + skip: Int = 0 + first: Int = 100 + orderBy: GraphAccountName_orderBy + orderDirection: OrderDirection + where: GraphAccountName_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [GraphAccountName!]! + subgraph( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Subgraph + subgraphs( + skip: Int = 0 + first: Int = 100 + orderBy: Subgraph_orderBy + orderDirection: OrderDirection + where: Subgraph_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Subgraph!]! + subgraphMeta( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphMeta + subgraphMetas( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphMeta_orderBy + orderDirection: OrderDirection + where: SubgraphMeta_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphMeta!]! + currentSubgraphDeploymentRelation( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): CurrentSubgraphDeploymentRelation + currentSubgraphDeploymentRelations( + skip: Int = 0 + first: Int = 100 + orderBy: CurrentSubgraphDeploymentRelation_orderBy + orderDirection: OrderDirection + where: CurrentSubgraphDeploymentRelation_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [CurrentSubgraphDeploymentRelation!]! + subgraphVersion( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphVersion + subgraphVersions( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphVersion_orderBy + orderDirection: OrderDirection + where: SubgraphVersion_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphVersion!]! + subgraphVersionMeta( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphVersionMeta + subgraphVersionMetas( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphVersionMeta_orderBy + orderDirection: OrderDirection + where: SubgraphVersionMeta_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphVersionMeta!]! + subgraphDeployment( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphDeployment + subgraphDeployments( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphDeployment_orderBy + orderDirection: OrderDirection + where: SubgraphDeployment_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphDeployment!]! + subgraphDeploymentSchema( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphDeploymentSchema + subgraphDeploymentSchemas( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphDeploymentSchema_orderBy + orderDirection: OrderDirection + where: SubgraphDeploymentSchema_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphDeploymentSchema!]! + subgraphDeploymentManifest( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SubgraphDeploymentManifest + subgraphDeploymentManifests( + skip: Int = 0 + first: Int = 100 + orderBy: SubgraphDeploymentManifest_orderBy + orderDirection: OrderDirection + where: SubgraphDeploymentManifest_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SubgraphDeploymentManifest!]! + indexer( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Indexer + indexers( + skip: Int = 0 + first: Int = 100 + orderBy: Indexer_orderBy + orderDirection: OrderDirection + where: Indexer_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Indexer!]! + allocation( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Allocation + allocations( + skip: Int = 0 + first: Int = 100 + orderBy: Allocation_orderBy + orderDirection: OrderDirection + where: Allocation_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Allocation!]! + pool( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Pool + pools( + skip: Int = 0 + first: Int = 100 + orderBy: Pool_orderBy + orderDirection: OrderDirection + where: Pool_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Pool!]! + delegator( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Delegator + delegators( + skip: Int = 0 + first: Int = 100 + orderBy: Delegator_orderBy + orderDirection: OrderDirection + where: Delegator_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Delegator!]! + delegatedStake( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): DelegatedStake + delegatedStakes( + skip: Int = 0 + first: Int = 100 + orderBy: DelegatedStake_orderBy + orderDirection: OrderDirection + where: DelegatedStake_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [DelegatedStake!]! + curator( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Curator + curators( + skip: Int = 0 + first: Int = 100 + orderBy: Curator_orderBy + orderDirection: OrderDirection + where: Curator_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Curator!]! + signal( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Signal + signals( + skip: Int = 0 + first: Int = 100 + orderBy: Signal_orderBy + orderDirection: OrderDirection + where: Signal_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Signal!]! + nameSignal( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): NameSignal + nameSignals( + skip: Int = 0 + first: Int = 100 + orderBy: NameSignal_orderBy + orderDirection: OrderDirection + where: NameSignal_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [NameSignal!]! + nameSignalSubgraphRelation( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): NameSignalSubgraphRelation + nameSignalSubgraphRelations( + skip: Int = 0 + first: Int = 100 + orderBy: NameSignalSubgraphRelation_orderBy + orderDirection: OrderDirection + where: NameSignalSubgraphRelation_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [NameSignalSubgraphRelation!]! + dispute( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Dispute + disputes( + skip: Int = 0 + first: Int = 100 + orderBy: Dispute_orderBy + orderDirection: OrderDirection + where: Dispute_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Dispute!]! + attestation( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Attestation + attestations( + skip: Int = 0 + first: Int = 100 + orderBy: Attestation_orderBy + orderDirection: OrderDirection + where: Attestation_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Attestation!]! + epoch( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Epoch + epoches( + skip: Int = 0 + first: Int = 100 + orderBy: Epoch_orderBy + orderDirection: OrderDirection + where: Epoch_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Epoch!]! + nameSignalTransaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): NameSignalTransaction + nameSignalTransactions( + skip: Int = 0 + first: Int = 100 + orderBy: NameSignalTransaction_orderBy + orderDirection: OrderDirection + where: NameSignalTransaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [NameSignalTransaction!]! + signalTransaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): SignalTransaction + signalTransactions( + skip: Int = 0 + first: Int = 100 + orderBy: SignalTransaction_orderBy + orderDirection: OrderDirection + where: SignalTransaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [SignalTransaction!]! + bridgeWithdrawalTransaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): BridgeWithdrawalTransaction + bridgeWithdrawalTransactions( + skip: Int = 0 + first: Int = 100 + orderBy: BridgeWithdrawalTransaction_orderBy + orderDirection: OrderDirection + where: BridgeWithdrawalTransaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [BridgeWithdrawalTransaction!]! + bridgeDepositTransaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): BridgeDepositTransaction + bridgeDepositTransactions( + skip: Int = 0 + first: Int = 100 + orderBy: BridgeDepositTransaction_orderBy + orderDirection: OrderDirection + where: BridgeDepositTransaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [BridgeDepositTransaction!]! + retryableTicket( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): RetryableTicket + retryableTickets( + skip: Int = 0 + first: Int = 100 + orderBy: RetryableTicket_orderBy + orderDirection: OrderDirection + where: RetryableTicket_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [RetryableTicket!]! + retryableTicketRedeemAttempt( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): RetryableTicketRedeemAttempt + retryableTicketRedeemAttempts( + skip: Int = 0 + first: Int = 100 + orderBy: RetryableTicketRedeemAttempt_orderBy + orderDirection: OrderDirection + where: RetryableTicketRedeemAttempt_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [RetryableTicketRedeemAttempt!]! + tokenManager( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): TokenManager + tokenManagers( + skip: Int = 0 + first: Int = 100 + orderBy: TokenManager_orderBy + orderDirection: OrderDirection + where: TokenManager_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [TokenManager!]! + authorizedFunction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): AuthorizedFunction + authorizedFunctions( + skip: Int = 0 + first: Int = 100 + orderBy: AuthorizedFunction_orderBy + orderDirection: OrderDirection + where: AuthorizedFunction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [AuthorizedFunction!]! + tokenLockWallet( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): TokenLockWallet + tokenLockWallets( + skip: Int = 0 + first: Int = 100 + orderBy: TokenLockWallet_orderBy + orderDirection: OrderDirection + where: TokenLockWallet_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [TokenLockWallet!]! + transaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Transaction + transactions( + skip: Int = 0 + first: Int = 100 + orderBy: Transaction_orderBy + orderDirection: OrderDirection + where: Transaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Transaction!]! + + """Access to subgraph metadata""" + _meta(block: Block_height): _Meta_ +} + +""" +A string representation of microseconds UNIX timestamp (16 digits) + +""" +scalar Timestamp + +""" +Token Lock Wallets which hold locked GRT + +""" +type TokenLockWallet { + """The address of the token lock wallet""" + id: ID! + + """The Manager address""" + manager: Bytes! + + """The hash of the initializer""" + initHash: Bytes! + + """Address of the beneficiary of locked tokens""" + beneficiary: Bytes! + + """The token being used (GRT)""" + token: Bytes! + + """Amount of tokens to be managed by the lock contract""" + managedAmount: BigInt! + + """Start time of the release schedule""" + startTime: BigInt! + + """End time of the release schedule""" + endTime: BigInt! + + """Number of periods between start time and end time""" + periods: BigInt! + + """Time when the releases start""" + releaseStartTime: BigInt! + + """Time the cliff vests, 0 if no cliff""" + vestingCliffTime: BigInt! + + """Whether or not the contract is revocable""" + revocable: Revocability + + """ + True if the beneficiary has approved addresses that the manager has approved + """ + tokenDestinationsApproved: Boolean! + + """The amount of tokens that have been resleased""" + tokensReleased: BigInt! + + """The amount of tokens that have been withdrawn""" + tokensWithdrawn: BigInt! + + """The amount of tokens that have been revoked""" + tokensRevoked: BigInt! + + """The block this wlalet was created""" + blockNumberCreated: BigInt! + + """The creation tx hash of the wallet""" + txHash: Bytes! +} + +input TokenLockWallet_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + manager: Bytes + manager_not: Bytes + manager_gt: Bytes + manager_lt: Bytes + manager_gte: Bytes + manager_lte: Bytes + manager_in: [Bytes!] + manager_not_in: [Bytes!] + manager_contains: Bytes + manager_not_contains: Bytes + initHash: Bytes + initHash_not: Bytes + initHash_gt: Bytes + initHash_lt: Bytes + initHash_gte: Bytes + initHash_lte: Bytes + initHash_in: [Bytes!] + initHash_not_in: [Bytes!] + initHash_contains: Bytes + initHash_not_contains: Bytes + beneficiary: Bytes + beneficiary_not: Bytes + beneficiary_gt: Bytes + beneficiary_lt: Bytes + beneficiary_gte: Bytes + beneficiary_lte: Bytes + beneficiary_in: [Bytes!] + beneficiary_not_in: [Bytes!] + beneficiary_contains: Bytes + beneficiary_not_contains: Bytes + token: Bytes + token_not: Bytes + token_gt: Bytes + token_lt: Bytes + token_gte: Bytes + token_lte: Bytes + token_in: [Bytes!] + token_not_in: [Bytes!] + token_contains: Bytes + token_not_contains: Bytes + managedAmount: BigInt + managedAmount_not: BigInt + managedAmount_gt: BigInt + managedAmount_lt: BigInt + managedAmount_gte: BigInt + managedAmount_lte: BigInt + managedAmount_in: [BigInt!] + managedAmount_not_in: [BigInt!] + startTime: BigInt + startTime_not: BigInt + startTime_gt: BigInt + startTime_lt: BigInt + startTime_gte: BigInt + startTime_lte: BigInt + startTime_in: [BigInt!] + startTime_not_in: [BigInt!] + endTime: BigInt + endTime_not: BigInt + endTime_gt: BigInt + endTime_lt: BigInt + endTime_gte: BigInt + endTime_lte: BigInt + endTime_in: [BigInt!] + endTime_not_in: [BigInt!] + periods: BigInt + periods_not: BigInt + periods_gt: BigInt + periods_lt: BigInt + periods_gte: BigInt + periods_lte: BigInt + periods_in: [BigInt!] + periods_not_in: [BigInt!] + releaseStartTime: BigInt + releaseStartTime_not: BigInt + releaseStartTime_gt: BigInt + releaseStartTime_lt: BigInt + releaseStartTime_gte: BigInt + releaseStartTime_lte: BigInt + releaseStartTime_in: [BigInt!] + releaseStartTime_not_in: [BigInt!] + vestingCliffTime: BigInt + vestingCliffTime_not: BigInt + vestingCliffTime_gt: BigInt + vestingCliffTime_lt: BigInt + vestingCliffTime_gte: BigInt + vestingCliffTime_lte: BigInt + vestingCliffTime_in: [BigInt!] + vestingCliffTime_not_in: [BigInt!] + revocable: Revocability + revocable_not: Revocability + revocable_in: [Revocability!] + revocable_not_in: [Revocability!] + tokenDestinationsApproved: Boolean + tokenDestinationsApproved_not: Boolean + tokenDestinationsApproved_in: [Boolean!] + tokenDestinationsApproved_not_in: [Boolean!] + tokensReleased: BigInt + tokensReleased_not: BigInt + tokensReleased_gt: BigInt + tokensReleased_lt: BigInt + tokensReleased_gte: BigInt + tokensReleased_lte: BigInt + tokensReleased_in: [BigInt!] + tokensReleased_not_in: [BigInt!] + tokensWithdrawn: BigInt + tokensWithdrawn_not: BigInt + tokensWithdrawn_gt: BigInt + tokensWithdrawn_lt: BigInt + tokensWithdrawn_gte: BigInt + tokensWithdrawn_lte: BigInt + tokensWithdrawn_in: [BigInt!] + tokensWithdrawn_not_in: [BigInt!] + tokensRevoked: BigInt + tokensRevoked_not: BigInt + tokensRevoked_gt: BigInt + tokensRevoked_lt: BigInt + tokensRevoked_gte: BigInt + tokensRevoked_lte: BigInt + tokensRevoked_in: [BigInt!] + tokensRevoked_not_in: [BigInt!] + blockNumberCreated: BigInt + blockNumberCreated_not: BigInt + blockNumberCreated_gt: BigInt + blockNumberCreated_lt: BigInt + blockNumberCreated_gte: BigInt + blockNumberCreated_lte: BigInt + blockNumberCreated_in: [BigInt!] + blockNumberCreated_not_in: [BigInt!] + txHash: Bytes + txHash_not: Bytes + txHash_gt: Bytes + txHash_lt: Bytes + txHash_gte: Bytes + txHash_lte: Bytes + txHash_in: [Bytes!] + txHash_not_in: [Bytes!] + txHash_contains: Bytes + txHash_not_contains: Bytes + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [TokenLockWallet_filter] + or: [TokenLockWallet_filter] +} + +enum TokenLockWallet_orderBy { + id + manager + initHash + beneficiary + token + managedAmount + startTime + endTime + periods + releaseStartTime + vestingCliffTime + revocable + tokenDestinationsApproved + tokensReleased + tokensWithdrawn + tokensRevoked + blockNumberCreated + txHash +} + +""" +The Token manager data + +""" +type TokenManager { + """Token manager address""" + id: ID! + + """Master copy address""" + masterCopy: Bytes! + + """Tokens stored in manger through deposit or withdraw""" + tokens: BigInt! + + """List of addresses that are allowed to pull funds""" + tokenDestinations: [Bytes!] + + """List of function call authorizations""" + authorizedFunctions(skip: Int = 0, first: Int = 100, orderBy: AuthorizedFunction_orderBy, orderDirection: OrderDirection, where: AuthorizedFunction_filter): [AuthorizedFunction!] + + """Token lock count of contracts created""" + tokenLockCount: BigInt! +} + +input TokenManager_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + masterCopy: Bytes + masterCopy_not: Bytes + masterCopy_gt: Bytes + masterCopy_lt: Bytes + masterCopy_gte: Bytes + masterCopy_lte: Bytes + masterCopy_in: [Bytes!] + masterCopy_not_in: [Bytes!] + masterCopy_contains: Bytes + masterCopy_not_contains: Bytes + tokens: BigInt + tokens_not: BigInt + tokens_gt: BigInt + tokens_lt: BigInt + tokens_gte: BigInt + tokens_lte: BigInt + tokens_in: [BigInt!] + tokens_not_in: [BigInt!] + tokenDestinations: [Bytes!] + tokenDestinations_not: [Bytes!] + tokenDestinations_contains: [Bytes!] + tokenDestinations_contains_nocase: [Bytes!] + tokenDestinations_not_contains: [Bytes!] + tokenDestinations_not_contains_nocase: [Bytes!] + authorizedFunctions_: AuthorizedFunction_filter + tokenLockCount: BigInt + tokenLockCount_not: BigInt + tokenLockCount_gt: BigInt + tokenLockCount_lt: BigInt + tokenLockCount_gte: BigInt + tokenLockCount_lte: BigInt + tokenLockCount_in: [BigInt!] + tokenLockCount_not_in: [BigInt!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [TokenManager_filter] + or: [TokenManager_filter] +} + +enum TokenManager_orderBy { + id + masterCopy + tokens + tokenDestinations + authorizedFunctions + tokenLockCount +} + +""" +A generic transaction in The Graph Network + +""" +interface Transaction { + """Transaction hash concatenated with event log index""" + id: ID! + + """Block number for the transaction""" + blockNumber: Int! + + """Timestamp for the transaction""" + timestamp: Int! + + """Signer of the transaction""" + signer: GraphAccount! + + """Type of Graph Network transaction""" + type: TransactionType! +} + +input Transaction_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + blockNumber: Int + blockNumber_not: Int + blockNumber_gt: Int + blockNumber_lt: Int + blockNumber_gte: Int + blockNumber_lte: Int + blockNumber_in: [Int!] + blockNumber_not_in: [Int!] + timestamp: Int + timestamp_not: Int + timestamp_gt: Int + timestamp_lt: Int + timestamp_gte: Int + timestamp_lte: Int + timestamp_in: [Int!] + timestamp_not_in: [Int!] + signer: String + signer_not: String + signer_gt: String + signer_lt: String + signer_gte: String + signer_lte: String + signer_in: [String!] + signer_not_in: [String!] + signer_contains: String + signer_contains_nocase: String + signer_not_contains: String + signer_not_contains_nocase: String + signer_starts_with: String + signer_starts_with_nocase: String + signer_not_starts_with: String + signer_not_starts_with_nocase: String + signer_ends_with: String + signer_ends_with_nocase: String + signer_not_ends_with: String + signer_not_ends_with_nocase: String + signer_: GraphAccount_filter + type: TransactionType + type_not: TransactionType + type_in: [TransactionType!] + type_not_in: [TransactionType!] + + """Filter for the block changed event.""" + _change_block: BlockChangedFilter + and: [Transaction_filter] + or: [Transaction_filter] +} + +enum Transaction_orderBy { + id + blockNumber + timestamp + signer + signer__id + signer__createdAt + signer__defaultDisplayName + signer__balance + signer__balanceReceivedFromL1Signalling + signer__balanceReceivedFromL1Delegation + signer__curationApproval + signer__stakingApproval + signer__gnsApproval + signer__developerCreatedAt + signer__subgraphQueryFees + type +} + +enum TransactionType { + Stake + Unstake + MintSignal + BurnSignal + MintNSignal + BurnNSignal + BridgeWithdrawal + BridgeDeposit +} diff --git a/graphql/tap.schema.graphql b/graphql/tap.schema.graphql new file mode 100644 index 000000000..d68c793d6 --- /dev/null +++ b/graphql/tap.schema.graphql @@ -0,0 +1,990 @@ +""" +Marks the GraphQL type as indexable entity. Each type that should be an entity +is required to be annotated with this directive. +""" +directive @entity on OBJECT + +""" +Defined a Subgraph ID for an object type +""" +directive @subgraphId(id: String!) on OBJECT + +""" +creates a virtual field on the entity that may be queried but cannot be set manually through the mappings API. +""" +directive @derivedFrom(field: String!) on FIELD_DEFINITION + +type _Block_ { + """ + The hash of the block + """ + hash: Bytes + + """ + The block number + """ + number: Int! + + """ + Integer representation of the timestamp stored in blocks for the chain + """ + timestamp: Int + + """ + The hash of the parent block + """ + parentHash: Bytes +} + +""" +The type for the top-level _meta field +""" +type _Meta_ { + """ + Information about a specific subgraph block. The hash of the block + will be null if the _meta field has a block constraint that asks for + a block number. It will be filled if the _meta field has no block constraint + and therefore asks for the latest block + """ + block: _Block_! + + """ + The deployment ID + """ + deployment: String! + + """ + If `true`, the subgraph encountered indexing errors at some past block + """ + hasIndexingErrors: Boolean! +} + +enum _SubgraphErrorPolicy_ { + """ + Data will be returned even if the subgraph has indexing errors + """ + allow + + """ + If the subgraph has indexing errors, data will be omitted. The default. + """ + deny +} + +enum Aggregation_interval { + hour + day +} + +scalar BigDecimal + +scalar BigInt + +input Block_height { + hash: Bytes + number: Int + number_gte: Int +} + +input BlockChangedFilter { + number_gte: Int! +} + +scalar Bytes + +type EscrowAccount { + id: ID! + sender: Sender! + receiver: Receiver! + balance: BigInt! + totalAmountThawing: BigInt! + thawEndTimestamp: BigInt! + transactions( + skip: Int = 0 + first: Int = 100 + orderBy: Transaction_orderBy + orderDirection: OrderDirection + where: Transaction_filter + ): [Transaction!] +} + +input EscrowAccount_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + sender: String + sender_not: String + sender_gt: String + sender_lt: String + sender_gte: String + sender_lte: String + sender_in: [String!] + sender_not_in: [String!] + sender_contains: String + sender_contains_nocase: String + sender_not_contains: String + sender_not_contains_nocase: String + sender_starts_with: String + sender_starts_with_nocase: String + sender_not_starts_with: String + sender_not_starts_with_nocase: String + sender_ends_with: String + sender_ends_with_nocase: String + sender_not_ends_with: String + sender_not_ends_with_nocase: String + sender_: Sender_filter + receiver: String + receiver_not: String + receiver_gt: String + receiver_lt: String + receiver_gte: String + receiver_lte: String + receiver_in: [String!] + receiver_not_in: [String!] + receiver_contains: String + receiver_contains_nocase: String + receiver_not_contains: String + receiver_not_contains_nocase: String + receiver_starts_with: String + receiver_starts_with_nocase: String + receiver_not_starts_with: String + receiver_not_starts_with_nocase: String + receiver_ends_with: String + receiver_ends_with_nocase: String + receiver_not_ends_with: String + receiver_not_ends_with_nocase: String + receiver_: Receiver_filter + balance: BigInt + balance_not: BigInt + balance_gt: BigInt + balance_lt: BigInt + balance_gte: BigInt + balance_lte: BigInt + balance_in: [BigInt!] + balance_not_in: [BigInt!] + totalAmountThawing: BigInt + totalAmountThawing_not: BigInt + totalAmountThawing_gt: BigInt + totalAmountThawing_lt: BigInt + totalAmountThawing_gte: BigInt + totalAmountThawing_lte: BigInt + totalAmountThawing_in: [BigInt!] + totalAmountThawing_not_in: [BigInt!] + thawEndTimestamp: BigInt + thawEndTimestamp_not: BigInt + thawEndTimestamp_gt: BigInt + thawEndTimestamp_lt: BigInt + thawEndTimestamp_gte: BigInt + thawEndTimestamp_lte: BigInt + thawEndTimestamp_in: [BigInt!] + thawEndTimestamp_not_in: [BigInt!] + transactions_: Transaction_filter + + """ + Filter for the block changed event. + """ + _change_block: BlockChangedFilter + and: [EscrowAccount_filter] + or: [EscrowAccount_filter] +} + +enum EscrowAccount_orderBy { + id + sender + sender__id + receiver + receiver__id + balance + totalAmountThawing + thawEndTimestamp + transactions +} + +""" +8 bytes signed integer +""" +scalar Int8 + +""" +Defines the order direction, either ascending or descending +""" +enum OrderDirection { + asc + desc +} + +type Query { + escrowAccount( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): EscrowAccount + escrowAccounts( + skip: Int = 0 + first: Int = 100 + orderBy: EscrowAccount_orderBy + orderDirection: OrderDirection + where: EscrowAccount_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [EscrowAccount!]! + sender( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Sender + senders( + skip: Int = 0 + first: Int = 100 + orderBy: Sender_orderBy + orderDirection: OrderDirection + where: Sender_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Sender!]! + receiver( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Receiver + receivers( + skip: Int = 0 + first: Int = 100 + orderBy: Receiver_orderBy + orderDirection: OrderDirection + where: Receiver_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Receiver!]! + transaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Transaction + transactions( + skip: Int = 0 + first: Int = 100 + orderBy: Transaction_orderBy + orderDirection: OrderDirection + where: Transaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Transaction!]! + signer( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Signer + signers( + skip: Int = 0 + first: Int = 100 + orderBy: Signer_orderBy + orderDirection: OrderDirection + where: Signer_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Signer!]! + + """ + Access to subgraph metadata + """ + _meta(block: Block_height): _Meta_ +} + +type Receiver { + id: ID! + escrowAccounts( + skip: Int = 0 + first: Int = 100 + orderBy: EscrowAccount_orderBy + orderDirection: OrderDirection + where: EscrowAccount_filter + ): [EscrowAccount!] + transactions( + skip: Int = 0 + first: Int = 100 + orderBy: Transaction_orderBy + orderDirection: OrderDirection + where: Transaction_filter + ): [Transaction!] +} + +input Receiver_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + escrowAccounts_: EscrowAccount_filter + transactions_: Transaction_filter + + """ + Filter for the block changed event. + """ + _change_block: BlockChangedFilter + and: [Receiver_filter] + or: [Receiver_filter] +} + +enum Receiver_orderBy { + id + escrowAccounts + transactions +} + +type Sender { + id: ID! + escrowAccounts( + skip: Int = 0 + first: Int = 100 + orderBy: EscrowAccount_orderBy + orderDirection: OrderDirection + where: EscrowAccount_filter + ): [EscrowAccount!] + transactions( + skip: Int = 0 + first: Int = 100 + orderBy: Transaction_orderBy + orderDirection: OrderDirection + where: Transaction_filter + ): [Transaction!] + signers( + skip: Int = 0 + first: Int = 100 + orderBy: Signer_orderBy + orderDirection: OrderDirection + where: Signer_filter + ): [Signer!] +} + +input Sender_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + escrowAccounts_: EscrowAccount_filter + transactions_: Transaction_filter + signers_: Signer_filter + + """ + Filter for the block changed event. + """ + _change_block: BlockChangedFilter + and: [Sender_filter] + or: [Sender_filter] +} + +enum Sender_orderBy { + id + escrowAccounts + transactions + signers +} + +type Signer { + id: ID! + isAuthorized: Boolean! + sender: Sender! + thawEndTimestamp: BigInt! +} + +input Signer_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + isAuthorized: Boolean + isAuthorized_not: Boolean + isAuthorized_in: [Boolean!] + isAuthorized_not_in: [Boolean!] + sender: String + sender_not: String + sender_gt: String + sender_lt: String + sender_gte: String + sender_lte: String + sender_in: [String!] + sender_not_in: [String!] + sender_contains: String + sender_contains_nocase: String + sender_not_contains: String + sender_not_contains_nocase: String + sender_starts_with: String + sender_starts_with_nocase: String + sender_not_starts_with: String + sender_not_starts_with_nocase: String + sender_ends_with: String + sender_ends_with_nocase: String + sender_not_ends_with: String + sender_not_ends_with_nocase: String + sender_: Sender_filter + thawEndTimestamp: BigInt + thawEndTimestamp_not: BigInt + thawEndTimestamp_gt: BigInt + thawEndTimestamp_lt: BigInt + thawEndTimestamp_gte: BigInt + thawEndTimestamp_lte: BigInt + thawEndTimestamp_in: [BigInt!] + thawEndTimestamp_not_in: [BigInt!] + + """ + Filter for the block changed event. + """ + _change_block: BlockChangedFilter + and: [Signer_filter] + or: [Signer_filter] +} + +enum Signer_orderBy { + id + isAuthorized + sender + sender__id + thawEndTimestamp +} + +type Subscription { + escrowAccount( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): EscrowAccount + escrowAccounts( + skip: Int = 0 + first: Int = 100 + orderBy: EscrowAccount_orderBy + orderDirection: OrderDirection + where: EscrowAccount_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [EscrowAccount!]! + sender( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Sender + senders( + skip: Int = 0 + first: Int = 100 + orderBy: Sender_orderBy + orderDirection: OrderDirection + where: Sender_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Sender!]! + receiver( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Receiver + receivers( + skip: Int = 0 + first: Int = 100 + orderBy: Receiver_orderBy + orderDirection: OrderDirection + where: Receiver_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Receiver!]! + transaction( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Transaction + transactions( + skip: Int = 0 + first: Int = 100 + orderBy: Transaction_orderBy + orderDirection: OrderDirection + where: Transaction_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Transaction!]! + signer( + id: ID! + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): Signer + signers( + skip: Int = 0 + first: Int = 100 + orderBy: Signer_orderBy + orderDirection: OrderDirection + where: Signer_filter + + """ + The block at which the query should be executed. Can either be a `{ hash: + Bytes }` value containing a block hash, a `{ number: Int }` containing the + block number, or a `{ number_gte: Int }` containing the minimum block + number. In the case of `number_gte`, the query will be executed on the + latest block only if the subgraph has progressed to or past the minimum + block number. Defaults to the latest block when omitted. + """ + block: Block_height + + """ + Set to `allow` to receive data even if the subgraph has skipped over errors while syncing. + """ + subgraphError: _SubgraphErrorPolicy_! = deny + ): [Signer!]! + + """ + Access to subgraph metadata + """ + _meta(block: Block_height): _Meta_ +} + +""" +A string representation of microseconds UNIX timestamp (16 digits) +""" +scalar Timestamp + +type Transaction { + id: ID! + transactionGroupID: String! + type: String! + sender: Sender! + receiver: Receiver! + allocationID: String + expectedAmount: BigInt + amount: BigInt! + escrowAccount: EscrowAccount! +} + +input Transaction_filter { + id: ID + id_not: ID + id_gt: ID + id_lt: ID + id_gte: ID + id_lte: ID + id_in: [ID!] + id_not_in: [ID!] + transactionGroupID: String + transactionGroupID_not: String + transactionGroupID_gt: String + transactionGroupID_lt: String + transactionGroupID_gte: String + transactionGroupID_lte: String + transactionGroupID_in: [String!] + transactionGroupID_not_in: [String!] + transactionGroupID_contains: String + transactionGroupID_contains_nocase: String + transactionGroupID_not_contains: String + transactionGroupID_not_contains_nocase: String + transactionGroupID_starts_with: String + transactionGroupID_starts_with_nocase: String + transactionGroupID_not_starts_with: String + transactionGroupID_not_starts_with_nocase: String + transactionGroupID_ends_with: String + transactionGroupID_ends_with_nocase: String + transactionGroupID_not_ends_with: String + transactionGroupID_not_ends_with_nocase: String + type: String + type_not: String + type_gt: String + type_lt: String + type_gte: String + type_lte: String + type_in: [String!] + type_not_in: [String!] + type_contains: String + type_contains_nocase: String + type_not_contains: String + type_not_contains_nocase: String + type_starts_with: String + type_starts_with_nocase: String + type_not_starts_with: String + type_not_starts_with_nocase: String + type_ends_with: String + type_ends_with_nocase: String + type_not_ends_with: String + type_not_ends_with_nocase: String + sender: String + sender_not: String + sender_gt: String + sender_lt: String + sender_gte: String + sender_lte: String + sender_in: [String!] + sender_not_in: [String!] + sender_contains: String + sender_contains_nocase: String + sender_not_contains: String + sender_not_contains_nocase: String + sender_starts_with: String + sender_starts_with_nocase: String + sender_not_starts_with: String + sender_not_starts_with_nocase: String + sender_ends_with: String + sender_ends_with_nocase: String + sender_not_ends_with: String + sender_not_ends_with_nocase: String + sender_: Sender_filter + receiver: String + receiver_not: String + receiver_gt: String + receiver_lt: String + receiver_gte: String + receiver_lte: String + receiver_in: [String!] + receiver_not_in: [String!] + receiver_contains: String + receiver_contains_nocase: String + receiver_not_contains: String + receiver_not_contains_nocase: String + receiver_starts_with: String + receiver_starts_with_nocase: String + receiver_not_starts_with: String + receiver_not_starts_with_nocase: String + receiver_ends_with: String + receiver_ends_with_nocase: String + receiver_not_ends_with: String + receiver_not_ends_with_nocase: String + receiver_: Receiver_filter + allocationID: String + allocationID_not: String + allocationID_gt: String + allocationID_lt: String + allocationID_gte: String + allocationID_lte: String + allocationID_in: [String!] + allocationID_not_in: [String!] + allocationID_contains: String + allocationID_contains_nocase: String + allocationID_not_contains: String + allocationID_not_contains_nocase: String + allocationID_starts_with: String + allocationID_starts_with_nocase: String + allocationID_not_starts_with: String + allocationID_not_starts_with_nocase: String + allocationID_ends_with: String + allocationID_ends_with_nocase: String + allocationID_not_ends_with: String + allocationID_not_ends_with_nocase: String + expectedAmount: BigInt + expectedAmount_not: BigInt + expectedAmount_gt: BigInt + expectedAmount_lt: BigInt + expectedAmount_gte: BigInt + expectedAmount_lte: BigInt + expectedAmount_in: [BigInt!] + expectedAmount_not_in: [BigInt!] + amount: BigInt + amount_not: BigInt + amount_gt: BigInt + amount_lt: BigInt + amount_gte: BigInt + amount_lte: BigInt + amount_in: [BigInt!] + amount_not_in: [BigInt!] + escrowAccount: String + escrowAccount_not: String + escrowAccount_gt: String + escrowAccount_lt: String + escrowAccount_gte: String + escrowAccount_lte: String + escrowAccount_in: [String!] + escrowAccount_not_in: [String!] + escrowAccount_contains: String + escrowAccount_contains_nocase: String + escrowAccount_not_contains: String + escrowAccount_not_contains_nocase: String + escrowAccount_starts_with: String + escrowAccount_starts_with_nocase: String + escrowAccount_not_starts_with: String + escrowAccount_not_starts_with_nocase: String + escrowAccount_ends_with: String + escrowAccount_ends_with_nocase: String + escrowAccount_not_ends_with: String + escrowAccount_not_ends_with_nocase: String + escrowAccount_: EscrowAccount_filter + + """ + Filter for the block changed event. + """ + _change_block: BlockChangedFilter + and: [Transaction_filter] + or: [Transaction_filter] +} + +enum Transaction_orderBy { + id + transactionGroupID + type + sender + sender__id + receiver + receiver__id + allocationID + expectedAmount + amount + escrowAccount + escrowAccount__id + escrowAccount__balance + escrowAccount__totalAmountThawing + escrowAccount__thawEndTimestamp +} diff --git a/graphql/test.schema.graphql b/graphql/test.schema.graphql new file mode 100644 index 000000000..acfa70414 --- /dev/null +++ b/graphql/test.schema.graphql @@ -0,0 +1,7 @@ +type User { + name: String! +} + +type Query { + user(id: Int!): User! +} diff --git a/graphql/transactions.query.graphql b/graphql/transactions.query.graphql new file mode 100644 index 000000000..607628e98 --- /dev/null +++ b/graphql/transactions.query.graphql @@ -0,0 +1,19 @@ +query TapTransactions( + $sender_id: ID! + $receiver_id: ID! + $allocation_id: ID! +) { + transactions( + where: { + and: [ + { type: "redeem" } + { sender_: { id: $sender_id } } + { receiver_: { id: $receiver_id } } + { allocationID: $allocation_id } + ] + } + ) { + id + } +} + diff --git a/graphql/unfinalized_tx.query.graphql b/graphql/unfinalized_tx.query.graphql new file mode 100644 index 000000000..1f3bfaaf1 --- /dev/null +++ b/graphql/unfinalized_tx.query.graphql @@ -0,0 +1,14 @@ +query UnfinalizedTransactions( + $unfinalizedRavsAllocationIds: [ID!]! + $sender: ID! +) { + transactions( + where: { + type: "redeem" + allocationID_in: $unfinalizedRavsAllocationIds + sender_: { id: $sender } + } + ) { + allocationID + } +} diff --git a/graphql/user.query.graphql b/graphql/user.query.graphql new file mode 100644 index 000000000..837b52a6f --- /dev/null +++ b/graphql/user.query.graphql @@ -0,0 +1,5 @@ +query UserQuery { + user(id: 1) { + name + } +} diff --git a/tap-agent/Cargo.toml b/tap-agent/Cargo.toml index eaf318426..3a117bba3 100644 --- a/tap-agent/Cargo.toml +++ b/tap-agent/Cargo.toml @@ -30,6 +30,8 @@ thegraph-core.workspace = true clap.workspace = true tracing-subscriber.workspace = true bigdecimal = { workspace = true, features = ["serde"] } +graphql_client.workspace = true + ruint = { version = "1.12.3", features = [ "num-traits", ], default-features = false } diff --git a/tap-agent/src/agent/sender_account.rs b/tap-agent/src/agent/sender_account.rs index 390af48df..46e900800 100644 --- a/tap-agent/src/agent/sender_account.rs +++ b/tap-agent/src/agent/sender_account.rs @@ -5,6 +5,7 @@ use alloy::hex::ToHexExt; use alloy::primitives::U256; use bigdecimal::num_bigint::ToBigInt; use bigdecimal::ToPrimitive; +use graphql_client::GraphQLQuery; use prometheus::{register_gauge_vec, register_int_gauge_vec, GaugeVec, IntGaugeVec}; use std::collections::{HashMap, HashSet}; use std::str::FromStr; @@ -14,10 +15,8 @@ use tokio::task::JoinHandle; use alloy::dyn_abi::Eip712Domain; use anyhow::Result; use eventuals::{Eventual, EventualExt, PipeHandle}; -use indexer_common::subgraph_client::Query; use indexer_common::{escrow_accounts::EscrowAccounts, prelude::SubgraphClient}; use ractor::{call, Actor, ActorProcessingErr, ActorRef, MessagingErr, SupervisionEvent}; -use serde::Deserialize; use sqlx::PgPool; use tap_core::rav::SignedRAV; use thegraph_core::Address; @@ -299,6 +298,15 @@ impl State { } } +#[derive(GraphQLQuery)] +#[graphql( + schema_path = "../graphql/tap.schema.graphql", + query_path = "../graphql/unfinalized_tx.query.graphql", + response_derives = "Debug", + variables_derives = "Clone" +)] +struct UnfinalizedTransactions; + #[async_trait::async_trait] impl Actor for SenderAccount { type Msg = SenderAccountMessage; @@ -349,17 +357,6 @@ impl Actor for SenderAccount { .get_balance_for_sender(&sender_id) .unwrap_or_default(); - #[derive(Deserialize)] - struct Transaction { - #[serde(rename = "allocationID")] - allocation_id: String, - } - - #[derive(Deserialize)] - struct Response { - transactions: Vec, - } - async move { let last_non_final_ravs = sqlx::query!( r#" @@ -373,45 +370,24 @@ impl Actor for SenderAccount { .await .expect("Should not fail to fetch from scalar_tap_ravs"); - let query = r#" - query transactions( - $unfinalizedRavsAllocationIds: [String!]! - $sender: String! - ) { - transactions( - where: { - type: "redeem" - allocationID_in: $unfinalizedRavsAllocationIds - sender_: { id: $sender } - } - ) { - allocationID - } - } - "#; - // get a list from the subgraph of which subgraphs were already redeemed and were not marked as final let redeemed_ravs_allocation_ids = match escrow_subgraph - .query::(Query::new_with_variables( - query, - [ - ( - "unfinalizedRavsAllocationIds", - last_non_final_ravs - .iter() - .map(|rav| rav.allocation_id.to_string()) - .collect::>() - .into(), - ), - ("sender", format!("{:x?}", sender_id).into()), - ], - )) + .query::(unfinalized_transactions::Variables { + unfinalized_ravs_allocation_ids: last_non_final_ravs + .iter() + .map(|rav| rav.allocation_id.to_string()) + .collect::>(), + sender: format!("{:x?}", sender_id), + }) .await { Ok(Ok(response)) => response .transactions .into_iter() - .map(|tx| tx.allocation_id) + .map(|tx| { + tx.allocation_id + .expect("all redeem tx must have allocation_id") + }) .collect::>(), // if we have any problems, we don't want to filter out _ => vec![], diff --git a/tap-agent/src/tap/context/checks/allocation_id.rs b/tap-agent/src/tap/context/checks/allocation_id.rs index bc041b350..62d608598 100644 --- a/tap-agent/src/tap/context/checks/allocation_id.rs +++ b/tap-agent/src/tap/context/checks/allocation_id.rs @@ -6,7 +6,8 @@ use std::time::Duration; use alloy::primitives::Address; use anyhow::anyhow; use eventuals::{Eventual, EventualExt}; -use indexer_common::subgraph_client::{Query, SubgraphClient}; +use graphql_client::GraphQLQuery; +use indexer_common::subgraph_client::SubgraphClient; use tap_core::receipt::{ checks::{Check, CheckError, CheckResult}, state::Checking, @@ -98,59 +99,27 @@ fn tap_allocation_redeemed_eventual( ) } +#[derive(GraphQLQuery)] +#[graphql( + schema_path = "../graphql/tap.schema.graphql", + query_path = "../graphql/transactions.query.graphql", + response_derives = "Debug", + variables_derives = "Clone" +)] +struct TapTransactions; + async fn query_escrow_check_transactions( allocation_id: Address, sender_address: Address, indexer_address: Address, escrow_subgraph: &'static SubgraphClient, ) -> anyhow::Result { - #[derive(serde::Deserialize)] - struct AllocationResponse { - #[allow(dead_code)] - id: String, - } - - #[derive(serde::Deserialize)] - struct TransactionsResponse { - transactions: Vec, - } let response = escrow_subgraph - .query::(Query::new_with_variables( - r#" - query ( - $sender_id: ID!, - $receiver_id: ID!, - $allocation_id: String! - ) { - transactions( - where: { - and: [ - { type: "redeem" } - { sender_: { id: $sender_id } } - { receiver_: { id: $receiver_id } } - { allocationID: $allocation_id } - ] - } - ) { - id - } - } - "#, - [ - ( - "sender_id", - sender_address.to_string().to_lowercase().into(), - ), - ( - "receiver_id", - indexer_address.to_string().to_lowercase().into(), - ), - ( - "allocation_id", - allocation_id.to_string().to_lowercase().into(), - ), - ], - )) + .query::(tap_transactions::Variables { + sender_id: sender_address.to_string().to_lowercase(), + receiver_id: indexer_address.to_string().to_lowercase(), + allocation_id: allocation_id.to_string().to_lowercase(), + }) .await?; response