Static filters silently drop call-filtered block handlers declared in templates (wrong data and PoI, no error) #6750

diff --git a/chain/ethereum/src/adapter.rs b/chain/ethereum/src/adapter.rs
index d37d5ba81f..ed129a5d81 100644
--- a/chain/ethereum/src/adapter.rs
+++ b/chain/ethereum/src/adapter.rs
@@ -2337,3 +2337,165 @@ fn requires_transaction_receipt_has_or_semantics_across_handlers() {
         );
     }
 }
+
+/// Probe: a template whose mapping has a `blockHandler` with `filter: { kind: call }`.
+/// A DDS is created from it, then a block contains a call to the DDS address.
+///
+/// The two filters below are built exactly as `SubgraphRunner::build_filter`
+/// (core/src/subgraph/runner/mod.rs) builds them:
+/// - default mode: `TriggerFilter::from_data_sources(onchain_data_sources())`,
+///   i.e. static data sources plus every created DDS;
+/// - static-filters mode: `TriggerFilter::from_data_sources(static data sources)`
+///   followed by `extend_with_template(templates)`; no restart happens on DDS
+///   creation in this mode, so this filter stays in force after block N.
+///
+/// The block triggers are then parsed by `parse_block_triggers`, the function used
+/// by `triggers_in_block` (chain.rs) and mirrored by `blocks_with_triggers`
+/// (ethereum_adapter.rs), and handed to the DDS's `match_and_decode`.
+#[cfg(test)]
+mod static_filters_call_block_handler {
+    use super::*;
+    use crate::data_source::{
+        BlockHandlerFilter, DataSource, DataSourceTemplate, MappingBlockHandler, TemplateSource,
+    };
+    use crate::ethereum_adapter::parse_block_triggers;
+    use graph::blockchain::{DataSource as _, TriggerFilter as _};
+    use graph::components::subgraph::{InstanceDSTemplate, InstanceDSTemplateInfo};
+    use graph::prelude::alloy::primitives::Bytes;
+    use graph::prelude::{
+        EthereumBlock, EthereumBlockWithCalls, EthereumCall, LightEthereumBlock,
+        create_minimal_block_for_test,
+    };
+    use std::sync::Arc;
+
+    fn template() -> DataSourceTemplate {
+        let mut mapping = receipt_merge_test_mapping(vec![]);
+        mapping.block_handlers = vec![MappingBlockHandler {
+            handler: "handleCallToDds".to_string(),
+            filter: Some(BlockHandlerFilter::Call),
+        }];
+        DataSourceTemplate {
+            kind: "ethereum/contract".to_string(),
+            network: Some("test".to_string()),
+            name: "CallTemplate".to_string(),
+            manifest_idx: 1,
+            source: TemplateSource {
+                abi: "mock_abi".to_string(),
+            },
+            mapping,
+        }
+    }
+
+    /// Handlers of the DDS fired by the block triggers that `filter` yields
+    /// for `block`.
+    fn fired(
+        filter: &TriggerFilter,
+        dds: &DataSource,
+        block: &crate::chain::BlockFinality,
+    ) -> (Vec<String>, Vec<String>) {
+        let crate::chain::BlockFinality::NonFinal(full) = block else {
+            unreachable!()
+        };
+        let triggers = parse_block_triggers(&filter.block, full);
+        // Trait `blockchain::DataSource::match_and_decode`, as called by the runner.
+        let arc_block = Arc::new(block.clone());
+        let logger = graph::log::discard();
+        let handlers = triggers
+            .iter()
+            .filter_map(|t| {
+                dds.match_and_decode(t, &arc_block, &logger)
+                    .unwrap()
+                    .map(|th| th.handler_name().to_string())
+            })
+            .collect();
+        (
+            triggers.iter().map(|t| format!("{t:?}")).collect(),
+            handlers,
+        )
+    }
+
+    #[test]
+    fn static_filters_fire_call_block_handler_of_dds() {
+        let static_addr = receipt_merge_test_addr(0xa0);
+        let dds_addr = receipt_merge_test_addr(0xa1);
+        let creation_block = 1;
+
+        // Static data source: one event handler, nothing else.
+        let static_ds = receipt_merge_test_data_source(
+            Some(static_addr),
+            vec![receipt_merge_test_event_handler(
+                receipt_merge_test_sig(1),
+                None,
+                None,
+                None,
+                false,
+            )],
+        );
+
+        // Template + DDS created from it, through the real constructor.
+        let tpl = template();
+        let ds_tpl = graph::data_source::DataSourceTemplate::<crate::Chain>::Onchain(tpl.clone());
+        let dds = DataSource::from_template_info(
+            InstanceDSTemplateInfo {
+                template: InstanceDSTemplate::from(&ds_tpl),
+                params: vec![format!("{dds_addr:x}")],
+                context: None,
+                creation_block,
+            },
+            &ds_tpl,
+        )
+        .unwrap();
+        assert_eq!(dds.address, Some(dds_addr));
+
+        // Default mode (runner/mod.rs build_filter, `!static_filters` branch).
+        let default_filter = TriggerFilter::from_data_sources([&static_ds, &dds].into_iter());
+
+        // Static-filters mode (runner/mod.rs build_filter, static branch).
+        let mut static_filter = TriggerFilter::from_data_sources([&static_ds].into_iter());
+        static_filter.extend_with_template([tpl].into_iter());
+
+        // Block N+1 (after creation) containing a call to the DDS address.
+        // The calls are given to both modes, even though in static mode
+        // `requires_traces()` is false and the RPC path would not fetch them.
+        let raw = create_minimal_block_for_test(2, B256::repeat_byte(2));
+        let full = crate::chain::BlockFinality::NonFinal(EthereumBlockWithCalls {
+            ethereum_block: EthereumBlock {
+                block: Arc::new(LightEthereumBlock::new(raw)),
+                ..Default::default()
+            },
+            calls: Some(vec![EthereumCall {
+                to: dds_addr,
+                block_number: 2,
+                block_hash: B256::repeat_byte(2),
+                input: Bytes::from(vec![1; 36]),
+                ..Default::default()
+            }]),
+        });
+
+        let (dt, dh) = fired(&default_filter, &dds, &full);
+        let (st, sh) = fired(&static_filter, &dds, &full);
+        println!(
+            "DEFAULT: requires_traces={} block.contract_addresses={:?} trigger_every_block={} triggers={:?} dds_handlers={:?}",
+            default_filter.requires_traces(),
+            default_filter.block.contract_addresses,
+            default_filter.block.trigger_every_block,
+            dt,
+            dh
+        );
+        println!(
+            "STATIC:  requires_traces={} block.contract_addresses={:?} trigger_every_block={} triggers={:?} dds_handlers={:?}",
+            static_filter.requires_traces(),
+            static_filter.block.contract_addresses,
+            static_filter.block.trigger_every_block,
+            st,
+            sh
+        );
+
+        assert_eq!(
+            dh,
+            vec!["handleCallToDds".to_string()],
+            "default mode fires"
+        );
+        assert_eq!(sh, dh, "static-filters mode must fire the same handlers as default mode");
+    }
+}