Report nondeterministic errors as unattestable (#2946)

This change sets the Graph-Attestable header on query results to signal
to the indexer-service whether it should include an attestation for the
client. Unattestable responses are those that are nondeterministic,
according to [GIP 20](https://hackmd.io/@CGmldHLrTRaYRnAva-HoPQ/S1W2vMjEt).

Author: Theodus

graph/src/data/query/error.rs

@@ -83,6 +83,63 @@ pub enum QueryExecutionError {
     ResultTooBig(usize, usize),
 }
 
+impl QueryExecutionError {
+    pub fn is_attestable(&self) -> bool {
+        use self::QueryExecutionError::*;
+        match self {
+            OperationNameRequired
+            | OperationNotFound(_)
+            | NotSupported(_)
+            | NoRootSubscriptionObjectType
+            | NamedTypeError(_)
+            | AbstractTypeError(_)
+            | InvalidArgumentError(_, _, _)
+            | MissingArgumentError(_, _)
+            | InvalidVariableTypeError(_, _)
+            | MissingVariableError(_, _)
+            | OrderByNotSupportedError(_, _)
+            | OrderByNotSupportedForType(_)
+            | FilterNotSupportedError(_, _)
+            | UnknownField(_, _, _)
+            | EmptyQuery
+            | MultipleSubscriptionFields
+            | SubgraphDeploymentIdError(_)
+            | InvalidFilterError
+            | EntityFieldError(_, _)
+            | ListTypesError(_, _)
+            | ListFilterError(_)
+            | AttributeTypeError(_, _)
+            | EmptySelectionSet(_)
+            | Unimplemented(_)
+            | CyclicalFragment(_)
+            | UndefinedFragment(_)
+            | FulltextQueryRequiresFilter => true,
+            NonNullError(_, _)
+            | ListValueError(_, _)
+            | ResolveEntitiesError(_)
+            | RangeArgumentsError(_, _, _)
+            | ValueParseError(_, _)
+            | EntityParseError(_)
+            | StoreError(_)
+            | Timeout
+            | EnumCoercionError(_, _, _, _, _)
+            | ScalarCoercionError(_, _, _, _)
+            | AmbiguousDerivedFromResult(_, _, _, _)
+            | TooComplex(_, _)
+            | TooDeep(_)
+            | IncorrectPrefetchResult { .. }
+            | Panic(_)
+            | EventStreamError
+            | TooExpensive
+            | Throttled
+            | DeploymentReverted
+            | SubgraphManifestResolveError(_)
+            | InvalidSubgraphManifest
+            | ResultTooBig(_, _) => false,
+        }
+    }
+}
+
 impl Error for QueryExecutionError {
     fn description(&self) -> &str {
         "Query execution error"
@@ -217,7 +274,7 @@ impl fmt::Display for QueryExecutionError {
             EventStreamError => write!(f, "error in the subscription event stream"),
             FulltextQueryRequiresFilter => write!(f, "fulltext search queries can only use EntityFilter::Equal"),
             TooExpensive => write!(f, "query is too expensive"),
-            Throttled=> write!(f, "service is overloaded and can not run the query right now. Please try again in a few minutes"),
+            Throttled => write!(f, "service is overloaded and can not run the query right now. Please try again in a few minutes"),
             DeploymentReverted => write!(f, "the chain was reorganized while executing the query"),
             SubgraphManifestResolveError(e) => write!(f, "failed to resolve subgraph manifest: {}", e),
             InvalidSubgraphManifest => write!(f, "invalid subgraph manifest file"),
@@ -271,6 +328,16 @@ pub enum QueryError {
     IndexingError,
 }
 
+impl QueryError {
+    pub fn is_attestable(&self) -> bool {
+        match self {
+            QueryError::EncodingError(_) | QueryError::ParseError(_) => true,
+            QueryError::ExecutionError(err) => err.is_attestable(),
+            QueryError::IndexingError => false,
+        }
+    }
+}
+
 impl From<FromUtf8Error> for QueryError {
     fn from(e: FromUtf8Error) -> Self {
         QueryError::EncodingError(e)

graph/src/data/query/result.rs

@@ -163,6 +163,10 @@ impl QueryResults {
             .header(ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type, User-Agent")
             .header(ACCESS_CONTROL_ALLOW_METHODS, "GET, OPTIONS, POST")
             .header(CONTENT_TYPE, "application/json")
+            .header(
+                "Graph-Attestable",
+                self.results.iter().all(|r| r.is_attestable()).to_string(),
+            )
             .body(T::from(json))
             .unwrap()
     }
@@ -211,6 +215,10 @@ impl QueryResult {
         self.data.is_some()
     }
 
+    pub fn is_attestable(&self) -> bool {
+        self.errors.iter().all(|err| err.is_attestable())
+    }
+
     pub fn to_result(self) -> Result<Option<r::Value>, Vec<QueryError>> {
         if self.has_errors() {
             Err(self.errors)