graph,runtime: Parse Block handler data type from the manifest

Author: fordN

core/src/subgraph/instance_manager.rs

@@ -879,7 +879,7 @@ async fn process_triggers<B: BlockStreamBuilder, T: RuntimeHostBuilder, S: Send
     mut block_state: BlockState,
     proof_of_indexing: SharedProofOfIndexing,
     ctx: IndexingContext<B, T, S>,
-    block: &Arc<LightEthereumBlock>,
+    block: &Arc<EthereumBlock>,
     triggers: Vec<EthereumTrigger>,
 ) -> Result<(IndexingContext<B, T, S>, BlockState), CancelableError<Error>> {
     for trigger in triggers.into_iter() {

graph/src/components/ethereum/adapter.rs

@@ -14,6 +14,7 @@ use web3::types::*;
 
 use super::types::*;
 use crate::components::metrics::{CounterVec, GaugeVec, HistogramVec};
+use crate::data::subgraph::BlockHandlerData;
 use crate::prelude::*;
 
 pub type EventSignature = H256;
@@ -422,8 +423,7 @@ impl EthereumBlockFilter {
                 let has_block_handler_with_call_filter = data_source
                     .mapping
                     .block_handlers
-                    .clone()
-                    .into_iter()
+                    .iter()
                     .any(|block_handler| match block_handler.filter {
                         Some(ref filter) if *filter == BlockHandlerFilter::Call => return true,
                         _ => return false,
@@ -432,14 +432,21 @@ impl EthereumBlockFilter {
                 let has_block_handler_without_filter = data_source
                     .mapping
                     .block_handlers
-                    .clone()
-                    .into_iter()
+                    .iter()
                     .any(|block_handler| block_handler.filter.is_none());
 
-                // TODO: process data source to get full_block boolean
+                let has_block_handler_with_fullblock = data_source
+                    .mapping
+                    .block_handlers
+                    .iter()
+                    .any(|block_handler| match block_handler.input {
+                        BlockHandlerData::FullBlock => return true,
+                        _ => return false,
+                    });
+
                 filter_opt.extend(Self {
                     trigger_every_block: has_block_handler_without_filter,
-                    full_block: true,
+                    full_block: has_block_handler_with_fullblock,
                     contract_addresses: if has_block_handler_with_call_filter {
                         vec![(
                             data_source.source.start_block,

graph/src/data/subgraph/mod.rs

@@ -22,10 +22,10 @@ use crate::data::query::QueryExecutionError;
 use crate::data::schema::{Schema, SchemaImportError, SchemaValidationError};
 use crate::data::store::Entity;
 use crate::data::subgraph::schema::{
-    EthereumBlockHandlerEntity, EthereumCallHandlerEntity, EthereumContractAbiEntity,
-    EthereumContractDataSourceTemplateEntity, EthereumContractDataSourceTemplateSourceEntity,
-    EthereumContractEventHandlerEntity, EthereumContractMappingEntity,
-    EthereumContractSourceEntity, SUBGRAPHS_ID,
+    EthereumBlockHandlerData, EthereumBlockHandlerEntity, EthereumCallHandlerEntity,
+    EthereumContractAbiEntity, EthereumContractDataSourceTemplateEntity,
+    EthereumContractDataSourceTemplateSourceEntity, EthereumContractEventHandlerEntity,
+    EthereumContractMappingEntity, EthereumContractSourceEntity, SUBGRAPHS_ID,
 };
 use crate::prelude::{
     anyhow::{self, Context},
@@ -515,6 +515,22 @@ impl UnresolvedMappingABI {
 pub struct MappingBlockHandler {
     pub handler: String,
     pub filter: Option<BlockHandlerFilter>,
+    pub input: BlockHandlerData,
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
+pub enum BlockHandlerData {
+    Block,
+    FullBlock,
+}
+
+impl From<EthereumBlockHandlerData> for BlockHandlerData {
+    fn from(data: EthereumBlockHandlerData) -> Self {
+        match data {
+            EthereumBlockHandlerData::FullBlock => BlockHandlerData::FullBlock,
+            _ => BlockHandlerData::Block,
+        }
+    }
 }
 
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
@@ -530,6 +546,7 @@ impl From<EthereumBlockHandlerEntity> for MappingBlockHandler {
         Self {
             handler: entity.handler,
             filter: None,
+            input: BlockHandlerData::from(entity.input),
         }
     }
 }

graph/src/data/subgraph/schema.rs

@@ -1009,6 +1009,7 @@ impl TryFromValue for EthereumContractAbiEntity {
 pub struct EthereumBlockHandlerEntity {
     pub handler: String,
     pub filter: Option<EthereumBlockHandlerFilterEntity>,
+    pub input: EthereumBlockHandlerData,
 }
 
 impl WriteOperations for EthereumBlockHandlerEntity {
@@ -1025,6 +1026,7 @@ impl WriteOperations for EthereumBlockHandlerEntity {
         if let Some(filter_id) = filter_id {
             entity.set("filter", filter_id);
         }
+        entity.set("data", String::from(self.input));
         ops.add(Self::TYPENAME, id.to_owned(), entity);
     }
 }
@@ -1048,6 +1050,7 @@ impl From<super::MappingBlockHandler> for EthereumBlockHandlerEntity {
         EthereumBlockHandlerEntity {
             handler: block_handler.handler,
             filter,
+            input: EthereumBlockHandlerData::from(block_handler.input),
         }
     }
 }
@@ -1065,6 +1068,7 @@ impl TryFromValue for EthereumBlockHandlerEntity {
         Ok(EthereumBlockHandlerEntity {
             handler: map.get_required("handler")?,
             filter: map.get_optional("filter")?,
+            input: map.get_optional("input")?.unwrap_or_default(),
         })
     }
 }
@@ -1106,6 +1110,69 @@ impl TryFromValue for EthereumBlockHandlerFilterEntity {
     }
 }
 
+#[derive(Debug, PartialEq)]
+pub enum EthereumBlockHandlerData {
+    Block,
+    FullBlock,
+}
+
+impl Default for EthereumBlockHandlerData {
+    fn default() -> EthereumBlockHandlerData {
+        EthereumBlockHandlerData::Block
+    }
+}
+
+impl FromStr for EthereumBlockHandlerData {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<EthereumBlockHandlerData, Error> {
+        match s {
+            "FullBlock" => Ok(EthereumBlockHandlerData::FullBlock),
+            "Block" => Ok(EthereumBlockHandlerData::Block),
+            _ => Err(format_err!(
+                "failed to parse `{}` as EthereumBlockHandlerData",
+                s
+            )),
+        }
+    }
+}
+
+impl From<EthereumBlockHandlerData> for String {
+    fn from(data: EthereumBlockHandlerData) -> String {
+        match data {
+            EthereumBlockHandlerData::FullBlock => "FullBlock".into(),
+            EthereumBlockHandlerData::Block => "Block".into(),
+        }
+    }
+}
+
+impl From<super::BlockHandlerData> for EthereumBlockHandlerData {
+    fn from(data: BlockHandlerData) -> Self {
+        match data {
+            BlockHandlerData::FullBlock => EthereumBlockHandlerData::FullBlock,
+            _ => EthereumBlockHandlerData::Block,
+        }
+    }
+}
+
+impl From<EthereumBlockHandlerData> for q::Value {
+    fn from(data: EthereumBlockHandlerData) -> q::Value {
+        q::Value::Enum(data.into())
+    }
+}
+
+impl TryFromValue for EthereumBlockHandlerData {
+    fn try_from_value(value: &q::Value) -> Result<EthereumBlockHandlerData, Error> {
+        match value {
+            q::Value::Enum(data) => EthereumBlockHandlerData::from_str(data),
+            _ => Err(format_err!(
+                "cannot parse value as EthereumBlockHandlerData: `{:?}`",
+                value
+            )),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct EthereumCallHandlerEntity {
     pub function: String,

graph/src/lib.rs

@@ -126,7 +126,7 @@ pub mod prelude {
     };
     pub use crate::data::subgraph::schema::{SubgraphDeploymentEntity, TypedEntity};
     pub use crate::data::subgraph::{
-        BlockHandlerFilter, CreateSubgraphResult, DataSource, DataSourceContext,
+        BlockHandlerData, BlockHandlerFilter, CreateSubgraphResult, DataSource, DataSourceContext,
         DataSourceTemplate, Link, MappingABI, MappingBlockHandler, MappingCallHandler,
         MappingEventHandler, SubgraphAssignmentProviderError, SubgraphAssignmentProviderEvent,
         SubgraphDeploymentId, SubgraphManifest, SubgraphManifestResolveError,

runtime/wasm/src/host.rs

@@ -576,7 +576,7 @@ impl RuntimeHostTrait for RuntimeHost {
         proof_of_indexing: SharedProofOfIndexing,
     ) -> Result<BlockState, anyhow::Error> {
         let block_handler = self.handler_for_block(trigger_type)?;
-        let theblock: EthereumBlockType = match trigger_type {
+        let theblock: EthereumBlockType = match dbg!(trigger_type) {
             EthereumBlockTriggerType::Every(BlockType::Full) => match graph::block_on_allow_panic(
                 future::lazy(move || {
                     self.host_exports
@@ -585,7 +585,7 @@ impl RuntimeHostTrait for RuntimeHost {
                 })
                 .compat(),
             ) {
-                Ok(block) => Ok(EthereumBlockType::Full(block)),
+                Ok(block) => Ok(EthereumBlockType::Full(dbg!(block))),
                 Err(e) => Err(anyhow::anyhow!(
                     "Failed to load full block: {}, error: {}",
                     &block.number.unwrap().to_string(),
@@ -606,7 +606,7 @@ impl RuntimeHostTrait for RuntimeHost {
             MappingTrigger::Block {
                 handler: block_handler.clone(),
             },
-            &Arc::new(theblock),
+            &Arc::new(dbg!(theblock)),
             proof_of_indexing,
         )
         .await