sim-rs: wait for equivocation before voting

Author: SupernaviX

sim-rs/implementations/LINEAR_LEIOS.md

@@ -15,6 +15,8 @@ When a node receives an RB body, it immediately removes all referenced/conflicti
 
 When a node receives an EB body, it runs lightweight validation and then propagates the body to peers. After this lightweight validation, it runs more expensive complete validation (presumably at the TX level) before voting.
 
+To detect equivocation, a node will wait until at least `3 * Δhdr` after an EB was generated before voting for it.
+
 When voting, a node runs a VRF lottery to decide how many times it can vote for that EB; if it has any votes, it will transmit them to all peers. If the EB has been certified after `L_vote` + `L_diff` slots have passed, the node removes all of its transactions from the mempool (under the assumption that the EB will make it on-chain).
 
 ## New parameters
@@ -43,5 +45,4 @@ When voting, a node runs a VRF lottery to decide how many times it can vote for
 
 ## Not yet implemented
 - Freshest first delivery is not implemented for EBs, though EBs are created infrequently enough that this likely doesn't matter.
-- We are not yet accounting for equivocation.
-- Nodes are supposed to wait until the diffuse stage to vote for an EB, they are currently voting as soon as they can.
+- We are not yet simulating equivocation.

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

@@ -9,7 +9,7 @@ use tokio_util::sync::CancellationToken;
 use tx::TransactionProducer;
 
 use crate::{
-    clock::{Clock, ClockCoordinator},
+    clock::{Clock, ClockCoordinator, Timestamp},
     config::{CpuTimeConfig, LeiosVariant, NodeConfiguration, NodeId, SimConfiguration},
     events::EventTracker,
     model::Transaction,
@@ -242,33 +242,40 @@ trait SimCpuTask {
     fn times(&self, config: &CpuTimeConfig) -> Vec<Duration>;
 }
 
-struct EventResult<Message: SimMessage, Task: SimCpuTask> {
-    messages: Vec<(NodeId, Message)>,
-    tasks: Vec<Task>,
+struct EventResult<N: NodeImpl> {
+    messages: Vec<(NodeId, N::Message)>,
+    tasks: Vec<N::Task>,
+    timed_events: Vec<(Timestamp, N::TimedEvent)>,
 }
 
-impl<Message: SimMessage, Task: SimCpuTask> Default for EventResult<Message, Task> {
+impl<N: NodeImpl> Default for EventResult<N> {
     fn default() -> Self {
         Self {
             messages: vec![],
             tasks: vec![],
+            timed_events: vec![],
         }
     }
 }
 
-impl<Message: SimMessage, Task: SimCpuTask> EventResult<Message, Task> {
-    pub fn send_to(&mut self, to: NodeId, msg: Message) {
+impl<N: NodeImpl> EventResult<N> {
+    pub fn send_to(&mut self, to: NodeId, msg: N::Message) {
         self.messages.push((to, msg));
     }
 
-    pub fn schedule_cpu_task(&mut self, task: Task) {
+    pub fn schedule_cpu_task(&mut self, task: N::Task) {
         self.tasks.push(task);
     }
+
+    pub fn schedule_event(&mut self, time: Timestamp, event: N::TimedEvent) {
+        self.timed_events.push((time, event));
+    }
 }
 
-trait NodeImpl {
+trait NodeImpl: Sized {
     type Message: SimMessage;
     type Task: SimCpuTask;
+    type TimedEvent;
 
     fn new(
         config: &NodeConfiguration,
@@ -278,12 +285,12 @@ trait NodeImpl {
         clock: Clock,
     ) -> Self;
 
-    fn handle_new_slot(&mut self, slot: u64) -> EventResult<Self::Message, Self::Task>;
-    fn handle_new_tx(&mut self, tx: Arc<Transaction>) -> EventResult<Self::Message, Self::Task>;
-    fn handle_message(
-        &mut self,
-        from: NodeId,
-        msg: Self::Message,
-    ) -> EventResult<Self::Message, Self::Task>;
-    fn handle_cpu_task(&mut self, task: Self::Task) -> EventResult<Self::Message, Self::Task>;
+    fn handle_new_slot(&mut self, slot: u64) -> EventResult<Self>;
+    fn handle_new_tx(&mut self, tx: Arc<Transaction>) -> EventResult<Self>;
+    fn handle_message(&mut self, from: NodeId, msg: Self::Message) -> EventResult<Self>;
+    fn handle_cpu_task(&mut self, task: Self::Task) -> EventResult<Self>;
+    fn handle_timed_event(&mut self, event: Self::TimedEvent) -> EventResult<Self> {
+        let _ = event;
+        EventResult::default()
+    }
 }

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

@@ -21,9 +21,10 @@ struct CpuTaskWrapper<Task: SimCpuTask> {
     cpu_time: Duration,
 }
 
-enum NodeEvent {
+enum NodeEvent<T> {
     NewSlot(u64),
     CpuSubtaskCompleted(Subtask),
+    Other(T),
 }
 
 pub struct NodeDriver<N: NodeImpl> {
@@ -35,7 +36,7 @@ pub struct NodeDriver<N: NodeImpl> {
     msg_source: NetworkSource<N::Message>,
     msg_sink: NetworkSink<MiniProtocol, N::Message>,
     tx_source: mpsc::UnboundedReceiver<Arc<Transaction>>,
-    events: BinaryHeap<FutureEvent<NodeEvent>>,
+    events: BinaryHeap<FutureEvent<NodeEvent<N::TimedEvent>>>,
     tracker: EventTracker,
     clock: ClockBarrier,
     cpu: CpuTaskQueue<CpuTaskWrapper<N::Task>>,
@@ -105,6 +106,9 @@ impl<N: NodeImpl> NodeDriver<N> {
                             };
                             (result, false)
                         }
+                        NodeEvent::Other(event) => {
+                            (self.node.handle_timed_event(event), false)
+                        }
                     }
                 }
             };
@@ -114,6 +118,9 @@ impl<N: NodeImpl> NodeDriver<N> {
             for task in result.tasks {
                 self.schedule_cpu_task(task);
             }
+            for (time, event) in result.timed_events {
+                self.events.push(FutureEvent(time, NodeEvent::Other(event)));
+            }
             if finish_task {
                 self.clock.finish_task();
             }
@@ -156,10 +163,7 @@ impl<N: NodeImpl> NodeDriver<N> {
         }
     }
 
-    fn handle_subtask_completed(
-        &mut self,
-        subtask: Subtask,
-    ) -> Option<EventResult<N::Message, N::Task>> {
+    fn handle_subtask_completed(&mut self, subtask: Subtask) -> Option<EventResult<N>> {
         let task_id = CpuTaskId {
             node: self.id,
             index: subtask.task_id,

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

@@ -372,11 +372,12 @@ impl PeerInputBlockRequests {
     }
 }
 
-type EventResult = super::EventResult<SimulationMessage, Task>;
+type EventResult = super::EventResult<LeiosNode>;
 
 impl NodeImpl for LeiosNode {
     type Task = Task;
     type Message = SimulationMessage;
+    type TimedEvent = ();
 
     fn new(
         config: &NodeConfiguration,

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

@@ -180,6 +180,10 @@ impl SimCpuTask for CpuTask {
     }
 }
 
+pub enum TimedEvent {
+    TryVote(Arc<EndorserBlock>, Timestamp),
+}
+
 enum TransactionView {
     Pending,
     Received(Arc<Transaction>),
@@ -269,11 +273,12 @@ pub struct LinearLeiosNode {
     leios: NodeLeiosState,
 }
 
-type EventResult = super::EventResult<Message, CpuTask>;
+type EventResult = super::EventResult<LinearLeiosNode>;
 
 impl NodeImpl for LinearLeiosNode {
     type Message = Message;
     type Task = CpuTask;
+    type TimedEvent = TimedEvent;
 
     fn new(
         config: &NodeConfiguration,
@@ -359,6 +364,13 @@ impl NodeImpl for LinearLeiosNode {
         }
         std::mem::take(&mut self.queued)
     }
+
+    fn handle_timed_event(&mut self, event: Self::TimedEvent) -> EventResult {
+        match event {
+            TimedEvent::TryVote(eb, seen) => self.vote_for_endorser_block(&eb, seen),
+        }
+        std::mem::take(&mut self.queued)
+    }
 }
 
 // Transaction propagation
@@ -839,6 +851,17 @@ impl LinearLeiosNode {
 // Voting
 impl LinearLeiosNode {
     fn vote_for_endorser_block(&mut self, eb: &Arc<EndorserBlock>, seen: Timestamp) {
+        let equivocation_cutoff_time =
+            Timestamp::from_secs(eb.slot) + (self.sim_config.header_diffusion_time * 3);
+        if eb.producer != self.id && self.clock.now() < equivocation_cutoff_time {
+            // If we haven't waited long enough to detect equivocations,
+            // schedule voting later.
+            self.queued.schedule_event(
+                equivocation_cutoff_time,
+                TimedEvent::TryVote(eb.clone(), seen),
+            );
+            return;
+        }
         if !self.try_vote_for_endorser_block(eb, seen) && self.sim_config.emit_conformance_events {
             self.tracker
                 .track_linear_no_vote_generated(self.id, eb.id());

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

@@ -246,11 +246,12 @@ pub struct StracciatellaLeiosNode {
     leios: NodeLeiosState,
 }
 
-type EventResult = super::EventResult<Message, CpuTask>;
+type EventResult = super::EventResult<StracciatellaLeiosNode>;
 
 impl NodeImpl for StracciatellaLeiosNode {
     type Message = Message;
     type Task = CpuTask;
+    type TimedEvent = ();
 
     fn new(
         config: &NodeConfiguration,