node, docs: Address review feedback on per-chain settings

- Guard ChainSettings::validate() to Ethereum chains only
- Add zero-value validation for polling_interval, json_rpc_timeout,
  request_retries, and target_triggers_per_block_range
- Fix ETHEREUM_POLLING_INTERVAL env var name in doc comment (drop GRAPH_ prefix)
- Fix polling_interval default in docs (500ms → 1000ms)

Author: dimitrovmaksim

docs/config.md

@@ -136,7 +136,7 @@ default (see [environment-variables.md](environment-variables.md) for
 details):
 
 - `polling_interval`: block ingestor polling interval in milliseconds.
-  Default: `ETHEREUM_POLLING_INTERVAL` (500ms).
+  Default: `ETHEREUM_POLLING_INTERVAL` (1000ms).
 - `json_rpc_timeout`: timeout for JSON-RPC requests in seconds.
   Default: `GRAPH_ETHEREUM_JSON_RPC_TIMEOUT` (180s).
 - `request_retries`: number of times to retry failed JSON-RPC requests.

docs/environment-variables.md

@@ -18,7 +18,7 @@ those.
 - `ETHEREUM_REORG_THRESHOLD`: Maximum expected reorg size, if a larger reorg
   happens, subgraphs might process inconsistent data. Defaults to 250.
 - `ETHEREUM_POLLING_INTERVAL`: how often to poll Ethereum for new blocks (in ms,
-  defaults to 500ms)
+  defaults to 1000ms)
 - `GRAPH_ETHEREUM_TARGET_TRIGGERS_PER_BLOCK_RANGE`: The ideal amount of triggers
   to be processed in a batch. If this is too small it may cause too many requests
   to the ethereum node, if it is too large it may cause unreasonably expensive

node/src/config.rs

@@ -489,7 +489,9 @@ impl ChainSection {
         }
 
         for (name, chain) in self.chains.iter_mut() {
-            chain.validate(name)?;
+            chain
+                .validate()
+                .map_err(|e| anyhow!("chain '{}': {}", name, e))?;
             if chain.cache_size <= reorg_threshold {
                 return Err(anyhow!(
                     "chain '{}': cache_size ({}) must be greater than reorg_threshold ({})",
@@ -641,7 +643,7 @@ impl ChainSection {
 /// `polling_interval`.
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub struct ChainSettings {
-    /// Set by `polling_interval` (milliseconds). Defaults to `GRAPH_ETHEREUM_POLLING_INTERVAL`.
+    /// Set by `polling_interval` (milliseconds). Defaults to `ETHEREUM_POLLING_INTERVAL`.
     #[serde(
         default = "default_polling_interval",
         deserialize_with = "deserialize_duration_millis"
@@ -703,6 +705,15 @@ impl Default for ChainSettings {
 
 impl ChainSettings {
     fn validate(&self) -> Result<()> {
+        anyhow::ensure!(
+            !self.polling_interval.is_zero(),
+            "polling_interval must be > 0"
+        );
+        anyhow::ensure!(
+            !self.json_rpc_timeout.is_zero(),
+            "json_rpc_timeout must be > 0"
+        );
+        anyhow::ensure!(self.request_retries > 0, "request_retries must be > 0");
         anyhow::ensure!(
             self.max_block_range_size > 0,
             "max_block_range_size must be > 0"
@@ -724,6 +735,10 @@ impl ChainSettings {
             self.get_logs_max_contracts > 0,
             "get_logs_max_contracts must be > 0"
         );
+        anyhow::ensure!(
+            self.target_triggers_per_block_range > 0,
+            "target_triggers_per_block_range must be > 0"
+        );
         Ok(())
     }
 }
@@ -758,22 +773,22 @@ fn default_blockchain_kind() -> BlockchainKind {
 }
 
 impl Chain {
-    fn validate(&mut self, name: &str) -> Result<()> {
+    fn validate(&mut self) -> Result<()> {
         let mut labels = self.providers.iter().map(|p| &p.label).collect_vec();
         labels.sort();
         labels.dedup();
         if labels.len() != self.providers.len() {
-            return Err(anyhow!("chain {}: provider labels must be unique", name));
+            return Err(anyhow!("provider labels must be unique"));
         }
 
         // `Config` validates that `self.shard` references a configured shard
         for provider in self.providers.iter_mut() {
             provider.validate()?
         }
 
-        self.settings
-            .validate()
-            .map_err(|e| anyhow!("chain {}: {}", name, e))?;
+        if self.protocol == BlockchainKind::Ethereum {
+            self.settings.validate()?;
+        }
 
         Ok(())
     }
@@ -2594,6 +2609,86 @@ fdw_pool_size = [
         );
     }
 
+    #[test]
+    fn chain_settings_rejects_zero_polling_interval() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            polling_interval = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("polling_interval must be > 0"),
+            "expected polling_interval error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_json_rpc_timeout() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            json_rpc_timeout = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("json_rpc_timeout must be > 0"),
+            "expected json_rpc_timeout error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_request_retries() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            request_retries = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("request_retries must be > 0"),
+            "expected request_retries error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_target_triggers_per_block_range() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            target_triggers_per_block_range = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("target_triggers_per_block_range must be > 0"),
+            "expected target_triggers_per_block_range error, got: {err}"
+        );
+    }
+
     #[test]
     fn chain_settings_validation_error_includes_chain_name() {
         let mut section = toml::from_str::<ChainSection>(