feat(starknet): data source validation

Author: xJonathanLEI

chain/starknet/src/chain.rs

@@ -425,3 +425,75 @@ impl TriggersAdapterTrait<Chain> for TriggersAdapter {
         }))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use graph::blockchain::DataSource as _;
+
+    use crate::{
+        data_source::{
+            DataSource, Mapping, MappingBlockHandler, MappingEventHandler, STARKNET_KIND,
+        },
+        felt::Felt,
+    };
+
+    #[test]
+    fn validate_no_handler() {
+        let ds = new_data_source(None);
+
+        let errs = ds.validate();
+        assert_eq!(errs.len(), 1, "{:?}", ds);
+        assert_eq!(
+            errs[0].to_string(),
+            "data source does not define any handler"
+        );
+    }
+
+    #[test]
+    fn validate_address_without_event_handler() {
+        let mut ds = new_data_source(Some([1u8; 32].into()));
+        ds.mapping.block_handler = Some(MappingBlockHandler {
+            handler: "asdf".into(),
+        });
+
+        let errs = ds.validate();
+        assert_eq!(errs.len(), 1, "{:?}", ds);
+        assert_eq!(
+            errs[0].to_string(),
+            "data source cannot have source address without event handlers"
+        );
+    }
+
+    #[test]
+    fn validate_no_address_with_event_handler() {
+        let mut ds = new_data_source(None);
+        ds.mapping.event_handlers.push(MappingEventHandler {
+            handler: "asdf".into(),
+            event_selector: [2u8; 32].into(),
+        });
+
+        let errs = ds.validate();
+        assert_eq!(errs.len(), 1, "{:?}", ds);
+        assert_eq!(errs[0].to_string(), "subgraph source address is required");
+    }
+
+    fn new_data_source(address: Option<Felt>) -> DataSource {
+        DataSource {
+            kind: STARKNET_KIND.to_string(),
+            network: "starknet-mainnet".into(),
+            name: "asd".to_string(),
+            source: crate::data_source::Source {
+                start_block: 10,
+                end_block: None,
+                address,
+            },
+            mapping: Mapping {
+                block_handler: None,
+                event_handlers: vec![],
+                runtime: Arc::new(vec![]),
+            },
+        }
+    }
+}

chain/starknet/src/data_source.rs

@@ -2,7 +2,7 @@ use graph::{
     anyhow::{anyhow, Error},
     blockchain::{self, Block as BlockchainBlock, TriggerWithHandler},
     components::{link_resolver::LinkResolver, store::StoredDynamicDataSource},
-    data::subgraph::DataSourceContext,
+    data::subgraph::{DataSourceContext, SubgraphManifestValidationError},
     prelude::{async_trait, BlockNumber, DataSourceTemplateInfo, Deserialize, Link, Logger},
     semver,
 };
@@ -16,10 +16,11 @@ use crate::{
     trigger::{StarknetEventTrigger, StarknetTrigger},
 };
 
+pub const STARKNET_KIND: &str = "starknet";
 const BLOCK_HANDLER_KIND: &str = "block";
 const EVENT_HANDLER_KIND: &str = "event";
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct DataSource {
     pub kind: String,
     pub network: String,
@@ -28,7 +29,7 @@ pub struct DataSource {
     pub mapping: Mapping,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct Mapping {
     pub block_handler: Option<MappingBlockHandler>,
     pub event_handlers: Vec<MappingEventHandler>,
@@ -44,7 +45,7 @@ pub struct UnresolvedDataSource {
     pub mapping: UnresolvedMapping,
 }
 
-#[derive(Clone, PartialEq, Eq, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Source {
     pub start_block: BlockNumber,
@@ -63,12 +64,12 @@ pub struct UnresolvedMapping {
     pub file: Link,
 }
 
-#[derive(Clone, PartialEq, Eq, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
 pub struct MappingBlockHandler {
     pub handler: String,
 }
 
-#[derive(Clone, PartialEq, Eq, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
 pub struct MappingEventHandler {
     pub handler: String,
     pub event_selector: Felt,
@@ -201,7 +202,34 @@ impl blockchain::DataSource<Chain> for DataSource {
     }
 
     fn validate(&self) -> Vec<Error> {
-        Default::default()
+        let mut errors = Vec::new();
+
+        if self.kind != STARKNET_KIND {
+            errors.push(anyhow!(
+                "data source has invalid `kind`, expected {} but found {}",
+                STARKNET_KIND,
+                self.kind
+            ))
+        }
+
+        // Validate that there's at least one handler of any kind
+        if self.mapping.block_handler.is_none() && self.mapping.event_handlers.is_empty() {
+            errors.push(anyhow!("data source does not define any handler"));
+        }
+
+        // Validate that `source` address must not be present if there's no event handler
+        if self.mapping.event_handlers.is_empty() && self.address().is_some() {
+            errors.push(anyhow!(
+                "data source cannot have source address without event handlers"
+            ));
+        }
+
+        // Validate that `source` address must be present when there's at least 1 event handler
+        if !self.mapping.event_handlers.is_empty() && self.address().is_none() {
+            errors.push(SubgraphManifestValidationError::SourceAddressRequired.into());
+        }
+
+        errors
     }
 
     fn api_version(&self) -> semver::Version {