GH-552: Eliminate extra block increment

node/src/blockchain/blockchain_bridge.rs

@@ -1290,7 +1290,7 @@ mod tests {
         let amount = 42;
         let amount2 = 55;
         let expected_transactions = RetrievedBlockchainTransactions {
-            new_start_block: BlockNumber::Number(8675309u64.into()),
+            new_start_block: BlockNumber::Number(100_006u64.into()),
             transactions: vec![
                 BlockchainTransaction {
                     block_number: 7,
@@ -1356,7 +1356,7 @@ mod tests {
             &ReceivedPayments {
                 timestamp: received_payments.timestamp,
                 payments: expected_transactions.transactions,
-                new_start_block: 8675309u64,
+                new_start_block: 100_006u64,
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
                     context_id: 4321
@@ -1703,6 +1703,148 @@ mod tests {
         let _ = subject.handle_retrieve_transactions(retrieve_transactions);
     }
 
+    #[test]
+    fn handle_retrieve_transactions_repeated_calling_does_not_skip_blocks() {
+        let retrieve_transactions_params_arc = Arc::new(Mutex::new(vec![]));
+        let system =
+            System::new("handle_retrieve_transactions_repeated_calling_does_not_skip_blocks");
+        let (accountant, _, accountant_recording_arc) = make_recorder();
+        let earning_wallet = make_wallet("earningwallet");
+        let amount_1 = 42;
+        let amount_2 = 55;
+        let amount_3 = 75;
+        let amount_4 = 99;
+        let initial_start_block: u64 = 0x45f2f3; // 4_584_179
+        let new_start_block_1 = initial_start_block + 1 + DEFAULT_MAX_BLOCK_COUNT;
+        let new_start_block_2 = initial_start_block + 2 + (2 * DEFAULT_MAX_BLOCK_COUNT);
+        let new_start_block_3 = initial_start_block + 3 + (3 * DEFAULT_MAX_BLOCK_COUNT);
+        let new_start_block_4 = 0x4be667;
+        let make_expected_transactions =
+            |new_start_block: u64, initial_start_block_increment: u64, wei_amount: u128| {
+                RetrievedBlockchainTransactions {
+                    new_start_block: BlockNumber::Number(new_start_block.into()),
+                    transactions: vec![BlockchainTransaction {
+                        block_number: initial_start_block + initial_start_block_increment,
+                        from: earning_wallet.clone(),
+                        wei_amount,
+                    }],
+                }
+            };
+        let expected_transactions_1 =
+            make_expected_transactions(new_start_block_1, 0x14382, amount_1);
+        let expected_transactions_2 =
+            make_expected_transactions(new_start_block_2, 0x308b3, amount_2);
+        let expected_transactions_3 =
+            make_expected_transactions(new_start_block_3, 0x34248, amount_3);
+        let expected_transactions_4 =
+            make_expected_transactions(new_start_block_4, 0x49b7e, amount_4);
+        let lower_interface = LowBlockchainIntMock::default()
+            .get_block_number_result(Ok(0x4be663.into()))
+            .get_block_number_result(Ok(0x4be664.into()))
+            .get_block_number_result(Ok(0x4be665.into()))
+            .get_block_number_result(Ok(new_start_block_4.into()));
+        let blockchain_interface = BlockchainInterfaceMock::default()
+            .lower_interface_results(Box::new(lower_interface))
+            .retrieve_transactions_params(&retrieve_transactions_params_arc)
+            .retrieve_transactions_result(Ok(expected_transactions_1.clone()))
+            .retrieve_transactions_result(Ok(expected_transactions_2.clone()))
+            .retrieve_transactions_result(Ok(expected_transactions_3.clone()))
+            .retrieve_transactions_result(Ok(expected_transactions_4.clone()));
+        let persistent_config = PersistentConfigurationMock::new()
+            .max_block_count_result(Ok(Some(DEFAULT_MAX_BLOCK_COUNT)))
+            .start_block_result(Ok(Some(initial_start_block)))
+            .start_block_result(Ok(Some(new_start_block_1)))
+            .start_block_result(Ok(Some(new_start_block_2)))
+            .start_block_result(Ok(Some(new_start_block_3)))
+            .start_block_result(Ok(Some(new_start_block_4)));
+        let subject = BlockchainBridge::new(
+            Box::new(blockchain_interface),
+            Box::new(persistent_config),
+            false,
+        );
+        let addr = subject.start();
+        let subject_subs = BlockchainBridge::make_subs_from(&addr);
+        let peer_actors = peer_actors_builder().accountant(accountant).build();
+        send_bind_message!(subject_subs, peer_actors);
+        let make_retrieve_transactions_msg = |context_id: u64| RetrieveTransactions {
+            recipient: earning_wallet.clone(),
+            response_skeleton_opt: Some(ResponseSkeleton {
+                client_id: 1234,
+                context_id,
+            }),
+        };
+        let requests = (1..=4)
+            .map(|context_id| RetrieveTransactions {
+                recipient: earning_wallet.clone(),
+                response_skeleton_opt: Some(ResponseSkeleton {
+                    client_id: 1234,
+                    context_id,
+                }),
+            })
+            .collect_vec();
+        let before = SystemTime::now();
+
+        requests.into_iter().for_each(|request| {
+            addr.try_send(request).unwrap();
+        });
+
+        System::current().stop();
+        system.run();
+        let after = SystemTime::now();
+        let retrieve_transactions_params = retrieve_transactions_params_arc.lock().unwrap();
+        assert_eq!(
+            *retrieve_transactions_params,
+            vec![
+                (
+                    BlockNumber::Number(initial_start_block.into()),
+                    BlockNumber::Number((initial_start_block + DEFAULT_MAX_BLOCK_COUNT).into()),
+                    earning_wallet.clone()
+                ),
+                (
+                    BlockNumber::Number(new_start_block_1.into()),
+                    BlockNumber::Number((new_start_block_1 + DEFAULT_MAX_BLOCK_COUNT).into()),
+                    earning_wallet.clone()
+                ),
+                (
+                    BlockNumber::Number(new_start_block_2.into()),
+                    BlockNumber::Number((new_start_block_2 + DEFAULT_MAX_BLOCK_COUNT).into()),
+                    earning_wallet.clone()
+                ),
+                (
+                    BlockNumber::Number(new_start_block_3.into()),
+                    BlockNumber::Number(new_start_block_4.into()),
+                    earning_wallet.clone()
+                ),
+            ]
+        );
+        let accountant_received_payment = accountant_recording_arc.lock().unwrap();
+        vec![
+            (expected_transactions_1, new_start_block_1),
+            (expected_transactions_2, new_start_block_2),
+            (expected_transactions_3, new_start_block_3),
+            (expected_transactions_4, new_start_block_4),
+        ]
+        .into_iter()
+        .enumerate()
+        .for_each(|(idx, (expected_transactions, new_start_block))| {
+            let received_payment = accountant_received_payment.get_record::<ReceivedPayments>(idx);
+            check_timestamp(before, received_payment.timestamp, after);
+            assert_eq!(
+                received_payment,
+                &ReceivedPayments {
+                    timestamp: received_payment.timestamp,
+                    payments: expected_transactions.transactions,
+                    new_start_block,
+                    response_skeleton_opt: Some(ResponseSkeleton {
+                        client_id: 1234,
+                        context_id: idx as u64 + 1
+                    }),
+                }
+            );
+        });
+        assert_eq!(accountant_received_payment.len(), 4);
+    }
+
     fn success_handler(
         _bcb: &mut BlockchainBridge,
         _msg: RetrieveTransactions,