fixup! 2beccfa

Author: f3r10

simln-lib/src/lib.rs

@@ -625,6 +625,7 @@ struct ExecutorKit {
 }
 
 struct PaymentEvent {
+    absolute_time: SystemTime,
     wait_time: Duration,
     destination: NodeInfo,
     current_count: u64,
@@ -634,7 +635,7 @@ struct PaymentEvent {
 
 impl Ord for PaymentEvent {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.wait_time.cmp(&other.wait_time)
+        self.absolute_time.cmp(&other.absolute_time)
     }
 }
 
@@ -646,7 +647,7 @@ impl PartialOrd for PaymentEvent {
 
 impl PartialEq for PaymentEvent {
     fn eq(&self, other: &Self) -> bool {
-        self.wait_time == other.wait_time
+        self.absolute_time == other.absolute_time
     }
 }
 
@@ -1109,7 +1110,7 @@ impl<C: Clock + 'static> Simulation<C> {
     ) -> Result<(), SimulationError> {
         let mut heap: BinaryHeap<Reverse<PaymentEvent>> = BinaryHeap::new();
         for executor in executors {
-            generate_payments(&mut heap, executor, 0)?;
+            generate_payment(&mut heap, executor, 0)?;
         }
 
         let listener = self.shutdown_listener.clone();
@@ -1127,19 +1128,19 @@ impl<C: Clock + 'static> Simulation<C> {
                 _ = async {} => {
                     match heap.pop() {
                         Some(Reverse(PaymentEvent {
+                            absolute_time: _,
                             wait_time,
                             destination,
                             current_count,
                             capacity,
                             executor,
                         })) => {
-
                             if let Some(c) = executor.payment_generator.payment_count() {
                                 if c == current_count {
                                     log::info!(
                                         "Payment count has been met for {}: {c} payments. Stopping the activity."
                                     , executor.source_info);
-                                    return Ok(());
+                                    continue
                                 }
                             }
                             let sender = producer_channels.get(&executor.source_info.pubkey).ok_or(
@@ -1167,17 +1168,17 @@ impl<C: Clock + 'static> Simulation<C> {
                                         log::debug!(
                                             "Skipping zero amount payment for {source} -> {destination}."
                                         );
-                                        generate_payments(&mut heap, executor, current_count)?;
+                                        generate_payment(&mut heap, executor, current_count)?;
                                         continue;
-                                    } else {
-                                        generate_payments(&mut heap, executor, current_count + 1)?;
-                                    }
+                                    } 
                                     amt
                                 },
                                 Err(e) => {
                                     return Err(SimulationError::PaymentGenerationError(e));
                                 },
                             };
+                            generate_payment(&mut heap, executor, current_count + 1)?;
+
                             // Wait until our time to next payment has elapsed then execute a random amount payment to a random
                             // destination.
                             pe_clock.sleep(wait_time).await;
@@ -1610,21 +1611,25 @@ async fn track_payment_result(
     Ok(())
 }
 
-fn generate_payments(
+fn generate_payment(
     heap: &mut BinaryHeap<Reverse<PaymentEvent>>,
     executor: ExecutorKit,
     current_count: u64,
 ) -> Result<(), SimulationError> {
+    let now = SystemTime::now();
     let wait_time = get_payment_delay(
         current_count,
         &executor.source_info,
         executor.payment_generator.as_ref(),
     )?;
+    let absolute_time = now.checked_add(wait_time).ok_or("Overflow adding duration").unwrap();
+
     let (destination, capacity) = executor
         .network_generator
         .choose_destination(executor.source_info.pubkey)
         .map_err(SimulationError::DestinationGenerationError)?;
     let payment_event = PaymentEvent {
+        absolute_time,
         wait_time,
         destination,
         current_count,