fixup! 19581f3

Author: f3r10

simln-lib/src/lib.rs

@@ -628,7 +628,6 @@ struct ExecutorKit {
 struct PaymentEvent {
     pubkey: PublicKey,
     absolute_time: SystemTime,
-    wait_time: Duration,
     destination: NodeInfo,
     capacity: Option<u64>,
 }
@@ -1097,11 +1096,19 @@ impl<C: Clock + 'static> Simulation<C> {
                     match heap.pop() {
                         Some(Reverse(PaymentEvent {
                             pubkey,
-                            absolute_time: _,
-                            wait_time,
+                            absolute_time,
                             destination,
                             capacity
                         })) => {
+                            let internal_now = SystemTime::now();
+                            let wait_time = match absolute_time.duration_since(internal_now) {
+                                Ok(elapsed) => {
+                                    elapsed
+                                },
+                                Err(e) => {
+                                    e.duration()
+                                }
+                            };
                             let payload = payment_event_payloads.get(&pubkey).ok_or(SimulationError::PaymentGenerationError(
                                     PaymentGenerationError(format!("executor {} not found", pubkey)),
                             ))?;
@@ -1122,22 +1129,24 @@ impl<C: Clock + 'static> Simulation<C> {
                             // a payment amount something has gone wrong (because we should have validated that we can always
                             // generate amounts), so we exit.
                             let amount = payload.executor.payment_generator.payment_amount(capacity).map_err(SimulationError::PaymentGenerationError)?;
-                            generate_payment(&mut heap, pubkey, payload.current_count + 1, &mut payment_event_payloads, SystemTime::now()).await?;
                             if amount == 0 {
                                 log::debug!(
                                     "Skipping zero amount payment for {source} -> {}.", destination
                                 );
+                                generate_payment(&mut heap, pubkey, payload.current_count, &mut payment_event_payloads, SystemTime::now()).await?;
                                 continue;
                             }
 
                             // Wait until our time to next payment has elapsed then execute a random amount payment to a random
                             // destination.
+                            let next_payment_count = payload.current_count + 1;
                             select! {
                                 biased;
                                 _ = listener.clone()  => {
                                     return Ok(())
                                 },
                                 _ = pe_clock.sleep(wait_time) => {
+                                    generate_payment(&mut heap, pubkey, next_payment_count, &mut payment_event_payloads, SystemTime::now()).await?;
                                     task_clone.spawn(async move {
                                         log::debug!("Generated payment: {source} -> {}: {amount} msat.", destination);
 
@@ -1533,7 +1542,6 @@ async fn generate_payment(
     let payment_event = PaymentEvent {
         pubkey,
         absolute_time,
-        wait_time,
         destination,
         capacity,
     };
@@ -2054,24 +2062,25 @@ mod tests {
         let elapsed = start.elapsed();
 
         let expected_payment_list = vec![
-            node_2.pubkey,
             node_2.pubkey,
             node_4.pubkey,
             node_2.pubkey,
-            node_4.pubkey,
             node_2.pubkey,
             node_4.pubkey,
             node_2.pubkey,
+            node_2.pubkey,
+            node_4.pubkey,
             node_4.pubkey,
             node_4.pubkey,
         ];
 
-        // Check that simulation ran 30 because
+        // Check that simulation ran 20ish seconds because
         // from activity_1 there are 5 payments with a wait_time of 2s -> 10s
         // from activity_2 there are 5 payments with a wait_time of 4s -> 20s
+        // but the wait time is interleave between the payments.
         assert!(
-            elapsed >= Duration::from_secs(30),
-            "Simulation should have run at least for 30s, took {:?}",
+            elapsed <= Duration::from_secs(21),
+            "Simulation should have run no more than 21, took {:?}",
             elapsed
         );