sim-rs: first pass at Full Leios

Author: SupernaviX

data/simulation/config.d.ts

@@ -24,6 +24,8 @@ export interface Config {
   "cleanup-policies": CleanupPolicies;
 
   // Leios Protocol Configuration
+  /** Only supported by Rust simulation. */
+  "leios-variant": LeiosVariant;
   "leios-stage-length-slots": bigint;
   "leios-stage-active-voting-slots": bigint;
   /**
@@ -33,6 +35,12 @@ export interface Config {
    *
    * Only supported by Haskell simulation. */
   "leios-vote-send-recv-stages": boolean;
+  /**
+   * The expected time it takes a header to fully diffuse across the network.
+   * This is Δhdr from the Leios paper.
+   * 
+   * Only supported by Rust simulation. */
+  "leios-header-diffusion-time-ms": number;
 
   // Transaction Configuration
   /** Only supported by Rust simulation. */
@@ -185,3 +193,8 @@ export enum RelayStrategy {
   RequestFromAll = "request-from-all",
   RequestFromFirst = "request-from-first",
 }
+
+export enum LeiosVariant {
+  Short = "short",
+  Full = "full",
+}

data/simulation/config.default.yaml

@@ -22,9 +22,11 @@ cleanup-policies: ["cleanup-expired-vote"]
 # Leios Protocol Configuration
 ################################################################################
 
+leios-variant: short
 leios-stage-length-slots: 20
 leios-stage-active-voting-slots: 1
 leios-vote-send-recv-stages: false
+leios-header-diffusion-time-ms: 1000.0
 
 ################################################################################
 # Transaction Configuration

data/simulation/config.schema.json

@@ -72,6 +72,10 @@
       },
       "type": "object"
     },
+    "LeiosVariant": {
+      "enum": ["short", "full"],
+      "type": "string"
+    },
     "LogNormalDistribution": {
       "properties": {
         "distribution": {
@@ -244,6 +248,10 @@
       "description": "Only supported by Rust simulation.",
       "type": "number"
     },
+    "leios-header-diffusion-time-ms": {
+      "description": "The expected time it takes a header to fully diffuse across the network.\nThis is Δhdr from the Leios paper.\n\nOnly supported by Rust simulation.",
+      "type": "number"
+    },
     "leios-stage-active-voting-slots": {
       "additionalProperties": false,
       "properties": {},
@@ -254,6 +262,10 @@
       "properties": {},
       "type": "number"
     },
+    "leios-variant": {
+      "$ref": "#/definitions/LeiosVariant",
+      "description": "Only supported by Rust simulation."
+    },
     "leios-vote-send-recv-stages": {
       "description": "Determines whether a Leios pipeline has separate Vote (Send) and Vote (Recv) stages.\nIf this is set to `true`, it is recommended to set `leios-stage-active-voting-slots`\nto be equal to `leios-stage-length-slots`.\n\nOnly supported by Haskell simulation.",
       "type": "boolean"

sim-rs/sim-cli/src/events.rs

@@ -92,6 +92,7 @@ impl EventMonitor {
         let mut eb_votes: BTreeMap<EndorserBlockId, f64> = BTreeMap::new();
         let mut ib_txs: BTreeMap<InputBlockId, Vec<TransactionId>> = BTreeMap::new();
         let mut eb_ibs: BTreeMap<EndorserBlockId, Vec<InputBlockId>> = BTreeMap::new();
+        let mut eb_ebs: BTreeMap<EndorserBlockId, Vec<EndorserBlockId>> = BTreeMap::new();
 
         let mut last_timestamp = Timestamp::zero();
         let mut total_slots = 0u64;
@@ -205,10 +206,13 @@ impl EventMonitor {
                         leios_blocks_with_endorsements += 1;
                         pending_ebs.retain(|eb| eb.slot != endorsement.eb.slot);
 
-                        let block_leios_txs: Vec<_> = eb_ibs
+                        let all_eb_ids = eb_ebs
                             .get(&endorsement.eb)
                             .unwrap()
                             .iter()
+                            .chain(std::iter::once(&endorsement.eb));
+                        let block_leios_txs: Vec<_> = all_eb_ids
+                            .flat_map(|eb| eb_ibs.get(eb).unwrap())
                             .flat_map(|ib| ib_txs.get(ib).unwrap())
                             .copied()
                             .collect();
@@ -290,11 +294,15 @@ impl EventMonitor {
                 }
                 Event::EBLotteryWon { .. } => {}
                 Event::EBGenerated {
-                    id, input_blocks, ..
+                    id,
+                    input_blocks,
+                    endorser_blocks,
+                    ..
                 } => {
                     generated_ebs += 1;
                     pending_ebs.insert(id.clone());
                     eb_ibs.insert(id.clone(), input_blocks.clone());
+                    eb_ebs.insert(id.clone(), endorser_blocks);
                     for ib_id in &input_blocks {
                         *ibs_in_eb.entry(id.clone()).or_default() += 1.0;
                         *ebs_containing_ib.entry(ib_id.clone()).or_default() += 1.0;

sim-rs/sim-core/src/clock/timestamp.rs

@@ -7,13 +7,21 @@ use std::{
 use serde::Serialize;
 
 /// A timestamp tracks the time from the start of the simulation.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
 pub struct Timestamp(Duration);
 
 impl Timestamp {
     pub fn zero() -> Self {
         Self(Duration::from_secs(0))
     }
+
+    pub fn from_secs(secs: u64) -> Self {
+        Self(Duration::from_secs(secs))
+    }
+
+    pub fn checked_sub_duration(self, rhs: Duration) -> Option<Self> {
+        Some(Self(self.0.checked_sub(rhs)?))
+    }
 }
 
 impl From<Duration> for Timestamp {

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

@@ -53,12 +53,14 @@ impl From<DistributionConfig> for FloatDistribution {
 #[serde(rename_all = "kebab-case")]
 pub struct RawParameters {
     // Simulation Configuration
+    pub leios_variant: LeiosVariant,
     pub relay_strategy: RelayStrategy,
     pub simulate_transactions: bool,
 
     // Leios protocol configuration
     pub leios_stage_length_slots: u64,
     pub leios_stage_active_voting_slots: u64,
+    pub leios_header_diffusion_time_ms: f64,
 
     // Transaction configuration
     pub tx_generation_distribution: DistributionConfig,
@@ -123,6 +125,13 @@ pub enum DiffusionStrategy {
     OldestFirst,
 }
 
+#[derive(Debug, Copy, Clone, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum LeiosVariant {
+    Short,
+    Full,
+}
+
 #[derive(Debug, Copy, Clone, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "kebab-case")]
 pub enum RelayStrategy {
@@ -404,6 +413,8 @@ pub struct SimConfiguration {
     pub links: Vec<LinkConfiguration>,
     pub stage_length: u64,
     pub max_eb_age: u64,
+    pub(crate) variant: LeiosVariant,
+    pub(crate) header_diffusion_time: Duration,
     pub(crate) relay_strategy: RelayStrategy,
     pub(crate) block_generation_probability: f64,
     pub(crate) ib_generation_probability: f64,
@@ -429,6 +440,8 @@ impl SimConfiguration {
             nodes: topology.nodes,
             trace_nodes: HashSet::new(),
             links: topology.links,
+            variant: params.leios_variant,
+            header_diffusion_time: duration_ms(params.leios_header_diffusion_time_ms),
             relay_strategy: params.relay_strategy,
             block_generation_probability: params.rb_generation_probability,
             ib_generation_probability: params.ib_generation_probability,

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

@@ -149,6 +149,7 @@ pub enum Event {
         id: EndorserBlockId<Node>,
         bytes: u64,
         input_blocks: Vec<InputBlockId<Node>>,
+        endorser_blocks: Vec<EndorserBlockId<Node>>,
     },
     EBSent {
         #[serde(flatten)]
@@ -380,6 +381,11 @@ impl EventTracker {
                 .iter()
                 .map(|id| self.to_input_block(*id))
                 .collect(),
+            endorser_blocks: block
+                .ebs
+                .iter()
+                .map(|id| self.to_endorser_block(*id))
+                .collect(),
         });
     }
 

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

@@ -178,6 +178,7 @@ pub struct EndorserBlock {
     pub bytes: u64,
     // The real impl will store hashes
     pub ibs: Vec<InputBlockId>,
+    pub ebs: Vec<EndorserBlockId>,
 }
 impl EndorserBlock {
     pub fn id(&self) -> EndorserBlockId {
@@ -223,6 +224,7 @@ pub enum NoVoteReason {
     InvalidSlot,
     ExtraIB,
     MissingIB,
+    MissingEB,
 }
 
 #[derive(Clone, Debug, Serialize)]