sim-rs: support late IB inclusion

Author: SupernaviX

sim-rs/sim-core/src/config.rs

@@ -60,6 +60,7 @@ pub struct RawParameters {
     // Leios protocol configuration
     pub leios_stage_length_slots: u64,
     pub leios_stage_active_voting_slots: u64,
+    pub leios_late_ib_inclusion: bool,
     pub leios_header_diffusion_time_ms: f64,
     pub praos_chain_quality: u64,
 
@@ -417,6 +418,7 @@ pub struct SimConfiguration {
     pub links: Vec<LinkConfiguration>,
     pub stage_length: u64,
     pub max_eb_age: u64,
+    pub late_ib_inclusion: bool,
     pub(crate) variant: LeiosVariant,
     pub(crate) header_diffusion_time: Duration,
     pub(crate) relay_strategy: RelayStrategy,
@@ -442,11 +444,14 @@ impl SimConfiguration {
         Self {
             seed: 0,
             slots: None,
-            aggregate_events: false,
             emit_conformance_events: false,
-            nodes: topology.nodes,
+            aggregate_events: false,
             trace_nodes: HashSet::new(),
+            nodes: topology.nodes,
             links: topology.links,
+            stage_length: params.leios_stage_length_slots,
+            max_eb_age: params.eb_max_age_slots,
+            late_ib_inclusion: params.leios_late_ib_inclusion,
             variant: params.leios_variant,
             header_diffusion_time: duration_ms(params.leios_header_diffusion_time_ms),
             relay_strategy: params.relay_strategy,
@@ -458,12 +463,10 @@ impl SimConfiguration {
             vote_threshold: params.vote_threshold,
             vote_slot_length: params.leios_stage_active_voting_slots,
             max_block_size: params.rb_body_max_size_bytes,
-            stage_length: params.leios_stage_length_slots,
             max_ib_size: params.ib_body_max_size_bytes,
             ib_diffusion_strategy: params.ib_diffusion_strategy,
             max_ib_requests_per_peer: params.ib_diffusion_max_bodies_to_request as usize,
             ib_shards: params.ib_shards,
-            max_eb_age: params.eb_max_age_slots,
             cpu_times: CpuTimeConfig::new(&params),
             sizes: BlockSizeConfig::new(&params),
             transactions: TransactionConfig::new(&params),

sim-rs/sim-core/src/sim/node.rs

@@ -578,17 +578,16 @@ impl Node {
                     pipeline,
                     producer: self.id,
                 });
-                let ibs = self.select_ibs_for_eb(pipeline);
-                let ebs = self.select_ebs_for_eb(pipeline);
-                let bytes = self.sim_config.sizes.eb(ibs.len(), ebs.len());
-                let eb = EndorserBlock {
+                let mut eb = EndorserBlock {
                     slot,
                     pipeline,
                     producer: self.id,
-                    bytes,
-                    ibs,
-                    ebs,
+                    bytes: 0,
+                    ibs: vec![],
+                    ebs: vec![],
                 };
+                self.try_filling_eb(&mut eb);
+                eb.bytes = self.sim_config.sizes.eb(eb.ibs.len(), eb.ebs.len());
                 self.schedule_cpu_task(CpuTaskType::EBBlockGenerated(eb));
                 // A node should only generate at most 1 EB per slot
                 return;
@@ -1319,7 +1318,28 @@ impl Node {
         Ok(())
     }
 
-    fn select_ibs_for_eb(&mut self, pipeline: u64) -> Vec<InputBlockId> {
+    fn try_filling_eb(&mut self, eb: &mut EndorserBlock) {
+        eb.ibs = self.select_ibs_from_pipeline(eb.pipeline);
+        eb.ebs = self.select_ebs_for_eb(eb.pipeline);
+        if !self.sim_config.late_ib_inclusion {
+            return;
+        }
+        let Some(expected_referenced_pipelines) = self.pipelines_referenced_by_ebs(eb.pipeline)
+        else {
+            return;
+        };
+
+        let pipelines_referenced_by_ebs: HashSet<u64> =
+            eb.ebs.iter().map(|eb| eb.pipeline).collect();
+        for pipeline in expected_referenced_pipelines {
+            if !pipelines_referenced_by_ebs.contains(&pipeline) {
+                let mut pipeline_ibs = self.select_ibs_from_pipeline(pipeline);
+                eb.ibs.append(&mut pipeline_ibs);
+            }
+        }
+    }
+
+    fn select_ibs_from_pipeline(&self, pipeline: u64) -> Vec<InputBlockId> {
         self.leios
             .ibs_by_pipeline
             .get(&pipeline)
@@ -1389,14 +1409,14 @@ impl Node {
 
     fn should_vote_for(&self, eb: &EndorserBlock) -> Result<(), NoVoteReason> {
         let mut ib_set = HashSet::new();
+        let mut pipelines_referenced_by_ibs = HashSet::new();
+
         for ib in &eb.ibs {
             if !matches!(self.leios.ibs.get(ib), Some(InputBlockState::Received(_))) {
                 return Err(NoVoteReason::MissingIB);
             }
-            if ib.pipeline != eb.pipeline {
-                return Err(NoVoteReason::InvalidSlot);
-            }
             ib_set.insert(*ib);
+            pipelines_referenced_by_ibs.insert(ib.pipeline);
         }
 
         if let Some(ibs) = self.leios.ibs_by_pipeline.get(&eb.pipeline) {
@@ -1409,31 +1429,40 @@ impl Node {
 
         // If this EB is meant to reference other EBs, validate that it references whatever it needs
         if let Some(expected_referenced_pipelines) = self.pipelines_referenced_by_ebs(eb.pipeline) {
-            let actual_referenced_pipelines: HashSet<u64> =
+            let pipelines_referenced_by_ebs: HashSet<u64> =
                 eb.ebs.iter().map(|id| id.pipeline).collect();
+
             for expected_pipeline in expected_referenced_pipelines {
-                let Some(certified_at) = self
+                let saw_certified_eb = self
                     .leios
                     .earliest_eb_cert_times_by_pipeline
                     .get(&expected_pipeline)
-                else {
-                    // We don't require an EB referenced from this pipeline if none of that pipeline's EBs have been certified yet,
-                    continue;
-                };
-
-                let last_pipeline_slot = (expected_pipeline + 1) * self.sim_config.stage_length - 1;
-                let cutoff = Timestamp::from_secs(last_pipeline_slot)
-                    .checked_sub_duration(self.sim_config.header_diffusion_time)
-                    .unwrap_or_default();
-                if certified_at > &cutoff {
-                    // Don't need an EB from this pipeline if it was certified so recently that it may not have propagated.
-                    continue;
-                }
-
-                if !actual_referenced_pipelines.contains(&expected_pipeline) {
+                    .is_some_and(|certified_at| {
+                        let last_pipeline_slot =
+                            (expected_pipeline + 1) * self.sim_config.stage_length - 1;
+                        let cutoff = Timestamp::from_secs(last_pipeline_slot)
+                            .checked_sub_duration(self.sim_config.header_diffusion_time)
+                            .unwrap_or_default();
+                        certified_at <= &cutoff
+                    });
+
+                if saw_certified_eb && !pipelines_referenced_by_ebs.contains(&expected_pipeline) {
+                    // We saw at least one certified EB for this pipeline, so we should have included one.
                     return Err(NoVoteReason::MissingEB);
                 }
+                if pipelines_referenced_by_ebs.contains(&expected_pipeline)
+                    && pipelines_referenced_by_ibs.contains(&expected_pipeline)
+                {
+                    // No pipeline should be referenced by both an EB and any IBs
+                    return Err(NoVoteReason::ExtraIB);
+                }
             }
+        } else if pipelines_referenced_by_ibs
+            .iter()
+            .any(|pipeline| *pipeline != eb.pipeline)
+        {
+            // This EB should only reference IBs from its own pipeline
+            return Err(NoVoteReason::InvalidSlot);
         }
 
         // If this EB _does_ reference other EBs, make sure we trust them