Move stracciatella to a separate implementation (#461)

* sim-rs: move stracciatella to a separate implementation

* sim-rs: fix issues with stracciatella

* sim-rs: support referencing txs from last stage in stracciatella

* sim-rs: remove stracciatella code from normal leios sim

Author: SupernaviX

data/simulation/config.d.ts

@@ -174,6 +174,9 @@ export interface Config {
   "eb-size-bytes-constant": bigint;
   "eb-size-bytes-per-ib": bigint;
   "eb-body-avg-size-bytes": bigint;
+  /** For stracciatella: when creating a new EB, have it reference transactions from a previous EB */
+  "eb-include-txs-from-previous-stage": boolean
+
   /** Only supported by Haskell simulation. */
   "eb-diffusion-strategy": DiffusionStrategy;
   /** Only supported by Haskell simulation. */

data/simulation/config.default.yaml

@@ -150,6 +150,8 @@ eb-header-validation-cpu-time-ms: 50.0
 # For linear leios: complete validation of the EB
 eb-body-validation-cpu-time-ms-constant: 50.0
 eb-body-validation-cpu-time-ms-per-byte: 0.0005
+# For stracciatella: when creating a new EB, have it reference transactions from a previous EB
+eb-include-txs-from-previous-stage: false
 
 eb-diffusion-strategy: "peer-order"
 

data/simulation/config.schema.json

@@ -192,6 +192,10 @@
     "eb-header-validation-cpu-time-ms": {
       "type": "number"
     },
+    "eb-include-txs-from-previous-stage": {
+      "description": "For stracciatella: when creating a new EB, have it reference transactions from a previous EB",
+      "type": "boolean"
+    },
     "eb-max-age-for-relay-slots": {
       "additionalProperties": false,
       "description": "The maximum age of EBs to be relayed.\n\nAn EB from slot `s` will only be relayed\nup to slot `s+eb-max-age-for-relay-slots`.\n\nOnly supported by Haskell simulation.",

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

@@ -123,6 +123,7 @@ pub struct RawParameters {
     pub eb_max_age_slots: u64,
     pub eb_referenced_txs_max_size_bytes: u64,
     pub eb_body_avg_size_bytes: u64,
+    pub eb_include_txs_from_previous_stage: bool,
 
     // Vote configuration
     pub vote_generation_probability: f64,
@@ -539,6 +540,7 @@ pub struct SimConfiguration {
     pub(crate) eb_generation_probability: f64,
     pub(crate) vote_probability: f64,
     pub(crate) vote_slot_length: u64,
+    pub(crate) eb_include_txs_from_previous_stage: bool,
     pub(crate) linear_vote_stage_length: u64,
     pub(crate) linear_diffuse_stage_length: u64,
     pub(crate) max_block_size: u64,
@@ -602,6 +604,7 @@ impl SimConfiguration {
             vote_probability: params.vote_generation_probability,
             vote_threshold: params.vote_threshold,
             vote_slot_length: params.leios_stage_active_voting_slots,
+            eb_include_txs_from_previous_stage: params.eb_include_txs_from_previous_stage,
             linear_vote_stage_length: params.linear_vote_stage_length_slots,
             linear_diffuse_stage_length: params.linear_diffuse_stage_length_slots,
             max_block_size: params.rb_body_max_size_bytes,

sim-rs/sim-core/src/events.rs

@@ -608,7 +608,7 @@ impl EventTracker {
             producer: self.to_node(block.producer),
             shard: block.shard,
             size_bytes: block.bytes,
-            transactions: block.txs.iter().map(|tx| BlockRef { id: tx.id }).collect(),
+            transactions: vec![],
             input_blocks: block
                 .ibs
                 .iter()
@@ -626,6 +626,29 @@ impl EventTracker {
         });
     }
 
+    pub fn track_stracciatella_eb_generated(
+        &self,
+        block: &crate::model::StracciatellaEndorserBlock,
+    ) {
+        self.send(Event::EBGenerated {
+            id: self.to_endorser_block(block.id()),
+            slot: block.slot,
+            pipeline: block.pipeline,
+            producer: self.to_node(block.producer),
+            shard: block.shard,
+            size_bytes: block.bytes,
+            transactions: block.txs.iter().map(|tx| BlockRef { id: tx.id }).collect(),
+            input_blocks: vec![],
+            endorser_blocks: block
+                .ebs
+                .iter()
+                .map(|id| BlockRef {
+                    id: self.to_endorser_block(*id),
+                })
+                .collect(),
+        });
+    }
+
     pub fn track_no_eb_generated(&self, node: NodeId, slot: u64) {
         self.send(Event::NoEBGenerated {
             node: self.to_node(node),
@@ -667,6 +690,23 @@ impl EventTracker {
         });
     }
 
+    pub fn track_stracciatella_eb_sent(
+        &self,
+        block: &crate::model::StracciatellaEndorserBlock,
+        sender: NodeId,
+        recipient: NodeId,
+    ) {
+        self.send(Event::EBSent {
+            id: self.to_endorser_block(block.id()),
+            slot: block.slot,
+            pipeline: block.pipeline,
+            producer: self.to_node(block.producer),
+            sender: self.to_node(sender),
+            recipient: self.to_node(recipient),
+            msg_size_bytes: block.bytes,
+        });
+    }
+
     pub fn track_eb_received(&self, id: EndorserBlockId, sender: NodeId, recipient: NodeId) {
         self.send(Event::EBReceived {
             id: self.to_endorser_block(id),

sim-rs/sim-core/src/model.rs

@@ -194,7 +194,6 @@ pub struct EndorserBlock {
     pub producer: NodeId,
     pub shard: u64,
     pub bytes: u64,
-    pub txs: Vec<Arc<Transaction>>,
     pub ibs: Vec<InputBlockId>,
     pub ebs: Vec<EndorserBlockId>,
 }
@@ -208,6 +207,26 @@ impl EndorserBlock {
     }
 }
 
+#[derive(Debug)]
+pub struct StracciatellaEndorserBlock {
+    pub slot: u64,
+    pub pipeline: u64,
+    pub producer: NodeId,
+    pub shard: u64,
+    pub bytes: u64,
+    pub txs: Vec<Arc<Transaction>>,
+    pub ebs: Vec<EndorserBlockId>,
+}
+impl StracciatellaEndorserBlock {
+    pub fn id(&self) -> EndorserBlockId {
+        EndorserBlockId {
+            slot: self.slot,
+            pipeline: self.pipeline,
+            producer: self.producer,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct LinearEndorserBlock {
     pub slot: u64,

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

@@ -14,7 +14,10 @@ use crate::{
     events::EventTracker,
     model::Transaction,
     network::Network,
-    sim::{driver::NodeDriver, leios::LeiosNode, linear_leios::LinearLeiosNode},
+    sim::{
+        driver::NodeDriver, leios::LeiosNode, linear_leios::LinearLeiosNode,
+        stracciatella::StracciatellaLeiosNode,
+    },
 };
 
 mod cpu;
@@ -23,30 +26,35 @@ mod leios;
 mod linear_leios;
 mod lottery;
 mod slot;
+mod stracciatella;
 mod tx;
 
 enum NetworkWrapper {
     Leios(Network<MiniProtocol, <LeiosNode as NodeImpl>::Message>),
+    Stracciatella(Network<MiniProtocol, <StracciatellaLeiosNode as NodeImpl>::Message>),
     LinearLeios(Network<MiniProtocol, <LinearLeiosNode as NodeImpl>::Message>),
 }
 impl NetworkWrapper {
     async fn run(&mut self) -> Result<()> {
         match self {
             Self::Leios(network) => network.run().await,
+            Self::Stracciatella(network) => network.run().await,
             Self::LinearLeios(network) => network.run().await,
         }
     }
 
     fn shutdown(self) -> Result<()> {
         match self {
             Self::Leios(network) => network.shutdown(),
+            Self::Stracciatella(network) => network.shutdown(),
             Self::LinearLeios(network) => network.shutdown(),
         }
     }
 }
 
 enum NodeListWrapper {
     Leios(Vec<NodeDriver<LeiosNode>>),
+    Stracciatella(Vec<NodeDriver<StracciatellaLeiosNode>>),
     LinearLeios(Vec<NodeDriver<LinearLeiosNode>>),
 }
 impl NodeListWrapper {
@@ -57,6 +65,11 @@ impl NodeListWrapper {
                     set.spawn(node.run());
                 }
             }
+            Self::Stracciatella(nodes) => {
+                for node in nodes.drain(..) {
+                    set.spawn(node.run());
+                }
+            }
             Self::LinearLeios(nodes) => {
                 for node in nodes.drain(..) {
                     set.spawn(node.run());
@@ -91,6 +104,13 @@ impl Simulation {
                 NetworkWrapper::LinearLeios,
                 NodeListWrapper::LinearLeios,
             )?,
+            LeiosVariant::FullWithoutIbs => Self::init(
+                &config,
+                &tracker,
+                &clock,
+                NetworkWrapper::Stracciatella,
+                NodeListWrapper::Stracciatella,
+            )?,
             _ => Self::init(
                 &config,
                 &tracker,