GH-728: Finish the password-change logic

multinode_integration_tests/tests/blockchain_interaction_test.rs

@@ -5,7 +5,6 @@ use std::path::PathBuf;
 use std::time::{Duration, SystemTime};
 
 use log::Level;
-use regex::escape;
 use serde_derive::Serialize;
 
 use masq_lib::messages::{FromMessageBody, ScanType, ToMessageBody, UiScanRequest, UiScanResponse};
@@ -157,19 +156,15 @@ fn blockchain_bridge_starts_properly_on_bootstrap() {
     let mut cluster = MASQNodeCluster::start().unwrap();
     let private_key = "0011223300112233001122330011223300112233001122330011223300112233";
     let subject = cluster.start_real_node(
-        NodeStartupConfigBuilder::zero_hop()
+        NodeStartupConfigBuilder::standard()
             .consuming_wallet_info(ConsumingWalletInfo::PrivateKey(private_key.to_string()))
             .chain(cluster.chain)
             .build(),
     );
 
-    let escaped_pattern = escape(&format!(
-        "DEBUG: BlockchainBridge: Received BindMessage; consuming wallet address {}",
-        subject.consuming_wallet().unwrap()
-    ));
     MASQNodeUtils::wrote_log_containing(
         subject.name(),
-        &escaped_pattern,
+        "DEBUG: BlockchainBridge: Received BindMessage",
         Duration::from_millis(1000),
     )
 }

node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/msgs.rs

@@ -2,23 +2,27 @@
 
 use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
 use crate::accountant::{ResponseSkeleton, SkeletonOptHolder};
+use crate::sub_lib::wallet::Wallet;
 use actix::Message;
 use masq_lib::type_obfuscation::Obfuscated;
 use std::fmt::Debug;
 
 #[derive(Debug, Message, PartialEq, Eq, Clone)]
 pub struct QualifiedPayablesMessage {
     pub protected_qualified_payables: Obfuscated,
+    pub consuming_wallet: Wallet,
     pub response_skeleton_opt: Option<ResponseSkeleton>,
 }
 
 impl QualifiedPayablesMessage {
     pub(in crate::accountant) fn new(
         protected_qualified_payables: Obfuscated,
+        consuming_wallet: Wallet,
         response_skeleton_opt: Option<ResponseSkeleton>,
     ) -> Self {
         Self {
             protected_qualified_payables,
+            consuming_wallet,
             response_skeleton_opt,
         }
     }

node/src/accountant/scanners/mod.rs

@@ -69,7 +69,6 @@ impl Scanners {
     pub fn new(
         dao_factories: DaoFactories,
         payment_thresholds: Rc<PaymentThresholds>,
-        earning_wallet: Rc<Wallet>,
         when_pending_too_long_sec: u64,
         financial_statistics: Rc<RefCell<FinancialStatistics>>,
     ) -> Self {
@@ -95,7 +94,6 @@ impl Scanners {
             dao_factories.banned_dao_factory.make(),
             Box::new(persistent_configuration),
             Rc::clone(&payment_thresholds),
-            earning_wallet,
             financial_statistics,
         ));
 
@@ -114,6 +112,7 @@ where
 {
     fn begin_scan(
         &mut self,
+        wallet: Wallet,
         timestamp: SystemTime,
         response_skeleton_opt: Option<ResponseSkeleton>,
         logger: &Logger,
@@ -194,6 +193,7 @@ pub struct PayableScanner {
 impl Scanner<QualifiedPayablesMessage, SentPayables> for PayableScanner {
     fn begin_scan(
         &mut self,
+        consuming_wallet: Wallet,
         timestamp: SystemTime,
         response_skeleton_opt: Option<ResponseSkeleton>,
         logger: &Logger,
@@ -226,8 +226,11 @@ impl Scanner<QualifiedPayablesMessage, SentPayables> for PayableScanner {
                     qualified_payables.len()
                 );
                 let protected_payables = self.protect_payables(qualified_payables);
-                let outgoing_msg =
-                    QualifiedPayablesMessage::new(protected_payables, response_skeleton_opt);
+                let outgoing_msg = QualifiedPayablesMessage::new(
+                    protected_payables,
+                    consuming_wallet,
+                    response_skeleton_opt,
+                );
                 Ok(outgoing_msg)
             }
         }
@@ -569,6 +572,7 @@ pub struct PendingPayableScanner {
 impl Scanner<RequestTransactionReceipts, ReportTransactionReceipts> for PendingPayableScanner {
     fn begin_scan(
         &mut self,
+        _irrelevant_wallet: Wallet,
         timestamp: SystemTime,
         response_skeleton_opt: Option<ResponseSkeleton>,
         logger: &Logger,
@@ -827,13 +831,13 @@ pub struct ReceivableScanner {
     pub receivable_dao: Box<dyn ReceivableDao>,
     pub banned_dao: Box<dyn BannedDao>,
     pub persistent_configuration: Box<dyn PersistentConfiguration>,
-    pub earning_wallet: Rc<Wallet>,
     pub financial_statistics: Rc<RefCell<FinancialStatistics>>,
 }
 
 impl Scanner<RetrieveTransactions, ReceivedPayments> for ReceivableScanner {
     fn begin_scan(
         &mut self,
+        earning_wallet: Wallet,
         timestamp: SystemTime,
         response_skeleton_opt: Option<ResponseSkeleton>,
         logger: &Logger,
@@ -842,14 +846,11 @@ impl Scanner<RetrieveTransactions, ReceivedPayments> for ReceivableScanner {
             return Err(BeginScanError::ScanAlreadyRunning(timestamp));
         }
         self.mark_as_started(timestamp);
-        info!(
-            logger,
-            "Scanning for receivables to {}", self.earning_wallet
-        );
+        info!(logger, "Scanning for receivables to {}", earning_wallet);
         self.scan_for_delinquencies(timestamp, logger);
 
         Ok(RetrieveTransactions {
-            recipient: self.earning_wallet.as_ref().clone(),
+            recipient: earning_wallet,
             response_skeleton_opt,
         })
     }
@@ -895,12 +896,10 @@ impl ReceivableScanner {
         banned_dao: Box<dyn BannedDao>,
         persistent_configuration: Box<dyn PersistentConfiguration>,
         payment_thresholds: Rc<PaymentThresholds>,
-        earning_wallet: Rc<Wallet>,
         financial_statistics: Rc<RefCell<FinancialStatistics>>,
     ) -> Self {
         Self {
             common: ScannerCommon::new(payment_thresholds),
-            earning_wallet,
             receivable_dao,
             banned_dao,
             persistent_configuration,
@@ -987,6 +986,7 @@ impl ReceivableScanner {
 #[derive(Debug, PartialEq, Eq)]
 pub enum BeginScanError {
     NothingToProcess,
+    NoConsumingWalletFound,
     ScanAlreadyRunning(SystemTime),
     CalledFromNullScanner, // Exclusive for tests
 }
@@ -1009,6 +1009,10 @@ impl BeginScanError {
                 scan_type,
                 BeginScanError::timestamp_as_string(timestamp)
             )),
+            BeginScanError::NoConsumingWalletFound => Some(format!(
+                "Cannot initiate {:?} scan because no consuming wallet was found.",
+                scan_type
+            )),
             BeginScanError::CalledFromNullScanner => match cfg!(test) {
                 true => None,
                 false => panic!("Null Scanner shouldn't be running inside production code."),
@@ -1136,9 +1140,9 @@ mod tests {
         DaoFactories, FinancialStatistics, PaymentThresholds, ScanIntervals,
         DEFAULT_PAYMENT_THRESHOLDS,
     };
-    use crate::test_utils::make_wallet;
     use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock;
     use crate::test_utils::unshared_test_utils::arbitrary_id_stamp::ArbitraryIdStamp;
+    use crate::test_utils::{make_paying_wallet, make_wallet};
     use actix::{Message, System};
     use ethereum_types::U64;
     use masq_lib::logger::Logger;
@@ -1176,7 +1180,6 @@ mod tests {
             total_paid_payable_wei: 1,
             total_paid_receivable_wei: 2,
         };
-        let earning_wallet = make_wallet("unique_wallet");
         let payment_thresholds = make_custom_payment_thresholds();
         let payment_thresholds_rc = Rc::new(payment_thresholds);
         let initial_rc_count = Rc::strong_count(&payment_thresholds_rc);
@@ -1190,7 +1193,6 @@ mod tests {
                 config_dao_factory: Box::new(config_dao_factory),
             },
             Rc::clone(&payment_thresholds_rc),
-            Rc::new(earning_wallet.clone()),
             when_pending_too_long_sec,
             Rc::new(RefCell::new(financial_statistics.clone())),
         );
@@ -1235,10 +1237,6 @@ mod tests {
             *receivable_scanner.financial_statistics.borrow(),
             financial_statistics
         );
-        assert_eq!(
-            receivable_scanner.earning_wallet.address(),
-            earning_wallet.address()
-        );
         assert_eq!(
             receivable_scanner.common.payment_thresholds.as_ref(),
             &payment_thresholds
@@ -1275,6 +1273,7 @@ mod tests {
     fn payable_scanner_can_initiate_a_scan() {
         init_test_logging();
         let test_name = "payable_scanner_can_initiate_a_scan";
+        let consuming_wallet = make_paying_wallet(b"consuming wallet");
         let now = SystemTime::now();
         let (qualified_payable_accounts, _, all_non_pending_payables) =
             make_payables(now, &PaymentThresholds::default());
@@ -1284,7 +1283,8 @@ mod tests {
             .payable_dao(payable_dao)
             .build();
 
-        let result = subject.begin_scan(now, None, &Logger::new(test_name));
+        let result =
+            subject.begin_scan(consuming_wallet.clone(), now, None, &Logger::new(test_name));
 
         let timestamp = subject.scan_started_at();
         assert_eq!(timestamp, Some(now));
@@ -1294,6 +1294,7 @@ mod tests {
                 protected_qualified_payables: protect_payables_in_test(
                     qualified_payable_accounts.clone()
                 ),
+                consuming_wallet,
                 response_skeleton_opt: None,
             })
         );
@@ -1308,16 +1309,22 @@ mod tests {
 
     #[test]
     fn payable_scanner_throws_error_when_a_scan_is_already_running() {
+        let consuming_wallet = make_paying_wallet(b"consuming wallet");
         let now = SystemTime::now();
         let (_, _, all_non_pending_payables) = make_payables(now, &PaymentThresholds::default());
         let payable_dao =
             PayableDaoMock::new().non_pending_payables_result(all_non_pending_payables);
         let mut subject = PayableScannerBuilder::new()
             .payable_dao(payable_dao)
             .build();
-        let _result = subject.begin_scan(now, None, &Logger::new("test"));
+        let _result = subject.begin_scan(consuming_wallet.clone(), now, None, &Logger::new("test"));
 
-        let run_again_result = subject.begin_scan(SystemTime::now(), None, &Logger::new("test"));
+        let run_again_result = subject.begin_scan(
+            consuming_wallet,
+            SystemTime::now(),
+            None,
+            &Logger::new("test"),
+        );
 
         let is_scan_running = subject.scan_started_at().is_some();
         assert_eq!(is_scan_running, true);
@@ -1329,6 +1336,7 @@ mod tests {
 
     #[test]
     fn payable_scanner_throws_error_in_case_no_qualified_payable_is_found() {
+        let consuming_wallet = make_paying_wallet(b"consuming wallet");
         let now = SystemTime::now();
         let (_, unqualified_payable_accounts, _) =
             make_payables(now, &PaymentThresholds::default());
@@ -1338,7 +1346,7 @@ mod tests {
             .payable_dao(payable_dao)
             .build();
 
-        let result = subject.begin_scan(now, None, &Logger::new("test"));
+        let result = subject.begin_scan(consuming_wallet, now, None, &Logger::new("test"));
 
         let is_scan_running = subject.scan_started_at().is_some();
         assert_eq!(is_scan_running, false);
@@ -2178,6 +2186,7 @@ mod tests {
     fn pending_payable_scanner_can_initiate_a_scan() {
         init_test_logging();
         let test_name = "pending_payable_scanner_can_initiate_a_scan";
+        let consuming_wallet = make_paying_wallet(b"consuming wallet");
         let now = SystemTime::now();
         let payable_fingerprint_1 = PendingPayableFingerprint {
             rowid: 555,
@@ -2202,7 +2211,12 @@ mod tests {
             .pending_payable_dao(pending_payable_dao)
             .build();
 
-        let result = pending_payable_scanner.begin_scan(now, None, &Logger::new(test_name));
+        let result = pending_payable_scanner.begin_scan(
+            consuming_wallet,
+            now,
+            None,
+            &Logger::new(test_name),
+        );
 
         let no_of_pending_payables = fingerprints.len();
         let is_scan_running = pending_payable_scanner.scan_started_at().is_some();
@@ -2225,6 +2239,7 @@ mod tests {
     #[test]
     fn pending_payable_scanner_throws_error_in_case_scan_is_already_running() {
         let now = SystemTime::now();
+        let consuming_wallet = make_paying_wallet(b"consuming");
         let pending_payable_dao = PendingPayableDaoMock::new()
             .return_all_errorless_fingerprints_result(vec![PendingPayableFingerprint {
                 rowid: 1234,
@@ -2238,9 +2253,9 @@ mod tests {
             .pending_payable_dao(pending_payable_dao)
             .build();
         let logger = Logger::new("test");
-        let _ = subject.begin_scan(now, None, &logger);
+        let _ = subject.begin_scan(consuming_wallet.clone(), now, None, &logger);
 
-        let result = subject.begin_scan(SystemTime::now(), None, &logger);
+        let result = subject.begin_scan(consuming_wallet, SystemTime::now(), None, &logger);
 
         let is_scan_running = subject.scan_started_at().is_some();
         assert_eq!(is_scan_running, true);
@@ -2250,13 +2265,15 @@ mod tests {
     #[test]
     fn pending_payable_scanner_throws_an_error_when_no_fingerprint_is_found() {
         let now = SystemTime::now();
+        let consuming_wallet = make_paying_wallet(b"consuming_wallet");
         let pending_payable_dao =
             PendingPayableDaoMock::new().return_all_errorless_fingerprints_result(vec![]);
         let mut pending_payable_scanner = PendingPayableScannerBuilder::new()
             .pending_payable_dao(pending_payable_dao)
             .build();
 
-        let result = pending_payable_scanner.begin_scan(now, None, &Logger::new("test"));
+        let result =
+            pending_payable_scanner.begin_scan(consuming_wallet, now, None, &Logger::new("test"));
 
         let is_scan_running = pending_payable_scanner.scan_started_at().is_some();
         assert_eq!(result, Err(BeginScanError::NothingToProcess));
@@ -2892,10 +2909,14 @@ mod tests {
         let earning_wallet = make_wallet("earning");
         let mut receivable_scanner = ReceivableScannerBuilder::new()
             .receivable_dao(receivable_dao)
-            .earning_wallet(earning_wallet.clone())
             .build();
 
-        let result = receivable_scanner.begin_scan(now, None, &Logger::new(test_name));
+        let result = receivable_scanner.begin_scan(
+            earning_wallet.clone(),
+            now,
+            None,
+            &Logger::new(test_name),
+        );
 
         let is_scan_running = receivable_scanner.scan_started_at().is_some();
         assert_eq!(is_scan_running, true);
@@ -2920,11 +2941,16 @@ mod tests {
         let earning_wallet = make_wallet("earning");
         let mut receivable_scanner = ReceivableScannerBuilder::new()
             .receivable_dao(receivable_dao)
-            .earning_wallet(earning_wallet)
             .build();
-        let _ = receivable_scanner.begin_scan(now, None, &Logger::new("test"));
+        let _ =
+            receivable_scanner.begin_scan(earning_wallet.clone(), now, None, &Logger::new("test"));
 
-        let result = receivable_scanner.begin_scan(SystemTime::now(), None, &Logger::new("test"));
+        let result = receivable_scanner.begin_scan(
+            earning_wallet,
+            SystemTime::now(),
+            None,
+            &Logger::new("test"),
+        );
 
         let is_scan_running = receivable_scanner.scan_started_at().is_some();
         assert_eq!(is_scan_running, true);
@@ -2957,12 +2983,11 @@ mod tests {
             .receivable_dao(receivable_dao)
             .banned_dao(banned_dao)
             .payment_thresholds(payment_thresholds)
-            .earning_wallet(earning_wallet.clone())
             .build();
         let logger = Logger::new("DELINQUENCY_TEST");
         let now = SystemTime::now();
 
-        let result = receivable_scanner.begin_scan(now, None, &logger);
+        let result = receivable_scanner.begin_scan(earning_wallet.clone(), now, None, &logger);
 
         assert_eq!(
             result,