sim-rs: respect tx-start-time and tx-stop-time in attacks

Author: SupernaviX

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

@@ -206,6 +206,8 @@ pub struct RawLateTXAttackConfig {
     pub attackers: NodeSelection,
     pub attack_probability: f64,
     pub tx_generation_distribution: DistributionConfig,
+    pub tx_start_time: Option<f64>,
+    pub tx_stop_time: Option<f64>,
 }
 
 #[derive(Deserialize)]
@@ -617,7 +619,7 @@ impl AttackConfig {
             late_tx: params
                 .late_tx_attack
                 .as_ref()
-                .map(|raw| LateTXAttackConfig::build(raw, topology)),
+                .map(|raw| LateTXAttackConfig::build(raw, topology, params)),
         }
     }
 }
@@ -645,16 +647,26 @@ impl LateEBAttackConfig {
 pub(crate) struct LateTXAttackConfig {
     pub(crate) probability: f64,
     pub(crate) txs_to_generate: FloatDistribution,
+    pub(crate) start_time: Option<Timestamp>,
+    pub(crate) stop_time: Option<Timestamp>,
 }
 
 impl LateTXAttackConfig {
-    fn build(raw: &RawLateTXAttackConfig, topology: &mut Topology) -> Self {
+    fn build(raw: &RawLateTXAttackConfig, topology: &mut Topology, params: &RawParameters) -> Self {
         for attacker in topology.select(&raw.attackers) {
             attacker.behaviours.withhold_txs = true;
         }
         Self {
             probability: raw.attack_probability,
             txs_to_generate: raw.tx_generation_distribution.into(),
+            start_time: raw
+                .tx_start_time
+                .or(params.tx_start_time)
+                .map(|t| Timestamp::zero() + Duration::from_secs_f64(t)),
+            stop_time: raw
+                .tx_stop_time
+                .or(params.tx_stop_time)
+                .map(|t| Timestamp::zero() + Duration::from_secs_f64(t)),
         }
     }
 }

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

@@ -571,7 +571,7 @@ impl LinearLeiosNode {
         if !produce_empty_block {
             // If we are performing a "withheld TX" attack, we will include a bunch of brand-new TXs in this EB.
             // They will get disseminated through the network at the same time as the EB.
-            withheld_txs = self.generate_withheld_txs();
+            withheld_txs = self.generate_withheld_txs(slot);
             eb_transactions.extend(withheld_txs.iter().cloned());
 
             if let TransactionConfig::Mock(config) = &self.sim_config.transactions {
@@ -1127,11 +1127,18 @@ impl LinearLeiosNode {
 // transactions, so that they cannot propagate in advance.
 // We implement this by generating the transactions at the same time as the EB itself.
 impl LinearLeiosNode {
-    fn generate_withheld_txs(&mut self) -> Vec<Arc<Transaction>> {
+    fn generate_withheld_txs(&mut self, slot: u64) -> Vec<Arc<Transaction>> {
         if !self.behaviours.withhold_txs {
             return vec![];
         }
         let withhold_tx_config = self.sim_config.attacks.late_tx.as_ref().unwrap();
+        let slot_ts = Timestamp::from_secs(slot);
+        if withhold_tx_config.start_time.is_some_and(|s| slot_ts < s) {
+            return vec![];
+        }
+        if withhold_tx_config.stop_time.is_some_and(|s| slot_ts > s) {
+            return vec![];
+        }
         if !self.rng.random_bool(withhold_tx_config.probability) {
             return vec![];
         }