GH-598: second QA fix - first review

multinode_integration_tests/tests/verify_bill_payment.rs

@@ -465,7 +465,7 @@ fn verify_pending_payables() {
     }
     MASQNodeUtils::assert_node_wrote_log_containing(
         real_consuming_node.name(),
-        "Found 3 pending payables and 0 unfinalized failures to process",
+        "Found 3 pending payables and 0 suspected failures to process",
         Duration::from_secs(5),
     );
     MASQNodeUtils::assert_node_wrote_log_containing(

node/src/accountant/mod.rs

@@ -348,8 +348,8 @@ impl Handler<TxReceiptsMessage> for Accountant {
                 if let Some(node_to_ui_msg) = ui_msg_opt {
                     info!(
                         self.logger,
-                        "Re-running the pending payable scan is recommended, as some \
-                    parts did not finish last time."
+                        "Re-running the pending payable scan is recommended, as some parts \
+                        did not finish last time."
                     );
                     self.ui_message_sub_opt
                         .as_ref()
@@ -417,27 +417,34 @@ impl Handler<ScanError> for Accountant {
 
     fn handle(&mut self, scan_error: ScanError, ctx: &mut Self::Context) -> Self::Result {
         error!(self.logger, "Received ScanError: {:?}", scan_error);
+
         self.scanners
             .acknowledge_scan_error(&scan_error, &self.logger);
 
         match scan_error.response_skeleton_opt {
-            None => match scan_error.scan_type {
-                DetailedScanType::NewPayables => self
-                    .scan_schedulers
-                    .payable
-                    .schedule_new_payable_scan(ctx, &self.logger),
-                DetailedScanType::RetryPayables => self
-                    .scan_schedulers
-                    .payable
-                    .schedule_retry_payable_scan(ctx, None, &self.logger),
-                DetailedScanType::PendingPayables => self
-                    .scan_schedulers
-                    .pending_payable
-                    .schedule(ctx, &self.logger),
-                DetailedScanType::Receivables => {
-                    self.scan_schedulers.receivable.schedule(ctx, &self.logger)
+            None => {
+                debug!(
+                    self.logger,
+                    "Trying to restore the scan train after a crash"
+                );
+                match scan_error.scan_type {
+                    DetailedScanType::NewPayables => self
+                        .scan_schedulers
+                        .payable
+                        .schedule_new_payable_scan(ctx, &self.logger),
+                    DetailedScanType::RetryPayables => self
+                        .scan_schedulers
+                        .payable
+                        .schedule_retry_payable_scan(ctx, None, &self.logger),
+                    DetailedScanType::PendingPayables => self
+                        .scan_schedulers
+                        .pending_payable
+                        .schedule(ctx, &self.logger),
+                    DetailedScanType::Receivables => {
+                        self.scan_schedulers.receivable.schedule(ctx, &self.logger)
+                    }
                 }
-            },
+            }
             Some(response_skeleton) => {
                 let error_msg = NodeToUiMessage {
                     target: ClientId(response_skeleton.client_id),
@@ -975,7 +982,7 @@ impl Accountant {
                 None => Err(StartScanError::NoConsumingWalletFound),
             };
 
-        self.scan_schedulers.payable.reset_scan_timer();
+        self.scan_schedulers.payable.reset_scan_timer(&self.logger);
 
         match result {
             Ok(scan_message) => {
@@ -3333,7 +3340,7 @@ mod tests {
             Mutex<Vec<(Wallet, SystemTime, Option<ResponseSkeleton>, Logger, String)>>,
         >,
         notify_and_notify_later_params: &NotifyAndNotifyLaterParams,
-        time_until_next_scan_until_next_new_payable_scan_params_arc: Arc<Mutex<Vec<()>>>,
+        time_until_next_new_payable_scan_params_arc: Arc<Mutex<Vec<()>>>,
         new_payable_expected_computed_interval: Duration,
     ) {
         // Note that there is no functionality from the payable scanner actually running.
@@ -3351,14 +3358,9 @@ mod tests {
                 new_payable_expected_computed_interval
             )]
         );
-        let time_until_next_scan_until_next_new_payable_scan_params =
-            time_until_next_scan_until_next_new_payable_scan_params_arc
-                .lock()
-                .unwrap();
-        assert_eq!(
-            *time_until_next_scan_until_next_new_payable_scan_params,
-            vec![()]
-        );
+        let time_until_next_new_payable_scan_params =
+            time_until_next_new_payable_scan_params_arc.lock().unwrap();
+        assert_eq!(*time_until_next_new_payable_scan_params, vec![()]);
         let payable_scanner_start_scan = payable_scanner_start_scan_arc.lock().unwrap();
         assert!(
             payable_scanner_start_scan.is_empty(),

node/src/accountant/scanners/mod.rs

@@ -256,6 +256,7 @@ impl Scanners {
     }
 
     pub fn acknowledge_scan_error(&mut self, error: &ScanError, logger: &Logger) {
+        debug!(logger, "Acknowledging a scan that couldn't finish");
         match error.scan_type {
             DetailedScanType::NewPayables | DetailedScanType::RetryPayables => {
                 self.payable.mark_as_ended(logger)
@@ -794,11 +795,11 @@ mod tests {
             false
         );
         let dumped_records = pending_payable_scanner
-            .yet_unproven_failed_payables
+            .suspected_failed_payables
             .dump_cache();
         assert!(
             dumped_records.is_empty(),
-            "There should be no yet unproven failures but found {:?}.",
+            "There should be no suspected failures but found {:?}.",
             dumped_records
         );
         assert_eq!(
@@ -1199,7 +1200,9 @@ mod tests {
         );
         TestLogHandler::new().assert_logs_match_in_order(vec![
             &format!("INFO: {test_name}: Scanning for pending payable"),
-            &format!("DEBUG: {test_name}: Found 1 pending payables and 1 unfinalized failures to process"),
+            &format!(
+                "DEBUG: {test_name}: Found 1 pending payables and 1 suspected failures to process"
+            ),
         ])
     }
 

node/src/accountant/scanners/payable_scanner/mod.rs

@@ -251,6 +251,10 @@ impl PayableScanner {
             self.insert_records_in_sent_payables(&batch_results.sent_txs);
         }
         if failed > 0 {
+            debug!(
+                logger,
+                "Recording failed txs: {:?}", batch_results.failed_txs
+            );
             self.insert_records_in_failed_payables(&batch_results.failed_txs);
         }
     }

node/src/accountant/scanners/payable_scanner/start_scan.rs

@@ -66,7 +66,7 @@ impl StartableScanner<ScanForRetryPayables, InitialTemplatesMessage> for Payable
         info!(logger, "Scanning for retry payables");
         let failed_txs = self.get_txs_to_retry();
         let amount_from_payables = self.find_amount_from_payables(&failed_txs);
-        let retry_tx_templates = RetryTxTemplates::new(&failed_txs, &amount_from_payables);
+        let retry_tx_templates = RetryTxTemplates::new(&failed_txs, &amount_from_payables, logger);
 
         Ok(InitialTemplatesMessage {
             initial_templates: Either::Right(retry_tx_templates),
@@ -157,11 +157,8 @@ mod tests {
         let retrieve_payables_params = retrieve_payables_params_arc.lock().unwrap();
         let expected_tx_templates = {
             let mut tx_template_1 = RetryTxTemplate::from(&failed_tx_1);
-            tx_template_1.base.amount_in_wei =
-                tx_template_1.base.amount_in_wei + payable_account_1.balance_wei;
-
+            tx_template_1.base.amount_in_wei = payable_account_1.balance_wei;
             let tx_template_2 = RetryTxTemplate::from(&failed_tx_2);
-
             RetryTxTemplates(vec![tx_template_1, tx_template_2])
         };
         assert_eq!(

node/src/accountant/scanners/payable_scanner/tx_templates/initial/retry.rs

@@ -1,6 +1,7 @@
 // Copyright (c) 2025, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 use crate::accountant::db_access_objects::failed_payable_dao::FailedTx;
 use crate::accountant::scanners::payable_scanner::tx_templates::BaseTxTemplate;
+use masq_lib::logger::Logger;
 use std::collections::{BTreeSet, HashMap};
 use std::ops::{Deref, DerefMut};
 use web3::types::Address;
@@ -13,11 +14,25 @@ pub struct RetryTxTemplate {
 }
 
 impl RetryTxTemplate {
-    pub fn new(failed_tx: &FailedTx, payable_scan_amount_opt: Option<u128>) -> Self {
+    pub fn new(
+        failed_tx: &FailedTx,
+        updated_payable_balance_opt: Option<u128>,
+        logger: &Logger,
+    ) -> Self {
         let mut retry_template = RetryTxTemplate::from(failed_tx);
 
-        if let Some(payable_scan_amount) = payable_scan_amount_opt {
-            retry_template.base.amount_in_wei += payable_scan_amount;
+        debug!(logger, "Tx to retry {:?}", failed_tx);
+
+        if let Some(updated_payable_balance) = updated_payable_balance_opt {
+            debug!(
+                logger,
+                "Updating the pay for {:?} from former {} to latest accounted balance {} of minor",
+                failed_tx.receiver_address,
+                failed_tx.amount_minor,
+                updated_payable_balance
+            );
+
+            retry_template.base.amount_in_wei = updated_payable_balance;
         }
 
         retry_template
@@ -44,6 +59,7 @@ impl RetryTxTemplates {
     pub fn new(
         txs_to_retry: &BTreeSet<FailedTx>,
         amounts_from_payables: &HashMap<Address, u128>,
+        logger: &Logger,
     ) -> Self {
         Self(
             txs_to_retry
@@ -52,7 +68,7 @@ impl RetryTxTemplates {
                     let payable_scan_amount_opt = amounts_from_payables
                         .get(&tx_to_retry.receiver_address)
                         .copied();
-                    RetryTxTemplate::new(tx_to_retry, payable_scan_amount_opt)
+                    RetryTxTemplate::new(tx_to_retry, payable_scan_amount_opt, logger)
                 })
                 .collect(),
         )
@@ -98,6 +114,49 @@ mod tests {
     };
     use crate::accountant::scanners::payable_scanner::tx_templates::BaseTxTemplate;
     use crate::blockchain::test_utils::{make_address, make_tx_hash};
+    use masq_lib::logger::Logger;
+
+    #[test]
+    fn retry_tx_template_constructor_works() {
+        let receiver_address = make_address(42);
+        let amount_in_wei = 1_000_000;
+        let gas_price = 20_000_000_000;
+        let nonce = 123;
+        let tx_hash = make_tx_hash(789);
+        let failed_tx = FailedTx {
+            hash: tx_hash,
+            receiver_address,
+            amount_minor: amount_in_wei,
+            gas_price_minor: gas_price,
+            nonce,
+            timestamp: 1234567,
+            reason: FailureReason::PendingTooLong,
+            status: FailureStatus::RetryRequired,
+        };
+        let logger = Logger::new("test");
+        let fetched_balance_from_payable_table_opt_1 = None;
+        let fetched_balance_from_payable_table_opt_2 = Some(1_234_567);
+
+        let result_1 = RetryTxTemplate::new(
+            &failed_tx,
+            fetched_balance_from_payable_table_opt_1,
+            &logger,
+        );
+        let result_2 = RetryTxTemplate::new(
+            &failed_tx,
+            fetched_balance_from_payable_table_opt_2,
+            &logger,
+        );
+
+        let assert = |result: RetryTxTemplate, expected_amount_in_wei: u128| {
+            assert_eq!(result.base.receiver_address, receiver_address);
+            assert_eq!(result.base.amount_in_wei, expected_amount_in_wei);
+            assert_eq!(result.prev_gas_price_wei, gas_price);
+            assert_eq!(result.prev_nonce, nonce);
+        };
+        assert(result_1, amount_in_wei);
+        assert(result_2, fetched_balance_from_payable_table_opt_2.unwrap());
+    }
 
     #[test]
     fn retry_tx_template_can_be_created_from_failed_tx() {