diff --git a/masq/tests/startup_shutdown_tests_integration.rs b/masq/tests/startup_shutdown_tests_integration.rs
index c0f681c29..c66589130 100644
--- a/masq/tests/startup_shutdown_tests_integration.rs
+++ b/masq/tests/startup_shutdown_tests_integration.rs
@@ -115,6 +115,8 @@ fn handles_startup_and_shutdown_integration() {
         "zero-hop",
         "--data-directory",
         dir_path.to_str().unwrap(),
+        "--blockchain-service-url",
+        "https://nonexistentblockchainservice.com",
     ]);
 
     let (stdout, stderr, exit_code) = masq_handle.stop();
diff --git a/masq_lib/src/test_utils/mock_blockchain_client_server.rs b/masq_lib/src/test_utils/mock_blockchain_client_server.rs
new file mode 100644
index 000000000..424a4433d
--- /dev/null
+++ b/masq_lib/src/test_utils/mock_blockchain_client_server.rs
@@ -0,0 +1,417 @@
+// Copyright (c) 2022, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
+
+use crate::test_utils::utils::UrlHolder;
+use crate::utils::localhost;
+use crossbeam_channel::{unbounded, Receiver, Sender};
+use itertools::Either;
+use itertools::Either::{Left, Right};
+use lazy_static::lazy_static;
+use regex::Regex;
+use serde::Serialize;
+use std::io::{ErrorKind, Read, Write};
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpListener, TcpStream};
+use std::sync::{Arc, Mutex};
+use std::thread;
+use std::thread::JoinHandle;
+use std::time::Duration;
+
+lazy_static! {
+    pub static ref CONTENT_LENGTH_DETECTOR: Regex =
+        Regex::new(r"[Cc]ontent-[Ll]ength: *(\d+)\r\n").expect("Bad regular expression");
+    pub static ref HTTP_VERSION_DETECTOR: Regex =
+        Regex::new(r"HTTP/(\d\.\d)").expect("Bad regular expression");
+}
+
+pub struct MBCSBuilder {
+    port: u16,
+    run_in_docker: bool,
+    response_batch_opt: Option<Vec<String>>,
+    responses: Vec<String>,
+    notifier: Sender<()>,
+}
+
+impl MBCSBuilder {
+    pub fn new(port: u16) -> Self {
+        Self {
+            port,
+            run_in_docker: false,
+            response_batch_opt: None,
+            responses: vec![],
+            notifier: unbounded().0,
+        }
+    }
+
+    pub fn run_in_docker(mut self) -> Self {
+        self.run_in_docker = true;
+        self
+    }
+
+    pub fn begin_batch(mut self) -> Self {
+        if self.response_batch_opt.is_some() {
+            panic!("Cannot nest response batches")
+        }
+        self.response_batch_opt = Some(vec![]);
+        self
+    }
+
+    pub fn end_batch(mut self) -> Self {
+        let batch_contents = self.response_batch_opt.take().unwrap();
+        self.responses
+            .push(format!("[{}]", batch_contents.join(", ")));
+        self
+    }
+
+    pub fn raw_response(self, raw_string: String) -> Self {
+        self.store_response_string(raw_string)
+    }
+
+    pub fn ok_response<R>(self, result: R, id: u64) -> Self
+    where
+        R: Serialize,
+    {
+        let result = serde_json::to_string(&result).unwrap();
+        let body = format!(
+            r#"{{"jsonrpc": "2.0", "result": {}, "id": {}}}"#,
+            result, id
+        );
+        self.store_response_string(body)
+    }
+
+    pub fn err_response<R>(self, code: i64, message: R, id: u64) -> Self
+    where
+        R: Serialize,
+    {
+        let message = serde_json::to_string(&message).unwrap();
+        let body = format!(
+            r#"{{"jsonrpc": "2.0", "error": {{ "code": {}, "message": {} }}, "id": {}}}"#,
+            code, message, id
+        );
+        self.store_response_string(body)
+    }
+
+    pub fn error<D>(self, code: u64, message: &str, data: Option<D>) -> Self
+    where
+        D: Serialize,
+    {
+        let data_str = match data.map(|d| serde_json::to_string(&d).unwrap()) {
+            None => "".to_string(),
+            Some(json) => format!(r#", "data": {}"#, json),
+        };
+        let body = format!(
+            r#"{{"jsonrpc": "2.0", "error": {{"code": {}, "message": "{}"{}}}}}"#,
+            code, message, data_str
+        );
+        self.store_response_string(body)
+    }
+
+    pub fn notifier(mut self, notifier: Sender<()>) -> Self {
+        self.notifier = notifier;
+        self
+    }
+
+    pub fn start(self) -> MockBlockchainClientServer {
+        let requests = Arc::new(Mutex::new(vec![]));
+        let mut server = MockBlockchainClientServer {
+            port_or_local_addr: if self.run_in_docker {
+                Right(SocketAddr::V4(SocketAddrV4::new(
+                    Ipv4Addr::new(172, 18, 0, 1),
+                    self.port,
+                )))
+            } else {
+                Left(self.port)
+            },
+            thread_info_opt: None,
+            requests_arc: requests,
+            responses: self.responses,
+            notifier: self.notifier,
+        };
+        server.start();
+        server
+    }
+
+    fn store_response_string(mut self, response_string: String) -> Self {
+        match self.response_batch_opt.as_mut() {
+            Some(response_batch) => response_batch.push(response_string),
+            None => self.responses.push(response_string),
+        }
+        self
+    }
+}
+
+struct MBCSThreadInfo {
+    stopper: Sender<()>,
+    join_handle: JoinHandle<()>,
+}
+
+pub struct MockBlockchainClientServer {
+    port_or_local_addr: Either<u16, SocketAddr>,
+    thread_info_opt: Option<MBCSThreadInfo>,
+    requests_arc: Arc<Mutex<Vec<String>>>,
+    responses: Vec<String>,
+    notifier: Sender<()>,
+}
+
+impl UrlHolder for MockBlockchainClientServer {
+    fn url(&self) -> String {
+        format!("http://{}", self.local_addr().unwrap())
+    }
+}
+
+impl Drop for MockBlockchainClientServer {
+    fn drop(&mut self) {
+        if let Some(thread_info) = self.thread_info_opt.take() {
+            let _ = thread_info.stopper.try_send(());
+            if let Err(e) = thread_info.join_handle.join() {
+                let msg = match e.downcast_ref::<&'static str>() {
+                    Some(m) => m.to_string(),
+                    None => match e.downcast::<String>() {
+                        Ok(m) => m.to_string(),
+                        Err(e) => format!("{:?}", e),
+                    },
+                };
+                if thread::panicking() {
+                    eprintln!(
+                        "MockBlockchainClientServer service thread also panicked: {}",
+                        msg
+                    );
+                } else {
+                    panic!("{}", msg);
+                }
+            }
+        }
+    }
+}
+
+impl MockBlockchainClientServer {
+    pub fn builder(port: u16) -> MBCSBuilder {
+        MBCSBuilder::new(port)
+    }
+
+    pub fn requests(&self) -> Vec<String> {
+        self.requests_arc.lock().unwrap().drain(..).collect()
+    }
+
+    pub fn start(&mut self) {
+        let addr = match self.port_or_local_addr {
+            Left(port) => SocketAddr::new(localhost(), port),
+            Right(addr) => addr,
+        };
+        let listener = match TcpListener::bind(addr) {
+            Ok(listener) => listener,
+            Err(e) => panic!(
+                "Error binding MBCS listener: did you remember to start the cluster first? ({:?})",
+                e
+            ),
+        };
+        listener.set_nonblocking(true).unwrap();
+        self.port_or_local_addr = Right(listener.local_addr().unwrap());
+        let requests_arc = self.requests_arc.clone();
+        let mut responses: Vec<String> = self.responses.drain(..).collect();
+        let (stopper_tx, stopper_rx) = unbounded();
+        let notifier = self.notifier.clone();
+        let join_handle = thread::spawn(move || {
+            let conn = loop {
+                if stopper_rx.try_recv().is_ok() {
+                    return;
+                }
+                match listener.accept() {
+                    Ok((conn, _)) => break conn,
+                    Err(e) if e.kind() == ErrorKind::WouldBlock => (),
+                    Err(e) if e.kind() == ErrorKind::TimedOut => (),
+                    Err(e) => panic!("MBCS accept() failed: {:?}", e),
+                };
+                thread::sleep(Duration::from_millis(100));
+            };
+            drop(listener);
+            conn.set_nonblocking(true).unwrap();
+            let mut conn_state = ConnectionState {
+                conn,
+                receive_buffer: [0u8; 16384],
+                receive_buffer_occupied: 0,
+                request_stage: RequestStage::Unparsed,
+                request_accumulator: "".to_string(),
+            };
+            Self::thread_guts(
+                &mut conn_state,
+                &requests_arc,
+                &mut responses,
+                &stopper_rx,
+                notifier,
+            );
+        });
+        self.thread_info_opt = Some(MBCSThreadInfo {
+            stopper: stopper_tx,
+            join_handle,
+        })
+    }
+
+    pub fn local_addr(&self) -> Option<SocketAddr> {
+        match self.port_or_local_addr {
+            Left(_) => None,
+            Right(local_addr) => Some(local_addr),
+        }
+    }
+
+    fn thread_guts(
+        conn_state: &mut ConnectionState,
+        requests_arc: &Arc<Mutex<Vec<String>>>,
+        responses: &mut Vec<String>,
+        stopper_rx: &Receiver<()>,
+        notifier_tx: Sender<()>,
+    ) {
+        loop {
+            if stopper_rx.try_recv().is_ok() {
+                break;
+            }
+            Self::receive_body(conn_state);
+            let body_opt = Self::process_body(conn_state);
+            match body_opt {
+                Some(body) if body.is_empty() => break,
+                Some(body) => {
+                    {
+                        let mut requests = requests_arc.lock().unwrap();
+                        requests.push(body);
+                    }
+                    if responses.is_empty() {
+                        break;
+                    }
+                    let response = responses.remove(0);
+                    Self::send_body(conn_state, response);
+                    let _ = notifier_tx.send(()); // receiver doesn't exist if test didn't set it up
+                }
+                None => (),
+            };
+            thread::sleep(Duration::from_millis(100));
+        }
+    }
+
+    fn receive_body(conn_state: &mut ConnectionState) {
+        let offset = conn_state.receive_buffer_occupied;
+        let limit = conn_state.receive_buffer.len();
+        if conn_state.receive_buffer_occupied >= limit {
+            panic!(
+                "{}-byte receive buffer overflowed; increase size or fix test",
+                conn_state.receive_buffer.len()
+            );
+        }
+        let len = match conn_state
+            .conn
+            .read(&mut conn_state.receive_buffer[offset..limit])
+        {
+            Ok(n) => n,
+            Err(e) if e.kind() == ErrorKind::Interrupted => return,
+            Err(e) if e.kind() == ErrorKind::TimedOut => return,
+            Err(e) if e.kind() == ErrorKind::WouldBlock => return,
+            Err(e) => panic!("{:?}", e),
+        };
+        conn_state.receive_buffer_occupied += len;
+        let chunk = String::from_utf8_lossy(
+            &conn_state.receive_buffer[offset..conn_state.receive_buffer_occupied],
+        );
+        conn_state.request_accumulator.extend(chunk.chars());
+    }
+
+    fn process_body(conn_state: &mut ConnectionState) -> Option<String> {
+        loop {
+            let original_stage = conn_state.request_stage.clone();
+            let request_str_opt = match conn_state.request_stage {
+                RequestStage::Unparsed => Self::handle_unparsed(conn_state),
+                RequestStage::Parsed {
+                    content_offset,
+                    content_length,
+                } => Self::handle_parsed(conn_state, content_offset, content_length),
+            };
+            match request_str_opt {
+                Some(request_str) => return Some(request_str),
+                None => {
+                    if conn_state.request_stage == original_stage {
+                        return None;
+                    }
+                }
+            }
+        }
+    }
+
+    fn handle_unparsed(conn_state: &mut ConnectionState) -> Option<String> {
+        match conn_state.request_accumulator.find("\r\n\r\n") {
+            None => None,
+            Some(crlf_offset) => {
+                let content_offset = crlf_offset + 4;
+                match HTTP_VERSION_DETECTOR.captures(&conn_state.request_accumulator) {
+                    Some(captures) => {
+                        let http_version = captures.get(1).unwrap().as_str();
+                        if http_version != "1.1" {
+                            panic!("MBCS handles only HTTP version 1.1, not {}", http_version)
+                        }
+                    }
+                    None => panic!("Request has no HTTP version"),
+                }
+                match CONTENT_LENGTH_DETECTOR.captures(&conn_state.request_accumulator) {
+                    Some(captures) => {
+                        let content_length =
+                            captures.get(1).unwrap().as_str().parse::<usize>().unwrap();
+                        conn_state.request_stage = RequestStage::Parsed {
+                            content_offset,
+                            content_length,
+                        };
+                        None
+                    }
+                    None => panic!("Request has no Content-Length header"),
+                }
+            }
+        }
+    }
+
+    fn handle_parsed(
+        conn_state: &mut ConnectionState,
+        content_offset: usize,
+        content_length: usize,
+    ) -> Option<String> {
+        let request_length = content_offset + content_length;
+        if conn_state.request_accumulator.len() >= request_length {
+            let request = conn_state.request_accumulator[0..request_length].to_string();
+            // TODO: What happens if we have multibyte Unicode characters here?
+            let delete_count = request.len();
+            let remaining_len = conn_state.receive_buffer_occupied - delete_count;
+            for i in 0..remaining_len {
+                conn_state.receive_buffer[i] = conn_state.receive_buffer[i + delete_count];
+            }
+            conn_state.receive_buffer_occupied -= delete_count;
+            conn_state.request_accumulator =
+                conn_state.request_accumulator[delete_count..].to_string();
+            conn_state.request_stage = RequestStage::Unparsed;
+            Some(request)
+        } else {
+            None
+        }
+    }
+
+    fn send_body(conn_state: &mut ConnectionState, response: String) {
+        let http = format!(
+            "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
+            response.len(),
+            response
+        );
+        conn_state.conn.write_all(http.as_bytes()).unwrap();
+    }
+}
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+enum RequestStage {
+    Unparsed,
+    Parsed {
+        content_offset: usize,
+        content_length: usize,
+    },
+}
+
+struct ConnectionState {
+    conn: TcpStream,
+    receive_buffer: [u8; 16384],
+    receive_buffer_occupied: usize,
+    request_stage: RequestStage,
+    request_accumulator: String,
+}
+
+// TODO GH-805
+// Tests for this are located: multinode_integration_tests/src/mock_blockchain_client_server.rs
diff --git a/masq_lib/src/test_utils/mod.rs b/masq_lib/src/test_utils/mod.rs
index d2b9ce02f..2dd76c962 100644
--- a/masq_lib/src/test_utils/mod.rs
+++ b/masq_lib/src/test_utils/mod.rs
@@ -3,6 +3,7 @@
 pub mod environment_guard;
 pub mod fake_stream_holder;
 pub mod logging;
+pub mod mock_blockchain_client_server;
 pub mod mock_websockets_server;
 pub mod ui_connection;
 pub mod utils;
diff --git a/masq_lib/src/test_utils/utils.rs b/masq_lib/src/test_utils/utils.rs
index 2fed96981..fa279a4f4 100644
--- a/masq_lib/src/test_utils/utils.rs
+++ b/masq_lib/src/test_utils/utils.rs
@@ -2,6 +2,7 @@
 
 use crate::blockchains::chains::Chain;
 use crate::test_utils::environment_guard::EnvironmentGuard;
+use serde_derive::Serialize;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
@@ -11,6 +12,25 @@ pub const TEST_DEFAULT_MULTINODE_CHAIN: Chain = Chain::Dev;
 pub const BASE_TEST_DIR: &str = "generated/test";
 const MASQ_SOURCE_CODE_UNAVAILABLE: &str = "MASQ_SOURCE_CODE_UNAVAILABLE";
 
+#[derive(Serialize)]
+pub struct LogObject {
+    // Strings are all hexadecimal
+    pub removed: bool,
+    #[serde(rename = "logIndex")]
+    pub log_index: Option<String>,
+    #[serde(rename = "transactionIndex")]
+    pub transaction_index: Option<String>,
+    #[serde(rename = "transactionHash")]
+    pub transaction_hash: Option<String>,
+    #[serde(rename = "blockHash")]
+    pub block_hash: Option<String>,
+    #[serde(rename = "blockNumber")]
+    pub block_number: Option<String>,
+    pub address: String,
+    pub data: String,
+    pub topics: Vec<String>,
+}
+
 pub fn node_home_directory(module: &str, name: &str) -> PathBuf {
     let home_dir_string = format!("{}/{}/{}/home", BASE_TEST_DIR, module, name);
     PathBuf::from(home_dir_string.as_str())
@@ -45,6 +65,10 @@ fn is_env_variable_set(var_name: &str, searched_value: &str) -> bool {
     }
 }
 
+pub trait UrlHolder {
+    fn url(&self) -> String;
+}
+
 #[derive(PartialEq, Eq)]
 pub enum ShouldWeRunTheTest {
     GoAhead,
diff --git a/multinode_integration_tests/docker/Dockerfile b/multinode_integration_tests/docker/Dockerfile
index 9adb3b09b..e33d2ee53 100644
--- a/multinode_integration_tests/docker/Dockerfile
+++ b/multinode_integration_tests/docker/Dockerfile
@@ -2,7 +2,8 @@
 #FROM debian:stable-slim
 #FROM debian:buster-slim
 #FROM debian:bullseye-slim
-FROM debian:bookworm-slim
+#FROM debian:bookworm-slim
+FROM debian:trixie-slim
 
 RUN apt-get update && \
     apt-get install -y libc6 && \
diff --git a/multinode_integration_tests/docker/blockchain/Dockerfile b/multinode_integration_tests/docker/blockchain/Dockerfile
index 7ff65ea16..e69de29bb 100644
--- a/multinode_integration_tests/docker/blockchain/Dockerfile
+++ b/multinode_integration_tests/docker/blockchain/Dockerfile
@@ -1,8 +0,0 @@
-# Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
-FROM trufflesuite/ganache-cli:v6.12.2
-
-ADD ./entrypoint.sh /app/
-
-EXPOSE 18545
-
-ENTRYPOINT ["/app/entrypoint.sh"]
diff --git a/multinode_integration_tests/docker/blockchain/amd64_linux/Dockerfile b/multinode_integration_tests/docker/blockchain/amd64_linux/Dockerfile
new file mode 100644
index 000000000..f7d13cda8
--- /dev/null
+++ b/multinode_integration_tests/docker/blockchain/amd64_linux/Dockerfile
@@ -0,0 +1,9 @@
+# Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
+
+FROM trufflesuite/ganache-cli:v6.12.2
+
+ADD ./amd64_linux/entrypoint.sh /app/
+
+EXPOSE 18545
+
+ENTRYPOINT /app/entrypoint.sh
\ No newline at end of file
diff --git a/multinode_integration_tests/docker/blockchain/amd64_linux/entrypoint.sh b/multinode_integration_tests/docker/blockchain/amd64_linux/entrypoint.sh
new file mode 100755
index 000000000..40fa6c40d
--- /dev/null
+++ b/multinode_integration_tests/docker/blockchain/amd64_linux/entrypoint.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+# All wallets begin with null balances. The only exception is the contract owner wallet whose means are to be
+# redistributed from there to every account that would need it. (Notice the argument --account '<contract owner wallet
+# private key>,<ETH in wei>' that assigns a certain initial balance.) This same principle of initialization needs to be
+# regarded, during the test setup, and applied with both the transaction fee (wei of ETH) and the service fee (MASQ).
+# While on the transaction fee it's a choice done by us, with the latter, there probably isn't any other solution given
+# the mechanism how the deployment of the blockchain smart contract generates the entire token supply only on
+# the account of the contract owner's wallet from where it must be sent out to other wallets if needed.
+
+node /app/ganache-core.docker.cli.js \
+  -p 18545 \
+  --networkId 2 \
+  --verbose \
+  --mnemonic "timber cage wide hawk phone shaft pattern movie army dizzy hen tackle lamp absent write kind term toddler sphere ripple idle dragon curious hold"
\ No newline at end of file
diff --git a/multinode_integration_tests/docker/blockchain/arm64_linux/Dockerfile b/multinode_integration_tests/docker/blockchain/arm64_linux/Dockerfile
new file mode 100644
index 000000000..84e462d68
--- /dev/null
+++ b/multinode_integration_tests/docker/blockchain/arm64_linux/Dockerfile
@@ -0,0 +1,10 @@
+# Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
+
+# This is version v6.12.2 according to the official ganache versioning
+FROM --platform=linux/arm64 nutrina/ganache-cli:0.3
+
+ADD ./arm64_linux/entrypoint.sh /app/
+
+EXPOSE 18545
+
+ENTRYPOINT /app/entrypoint.sh
\ No newline at end of file
diff --git a/multinode_integration_tests/docker/blockchain/arm64_linux/entrypoint.sh b/multinode_integration_tests/docker/blockchain/arm64_linux/entrypoint.sh
new file mode 100755
index 000000000..5639a2d66
--- /dev/null
+++ b/multinode_integration_tests/docker/blockchain/arm64_linux/entrypoint.sh
@@ -0,0 +1,16 @@
+#!/bin/sh
+
+# All wallets begin with null balances. The only exception is the contract owner wallet whose means are to be
+# redistributed from there to every account that would need it. (Notice the argument --account '<contract owner wallet
+# private key>,<ETH in wei>' that assigns a certain initial balance.) This same principle of initialization needs to be
+# regarded, during the test setup, and applied with both the transaction fee (wei of ETH) and the service fee (MASQ).
+# While on the transaction fee it's a choice done by us, with the latter, there probably isn't any other solution given
+# the mechanism how the deployment of the blockchain smart contract generates the entire token supply only on
+# the account of the contract owner's wallet from where it must be sent out to other wallets if needed.
+
+ganache-cli \
+  -h 0.0.0.0 \
+  -p 18545 \
+  --networkId 2 \
+  --verbose \
+  -m "timber cage wide hawk phone shaft pattern movie army dizzy hen tackle lamp absent write kind term toddler sphere ripple idle dragon curious hold"
\ No newline at end of file
diff --git a/multinode_integration_tests/docker/blockchain/build.sh b/multinode_integration_tests/docker/blockchain/build.sh
index 8ecfa5025..ce97437bd 100755
--- a/multinode_integration_tests/docker/blockchain/build.sh
+++ b/multinode_integration_tests/docker/blockchain/build.sh
@@ -1,4 +1,17 @@
 #!/bin/bash -evx
 # Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
-docker build -t ganache-cli .
+arch=`dpkg --print-architecture`
+
+if [[ $arch == "amd64" ]]; then
+
+    echo "Building ganache-cli image for linux/amd64 architecture"
+    docker build -t ganache-cli . -f amd64_linux/Dockerfile
+
+elif [[ $arch == "arm64" ]]; then
+
+    echo "Building ganache-cli image for linux/arm64 architecture"
+    docker build -t ganache-cli . -f arm64_linux/Dockerfile
+
+fi
+
diff --git a/multinode_integration_tests/docker/blockchain/entrypoint.sh b/multinode_integration_tests/docker/blockchain/entrypoint.sh
index c184cbb50..e69de29bb 100755
--- a/multinode_integration_tests/docker/blockchain/entrypoint.sh
+++ b/multinode_integration_tests/docker/blockchain/entrypoint.sh
@@ -1,8 +0,0 @@
-#!/bin/sh
-
-node /app/ganache-core.docker.cli.js \
-    -h 0.0.0.0 \
-    -p 18545 \
-    --networkId 2 \
-    --verbose \
-    --mnemonic "timber cage wide hawk phone shaft pattern movie army dizzy hen tackle lamp absent write kind term toddler sphere ripple idle dragon curious hold"
diff --git a/multinode_integration_tests/src/blockchain.rs b/multinode_integration_tests/src/blockchain.rs
index aecb91e22..3cc7acc7d 100644
--- a/multinode_integration_tests/src/blockchain.rs
+++ b/multinode_integration_tests/src/blockchain.rs
@@ -2,7 +2,7 @@
 
 use crate::command::Command;
 use crate::masq_node::MASQNodeUtils;
-use crate::utils::UrlHolder;
+use masq_lib::test_utils::utils::UrlHolder;
 use node_lib::test_utils;
 use std::net::{IpAddr, Ipv4Addr};
 
diff --git a/multinode_integration_tests/src/masq_real_node.rs b/multinode_integration_tests/src/masq_real_node.rs
index 77b82054c..d9dc2c6da 100644
--- a/multinode_integration_tests/src/masq_real_node.rs
+++ b/multinode_integration_tests/src/masq_real_node.rs
@@ -480,7 +480,7 @@ impl NodeStartupConfigBuilder {
             firewall: None,
             memory: None,
             fake_public_key: None,
-            blockchain_service_url: None,
+            blockchain_service_url: Some("https://0.0.0.0".to_string()),
             chain: TEST_DEFAULT_MULTINODE_CHAIN,
             scans_opt: None,
             log_level_opt: None,
@@ -1534,6 +1534,8 @@ mod tests {
                 "\"10000000000|1200|1200|490000000|2592000|490000000\"",
                 "--consuming-private-key",
                 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
+                "--blockchain-service-url",
+                "https://0.0.0.0",
                 "--chain",
                 TEST_DEFAULT_MULTINODE_CHAIN.rec().literal_identifier,
                 "--db-password",
diff --git a/multinode_integration_tests/src/mock_blockchain_client_server.rs b/multinode_integration_tests/src/mock_blockchain_client_server.rs
index a40543808..2f0d7a9c5 100644
--- a/multinode_integration_tests/src/mock_blockchain_client_server.rs
+++ b/multinode_integration_tests/src/mock_blockchain_client_server.rs
@@ -1,399 +1,23 @@
 // Copyright (c) 2022, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
-use std::io::{ErrorKind, Read, Write};
-use std::net::{SocketAddr, TcpListener, TcpStream};
-use std::sync::{Arc, Mutex};
-use std::thread;
-use std::thread::JoinHandle;
-use std::time::Duration;
-
-use crossbeam_channel::{unbounded, Receiver, Sender};
-use itertools::Either;
-use itertools::Either::{Left, Right};
-use lazy_static::lazy_static;
-use regex::Regex;
-use serde::Serialize;
-
-use crate::masq_node_cluster::DockerHostSocketAddr;
-use crate::utils::UrlHolder;
-
-lazy_static! {
-    static ref CONTENT_LENGTH_DETECTOR: Regex =
-        Regex::new(r"[Cc]ontent-[Ll]ength: *(\d+)\r\n").expect("Bad regular expression");
-    static ref HTTP_VERSION_DETECTOR: Regex =
-        Regex::new(r"HTTP/(\d\.\d)").expect("Bad regular expression");
-}
-
-pub struct MBCSBuilder {
-    port: u16,
-    response_batch_opt: Option<Vec<String>>,
-    responses: Vec<String>,
-    notifier: Sender<()>,
-}
-
-impl MBCSBuilder {
-    pub fn new(port: u16) -> Self {
-        Self {
-            port,
-            response_batch_opt: None,
-            responses: vec![],
-            notifier: unbounded().0,
-        }
-    }
-
-    pub fn begin_batch(mut self) -> Self {
-        if self.response_batch_opt.is_some() {
-            panic!("Cannot nest response batches")
-        }
-        self.response_batch_opt = Some(vec![]);
-        self
-    }
-
-    pub fn end_batch(mut self) -> Self {
-        let batch_contents = self.response_batch_opt.take().unwrap();
-        self.responses
-            .push(format!("[{}]", batch_contents.join(", ")));
-        self
-    }
-
-    pub fn response<R>(self, result: R, id: u64) -> Self
-    where
-        R: Serialize,
-    {
-        let result = serde_json::to_string(&result).unwrap();
-        let body = format!(
-            r#"{{"jsonrpc": "2.0", "result": {}, "id": {}}}"#,
-            result, id
-        );
-        self.store_response_string(body)
-    }
-
-    pub fn error<D>(self, code: u64, message: &str, data: Option<D>) -> Self
-    where
-        D: Serialize,
-    {
-        let data_str = match data.map(|d| serde_json::to_string(&d).unwrap()) {
-            None => "".to_string(),
-            Some(json) => format!(r#", "data": {}"#, json),
-        };
-        let body = format!(
-            r#"{{"jsonrpc": "2.0", "error": {{"code": {}, "message": "{}"{}}}}}"#,
-            code, message, data_str
-        );
-        self.store_response_string(body)
-    }
-
-    pub fn notifier(mut self, notifier: Sender<()>) -> Self {
-        self.notifier = notifier;
-        self
-    }
-
-    pub fn start(self) -> MockBlockchainClientServer {
-        let requests = Arc::new(Mutex::new(vec![]));
-        let mut server = MockBlockchainClientServer {
-            port_or_local_addr: Left(self.port),
-            thread_info_opt: None,
-            requests_arc: requests,
-            responses: self.responses,
-            notifier: self.notifier,
-        };
-        server.start();
-        server
-    }
-
-    fn store_response_string(mut self, response_string: String) -> Self {
-        match self.response_batch_opt.as_mut() {
-            Some(response_batch) => response_batch.push(response_string),
-            None => self.responses.push(response_string),
-        }
-        self
-    }
-}
-
-struct MBCSThreadInfo {
-    stopper: Sender<()>,
-    join_handle: JoinHandle<()>,
-}
-
-pub struct MockBlockchainClientServer {
-    port_or_local_addr: Either<u16, SocketAddr>,
-    thread_info_opt: Option<MBCSThreadInfo>,
-    requests_arc: Arc<Mutex<Vec<String>>>,
-    responses: Vec<String>,
-    notifier: Sender<()>,
-}
-
-impl UrlHolder for MockBlockchainClientServer {
-    fn url(&self) -> String {
-        format!("http://{}", self.local_addr().unwrap())
-    }
-}
-
-impl Drop for MockBlockchainClientServer {
-    fn drop(&mut self) {
-        if let Some(thread_info) = self.thread_info_opt.take() {
-            let _ = thread_info.stopper.try_send(());
-            if let Err(e) = thread_info.join_handle.join() {
-                let msg = match e.downcast_ref::<&'static str>() {
-                    Some(m) => m.to_string(),
-                    None => match e.downcast::<String>() {
-                        Ok(m) => m.to_string(),
-                        Err(e) => format!("{:?}", e),
-                    },
-                };
-                if thread::panicking() {
-                    eprintln!(
-                        "MockBlockchainClientServer service thread also panicked: {}",
-                        msg
-                    );
-                } else {
-                    panic!("{}", msg);
-                }
-            }
-        }
-    }
-}
-
-impl MockBlockchainClientServer {
-    pub fn builder(port: u16) -> MBCSBuilder {
-        MBCSBuilder::new(port)
-    }
-
-    pub fn requests(&self) -> Vec<String> {
-        self.requests_arc.lock().unwrap().drain(..).collect()
-    }
-
-    pub fn start(&mut self) {
-        let addr = DockerHostSocketAddr::new(self.port_or_local_addr.unwrap_left());
-        let listener = match TcpListener::bind(addr) {
-            Ok(listener) => listener,
-            Err(e) => panic!(
-                "Error binding MBCS listener: did you remember to start the cluster first? ({:?})",
-                e
-            ),
-        };
-        listener.set_nonblocking(true).unwrap();
-        self.port_or_local_addr = Right(listener.local_addr().unwrap());
-        let requests_arc = self.requests_arc.clone();
-        let mut responses: Vec<String> = self.responses.drain(..).collect();
-        let (stopper_tx, stopper_rx) = unbounded();
-        let notifier = self.notifier.clone();
-        let join_handle = thread::spawn(move || {
-            let conn = loop {
-                if stopper_rx.try_recv().is_ok() {
-                    return;
-                }
-                match listener.accept() {
-                    Ok((conn, _)) => break conn,
-                    Err(e) if e.kind() == ErrorKind::WouldBlock => (),
-                    Err(e) if e.kind() == ErrorKind::TimedOut => (),
-                    Err(e) => panic!("MBCS accept() failed: {:?}", e),
-                };
-                thread::sleep(Duration::from_millis(100));
-            };
-            drop(listener);
-            conn.set_nonblocking(true).unwrap();
-            let mut conn_state = ConnectionState {
-                conn,
-                receive_buffer: [0u8; 16384],
-                receive_buffer_occupied: 0,
-                request_stage: RequestStage::Unparsed,
-                request_accumulator: "".to_string(),
-            };
-            Self::thread_guts(
-                &mut conn_state,
-                &requests_arc,
-                &mut responses,
-                &stopper_rx,
-                notifier,
-            );
-        });
-        self.thread_info_opt = Some(MBCSThreadInfo {
-            stopper: stopper_tx,
-            join_handle,
-        })
-    }
-
-    pub fn local_addr(&self) -> Option<SocketAddr> {
-        match self.port_or_local_addr {
-            Left(_) => None,
-            Right(local_addr) => Some(local_addr),
-        }
-    }
-
-    fn thread_guts(
-        conn_state: &mut ConnectionState,
-        requests_arc: &Arc<Mutex<Vec<String>>>,
-        responses: &mut Vec<String>,
-        stopper_rx: &Receiver<()>,
-        notifier_tx: Sender<()>,
-    ) {
-        loop {
-            if stopper_rx.try_recv().is_ok() {
-                break;
-            }
-            Self::receive_body(conn_state);
-            let body_opt = Self::process_body(conn_state);
-            match body_opt {
-                Some(body) if body.is_empty() => break,
-                Some(body) => {
-                    {
-                        let mut requests = requests_arc.lock().unwrap();
-                        requests.push(body);
-                    }
-                    if !responses.is_empty() {
-                        let response = responses.remove(0);
-                        Self::send_body(conn_state, response);
-                    }
-                    let _ = notifier_tx.send(()); // receiver doesn't exist if test didn't set it up
-                }
-                None => (),
-            };
-            thread::sleep(Duration::from_millis(100));
-        }
-    }
-
-    fn receive_body(conn_state: &mut ConnectionState) {
-        let offset = conn_state.receive_buffer_occupied;
-        let limit = conn_state.receive_buffer.len();
-        if conn_state.receive_buffer_occupied >= limit {
-            panic!(
-                "{}-byte receive buffer overflowed; increase size or fix test",
-                conn_state.receive_buffer.len()
-            );
-        }
-        let len = match conn_state
-            .conn
-            .read(&mut conn_state.receive_buffer[offset..limit])
-        {
-            Ok(n) => n,
-            Err(e) if e.kind() == ErrorKind::Interrupted => return,
-            Err(e) if e.kind() == ErrorKind::TimedOut => return,
-            Err(e) if e.kind() == ErrorKind::WouldBlock => return,
-            Err(e) => panic!("{:?}", e),
-        };
-        conn_state.receive_buffer_occupied += len;
-        let chunk = String::from_utf8_lossy(
-            &conn_state.receive_buffer[offset..conn_state.receive_buffer_occupied],
-        );
-        conn_state.request_accumulator.extend(chunk.chars());
-    }
-
-    fn process_body(conn_state: &mut ConnectionState) -> Option<String> {
-        loop {
-            let original_stage = conn_state.request_stage.clone();
-            let request_str_opt = match conn_state.request_stage {
-                RequestStage::Unparsed => Self::handle_unparsed(conn_state),
-                RequestStage::Parsed {
-                    content_offset,
-                    content_length,
-                } => Self::handle_parsed(conn_state, content_offset, content_length),
-            };
-            match request_str_opt {
-                Some(request_str) => return Some(request_str),
-                None => {
-                    if conn_state.request_stage == original_stage {
-                        return None;
-                    }
-                }
-            }
-        }
-    }
-
-    fn handle_unparsed(conn_state: &mut ConnectionState) -> Option<String> {
-        match conn_state.request_accumulator.find("\r\n\r\n") {
-            None => None,
-            Some(crlf_offset) => {
-                let content_offset = crlf_offset + 4;
-                match HTTP_VERSION_DETECTOR.captures(&conn_state.request_accumulator) {
-                    Some(captures) => {
-                        let http_version = captures.get(1).unwrap().as_str();
-                        if http_version != "1.1" {
-                            panic!("MBCS handles only HTTP version 1.1, not {}", http_version)
-                        }
-                    }
-                    None => panic!("Request has no HTTP version"),
-                }
-                match CONTENT_LENGTH_DETECTOR.captures(&conn_state.request_accumulator) {
-                    Some(captures) => {
-                        let content_length =
-                            captures.get(1).unwrap().as_str().parse::<usize>().unwrap();
-                        conn_state.request_stage = RequestStage::Parsed {
-                            content_offset,
-                            content_length,
-                        };
-                        None
-                    }
-                    None => panic!("Request has no Content-Length header"),
-                }
-            }
-        }
-    }
-
-    fn handle_parsed(
-        conn_state: &mut ConnectionState,
-        content_offset: usize,
-        content_length: usize,
-    ) -> Option<String> {
-        let request_length = content_offset + content_length;
-        if conn_state.request_accumulator.len() >= request_length {
-            let request = conn_state.request_accumulator[0..request_length].to_string();
-            // TODO: What happens if we have multibyte Unicode characters here?
-            let delete_count = request.len();
-            let remaining_len = conn_state.receive_buffer_occupied - delete_count;
-            for i in 0..remaining_len {
-                conn_state.receive_buffer[i] = conn_state.receive_buffer[i + delete_count];
-            }
-            conn_state.receive_buffer_occupied -= delete_count;
-            conn_state.request_accumulator =
-                conn_state.request_accumulator[delete_count..].to_string();
-            conn_state.request_stage = RequestStage::Unparsed;
-            Some(request)
-        } else {
-            None
-        }
-    }
-
-    fn send_body(conn_state: &mut ConnectionState, response: String) {
-        let http = format!(
-            "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
-            response.len(),
-            response
-        );
-        conn_state.conn.write_all(http.as_bytes()).unwrap();
-    }
-}
-
-#[derive(PartialEq, Eq, Clone, Debug)]
-enum RequestStage {
-    Unparsed,
-    Parsed {
-        content_offset: usize,
-        content_length: usize,
-    },
-}
-
-struct ConnectionState {
-    conn: TcpStream,
-    receive_buffer: [u8; 16384],
-    receive_buffer_occupied: usize,
-    request_stage: RequestStage,
-    request_accumulator: String,
-}
+// TODO: GH-805
+// The actual mock server has been migrated to masq_lib/src/test_utils/mock_blockchain_client_server.rs
 
 #[cfg(test)]
 mod tests {
-    use serde_derive::Deserialize;
-    use std::io::{Read, Write};
+    use crate::masq_node_cluster::{DockerHostSocketAddr, MASQNodeCluster};
+    use crossbeam_channel::unbounded;
+    use masq_lib::test_utils::mock_blockchain_client_server::{
+        MockBlockchainClientServer, CONTENT_LENGTH_DETECTOR,
+    };
+    use masq_lib::utils::find_free_port;
+    use serde_derive::{Deserialize, Serialize};
+    use std::io::{ErrorKind, Read, Write};
     use std::net::TcpStream;
     use std::ops::Add;
+    use std::thread;
     use std::time::{Duration, Instant};
 
-    use crate::masq_node_cluster::MASQNodeCluster;
-    use masq_lib::utils::find_free_port;
-
-    use super::*;
-
     #[derive(Serialize, Deserialize)]
     struct Person {
         pub name: String,
@@ -405,7 +29,8 @@ mod tests {
         let _cluster = MASQNodeCluster::start();
         let port = find_free_port();
         let _subject = MockBlockchainClientServer::builder(port)
-            .response("Thank you and good night", 40)
+            .ok_response("Thank you and good night", 40)
+            .run_in_docker()
             .start();
         let mut client = connect(port);
         let chunks = vec![
@@ -435,8 +60,9 @@ mod tests {
         let _cluster = MASQNodeCluster::start();
         let port = find_free_port();
         let _subject = MockBlockchainClientServer::builder(port)
-            .response("Welcome, and thanks for coming!", 39)
-            .response("Thank you and good night", 40)
+            .ok_response("Welcome, and thanks for coming!", 39)
+            .ok_response("Thank you and good night", 40)
+            .run_in_docker()
             .start();
         let mut client = connect(port);
         client.write(b"POST /biddle HTTP/1.1\r\nContent-Length: 5\r\n\r\nfirstPOST /biddle HTTP/1.1\r\nContent-Length: 6\r\n\r\nsecond").unwrap();
@@ -459,7 +85,8 @@ mod tests {
         let _cluster = MASQNodeCluster::start();
         let port = find_free_port();
         let _subject = MockBlockchainClientServer::builder(port)
-            .response("irrelevant".to_string(), 42)
+            .ok_response("irrelevant".to_string(), 42)
+            .run_in_docker()
             .start();
         let mut client = connect(port);
         let request = b"POST /biddle HTTP/1.1\r\n\r\nbody";
@@ -475,7 +102,8 @@ mod tests {
         let _cluster = MASQNodeCluster::start();
         let port = find_free_port();
         let _subject = MockBlockchainClientServer::builder(port)
-            .response("irrelevant".to_string(), 42)
+            .ok_response("irrelevant".to_string(), 42)
+            .run_in_docker()
             .start();
         let mut client = connect(port);
         let request = b"GET /booga\r\nContent-Length: 4\r\n\r\nbody";
@@ -491,7 +119,8 @@ mod tests {
         let _cluster = MASQNodeCluster::start();
         let port = find_free_port();
         let _subject = MockBlockchainClientServer::builder(port)
-            .response("irrelevant".to_string(), 42)
+            .ok_response("irrelevant".to_string(), 42)
+            .run_in_docker()
             .start();
         let mut client = connect(port);
         let request = b"GET /booga HTTP/2.0\r\nContent-Length: 4\r\n\r\nbody";
@@ -509,10 +138,10 @@ mod tests {
         let subject = MockBlockchainClientServer::builder(port)
             .notifier(notifier)
             .begin_batch()
-            .response(1234u64, 40)
+            .ok_response(1234u64, 40)
             .error(1234, "My tummy hurts", None as Option<()>)
             .end_batch()
-            .response(
+            .ok_response(
                 Person {
                     name: "Billy".to_string(),
                     age: 15,
@@ -527,6 +156,7 @@ mod tests {
                     age: 37,
                 }),
             )
+            .run_in_docker()
             .start();
         let mut client = connect(port);
 
@@ -581,13 +211,14 @@ mod tests {
         let _cluster = MASQNodeCluster::start();
         let port = find_free_port();
         let subject = MockBlockchainClientServer::builder(port)
-            .response(
+            .ok_response(
                 Person {
                     name: "Billy".to_string(),
                     age: 15,
                 },
                 42,
             )
+            .run_in_docker()
             .start();
         let mut client = connect(port);
         let request =
diff --git a/multinode_integration_tests/src/utils.rs b/multinode_integration_tests/src/utils.rs
index 12c63f1ec..e04b94149 100644
--- a/multinode_integration_tests/src/utils.rs
+++ b/multinode_integration_tests/src/utils.rs
@@ -22,10 +22,6 @@ use std::path::PathBuf;
 use std::time::{Duration, Instant};
 use std::{io, thread};
 
-pub trait UrlHolder {
-    fn url(&self) -> String;
-}
-
 pub fn send_chunk(stream: &mut TcpStream, chunk: &[u8]) {
     stream
         .write_all(chunk)
diff --git a/multinode_integration_tests/tests/blockchain_interaction_test.rs b/multinode_integration_tests/tests/blockchain_interaction_test.rs
index 41b8f26f1..555312019 100644
--- a/multinode_integration_tests/tests/blockchain_interaction_test.rs
+++ b/multinode_integration_tests/tests/blockchain_interaction_test.rs
@@ -1,14 +1,9 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
-use std::ops::Add;
-use std::path::PathBuf;
-use std::time::{Duration, SystemTime};
-
 use log::Level;
-use serde_derive::Serialize;
-
 use masq_lib::messages::{FromMessageBody, ScanType, ToMessageBody, UiScanRequest, UiScanResponse};
-use masq_lib::test_utils::utils::is_running_under_github_actions;
+use masq_lib::test_utils::mock_blockchain_client_server::MBCSBuilder;
+use masq_lib::test_utils::utils::{is_running_under_github_actions, LogObject, UrlHolder};
 use masq_lib::utils::find_free_port;
 use multinode_integration_tests_lib::masq_node::MASQNode;
 use multinode_integration_tests_lib::masq_node::MASQNodeUtils;
@@ -16,13 +11,14 @@ use multinode_integration_tests_lib::masq_node_cluster::MASQNodeCluster;
 use multinode_integration_tests_lib::masq_real_node::{
     ConsumingWalletInfo, NodeStartupConfigBuilder,
 };
-use multinode_integration_tests_lib::mock_blockchain_client_server::MBCSBuilder;
 use multinode_integration_tests_lib::utils::{
     config_dao, node_chain_specific_data_directory, open_all_file_permissions, receivable_dao,
-    UrlHolder,
 };
 use node_lib::accountant::db_access_objects::utils::CustomQuery;
 use node_lib::sub_lib::wallet::Wallet;
+use std::ops::Add;
+use std::path::PathBuf;
+use std::time::{Duration, SystemTime};
 
 #[test]
 fn debtors_are_credited_once_but_not_twice() {
@@ -36,7 +32,8 @@ fn debtors_are_credited_once_but_not_twice() {
     // Create and initialize mock blockchain client: prepare a receivable at block 2000
     eprintln!("Setting up mock blockchain client");
     let blockchain_client_server = MBCSBuilder::new(mbcs_port)
-        .response(
+        .ok_response("0x9C4", 1) // eth_blockNumber 2500
+        .ok_response(
             vec![LogObject {
                 removed: false,
                 log_index: Some("0x20".to_string()),
@@ -62,6 +59,7 @@ fn debtors_are_credited_once_but_not_twice() {
             }],
             1,
         )
+        .run_in_docker()
         .start();
     // Start a real Node pointing at the mock blockchain client with a start block of 1000
     let node_config = NodeStartupConfigBuilder::standard()
@@ -141,12 +139,12 @@ fn debtors_are_credited_once_but_not_twice() {
         assert_eq!(receivable_accounts.len(), 1);
         assert_eq!(receivable_accounts[0].balance_wei, 9_000_000_000);
     }
-    // Use the config DAO to verify that the start block has been advanced to 2001
+    // Use the config DAO to verify that the start block has been advanced to 2501
     {
         let config_dao = config_dao(&node_name);
         assert_eq!(
             config_dao.get("start_block").unwrap().value_opt.unwrap(),
-            "2001"
+            "2501"
         );
     }
 }
@@ -168,22 +166,3 @@ fn blockchain_bridge_starts_properly_on_bootstrap() {
         Duration::from_millis(1000),
     )
 }
-
-#[derive(Serialize)]
-struct LogObject {
-    // Strings are all hexadecimal
-    removed: bool,
-    #[serde(rename = "logIndex")]
-    log_index: Option<String>,
-    #[serde(rename = "transactionIndex")]
-    transaction_index: Option<String>,
-    #[serde(rename = "transactionHash")]
-    transaction_hash: Option<String>,
-    #[serde(rename = "blockHash")]
-    block_hash: Option<String>,
-    #[serde(rename = "blockNumber")]
-    block_number: Option<String>,
-    address: String,
-    data: String,
-    topics: Vec<String>,
-}
diff --git a/multinode_integration_tests/tests/bookkeeping_test.rs b/multinode_integration_tests/tests/bookkeeping_test.rs
index 41642a724..cbed01e84 100644
--- a/multinode_integration_tests/tests/bookkeeping_test.rs
+++ b/multinode_integration_tests/tests/bookkeeping_test.rs
@@ -42,7 +42,7 @@ fn provided_and_consumed_services_are_recorded_in_databases() {
     let payables = non_pending_payables(&originating_node);
 
     // Waiting until the serving nodes have finished accruing their receivables
-    thread::sleep(Duration::from_secs(7));
+    thread::sleep(Duration::from_secs(10));
 
     // get all receivables from all other nodes
     let receivable_balances = non_originating_nodes
diff --git a/multinode_integration_tests/tests/communication_failure_test.rs b/multinode_integration_tests/tests/communication_failure_test.rs
index c71b4b4e6..1c96ad483 100644
--- a/multinode_integration_tests/tests/communication_failure_test.rs
+++ b/multinode_integration_tests/tests/communication_failure_test.rs
@@ -294,7 +294,7 @@ fn dns_resolution_failure_for_wildcard_ip_with_real_nodes() {
 
     thread::sleep(Duration::from_millis(1000));
     let mut client = originating_node.make_client(8080, STANDARD_CLIENT_TIMEOUT_MILLIS);
-    client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.xvideos.com\r\n\r\n");
+    client.send_chunk(b"GET / HTTP/1.1\r\nHost: www.adomainthatdoesntexist.com\r\n\r\n");
     let response = client.wait_for_chunk();
 
     assert_eq!(
@@ -304,7 +304,7 @@ fn dns_resolution_failure_for_wildcard_ip_with_real_nodes() {
         String::from_utf8(response.clone()).unwrap()
     );
     assert_eq!(
-        index_of(&response, &b"<p>DNS Failure, We have tried multiple Exit Nodes and all have failed to resolve this address www.xvideos.com</p>"[..]).is_some(),
+        index_of(&response, &b"<p>DNS Failure, We have tried multiple Exit Nodes and all have failed to resolve this address www.adomainthatdoesntexist.com</p>"[..]).is_some(),
         true,
         "Actual response:\n{}",
         String::from_utf8(response).unwrap()
diff --git a/multinode_integration_tests/tests/verify_bill_payment.rs b/multinode_integration_tests/tests/verify_bill_payment.rs
index 1240deb58..d40bf9950 100644
--- a/multinode_integration_tests/tests/verify_bill_payment.rs
+++ b/multinode_integration_tests/tests/verify_bill_payment.rs
@@ -3,15 +3,17 @@ use bip39::{Language, Mnemonic, Seed};
 use futures::Future;
 use masq_lib::blockchains::chains::Chain;
 use masq_lib::constants::WEIS_IN_GWEI;
-use masq_lib::utils::{derivation_path, NeighborhoodModeLight};
+use masq_lib::messages::{ScanType, ToMessageBody, UiScanRequest};
+use masq_lib::test_utils::utils::UrlHolder;
+use masq_lib::utils::{derivation_path, find_free_port, NeighborhoodModeLight};
 use multinode_integration_tests_lib::blockchain::BlockchainServer;
-use multinode_integration_tests_lib::masq_node::MASQNode;
+use multinode_integration_tests_lib::masq_node::{MASQNode, MASQNodeUtils};
 use multinode_integration_tests_lib::masq_node_cluster::MASQNodeCluster;
 use multinode_integration_tests_lib::masq_real_node::{
     ConsumingWalletInfo, EarningWalletInfo, NodeStartupConfig, NodeStartupConfigBuilder,
 };
 use multinode_integration_tests_lib::utils::{
-    node_chain_specific_data_directory, open_all_file_permissions, UrlHolder,
+    node_chain_specific_data_directory, open_all_file_permissions,
 };
 use node_lib::accountant::db_access_objects::payable_dao::{PayableDao, PayableDaoReal};
 use node_lib::accountant::db_access_objects::receivable_dao::{ReceivableDao, ReceivableDaoReal};
@@ -232,7 +234,7 @@ fn verify_bill_payment() {
     assert_balances(
         &contract_owner_wallet,
         &blockchain_interface,
-        "99998223682000000000",
+        "99995231980000000000",
         "471999999700000000000000000",
     );
 
@@ -306,6 +308,169 @@ fn verify_bill_payment() {
     });
 }
 
+#[test]
+fn verify_pending_payables() {
+    let mut cluster = MASQNodeCluster::start().unwrap();
+    let blockchain_server = BlockchainServer {
+        name: "ganache-cli",
+    };
+    blockchain_server.start();
+    blockchain_server.wait_until_ready();
+    let url = blockchain_server.url().to_string();
+    let (event_loop_handle, http) = Http::with_max_parallel(&url, REQUESTS_IN_PARALLEL).unwrap();
+    let web3 = Web3::new(http.clone());
+    let deriv_path = derivation_path(0, 0);
+    let seed = make_seed();
+    let (contract_owner_wallet, _) = make_node_wallet(&seed, &deriv_path);
+    let contract_addr = deploy_smart_contract(&contract_owner_wallet, &web3, cluster.chain);
+    assert_eq!(
+        contract_addr,
+        cluster.chain.rec().contract,
+        "Ganache is not as predictable as we thought: Update blockchain_interface::MULTINODE_CONTRACT_ADDRESS with {:?}",
+        contract_addr
+    );
+    let blockchain_interface = BlockchainInterfaceWeb3::new(http, event_loop_handle, cluster.chain);
+    assert_balances(
+        &contract_owner_wallet,
+        &blockchain_interface,
+        "99998381140000000000",
+        "472000000000000000000000000",
+    );
+
+    let payment_thresholds = PaymentThresholds {
+        threshold_interval_sec: 2_592_000,
+        debt_threshold_gwei: 1_000_000_000,
+        payment_grace_period_sec: 86_400,
+        maturity_threshold_sec: 86_400,
+        permanent_debt_allowed_gwei: 10_000_000,
+        unban_below_gwei: 10_000_000,
+    };
+
+    let ui_port = find_free_port();
+    let (node_wallet, node_secret) = make_node_wallet(&seed, deriv_path.as_str());
+    let consuming_config = NodeStartupConfigBuilder::standard()
+        .blockchain_service_url(blockchain_server.url())
+        .chain(Chain::Dev)
+        .payment_thresholds(payment_thresholds)
+        .consuming_wallet_info(ConsumingWalletInfo::PrivateKey(node_secret))
+        .earning_wallet_info(EarningWalletInfo::Address(format!(
+            "{}",
+            node_wallet.clone()
+        )))
+        .ui_port(ui_port)
+        .build();
+    let (consuming_node_name, consuming_node_index) = cluster.prepare_real_node(&consuming_config);
+    let consuming_node_path = node_chain_specific_data_directory(&consuming_node_name);
+    let consuming_node_connection = DbInitializerReal::default()
+        .initialize(
+            Path::new(&consuming_node_path),
+            make_init_config(cluster.chain),
+        )
+        .unwrap();
+    let consuming_payable_dao = PayableDaoReal::new(consuming_node_connection);
+    open_all_file_permissions(consuming_node_path.clone().into());
+    assert_eq!(
+        format!("{}", &contract_owner_wallet),
+        "0x5a4d5df91d0124dec73dbd112f82d6077ccab47d"
+    );
+
+    let (serving_node_1_wallet, _) = make_node_wallet(&seed, derivation_path(0, 1).as_str());
+    let (serving_node_2_wallet, _) = make_node_wallet(&seed, derivation_path(0, 2).as_str());
+    let (serving_node_3_wallet, _) = make_node_wallet(&seed, derivation_path(0, 3).as_str());
+    let amount = 10 * payment_thresholds.permanent_debt_allowed_gwei as u128 * WEIS_IN_GWEI as u128;
+    let now = SystemTime::now();
+    consuming_payable_dao
+        .more_money_payable(now, &serving_node_1_wallet, amount)
+        .unwrap();
+    consuming_payable_dao
+        .more_money_payable(now, &serving_node_2_wallet, amount)
+        .unwrap();
+    consuming_payable_dao
+        .more_money_payable(now, &serving_node_3_wallet, amount)
+        .unwrap();
+
+    expire_payables(consuming_node_path.into());
+
+    let real_consuming_node =
+        cluster.start_named_real_node(&consuming_node_name, consuming_node_index, consuming_config);
+    for _ in 0..6 {
+        cluster.start_real_node(
+            NodeStartupConfigBuilder::standard()
+                .chain(Chain::Dev)
+                .neighbor(real_consuming_node.node_reference())
+                .build(),
+        );
+    }
+
+    let now = Instant::now();
+    while !consuming_payable_dao.non_pending_payables().is_empty()
+        && now.elapsed() < Duration::from_secs(10)
+    {
+        thread::sleep(Duration::from_millis(400));
+    }
+
+    assert_balances(
+        &contract_owner_wallet,
+        &blockchain_interface,
+        "99995231980000000000",
+        "471999999700000000000000000",
+    );
+    assert_balances(
+        &serving_node_1_wallet,
+        &blockchain_interface,
+        "100000000000000000000",
+        amount.to_string().as_str(),
+    );
+    assert_balances(
+        &serving_node_2_wallet,
+        &blockchain_interface,
+        "100000000000000000000",
+        amount.to_string().as_str(),
+    );
+    assert_balances(
+        &serving_node_3_wallet,
+        &blockchain_interface,
+        "100000000000000000000",
+        amount.to_string().as_str(),
+    );
+
+    let ui_client = real_consuming_node.make_ui(ui_port);
+    ui_client.send_request(
+        UiScanRequest {
+            scan_type: ScanType::PendingPayables,
+        }
+        .tmb(0),
+    );
+
+    MASQNodeUtils::wrote_log_containing(
+        real_consuming_node.name(),
+        "Found 3 pending payables to process",
+        Duration::from_secs(5),
+    );
+
+    MASQNodeUtils::wrote_log_containing(
+        real_consuming_node.name(),
+        "Scan results: Successful: 3, Pending: 0, Failed: 0",
+        Duration::from_secs(5),
+    );
+
+    MASQNodeUtils::wrote_log_containing(
+        real_consuming_node.name(),
+        "Transaction 0x75a8f185b7fb3ac0c4d1ee6b402a46940c9ae0477c0c7378a1308fb4bf539c5c has been added to the blockchain;",
+        Duration::from_secs(5),
+    );
+    MASQNodeUtils::wrote_log_containing(
+        real_consuming_node.name(),
+        "Transaction 0x384a3bb5bbd9718a97322be2878fa88c7cacacb2ac3416f521a621ca1946ddfc has been added to the blockchain;",
+        Duration::from_secs(5),
+    );
+    MASQNodeUtils::wrote_log_containing(
+        real_consuming_node.name(),
+        "Transaction 0x6bc98d5db61ddd7676de1f25cb537156b3d9e066cec414fef8dbe9c695908215 has been added to the blockchain;",
+        Duration::from_secs(5),
+    );
+}
+
 fn make_init_config(chain: Chain) -> DbInitializationConfig {
     DbInitializationConfig::create_or_migrate(ExternalData::new(
         chain,
@@ -316,13 +481,14 @@ fn make_init_config(chain: Chain) -> DbInitializationConfig {
 
 fn assert_balances(
     wallet: &Wallet,
-    blockchain_interface: &BlockchainInterfaceWeb3<Http>,
+    blockchain_interface: &BlockchainInterfaceWeb3,
     expected_eth_balance: &str,
     expected_token_balance: &str,
 ) {
     let eth_balance = blockchain_interface
         .lower_interface()
-        .get_transaction_fee_balance(&wallet)
+        .get_transaction_fee_balance(wallet.address())
+        .wait()
         .unwrap_or_else(|_| panic!("Failed to retrieve gas balance for {}", wallet));
     assert_eq!(
         format!("{}", eth_balance),
@@ -333,7 +499,8 @@ fn assert_balances(
     );
     let token_balance = blockchain_interface
         .lower_interface()
-        .get_service_fee_balance(&wallet)
+        .get_service_fee_balance(wallet.address())
+        .wait()
         .unwrap_or_else(|_| panic!("Failed to retrieve masq balance for {}", wallet));
     assert_eq!(
         token_balance,
diff --git a/node/src/accountant/db_access_objects/pending_payable_dao.rs b/node/src/accountant/db_access_objects/pending_payable_dao.rs
index 981fa9f22..67c779ce0 100644
--- a/node/src/accountant/db_access_objects/pending_payable_dao.rs
+++ b/node/src/accountant/db_access_objects/pending_payable_dao.rs
@@ -6,6 +6,7 @@ use crate::accountant::db_access_objects::utils::{
 use crate::accountant::db_big_integer::big_int_divider::BigIntDivider;
 use crate::accountant::{checked_conversion, comma_joined_stringifiable};
 use crate::blockchain::blockchain_bridge::PendingPayableFingerprint;
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::HashAndAmount;
 use crate::database::rusqlite_wrappers::ConnectionWrapper;
 use crate::sub_lib::wallet::Wallet;
 use masq_lib::utils::ExpectValue;
@@ -38,7 +39,7 @@ pub trait PendingPayableDao {
     fn return_all_errorless_fingerprints(&self) -> Vec<PendingPayableFingerprint>;
     fn insert_new_fingerprints(
         &self,
-        hashes_and_amounts: &[(H256, u128)],
+        hashes_and_amounts: &[HashAndAmount],
         batch_wide_timestamp: SystemTime,
     ) -> Result<(), PendingPayableDaoError>;
     fn delete_fingerprints(&self, ids: &[u64]) -> Result<(), PendingPayableDaoError>;
@@ -125,20 +126,20 @@ impl PendingPayableDao for PendingPayableDaoReal<'_> {
 
     fn insert_new_fingerprints(
         &self,
-        hashes_and_amounts: &[(H256, u128)],
+        hashes_and_amounts: &[HashAndAmount],
         batch_wide_timestamp: SystemTime,
     ) -> Result<(), PendingPayableDaoError> {
         fn values_clause_for_fingerprints_to_insert(
-            hashes_and_amounts: &[(H256, u128)],
+            hashes_and_amounts: &[HashAndAmount],
             batch_wide_timestamp: SystemTime,
         ) -> String {
             let time_t = to_time_t(batch_wide_timestamp);
-            comma_joined_stringifiable(hashes_and_amounts, |(hash, amount)| {
-                let amount_checked = checked_conversion::<u128, i128>(*amount);
+            comma_joined_stringifiable(hashes_and_amounts, |hash_and_amount| {
+                let amount_checked = checked_conversion::<u128, i128>(hash_and_amount.amount);
                 let (high_bytes, low_bytes) = BigIntDivider::deconstruct(amount_checked);
                 format!(
                     "('{:?}', {}, {}, {}, 1, null)",
-                    hash, high_bytes, low_bytes, time_t
+                    hash_and_amount.hash, high_bytes, low_bytes, time_t
                 )
             })
         }
@@ -277,6 +278,7 @@ mod tests {
     use crate::accountant::db_access_objects::utils::from_time_t;
     use crate::accountant::db_big_integer::big_int_divider::BigIntDivider;
     use crate::blockchain::blockchain_bridge::PendingPayableFingerprint;
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::HashAndAmount;
     use crate::blockchain::test_utils::make_tx_hash;
     use crate::database::db_initializer::{
         DbInitializationConfig, DbInitializer, DbInitializerReal, DATABASE_FILE,
@@ -304,10 +306,18 @@ mod tests {
         let amount_2 = 44445;
         let batch_wide_timestamp = from_time_t(200_000_000);
         let subject = PendingPayableDaoReal::new(wrapped_conn);
+        let hash_and_amount_1 = HashAndAmount {
+            hash: hash_1,
+            amount: amount_1,
+        };
+        let hash_and_amount_2 = HashAndAmount {
+            hash: hash_2,
+            amount: amount_2,
+        };
 
         let _ = subject
             .insert_new_fingerprints(
-                &[(hash_1, amount_1), (hash_2, amount_2)],
+                &[hash_and_amount_1, hash_and_amount_2],
                 batch_wide_timestamp,
             )
             .unwrap();
@@ -319,17 +329,17 @@ mod tests {
                 PendingPayableFingerprint {
                     rowid: 1,
                     timestamp: batch_wide_timestamp,
-                    hash: hash_1,
+                    hash: hash_and_amount_1.hash,
                     attempt: 1,
-                    amount: amount_1,
+                    amount: hash_and_amount_1.amount,
                     process_error: None
                 },
                 PendingPayableFingerprint {
                     rowid: 2,
                     timestamp: batch_wide_timestamp,
-                    hash: hash_2,
+                    hash: hash_and_amount_2.hash,
                     attempt: 1,
-                    amount: amount_2,
+                    amount: hash_and_amount_2.amount,
                     process_error: None
                 }
             ]
@@ -357,8 +367,9 @@ mod tests {
         let amount = 55556;
         let timestamp = from_time_t(200_000_000);
         let subject = PendingPayableDaoReal::new(Box::new(wrapped_conn));
+        let hash_and_amount = HashAndAmount { hash, amount };
 
-        let result = subject.insert_new_fingerprints(&[(hash, amount)], timestamp);
+        let result = subject.insert_new_fingerprints(&[hash_and_amount], timestamp);
 
         assert_eq!(
             result,
@@ -385,8 +396,12 @@ mod tests {
         let amount_1 = 55556;
         let batch_wide_timestamp = from_time_t(200_000_000);
         let subject = PendingPayableDaoReal::new(Box::new(wrapped_conn));
+        let hash_and_amount = HashAndAmount {
+            hash: hash_1,
+            amount: amount_1,
+        };
 
-        let _ = subject.insert_new_fingerprints(&[(hash_1, amount_1)], batch_wide_timestamp);
+        let _ = subject.insert_new_fingerprints(&[hash_and_amount], batch_wide_timestamp);
     }
 
     #[test]
@@ -408,7 +423,15 @@ mod tests {
         let hash_2 =
             H256::from_str("5a2909e7bb71943c82a94d9beb04e230351541fc14619ee8bb9b7372ea88ba39")
                 .unwrap();
-        let fingerprints_init_input = vec![(hash_1, 4567), (hash_2, 6789)];
+        let hash_and_amount_1 = HashAndAmount {
+            hash: hash_1,
+            amount: 4567,
+        };
+        let hash_and_amount_2 = HashAndAmount {
+            hash: hash_2,
+            amount: 6789,
+        };
+        let fingerprints_init_input = vec![hash_and_amount_1, hash_and_amount_2];
         {
             subject
                 .insert_new_fingerprints(&fingerprints_init_input, timestamp)
@@ -452,10 +475,22 @@ mod tests {
         // this test, and in the end, I delete the first one. It leaves a single record still in but with the rowid 2 instead of
         // just an ambiguous 1
         subject
-            .insert_new_fingerprints(&[(hash_2, 8901234)], SystemTime::now())
+            .insert_new_fingerprints(
+                &[HashAndAmount {
+                    hash: hash_2,
+                    amount: 8901234,
+                }],
+                SystemTime::now(),
+            )
             .unwrap();
         subject
-            .insert_new_fingerprints(&[(hash_3, 1234567)], SystemTime::now())
+            .insert_new_fingerprints(
+                &[HashAndAmount {
+                    hash: hash_3,
+                    amount: 1234567,
+                }],
+                SystemTime::now(),
+            )
             .unwrap();
         subject.delete_fingerprints(&[1]).unwrap();
 
@@ -480,10 +515,19 @@ mod tests {
         let amount_1 = 787;
         let hash_2 = make_tx_hash(10000);
         let amount_2 = 333;
+        let hash_and_amount_1 = HashAndAmount {
+            hash: hash_1,
+            amount: amount_1,
+        };
+        let hash_and_amount_2 = HashAndAmount {
+            hash: hash_2,
+            amount: amount_2,
+        };
+
         {
             subject
                 .insert_new_fingerprints(
-                    &[(hash_1, amount_1), (hash_2, amount_2)],
+                    &[hash_and_amount_1, hash_and_amount_2],
                     batch_wide_timestamp,
                 )
                 .unwrap();
@@ -527,9 +571,14 @@ mod tests {
         let timestamp = from_time_t(198_000_000);
         let hash = make_tx_hash(10000);
         let amount = 333;
+        let hash_and_amount_1 = HashAndAmount {
+            hash: make_tx_hash(11119),
+            amount: 2000,
+        };
+        let hash_and_amount_2 = HashAndAmount { hash, amount };
         {
             subject
-                .insert_new_fingerprints(&[(make_tx_hash(11119), 2000), (hash, amount)], timestamp)
+                .insert_new_fingerprints(&[hash_and_amount_1, hash_and_amount_2], timestamp)
                 .unwrap();
             subject.mark_failures(&[1]).unwrap();
         }
@@ -589,9 +638,18 @@ mod tests {
             subject
                 .insert_new_fingerprints(
                     &[
-                        (make_tx_hash(1234), 1111),
-                        (make_tx_hash(2345), 5555),
-                        (make_tx_hash(3456), 2222),
+                        HashAndAmount {
+                            hash: make_tx_hash(1234),
+                            amount: 1111,
+                        },
+                        HashAndAmount {
+                            hash: make_tx_hash(2345),
+                            amount: 5555,
+                        },
+                        HashAndAmount {
+                            hash: make_tx_hash(3456),
+                            amount: 2222,
+                        },
                     ],
                     SystemTime::now(),
                 )
@@ -655,7 +713,13 @@ mod tests {
         let subject = PendingPayableDaoReal::new(conn);
         {
             subject
-                .insert_new_fingerprints(&[(make_tx_hash(666666), 5555)], SystemTime::now())
+                .insert_new_fingerprints(
+                    &[HashAndAmount {
+                        hash: make_tx_hash(666666),
+                        amount: 5555,
+                    }],
+                    SystemTime::now(),
+                )
                 .unwrap();
         }
 
@@ -674,12 +738,24 @@ mod tests {
         let hash_1 = make_tx_hash(345);
         let hash_2 = make_tx_hash(456);
         let hash_3 = make_tx_hash(567);
+        let hash_and_amount_1 = HashAndAmount {
+            hash: hash_1,
+            amount: 1122,
+        };
+        let hash_and_amount_2 = HashAndAmount {
+            hash: hash_2,
+            amount: 2233,
+        };
+        let hash_and_amount_3 = HashAndAmount {
+            hash: hash_3,
+            amount: 3344,
+        };
         let timestamp = from_time_t(190_000_000);
         let subject = PendingPayableDaoReal::new(conn);
         {
             subject
                 .insert_new_fingerprints(
-                    &[(hash_1, 1122), (hash_2, 2233), (hash_3, 3344)],
+                    &[hash_and_amount_1, hash_and_amount_2, hash_and_amount_3],
                     timestamp,
                 )
                 .unwrap();
@@ -758,11 +834,19 @@ mod tests {
         let amount_1 = 1234;
         let hash_2 = make_tx_hash(666);
         let amount_2 = 2345;
+        let hash_and_amount_1 = HashAndAmount {
+            hash: hash_1,
+            amount: amount_1,
+        };
+        let hash_and_amount_2 = HashAndAmount {
+            hash: hash_2,
+            amount: amount_2,
+        };
         let timestamp = from_time_t(190_000_000);
         let subject = PendingPayableDaoReal::new(conn);
         {
             subject
-                .insert_new_fingerprints(&[(hash_1, amount_1), (hash_2, amount_2)], timestamp)
+                .insert_new_fingerprints(&[hash_and_amount_1, hash_and_amount_2], timestamp)
                 .unwrap();
         }
 
diff --git a/node/src/accountant/mod.rs b/node/src/accountant/mod.rs
index e76b15a0d..8d67e790c 100644
--- a/node/src/accountant/mod.rs
+++ b/node/src/accountant/mod.rs
@@ -29,6 +29,7 @@ use crate::accountant::scanners::{BeginScanError, ScanSchedulers, Scanners};
 use crate::blockchain::blockchain_bridge::{
     PendingPayableFingerprint, PendingPayableFingerprintSeeds, RetrieveTransactions,
 };
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::HashAndAmount;
 use crate::blockchain::blockchain_interface::data_structures::errors::PayableTransactionError;
 use crate::blockchain::blockchain_interface::data_structures::{
     BlockchainTransaction, ProcessedPayableFallible,
@@ -76,7 +77,8 @@ use std::ops::{Div, Mul};
 use std::path::Path;
 use std::rc::Rc;
 use std::time::SystemTime;
-use web3::types::{TransactionReceipt, H256};
+use web3::types::H256;
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::TransactionReceiptResult;
 
 pub const CRASH_KEY: &str = "ACCOUNTANT";
 pub const DEFAULT_PENDING_TOO_LONG_SEC: u64 = 21_600; //6 hours
@@ -113,6 +115,12 @@ pub struct ResponseSkeleton {
     pub context_id: u64,
 }
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum ReceivedPaymentsError {
+    ExceededBlockScanLimit(u64),
+    OtherRPCError(String),
+}
+
 #[derive(Debug, Message, PartialEq, Eq)]
 pub struct ReceivedPayments {
     //TODO When we decide whether to delinquency-ban a debtor, we do so based on the age
@@ -123,8 +131,8 @@ pub struct ReceivedPayments {
     // detects any upcoming delinquency later than the more accurate version would. Is this
     // a problem? Do we want to correct the timestamp? Discuss.
     pub timestamp: SystemTime,
-    pub payments: Vec<BlockchainTransaction>,
     pub new_start_block: u64,
+    pub transactions: Vec<BlockchainTransaction>,
     pub response_skeleton_opt: Option<ResponseSkeleton>,
 }
 
@@ -187,6 +195,7 @@ impl Handler<StartMessage> for Accountant {
                 &self.logger,
                 "Started with --scans on; starting database and blockchain scans"
             );
+
             ctx.notify(ScanForPendingPayables {
                 response_skeleton_opt: None,
             });
@@ -360,9 +369,9 @@ impl SkeletonOptHolder for RequestTransactionReceipts {
     }
 }
 
-#[derive(Debug, PartialEq, Message, Clone)]
+#[derive(Debug, PartialEq, Eq, Message, Clone)]
 pub struct ReportTransactionReceipts {
-    pub fingerprints_with_receipts: Vec<(Option<TransactionReceipt>, PendingPayableFingerprint)>,
+    pub fingerprints_with_receipts: Vec<(TransactionReceiptResult, PendingPayableFingerprint)>,
     pub response_skeleton_opt: Option<ResponseSkeleton>,
 }
 
@@ -487,9 +496,9 @@ impl Accountant {
         if !self.our_wallet(wallet) {
             match self.receivable_dao
                 .as_ref()
-                .more_money_receivable(timestamp,wallet, total_charge) {
+                .more_money_receivable(timestamp, wallet, total_charge) {
                 Ok(_) => (),
-                Err(ReceivableDaoError::SignConversion(_)) => error! (
+                Err(ReceivableDaoError::SignConversion(_)) => error!(
                     self.logger,
                     "Overflow error recording service provided for {}: service rate {}, byte rate {}, payload size {}. Skipping",
                     wallet,
@@ -497,7 +506,7 @@ impl Accountant {
                     byte_rate,
                     payload_size
                 ),
-                Err(e)=> panic!("Recording services provided for {} but has hit fatal database error: {:?}", wallet, e)
+                Err(e) => panic!("Recording services provided for {} but has hit fatal database error: {:?}", wallet, e)
             };
         } else {
             warning!(
@@ -521,9 +530,9 @@ impl Accountant {
         if !self.our_wallet(wallet) {
             match self.payable_dao
                 .as_ref()
-                .more_money_payable(timestamp, wallet,total_charge){
+                .more_money_payable(timestamp, wallet, total_charge) {
                 Ok(_) => (),
-                Err(PayableDaoError::SignConversion(_)) => error! (
+                Err(PayableDaoError::SignConversion(_)) => error!(
                     self.logger,
                     "Overflow error recording consumed services from {}: total charge {}, service rate {}, byte rate {}, payload size {}. Skipping",
                     wallet,
@@ -933,10 +942,11 @@ impl Accountant {
     }
 
     fn handle_new_pending_payable_fingerprints(&self, msg: PendingPayableFingerprintSeeds) {
-        fn serialize_hashes(fingerprints_data: &[(H256, u128)]) -> String {
-            comma_joined_stringifiable(fingerprints_data, |(hash, _)| format!("{:?}", hash))
+        fn serialize_hashes(fingerprints_data: &[HashAndAmount]) -> String {
+            comma_joined_stringifiable(fingerprints_data, |hash_and_amount| {
+                format!("{:?}", hash_and_amount.hash)
+            })
         }
-
         match self
             .pending_payable_dao
             .insert_new_fingerprints(&msg.hashes_and_balances, msg.batch_wide_timestamp)
@@ -1053,7 +1063,10 @@ mod tests {
     use crate::accountant::test_utils::{AccountantBuilder, BannedDaoMock};
     use crate::accountant::Accountant;
     use crate::blockchain::blockchain_bridge::BlockchainBridge;
-    use crate::blockchain::test_utils::{make_tx_hash, BlockchainInterfaceMock};
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::HashAndAmount;
+    use crate::blockchain::test_utils::{
+        make_blockchain_interface_web3, make_tx_hash, ReceiptResponseBuilder,
+    };
     use crate::database::rusqlite_wrappers::TransactionSafeWrapper;
     use crate::database::test_utils::transaction_wrapper_mock::TransactionInnerWrapperMockBuilder;
     use crate::db_config::config_dao::ConfigDaoRecord;
@@ -1082,7 +1095,6 @@ mod tests {
     use actix::{Arbiter, System};
     use ethereum_types::U64;
     use ethsign_crypto::Keccak256;
-    use itertools::Itertools;
     use log::Level;
     use masq_lib::constants::{
         REQUEST_WITH_MUTUALLY_EXCLUSIVE_PARAMS, REQUEST_WITH_NO_VALUES, SCAN_ERROR,
@@ -1095,16 +1107,19 @@ mod tests {
     };
     use masq_lib::test_utils::logging::init_test_logging;
     use masq_lib::test_utils::logging::TestLogHandler;
+    use masq_lib::test_utils::mock_blockchain_client_server::MBCSBuilder;
     use masq_lib::test_utils::utils::ensure_node_home_directory_exists;
     use masq_lib::ui_gateway::MessagePath::Conversation;
     use masq_lib::ui_gateway::{MessageBody, MessagePath, NodeFromUiMessage, NodeToUiMessage};
+    use masq_lib::utils::find_free_port;
     use std::any::TypeId;
     use std::ops::{Add, Sub};
+    use std::str::FromStr;
     use std::sync::Arc;
     use std::sync::Mutex;
     use std::time::Duration;
     use std::vec;
-    use web3::types::TransactionReceipt;
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{TransactionBlock, TxReceipt, TxStatus};
 
     impl Handler<AssertionsMessage<Accountant>> for Accountant {
         type Result = ();
@@ -1387,12 +1402,12 @@ mod tests {
         subject_addr.try_send(BindMessage { peer_actors }).unwrap();
         let received_payments = ReceivedPayments {
             timestamp: SystemTime::now(),
-            payments: vec![],
-            new_start_block: 1234567,
+            new_start_block: 0,
             response_skeleton_opt: Some(ResponseSkeleton {
                 client_id: 1234,
                 context_id: 4321,
             }),
+            transactions: vec![],
         };
 
         subject_addr.try_send(received_payments).unwrap();
@@ -1480,8 +1495,9 @@ mod tests {
         let system = System::new("test");
         let peer_actors = peer_actors_builder().ui_gateway(ui_gateway).build();
         subject_addr.try_send(BindMessage { peer_actors }).unwrap();
+
         let sent_payable = SentPayables {
-            payment_procedure_result: Ok(vec![Ok(PendingPayable {
+            payment_procedure_result: Ok(vec![ProcessedPayableFallible::Correct(PendingPayable {
                 recipient_wallet: make_wallet("blah"),
                 hash: make_tx_hash(123),
             })]),
@@ -1696,6 +1712,10 @@ mod tests {
         let blockchain_bridge_recording = blockchain_bridge_recording_arc.lock().unwrap();
         let payments_instructions =
             blockchain_bridge_recording.get_record::<OutboundPaymentsInstructions>(0);
+        assert_eq!(
+            payments_instructions.agent.arbitrary_id_stamp(),
+            agent_id_stamp_second_phase
+        );
         assert_eq!(
             payments_instructions.affordable_accounts,
             affordable_accounts
@@ -1704,10 +1724,6 @@ mod tests {
             payments_instructions.response_skeleton_opt,
             Some(response_skeleton)
         );
-        assert_eq!(
-            payments_instructions.agent.arbitrary_id_stamp(),
-            agent_id_stamp_second_phase
-        );
         assert_eq!(blockchain_bridge_recording.len(), 1);
         test_use_of_the_same_logger(&logger_clone, test_name)
     }
@@ -1886,7 +1902,9 @@ mod tests {
             .build();
         let expected_payable = PendingPayable::new(expected_wallet.clone(), expected_hash.clone());
         let sent_payable = SentPayables {
-            payment_procedure_result: Ok(vec![Ok(expected_payable.clone())]),
+            payment_procedure_result: Ok(vec![ProcessedPayableFallible::Correct(
+                expected_payable.clone(),
+            )]),
             response_skeleton_opt: None,
         };
         let subject = accountant.start();
@@ -2031,13 +2049,12 @@ mod tests {
             .build();
         let system = System::new("accountant_uses_receivables_dao_to_process_received_payments");
         let subject = accountant.start();
-
         subject
             .try_send(ReceivedPayments {
                 timestamp: now,
-                payments: vec![expected_receivable_1.clone(), expected_receivable_2.clone()],
                 new_start_block: 123456789u64,
                 response_skeleton_opt: None,
+                transactions: vec![expected_receivable_1.clone(), expected_receivable_2.clone()],
             })
             .expect("unexpected actix error");
 
@@ -3420,20 +3437,95 @@ mod tests {
     #[test]
     fn pending_transaction_is_registered_and_monitored_until_it_gets_confirmed_or_canceled() {
         init_test_logging();
-        let build_blockchain_agent_params = Arc::new(Mutex::new(vec![]));
+        let port = find_free_port();
+        let pending_tx_hash_1 =
+            H256::from_str("e66814b2812a80d619813f51aa999c0df84eb79d10f4923b2b7667b30d6b33d3")
+                .unwrap();
+        let pending_tx_hash_2 =
+            H256::from_str("0288ef000581b3bca8a2017eac9aea696366f8f1b7437f18d1aad57bccb7032c")
+                .unwrap();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            // Blockchain Agent Gas Price
+            .ok_response("0x3B9ACA00".to_string(), 0) // 1000000000
+            // Blockchain Agent transaction fee balance
+            .ok_response("0xFFF0".to_string(), 0) // 65520
+            // Blockchain Agent masq balance
+            .ok_response(
+                "0x000000000000000000000000000000000000000000000000000000000000FFFF".to_string(),
+                0,
+            )
+            // Submit payments to blockchain
+            .ok_response("0xFFF0".to_string(), 1)
+            .begin_batch()
+            .raw_response(
+                ReceiptResponseBuilder::default()
+                    .transaction_hash(pending_tx_hash_1)
+                    .build(),
+            )
+            .raw_response(
+                ReceiptResponseBuilder::default()
+                    .transaction_hash(pending_tx_hash_2)
+                    .build(),
+            )
+            .end_batch()
+            // Round 1 - handle_request_transaction_receipts
+            .begin_batch()
+            .raw_response(r#"{ "jsonrpc": "2.0", "id": 1, "result": null }"#.to_string()) // Null response
+            .raw_response(
+                ReceiptResponseBuilder::default()
+                    .transaction_hash(pending_tx_hash_2)
+                    .build(),
+            )
+            .end_batch()
+            // Round 2 - handle_request_transaction_receipts
+            .begin_batch()
+            .raw_response(
+                ReceiptResponseBuilder::default()
+                    .transaction_hash(pending_tx_hash_1)
+                    .build(),
+            )
+            .raw_response(
+                ReceiptResponseBuilder::default()
+                    .transaction_hash(pending_tx_hash_2)
+                    .build(),
+            )
+            .end_batch()
+            // Round 3 - handle_request_transaction_receipts
+            .begin_batch()
+            .raw_response(
+                ReceiptResponseBuilder::default()
+                    .transaction_hash(pending_tx_hash_1)
+                    .status(U64::from(0))
+                    .build(),
+            )
+            .raw_response(
+                ReceiptResponseBuilder::default()
+                    .transaction_hash(pending_tx_hash_2)
+                    .build(),
+            )
+            .end_batch()
+            // Round 4 - handle_request_transaction_receipts
+            .begin_batch()
+            .raw_response(
+                ReceiptResponseBuilder::default()
+                    .transaction_hash(pending_tx_hash_2)
+                    .status(U64::from(1))
+                    .block_number(U64::from(1234))
+                    .block_hash(Default::default())
+                    .build(),
+            )
+            .end_batch()
+            .start();
+        let non_pending_payables_params_arc = Arc::new(Mutex::new(vec![]));
         let mark_pending_payable_params_arc = Arc::new(Mutex::new(vec![]));
-        let transactions_confirmed_params_arc = Arc::new(Mutex::new(vec![]));
-        let get_transaction_receipt_params_arc = Arc::new(Mutex::new(vec![]));
         let return_all_errorless_fingerprints_params_arc = Arc::new(Mutex::new(vec![]));
-        let non_pending_payables_params_arc = Arc::new(Mutex::new(vec![]));
         let update_fingerprint_params_arc = Arc::new(Mutex::new(vec![]));
         let mark_failure_params_arc = Arc::new(Mutex::new(vec![]));
+        let transactions_confirmed_params_arc = Arc::new(Mutex::new(vec![]));
         let delete_record_params_arc = Arc::new(Mutex::new(vec![]));
         let notify_later_scan_for_pending_payable_params_arc = Arc::new(Mutex::new(vec![]));
         let notify_later_scan_for_pending_payable_arc_cloned =
             notify_later_scan_for_pending_payable_params_arc.clone(); // because it moves into a closure
-        let pending_tx_hash_1 = make_tx_hash(0x7b);
-        let pending_tx_hash_2 = make_tx_hash(0x237);
         let rowid_for_account_1 = 3;
         let rowid_for_account_2 = 5;
         let now = SystemTime::now();
@@ -3451,39 +3543,7 @@ mod tests {
             gwei_to_wei(DEFAULT_PAYMENT_THRESHOLDS.debt_threshold_gwei + 666);
         let wallet_account_1 = make_wallet("creditor1");
         let wallet_account_2 = make_wallet("creditor2");
-        let transaction_receipt_tx_2_first_round = TransactionReceipt::default();
-        let transaction_receipt_tx_1_second_round = TransactionReceipt::default();
-        let transaction_receipt_tx_2_second_round = TransactionReceipt::default();
-        let mut transaction_receipt_tx_1_third_round = TransactionReceipt::default();
-        transaction_receipt_tx_1_third_round.status = Some(U64::from(0)); // failure
-        let transaction_receipt_tx_2_third_round = TransactionReceipt::default();
-        let mut transaction_receipt_tx_2_fourth_round = TransactionReceipt::default();
-        transaction_receipt_tx_2_fourth_round.status = Some(U64::from(1)); // confirmed
-        let agent = BlockchainAgentMock::default();
-        let blockchain_interface = BlockchainInterfaceMock::default()
-            .build_blockchain_agent_params(&build_blockchain_agent_params)
-            .build_blockchain_agent_result(Ok(Box::new(agent)))
-            // because we cannot have both, resolution on the high level and also of what's inside blockchain interface,
-            // there is one component missing in this wholesome test - the part where we send a request for
-            // a fingerprint of that payable in the DB - this happens inside send_raw_transaction()
-            .send_batch_of_payables_result(Ok(vec![
-                Ok(PendingPayable {
-                    recipient_wallet: wallet_account_1.clone(),
-                    hash: pending_tx_hash_1,
-                }),
-                Ok(PendingPayable {
-                    recipient_wallet: wallet_account_2.clone(),
-                    hash: pending_tx_hash_2,
-                }),
-            ]))
-            .get_transaction_receipt_params(&get_transaction_receipt_params_arc)
-            .get_transaction_receipt_result(Ok(None))
-            .get_transaction_receipt_result(Ok(Some(transaction_receipt_tx_2_first_round)))
-            .get_transaction_receipt_result(Ok(Some(transaction_receipt_tx_1_second_round)))
-            .get_transaction_receipt_result(Ok(Some(transaction_receipt_tx_2_second_round)))
-            .get_transaction_receipt_result(Ok(Some(transaction_receipt_tx_1_third_round)))
-            .get_transaction_receipt_result(Ok(Some(transaction_receipt_tx_2_third_round)))
-            .get_transaction_receipt_result(Ok(Some(transaction_receipt_tx_2_fourth_round)));
+        let blockchain_interface = make_blockchain_interface_web3(port);
         let consuming_wallet = make_paying_wallet(b"wallet");
         let system = System::new("pending_transaction");
         let persistent_config_id_stamp = ArbitraryIdStamp::new();
@@ -3491,7 +3551,7 @@ mod tests {
             .set_arbitrary_id_stamp(persistent_config_id_stamp);
         let blockchain_bridge = BlockchainBridge::new(
             Box::new(blockchain_interface),
-            Box::new(persistent_config),
+            Arc::new(Mutex::new(persistent_config)),
             false,
         );
         let account_1 = PayableAccount {
@@ -3506,7 +3566,7 @@ mod tests {
             last_paid_timestamp: past_payable_timestamp_2,
             pending_payable_opt: None,
         };
-        let pending_payable_scan_interval = 200; // should be slightly less than 1/5 of the time until shutting the system
+        let pending_payable_scan_interval = 1000; // should be slightly less than 1/5 of the time until shutting the system
         let payable_dao_for_payable_scanner = PayableDaoMock::new()
             .non_pending_payables_params(&non_pending_payables_params_arc)
             .non_pending_payables_result(vec![account_1, account_2])
@@ -3558,6 +3618,13 @@ mod tests {
             ..fingerprint_2_first_round.clone()
         };
         let pending_payable_dao_for_payable_scanner = PendingPayableDaoMock::default()
+            .fingerprints_rowids_result(TransactionHashes {
+                rowid_results: vec![
+                    (rowid_for_account_1, pending_tx_hash_1),
+                    (rowid_for_account_2, pending_tx_hash_2),
+                ],
+                no_rowid_results: vec![],
+            })
             .fingerprints_rowids_result(TransactionHashes {
                 rowid_results: vec![
                     (rowid_for_account_1, pending_tx_hash_1),
@@ -3600,18 +3667,20 @@ mod tests {
             .delete_fingerprints_result(Ok(()));
         pending_payable_dao_for_pending_payable_scanner
             .have_return_all_errorless_fingerprints_shut_down_the_system = true;
-        let consuming_wallet_for_accountant = consuming_wallet.clone();
+        let pending_payable_dao_for_accountant =
+            PendingPayableDaoMock::new().insert_fingerprints_result(Ok(()));
         let accountant_addr = Arbiter::builder()
             .stop_system_on_panic(true)
             .start(move |_| {
                 let mut subject = AccountantBuilder::default()
-                    .consuming_wallet(consuming_wallet_for_accountant)
+                    .consuming_wallet(consuming_wallet)
                     .bootstrapper_config(bootstrapper_config)
                     .payable_daos(vec![
                         ForPayableScanner(payable_dao_for_payable_scanner),
                         ForPendingPayableScanner(payable_dao_for_pending_payable_scanner),
                     ])
                     .pending_payable_daos(vec![
+                        ForAccountantBody(pending_payable_dao_for_accountant),
                         ForPayableScanner(pending_payable_dao_for_payable_scanner),
                         ForPendingPayableScanner(pending_payable_dao_for_pending_payable_scanner),
                     ])
@@ -3659,31 +3728,13 @@ mod tests {
         assert!(return_all_errorless_fingerprints_params.len() >= 5);
         let non_pending_payables_params = non_pending_payables_params_arc.lock().unwrap();
         assert_eq!(*non_pending_payables_params, vec![()]); // because we disabled further scanning for payables
-        let get_transaction_receipt_params = get_transaction_receipt_params_arc.lock().unwrap();
-        assert_eq!(
-            *get_transaction_receipt_params,
-            vec![
-                pending_tx_hash_1,
-                pending_tx_hash_2,
-                pending_tx_hash_1,
-                pending_tx_hash_2,
-                pending_tx_hash_1,
-                pending_tx_hash_2,
-                pending_tx_hash_2,
-            ]
-        );
-        let build_blockchain_agent_params = build_blockchain_agent_params.lock().unwrap();
-        assert_eq!(
-            *build_blockchain_agent_params,
-            vec![(consuming_wallet, persistent_config_id_stamp)]
-        );
         let update_fingerprints_params = update_fingerprint_params_arc.lock().unwrap();
         assert_eq!(
             *update_fingerprints_params,
             vec![
                 vec![rowid_for_account_1, rowid_for_account_2],
                 vec![rowid_for_account_1, rowid_for_account_2],
-                vec![rowid_for_account_2]
+                vec![rowid_for_account_2],
             ]
         );
         let mark_failure_params = mark_failure_params_arc.lock().unwrap();
@@ -3721,16 +3772,16 @@ mod tests {
         );
         let log_handler = TestLogHandler::new();
         log_handler.exists_log_containing(
-            "WARN: Accountant: Broken transactions 0x00000000000000000000000000000000000000000000000\
-            0000000000000007b marked as an error. You should take over the care of those to make sure \
-            your debts are going to be settled properly. At the moment, there is no automated process \
-            fixing that without your assistance");
-        log_handler.exists_log_matching("INFO: Accountant: Transaction 0x000000000000000000000000000\
-        0000000000000000000000000000000000237 has been added to the blockchain; detected locally at \
-        attempt 4 at \\d{2,}ms after its sending");
+            "WARN: Accountant: Broken transactions 0xe66814b2812a80d619813f51aa999c0df84eb79d10f\
+            4923b2b7667b30d6b33d3 marked as an error. You should take over the care of those to make sure \
+                your debts are going to be settled properly. At the moment, there is no automated process \
+                fixing that without your assistance");
+        log_handler.exists_log_matching("INFO: Accountant: Transaction 0x0288ef000581b3bca8a2017eac9\
+        aea696366f8f1b7437f18d1aad57bccb7032c has been added to the blockchain; detected locally at \
+            attempt 4 at \\d{2,}ms after its sending");
         log_handler.exists_log_containing(
-            "INFO: Accountant: Transactions 0x000000000000000000000000\
-        0000000000000000000000000000000000000237 completed their confirmation process succeeding",
+            "INFO: Accountant: Transactions 0x0288ef000581b3bca8a2017eac9aea696366f8f1b7437f18d1aad5\
+            7bccb7032c completed their confirmation process succeeding",
         );
     }
 
@@ -3748,9 +3799,13 @@ mod tests {
             .build();
         let subject_addr = subject.start();
         let transaction_hash_1 = make_tx_hash(4545);
-        let mut transaction_receipt_1 = TransactionReceipt::default();
-        transaction_receipt_1.transaction_hash = transaction_hash_1;
-        transaction_receipt_1.status = Some(U64::from(1)); //success
+        let transaction_receipt_1 = TxReceipt {
+            transaction_hash: transaction_hash_1,
+            status: TxStatus::Succeeded(TransactionBlock {
+                block_hash: Default::default(),
+                block_number: U64::from(100),
+            }),
+        };
         let fingerprint_1 = PendingPayableFingerprint {
             rowid: 5,
             timestamp: from_time_t(200_000_000),
@@ -3760,9 +3815,13 @@ mod tests {
             process_error: None,
         };
         let transaction_hash_2 = make_tx_hash(3333333);
-        let mut transaction_receipt_2 = TransactionReceipt::default();
-        transaction_receipt_2.transaction_hash = transaction_hash_2;
-        transaction_receipt_2.status = Some(U64::from(1)); //success
+        let transaction_receipt_2 = TxReceipt {
+            transaction_hash: transaction_hash_2,
+            status: TxStatus::Succeeded(TransactionBlock {
+                block_hash: Default::default(),
+                block_number: U64::from(200),
+            }),
+        };
         let fingerprint_2 = PendingPayableFingerprint {
             rowid: 10,
             timestamp: from_time_t(199_780_000),
@@ -3773,8 +3832,14 @@ mod tests {
         };
         let msg = ReportTransactionReceipts {
             fingerprints_with_receipts: vec![
-                (Some(transaction_receipt_1), fingerprint_1.clone()),
-                (Some(transaction_receipt_2), fingerprint_2.clone()),
+                (
+                    TransactionReceiptResult::RpcResponse(transaction_receipt_1),
+                    fingerprint_1.clone(),
+                ),
+                (
+                    TransactionReceiptResult::RpcResponse(transaction_receipt_2),
+                    fingerprint_2.clone(),
+                ),
             ],
             response_skeleton_opt: None,
         };
@@ -3808,7 +3873,15 @@ mod tests {
         let amount_1 = 12345;
         let hash_2 = make_tx_hash(0x1b207);
         let amount_2 = 87654;
-        let init_params = vec![(hash_1, amount_1), (hash_2, amount_2)];
+        let hash_and_amount_1 = HashAndAmount {
+            hash: hash_1,
+            amount: amount_1,
+        };
+        let hash_and_amount_2 = HashAndAmount {
+            hash: hash_2,
+            amount: amount_2,
+        };
+        let init_params = vec![hash_and_amount_1, hash_and_amount_2];
         let init_fingerprints_msg = PendingPayableFingerprintSeeds {
             batch_wide_timestamp: timestamp,
             hashes_and_balances: init_params.clone(),
@@ -3825,7 +3898,7 @@ mod tests {
         let insert_fingerprint_params = insert_fingerprint_params_arc.lock().unwrap();
         assert_eq!(
             *insert_fingerprint_params,
-            vec![(vec![(hash_1, amount_1), (hash_2, amount_2)], timestamp)]
+            vec![(vec![hash_and_amount_1, hash_and_amount_2], timestamp)]
         );
         TestLogHandler::new().exists_log_containing(
             "DEBUG: Accountant: Saved new pending payable fingerprints for: \
@@ -3845,13 +3918,17 @@ mod tests {
             )));
         let amount = 2345;
         let transaction_hash = make_tx_hash(0x1c8);
+        let hash_and_amount = HashAndAmount {
+            hash: transaction_hash,
+            amount,
+        };
         let subject = AccountantBuilder::default()
             .pending_payable_daos(vec![ForAccountantBody(pending_payable_dao)])
             .build();
         let timestamp = SystemTime::now();
         let report_new_fingerprints = PendingPayableFingerprintSeeds {
             batch_wide_timestamp: timestamp,
-            hashes_and_balances: vec![(transaction_hash, amount)],
+            hashes_and_balances: vec![hash_and_amount],
         };
 
         let _ = subject.handle_new_pending_payable_fingerprints(report_new_fingerprints);
@@ -3859,7 +3936,7 @@ mod tests {
         let insert_fingerprint_params = insert_fingerprint_params_arc.lock().unwrap();
         assert_eq!(
             *insert_fingerprint_params,
-            vec![(vec![(transaction_hash, amount)], timestamp)]
+            vec![(vec![hash_and_amount], timestamp)]
         );
         TestLogHandler::new().exists_log_containing("ERROR: Accountant: Failed to process \
          new pending payable fingerprints due to 'InsertionFailed(\"Crashed\")', disabling the automated \
@@ -4665,7 +4742,7 @@ mod tests {
     fn checked_conversion_without_panic() {
         let result = politely_checked_conversion::<u128, i128>(u128::MAX);
 
-        assert_eq!(result,Err("Overflow detected with 340282366920938463463374607431768211455: cannot be converted from u128 to i128".to_string()))
+        assert_eq!(result, Err("Overflow detected with 340282366920938463463374607431768211455: cannot be converted from u128 to i128".to_string()))
     }
 
     #[test]
diff --git a/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/agent_null.rs b/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/agent_null.rs
index faf7d45cc..e95673002 100644
--- a/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/agent_null.rs
+++ b/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/agent_null.rs
@@ -5,7 +5,9 @@ use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockch
 use crate::sub_lib::blockchain_bridge::ConsumingWalletBalances;
 use crate::sub_lib::wallet::Wallet;
 use ethereum_types::U256;
+use masq_lib::blockchains::chains::Chain;
 use masq_lib::logger::Logger;
+use masq_lib::test_utils::utils::TEST_DEFAULT_CHAIN;
 
 #[derive(Clone)]
 pub struct BlockchainAgentNull {
@@ -27,7 +29,7 @@ impl BlockchainAgent for BlockchainAgentNull {
         }
     }
 
-    fn agreed_fee_per_computation_unit(&self) -> u64 {
+    fn agreed_fee_per_computation_unit(&self) -> u128 {
         self.log_function_call("agreed_fee_per_computation_unit()");
         0
     }
@@ -37,9 +39,9 @@ impl BlockchainAgent for BlockchainAgentNull {
         &self.wallet
     }
 
-    fn pending_transaction_id(&self) -> U256 {
-        self.log_function_call("pending_transaction_id()");
-        U256::zero()
+    fn get_chain(&self) -> Chain {
+        self.log_function_call("get_chain()");
+        TEST_DEFAULT_CHAIN
     }
 
     #[cfg(test)]
@@ -83,6 +85,7 @@ mod tests {
 
     use masq_lib::logger::Logger;
     use masq_lib::test_utils::logging::{init_test_logging, TestLogHandler};
+    use masq_lib::test_utils::utils::TEST_DEFAULT_CHAIN;
     use web3::types::U256;
 
     fn blockchain_agent_null_constructor_works<C>(constructor: C)
@@ -178,15 +181,15 @@ mod tests {
     }
 
     #[test]
-    fn null_agent_pending_transaction_id() {
+    fn null_agent_get_chain() {
         init_test_logging();
-        let test_name = "null_agent_pending_transaction_id";
+        let test_name = "null_agent_get_chain";
         let mut subject = BlockchainAgentNull::new();
         subject.logger = Logger::new(test_name);
 
-        let result = subject.pending_transaction_id();
+        let result = subject.get_chain();
 
-        assert_eq!(result, U256::zero());
-        assert_error_log(test_name, "pending_transaction_id");
+        assert_eq!(result, TEST_DEFAULT_CHAIN);
+        assert_error_log(test_name, "get_chain")
     }
 }
diff --git a/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/agent_web3.rs b/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/agent_web3.rs
index d54224352..725e14f00 100644
--- a/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/agent_web3.rs
+++ b/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/agent_web3.rs
@@ -1,26 +1,24 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
 use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
-
 use crate::sub_lib::blockchain_bridge::ConsumingWalletBalances;
 use crate::sub_lib::wallet::Wallet;
-
-use web3::types::U256;
+use masq_lib::blockchains::chains::Chain;
 
 #[derive(Debug, Clone)]
 pub struct BlockchainAgentWeb3 {
-    gas_price_gwei: u64,
-    gas_limit_const_part: u64,
-    maximum_added_gas_margin: u64,
+    gas_price_wei: u128,
+    gas_limit_const_part: u128,
+    maximum_added_gas_margin: u128,
     consuming_wallet: Wallet,
     consuming_wallet_balances: ConsumingWalletBalances,
-    pending_transaction_id: U256,
+    chain: Chain,
 }
 
 impl BlockchainAgent for BlockchainAgentWeb3 {
     fn estimated_transaction_fee_total(&self, number_of_transactions: usize) -> u128 {
-        let gas_price = self.gas_price_gwei as u128;
-        let max_gas_limit = (self.maximum_added_gas_margin + self.gas_limit_const_part) as u128;
+        let gas_price = self.gas_price_wei;
+        let max_gas_limit = self.maximum_added_gas_margin + self.gas_limit_const_part;
         number_of_transactions as u128 * gas_price * max_gas_limit
     }
 
@@ -28,38 +26,38 @@ impl BlockchainAgent for BlockchainAgentWeb3 {
         self.consuming_wallet_balances
     }
 
-    fn agreed_fee_per_computation_unit(&self) -> u64 {
-        self.gas_price_gwei
+    fn agreed_fee_per_computation_unit(&self) -> u128 {
+        self.gas_price_wei
     }
 
     fn consuming_wallet(&self) -> &Wallet {
         &self.consuming_wallet
     }
 
-    fn pending_transaction_id(&self) -> U256 {
-        self.pending_transaction_id
+    fn get_chain(&self) -> Chain {
+        self.chain
     }
 }
 
 // 64 * (64 - 12) ... std transaction has data of 64 bytes and 12 bytes are never used with us;
 // each non-zero byte costs 64 units of gas
-pub const WEB3_MAXIMAL_GAS_LIMIT_MARGIN: u64 = 3328;
+pub const WEB3_MAXIMAL_GAS_LIMIT_MARGIN: u128 = 3328;
 
 impl BlockchainAgentWeb3 {
     pub fn new(
-        gas_price_gwei: u64,
-        gas_limit_const_part: u64,
+        gas_price_wei: u128,
+        gas_limit_const_part: u128,
         consuming_wallet: Wallet,
         consuming_wallet_balances: ConsumingWalletBalances,
-        pending_transaction_id: U256,
+        chain: Chain,
     ) -> Self {
         Self {
-            gas_price_gwei,
+            gas_price_wei,
             gas_limit_const_part,
             consuming_wallet,
             maximum_added_gas_margin: WEB3_MAXIMAL_GAS_LIMIT_MARGIN,
             consuming_wallet_balances,
-            pending_transaction_id,
+            chain,
         }
     }
 }
@@ -70,15 +68,14 @@ mod tests {
         BlockchainAgentWeb3, WEB3_MAXIMAL_GAS_LIMIT_MARGIN,
     };
     use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
-
     use crate::sub_lib::blockchain_bridge::ConsumingWalletBalances;
     use crate::test_utils::make_wallet;
-
+    use masq_lib::test_utils::utils::TEST_DEFAULT_CHAIN;
     use web3::types::U256;
 
     #[test]
     fn constants_are_correct() {
-        assert_eq!(WEB3_MAXIMAL_GAS_LIMIT_MARGIN, 3328)
+        assert_eq!(WEB3_MAXIMAL_GAS_LIMIT_MARGIN, 3_328)
     }
 
     #[test]
@@ -90,14 +87,13 @@ mod tests {
             transaction_fee_balance_in_minor_units: U256::from(456_789),
             masq_token_balance_in_minor_units: U256::from(123_000_000),
         };
-        let pending_transaction_id = U256::from(777);
 
         let subject = BlockchainAgentWeb3::new(
             gas_price_gwei,
             gas_limit_const_part,
             consuming_wallet.clone(),
             consuming_wallet_balances,
-            pending_transaction_id,
+            TEST_DEFAULT_CHAIN,
         );
 
         assert_eq!(subject.agreed_fee_per_computation_unit(), gas_price_gwei);
@@ -106,7 +102,7 @@ mod tests {
             subject.consuming_wallet_balances(),
             consuming_wallet_balances
         );
-        assert_eq!(subject.pending_transaction_id(), pending_transaction_id)
+        assert_eq!(subject.get_chain(), TEST_DEFAULT_CHAIN);
     }
 
     #[test]
@@ -116,13 +112,12 @@ mod tests {
             transaction_fee_balance_in_minor_units: Default::default(),
             masq_token_balance_in_minor_units: Default::default(),
         };
-        let nonce = U256::from(55);
         let agent = BlockchainAgentWeb3::new(
             444,
             77_777,
             consuming_wallet,
             consuming_wallet_balances,
-            nonce,
+            TEST_DEFAULT_CHAIN,
         );
 
         let result = agent.estimated_transaction_fee_total(3);
diff --git a/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/blockchain_agent.rs b/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/blockchain_agent.rs
index 3ded6a16b..2f2af4015 100644
--- a/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/blockchain_agent.rs
+++ b/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/blockchain_agent.rs
@@ -3,7 +3,7 @@
 use crate::arbitrary_id_stamp_in_trait;
 use crate::sub_lib::blockchain_bridge::ConsumingWalletBalances;
 use crate::sub_lib::wallet::Wallet;
-use web3::types::U256;
+use masq_lib::blockchains::chains::Chain;
 
 // Table of chains by
 //
@@ -24,9 +24,10 @@ use web3::types::U256;
 pub trait BlockchainAgent: Send {
     fn estimated_transaction_fee_total(&self, number_of_transactions: usize) -> u128;
     fn consuming_wallet_balances(&self) -> ConsumingWalletBalances;
-    fn agreed_fee_per_computation_unit(&self) -> u64;
+    fn agreed_fee_per_computation_unit(&self) -> u128;
     fn consuming_wallet(&self) -> &Wallet;
-    fn pending_transaction_id(&self) -> U256;
+
+    fn get_chain(&self) -> Chain;
 
     #[cfg(test)]
     fn dup(&self) -> Box<dyn BlockchainAgent> {
diff --git a/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/test_utils.rs b/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/test_utils.rs
index 5de2a6b06..d3ab97284 100644
--- a/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/test_utils.rs
+++ b/node/src/accountant/scanners/mid_scan_msg_handling/payable_scanner/test_utils.rs
@@ -7,16 +7,27 @@ use crate::sub_lib::blockchain_bridge::ConsumingWalletBalances;
 use crate::sub_lib::wallet::Wallet;
 use crate::test_utils::unshared_test_utils::arbitrary_id_stamp::ArbitraryIdStamp;
 use crate::{arbitrary_id_stamp_in_trait_impl, set_arbitrary_id_stamp_in_mock_impl};
-use ethereum_types::U256;
+use masq_lib::blockchains::chains::Chain;
 use std::cell::RefCell;
 
-#[derive(Default)]
 pub struct BlockchainAgentMock {
     consuming_wallet_balances_results: RefCell<Vec<ConsumingWalletBalances>>,
-    agreed_fee_per_computation_unit_results: RefCell<Vec<u64>>,
+    agreed_fee_per_computation_unit_results: RefCell<Vec<u128>>,
     consuming_wallet_result_opt: Option<Wallet>,
-    pending_transaction_id_results: RefCell<Vec<U256>>,
     arbitrary_id_stamp_opt: Option<ArbitraryIdStamp>,
+    get_chain_result_opt: Option<Chain>,
+}
+
+impl Default for BlockchainAgentMock {
+    fn default() -> Self {
+        BlockchainAgentMock {
+            consuming_wallet_balances_results: RefCell::new(vec![]),
+            agreed_fee_per_computation_unit_results: RefCell::new(vec![]),
+            consuming_wallet_result_opt: None,
+            arbitrary_id_stamp_opt: None,
+            get_chain_result_opt: None,
+        }
+    }
 }
 
 impl BlockchainAgent for BlockchainAgentMock {
@@ -28,7 +39,7 @@ impl BlockchainAgent for BlockchainAgentMock {
         todo!("to be implemented by GH-711")
     }
 
-    fn agreed_fee_per_computation_unit(&self) -> u64 {
+    fn agreed_fee_per_computation_unit(&self) -> u128 {
         self.agreed_fee_per_computation_unit_results
             .borrow_mut()
             .remove(0)
@@ -38,8 +49,8 @@ impl BlockchainAgent for BlockchainAgentMock {
         self.consuming_wallet_result_opt.as_ref().unwrap()
     }
 
-    fn pending_transaction_id(&self) -> U256 {
-        self.pending_transaction_id_results.borrow_mut().remove(0)
+    fn get_chain(&self) -> Chain {
+        self.get_chain_result_opt.unwrap()
     }
 
     fn dup(&self) -> Box<dyn BlockchainAgent> {
@@ -57,7 +68,7 @@ impl BlockchainAgentMock {
         self
     }
 
-    pub fn agreed_fee_per_computation_unit_result(self, result: u64) -> Self {
+    pub fn agreed_fee_per_computation_unit_result(self, result: u128) -> Self {
         self.agreed_fee_per_computation_unit_results
             .borrow_mut()
             .push(result);
@@ -69,10 +80,8 @@ impl BlockchainAgentMock {
         self
     }
 
-    pub fn pending_transaction_id_result(self, result: U256) -> Self {
-        self.pending_transaction_id_results
-            .borrow_mut()
-            .push(result);
+    pub fn get_chain_result(mut self, get_chain_result: Chain) -> Self {
+        self.get_chain_result_opt = Some(get_chain_result);
         self
     }
 
diff --git a/node/src/accountant/scanners/mod.rs b/node/src/accountant/scanners/mod.rs
index fc5f5ce91..0b5837172 100644
--- a/node/src/accountant/scanners/mod.rs
+++ b/node/src/accountant/scanners/mod.rs
@@ -17,10 +17,7 @@ use crate::accountant::scanners::scanners_utils::payable_scanner_utils::{
     separate_errors, separate_rowids_and_hashes, PayableThresholdsGauge,
     PayableThresholdsGaugeReal, PayableTransactingErrorEnum, PendingPayableMetadata,
 };
-use crate::accountant::scanners::scanners_utils::pending_payable_scanner_utils::{
-    elapsed_in_ms, handle_none_status, handle_status_with_failure, handle_status_with_success,
-    PendingPayableScanReport,
-};
+use crate::accountant::scanners::scanners_utils::pending_payable_scanner_utils::{handle_none_receipt, handle_status_with_failure, handle_status_with_success, PendingPayableScanReport};
 use crate::accountant::scanners::scanners_utils::receivable_scanner_utils::balance_and_age;
 use crate::accountant::PendingPayableId;
 use crate::accountant::{
@@ -51,10 +48,11 @@ use std::rc::Rc;
 use std::time::{Duration, SystemTime};
 use time::format_description::parse;
 use time::OffsetDateTime;
-use web3::types::{TransactionReceipt, H256};
+use web3::types::H256;
 use masq_lib::type_obfuscation::Obfuscated;
 use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::{PreparedAdjustment, MultistagePayableScanner, SolvencySensitivePaymentInstructor};
 use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::msgs::{BlockchainAgentWithContextMessage, QualifiedPayablesMessage};
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{TransactionReceiptResult, TxStatus};
 use crate::blockchain::blockchain_interface::data_structures::errors::PayableTransactionError;
 use crate::db_config::persistent_configuration::{PersistentConfiguration, PersistentConfigurationReal};
 
@@ -237,7 +235,6 @@ impl Scanner<QualifiedPayablesMessage, SentPayables> for PayableScanner {
 
     fn finish_scan(&mut self, message: SentPayables, logger: &Logger) -> Option<NodeToUiMessage> {
         let (sent_payables, err_opt) = separate_errors(&message, logger);
-
         debug!(
             logger,
             "{}",
@@ -497,7 +494,7 @@ impl PayableScanner {
     ) {
         if let Some(err) = err_opt {
             match err {
-                LocallyCausedError(PayableTransactionError::Sending {hashes, ..})
+                LocallyCausedError(PayableTransactionError::Sending { hashes, .. })
                 | RemotelyCausedErrors(hashes) => {
                     self.discard_failed_transactions_with_possible_fingerprints(hashes, logger)
                 }
@@ -654,72 +651,34 @@ impl PendingPayableScanner {
         msg: ReportTransactionReceipts,
         logger: &Logger,
     ) -> PendingPayableScanReport {
-        fn handle_none_receipt(
-            mut scan_report: PendingPayableScanReport,
-            payable: PendingPayableFingerprint,
-            logger: &Logger,
-        ) -> PendingPayableScanReport {
-            debug!(logger,
-                "Interpreting a receipt for transaction {:?} but none was given; attempt {}, {}ms since sending",
-                payable.hash, payable.attempt,elapsed_in_ms(payable.timestamp)
-            );
-
-            scan_report
-                .still_pending
-                .push(PendingPayableId::new(payable.rowid, payable.hash));
-            scan_report
-        }
-
         let scan_report = PendingPayableScanReport::default();
         msg.fingerprints_with_receipts.into_iter().fold(
             scan_report,
-            |scan_report_so_far, (receipt_opt, fingerprint)| match receipt_opt {
-                Some(receipt) => self.interpret_transaction_receipt(
+            |scan_report_so_far, (receipt_result, fingerprint)| match receipt_result {
+                TransactionReceiptResult::RpcResponse(tx_receipt) => match tx_receipt.status {
+                    TxStatus::Pending => handle_none_receipt(
+                        scan_report_so_far,
+                        fingerprint,
+                        "none was given",
+                        logger,
+                    ),
+                    TxStatus::Failed => {
+                        handle_status_with_failure(scan_report_so_far, fingerprint, logger)
+                    }
+                    TxStatus::Succeeded(_) => {
+                        handle_status_with_success(scan_report_so_far, fingerprint, logger)
+                    }
+                },
+                TransactionReceiptResult::LocalError(e) => handle_none_receipt(
                     scan_report_so_far,
-                    &receipt,
                     fingerprint,
+                    &format!("failed due to {}", e),
                     logger,
                 ),
-                None => handle_none_receipt(scan_report_so_far, fingerprint, logger),
             },
         )
     }
 
-    fn interpret_transaction_receipt(
-        &self,
-        scan_report: PendingPayableScanReport,
-        receipt: &TransactionReceipt,
-        fingerprint: PendingPayableFingerprint,
-        logger: &Logger,
-    ) -> PendingPayableScanReport {
-        const WEB3_SUCCESS: u64 = 1;
-        const WEB3_FAILURE: u64 = 0;
-
-        match receipt.status {
-            None => handle_none_status(
-                scan_report,
-                fingerprint,
-                self.when_pending_too_long_sec,
-                logger,
-            ),
-            Some(status_code) => {
-                let code = status_code.as_u64();
-                //TODO: failures handling is going to need enhancement suggested by GH-693
-                if code == WEB3_FAILURE {
-                    handle_status_with_failure(scan_report, fingerprint, logger)
-                } else if code == WEB3_SUCCESS {
-                    handle_status_with_success(scan_report, fingerprint, logger)
-                } else {
-                    unreachable!(
-                        "tx receipt for pending {:?}: status code other than 0 or 1 \
-                        shouldn't be possible, but was {}",
-                        fingerprint.hash, code
-                    )
-                }
-            }
-        }
-    }
-
     fn process_transactions_by_reported_state(
         &mut self,
         scan_report: PendingPayableScanReport,
@@ -854,26 +813,7 @@ impl Scanner<RetrieveTransactions, ReceivedPayments> for ReceivableScanner {
     }
 
     fn finish_scan(&mut self, msg: ReceivedPayments, logger: &Logger) -> Option<NodeToUiMessage> {
-        if msg.payments.is_empty() {
-            info!(
-                logger,
-                "No newly received payments were detected during the scanning process."
-            );
-
-            match self
-                .persistent_configuration
-                .set_start_block(Some(msg.new_start_block))
-            {
-                Ok(()) => debug!(logger, "Start block updated to {}", msg.new_start_block),
-                Err(e) => panic!(
-                    "Attempt to set new start block to {} failed due to: {:?}",
-                    msg.new_start_block, e
-                ),
-            }
-        } else {
-            self.handle_new_received_payments(&msg, logger)
-        }
-
+        self.handle_new_received_payments(&msg, logger);
         self.mark_as_ended(logger);
         msg.response_skeleton_opt
             .map(|response_skeleton| NodeToUiMessage {
@@ -905,39 +845,60 @@ impl ReceivableScanner {
         }
     }
 
-    fn handle_new_received_payments(&mut self, msg: &ReceivedPayments, logger: &Logger) {
-        let mut txn = self
-            .receivable_dao
-            .as_mut()
-            .more_money_received(msg.timestamp, &msg.payments);
-
-        let new_start_block = msg.new_start_block;
-        match self
-            .persistent_configuration
-            .set_start_block_from_txn(Some(new_start_block), &mut txn)
-        {
-            Ok(()) => (),
-            Err(e) => panic!(
-                "Attempt to set new start block to {} failed due to: {:?}",
-                new_start_block, e
-            ),
-        }
+    fn handle_new_received_payments(
+        &mut self,
+        received_payments_msg: &ReceivedPayments,
+        logger: &Logger,
+    ) {
+        if received_payments_msg.transactions.is_empty() {
+            info!(
+                logger,
+                "No newly received payments were detected during the scanning process."
+            );
+            let new_start_block = received_payments_msg.new_start_block;
+            match self
+                .persistent_configuration
+                .set_start_block(Some(new_start_block))
+            {
+                Ok(()) => debug!(logger, "Start block updated to {}", new_start_block),
+                Err(e) => panic!(
+                    "Attempt to set new start block to {} failed due to: {:?}",
+                    new_start_block, e
+                ),
+            }
+        } else {
+            let mut txn = self.receivable_dao.as_mut().more_money_received(
+                received_payments_msg.timestamp,
+                &received_payments_msg.transactions,
+            );
+            let new_start_block = received_payments_msg.new_start_block;
+            match self
+                .persistent_configuration
+                .set_start_block_from_txn(Some(new_start_block), &mut txn)
+            {
+                Ok(()) => (),
+                Err(e) => panic!(
+                    "Attempt to set new start block to {} failed due to: {:?}",
+                    new_start_block, e
+                ),
+            }
 
-        match txn.commit() {
-            Ok(_) => {
-                debug!(logger, "Updated start block to: {}", new_start_block)
+            match txn.commit() {
+                Ok(_) => {
+                    debug!(logger, "Updated start block to: {}", new_start_block)
+                }
+                Err(e) => panic!("Commit of received transactions failed: {:?}", e),
             }
-            Err(e) => panic!("Commit of received transactions failed: {:?}", e),
-        }
 
-        let total_newly_paid_receivable = msg
-            .payments
-            .iter()
-            .fold(0, |so_far, now| so_far + now.wei_amount);
+            let total_newly_paid_receivable = received_payments_msg
+                .transactions
+                .iter()
+                .fold(0, |so_far, now| so_far + now.wei_amount);
 
-        self.financial_statistics
-            .borrow_mut()
-            .total_paid_receivable_wei += total_newly_paid_receivable;
+            self.financial_statistics
+                .borrow_mut()
+                .total_paid_receivable_wei += total_newly_paid_receivable;
+        }
     }
 
     pub fn scan_for_delinquencies(&self, timestamp: SystemTime, logger: &Logger) {
@@ -1106,7 +1067,7 @@ mod tests {
     use crate::accountant::db_access_objects::utils::{from_time_t, to_time_t};
     use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::msgs::QualifiedPayablesMessage;
     use crate::accountant::scanners::scanners_utils::payable_scanner_utils::PendingPayableMetadata;
-    use crate::accountant::scanners::scanners_utils::pending_payable_scanner_utils::PendingPayableScanReport;
+    use crate::accountant::scanners::scanners_utils::pending_payable_scanner_utils::{handle_none_status, handle_status_with_failure, PendingPayableScanReport};
     use crate::accountant::scanners::test_utils::protect_payables_in_test;
     use crate::accountant::scanners::{
         BeginScanError, PayableScanner, PendingPayableScanner, ReceivableScanner, ScanSchedulers,
@@ -1120,20 +1081,17 @@ mod tests {
         PendingPayableDaoMock, PendingPayableScannerBuilder, ReceivableDaoFactoryMock,
         ReceivableDaoMock, ReceivableScannerBuilder,
     };
-    use crate::accountant::{
-        gwei_to_wei, PendingPayableId, ReceivedPayments, ReportTransactionReceipts,
-        RequestTransactionReceipts, SentPayables, DEFAULT_PENDING_TOO_LONG_SEC,
-    };
+    use crate::accountant::{gwei_to_wei, PendingPayableId, ReceivedPayments, ReportTransactionReceipts, RequestTransactionReceipts, SentPayables, DEFAULT_PENDING_TOO_LONG_SEC};
     use crate::blockchain::blockchain_bridge::{PendingPayableFingerprint, RetrieveTransactions};
     use crate::blockchain::blockchain_interface::data_structures::errors::PayableTransactionError;
     use crate::blockchain::blockchain_interface::data_structures::{
-        BlockchainTransaction, RpcPayablesFailure,
+        BlockchainTransaction, ProcessedPayableFallible, RpcPayableFailure,
     };
     use crate::blockchain::test_utils::make_tx_hash;
     use crate::database::rusqlite_wrappers::TransactionSafeWrapper;
     use crate::database::test_utils::transaction_wrapper_mock::TransactionInnerWrapperMockBuilder;
     use crate::db_config::mocks::ConfigDaoMock;
-    use crate::db_config::persistent_configuration::PersistentConfigError;
+    use crate::db_config::persistent_configuration::{PersistentConfigError};
     use crate::sub_lib::accountant::{
         DaoFactories, FinancialStatistics, PaymentThresholds, ScanIntervals,
         DEFAULT_PAYMENT_THRESHOLDS,
@@ -1157,6 +1115,7 @@ mod tests {
     use std::time::{Duration, SystemTime};
     use web3::types::{TransactionReceipt, H256};
     use web3::Error;
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{TransactionBlock, TransactionReceiptResult, TxReceipt, TxStatus};
 
     #[test]
     fn scanners_struct_can_be_constructed_with_the_respective_scanners() {
@@ -1367,7 +1326,7 @@ mod tests {
         let failure_payable_hash_2 = make_tx_hash(0xde);
         let failure_payable_rowid_2 = 126;
         let failure_payable_wallet_2 = make_wallet("hihihi");
-        let failure_payable_2 = RpcPayablesFailure {
+        let failure_payable_2 = RpcPayableFailure {
             rpc_error: Error::InvalidResponse(
                 "Learn how to write before you send your garbage!".to_string(),
             ),
@@ -1405,9 +1364,9 @@ mod tests {
         let logger = Logger::new(test_name);
         let sent_payable = SentPayables {
             payment_procedure_result: Ok(vec![
-                Ok(correct_pending_payable_1),
-                Err(failure_payable_2),
-                Ok(correct_pending_payable_3),
+                ProcessedPayableFallible::Correct(correct_pending_payable_1),
+                ProcessedPayableFallible::Failed(failure_payable_2),
+                ProcessedPayableFallible::Correct(correct_pending_payable_3),
             ]),
             response_skeleton_opt: None,
         };
@@ -1667,7 +1626,10 @@ mod tests {
             .pending_payable_dao(pending_payable_dao)
             .build();
         let sent_payable = SentPayables {
-            payment_procedure_result: Ok(vec![Ok(payment_1), Ok(payment_2)]),
+            payment_procedure_result: Ok(vec![
+                ProcessedPayableFallible::Correct(payment_1),
+                ProcessedPayableFallible::Correct(payment_2),
+            ]),
             response_skeleton_opt: None,
         };
 
@@ -1690,7 +1652,10 @@ mod tests {
             .pending_payable_dao(pending_payable_dao)
             .build();
         let sent_payables = SentPayables {
-            payment_procedure_result: Ok(vec![Ok(payable_1), Ok(payable_2)]),
+            payment_procedure_result: Ok(vec![
+                ProcessedPayableFallible::Correct(payable_1),
+                ProcessedPayableFallible::Correct(payable_2),
+            ]),
             response_skeleton_opt: None,
         };
 
@@ -1815,7 +1780,7 @@ mod tests {
             &format!("WARN: {test_name}: \
             Deleting fingerprints for failed transactions 0x00000000000000000000000000000000000000000000000000000000000015b3, \
             0x0000000000000000000000000000000000000000000000000000000000003039",
-        ));
+            ));
         // we haven't supplied any result for mark_pending_payable() and so it's proved uncalled
     }
 
@@ -1955,18 +1920,21 @@ mod tests {
         let mut subject = PayableScannerBuilder::new()
             .pending_payable_dao(pending_payable_dao)
             .build();
-        let failed_payment_1 = Err(RpcPayablesFailure {
+        let failed_payment_1 = RpcPayableFailure {
             rpc_error: Error::Unreachable,
             recipient_wallet: make_wallet("abc"),
             hash: existent_record_hash,
-        });
-        let failed_payment_2 = Err(RpcPayablesFailure {
+        };
+        let failed_payment_2 = RpcPayableFailure {
             rpc_error: Error::Internal,
             recipient_wallet: make_wallet("def"),
             hash: nonexistent_record_hash,
-        });
+        };
         let sent_payable = SentPayables {
-            payment_procedure_result: Ok(vec![failed_payment_1, failed_payment_2]),
+            payment_procedure_result: Ok(vec![
+                ProcessedPayableFallible::Failed(failed_payment_1),
+                ProcessedPayableFallible::Failed(failed_payment_2),
+            ]),
             response_skeleton_opt: None,
         };
 
@@ -2320,11 +2288,7 @@ mod tests {
         hash: H256,
     ) -> PendingPayableScanReport {
         init_test_logging();
-        let tx_receipt = TransactionReceipt::default(); //status defaulted to None
         let when_sent = SystemTime::now().sub(Duration::from_secs(pending_payable_age_sec));
-        let subject = PendingPayableScannerBuilder::new()
-            .when_pending_too_long_sec(when_pending_too_long_sec)
-            .build();
         let fingerprint = PendingPayableFingerprint {
             rowid,
             timestamp: when_sent,
@@ -2336,7 +2300,7 @@ mod tests {
         let logger = Logger::new(test_name);
         let scan_report = PendingPayableScanReport::default();
 
-        subject.interpret_transaction_receipt(scan_report, &tx_receipt, fingerprint, &logger)
+        handle_none_status(scan_report, fingerprint, when_pending_too_long_sec, &logger)
     }
 
     fn assert_log_msg_and_elapsed_time_in_log_makes_sense(
@@ -2400,7 +2364,7 @@ mod tests {
             00000000000000000000000237 has exceeded the maximum pending time \\({}sec\\) with the age \
             \\d+sec and the confirmation process is going to be aborted now at the final attempt 1; manual \
             resolution is required from the user to complete the transaction"
-            ,test_name, DEFAULT_PENDING_TOO_LONG_SEC, ),elapsed_after,capture_regex)
+            , test_name, DEFAULT_PENDING_TOO_LONG_SEC, ), elapsed_after, capture_regex)
     }
 
     #[test]
@@ -2428,7 +2392,7 @@ mod tests {
             }
         );
         let capture_regex = r#"\s(\d+)ms"#;
-        assert_log_msg_and_elapsed_time_in_log_makes_sense (&format!(
+        assert_log_msg_and_elapsed_time_in_log_makes_sense(&format!(
             "INFO: {test_name}: Pending transaction 0x0000000000000000000000000000000000000000000000000\
             00000000000007b couldn't be confirmed at attempt 1 at \\d+ms after its sending"), elapsed_after_ms, capture_regex);
     }
@@ -2464,29 +2428,10 @@ mod tests {
         ), elapsed_after_ms, capture_regex);
     }
 
-    #[test]
-    #[should_panic(
-        expected = "tx receipt for pending 0x000000000000000000000000000000000000000000000000000000000000007b: \
-         status code other than 0 or 1 shouldn't be possible, but was 456"
-    )]
-    fn interpret_transaction_receipt_panics_at_undefined_status_code() {
-        let mut tx_receipt = TransactionReceipt::default();
-        tx_receipt.status = Some(U64::from(456));
-        let mut fingerprint = make_pending_payable_fingerprint();
-        fingerprint.hash = make_tx_hash(0x7b);
-        let subject = PendingPayableScannerBuilder::new().build();
-        let scan_report = PendingPayableScanReport::default();
-        let logger = Logger::new("test");
-
-        let _ =
-            subject.interpret_transaction_receipt(scan_report, &tx_receipt, fingerprint, &logger);
-    }
-
     #[test]
     fn interpret_transaction_receipt_when_transaction_status_is_a_failure() {
         init_test_logging();
         let test_name = "interpret_transaction_receipt_when_transaction_status_is_a_failure";
-        let subject = PendingPayableScannerBuilder::new().build();
         let mut tx_receipt = TransactionReceipt::default();
         tx_receipt.status = Some(U64::from(0)); //failure
         let hash = make_tx_hash(0xd7);
@@ -2501,8 +2446,7 @@ mod tests {
         let logger = Logger::new(test_name);
         let scan_report = PendingPayableScanReport::default();
 
-        let result =
-            subject.interpret_transaction_receipt(scan_report, &tx_receipt, fingerprint, &logger);
+        let result = handle_status_with_failure(scan_report, fingerprint, &logger);
 
         assert_eq!(
             result,
@@ -2524,7 +2468,6 @@ mod tests {
         init_test_logging();
         let test_name = "handle_pending_txs_with_receipts_handles_none_for_receipt";
         let subject = PendingPayableScannerBuilder::new().build();
-        let tx_receipt_opt = None;
         let rowid = 455;
         let hash = make_tx_hash(0x913);
         let fingerprint = PendingPayableFingerprint {
@@ -2536,7 +2479,13 @@ mod tests {
             process_error: None,
         };
         let msg = ReportTransactionReceipts {
-            fingerprints_with_receipts: vec![(tx_receipt_opt, fingerprint.clone())],
+            fingerprints_with_receipts: vec![(
+                TransactionReceiptResult::RpcResponse(TxReceipt {
+                    transaction_hash: hash,
+                    status: TxStatus::Pending,
+                }),
+                fingerprint.clone(),
+            )],
             response_skeleton_opt: None,
         };
 
@@ -2854,9 +2803,13 @@ mod tests {
             .pending_payable_dao(pending_payable_dao)
             .build();
         let transaction_hash_1 = make_tx_hash(4545);
-        let mut transaction_receipt_1 = TransactionReceipt::default();
-        transaction_receipt_1.transaction_hash = transaction_hash_1;
-        transaction_receipt_1.status = Some(U64::from(1)); //success
+        let transaction_receipt_1 = TxReceipt {
+            transaction_hash: transaction_hash_1,
+            status: TxStatus::Succeeded(TransactionBlock {
+                block_hash: Default::default(),
+                block_number: U64::from(1234),
+            }),
+        };
         let fingerprint_1 = PendingPayableFingerprint {
             rowid: 5,
             timestamp: from_time_t(200_000_000),
@@ -2866,9 +2819,13 @@ mod tests {
             process_error: None,
         };
         let transaction_hash_2 = make_tx_hash(1234);
-        let mut transaction_receipt_2 = TransactionReceipt::default();
-        transaction_receipt_2.transaction_hash = transaction_hash_2;
-        transaction_receipt_2.status = Some(U64::from(1)); //success
+        let transaction_receipt_2 = TxReceipt {
+            transaction_hash: transaction_hash_2,
+            status: TxStatus::Succeeded(TransactionBlock {
+                block_hash: Default::default(),
+                block_number: U64::from(2345),
+            }),
+        };
         let fingerprint_2 = PendingPayableFingerprint {
             rowid: 10,
             timestamp: from_time_t(199_780_000),
@@ -2879,8 +2836,14 @@ mod tests {
         };
         let msg = ReportTransactionReceipts {
             fingerprints_with_receipts: vec![
-                (Some(transaction_receipt_1), fingerprint_1.clone()),
-                (Some(transaction_receipt_2), fingerprint_2.clone()),
+                (
+                    TransactionReceiptResult::RpcResponse(transaction_receipt_1),
+                    fingerprint_1.clone(),
+                ),
+                (
+                    TransactionReceiptResult::RpcResponse(transaction_receipt_2),
+                    fingerprint_2.clone(),
+                ),
             ],
             response_skeleton_opt: None,
         };
@@ -3066,7 +3029,7 @@ mod tests {
     #[test]
     fn receivable_scanner_handles_no_new_payments_found() {
         init_test_logging();
-        let test_name = "receivable_scanner_aborts_scan_if_no_payments_were_supplied";
+        let test_name = "receivable_scanner_handles_no_new_payments_found";
         let set_start_block_params_arc = Arc::new(Mutex::new(vec![]));
         let new_start_block = 4321;
         let persistent_config = PersistentConfigurationMock::new()
@@ -3078,9 +3041,9 @@ mod tests {
             .build();
         let msg = ReceivedPayments {
             timestamp: SystemTime::now(),
-            payments: vec![],
             new_start_block,
             response_skeleton_opt: None,
+            transactions: vec![],
         };
 
         let message_opt = subject.finish_scan(msg, &Logger::new(test_name));
@@ -3113,10 +3076,11 @@ mod tests {
             .build();
         let msg = ReceivedPayments {
             timestamp: now,
-            payments: vec![],
             new_start_block,
             response_skeleton_opt: None,
+            transactions: vec![],
         };
+
         // Not necessary, rather for preciseness
         subject.mark_as_started(SystemTime::now());
 
@@ -3165,9 +3129,9 @@ mod tests {
         ];
         let msg = ReceivedPayments {
             timestamp: now,
-            payments: receivables.clone(),
             new_start_block: 7890123,
             response_skeleton_opt: None,
+            transactions: receivables.clone(),
         };
         subject.mark_as_started(SystemTime::now());
 
@@ -3220,9 +3184,9 @@ mod tests {
         }];
         let msg = ReceivedPayments {
             timestamp: now,
-            payments: receivables,
             new_start_block: 7890123,
             response_skeleton_opt: None,
+            transactions: receivables,
         };
         // Not necessary, rather for preciseness
         subject.mark_as_started(SystemTime::now());
@@ -3264,9 +3228,9 @@ mod tests {
         }];
         let msg = ReceivedPayments {
             timestamp: now,
-            payments: receivables,
-            new_start_block: 7890123,
+            new_start_block: 0,
             response_skeleton_opt: None,
+            transactions: receivables,
         };
         // Not necessary, rather for preciseness
         subject.mark_as_started(SystemTime::now());
diff --git a/node/src/accountant/scanners/scanners_utils.rs b/node/src/accountant/scanners/scanners_utils.rs
index 897015dec..30b3a3d2d 100644
--- a/node/src/accountant/scanners/scanners_utils.rs
+++ b/node/src/accountant/scanners/scanners_utils.rs
@@ -6,7 +6,7 @@ pub mod payable_scanner_utils {
     use crate::accountant::scanners::scanners_utils::payable_scanner_utils::PayableTransactingErrorEnum::{
         LocallyCausedError, RemotelyCausedErrors,
     };
-    use crate::accountant::{comma_joined_stringifiable, ProcessedPayableFallible, SentPayables};
+    use crate::accountant::{comma_joined_stringifiable, SentPayables};
     use crate::sub_lib::accountant::PaymentThresholds;
     use crate::sub_lib::wallet::Wallet;
     use itertools::Itertools;
@@ -18,7 +18,7 @@ pub mod payable_scanner_utils {
     use web3::types::H256;
     use crate::accountant::db_access_objects::pending_payable_dao::PendingPayable;
     use crate::blockchain::blockchain_interface::data_structures::errors::PayableTransactionError;
-    use crate::blockchain::blockchain_interface::data_structures::{RpcPayablesFailure};
+    use crate::blockchain::blockchain_interface::data_structures::{ProcessedPayableFallible, RpcPayableFailure};
 
     #[derive(Debug, PartialEq, Eq)]
     pub enum PayableTransactingErrorEnum {
@@ -152,8 +152,10 @@ pub mod payable_scanner_utils {
         logger: &'b Logger,
     ) -> SeparateTxsByResult<'a> {
         match rpc_result {
-            Ok(pending_payable) => add_pending_payable(acc, pending_payable),
-            Err(RpcPayablesFailure {
+            ProcessedPayableFallible::Correct(pending_payable) => {
+                add_pending_payable(acc, pending_payable)
+            }
+            ProcessedPayableFallible::Failed(RpcPayableFailure {
                 rpc_error,
                 recipient_wallet,
                 hash,
@@ -381,6 +383,7 @@ pub mod pending_payable_scanner_utils {
         scan_report
     }
 
+    //TODO: failures handling is going to need enhancement suggested by GH-693
     pub fn handle_status_with_failure(
         mut scan_report: PendingPayableScanReport,
         fingerprint: PendingPayableFingerprint,
@@ -397,6 +400,27 @@ pub mod pending_payable_scanner_utils {
         scan_report.failures.push(fingerprint.into());
         scan_report
     }
+
+    pub fn handle_none_receipt(
+        mut scan_report: PendingPayableScanReport,
+        payable: PendingPayableFingerprint,
+        error_msg: &str,
+        logger: &Logger,
+    ) -> PendingPayableScanReport {
+        debug!(
+            logger,
+            "Interpreting a receipt for transaction {:?} but {}; attempt {}, {}ms since sending",
+            payable.hash,
+            error_msg,
+            payable.attempt,
+            elapsed_in_ms(payable.timestamp)
+        );
+
+        scan_report
+            .still_pending
+            .push(PendingPayableId::new(payable.rowid, payable.hash));
+        scan_report
+    }
 }
 
 pub mod receivable_scanner_utils {
@@ -438,7 +462,7 @@ mod tests {
     use std::time::SystemTime;
     use crate::accountant::db_access_objects::pending_payable_dao::PendingPayable;
     use crate::blockchain::blockchain_interface::data_structures::errors::{BlockchainError, PayableTransactionError};
-    use crate::blockchain::blockchain_interface::data_structures::{RpcPayablesFailure};
+    use crate::blockchain::blockchain_interface::data_structures::{ProcessedPayableFallible, RpcPayableFailure};
 
     #[test]
     fn investigate_debt_extremes_picks_the_most_relevant_records() {
@@ -508,8 +532,8 @@ mod tests {
         };
         let sent_payable = SentPayables {
             payment_procedure_result: Ok(vec![
-                Ok(correct_payment_1.clone()),
-                Ok(correct_payment_2.clone()),
+                ProcessedPayableFallible::Correct(correct_payment_1.clone()),
+                ProcessedPayableFallible::Correct(correct_payment_2.clone()),
             ]),
             response_skeleton_opt: None,
         };
@@ -550,13 +574,16 @@ mod tests {
             recipient_wallet: make_wallet("blah"),
             hash: make_tx_hash(123),
         };
-        let bad_rpc_call = RpcPayablesFailure {
+        let bad_rpc_call = RpcPayableFailure {
             rpc_error: web3::Error::InvalidResponse("That jackass screwed it up".to_string()),
             recipient_wallet: make_wallet("whooa"),
             hash: make_tx_hash(0x315),
         };
         let sent_payable = SentPayables {
-            payment_procedure_result: Ok(vec![Ok(payable_ok.clone()), Err(bad_rpc_call.clone())]),
+            payment_procedure_result: Ok(vec![
+                ProcessedPayableFallible::Correct(payable_ok.clone()),
+                ProcessedPayableFallible::Failed(bad_rpc_call.clone()),
+            ]),
             response_skeleton_opt: None,
         };
 
@@ -757,7 +784,9 @@ mod tests {
                 "blah".to_string(),
             )),
             PayableTransactionError::MissingConsumingWallet,
-            PayableTransactionError::GasPriceQueryFailed("ouch".to_string()),
+            PayableTransactionError::GasPriceQueryFailed(BlockchainError::QueryFailed(
+                "ouch".to_string(),
+            )),
             PayableTransactionError::UnusableWallet("fooo".to_string()),
             PayableTransactionError::Signing("tsss".to_string()),
         ];
diff --git a/node/src/accountant/test_utils.rs b/node/src/accountant/test_utils.rs
index 6de6968ac..5c9d6f14a 100644
--- a/node/src/accountant/test_utils.rs
+++ b/node/src/accountant/test_utils.rs
@@ -29,6 +29,7 @@ use crate::accountant::{
     gwei_to_wei, Accountant, ResponseSkeleton, SentPayables, DEFAULT_PENDING_TOO_LONG_SEC,
 };
 use crate::blockchain::blockchain_bridge::PendingPayableFingerprint;
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::HashAndAmount;
 use crate::blockchain::blockchain_interface::data_structures::BlockchainTransaction;
 use crate::blockchain::test_utils::make_tx_hash;
 use crate::bootstrapper::BootstrapperConfig;
@@ -891,7 +892,7 @@ pub struct PendingPayableDaoMock {
     fingerprints_rowids_results: RefCell<Vec<TransactionHashes>>,
     delete_fingerprints_params: Arc<Mutex<Vec<Vec<u64>>>>,
     delete_fingerprints_results: RefCell<Vec<Result<(), PendingPayableDaoError>>>,
-    insert_new_fingerprints_params: Arc<Mutex<Vec<(Vec<(H256, u128)>, SystemTime)>>>,
+    insert_new_fingerprints_params: Arc<Mutex<Vec<(Vec<HashAndAmount>, SystemTime)>>>,
     insert_new_fingerprints_results: RefCell<Vec<Result<(), PendingPayableDaoError>>>,
     increment_scan_attempts_params: Arc<Mutex<Vec<Vec<u64>>>>,
     increment_scan_attempts_result: RefCell<Vec<Result<(), PendingPayableDaoError>>>,
@@ -932,7 +933,7 @@ impl PendingPayableDao for PendingPayableDaoMock {
 
     fn insert_new_fingerprints(
         &self,
-        hashes_and_amounts: &[(H256, u128)],
+        hashes_and_amounts: &[HashAndAmount],
         batch_wide_timestamp: SystemTime,
     ) -> Result<(), PendingPayableDaoError> {
         self.insert_new_fingerprints_params
@@ -981,7 +982,7 @@ impl PendingPayableDaoMock {
 
     pub fn insert_fingerprints_params(
         mut self,
-        params: &Arc<Mutex<Vec<(Vec<(H256, u128)>, SystemTime)>>>,
+        params: &Arc<Mutex<Vec<(Vec<HashAndAmount>, SystemTime)>>>,
     ) -> Self {
         self.insert_new_fingerprints_params = params.clone();
         self
diff --git a/node/src/actor_system_factory.rs b/node/src/actor_system_factory.rs
index 2a30f5f48..0cb035f61 100644
--- a/node/src/actor_system_factory.rs
+++ b/node/src/actor_system_factory.rs
@@ -308,7 +308,7 @@ impl ActorSystemFactoryToolsReal {
                 AutomapChange::NewIp(new_public_ip) => {
                     exit_process(
                         1,
-                        format! ("IP change to {} reported from ISP. We can't handle that until GH-499. Going down...", new_public_ip).as_str()
+                        format!("IP change to {} reported from ISP. We can't handle that until GH-499. Going down...", new_public_ip).as_str(),
                     );
                 }
                 AutomapChange::Error(e) => Self::handle_housekeeping_thread_error(e),
@@ -378,7 +378,17 @@ pub trait ActorFactory {
     fn make_and_start_configurator(&self, config: &BootstrapperConfig) -> ConfiguratorSubs;
 }
 
-pub struct ActorFactoryReal {}
+pub struct ActorFactoryReal {
+    logger: Logger,
+}
+
+impl ActorFactoryReal {
+    pub fn new() -> Self {
+        Self {
+            logger: Logger::new("ActorFactory"),
+        }
+    }
+}
 
 impl ActorFactory for ActorFactoryReal {
     fn make_and_start_dispatcher(
@@ -509,10 +519,12 @@ impl ActorFactory for ActorFactoryReal {
         let data_directory = config.data_directory.clone();
         let chain = config.blockchain_bridge_config.chain;
         let arbiter = Arbiter::builder().stop_system_on_panic(true);
+        let logger = self.logger.clone();
         let addr: Addr<BlockchainBridge> = arbiter.start(move |_| {
             let blockchain_interface = BlockchainBridge::initialize_blockchain_interface(
                 blockchain_service_url_opt,
                 chain,
+                logger,
             );
             let persistent_config =
                 BlockchainBridge::initialize_persistent_configuration(&data_directory);
@@ -624,7 +636,6 @@ mod tests {
     use super::*;
     use crate::accountant::exportable_test_parts::test_accountant_is_constructed_with_upgraded_db_connection_recognizing_our_extra_sqlite_functions;
     use crate::accountant::DEFAULT_PENDING_TOO_LONG_SEC;
-    use crate::blockchain::blockchain_bridge::exportable_test_parts::test_blockchain_bridge_is_constructed_with_correctly_functioning_connections;
     use crate::bootstrapper::{Bootstrapper, RealUser};
     use crate::node_test_utils::{
         make_stream_handler_pool_subs_from_recorder, start_recorder_refcell_opt,
@@ -1050,7 +1061,7 @@ mod tests {
         };
         let main_cryptde_public_key_expected = pk_from_cryptde_null(main_cryptde);
         let alias_cryptde_public_key_expected = pk_from_cryptde_null(alias_cryptde);
-        let actor_factory = Box::new(ActorFactoryReal {});
+        let actor_factory = Box::new(ActorFactoryReal::new());
         let actor_factory_raw_address_expected = addr_of!(*actor_factory);
         let persistent_config_expected_arbitrary_id = ArbitraryIdStamp::new();
         let persistent_config = Box::new(
@@ -1236,7 +1247,7 @@ mod tests {
             earning_wallet: make_wallet("earning"),
             consuming_wallet_opt: Some(make_wallet("consuming")),
             data_directory: PathBuf::new(),
-            node_descriptor: NodeDescriptor::try_from ((main_cryptde(), "masq://polygon-mainnet:OHsC2CAm4rmfCkaFfiynwxflUgVTJRb2oY5mWxNCQkY@172.50.48.6:9342")).unwrap(),
+            node_descriptor: NodeDescriptor::try_from((main_cryptde(), "masq://polygon-mainnet:OHsC2CAm4rmfCkaFfiynwxflUgVTJRb2oY5mWxNCQkY@172.50.48.6:9342")).unwrap(),
             main_cryptde_null_opt: None,
             alias_cryptde_null_opt: None,
             mapping_protocol_opt: Some(AutomapProtocol::Igdp),
@@ -1250,7 +1261,7 @@ mod tests {
                 min_hops: MIN_HOPS_FOR_TEST,
             },
             payment_thresholds_opt: Default::default(),
-            when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC
+            when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC,
         };
         let add_mapping_params_arc = Arc::new(Mutex::new(vec![]));
         let mut subject = make_subject_with_null_setter();
@@ -1337,7 +1348,7 @@ mod tests {
         let dispatcher_param = Parameters::get(parameters.dispatcher_params);
         assert_eq!(
             dispatcher_param.node_descriptor,
-            NodeDescriptor::try_from ((main_cryptde(), "masq://polygon-mainnet:OHsC2CAm4rmfCkaFfiynwxflUgVTJRb2oY5mWxNCQkY@172.50.48.6:9342")).unwrap()
+            NodeDescriptor::try_from((main_cryptde(), "masq://polygon-mainnet:OHsC2CAm4rmfCkaFfiynwxflUgVTJRb2oY5mWxNCQkY@172.50.48.6:9342")).unwrap()
         );
         let blockchain_bridge_param = Parameters::get(parameters.blockchain_bridge_params);
         assert_eq!(
@@ -1549,7 +1560,7 @@ mod tests {
                 min_hops: MIN_HOPS_FOR_TEST,
             },
             payment_thresholds_opt: Default::default(),
-            when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC
+            when_pending_too_long_sec: DEFAULT_PENDING_TOO_LONG_SEC,
         };
         let system = System::new("MASQNode");
         let mut subject = make_subject_with_null_setter();
@@ -1762,7 +1773,7 @@ mod tests {
         let closure = || {
             let mut bootstrapper_config = BootstrapperConfig::default();
             bootstrapper_config.crash_point = CrashPoint::Message;
-            let subscribers = ActorFactoryReal {}
+            let subscribers = ActorFactoryReal::new()
                 .make_and_start_proxy_server(make_cryptde_pair(), &bootstrapper_config);
             subscribers.node_from_ui
         };
@@ -1783,7 +1794,7 @@ mod tests {
                 crashable: true,
                 exit_byte_rate: 50,
             };
-            let subscribers = ActorFactoryReal {}.make_and_start_proxy_client(proxy_cl_config);
+            let subscribers = ActorFactoryReal::new().make_and_start_proxy_client(proxy_cl_config);
             subscribers.node_from_ui
         };
 
@@ -1800,7 +1811,7 @@ mod tests {
                 is_decentralized: false,
                 crashable: true,
             };
-            let subscribers = ActorFactoryReal {}.make_and_start_hopper(hopper_config);
+            let subscribers = ActorFactoryReal::new().make_and_start_hopper(hopper_config);
             subscribers.node_from_ui
         };
 
@@ -1812,7 +1823,8 @@ mod tests {
         let closure = || {
             let mut bootstrapper_config = BootstrapperConfig::default();
             bootstrapper_config.crash_point = CrashPoint::Message;
-            let subscribers = ActorFactoryReal {}.make_and_start_ui_gateway(&bootstrapper_config);
+            let subscribers =
+                ActorFactoryReal::new().make_and_start_ui_gateway(&bootstrapper_config);
             subscribers.node_from_ui_message_sub
         };
 
@@ -1825,7 +1837,7 @@ mod tests {
             let mut bootstrapper_config = BootstrapperConfig::default();
             bootstrapper_config.crash_point = CrashPoint::Message;
             let subscribers =
-                ActorFactoryReal {}.make_and_start_stream_handler_pool(&bootstrapper_config);
+                ActorFactoryReal::new().make_and_start_stream_handler_pool(&bootstrapper_config);
             subscribers.node_from_ui_sub
         };
 
@@ -1948,7 +1960,7 @@ mod tests {
 
         let _ = subject.make_and_start_actors(
             bootstrapper_config,
-            Box::new(ActorFactoryReal {}),
+            Box::new(ActorFactoryReal::new()),
             Box::new(persistent_config),
         );
     }
@@ -1960,7 +1972,7 @@ mod tests {
                    db_initializer: DbInitializerReal,
                    banned_cache_loader: BannedCacheLoaderMock,
                    address_leaker: SubsFactoryTestAddrLeaker<Accountant>| {
-            ActorFactoryReal {}.make_and_start_accountant(
+            ActorFactoryReal::new().make_and_start_accountant(
                 bootstrapper_config,
                 &db_initializer,
                 &banned_cache_loader,
@@ -1975,21 +1987,6 @@ mod tests {
         )
     }
 
-    #[test]
-    fn blockchain_bridge_is_constructed_with_correctly_functioning_connections() {
-        let act = |bootstrapper_config: BootstrapperConfig,
-                   address_leaker: SubsFactoryTestAddrLeaker<BlockchainBridge>| {
-            ActorFactoryReal {}
-                .make_and_start_blockchain_bridge(&bootstrapper_config, &address_leaker)
-        };
-
-        test_blockchain_bridge_is_constructed_with_correctly_functioning_connections(
-            "actor_system_factory",
-            "blockchain_bridge_is_constructed_with_correctly_functioning_connections",
-            act,
-        )
-    }
-
     #[test]
     fn load_banned_cache_implements_panic_on_migration() {
         let data_dir = ensure_node_home_directory_exists(
diff --git a/node/src/blockchain/blockchain_bridge.rs b/node/src/blockchain/blockchain_bridge.rs
index 67d018e27..0de419dfb 100644
--- a/node/src/blockchain/blockchain_bridge.rs
+++ b/node/src/blockchain/blockchain_bridge.rs
@@ -1,16 +1,15 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
-use crate::accountant::db_access_objects::payable_dao::PayableAccount;
-use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
 use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::msgs::{
     BlockchainAgentWithContextMessage, QualifiedPayablesMessage,
 };
 use crate::accountant::{
-    ReceivedPayments, ResponseSkeleton, ScanError, SentPayables, SkeletonOptHolder,
+    ReceivedPayments, ResponseSkeleton, ScanError,
+    SentPayables, SkeletonOptHolder,
 };
 use crate::accountant::{ReportTransactionReceipts, RequestTransactionReceipts};
 use crate::actor_system_factory::SubsFactory;
-use crate::blockchain::blockchain_interface::blockchain_interface_null::BlockchainInterfaceNull;
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::HashAndAmount;
 use crate::blockchain::blockchain_interface::data_structures::errors::{
     BlockchainError, PayableTransactionError,
 };
@@ -22,33 +21,41 @@ use crate::db_config::config_dao::ConfigDaoReal;
 use crate::db_config::persistent_configuration::{
     PersistentConfiguration, PersistentConfigurationReal,
 };
-use crate::sub_lib::blockchain_bridge::{BlockchainBridgeSubs, OutboundPaymentsInstructions};
+use crate::sub_lib::blockchain_bridge::{
+    BlockchainBridgeSubs, OutboundPaymentsInstructions,
+};
 use crate::sub_lib::peer_actors::BindMessage;
 use crate::sub_lib::utils::{db_connection_launch_panic, handle_ui_crash_request};
-use crate::sub_lib::wallet::Wallet;
+use crate::sub_lib::wallet::{Wallet};
 use actix::Actor;
 use actix::Context;
 use actix::Handler;
 use actix::Message;
 use actix::{Addr, Recipient};
+use futures::Future;
 use itertools::Itertools;
 use masq_lib::blockchains::chains::Chain;
-use masq_lib::constants::DEFAULT_MAX_BLOCK_COUNT;
 use masq_lib::logger::Logger;
 use masq_lib::messages::ScanType;
 use masq_lib::ui_gateway::NodeFromUiMessage;
-use masq_lib::utils::to_string;
 use regex::Regex;
 use std::path::Path;
+use std::string::ToString;
+use std::sync::{Arc, Mutex};
 use std::time::SystemTime;
-use web3::types::{BlockNumber, TransactionReceipt, H256};
+use ethabi::Hash;
+use web3::types::H256;
+use crate::accountant::db_access_objects::payable_dao::PayableAccount;
+use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{TransactionReceiptResult, TxStatus};
 
 pub const CRASH_KEY: &str = "BLOCKCHAINBRIDGE";
+pub const DEFAULT_BLOCKCHAIN_SERVICE_URL: &str = "https://0.0.0.0";
 
 pub struct BlockchainBridge {
     blockchain_interface: Box<dyn BlockchainInterface>,
     logger: Logger,
-    persistent_config: Box<dyn PersistentConfiguration>,
+    persistent_config_arc: Arc<Mutex<dyn PersistentConfiguration>>,
     sent_payable_subs_opt: Option<Recipient<SentPayables>>,
     payable_payments_setup_subs_opt: Option<Recipient<BlockchainAgentWithContextMessage>>,
     received_payments_subs_opt: Option<Recipient<ReceivedPayments>>,
@@ -62,6 +69,18 @@ struct TransactionConfirmationTools {
     report_transaction_receipts_sub_opt: Option<Recipient<ReportTransactionReceipts>>,
 }
 
+#[derive(PartialEq, Eq)]
+pub enum BlockScanRange {
+    NoLimit,
+    Range(u64),
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum BlockMarker {
+    Uninitialized,
+    Value(u64),
+}
+
 impl Actor for BlockchainBridge {
     type Context = Context<Self>;
 }
@@ -106,7 +125,7 @@ impl Handler<RetrieveTransactions> for BlockchainBridge {
         msg: RetrieveTransactions,
         _ctx: &mut Self::Context,
     ) -> <Self as Handler<RetrieveTransactions>>::Result {
-        self.handle_scan(
+        self.handle_scan_future(
             Self::handle_retrieve_transactions,
             ScanType::Receivables,
             msg,
@@ -118,7 +137,7 @@ impl Handler<RequestTransactionReceipts> for BlockchainBridge {
     type Result = ();
 
     fn handle(&mut self, msg: RequestTransactionReceipts, _ctx: &mut Self::Context) {
-        self.handle_scan(
+        self.handle_scan_future(
             Self::handle_request_transaction_receipts,
             ScanType::PendingPayables,
             msg,
@@ -130,7 +149,7 @@ impl Handler<QualifiedPayablesMessage> for BlockchainBridge {
     type Result = ();
 
     fn handle(&mut self, msg: QualifiedPayablesMessage, _ctx: &mut Self::Context) {
-        self.handle_scan(Self::handle_qualified_payable_msg, ScanType::Payables, msg);
+        self.handle_scan_future(Self::handle_qualified_payable_msg, ScanType::Payables, msg);
     }
 }
 
@@ -138,7 +157,7 @@ impl Handler<OutboundPaymentsInstructions> for BlockchainBridge {
     type Result = ();
 
     fn handle(&mut self, msg: OutboundPaymentsInstructions, _ctx: &mut Self::Context) {
-        self.handle_scan(
+        self.handle_scan_future(
             Self::handle_outbound_payments_instructions,
             ScanType::Payables,
             msg,
@@ -149,7 +168,7 @@ impl Handler<OutboundPaymentsInstructions> for BlockchainBridge {
 #[derive(Debug, Clone, PartialEq, Eq, Message)]
 pub struct PendingPayableFingerprintSeeds {
     pub batch_wide_timestamp: SystemTime,
-    pub hashes_and_balances: Vec<(H256, u128)>,
+    pub hashes_and_balances: Vec<HashAndAmount>,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -175,12 +194,12 @@ impl Handler<NodeFromUiMessage> for BlockchainBridge {
 impl BlockchainBridge {
     pub fn new(
         blockchain_interface: Box<dyn BlockchainInterface>,
-        persistent_config: Box<dyn PersistentConfiguration>,
+        persistent_config: Arc<Mutex<dyn PersistentConfiguration>>,
         crashable: bool,
     ) -> BlockchainBridge {
         BlockchainBridge {
             blockchain_interface,
-            persistent_config,
+            persistent_config_arc: persistent_config,
             sent_payable_subs_opt: None,
             payable_payments_setup_subs_opt: None,
             received_payments_subs_opt: None,
@@ -196,26 +215,32 @@ impl BlockchainBridge {
 
     pub fn initialize_persistent_configuration(
         data_directory: &Path,
-    ) -> Box<dyn PersistentConfiguration> {
+    ) -> Arc<Mutex<dyn PersistentConfiguration>> {
         let config_dao = Box::new(ConfigDaoReal::new(
             DbInitializerReal::default()
                 .initialize(data_directory, DbInitializationConfig::panic_on_migration())
                 .unwrap_or_else(|err| db_connection_launch_panic(err, data_directory)),
         ));
-        Box::new(PersistentConfigurationReal::new(config_dao))
+        Arc::new(Mutex::new(PersistentConfigurationReal::new(config_dao)))
     }
 
     pub fn initialize_blockchain_interface(
         blockchain_service_url_opt: Option<String>,
         chain: Chain,
+        logger: Logger,
     ) -> Box<dyn BlockchainInterface> {
         match blockchain_service_url_opt {
             Some(url) => {
                 // TODO if we decided to have interchangeably runtime switchable or simultaneously usable interfaces we will
                 // probably want to make BlockchainInterfaceInitializer a collaborator that's a part of the actor
+                info!(logger, "Blockchain service url has been set to {}", url);
                 BlockchainInterfaceInitializer {}.initialize_interface(&url, chain)
             }
-            None => Box::new(BlockchainInterfaceNull::default()),
+            None => {
+                info!(logger, "The Blockchain service url is not set yet. its been defaulted to a wild card IP");
+                BlockchainInterfaceInitializer {}
+                    .initialize_interface(DEFAULT_BLOCKCHAIN_SERVICE_URL, chain)
+            }
         }
     }
 
@@ -233,244 +258,266 @@ impl BlockchainBridge {
     fn handle_qualified_payable_msg(
         &mut self,
         incoming_message: QualifiedPayablesMessage,
-    ) -> Result<(), String> {
-        let agent = self
-            .blockchain_interface
-            .build_blockchain_agent(&incoming_message.consuming_wallet, &*self.persistent_config)
-            .map_err(to_string)?;
-
-        let outgoing_message = BlockchainAgentWithContextMessage::new(
-            incoming_message.protected_qualified_payables,
-            agent,
-            incoming_message.response_skeleton_opt,
-        );
-
-        self.payable_payments_setup_subs_opt
-            .as_ref()
-            .expect("Accountant is unbound")
-            .try_send(outgoing_message)
-            .expect("Accountant is dead");
-
-        Ok(())
+    ) -> Box<dyn Future<Item = (), Error = String>> {
+        // TODO rewrite this into a batch call as soon as GH-629 gets into master
+        let accountant_recipient = self.payable_payments_setup_subs_opt.clone();
+        Box::new(
+            self.blockchain_interface
+                .build_blockchain_agent(incoming_message.consuming_wallet)
+                .map_err(|e| format!("Blockchain agent build error: {:?}", e))
+                .and_then(move |agent| {
+                    let outgoing_message = BlockchainAgentWithContextMessage::new(
+                        incoming_message.protected_qualified_payables,
+                        agent,
+                        incoming_message.response_skeleton_opt,
+                    );
+                    accountant_recipient
+                        .expect("Accountant is unbound")
+                        .try_send(outgoing_message)
+                        .expect("Accountant is dead");
+                    Ok(())
+                }),
+        )
     }
 
     fn handle_outbound_payments_instructions(
         &mut self,
         msg: OutboundPaymentsInstructions,
-    ) -> Result<(), String> {
+    ) -> Box<dyn Future<Item = (), Error = String>> {
         let skeleton_opt = msg.response_skeleton_opt;
-        let agent = msg.agent;
-        let checked_accounts = msg.affordable_accounts;
-        let result = self.process_payments(agent, checked_accounts);
-
-        let locally_produced_result = match &result {
-            Err(e) => Err(format!("ReportAccountsPayable: {}", e)),
-            Ok(_) => Ok(()),
-        };
-
-        self.sent_payable_subs_opt
+        let sent_payable_subs = self
+            .sent_payable_subs_opt
             .as_ref()
             .expect("Accountant is unbound")
-            .try_send(SentPayables {
-                payment_procedure_result: result,
-                response_skeleton_opt: skeleton_opt,
-            })
-            .expect("Accountant is dead");
+            .clone();
+
+        let send_message_if_failure = move |msg: SentPayables| {
+            sent_payable_subs.try_send(msg).expect("Accountant is dead");
+        };
+        let send_message_if_successful = send_message_if_failure.clone();
 
-        locally_produced_result
+        Box::new(
+            self.process_payments(msg.agent, msg.affordable_accounts)
+                .map_err(move |e: PayableTransactionError| {
+                    send_message_if_failure(SentPayables {
+                        payment_procedure_result: Err(e.clone()),
+                        response_skeleton_opt: skeleton_opt,
+                    });
+                    format!("ReportAccountsPayable: {}", e)
+                })
+                .and_then(move |payment_result| {
+                    send_message_if_successful(SentPayables {
+                        payment_procedure_result: Ok(payment_result),
+                        response_skeleton_opt: skeleton_opt,
+                    });
+                    Ok(())
+                }),
+        )
     }
 
-    fn handle_retrieve_transactions(&mut self, msg: RetrieveTransactions) -> Result<(), String> {
-        let start_block_nbr = match self.persistent_config.start_block() {
-            Ok(Some(sb)) => sb,
-            Ok(None) => u64::MAX,
-            Err(e) => panic!("Cannot retrieve start block from database; payments to you may not be processed: {:?}", e)
-        };
-        let max_block_count = match self.persistent_config.max_block_count() {
-            Ok(Some(mbc)) => mbc,
-            _ => DEFAULT_MAX_BLOCK_COUNT,
-        };
-        let use_unlimited_block_count_range = u64::MAX == max_block_count;
-        let use_latest_block = u64::MAX == start_block_nbr;
-        let end_block = match self
-            .blockchain_interface
-            .lower_interface()
-            .get_block_number()
-        {
-            Ok(eb) => {
-                if use_unlimited_block_count_range || use_latest_block {
-                    BlockNumber::Number(eb)
-                } else {
-                    BlockNumber::Number(eb.as_u64().min(start_block_nbr + max_block_count).into())
-                }
-            }
-            Err(e) => {
-                if use_unlimited_block_count_range || use_latest_block {
-                    debug!(
-                        self.logger,
-                        "Using 'latest' block number instead of a literal number. {:?}", e
-                    );
-                    BlockNumber::Latest
-                } else {
-                    debug!(
-                        self.logger,
-                        "Using '{}' ending block number. {:?}",
-                        start_block_nbr + max_block_count,
-                        e
-                    );
-                    BlockNumber::Number((start_block_nbr + max_block_count).into())
-                }
-            }
-        };
-        let start_block = if use_latest_block {
-            end_block
-        } else {
-            BlockNumber::Number(start_block_nbr.into())
+    fn handle_retrieve_transactions(
+        &mut self,
+        msg: RetrieveTransactions,
+    ) -> Box<dyn Future<Item = (), Error = String>> {
+        let (start_block, block_scan_range) = {
+            let persistent_config_lock = self
+                .persistent_config_arc
+                .lock()
+                .expect("Unable to lock persistent config in BlockchainBridge");
+            let start_block_value = match persistent_config_lock.start_block() {
+                    Ok(Some(block)) => BlockMarker::Value(block),
+                    Ok(None) => BlockMarker::Uninitialized,
+                    Err(e) => panic!("Cannot retrieve start block from database; payments to you may not be processed: {:?}", e)
+                };
+            // TODO: Rename this field to block_scan_range but it'll require changes in database and UI communication
+            let block_scan_range_value = match persistent_config_lock.max_block_count() {
+                    Ok(Some(range)) => BlockScanRange::Range(range),
+                    Ok(None) => BlockScanRange::NoLimit,
+                    Err(e) => panic!("Cannot retrieve block scan range from database; payments to you may not be processed: {:?}", e)
+                };
+            (start_block_value, block_scan_range_value)
         };
-        let retrieved_transactions =
+
+        let logger = self.logger.clone();
+        let received_payments_subs = self
+            .received_payments_subs_opt
+            .as_ref()
+            .expect("Accountant is unbound")
+            .clone();
+        let persistent_config_arc = self.persistent_config_arc.clone();
+
+        Box::new(
             self.blockchain_interface
-                .retrieve_transactions(start_block, end_block, &msg.recipient);
-        match retrieved_transactions {
-            Ok(transactions) => {
-                if let BlockNumber::Number(new_start_block_number) = transactions.new_start_block {
-                    if transactions.transactions.is_empty() {
-                        debug!(self.logger, "No new receivable detected");
+                .retrieve_transactions(
+                    start_block,
+                    block_scan_range,
+                    msg.recipient.address(),
+                )
+                .map_err(move |e| {
+                    if let Some(max_block_count) =
+                        BlockchainBridge::extract_max_block_count(e.clone())
+                    {
+                        match persistent_config_arc
+                            .lock()
+                            .expect("Mutex with persistent configuration in BlockchainBridge was poisoned")
+                            .set_max_block_count(Some(max_block_count))
+                        {
+                            Ok(()) => {
+                                debug!(
+                                    logger,
+                                    "Updated max_block_count to {} in database.", max_block_count
+                                );
+                            }
+                            Err(e) => {
+                                panic!(
+                                    "Attempt to set new max block to {} failed due to: {:?}",
+                                    max_block_count, e
+                                )
+                            }
+                        }
                     }
-                    self.received_payments_subs_opt
-                        .as_ref()
-                        .expect("Accountant is unbound")
+                    format!("Error while retrieving transactions: {:?}", e)
+                })
+                .and_then(move |retrieved_blockchain_transactions| {
+                    received_payments_subs
                         .try_send(ReceivedPayments {
                             timestamp: SystemTime::now(),
-                            payments: transactions.transactions,
-                            new_start_block: new_start_block_number.as_u64(),
+                            new_start_block: retrieved_blockchain_transactions.new_start_block,
                             response_skeleton_opt: msg.response_skeleton_opt,
+                            transactions: retrieved_blockchain_transactions.transactions,
                         })
                         .expect("Accountant is dead.");
-                }
-                Ok(())
-            }
-            Err(e) => {
-                if let Some(max_block_count) = self.extract_max_block_count(e.clone()) {
-                    debug!(self.logger, "Writing max_block_count({})", &max_block_count);
-                    self.persistent_config
-                        .set_max_block_count(Some(max_block_count))
-                        .map_or_else(
-                            |_| {
-                                warning!(self.logger, "{} update max_block_count to {}. Scheduling next scan with that limit.", e, &max_block_count);
-                                Err(format!("{} updated max_block_count to {}. Scheduling next scan with that limit.", e, &max_block_count))
-                            },
-                            |e| {
-                                warning!(self.logger, "Writing max_block_count failed: {:?}", e);
-                                Err(format!("Writing max_block_count failed: {:?}", e))
-                            },
-                        )
-                } else {
-                    warning!(
-                        self.logger,
-                        "Attempted to retrieve received payments but failed: {:?}",
-                        e
-                    );
-                    Err(format!(
-                        "Attempted to retrieve received payments but failed: {:?}",
-                        e
-                    ))
-                }
-            }
-        }
+                    Ok(())
+                }),
+        )
+    }
+
+    fn log_status_of_tx_receipts(
+        logger: &Logger,
+        transaction_receipts_results: &[TransactionReceiptResult],
+    ) {
+        logger.debug(|| {
+            let (successful_count, failed_count, pending_count) =
+                transaction_receipts_results.iter().fold(
+                    (0, 0, 0),
+                    |(success, fail, pending), transaction_receipt| match transaction_receipt {
+                        TransactionReceiptResult::RpcResponse(tx_receipt) => {
+                            match tx_receipt.status {
+                                TxStatus::Failed => (success, fail + 1, pending),
+                                TxStatus::Pending => (success, fail, pending + 1),
+                                TxStatus::Succeeded(_) => (success + 1, fail, pending),
+                            }
+                        }
+                        TransactionReceiptResult::LocalError(_) => (success, fail, pending + 1),
+                    },
+                );
+            format!(
+                "Scan results: Successful: {}, Pending: {}, Failed: {}",
+                successful_count, pending_count, failed_count
+            )
+        });
     }
 
     fn handle_request_transaction_receipts(
         &mut self,
         msg: RequestTransactionReceipts,
-    ) -> Result<(), String> {
-        let init: (
-            Vec<Option<TransactionReceipt>>,
-            Option<(BlockchainError, H256)>,
-        ) = (vec![], None);
-        let (vector_of_results, error_opt) = msg.pending_payable.iter().fold(
-            init,
-            |(mut ok_receipts, err_opt), current_fingerprint| match err_opt {
-                None => match self
-                    .blockchain_interface
-                    .get_transaction_receipt(current_fingerprint.hash)
-                {
-                    Ok(receipt_opt) => {
-                        ok_receipts.push(receipt_opt);
-                        (ok_receipts, None)
-                    }
-                    Err(e) => (ok_receipts, Some((e, current_fingerprint.hash))),
-                },
-                _ => (ok_receipts, err_opt),
-            },
-        );
-        let pairs = vector_of_results
-            .into_iter()
-            .zip(msg.pending_payable.into_iter())
-            .collect_vec();
-        self.pending_payable_confirmation
+    ) -> Box<dyn Future<Item = (), Error = String>> {
+        let logger = self.logger.clone();
+        let accountant_recipient = self
+            .pending_payable_confirmation
             .report_transaction_receipts_sub_opt
-            .as_ref()
-            .expect("Accountant is unbound")
-            .try_send(ReportTransactionReceipts {
-                fingerprints_with_receipts: pairs,
-                response_skeleton_opt: msg.response_skeleton_opt,
-            })
-            .expect("Accountant is dead");
-        if let Some((e, hash)) = error_opt {
-            return Err (format! (
-                "Aborting scanning; request of a transaction receipt for '{:?}' failed due to '{:?}'",
-                hash,
-                e
-            ));
-        }
-        Ok(())
+            .clone()
+            .expect("Accountant is unbound");
+
+        let transaction_hashes = msg
+            .pending_payable
+            .iter()
+            .map(|finger_print| finger_print.hash)
+            .collect::<Vec<Hash>>();
+
+        trace!(
+            &logger,
+            "Transaction Receipts Hashes: {:?}",
+            transaction_hashes
+        );
+
+        Box::new(
+            self.blockchain_interface
+                .process_transaction_receipts(transaction_hashes)
+                .map_err(move |e| e.to_string())
+                .and_then(move |transaction_receipts_results| {
+                    trace!(
+                        &logger,
+                        "Transaction Receipts Results: {:?}",
+                        transaction_receipts_results
+                    );
+                    Self::log_status_of_tx_receipts(&logger, &transaction_receipts_results);
+
+                    let pairs = transaction_receipts_results
+                        .into_iter()
+                        .zip(msg.pending_payable.into_iter())
+                        .collect_vec();
+
+                    accountant_recipient
+                        .try_send(ReportTransactionReceipts {
+                            fingerprints_with_receipts: pairs,
+                            response_skeleton_opt: msg.response_skeleton_opt,
+                        })
+                        .expect("Accountant is dead");
+
+                    Ok(())
+                }),
+        )
     }
 
-    fn handle_scan<M, F>(&mut self, handler: F, scan_type: ScanType, msg: M)
+    fn handle_scan_future<M, F>(&mut self, handler: F, scan_type: ScanType, msg: M)
     where
-        F: FnOnce(&mut BlockchainBridge, M) -> Result<(), String>,
+        F: FnOnce(&mut BlockchainBridge, M) -> Box<dyn Future<Item = (), Error = String>>,
         M: SkeletonOptHolder,
     {
         let skeleton_opt = msg.skeleton_opt();
-        match handler(self, msg) {
-            Ok(_r) => (),
-            Err(e) => {
-                warning!(self.logger, "{}", e);
-                self.scan_error_subs_opt
-                    .as_ref()
-                    .expect("Accountant not bound")
-                    .try_send(ScanError {
-                        scan_type,
-                        response_skeleton_opt: skeleton_opt,
-                        msg: e,
-                    })
-                    .expect("Accountant is dead");
-            }
-        }
+        let logger = self.logger.clone();
+        let scan_error_subs_opt = self.scan_error_subs_opt.clone();
+        let future = handler(self, msg).map_err(move |e| {
+            warning!(logger, "{}", e);
+            scan_error_subs_opt
+                .as_ref()
+                .expect("Accountant not bound")
+                .try_send(ScanError {
+                    scan_type,
+                    response_skeleton_opt: skeleton_opt,
+                    msg: e,
+                })
+                .expect("Accountant is dead");
+        });
+
+        actix::spawn(future);
     }
 
     fn process_payments(
         &self,
         agent: Box<dyn BlockchainAgent>,
         affordable_accounts: Vec<PayableAccount>,
-    ) -> Result<Vec<ProcessedPayableFallible>, PayableTransactionError> {
+    ) -> Box<dyn Future<Item = Vec<ProcessedPayableFallible>, Error = PayableTransactionError>>
+    {
         let new_fingerprints_recipient = self.new_fingerprints_recipient();
-
-        self.blockchain_interface.send_batch_of_payables(
+        let logger = self.logger.clone();
+        self.blockchain_interface.submit_payables_in_batch(
+            logger,
             agent,
             new_fingerprints_recipient,
-            &affordable_accounts,
+            affordable_accounts,
         )
     }
 
-    fn new_fingerprints_recipient(&self) -> &Recipient<PendingPayableFingerprintSeeds> {
+    fn new_fingerprints_recipient(&self) -> Recipient<PendingPayableFingerprintSeeds> {
         self.pending_payable_confirmation
             .new_pp_fingerprints_sub_opt
-            .as_ref()
+            .clone()
             .expect("Accountant unbound")
     }
 
-    pub fn extract_max_block_count(&self, error: BlockchainError) -> Option<u64> {
+    pub fn extract_max_block_count(error: BlockchainError) -> Option<u64> {
         let regex_result =
             Regex::new(r".* (max: |allowed for your plan: |is limited to |block range limit \(|exceeds max block range )(?P<max_block_count>\d+).*")
                 .expect("Invalid regex");
@@ -514,44 +561,56 @@ mod tests {
     use crate::accountant::db_access_objects::payable_dao::PayableAccount;
     use crate::accountant::db_access_objects::pending_payable_dao::PendingPayable;
     use crate::accountant::db_access_objects::utils::from_time_t;
+    use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::agent_web3::WEB3_MAXIMAL_GAS_LIMIT_MARGIN;
     use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::test_utils::BlockchainAgentMock;
     use crate::accountant::scanners::test_utils::protect_payables_in_test;
-    use crate::accountant::test_utils::make_pending_payable_fingerprint;
-    use crate::blockchain::blockchain_interface::blockchain_interface_null::BlockchainInterfaceNull;
+    use crate::accountant::test_utils::{make_payable_account, make_pending_payable_fingerprint};
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::BlockchainInterfaceWeb3;
+    use crate::blockchain::blockchain_interface::data_structures::errors::PayableTransactionError::TransactionID;
     use crate::blockchain::blockchain_interface::data_structures::errors::{
         BlockchainAgentBuildError, PayableTransactionError,
     };
+    use crate::blockchain::blockchain_interface::data_structures::ProcessedPayableFallible::Correct;
     use crate::blockchain::blockchain_interface::data_structures::{
         BlockchainTransaction, RetrievedBlockchainTransactions,
     };
-    use crate::blockchain::blockchain_interface::lower_level_interface::LatestBlockNumber;
-    use crate::blockchain::blockchain_interface::test_utils::LowBlockchainIntMock;
-    use crate::blockchain::test_utils::{make_tx_hash, BlockchainInterfaceMock};
+    use crate::blockchain::test_utils::{
+        make_blockchain_interface_web3, make_tx_hash, ReceiptResponseBuilder,
+    };
     use crate::db_config::persistent_configuration::PersistentConfigError;
     use crate::match_every_type_id;
     use crate::node_test_utils::check_timestamp;
+    use crate::sub_lib::blockchain_bridge::ConsumingWalletBalances;
     use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock;
-    use crate::test_utils::recorder::{make_recorder, peer_actors_builder};
+    use crate::test_utils::recorder::{
+        make_accountant_subs_from_recorder, make_recorder, peer_actors_builder,
+    };
     use crate::test_utils::recorder_stop_conditions::StopCondition;
     use crate::test_utils::recorder_stop_conditions::StopConditions;
     use crate::test_utils::unshared_test_utils::arbitrary_id_stamp::ArbitraryIdStamp;
     use crate::test_utils::unshared_test_utils::{
-        assert_on_initialization_with_panic_on_migration,
-        prove_that_crash_request_handler_is_hooked_up, AssertionsMessage,
+        assert_on_initialization_with_panic_on_migration, configure_default_persistent_config,
+        prove_that_crash_request_handler_is_hooked_up, AssertionsMessage, ZERO,
     };
     use crate::test_utils::{make_paying_wallet, make_wallet};
     use actix::System;
     use ethereum_types::U64;
-    use ethsign_crypto::Keccak256;
     use masq_lib::messages::ScanType;
     use masq_lib::test_utils::logging::init_test_logging;
     use masq_lib::test_utils::logging::TestLogHandler;
-    use masq_lib::test_utils::utils::{ensure_node_home_directory_exists, TEST_DEFAULT_CHAIN};
+    use masq_lib::test_utils::mock_blockchain_client_server::MBCSBuilder;
+    use masq_lib::test_utils::utils::{
+        ensure_node_home_directory_exists, LogObject, TEST_DEFAULT_CHAIN,
+    };
+    use masq_lib::utils::find_free_port;
     use std::any::TypeId;
     use std::path::Path;
+    use std::str::FromStr;
     use std::sync::{Arc, Mutex};
     use std::time::{Duration, SystemTime};
-    use web3::types::{TransactionReceipt, H160, H256};
+    use web3::types::{TransactionReceipt, H160};
+    use masq_lib::constants::DEFAULT_MAX_BLOCK_COUNT;
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{TransactionBlock, TxReceipt};
 
     impl Handler<AssertionsMessage<Self>> for BlockchainBridge {
         type Result = ();
@@ -568,16 +627,67 @@ mod tests {
     #[test]
     fn constants_have_correct_values() {
         assert_eq!(CRASH_KEY, "BLOCKCHAINBRIDGE");
+        assert_eq!(DEFAULT_BLOCKCHAIN_SERVICE_URL, "https://0.0.0.0");
+    }
+
+    fn stub_bi() -> Box<dyn BlockchainInterface> {
+        Box::new(make_blockchain_interface_web3(find_free_port()))
     }
 
     #[test]
-    fn blockchain_interface_null_as_result_of_missing_blockchain_service_url() {
-        let result = BlockchainBridge::initialize_blockchain_interface(None, TEST_DEFAULT_CHAIN);
+    fn blockchain_bridge_receives_bind_message() {
+        init_test_logging();
+        let subject = BlockchainBridge::new(
+            stub_bi(),
+            Arc::new(Mutex::new(configure_default_persistent_config(ZERO))),
+            false,
+        );
+        let system = System::new("blockchain_bridge_receives_bind_message");
+        let addr = subject.start();
 
-        result
-            .as_any()
-            .downcast_ref::<BlockchainInterfaceNull>()
-            .unwrap();
+        addr.try_send(BindMessage {
+            peer_actors: peer_actors_builder().build(),
+        })
+        .unwrap();
+
+        System::current().stop();
+        system.run();
+        TestLogHandler::new()
+            .exists_log_containing("DEBUG: BlockchainBridge: Received BindMessage");
+    }
+
+    #[test]
+    fn blockchain_interface_is_constructed_with_missing_blockchain_service_url() {
+        init_test_logging();
+        let subject = BlockchainBridge::initialize_blockchain_interface(
+            None,
+            TEST_DEFAULT_CHAIN,
+            Logger::new("test"),
+        );
+
+        let chain = subject.get_chain();
+
+        assert_eq!(chain, TEST_DEFAULT_CHAIN);
+        TestLogHandler::new().exists_log_containing("INFO: test: The Blockchain service url is not set yet. its been defaulted to a wild card IP");
+    }
+
+    #[test]
+    fn blockchain_interface_is_constructed_with_a_blockchain_service_url() {
+        init_test_logging();
+        let blockchain_service_url = "https://example.com";
+        let subject = BlockchainBridge::initialize_blockchain_interface(
+            Some(blockchain_service_url.to_string()),
+            TEST_DEFAULT_CHAIN,
+            Logger::new("test"),
+        );
+
+        let chain = subject.get_chain();
+
+        assert_eq!(chain, TEST_DEFAULT_CHAIN);
+        TestLogHandler::new().exists_log_containing(&format!(
+            "INFO: test: Blockchain service url has been set to {}",
+            blockchain_service_url
+        ));
     }
 
     #[test]
@@ -586,17 +696,20 @@ mod tests {
         let system = System::new(
             "qualified_payables_msg_is_handled_and_new_msg_with_an_added_blockchain_agent_returns_to_accountant",
         );
-        let build_blockchain_agent_params_arc = Arc::new(Mutex::new(vec![]));
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x230000000".to_string(), 1) // 9395240960
+            .ok_response("0x23".to_string(), 1)
+            .ok_response(
+                "0x000000000000000000000000000000000000000000000000000000000000FFFF".to_string(),
+                0,
+            )
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
-        let agent_id_stamp = ArbitraryIdStamp::new();
-        let agent = BlockchainAgentMock::default().set_arbitrary_id_stamp(agent_id_stamp);
-        let blockchain_interface = BlockchainInterfaceMock::default()
-            .build_blockchain_agent_params(&build_blockchain_agent_params_arc)
-            .build_blockchain_agent_result(Ok(Box::new(agent)));
+        let accountant_recipient = accountant.start().recipient();
+        let blockchain_interface = make_blockchain_interface_web3(port);
         let consuming_wallet = make_paying_wallet(b"somewallet");
-        let persistent_config_id_stamp = ArbitraryIdStamp::new();
-        let persistent_configuration = PersistentConfigurationMock::default()
-            .set_arbitrary_id_stamp(persistent_config_id_stamp);
+        let persistent_configuration = PersistentConfigurationMock::default();
         let wallet_1 = make_wallet("booga");
         let wallet_2 = make_wallet("gulp");
         let qualified_payables = vec![
@@ -617,14 +730,12 @@ mod tests {
                 pending_payable_opt: None,
             },
         ];
-        let subject = BlockchainBridge::new(
+        let mut subject = BlockchainBridge::new(
             Box::new(blockchain_interface),
-            Box::new(persistent_configuration),
+            Arc::new(Mutex::new(persistent_configuration)),
             false,
         );
-        let addr = subject.start();
-        let subject_subs = BlockchainBridge::make_subs_from(&addr);
-        let peer_actors = peer_actors_builder().accountant(accountant).build();
+        subject.payable_payments_setup_subs_opt = Some(accountant_recipient);
         let qualified_payables = protect_payables_in_test(qualified_payables.clone());
         let qualified_payables_msg = QualifiedPayablesMessage {
             protected_qualified_payables: qualified_payables.clone(),
@@ -634,18 +745,15 @@ mod tests {
                 context_id: 444,
             }),
         };
-        send_bind_message!(subject_subs, peer_actors);
 
-        addr.try_send(qualified_payables_msg).unwrap();
+        subject
+            .handle_qualified_payable_msg(qualified_payables_msg)
+            .wait()
+            .unwrap();
 
         System::current().stop();
         system.run();
 
-        let build_blockchain_agent_params = build_blockchain_agent_params_arc.lock().unwrap();
-        assert_eq!(
-            *build_blockchain_agent_params,
-            vec![(consuming_wallet.clone(), persistent_config_id_stamp)]
-        );
         let accountant_received_payment = accountant_recording_arc.lock().unwrap();
         let blockchain_agent_with_context_msg_actual: &BlockchainAgentWithContextMessage =
             accountant_received_payment.get_record(0);
@@ -656,125 +764,140 @@ mod tests {
         assert_eq!(
             blockchain_agent_with_context_msg_actual
                 .agent
-                .arbitrary_id_stamp(),
-            agent_id_stamp
+                .consuming_wallet(),
+            &consuming_wallet
+        );
+        assert_eq!(
+            blockchain_agent_with_context_msg_actual
+                .agent
+                .agreed_fee_per_computation_unit(),
+            0x230000000
+        );
+        assert_eq!(
+            blockchain_agent_with_context_msg_actual
+                .agent
+                .consuming_wallet_balances(),
+            ConsumingWalletBalances::new(
+                35.into(),
+                0x000000000000000000000000000000000000000000000000000000000000FFFF.into()
+            )
+        );
+        let gas_limit_const_part =
+            BlockchainInterfaceWeb3::web3_gas_limit_const_part(Chain::PolyMainnet);
+        assert_eq!(
+            blockchain_agent_with_context_msg_actual
+                .agent
+                .estimated_transaction_fee_total(1),
+            (1 * 0x230000000 * (gas_limit_const_part + WEB3_MAXIMAL_GAS_LIMIT_MARGIN))
+        );
+        assert_eq!(
+            blockchain_agent_with_context_msg_actual.response_skeleton_opt,
+            Some(ResponseSkeleton {
+                client_id: 11122,
+                context_id: 444
+            })
         );
         assert_eq!(accountant_received_payment.len(), 1);
     }
 
     #[test]
-    fn build_of_blockchain_agent_throws_err_out_and_ends_handling_qualified_payables_message() {
-        init_test_logging();
-        let test_name =
-            "build_of_blockchain_agent_throws_err_out_and_ends_handling_qualified_payables_message";
+    fn qualified_payables_msg_is_handled_but_fails_on_build_blockchain_agent() {
+        let system =
+            System::new("qualified_payables_msg_is_handled_but_fails_on_build_blockchain_agent");
+        let port = find_free_port();
+        // build blockchain agent fails by not providing the third response.
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x23".to_string(), 1)
+            .ok_response("0x23".to_string(), 1)
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
-        let scan_error_recipient: Recipient<ScanError> = accountant
-            .system_stop_conditions(match_every_type_id!(ScanError))
-            .start()
-            .recipient();
-        let persistent_configuration = PersistentConfigurationMock::default();
-        let consuming_wallet = make_wallet(test_name);
-        let blockchain_interface = BlockchainInterfaceMock::default()
-            .build_blockchain_agent_result(Err(BlockchainAgentBuildError::GasPrice(
-                PersistentConfigError::NotPresent,
-            )));
+        let accountant_recipient = accountant.start().recipient();
+        let blockchain_interface = make_blockchain_interface_web3(port);
+        let consuming_wallet = make_paying_wallet(b"somewallet");
         let mut subject = BlockchainBridge::new(
             Box::new(blockchain_interface),
-            Box::new(persistent_configuration),
+            Arc::new(Mutex::new(PersistentConfigurationMock::default())),
             false,
         );
-        subject.logger = Logger::new(test_name);
-        subject.scan_error_subs_opt = Some(scan_error_recipient);
-        let request = QualifiedPayablesMessage {
-            protected_qualified_payables: protect_payables_in_test(vec![PayableAccount {
-                wallet: make_wallet("blah"),
-                balance_wei: 42,
-                last_paid_timestamp: SystemTime::now(),
-                pending_payable_opt: None,
-            }]),
-            consuming_wallet,
+        subject.payable_payments_setup_subs_opt = Some(accountant_recipient);
+        let qualified_payables = protect_payables_in_test(vec![]);
+        let qualified_payables_msg = QualifiedPayablesMessage {
+            protected_qualified_payables: qualified_payables,
+            consuming_wallet: consuming_wallet.clone(),
             response_skeleton_opt: Some(ResponseSkeleton {
-                client_id: 11,
-                context_id: 2323,
+                client_id: 11122,
+                context_id: 444,
             }),
         };
-        let subject_addr = subject.start();
-        let system = System::new(test_name);
 
-        // Don't eliminate or bypass this message as an important check that
-        // the Handler employs scan_handle()
-        subject_addr.try_send(request).unwrap();
+        let error_msg = subject
+            .handle_qualified_payable_msg(qualified_payables_msg)
+            .wait()
+            .unwrap_err();
 
+        System::current().stop();
         system.run();
-        let recording = accountant_recording_arc.lock().unwrap();
-        let message = recording.get_record::<ScanError>(0);
-        assert_eq!(recording.len(), 1);
-        let expected_error_msg = "Blockchain agent construction failed at fetching gas \
-        price from the database: NotPresent";
-        assert_eq!(
-            message,
-            &ScanError {
-                scan_type: ScanType::Payables,
-                response_skeleton_opt: Some(ResponseSkeleton {
-                    client_id: 11,
-                    context_id: 2323
-                }),
-                msg: expected_error_msg.to_string()
-            }
+
+        let accountant_recording = accountant_recording_arc.lock().unwrap();
+        assert_eq!(accountant_recording.len(), 0);
+        let service_fee_balance_error = BlockchainAgentBuildError::ServiceFeeBalance(
+            consuming_wallet.address(),
+            BlockchainError::QueryFailed(
+                "Api error: Transport error: Error(IncompleteMessage)".to_string(),
+            ),
         );
-        TestLogHandler::new()
-            .exists_log_containing(&format!("WARN: {test_name}: {expected_error_msg}"));
+        assert_eq!(
+            error_msg,
+            format!(
+                "Blockchain agent build error: {:?}",
+                service_fee_balance_error
+            )
+        )
     }
 
     #[test]
     fn handle_outbound_payments_instructions_sees_payments_happen_and_sends_payment_results_back_to_accountant(
     ) {
-        let system =
-            System::new("handle_outbound_payments_instructions_sees_payments_happen_and_sends_payment_results_back_to_accountant");
-        let send_batch_of_payables_params_arc = Arc::new(Mutex::new(vec![]));
+        let system = System::new(
+            "handle_outbound_payments_instructions_sees_payments_happen_and_sends_payment_results_back_to_accountant",
+        );
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x20".to_string(), 1)
+            .begin_batch()
+            .ok_response("rpc result".to_string(), 1)
+            .end_batch()
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
-        let accountant =
-            accountant.system_stop_conditions(match_every_type_id!(PendingPayableFingerprintSeeds));
-        let wallet_account_1 = make_wallet("blah");
-        let wallet_account_2 = make_wallet("foo");
-        let blockchain_interface_id_stamp = ArbitraryIdStamp::new();
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .set_arbitrary_id_stamp(blockchain_interface_id_stamp)
-            .send_batch_of_payables_params(&send_batch_of_payables_params_arc)
-            .send_batch_of_payables_result(Ok(vec![
-                Ok(PendingPayable {
-                    recipient_wallet: wallet_account_1.clone(),
-                    hash: H256::from("sometransactionhash".keccak256()),
-                }),
-                Ok(PendingPayable {
-                    recipient_wallet: wallet_account_2.clone(),
-                    hash: H256::from("someothertransactionhash".keccak256()),
-                }),
-            ]));
+        let accountant_addr = accountant
+            .system_stop_conditions(match_every_type_id!(SentPayables))
+            .start();
+        let wallet_account = make_wallet("blah");
+        let consuming_wallet = make_paying_wallet(b"consuming_wallet");
+        let blockchain_interface = make_blockchain_interface_web3(port);
+        let persistent_configuration_mock = PersistentConfigurationMock::default();
         let subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(PersistentConfigurationMock::default()),
+            Box::new(blockchain_interface),
+            Arc::new(Mutex::new(persistent_configuration_mock)),
             false,
         );
         let addr = subject.start();
         let subject_subs = BlockchainBridge::make_subs_from(&addr);
-        let peer_actors = peer_actors_builder().accountant(accountant).build();
-        let accounts = vec![
-            PayableAccount {
-                wallet: wallet_account_1.clone(),
-                balance_wei: 420,
-                last_paid_timestamp: from_time_t(150_000_000),
-                pending_payable_opt: None,
-            },
-            PayableAccount {
-                wallet: wallet_account_2.clone(),
-                balance_wei: 210,
-                last_paid_timestamp: from_time_t(160_000_000),
-                pending_payable_opt: None,
-            },
-        ];
+        let mut peer_actors = peer_actors_builder().build();
+        peer_actors.accountant = make_accountant_subs_from_recorder(&accountant_addr);
+        let accounts = vec![PayableAccount {
+            wallet: wallet_account,
+            balance_wei: 111_420_204,
+            last_paid_timestamp: from_time_t(150_000_000),
+            pending_payable_opt: None,
+        }];
         let agent_id_stamp = ArbitraryIdStamp::new();
-        let agent = BlockchainAgentMock::default().set_arbitrary_id_stamp(agent_id_stamp);
+        let agent = BlockchainAgentMock::default()
+            .set_arbitrary_id_stamp(agent_id_stamp)
+            .agreed_fee_per_computation_unit_result(123)
+            .consuming_wallet_result(consuming_wallet)
+            .get_chain_result(Chain::PolyMainnet);
+
         send_bind_message!(subject_subs, peer_actors);
 
         let _ = addr
@@ -788,76 +911,86 @@ mod tests {
             })
             .unwrap();
 
-        System::current().stop();
+        let time_before = SystemTime::now();
         system.run();
-        let mut send_batch_of_payables_params = send_batch_of_payables_params_arc.lock().unwrap();
-        //cannot assert on the captured recipient as its actor is gone after the System stops spinning
-        let (actual_agent_id_stamp, _recipient_actual, accounts_actual) =
-            send_batch_of_payables_params.remove(0);
-        assert!(send_batch_of_payables_params.is_empty());
-        assert_eq!(actual_agent_id_stamp, agent_id_stamp);
-        assert_eq!(accounts_actual, accounts);
+        let time_after = SystemTime::now();
         let accountant_recording = accountant_recording_arc.lock().unwrap();
-        let sent_payments_msg = accountant_recording.get_record::<SentPayables>(0);
+        let pending_payable_fingerprint_seeds_msg =
+            accountant_recording.get_record::<PendingPayableFingerprintSeeds>(0);
+        let sent_payables_msg = accountant_recording.get_record::<SentPayables>(1);
         assert_eq!(
-            *sent_payments_msg,
-            SentPayables {
-                payment_procedure_result: Ok(vec![
-                    Ok(PendingPayable {
-                        recipient_wallet: wallet_account_1,
-                        hash: H256::from("sometransactionhash".keccak256())
-                    }),
-                    Ok(PendingPayable {
-                        recipient_wallet: wallet_account_2,
-                        hash: H256::from("someothertransactionhash".keccak256())
-                    })
-                ]),
+            sent_payables_msg,
+            &SentPayables {
+                payment_procedure_result: Ok(vec![Correct(PendingPayable {
+                    recipient_wallet: accounts[0].wallet.clone(),
+                    hash: H256::from_str(
+                        "36e9d7cdd657181317dd461192d537d9944c57a51ee950607de5a618b00e57a1"
+                    )
+                    .unwrap()
+                })]),
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
                     context_id: 4321
                 })
             }
         );
-        assert_eq!(accountant_recording.len(), 1);
+        assert!(pending_payable_fingerprint_seeds_msg.batch_wide_timestamp >= time_before);
+        assert!(pending_payable_fingerprint_seeds_msg.batch_wide_timestamp <= time_after);
+        assert_eq!(
+            pending_payable_fingerprint_seeds_msg.hashes_and_balances,
+            vec![HashAndAmount {
+                hash: H256::from_str(
+                    "36e9d7cdd657181317dd461192d537d9944c57a51ee950607de5a618b00e57a1"
+                )
+                .unwrap(),
+                amount: accounts[0].balance_wei
+            }]
+        );
+        assert_eq!(accountant_recording.len(), 2);
     }
 
     #[test]
-    fn handle_outbound_payments_instructions_sends_eleventh_hour_error_back_to_accountant() {
+    fn handle_outbound_payments_instructions_sends_error_when_failing_on_submit_batch() {
         let system = System::new(
-            "handle_outbound_payments_instructions_sends_eleventh_hour_error_back_to_accountant",
+            "handle_outbound_payments_instructions_sends_error_when_failing_on_submit_batch",
         );
+        let port = find_free_port();
+        // To make submit_batch failed we didn't provide any responses for batch calls
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x20".to_string(), 1)
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
-        let hash = make_tx_hash(0xde);
+        let accountant_addr = accountant
+            .system_stop_conditions(match_every_type_id!(SentPayables))
+            .start();
         let wallet_account = make_wallet("blah");
-        let expected_error_msg = "We were so close but we stumbled and smashed our face against \
-         the ground just a moment after the signing";
-        let expected_error = Err(PayableTransactionError::Sending {
-            msg: expected_error_msg.to_string(),
-            hashes: vec![hash],
-        });
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .send_batch_of_payables_result(expected_error.clone());
+        let blockchain_interface = make_blockchain_interface_web3(port);
         let persistent_configuration_mock = PersistentConfigurationMock::default();
         let subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(persistent_configuration_mock),
+            Box::new(blockchain_interface),
+            Arc::new(Mutex::new(persistent_configuration_mock)),
             false,
         );
         let addr = subject.start();
         let subject_subs = BlockchainBridge::make_subs_from(&addr);
-        let peer_actors = peer_actors_builder().accountant(accountant).build();
+        let mut peer_actors = peer_actors_builder().build();
+        peer_actors.accountant = make_accountant_subs_from_recorder(&accountant_addr);
         let accounts = vec![PayableAccount {
             wallet: wallet_account,
             balance_wei: 111_420_204,
             last_paid_timestamp: from_time_t(150_000_000),
             pending_payable_opt: None,
         }];
-        let agent = BlockchainAgentMock::default();
+        let consuming_wallet = make_paying_wallet(b"consuming_wallet");
+        let agent = BlockchainAgentMock::default()
+            .consuming_wallet_result(consuming_wallet)
+            .agreed_fee_per_computation_unit_result(123)
+            .get_chain_result(Chain::PolyMainnet);
         send_bind_message!(subject_subs, peer_actors);
 
         let _ = addr
             .try_send(OutboundPaymentsInstructions {
-                affordable_accounts: accounts,
+                affordable_accounts: accounts.clone(),
                 agent: Box::new(agent),
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
@@ -866,21 +999,29 @@ mod tests {
             })
             .unwrap();
 
-        System::current().stop();
         system.run();
         let accountant_recording = accountant_recording_arc.lock().unwrap();
-        let sent_payments_msg = accountant_recording.get_record::<SentPayables>(0);
+        let pending_payable_fingerprint_seeds_msg =
+            accountant_recording.get_record::<PendingPayableFingerprintSeeds>(0);
+        let sent_payables_msg = accountant_recording.get_record::<SentPayables>(1);
+        let scan_error_msg = accountant_recording.get_record::<ScanError>(2);
+        assert_sending_error(
+            sent_payables_msg
+                .payment_procedure_result
+                .as_ref()
+                .unwrap_err(),
+            "Transport error: Error(IncompleteMessage)",
+        );
         assert_eq!(
-            *sent_payments_msg,
-            SentPayables {
-                payment_procedure_result: expected_error,
-                response_skeleton_opt: Some(ResponseSkeleton {
-                    client_id: 1234,
-                    context_id: 4321
-                })
-            }
+            pending_payable_fingerprint_seeds_msg.hashes_and_balances,
+            vec![HashAndAmount {
+                hash: H256::from_str(
+                    "36e9d7cdd657181317dd461192d537d9944c57a51ee950607de5a618b00e57a1"
+                )
+                .unwrap(),
+                amount: accounts[0].balance_wei
+            }]
         );
-        let scan_error_msg = accountant_recording.get_record::<ScanError>(1);
         assert_eq!(
             *scan_error_msg,
             ScanError {
@@ -890,57 +1031,137 @@ mod tests {
                     context_id: 4321
                 }),
                 msg: format!(
-                    "ReportAccountsPayable: Sending phase: \"{}\". Signed and hashed transactions: \
-            0x00000000000000000000000000000000000000000000000000000000000000de",
-                    expected_error_msg
+                    "ReportAccountsPayable: Sending phase: \"Transport error: Error(IncompleteMessage)\". Signed and hashed transactions: 0x36e9d7cdd657181317dd461192d537d9944c57a51ee950607de5a618b00e57a1"
                 )
             }
         );
-        assert_eq!(accountant_recording.len(), 2)
+        assert_eq!(accountant_recording.len(), 3);
     }
 
     #[test]
-    fn process_payments_returns_error_from_sending_batch() {
-        let transaction_hash = make_tx_hash(789);
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .send_batch_of_payables_result(Err(PayableTransactionError::Sending {
-                msg: "failure from chronic exhaustion".to_string(),
-                hashes: vec![transaction_hash],
-            }));
-        let persistent_configuration_mock = PersistentConfigurationMock::new();
+    fn process_payments_works() {
+        let test_name = "process_payments_works";
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x01".to_string(), 1)
+            .begin_batch()
+            .ok_response("rpc_result".to_string(), 7)
+            .ok_response("rpc_result_2".to_string(), 7)
+            .end_batch()
+            .start();
+        let blockchain_interface_web3 = make_blockchain_interface_web3(port);
+        let consuming_wallet = make_paying_wallet(b"consuming_wallet");
+        let accounts_1 = make_payable_account(1);
+        let accounts_2 = make_payable_account(2);
+        let accounts = vec![accounts_1.clone(), accounts_2.clone()];
+        let system = System::new(test_name);
+        let agent = BlockchainAgentMock::default()
+            .consuming_wallet_result(consuming_wallet)
+            .agreed_fee_per_computation_unit_result(1)
+            .get_chain_result(Chain::PolyMainnet);
+        let msg = OutboundPaymentsInstructions::new(accounts, Box::new(agent), None);
+        let persistent_config = PersistentConfigurationMock::new();
         let mut subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(persistent_configuration_mock),
+            Box::new(blockchain_interface_web3),
+            Arc::new(Mutex::new(persistent_config)),
             false,
         );
-        let checked_accounts = vec![PayableAccount {
-            wallet: make_wallet("blah"),
-            balance_wei: 424_454,
-            last_paid_timestamp: SystemTime::now(),
-            pending_payable_opt: None,
-        }];
-        let agent = Box::new(BlockchainAgentMock::default());
-        let (accountant, _, _) = make_recorder();
-        let fingerprint_recipient = accountant.start().recipient();
+        let (accountant, _, accountant_recording) = make_recorder();
         subject
             .pending_payable_confirmation
-            .new_pp_fingerprints_sub_opt = Some(fingerprint_recipient);
+            .new_pp_fingerprints_sub_opt = Some(accountant.start().recipient());
 
-        let result = subject.process_payments(agent, checked_accounts);
+        let result = subject
+            .process_payments(msg.agent, msg.affordable_accounts)
+            .wait();
 
+        System::current().stop();
+        system.run();
+        let processed_payments = result.unwrap();
+        assert_eq!(
+            processed_payments[0],
+            Correct(PendingPayable {
+                recipient_wallet: accounts_1.wallet,
+                hash: H256::from_str(
+                    "cc73f3d5fe9fc3dac28b510ddeb157b0f8030b201e809014967396cdf365488a"
+                )
+                .unwrap()
+            })
+        );
         assert_eq!(
-            result,
-            Err(PayableTransactionError::Sending {
-                msg: "failure from chronic exhaustion".to_string(),
-                hashes: vec![transaction_hash]
+            processed_payments[1],
+            Correct(PendingPayable {
+                recipient_wallet: accounts_2.wallet,
+                hash: H256::from_str(
+                    "891d9ffa838aedc0bb2f6f7e9737128ce98bb33d07b4c8aa5645871e20d6cd13"
+                )
+                .unwrap()
             })
         );
+        let recording = accountant_recording.lock().unwrap();
+        assert_eq!(recording.len(), 1);
     }
 
     #[test]
-    fn blockchain_bridge_processes_requests_for_transaction_receipts_when_all_were_ok() {
-        let get_transaction_receipt_params_arc = Arc::new(Mutex::new(vec![]));
+    fn process_payments_fails_on_get_transaction_count() {
+        let test_name = "process_payments_fails_on_get_transaction_count";
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("trash transaction id".to_string(), 1)
+            .start();
+        let blockchain_interface_web3 = make_blockchain_interface_web3(port);
+        let consuming_wallet = make_paying_wallet(b"consuming_wallet");
+        let system = System::new(test_name);
+        let agent = BlockchainAgentMock::default()
+            .get_chain_result(TEST_DEFAULT_CHAIN)
+            .consuming_wallet_result(consuming_wallet)
+            .agreed_fee_per_computation_unit_result(123);
+        let msg = OutboundPaymentsInstructions::new(vec![], Box::new(agent), None);
+        let persistent_config = configure_default_persistent_config(ZERO);
+        let mut subject = BlockchainBridge::new(
+            Box::new(blockchain_interface_web3),
+            Arc::new(Mutex::new(persistent_config)),
+            false,
+        );
+        let (accountant, _, accountant_recording) = make_recorder();
+        subject
+            .pending_payable_confirmation
+            .new_pp_fingerprints_sub_opt = Some(accountant.start().recipient());
+
+        let result = subject
+            .process_payments(msg.agent, msg.affordable_accounts)
+            .wait();
+
+        System::current().stop();
+        system.run();
+        let error_result = result.unwrap_err();
+        assert_eq!(
+            error_result,
+            TransactionID(BlockchainError::QueryFailed(
+                "Decoder error: Error(\"0x prefix is missing\", line: 0, column: 0) for wallet 0x2581…7849".to_string()
+            ))
+        );
+        let recording = accountant_recording.lock().unwrap();
+        assert_eq!(recording.len(), 0);
+    }
+
+    fn assert_sending_error(error: &PayableTransactionError, error_msg: &str) {
+        if let PayableTransactionError::Sending { msg, .. } = error {
+            assert!(
+                msg.contains(error_msg),
+                "Actual Error message: {} does not contain this fragment {}",
+                msg,
+                error_msg
+            );
+        } else {
+            panic!("Received wrong error: {:?}", error);
+        }
+    }
+
+    #[test]
+    fn blockchain_bridge_processes_requests_for_a_complete_and_null_transaction_receipt() {
         let (accountant, _, accountant_recording_arc) = make_recorder();
+        let accountant = accountant.system_stop_conditions(match_every_type_id!(ScanError));
         let pending_payable_fingerprint_1 = make_pending_payable_fingerprint();
         let hash_1 = pending_payable_fingerprint_1.hash;
         let hash_2 = make_tx_hash(78989);
@@ -952,13 +1173,22 @@ mod tests {
             amount: 4565,
             process_error: None,
         };
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .get_transaction_receipt_params(&get_transaction_receipt_params_arc)
-            .get_transaction_receipt_result(Ok(Some(TransactionReceipt::default())))
-            .get_transaction_receipt_result(Ok(None));
+        let first_response = ReceiptResponseBuilder::default()
+            .status(U64::from(1))
+            .transaction_hash(hash_1)
+            .build();
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .begin_batch()
+            .raw_response(first_response)
+            // A transaction receipt is null when the transaction is not available
+            .raw_response(r#"{ "jsonrpc": "2.0", "id": 1, "result": null }"#.to_string())
+            .end_batch()
+            .start();
+        let blockchain_interface = make_blockchain_interface_web3(port);
         let subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(PersistentConfigurationMock::default()),
+            Box::new(blockchain_interface),
+            Arc::new(Mutex::new(PersistentConfigurationMock::default())),
             false,
         );
         let addr = subject.start();
@@ -979,20 +1209,29 @@ mod tests {
         let _ = addr.try_send(msg).unwrap();
 
         let system = System::new("transaction receipts");
-        System::current().stop();
         system.run();
         let accountant_recording = accountant_recording_arc.lock().unwrap();
         assert_eq!(accountant_recording.len(), 1);
-        let received_message = accountant_recording.get_record::<ReportTransactionReceipts>(0);
+        let report_transaction_receipt_message =
+            accountant_recording.get_record::<ReportTransactionReceipts>(0);
+        let mut expected_receipt = TransactionReceipt::default();
+        expected_receipt.transaction_hash = hash_1;
+        expected_receipt.status = Some(U64::from(1));
         assert_eq!(
-            received_message,
+            report_transaction_receipt_message,
             &ReportTransactionReceipts {
                 fingerprints_with_receipts: vec![
                     (
-                        Some(TransactionReceipt::default()),
+                        TransactionReceiptResult::RpcResponse(expected_receipt.into()),
                         pending_payable_fingerprint_1
                     ),
-                    (None, pending_payable_fingerprint_2),
+                    (
+                        TransactionReceiptResult::RpcResponse(TxReceipt {
+                            transaction_hash: hash_2,
+                            status: TxStatus::Pending
+                        }),
+                        pending_payable_fingerprint_2
+                    ),
                 ],
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
@@ -1000,34 +1239,33 @@ mod tests {
                 }),
             }
         );
-        let get_transaction_receipt_params = get_transaction_receipt_params_arc.lock().unwrap();
-        assert_eq!(*get_transaction_receipt_params, vec![hash_1, hash_2])
     }
 
     #[test]
     fn blockchain_bridge_logs_error_from_retrieving_received_payments() {
         init_test_logging();
+        let port = find_free_port();
+        // We have intentionally left out responses to cause this error
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x3B9ACA00".to_string(), 0)
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
-        let scan_error_recipient: Recipient<ScanError> = accountant
+        let accountant_addr = accountant
             .system_stop_conditions(match_every_type_id!(ScanError))
-            .start()
-            .recipient();
-        let lower_interface = LowBlockchainIntMock::default()
-            .get_block_number_result(LatestBlockNumber::Ok(U64::from(1234u64)));
-        let blockchain_interface = BlockchainInterfaceMock::default()
-            .retrieve_transactions_result(Err(BlockchainError::QueryFailed(
-                "we have no luck".to_string(),
-            )))
-            .lower_interface_results(Box::new(lower_interface));
+            .start();
+        let scan_error_recipient: Recipient<ScanError> = accountant_addr.clone().recipient();
+        let received_payments_subs: Recipient<ReceivedPayments> = accountant_addr.recipient();
+        let blockchain_interface = make_blockchain_interface_web3(port);
         let persistent_config = PersistentConfigurationMock::new()
             .max_block_count_result(Ok(Some(DEFAULT_MAX_BLOCK_COUNT)))
             .start_block_result(Ok(Some(5))); // no set_start_block_result: set_start_block() must not be called
         let mut subject = BlockchainBridge::new(
             Box::new(blockchain_interface),
-            Box::new(persistent_config),
+            Arc::new(Mutex::new(persistent_config)),
             false,
         );
         subject.scan_error_subs_opt = Some(scan_error_recipient);
+        subject.received_payments_subs_opt = Some(received_payments_subs);
         let msg = RetrieveTransactions {
             recipient: make_wallet("blah"),
             response_skeleton_opt: None,
@@ -1039,19 +1277,18 @@ mod tests {
 
         system.run();
         let recording = accountant_recording_arc.lock().unwrap();
-        let message = recording.get_record::<ScanError>(0);
+        let scan_error = recording.get_record::<ScanError>(0);
         assert_eq!(
-            message,
+            scan_error,
             &ScanError {
                 scan_type: ScanType::Receivables,
                 response_skeleton_opt: None,
-                msg: "Attempted to retrieve received payments but failed: QueryFailed(\"we have no luck\")".to_string()
+                msg: "Error while retrieving transactions: QueryFailed(\"Transport error: Error(IncompleteMessage)\")".to_string()
             }
         );
         assert_eq!(recording.len(), 1);
         TestLogHandler::new().exists_log_containing(
-            "WARN: BlockchainBridge: Attempted to retrieve \
-         received payments but failed: QueryFailed(\"we have no luck\")",
+            "WARN: BlockchainBridge: Error while retrieving transactions: QueryFailed(\"Transport error: Error(IncompleteMessage)\")",
         );
     }
 
@@ -1059,7 +1296,28 @@ mod tests {
     fn handle_request_transaction_receipts_short_circuits_on_failure_from_remote_process_sends_back_all_good_results_and_logs_abort(
     ) {
         init_test_logging();
-        let get_transaction_receipt_params_arc = Arc::new(Mutex::new(vec![]));
+        let port = find_free_port();
+        let block_number = U64::from(4545454);
+        let contract_address = H160::from_low_u64_be(887766);
+        let tx_receipt_response = ReceiptResponseBuilder::default()
+            .block_number(block_number)
+            .block_hash(Default::default())
+            .status(U64::from(1))
+            .contract_address(contract_address)
+            .build();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .begin_batch()
+            .raw_response(r#"{ "jsonrpc": "2.0", "id": 1, "result": null }"#.to_string())
+            .raw_response(tx_receipt_response)
+            .raw_response(r#"{ "jsonrpc": "2.0", "id": 1, "result": null }"#.to_string())
+            .err_response(
+                429,
+                "The requests per second (RPS) of your requests are higher than your plan allows."
+                    .to_string(),
+                7,
+            )
+            .end_batch()
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
         let accountant_addr = accountant
             .system_stop_conditions(match_every_type_id!(ReportTransactionReceipts, ScanError))
@@ -1097,20 +1355,18 @@ mod tests {
             amount: 7879,
             process_error: None,
         };
-        let mut transaction_receipt = TransactionReceipt::default();
-        transaction_receipt.block_number = Some(U64::from(4545454));
-        transaction_receipt.contract_address = Some(H160::from_low_u64_be(887766));
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .get_transaction_receipt_params(&get_transaction_receipt_params_arc)
-            .get_transaction_receipt_result(Ok(None))
-            .get_transaction_receipt_result(Ok(Some(transaction_receipt.clone())))
-            .get_transaction_receipt_result(Err(BlockchainError::QueryFailed(
-                "bad bad bad".to_string(),
-            )));
+        let transaction_receipt = TxReceipt {
+            transaction_hash: Default::default(),
+            status: TxStatus::Succeeded(TransactionBlock {
+                block_hash: Default::default(),
+                block_number,
+            }),
+        };
+        let blockchain_interface = make_blockchain_interface_web3(port);
         let system = System::new("test_transaction_receipts");
         let mut subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(PersistentConfigurationMock::default()),
+            Box::new(blockchain_interface),
+            Arc::new(Mutex::new(PersistentConfigurationMock::default())),
             false,
         );
         subject
@@ -1121,8 +1377,8 @@ mod tests {
             pending_payable: vec![
                 fingerprint_1.clone(),
                 fingerprint_2.clone(),
-                fingerprint_3,
-                fingerprint_4,
+                fingerprint_3.clone(),
+                fingerprint_4.clone(),
             ],
             response_skeleton_opt: Some(ResponseSkeleton {
                 client_id: 1234,
@@ -1134,20 +1390,17 @@ mod tests {
         subject_addr.try_send(msg).unwrap();
 
         assert_eq!(system.run(), 0);
-        let get_transaction_receipts_params = get_transaction_receipt_params_arc.lock().unwrap();
-        assert_eq!(
-            *get_transaction_receipts_params,
-            vec![hash_1, hash_2, hash_3]
-        );
         let accountant_recording = accountant_recording_arc.lock().unwrap();
-        assert_eq!(accountant_recording.len(), 2);
+        assert_eq!(accountant_recording.len(), 1);
         let report_receipts_msg = accountant_recording.get_record::<ReportTransactionReceipts>(0);
         assert_eq!(
             *report_receipts_msg,
             ReportTransactionReceipts {
                 fingerprints_with_receipts: vec![
-                    (None, fingerprint_1),
-                    (Some(transaction_receipt), fingerprint_2)
+                    (TransactionReceiptResult::RpcResponse(TxReceipt{ transaction_hash: hash_1, status: TxStatus::Pending }), fingerprint_1),
+                    (TransactionReceiptResult::RpcResponse(transaction_receipt), fingerprint_2),
+                    (TransactionReceiptResult::RpcResponse(TxReceipt{ transaction_hash: hash_3, status: TxStatus::Pending }), fingerprint_3),
+                    (TransactionReceiptResult::LocalError("RPC error: Error { code: ServerError(429), message: \"The requests per second (RPS) of your requests are higher than your plan allows.\", data: None }".to_string()), fingerprint_4)
                 ],
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
@@ -1155,61 +1408,21 @@ mod tests {
                 }),
             }
         );
-        let scan_error_msg = accountant_recording.get_record::<ScanError>(1);
-        assert_eq!(*scan_error_msg, ScanError {
-            scan_type: ScanType::PendingPayables,
-            response_skeleton_opt: Some(ResponseSkeleton { client_id: 1234, context_id: 4321 }),
-            msg: "Aborting scanning; request of a transaction receipt \
-         for '0x000000000000000000000000000000000000000000000000000000000001348d' failed due to 'QueryFailed(\"bad bad bad\")'".to_string()
-        });
-        TestLogHandler::new().exists_log_containing("WARN: BlockchainBridge: Aborting scanning; request of a transaction receipt \
-         for '0x000000000000000000000000000000000000000000000000000000000001348d' failed due to 'QueryFailed(\"bad bad bad\")'");
-    }
-
-    #[test]
-    fn blockchain_bridge_can_return_report_transaction_receipts_with_an_empty_vector() {
-        let (accountant, _, accountant_recording) = make_recorder();
-        let recipient = accountant.start().recipient();
-        let mut subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
-            false,
-        );
-        subject
-            .pending_payable_confirmation
-            .report_transaction_receipts_sub_opt = Some(recipient);
-        let msg = RequestTransactionReceipts {
-            pending_payable: vec![],
-            response_skeleton_opt: None,
-        };
-        let system = System::new(
-            "blockchain_bridge_can_return_report_transaction_receipts_with_an_empty_vector",
+        TestLogHandler::new().exists_log_containing(
+            "DEBUG: BlockchainBridge: Scan results: Successful: 1, Pending: 3, Failed: 0",
         );
-
-        let _ = subject.handle_request_transaction_receipts(msg);
-
-        System::current().stop();
-        system.run();
-        let recording = accountant_recording.lock().unwrap();
-        assert_eq!(
-            recording.get_record::<ReportTransactionReceipts>(0),
-            &ReportTransactionReceipts {
-                fingerprints_with_receipts: vec![],
-                response_skeleton_opt: None
-            }
-        )
     }
 
     #[test]
-    fn handle_request_transaction_receipts_short_circuits_on_failure_of_the_first_payment_and_it_sends_a_message_with_empty_vector_and_logs(
-    ) {
+    fn handle_request_transaction_receipts_short_circuits_if_submit_batch_fails() {
         init_test_logging();
         let (accountant, _, accountant_recording) = make_recorder();
-        let accountant_addr = accountant.start();
+        let accountant_addr = accountant
+            .system_stop_conditions(match_every_type_id!(ScanError))
+            .start();
         let scan_error_recipient: Recipient<ScanError> = accountant_addr.clone().recipient();
         let report_transaction_recipient: Recipient<ReportTransactionReceipts> =
             accountant_addr.recipient();
-        let get_transaction_receipt_params_arc = Arc::new(Mutex::new(vec![]));
         let hash_1 = make_tx_hash(0x1b2e6);
         let fingerprint_1 = PendingPayableFingerprint {
             rowid: 454,
@@ -1227,17 +1440,16 @@ mod tests {
             amount: 4565,
             process_error: None,
         };
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .get_transaction_receipt_params(&get_transaction_receipt_params_arc)
-            .get_transaction_receipt_result(Err(BlockchainError::QueryFailed("booga".to_string())));
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port).start();
+        let blockchain_interface = make_blockchain_interface_web3(port);
         let mut subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(PersistentConfigurationMock::default()),
+            Box::new(blockchain_interface),
+            Arc::new(Mutex::new(PersistentConfigurationMock::default())),
             false,
         );
         subject
             .pending_payable_confirmation
-            //due to this None we would've panicked if we tried to send a msg
             .report_transaction_receipts_sub_opt = Some(report_transaction_recipient);
         subject.scan_error_subs_opt = Some(scan_error_recipient);
         let msg = RequestTransactionReceipts {
@@ -1246,84 +1458,83 @@ mod tests {
         };
         let system = System::new("test");
 
-        let _ = subject.handle_scan(
+        let _ = subject.handle_scan_future(
             BlockchainBridge::handle_request_transaction_receipts,
             ScanType::PendingPayables,
             msg,
         );
 
-        System::current().stop();
         system.run();
-        let get_transaction_receipts_params = get_transaction_receipt_params_arc.lock().unwrap();
         let recording = accountant_recording.lock().unwrap();
-        assert_eq!(*get_transaction_receipts_params, vec![hash_1]);
         assert_eq!(
-            recording.get_record::<ReportTransactionReceipts>(0),
-            &ReportTransactionReceipts {
-                fingerprints_with_receipts: vec![],
-                response_skeleton_opt: None
-            }
-        );
-        assert_eq!(
-            recording.get_record::<ScanError>(1),
+            recording.get_record::<ScanError>(0),
             &ScanError {
                 scan_type: ScanType::PendingPayables,
                 response_skeleton_opt: None,
-                msg: "Aborting scanning; request of a transaction receipt for '0x000000000000000000000000000000000000000000000000000000000001b2e6' failed due to 'QueryFailed(\"booga\")'".to_string()
+                msg: "Blockchain error: Query failed: Transport error: Error(IncompleteMessage)"
+                    .to_string()
             }
         );
-        assert_eq!(recording.len(), 2);
-        TestLogHandler::new().exists_log_containing("WARN: BlockchainBridge: Aborting scanning; request of a transaction \
-         receipt for '0x000000000000000000000000000000000000000000000000000000000001b2e6' failed due to 'QueryFailed(\"booga\")'");
+        assert_eq!(recording.len(), 1);
+        TestLogHandler::new().exists_log_containing("WARN: BlockchainBridge: Blockchain error: Query failed: Transport error: Error(IncompleteMessage)");
     }
 
     #[test]
     fn handle_retrieve_transactions_uses_default_max_block_count_for_ending_block_number_upon_get_block_number_error(
     ) {
         init_test_logging();
-        let retrieve_transactions_params_arc = Arc::new(Mutex::new(vec![]));
         let system = System::new(
             "handle_retrieve_transactions_uses_default_max_block_count_for_ending_block_number_upon_get_block_number_error",
         );
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x3B9ACA00".to_string(), 0)// 1,000,000,000
+            .raw_response(r#"{
+              "jsonrpc": "2.0",
+              "id": 1,
+              "result": [
+                {
+                  "address": "0x06012c8cf97bead5deae237070f9587f8e7a266d",
+                  "blockHash": "0x7c5a35e9cb3e8ae0e221ab470abae9d446c3a5626ce6689fc777dcffcab52c70",
+                  "blockNumber": "0x5c29fb",
+                  "data": "0x0000000000000000000000000000002a",
+                  "logIndex": "0x1d",
+                  "removed": false,
+                  "topics": [
+                    "0x241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80",
+                    "0x000000000000000000000000000000000000000066697273745f77616c6c6574"
+                  ],
+                  "transactionHash": "0x3dc91b98249fa9f2c5c37486a2427a3a7825be240c1c84961dfb3063d9c04d50",
+                  "transactionIndex": "0x1d"
+                },
+                {
+                  "address": "0x06012c8cf97bead5deae237070f9587f8e7a266d",
+                  "blockHash": "0x7c5a35e9cb3e8ae0e221ab470abae9d446c3a5626ce6689fc777dcffcab52c70",
+                  "blockNumber": "0x5c29fc",
+                  "data": "0x00000000000000000000000000000037",
+                  "logIndex": "0x57",
+                  "removed": false,
+                  "topics": [
+                    "0x241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80",
+                    "0x000000000000000000000000000000000000007365636f6e645f77616c6c6574"
+                  ],
+                  "transactionHash": "0x788b1442414cb9c9a36dba2abe250763161a6f6395788a2e808f1b34e92beec1",
+                  "transactionIndex": "0x54"
+                }
+              ]
+            }"#.to_string())
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
         let earning_wallet = make_wallet("somewallet");
-        let amount = 42;
-        let amount2 = 55;
-        let expected_transactions = RetrievedBlockchainTransactions {
-            new_start_block: BlockNumber::Number(8675309u64.into()),
-            transactions: vec![
-                BlockchainTransaction {
-                    block_number: 7,
-                    from: earning_wallet.clone(),
-                    wei_amount: amount,
-                },
-                BlockchainTransaction {
-                    block_number: 9,
-                    from: earning_wallet.clone(),
-                    wei_amount: amount2,
-                },
-            ],
-        };
-        let lower_interface =
-            LowBlockchainIntMock::default().get_block_number_result(LatestBlockNumber::Err(
-                BlockchainError::QueryFailed("Failed to read the latest block number".to_string()),
-            ));
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .retrieve_transactions_params(&retrieve_transactions_params_arc)
-            .retrieve_transactions_result(Ok(expected_transactions.clone()))
-            .lower_interface_results(Box::new(lower_interface));
         let persistent_config = PersistentConfigurationMock::new()
-            .max_block_count_result(Ok(Some(DEFAULT_MAX_BLOCK_COUNT)))
-            .start_block_result(Ok(Some(6)));
-        let subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(persistent_config),
+            .max_block_count_result(Ok(Some(9_000_000u64)))
+            .start_block_result(Ok(Some(42)));
+        let mut subject = BlockchainBridge::new(
+            Box::new(make_blockchain_interface_web3(port)),
+            Arc::new(Mutex::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);
+        subject.received_payments_subs_opt = Some(accountant.start().recipient());
         let retrieve_transactions = RetrieveTransactions {
             recipient: earning_wallet.clone(),
             response_skeleton_opt: Some(ResponseSkeleton {
@@ -1333,20 +1544,33 @@ mod tests {
         };
         let before = SystemTime::now();
 
-        let _ = addr.try_send(retrieve_transactions).unwrap();
+        subject
+            .handle_retrieve_transactions(retrieve_transactions)
+            .wait()
+            .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(6u64.into()),
-                BlockNumber::Number((DEFAULT_MAX_BLOCK_COUNT + 6u64).into()),
-                earning_wallet
-            )]
-        );
+        let expected_transactions = RetrievedBlockchainTransactions {
+            new_start_block: 42 + 9_000_000 + 1,
+            transactions: vec![
+                BlockchainTransaction {
+                    block_number: 6040059,
+                    // Wallet represented in the RPC response by the first 'topic' as: 0x241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80
+                    from: make_wallet("first_wallet"),
+                    // Paid amount read out from the field 'data' in the RPC
+                    wei_amount: 42,
+                },
+                BlockchainTransaction {
+                    block_number: 6040060,
+                    // Wallet represented in the RPC response by the first 'topic' as: 0x241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80
+                    from: make_wallet("second_wallet"),
+                    // Paid amount read out from the field 'data' in the RPC
+                    wei_amount: 55,
+                },
+            ],
+        };
         let accountant_received_payment = accountant_recording_arc.lock().unwrap();
         assert_eq!(accountant_received_payment.len(), 1);
         let received_payments = accountant_received_payment.get_record::<ReceivedPayments>(0);
@@ -1355,66 +1579,81 @@ mod tests {
             received_payments,
             &ReceivedPayments {
                 timestamp: received_payments.timestamp,
-                payments: expected_transactions.transactions,
-                new_start_block: 8675309u64,
+                new_start_block: expected_transactions.new_start_block,
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
                     context_id: 4321
                 }),
+                transactions: expected_transactions.transactions,
             }
         );
-        TestLogHandler::new().exists_log_containing("DEBUG: BlockchainBridge: Using '100006' ending block number. QueryFailed(\"Failed to read the latest block number\")");
     }
 
     #[test]
     fn handle_retrieve_transactions_when_start_block_number_starts_undefined_in_a_brand_new_database(
     ) {
-        let retrieve_transactions_params_arc = Arc::new(Mutex::new(vec![]));
         let system = System::new(
             "handle_retrieve_transactions_when_start_block_number_starts_undefined_in_a_brand_new_database",
         );
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x845FED".to_string(), 0)
+            .ok_response(
+                vec![LogObject {
+                    removed: false,
+                    log_index: Some("0x20".to_string()),
+                    transaction_index: Some("0x30".to_string()),
+                    transaction_hash: Some(
+                        "0x2222222222222222222222222222222222222222222222222222222222222222"
+                            .to_string(),
+                    ),
+                    block_hash: Some(
+                        "0x1111111111111111111111111111111111111111111111111111111111111111"
+                            .to_string(),
+                    ),
+                    block_number: Some("0x845FEC".to_string()),
+                    address: "0x3333333333333333333333333333333333333334".to_string(),
+                    data: "0x000000000000000000000000000000000000000000000000000000003b5dc100"
+                        .to_string(),
+                    topics: vec![
+                        "0xddf252ad1be2c89b69c2b06800000000000000000000736f6d6577616c6c6574"
+                            .to_string(),
+                        "0xddf252ad1be2c89b69c2b06900000000000000000000736f6d6577616c6c6574"
+                            .to_string(),
+                    ],
+                }],
+                1,
+            )
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
-        let earning_wallet = make_wallet("somewallet");
-        let amount = 42;
-        let amount2 = 55;
+        let accountant_addr =
+            accountant.system_stop_conditions(match_every_type_id!(ReceivedPayments));
+        let some_wallet = make_wallet("somewallet");
+        let recipient_wallet = make_wallet("recipient_wallet");
+        let amount = 996000000;
         let expected_transactions = RetrievedBlockchainTransactions {
-            new_start_block: BlockNumber::Number(8675309u64.into()),
-            transactions: vec![
-                BlockchainTransaction {
-                    block_number: 8675308u64,
-                    from: earning_wallet.clone(),
-                    wei_amount: amount,
-                },
-                BlockchainTransaction {
-                    block_number: 8675309u64,
-                    from: earning_wallet.clone(),
-                    wei_amount: amount2,
-                },
-            ],
+            new_start_block: 8675309u64,
+            transactions: vec![BlockchainTransaction {
+                block_number: 8675308u64,
+                from: some_wallet.clone(),
+                wei_amount: amount,
+            }],
         };
-        let lower_interface = LowBlockchainIntMock::default().get_block_number_result(
-            LatestBlockNumber::Err(BlockchainError::QueryFailed(
-                "\"Failed to read the latest block number\"".to_string(),
-            )),
-        );
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .retrieve_transactions_params(&retrieve_transactions_params_arc)
-            .retrieve_transactions_result(Ok(expected_transactions.clone()))
-            .lower_interface_results(Box::new(lower_interface));
+        let blockchain_interface = make_blockchain_interface_web3(port);
         let persistent_config = PersistentConfigurationMock::new()
-            .max_block_count_result(Ok(Some(DEFAULT_MAX_BLOCK_COUNT)))
+            .max_block_count_result(Ok(None))
             .start_block_result(Ok(None));
         let subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(persistent_config),
+            Box::new(blockchain_interface),
+            Arc::new(Mutex::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();
+        let peer_actors = peer_actors_builder().accountant(accountant_addr).build();
         send_bind_message!(subject_subs, peer_actors);
         let retrieve_transactions = RetrieveTransactions {
-            recipient: earning_wallet.clone(),
+            recipient: recipient_wallet.clone(),
             response_skeleton_opt: Some(ResponseSkeleton {
                 client_id: 1234,
                 context_id: 4321,
@@ -1424,14 +1663,8 @@ mod tests {
 
         let _ = addr.try_send(retrieve_transactions).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::Latest, BlockNumber::Latest, earning_wallet)]
-        );
         let accountant_received_payment = accountant_recording_arc.lock().unwrap();
         assert_eq!(accountant_received_payment.len(), 1);
         let received_payments = accountant_received_payment.get_record::<ReceivedPayments>(0);
@@ -1440,8 +1673,8 @@ mod tests {
             received_payments,
             &ReceivedPayments {
                 timestamp: received_payments.timestamp,
-                payments: expected_transactions.transactions,
-                new_start_block: 8675309u64,
+                new_start_block: 8675309u64 + 1,
+                transactions: expected_transactions.transactions,
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
                     context_id: 4321
@@ -1451,52 +1684,57 @@ mod tests {
     }
 
     #[test]
-    fn handle_retrieve_transactions_when_get_block_number_fails_uses_latest_for_start_and_end_block(
-    ) {
-        let retrieve_transactions_params_arc = Arc::new(Mutex::new(vec![]));
-        let earning_wallet = make_wallet("somewallet");
-        let amount = 42;
-        let amount2 = 55;
-        let expected_transactions = RetrievedBlockchainTransactions {
-            new_start_block: BlockNumber::Number(98765u64.into()),
-            transactions: vec![
-                BlockchainTransaction {
-                    block_number: 77,
-                    from: earning_wallet.clone(),
-                    wei_amount: amount,
-                },
-                BlockchainTransaction {
-                    block_number: 99,
-                    from: earning_wallet.clone(),
-                    wei_amount: amount2,
-                },
-            ],
-        };
+    fn handle_retrieve_transactions_sends_received_payments_back_to_accountant() {
+        let system =
+            System::new("handle_retrieve_transactions_sends_received_payments_back_to_accountant");
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x3B9ACA00".to_string(), 0) // 1,000,000,000
+            .ok_response(
+                vec![LogObject {
+                    removed: false,
+                    log_index: Some("0x20".to_string()),
+                    transaction_index: Some("0x30".to_string()),
+                    transaction_hash: Some(
+                        "0x2222222222222222222222222222222222222222222222222222222222222222"
+                            .to_string(),
+                    ),
+                    block_hash: Some(
+                        "0x1111111111111111111111111111111111111111111111111111111111111111"
+                            .to_string(),
+                    ),
+                    block_number: Some("0x7D0".to_string()), // 2000 decimal
+                    address: "0x3333333333333333333333333333333333333334".to_string(),
+                    data: "0x000000000000000000000000000000000000000000000000000000003b5dc100"
+                        .to_string(),
+                    topics: vec![
+                        "0xddf252ad1be2c89b69c2b0680000000000006561726e696e675f77616c6c6574"
+                            .to_string(),
+                        "0xddf252ad1be2c89b69c2b0690000000000006561726e696e675f77616c6c6574"
+                            .to_string(),
+                    ],
+                }],
+                1,
+            )
+            .start();
 
-        let system = System::new(
-            "handle_retrieve_transactions_when_get_block_number_fails_uses_latest_for_start_and_end_block",
-        );
         let (accountant, _, accountant_recording_arc) = make_recorder();
+        let accountant_addr =
+            accountant.system_stop_conditions(match_every_type_id!(ReceivedPayments));
+        let earning_wallet = make_wallet("earning_wallet");
+        let amount = 996000000;
+        let blockchain_interface = make_blockchain_interface_web3(port);
         let persistent_config = PersistentConfigurationMock::new()
-            .max_block_count_result(Ok(Some(DEFAULT_MAX_BLOCK_COUNT)))
-            .start_block_result(Ok(None));
-        let latest_block_number = LatestBlockNumber::Err(BlockchainError::QueryFailed(
-            "Failed to read from block chain service".to_string(),
-        ));
-        let lower_interface =
-            LowBlockchainIntMock::default().get_block_number_result(latest_block_number);
-        let blockchain_interface = BlockchainInterfaceMock::default()
-            .retrieve_transactions_params(&retrieve_transactions_params_arc)
-            .retrieve_transactions_result(Ok(expected_transactions.clone()))
-            .lower_interface_results(Box::new(lower_interface));
+            .start_block_result(Ok(Some(6)))
+            .max_block_count_result(Ok(Some(5000)));
         let subject = BlockchainBridge::new(
             Box::new(blockchain_interface),
-            Box::new(persistent_config),
+            Arc::new(Mutex::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();
+        let peer_actors = peer_actors_builder().accountant(accountant_addr).build();
         send_bind_message!(subject_subs, peer_actors);
         let retrieve_transactions = RetrieveTransactions {
             recipient: earning_wallet.clone(),
@@ -1509,74 +1747,78 @@ mod tests {
 
         let _ = addr.try_send(retrieve_transactions).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::Latest, BlockNumber::Latest, earning_wallet)]
-        );
-        let accountant_received_payment = accountant_recording_arc.lock().unwrap();
-        assert_eq!(accountant_received_payment.len(), 1);
-        let received_payments = accountant_received_payment.get_record::<ReceivedPayments>(0);
-        check_timestamp(before, received_payments.timestamp, after);
+        let accountant_recording = accountant_recording_arc.lock().unwrap();
+        assert_eq!(accountant_recording.len(), 1);
+        let received_payments_message = accountant_recording.get_record::<ReceivedPayments>(0);
+        check_timestamp(before, received_payments_message.timestamp, after);
+        let expected_transactions = RetrievedBlockchainTransactions {
+            new_start_block: 6 + 5000 + 1,
+            transactions: vec![BlockchainTransaction {
+                block_number: 2000,
+                from: earning_wallet.clone(),
+                wei_amount: amount,
+            }],
+        };
         assert_eq!(
-            received_payments,
+            received_payments_message,
             &ReceivedPayments {
-                timestamp: received_payments.timestamp,
-                payments: expected_transactions.transactions,
-                new_start_block: 98765,
+                timestamp: received_payments_message.timestamp,
+                new_start_block: expected_transactions.new_start_block,
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
                     context_id: 4321
                 }),
+                transactions: expected_transactions.transactions,
             }
         );
     }
 
     #[test]
-    fn handle_retrieve_transactions_sends_received_payments_back_to_accountant() {
-        let retrieve_transactions_params_arc = Arc::new(Mutex::new(vec![]));
-        let system =
-            System::new("handle_retrieve_transactions_sends_received_payments_back_to_accountant");
-        let (accountant, _, accountant_recording_arc) = make_recorder();
-        let earning_wallet = make_wallet("somewallet");
-        let amount = 42;
-        let amount2 = 55;
-        let expected_transactions = RetrievedBlockchainTransactions {
-            new_start_block: BlockNumber::Number(9876.into()),
-            transactions: vec![
-                BlockchainTransaction {
-                    block_number: 7,
-                    from: earning_wallet.clone(),
-                    wei_amount: amount,
-                },
-                BlockchainTransaction {
-                    block_number: 9,
-                    from: earning_wallet.clone(),
-                    wei_amount: amount2,
-                },
+    fn handle_retrieve_transactions_receives_invalid_topics() {
+        init_test_logging();
+        let test_name = "handle_retrieve_transactions_receives_invalid_topics";
+        let system = System::new(test_name);
+        let logger = Logger::new(test_name);
+        let port = find_free_port();
+        let expected_response_logs = vec![LogObject {
+            removed: false,
+            log_index: Some("0x20".to_string()),
+            transaction_index: Some("0x30".to_string()),
+            transaction_hash: Some(
+                "0x2222222222222222222222222222222222222222222222222222222222222222".to_string(),
+            ),
+            block_hash: Some(
+                "0x1111111111111111111111111111111111111111111111111111111111111111".to_string(),
+            ),
+            block_number: Some("0x7D0".to_string()), // 2000 decimal
+            address: "0x3333333333333333333333333333333333333334".to_string(),
+            data: "0x000000000000000000000000000000000000000000000000000000003b5dc100".to_string(),
+            topics: vec![
+                "0xddf252ad1be2c89b69c2b0680000000000006561726e696e675f77616c6c6574".to_string(),
             ],
-        };
-        let latest_block_number = LatestBlockNumber::Ok(1024u64.into());
-        let lower_interface =
-            LowBlockchainIntMock::default().get_block_number_result(latest_block_number);
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .retrieve_transactions_params(&retrieve_transactions_params_arc)
-            .retrieve_transactions_result(Ok(expected_transactions.clone()))
-            .lower_interface_results(Box::new(lower_interface));
+        }];
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x3B9ACA00".to_string(), 0)
+            .ok_response(expected_response_logs, 1)
+            .start();
+        let (accountant, _, accountant_recording_arc) = make_recorder();
+        let accountant_addr = accountant.system_stop_conditions(match_every_type_id!(ScanError));
+        let earning_wallet = make_wallet("earning_wallet");
+        let mut blockchain_interface = make_blockchain_interface_web3(port);
+        blockchain_interface.logger = logger;
         let persistent_config = PersistentConfigurationMock::new()
-            .max_block_count_result(Ok(Some(10000u64)))
-            .start_block_result(Ok(Some(6)));
+            .start_block_result(Ok(Some(6)))
+            .max_block_count_result(Ok(Some(1000)));
         let subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(persistent_config),
+            Box::new(blockchain_interface),
+            Arc::new(Mutex::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();
+        let peer_actors = peer_actors_builder().accountant(accountant_addr).build();
         send_bind_message!(subject_subs, peer_actors);
         let retrieve_transactions = RetrieveTransactions {
             recipient: earning_wallet.clone(),
@@ -1585,98 +1827,132 @@ mod tests {
                 context_id: 4321,
             }),
         };
-        let before = SystemTime::now();
 
         let _ = addr.try_send(retrieve_transactions).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(6u64.into()),
-                BlockNumber::Number(1024u64.into()),
-                earning_wallet
-            )]
-        );
-        let accountant_received_payment = accountant_recording_arc.lock().unwrap();
-        assert_eq!(accountant_received_payment.len(), 1);
-        let received_payments = accountant_received_payment.get_record::<ReceivedPayments>(0);
-        check_timestamp(before, received_payments.timestamp, after);
+        let accountant_recording = accountant_recording_arc.lock().unwrap();
+        assert_eq!(accountant_recording.len(), 1);
+        let scan_error_msg = accountant_recording.get_record::<ScanError>(0);
         assert_eq!(
-            received_payments,
-            &ReceivedPayments {
-                timestamp: received_payments.timestamp,
-                payments: expected_transactions.transactions,
-                new_start_block: 9876,
+            scan_error_msg,
+            &ScanError {
+                scan_type: ScanType::Receivables,
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
                     context_id: 4321
                 }),
+                msg: "Error while retrieving transactions: InvalidResponse".to_string(),
             }
         );
+        TestLogHandler::new().exists_log_containing(&format!(
+            "WARN: {test_name}: Invalid response from blockchain server:"
+        ));
     }
 
     #[test]
-    fn processing_of_received_payments_continues_even_if_no_payments_are_detected() {
+    fn handle_retrieve_transactions_receives_query_failed_and_updates_max_block() {
         init_test_logging();
-        let lower_interface =
-            LowBlockchainIntMock::default().get_block_number_result(Ok(0u64.into()));
-        let blockchain_interface_mock = BlockchainInterfaceMock::default()
-            .retrieve_transactions_result(Ok(RetrievedBlockchainTransactions {
-                new_start_block: BlockNumber::Number(7.into()),
-                transactions: vec![],
-            }))
-            .lower_interface_results(Box::new(lower_interface));
-        let persistent_config = PersistentConfigurationMock::new()
-            .max_block_count_result(Ok(Some(10000u64)))
-            .start_block_result(Ok(Some(6)));
+        let test_name = "handle_retrieve_transactions_receives_query_failed_and_updates_max_block";
+        let system = System::new(test_name);
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x3B9ACA00".to_string(), 0)
+            .err_response(-32005, "Blockheight too far in the past. Check params passed to eth_getLogs or eth_call requests.Range of blocks allowed for your plan: 1000", 0)
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
-        let system = System::new(
-            "processing_of_received_payments_continues_even_if_no_payments_are_detected",
-        );
-        let subject = BlockchainBridge::new(
-            Box::new(blockchain_interface_mock),
-            Box::new(persistent_config),
+        let accountant = accountant.system_stop_conditions(match_every_type_id!(ScanError));
+        let earning_wallet = make_wallet("earning_wallet");
+        let blockchain_interface = make_blockchain_interface_web3(port);
+        let set_max_block_count_params_arc = Arc::new(Mutex::new(vec![]));
+        let persistent_config = PersistentConfigurationMock::new()
+            .start_block_result(Ok(Some(6)))
+            .max_block_count_result(Ok(None))
+            .set_max_block_count_result(Ok(()))
+            .set_max_block_count_params(&set_max_block_count_params_arc);
+        let mut subject = BlockchainBridge::new(
+            Box::new(blockchain_interface),
+            Arc::new(Mutex::new(persistent_config)),
             false,
         );
+        subject.logger = Logger::new(test_name);
         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 retrieve_transactions = RetrieveTransactions {
-            recipient: make_wallet("somewallet"),
+            recipient: earning_wallet.clone(),
             response_skeleton_opt: Some(ResponseSkeleton {
                 client_id: 1234,
                 context_id: 4321,
             }),
         };
-        let before = SystemTime::now();
 
         let _ = addr.try_send(retrieve_transactions).unwrap();
 
-        System::current().stop();
         system.run();
-        let after = SystemTime::now();
-        let accountant_received_payment = accountant_recording_arc.lock().unwrap();
-        let received_payments = accountant_received_payment.get_record::<ReceivedPayments>(0);
-        check_timestamp(before, received_payments.timestamp, after);
+        let accountant_recording = accountant_recording_arc.lock().unwrap();
+        assert_eq!(accountant_recording.len(), 1);
+        let scan_error_msg = accountant_recording.get_record::<ScanError>(0);
         assert_eq!(
-            received_payments,
-            &ReceivedPayments {
-                timestamp: received_payments.timestamp,
-                payments: vec![],
-                new_start_block: 7,
+            scan_error_msg,
+            &ScanError {
+                scan_type: ScanType::Receivables,
                 response_skeleton_opt: Some(ResponseSkeleton {
                     client_id: 1234,
                     context_id: 4321
                 }),
+                msg: "Error while retrieving transactions: QueryFailed(\"RPC error: Error { code: ServerError(-32005), message: \\\"Blockheight too far in the past. Check params passed to eth_getLogs or eth_call requests.Range of blocks allowed for your plan: 1000\\\", data: None }\")".to_string(),
             }
         );
-        TestLogHandler::new()
-            .exists_log_containing("DEBUG: BlockchainBridge: No new receivable detected");
+        let max_block_count_params = set_max_block_count_params_arc.lock().unwrap();
+        assert_eq!(*max_block_count_params, vec![Some(1000)]);
+        TestLogHandler::new().exists_log_containing(&format!(
+            "DEBUG: {test_name}: Updated max_block_count to 1000 in database"
+        ));
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Attempt to set new max block to 1000 failed due to: DatabaseError(\"my brain hurts\")"
+    )]
+    fn handle_retrieve_transactions_receives_panics_when_it_receives_persistent_config_error_while_setting_value(
+    ) {
+        let system = System::new("test");
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x3B9ACA00".to_string(), 0)
+            .err_response(-32005, "Blockheight too far in the past. Check params passed to eth_getLogs or eth_call requests.Range of blocks allowed for your plan: 1000", 0)
+            .start();
+        let (accountant, _, _) = make_recorder();
+        let earning_wallet = make_wallet("earning_wallet");
+        let blockchain_interface = make_blockchain_interface_web3(port);
+        let persistent_config = PersistentConfigurationMock::new()
+            .start_block_result(Ok(Some(6)))
+            .max_block_count_result(Ok(Some(1000)))
+            .set_max_block_count_result(Err(PersistentConfigError::DatabaseError(
+                "my brain hurts".to_string(),
+            )));
+        let subject = BlockchainBridge::new(
+            Box::new(blockchain_interface),
+            Arc::new(Mutex::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 retrieve_transactions = RetrieveTransactions {
+            recipient: earning_wallet.clone(),
+            response_skeleton_opt: Some(ResponseSkeleton {
+                client_id: 1234,
+                context_id: 4321,
+            }),
+        };
+
+        let _ = addr.try_send(retrieve_transactions).unwrap();
+
+        system.run();
     }
 
     #[test]
@@ -1684,15 +1960,11 @@ mod tests {
         expected = "Cannot retrieve start block from database; payments to you may not be processed: TransactionError"
     )]
     fn handle_retrieve_transactions_panics_if_start_block_cannot_be_read() {
-        let lower_interface =
-            LowBlockchainIntMock::default().get_block_number_result(Ok(0u64.into()));
-        let blockchain_interface =
-            BlockchainInterfaceMock::default().lower_interface_results(Box::new(lower_interface));
         let persistent_config = PersistentConfigurationMock::new()
             .start_block_result(Err(PersistentConfigError::TransactionError));
         let mut subject = BlockchainBridge::new(
-            Box::new(blockchain_interface),
-            Box::new(persistent_config),
+            Box::new(make_blockchain_interface_web3(find_free_port())),
+            Arc::new(Mutex::new(persistent_config)),
             false,
         );
         let retrieve_transactions = RetrieveTransactions {
@@ -1703,128 +1975,143 @@ mod tests {
         let _ = subject.handle_retrieve_transactions(retrieve_transactions);
     }
 
-    fn success_handler(
-        _bcb: &mut BlockchainBridge,
-        _msg: RetrieveTransactions,
-    ) -> Result<(), String> {
-        Ok(())
-    }
-
-    fn failure_handler(
-        _bcb: &mut BlockchainBridge,
-        _msg: RetrieveTransactions,
-    ) -> Result<(), String> {
-        Err("My tummy hurts".to_string())
-    }
-
+    // TODO: GH-555: Remove system_stop_conditions while also confirming the ScanError msg wasn't sent.
     #[test]
-    fn handle_scan_handles_success() {
+    fn handle_scan_future_handles_success() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0xC8".to_string(), 0)
+            .raw_response(r#"{
+              "jsonrpc": "2.0",
+              "id": 1,
+              "result": [
+                {
+                  "address": "0x06012c8cf97bead5deae237070f9587f8e7a266d",
+                  "blockHash": "0x7c5a35e9cb3e8ae0e221ab470abae9d446c3a5626ce6689fc777dcffcab52c70",
+                  "blockNumber": "0x5c29fb",
+                  "data": "0x0000000000000000000000000000002a",
+                  "logIndex": "0x1d",
+                  "removed": false,
+                  "topics": [
+                    "0x241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80",
+                    "0x000000000000000000000000000000000000000066697273745f77616c6c6574"
+                  ],
+                  "transactionHash": "0x3dc91b98249fa9f2c5c37486a2427a3a7825be240c1c84961dfb3063d9c04d50",
+                  "transactionIndex": "0x1d"
+                },
+                {
+                  "address": "0x06012c8cf97bead5deae237070f9587f8e7a266d",
+                  "blockHash": "0x7c5a35e9cb3e8ae0e221ab470abae9d446c3a5626ce6689fc777dcffcab52c70",
+                  "blockNumber": "0x5c29fc",
+                  "data": "0x00000000000000000000000000000037",
+                  "logIndex": "0x57",
+                  "removed": false,
+                  "topics": [
+                    "0x241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80",
+                    "0x000000000000000000000000000000000000007365636f6e645f77616c6c6574"
+                  ],
+                  "transactionHash": "0x788b1442414cb9c9a36dba2abe250763161a6f6395788a2e808f1b34e92beec1",
+                  "transactionIndex": "0x54"
+                }
+              ]
+            }"#.to_string())
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
-        let mut subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::new()),
-            false,
-        );
-        let system = System::new("test");
-        subject.scan_error_subs_opt = Some(accountant.start().recipient());
+        let start_block = Some(2000);
+        let wallet = make_wallet("somewallet");
+        let persistent_config = PersistentConfigurationMock::default()
+            .start_block_result(Ok(start_block))
+            .max_block_count_result(Ok(None));
         let retrieve_transactions = RetrieveTransactions {
-            recipient: make_wallet("somewallet"),
+            recipient: wallet.clone(),
             response_skeleton_opt: Some(ResponseSkeleton {
                 client_id: 1234,
                 context_id: 4321,
             }),
         };
-
-        subject.handle_scan(
-            success_handler,
-            ScanType::Receivables,
-            retrieve_transactions,
-        );
-
-        System::current().stop();
-        system.run();
-        let accountant_recording = accountant_recording_arc.lock().unwrap();
-        assert_eq!(accountant_recording.len(), 0);
-    }
-
-    #[test]
-    fn handle_scan_handles_failure_without_skeleton() {
-        init_test_logging();
-        let (accountant, _, accountant_recording_arc) = make_recorder();
         let mut subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::new()),
+            Box::new(make_blockchain_interface_web3(port)),
+            Arc::new(Mutex::new(persistent_config)),
             false,
         );
         let system = System::new("test");
-        subject.scan_error_subs_opt = Some(accountant.start().recipient());
-        let retrieve_transactions = RetrieveTransactions {
-            recipient: make_wallet("somewallet"),
-            response_skeleton_opt: None,
-        };
-
-        subject.handle_scan(
-            failure_handler,
+        let accountant_addr = accountant
+            .system_stop_conditions(match_every_type_id!(ScanError))
+            .start();
+        subject.received_payments_subs_opt = Some(accountant_addr.clone().recipient());
+        subject.scan_error_subs_opt = Some(accountant_addr.recipient());
+        subject.handle_scan_future(
+            BlockchainBridge::handle_retrieve_transactions,
             ScanType::Receivables,
             retrieve_transactions,
         );
 
-        System::current().stop();
         system.run();
         let accountant_recording = accountant_recording_arc.lock().unwrap();
-        let message = accountant_recording.get_record::<ScanError>(0);
-        assert_eq!(
-            message,
-            &ScanError {
-                scan_type: ScanType::Receivables,
-                response_skeleton_opt: None,
-                msg: "My tummy hurts".to_string()
-            }
-        );
-        assert_eq!(accountant_recording.len(), 1);
-        TestLogHandler::new().exists_log_containing("WARN: BlockchainBridge: My tummy hurts");
+        let msg_opt = accountant_recording.get_record_opt::<ScanError>(0);
+        assert_eq!(msg_opt, None, "We didnt expect a scan error: {:?}", msg_opt);
     }
 
     #[test]
-    fn handle_scan_handles_failure_with_skeleton() {
+    fn handle_scan_future_handles_failure() {
+        assert_handle_scan_future_handles_failure(RetrieveTransactions {
+            recipient: make_wallet("somewallet"),
+            response_skeleton_opt: Some(ResponseSkeleton {
+                client_id: 1234,
+                context_id: 4321,
+            }),
+        });
+
+        assert_handle_scan_future_handles_failure(RetrieveTransactions {
+            recipient: make_wallet("somewallet"),
+            response_skeleton_opt: None,
+        });
+    }
+
+    fn assert_handle_scan_future_handles_failure(msg: RetrieveTransactions) {
         init_test_logging();
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0xC8".to_string(), 0)
+            .err_response(-32005, "My tummy hurts", 0)
+            .start();
         let (accountant, _, accountant_recording_arc) = make_recorder();
+        let start_block = Some(2000);
+        let persistent_config = PersistentConfigurationMock::default()
+            .start_block_result(Ok(start_block))
+            .max_block_count_result(Ok(None));
         let mut subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::new()),
+            Box::new(make_blockchain_interface_web3(port)),
+            Arc::new(Mutex::new(persistent_config)),
             false,
         );
         let system = System::new("test");
-        subject.scan_error_subs_opt = Some(accountant.start().recipient());
-        let retrieve_transactions = RetrieveTransactions {
-            recipient: make_wallet("somewallet"),
-            response_skeleton_opt: Some(ResponseSkeleton {
-                client_id: 1234,
-                context_id: 4321,
-            }),
-        };
+        let accountant_addr = accountant
+            .system_stop_conditions(match_every_type_id!(ScanError))
+            .start();
+        subject.received_payments_subs_opt = Some(accountant_addr.clone().recipient());
+        subject.scan_error_subs_opt = Some(accountant_addr.recipient());
 
-        subject.handle_scan(
-            failure_handler,
+        subject.handle_scan_future(
+            BlockchainBridge::handle_retrieve_transactions,
             ScanType::Receivables,
-            retrieve_transactions,
+            msg.clone(),
         );
 
-        System::current().stop();
         system.run();
         let accountant_recording = accountant_recording_arc.lock().unwrap();
+        let message = accountant_recording.get_record::<ScanError>(0);
         assert_eq!(
-            accountant_recording.get_record::<ScanError>(0),
+            message,
             &ScanError {
                 scan_type: ScanType::Receivables,
-                response_skeleton_opt: Some(ResponseSkeleton {
-                    client_id: 1234,
-                    context_id: 4321
-                }),
-                msg: "My tummy hurts".to_string()
+                response_skeleton_opt: msg.response_skeleton_opt,
+                msg: "Error while retrieving transactions: QueryFailed(\"RPC error: Error { code: ServerError(-32005), message: \\\"My tummy hurts\\\", data: None }\")"
+                    .to_string()
             }
         );
-        TestLogHandler::new().exists_log_containing("WARN: BlockchainBridge: My tummy hurts");
+        assert_eq!(accountant_recording.len(), 1);
+        TestLogHandler::new().exists_log_containing("WARN: BlockchainBridge: Error while retrieving transactions: QueryFailed(\"RPC error: Error { code: ServerError(-32005), message: \\\"My tummy hurts\\\", data: None }\")");
     }
 
     #[test]
@@ -1834,8 +2121,8 @@ mod tests {
     fn blockchain_bridge_can_be_crashed_properly_but_not_improperly() {
         let crashable = true;
         let subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
+            Box::new(make_blockchain_interface_web3(find_free_port())),
+            Arc::new(Mutex::new(PersistentConfigurationMock::default())),
             crashable,
         );
 
@@ -1845,12 +2132,8 @@ mod tests {
     #[test]
     fn extract_max_block_range_from_error_response() {
         let result = BlockchainError::QueryFailed("RPC error: Error { code: ServerError(-32005), message: \"eth_getLogs block range too large, range: 33636, max: 3500\", data: None }".to_string());
-        let subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
-            false,
-        );
-        let max_block_count = subject.extract_max_block_count(result);
+
+        let max_block_count = BlockchainBridge::extract_max_block_count(result);
 
         assert_eq!(Some(3500u64), max_block_count);
     }
@@ -1858,12 +2141,8 @@ mod tests {
     #[test]
     fn extract_max_block_range_from_pokt_error_response() {
         let result = BlockchainError::QueryFailed("Rpc(Error { code: ServerError(-32001), message: \"Relay request failed validation: invalid relay request: eth_getLogs block range limit (100000 blocks) exceeded\", data: None })".to_string());
-        let subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
-            false,
-        );
-        let max_block_count = subject.extract_max_block_count(result);
+
+        let max_block_count = BlockchainBridge::extract_max_block_count(result);
 
         assert_eq!(Some(100000u64), max_block_count);
     }
@@ -1878,12 +2157,8 @@ mod tests {
     #[test]
     fn extract_max_block_range_for_ankr_error_response() {
         let result = BlockchainError::QueryFailed("RPC error: Error { code: ServerError(-32600), message: \"block range is too wide\", data: None }".to_string());
-        let subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
-            false,
-        );
-        let max_block_count = subject.extract_max_block_count(result);
+
+        let max_block_count = BlockchainBridge::extract_max_block_count(result);
 
         assert_eq!(None, max_block_count);
     }
@@ -1895,12 +2170,8 @@ mod tests {
     #[test]
     fn extract_max_block_range_for_matic_vigil_error_response() {
         let result = BlockchainError::QueryFailed("RPC error: Error { code: ServerError(-32005), message: \"Blockheight too far in the past. Check params passed to eth_getLogs or eth_call requests.Range of blocks allowed for your plan: 1000\", data: None }".to_string());
-        let subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
-            false,
-        );
-        let max_block_count = subject.extract_max_block_count(result);
+
+        let max_block_count = BlockchainBridge::extract_max_block_count(result);
 
         assert_eq!(Some(1000), max_block_count);
     }
@@ -1912,12 +2183,8 @@ mod tests {
     #[test]
     fn extract_max_block_range_for_blockpi_error_response() {
         let result = BlockchainError::QueryFailed("RPC error: Error { code: ServerError(-32005), message: \"eth_getLogs is limited to 1024 block range. Please check the parameter requirements at  https://docs.blockpi.io/documentations/api-reference\", data: None }".to_string());
-        let subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
-            false,
-        );
-        let max_block_count = subject.extract_max_block_count(result);
+
+        let max_block_count = BlockchainBridge::extract_max_block_count(result);
 
         assert_eq!(Some(1024), max_block_count);
     }
@@ -1931,12 +2198,8 @@ mod tests {
     #[test]
     fn extract_max_block_range_for_blastapi_error_response() {
         let result = BlockchainError::QueryFailed("RPC error: Error { code: ServerError(-32601), message: \"Method not found\", data: \"'eth_getLogs' is not available on our public API. Head over to https://docs.blastapi.io/blast-documentation/tutorials-and-guides/using-blast-to-get-a-blockchain-endpoint for more information\" }".to_string());
-        let subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
-            false,
-        );
-        let max_block_count = subject.extract_max_block_count(result);
+
+        let max_block_count = BlockchainBridge::extract_max_block_count(result);
 
         assert_eq!(None, max_block_count);
     }
@@ -1944,12 +2207,8 @@ mod tests {
     #[test]
     fn extract_max_block_range_for_nodies_error_response() {
         let result = BlockchainError::QueryFailed("RPC error: Error { code: InvalidParams, message: \"query exceeds max block range 100000\", data: None }".to_string());
-        let subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
-            false,
-        );
-        let max_block_count = subject.extract_max_block_count(result);
+
+        let max_block_count = BlockchainBridge::extract_max_block_count(result);
 
         assert_eq!(Some(100000), max_block_count);
     }
@@ -1959,12 +2218,8 @@ mod tests {
         let result = BlockchainError::QueryFailed(
             "Got invalid response: Expected batch, got single.".to_string(),
         );
-        let subject = BlockchainBridge::new(
-            Box::new(BlockchainInterfaceMock::default()),
-            Box::new(PersistentConfigurationMock::default()),
-            false,
-        );
-        let max_block_count = subject.extract_max_block_count(result);
+
+        let max_block_count = BlockchainBridge::extract_max_block_count(result);
 
         assert_eq!(Some(1000), max_block_count);
     }
@@ -1987,18 +2242,8 @@ mod tests {
 #[cfg(test)]
 pub mod exportable_test_parts {
     use super::*;
-    use crate::bootstrapper::BootstrapperConfig;
-    use crate::test_utils::http_test_server::TestServer;
-    use crate::test_utils::make_wallet;
     use crate::test_utils::recorder::make_blockchain_bridge_subs_from_recorder;
-    use crate::test_utils::unshared_test_utils::{AssertionsMessage, SubsFactoryTestAddrLeaker};
-    use actix::System;
-    use crossbeam_channel::{bounded, Receiver};
-    use masq_lib::test_utils::utils::{ensure_node_home_directory_exists, TEST_DEFAULT_CHAIN};
-    use masq_lib::utils::find_free_port;
-    use serde_json::Value::Object;
-    use serde_json::{Map, Value};
-    use std::net::Ipv4Addr;
+    use crate::test_utils::unshared_test_utils::SubsFactoryTestAddrLeaker;
 
     impl SubsFactory<BlockchainBridge, BlockchainBridgeSubs>
         for SubsFactoryTestAddrLeaker<BlockchainBridge>
@@ -2010,117 +2255,4 @@ pub mod exportable_test_parts {
             )
         }
     }
-
-    pub fn test_blockchain_bridge_is_constructed_with_correctly_functioning_connections<A>(
-        test_module: &str,
-        test_name: &str,
-        act: A,
-    ) where
-        A: FnOnce(
-            BootstrapperConfig,
-            SubsFactoryTestAddrLeaker<BlockchainBridge>,
-        ) -> BlockchainBridgeSubs,
-    {
-        fn prepare_db_with_unique_value(data_dir: &Path, gas_price: u64) {
-            let mut persistent_config = {
-                let conn = DbInitializerReal::default()
-                    .initialize(data_dir, DbInitializationConfig::test_default())
-                    .unwrap();
-                PersistentConfigurationReal::from(conn)
-            };
-            persistent_config.set_gas_price(gas_price).unwrap()
-        }
-        fn launch_prepared_test_server() -> (TestServer, String) {
-            let port = find_free_port();
-            let server_url = format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port);
-            (
-                TestServer::start(
-                    port,
-                    vec![br#"{"jsonrpc":"2.0","id":0,"result":someGarbage}"#.to_vec()],
-                ),
-                server_url,
-            )
-        }
-        fn send_rpc_request_to_assert_on_later_and_assert_db_connection(
-            actor_addr_rx: Receiver<Addr<BlockchainBridge>>,
-            wallet: Wallet,
-            expected_gas_price: u64,
-        ) {
-            let blockchain_bridge_addr = actor_addr_rx.try_recv().unwrap();
-            let msg = AssertionsMessage {
-                assertions: Box::new(move |bb: &mut BlockchainBridge| {
-                    // We will assert on soundness of the connection by checking the receipt of
-                    // this request
-                    let _result = bb
-                        .blockchain_interface
-                        .lower_interface()
-                        .get_service_fee_balance(&wallet);
-
-                    // Asserting that we can look into the expected db from here, meaning the
-                    // PersistentConfiguration was set up correctly
-                    assert_eq!(
-                        bb.persistent_config.gas_price().unwrap(),
-                        expected_gas_price
-                    );
-                    // I don't know why exactly but the standard position
-                    // of this call doesn't work
-                    System::current().stop();
-                }),
-            };
-            blockchain_bridge_addr.try_send(msg).unwrap();
-        }
-        fn assert_blockchain_interface_connection(test_server: &TestServer, wallet: Wallet) {
-            let requests = test_server.requests_so_far();
-            let bodies: Vec<Value> = requests
-                .into_iter()
-                .map(|request| serde_json::from_slice(&request.body()).unwrap())
-                .collect();
-            let params = &bodies[0]["params"];
-            let expected_params = {
-                let mut map = Map::new();
-                let hashed_data = format!(
-                    "0x70a08231000000000000000000000000{}",
-                    &wallet.to_string()[2..]
-                );
-                map.insert("data".to_string(), Value::String(hashed_data));
-                map.insert(
-                    "to".to_string(),
-                    Value::String(format!("{:?}", TEST_DEFAULT_CHAIN.rec().contract)),
-                );
-                map
-            };
-            assert_eq!(
-                params,
-                &Value::Array(vec![
-                    Object(expected_params),
-                    Value::String("latest".to_string())
-                ])
-            );
-        }
-
-        let data_dir = ensure_node_home_directory_exists(test_module, test_name);
-        let gas_price = 444;
-        prepare_db_with_unique_value(&data_dir, gas_price);
-        let (test_server, server_url) = launch_prepared_test_server();
-        let wallet = make_wallet("abc");
-        let mut bootstrapper_config = BootstrapperConfig::new();
-        bootstrapper_config
-            .blockchain_bridge_config
-            .blockchain_service_url_opt = Some(server_url);
-        bootstrapper_config.blockchain_bridge_config.chain = TEST_DEFAULT_CHAIN;
-        bootstrapper_config.data_directory = data_dir;
-        let (tx, blockchain_bridge_addr_rx) = bounded(1);
-        let address_leaker = SubsFactoryTestAddrLeaker { address_leaker: tx };
-        let system = System::new(test_name);
-
-        act(bootstrapper_config, address_leaker);
-
-        send_rpc_request_to_assert_on_later_and_assert_db_connection(
-            blockchain_bridge_addr_rx,
-            wallet.clone(),
-            gas_price,
-        );
-        assert_eq!(system.run(), 0);
-        assert_blockchain_interface_connection(&test_server, wallet)
-    }
 }
diff --git a/node/src/blockchain/blockchain_interface/blockchain_interface_null/lower_level_interface_null.rs b/node/src/blockchain/blockchain_interface/blockchain_interface_null/lower_level_interface_null.rs
deleted file mode 100644
index bde60a6bc..000000000
--- a/node/src/blockchain/blockchain_interface/blockchain_interface_null/lower_level_interface_null.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
-
-use crate::blockchain::blockchain_interface::data_structures::errors::BlockchainError;
-use crate::blockchain::blockchain_interface::lower_level_interface::{
-    LatestBlockNumber, LowBlockchainInt, ResultForBalance, ResultForNonce,
-};
-use crate::sub_lib::wallet::Wallet;
-use masq_lib::logger::Logger;
-
-pub struct LowBlockChainIntNull {
-    logger: Logger,
-}
-
-impl LowBlockchainInt for LowBlockChainIntNull {
-    fn get_transaction_fee_balance(&self, _wallet: &Wallet) -> ResultForBalance {
-        Err(self.handle_null_call("transaction fee balance"))
-    }
-
-    fn get_service_fee_balance(&self, _wallet: &Wallet) -> ResultForBalance {
-        Err(self.handle_null_call("masq balance"))
-    }
-
-    fn get_block_number(&self) -> LatestBlockNumber {
-        Err(self.handle_null_call("block number"))
-    }
-
-    fn get_transaction_id(&self, _wallet: &Wallet) -> ResultForNonce {
-        Err(self.handle_null_call("transaction id"))
-    }
-}
-
-impl LowBlockChainIntNull {
-    pub fn new(logger: &Logger) -> Self {
-        Self {
-            logger: logger.clone(),
-        }
-    }
-
-    fn handle_null_call(&self, operation: &str) -> BlockchainError {
-        error!(self.logger, "Null version can't fetch {operation}");
-        BlockchainError::UninitializedBlockchainInterface
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::blockchain::blockchain_interface::BlockchainError;
-    use crate::blockchain::blockchain_interface::blockchain_interface_null::lower_level_interface_null::LowBlockChainIntNull;
-    use crate::blockchain::blockchain_interface::lower_level_interface::LowBlockchainInt;
-    use crate::sub_lib::wallet::Wallet;
-    use crate::test_utils::make_wallet;
-    use masq_lib::logger::Logger;
-    use masq_lib::test_utils::logging::{init_test_logging, TestLogHandler};
-    use std::fmt::Debug;
-
-    #[test]
-    fn low_bci_null_gets_no_transaction_fee_balance() {
-        let test_name = "low_bci_null_gets_no_transaction_fee_balance";
-        let act = |subject: &LowBlockChainIntNull, wallet: &Wallet| {
-            subject.get_transaction_fee_balance(wallet)
-        };
-
-        test_null_method(test_name, act, "transaction fee balance");
-    }
-
-    #[test]
-    fn low_bci_null_gets_no_masq_balance() {
-        let test_name = "low_bci_null_gets_no_masq_balance";
-        let act = |subject: &LowBlockChainIntNull, wallet: &Wallet| {
-            subject.get_service_fee_balance(wallet)
-        };
-
-        test_null_method(test_name, act, "masq balance");
-    }
-
-    #[test]
-    fn low_bci_null_gets_no_block_number() {
-        let test_name = "low_bci_null_gets_no_block_number";
-        let act = |subject: &LowBlockChainIntNull, _wallet: &Wallet| subject.get_block_number();
-
-        test_null_method(test_name, act, "block number");
-    }
-
-    #[test]
-    fn low_bci_null_gets_no_transaction_id() {
-        let test_name = "low_bci_null_gets_no_transaction_id";
-        let act =
-            |subject: &LowBlockChainIntNull, wallet: &Wallet| subject.get_transaction_id(wallet);
-
-        test_null_method(test_name, act, "transaction id");
-    }
-
-    fn test_null_method<T: Debug + PartialEq>(
-        test_name: &str,
-        act: fn(&LowBlockChainIntNull, &Wallet) -> Result<T, BlockchainError>,
-        expected_method_name: &str,
-    ) {
-        init_test_logging();
-        let wallet = make_wallet("blah");
-        let subject = LowBlockChainIntNull::new(&Logger::new(test_name));
-
-        let result = act(&subject, &wallet);
-
-        assert_eq!(
-            result,
-            Err(BlockchainError::UninitializedBlockchainInterface)
-        );
-        let _expected_log_msg = TestLogHandler::new().exists_log_containing(&format!(
-            "ERROR: {test_name}: Null version can't fetch {expected_method_name}"
-        ));
-    }
-}
diff --git a/node/src/blockchain/blockchain_interface/blockchain_interface_null/mod.rs b/node/src/blockchain/blockchain_interface/blockchain_interface_null/mod.rs
deleted file mode 100644
index 69570c23b..000000000
--- a/node/src/blockchain/blockchain_interface/blockchain_interface_null/mod.rs
+++ /dev/null
@@ -1,291 +0,0 @@
-// Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
-
-pub mod lower_level_interface_null;
-
-use crate::accountant::db_access_objects::payable_dao::PayableAccount;
-use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
-use crate::blockchain::blockchain_bridge::PendingPayableFingerprintSeeds;
-use crate::blockchain::blockchain_interface::blockchain_interface_null::lower_level_interface_null::LowBlockChainIntNull;
-use crate::blockchain::blockchain_interface::lower_level_interface::LowBlockchainInt;
-use crate::db_config::persistent_configuration::PersistentConfiguration;
-use crate::sub_lib::wallet::Wallet;
-use actix::Recipient;
-use masq_lib::logger::Logger;
-use web3::types::{Address, BlockNumber, H160, H256};
-use crate::blockchain::blockchain_interface::BlockchainInterface;
-use crate::blockchain::blockchain_interface::data_structures::errors::{BlockchainAgentBuildError, BlockchainError, PayableTransactionError, ResultForReceipt};
-use crate::blockchain::blockchain_interface::data_structures::{ProcessedPayableFallible, RetrievedBlockchainTransactions};
-
-pub struct BlockchainInterfaceNull {
-    logger: Logger,
-    lower_level_interface: Box<dyn LowBlockchainInt>,
-}
-
-impl BlockchainInterface for BlockchainInterfaceNull {
-    fn contract_address(&self) -> Address {
-        self.log_uninitialized_for_operation("get contract address");
-        H160::zero()
-    }
-
-    fn retrieve_transactions(
-        &self,
-        _start_block: BlockNumber,
-        _end_block: BlockNumber,
-        _wallet: &Wallet,
-    ) -> Result<RetrievedBlockchainTransactions, BlockchainError> {
-        self.handle_uninitialized_interface("retrieve transactions")
-    }
-
-    fn build_blockchain_agent(
-        &self,
-        _consuming_wallet: &Wallet,
-        _persistent_config: &dyn PersistentConfiguration,
-    ) -> Result<Box<dyn BlockchainAgent>, BlockchainAgentBuildError> {
-        self.handle_uninitialized_interface("build blockchain agent")
-    }
-
-    fn send_batch_of_payables(
-        &self,
-        _agent: Box<dyn BlockchainAgent>,
-        _new_fingerprints_recipient: &Recipient<PendingPayableFingerprintSeeds>,
-        _accounts: &[PayableAccount],
-    ) -> Result<Vec<ProcessedPayableFallible>, PayableTransactionError> {
-        self.handle_uninitialized_interface("pay for payables")
-    }
-
-    fn get_transaction_receipt(&self, _hash: H256) -> ResultForReceipt {
-        self.handle_uninitialized_interface("get transaction receipt")
-    }
-
-    fn lower_interface(&self) -> &dyn LowBlockchainInt {
-        error!(
-            self.logger,
-            "Provides the null version of lower blockchain interface only"
-        );
-        &*self.lower_level_interface
-    }
-
-    as_any_ref_in_trait_impl!();
-}
-
-impl Default for BlockchainInterfaceNull {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-trait BlockchainInterfaceUninitializedError {
-    fn error() -> Self;
-}
-
-macro_rules! impl_bci_uninitialized {
-    ($($error_type: ty),+) => {
-        $(
-            impl BlockchainInterfaceUninitializedError for $error_type {
-                fn error() -> Self {
-                    Self::UninitializedBlockchainInterface
-                }
-            }
-        )+
-    }
-}
-
-impl_bci_uninitialized!(
-    PayableTransactionError,
-    BlockchainError,
-    BlockchainAgentBuildError
-);
-
-impl BlockchainInterfaceNull {
-    pub fn new() -> Self {
-        let logger = Logger::new("BlockchainInterface");
-        let lower_level_interface = Box::new(LowBlockChainIntNull::new(&logger));
-        BlockchainInterfaceNull {
-            logger,
-            lower_level_interface,
-        }
-    }
-
-    fn handle_uninitialized_interface<Irrelevant, E>(
-        &self,
-        operation: &str,
-    ) -> Result<Irrelevant, E>
-    where
-        E: BlockchainInterfaceUninitializedError,
-    {
-        self.log_uninitialized_for_operation(operation);
-        let err = E::error();
-        Err(err)
-    }
-
-    fn log_uninitialized_for_operation(&self, operation: &str) {
-        error!(
-            self.logger,
-            "Failed to {} with uninitialized blockchain \
-            interface. Parameter blockchain-service-url is missing.",
-            operation
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::agent_null::BlockchainAgentNull;
-    use crate::accountant::test_utils::make_payable_account;
-    use crate::blockchain::blockchain_interface::blockchain_interface_null::lower_level_interface_null::LowBlockChainIntNull;
-    use crate::blockchain::blockchain_interface::blockchain_interface_null::{
-        BlockchainInterfaceNull, BlockchainInterfaceUninitializedError,
-    };
-    use crate::blockchain::test_utils::make_tx_hash;
-    use crate::test_utils::make_wallet;
-    use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock;
-    use crate::test_utils::recorder::make_recorder;
-    use actix::Actor;
-    use ethereum_types::U64;
-    use masq_lib::logger::Logger;
-    use masq_lib::test_utils::logging::{init_test_logging, TestLogHandler};
-    use web3::types::{BlockNumber, H160};
-    use crate::blockchain::blockchain_interface::BlockchainInterface;
-    use crate::blockchain::blockchain_interface::data_structures::errors::{BlockchainAgentBuildError, BlockchainError, PayableTransactionError};
-
-    fn make_subject(test_name: &str) -> BlockchainInterfaceNull {
-        let logger = Logger::new(test_name);
-        let lower_level_interface = Box::new(LowBlockChainIntNull::new(&logger));
-        BlockchainInterfaceNull {
-            logger,
-            lower_level_interface,
-        }
-    }
-
-    #[test]
-    fn blockchain_interface_null_returns_contract_address() {
-        let result = make_subject("irrelevant").contract_address();
-
-        assert_eq!(result, H160::zero())
-    }
-
-    #[test]
-    fn blockchain_interface_null_retrieves_no_transactions() {
-        init_test_logging();
-        let test_name = "blockchain_interface_null_retrieves_no_transactions";
-        let wallet = make_wallet("blah");
-
-        let result = make_subject(test_name).retrieve_transactions(
-            BlockNumber::Number(U64::zero()),
-            BlockNumber::Latest,
-            &wallet,
-        );
-
-        assert_eq!(
-            result,
-            Err(BlockchainError::UninitializedBlockchainInterface)
-        );
-        let expected_msg = "Failed to retrieve transactions with uninitialized blockchain \
-            interface. Parameter blockchain-service-url is missing.";
-        let expected_log_msg = format!("ERROR: {test_name}: {}", expected_msg);
-        TestLogHandler::new().exists_log_containing(expected_log_msg.as_str());
-    }
-
-    #[test]
-    fn blockchain_interface_null_builds_null_agent() {
-        init_test_logging();
-        let test_name = "blockchain_interface_null_builds_null_agent";
-        let wallet = make_wallet("blah");
-        let persistent_config = PersistentConfigurationMock::new();
-        let subject = make_subject(test_name);
-
-        let result = subject.build_blockchain_agent(&wallet, &persistent_config);
-
-        let err = match result {
-            Ok(_) => panic!("we expected an error but got ok"),
-            Err(e) => e,
-        };
-        assert_eq!(
-            err,
-            BlockchainAgentBuildError::UninitializedBlockchainInterface
-        );
-        let expected_log_msg = format!(
-            "ERROR: {test_name}: Failed to build blockchain agent with uninitialized blockchain \
-            interface. Parameter blockchain-service-url is missing."
-        );
-        TestLogHandler::new().exists_log_containing(expected_log_msg.as_str());
-    }
-
-    #[test]
-    fn blockchain_interface_null_cannot_send_batch_of_payables() {
-        init_test_logging();
-        let test_name = "blockchain_interface_null_cannot_send_batch_of_payables";
-        let (recorder, _, _) = make_recorder();
-        let recipient = recorder.start().recipient();
-        let accounts = vec![make_payable_account(111)];
-        let agent = Box::new(BlockchainAgentNull::new());
-
-        let result = make_subject(test_name).send_batch_of_payables(agent, &recipient, &accounts);
-
-        assert_eq!(
-            result,
-            Err(PayableTransactionError::UninitializedBlockchainInterface)
-        );
-        let expected_log_msg = format!(
-            "ERROR: {test_name}: Failed to pay for payables with uninitialized blockchain \
-            interface. Parameter blockchain-service-url is missing."
-        );
-        TestLogHandler::new().exists_log_containing(expected_log_msg.as_str());
-    }
-
-    #[test]
-    fn blockchain_interface_null_gets_no_transaction_receipt() {
-        init_test_logging();
-        let test_name = "blockchain_interface_null_gets_no_transaction_receipt";
-        let tx_hash = make_tx_hash(123);
-
-        let result = make_subject(test_name).get_transaction_receipt(tx_hash);
-
-        assert_eq!(
-            result,
-            Err(BlockchainError::UninitializedBlockchainInterface)
-        );
-        let expected_log_msg = format!(
-            "ERROR: {test_name}: Failed to get transaction receipt with uninitialized \
-            blockchain interface. Parameter blockchain-service-url is missing."
-        );
-        TestLogHandler::new().exists_log_containing(expected_log_msg.as_str());
-    }
-
-    #[test]
-    fn blockchain_interface_null_gives_null_lower_interface() {
-        init_test_logging();
-        let test_name = "blockchain_interface_null_gives_null_lower_interface";
-        let wallet = make_wallet("abc");
-
-        let _ = make_subject(test_name)
-            .lower_interface()
-            .get_transaction_id(&wallet);
-
-        let expected_log_msg_from_low_level_interface_call = format!(
-            "ERROR: {test_name}: Provides the null version of lower blockchain interface only"
-        );
-        let expected_log_msg_from_rcp_call =
-            format!("ERROR: {test_name}: Null version can't fetch transaction id");
-        TestLogHandler::new().assert_logs_contain_in_order(vec![
-            expected_log_msg_from_low_level_interface_call.as_str(),
-            expected_log_msg_from_rcp_call.as_str(),
-        ]);
-    }
-
-    #[test]
-    fn blockchain_interface_null_error_is_implemented_for_blockchain_error() {
-        assert_eq!(
-            BlockchainError::error(),
-            BlockchainError::UninitializedBlockchainInterface
-        )
-    }
-
-    #[test]
-    fn blockchain_interface_null_error_is_implemented_for_payable_transaction_error() {
-        assert_eq!(
-            PayableTransactionError::error(),
-            PayableTransactionError::UninitializedBlockchainInterface
-        )
-    }
-}
diff --git a/node/src/blockchain/blockchain_interface/blockchain_interface_web3/batch_payable_tools.rs b/node/src/blockchain/blockchain_interface/blockchain_interface_web3/batch_payable_tools.rs
deleted file mode 100644
index ed0e21d15..000000000
--- a/node/src/blockchain/blockchain_interface/blockchain_interface_web3/batch_payable_tools.rs
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
-
-use crate::blockchain::blockchain_bridge::PendingPayableFingerprintSeeds;
-use actix::Recipient;
-use futures::Future;
-use serde_json::Value;
-use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::time::SystemTime;
-use web3::transports::Batch;
-use web3::types::{Bytes, SignedTransaction, TransactionParameters, H256};
-use web3::{BatchTransport, Error as Web3Error, Web3};
-
-pub trait BatchPayableTools<T>
-where
-    T: BatchTransport,
-{
-    fn sign_transaction(
-        &self,
-        transaction_params: TransactionParameters,
-        web3: &Web3<Batch<T>>,
-        key: &secp256k1secrets::key::SecretKey,
-    ) -> Result<SignedTransaction, Web3Error>;
-    fn append_transaction_to_batch(&self, signed_transaction: Bytes, web3: &Web3<Batch<T>>);
-    fn batch_wide_timestamp(&self) -> SystemTime;
-    fn send_new_payable_fingerprints_seeds(
-        &self,
-        batch_wide_timestamp: SystemTime,
-        new_pp_fingerprints_sub: &Recipient<PendingPayableFingerprintSeeds>,
-        hashes_and_balances: &[(H256, u128)],
-    );
-    fn submit_batch(
-        &self,
-        web3: &Web3<Batch<T>>,
-    ) -> Result<Vec<web3::transports::Result<Value>>, Web3Error>;
-}
-
-#[derive(Debug)]
-pub struct BatchPayableToolsReal<T> {
-    phantom: PhantomData<T>,
-}
-
-impl<T: BatchTransport> Default for BatchPayableToolsReal<T> {
-    fn default() -> Self {
-        Self {
-            phantom: Default::default(),
-        }
-    }
-}
-
-impl<T: BatchTransport + Debug> BatchPayableTools<T> for BatchPayableToolsReal<T> {
-    fn sign_transaction(
-        &self,
-        transaction_params: TransactionParameters,
-        web3: &Web3<Batch<T>>,
-        key: &secp256k1secrets::key::SecretKey,
-    ) -> Result<SignedTransaction, Web3Error> {
-        web3.accounts()
-            .sign_transaction(transaction_params, key)
-            .wait()
-    }
-
-    fn append_transaction_to_batch(&self, signed_transaction: Bytes, web3: &Web3<Batch<T>>) {
-        let _ = web3.eth().send_raw_transaction(signed_transaction);
-    }
-
-    fn batch_wide_timestamp(&self) -> SystemTime {
-        SystemTime::now()
-    }
-
-    fn send_new_payable_fingerprints_seeds(
-        &self,
-        batch_wide_timestamp: SystemTime,
-        pp_fingerprint_sub: &Recipient<PendingPayableFingerprintSeeds>,
-        hashes_and_balances: &[(H256, u128)],
-    ) {
-        pp_fingerprint_sub
-            .try_send(PendingPayableFingerprintSeeds {
-                batch_wide_timestamp,
-                hashes_and_balances: hashes_and_balances.to_vec(),
-            })
-            .expect("Accountant is dead");
-    }
-
-    fn submit_batch(
-        &self,
-        web3: &Web3<Batch<T>>,
-    ) -> Result<Vec<web3::transports::Result<Value>>, Web3Error> {
-        web3.transport().submit_batch().wait()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::blockchain::blockchain_bridge::PendingPayableFingerprintSeeds;
-    use crate::blockchain::blockchain_interface::blockchain_interface_web3::batch_payable_tools::{
-        BatchPayableTools, BatchPayableToolsReal,
-    };
-    use crate::blockchain::test_utils::{make_tx_hash, TestTransport};
-    use crate::test_utils::recorder::make_recorder;
-    use actix::{Actor, System};
-    use std::time::SystemTime;
-
-    #[test]
-    fn request_new_payable_fingerprints_works() {
-        let (accountant, _, accountant_recording_arc) = make_recorder();
-        let recipient = accountant.start().recipient();
-        let timestamp = SystemTime::now();
-        let hashes_and_balances = vec![(make_tx_hash(123), 5), (make_tx_hash(45466), 444444)];
-
-        let _ = BatchPayableToolsReal::<TestTransport>::default()
-            .send_new_payable_fingerprints_seeds(timestamp, &recipient, &hashes_and_balances);
-
-        let system = System::new("new fingerprints");
-        System::current().stop();
-        assert_eq!(system.run(), 0);
-        let accountant_recording = accountant_recording_arc.lock().unwrap();
-        let message = accountant_recording.get_record::<PendingPayableFingerprintSeeds>(0);
-        assert_eq!(
-            message,
-            &PendingPayableFingerprintSeeds {
-                batch_wide_timestamp: timestamp,
-                hashes_and_balances
-            }
-        )
-    }
-
-    #[test]
-    fn batch_wide_timestamp_returns_current_now() {
-        let subject = BatchPayableToolsReal::<TestTransport>::default();
-        let before = SystemTime::now();
-
-        let result = subject.batch_wide_timestamp();
-
-        let after = SystemTime::now();
-        assert!(
-            before <= result && result <= after,
-            "Actual timestamp {:?} didn't fit between before {:?} and after {:?}",
-            result,
-            before,
-            after
-        )
-    }
-}
diff --git a/node/src/blockchain/blockchain_interface/blockchain_interface_web3/lower_level_interface_web3.rs b/node/src/blockchain/blockchain_interface/blockchain_interface_web3/lower_level_interface_web3.rs
index 345853476..5879a47a3 100644
--- a/node/src/blockchain/blockchain_interface/blockchain_interface_web3/lower_level_interface_web3.rs
+++ b/node/src/blockchain/blockchain_interface/blockchain_interface_web3/lower_level_interface_web3.rs
@@ -1,77 +1,170 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::CONTRACT_ABI;
 use crate::blockchain::blockchain_interface::data_structures::errors::BlockchainError;
-use crate::blockchain::blockchain_interface::lower_level_interface::{
-    LatestBlockNumber, LowBlockchainInt, ResultForBalance, ResultForNonce,
-};
-use crate::sub_lib::wallet::Wallet;
+use crate::blockchain::blockchain_interface::data_structures::errors::BlockchainError::QueryFailed;
+use crate::blockchain::blockchain_interface::lower_level_interface::LowBlockchainInt;
+use ethereum_types::{H256, U256, U64};
 use futures::Future;
-use std::rc::Rc;
+use serde_json::Value;
 use web3::contract::{Contract, Options};
-use web3::transports::Batch;
-use web3::types::BlockNumber;
-use web3::{BatchTransport, Web3};
-
-pub struct LowBlockchainIntWeb3<T>
-where
-    T: BatchTransport,
-{
-    web3: Rc<Web3<T>>,
+use web3::transports::{Batch, Http};
+use web3::types::{Address, BlockNumber, Filter, Log, TransactionReceipt};
+use web3::{Error, Web3};
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum TransactionReceiptResult {
+    RpcResponse(TxReceipt),
+    LocalError(String),
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum TxStatus {
+    Failed,
+    Pending,
+    Succeeded(TransactionBlock),
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct TxReceipt {
+    pub transaction_hash: H256,
+    pub status: TxStatus,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct TransactionBlock {
+    pub block_hash: H256,
+    pub block_number: U64,
+}
+
+impl From<TransactionReceipt> for TxReceipt {
+    fn from(receipt: TransactionReceipt) -> Self {
+        let status = match (receipt.status, receipt.block_hash, receipt.block_number) {
+            (Some(status), Some(block_hash), Some(block_number)) if status == U64::from(1) => {
+                TxStatus::Succeeded(TransactionBlock {
+                    block_hash,
+                    block_number,
+                })
+            }
+            (Some(status), _, _) if status == U64::from(0) => TxStatus::Failed,
+            _ => TxStatus::Pending,
+        };
+
+        TxReceipt {
+            transaction_hash: receipt.transaction_hash,
+            status,
+        }
+    }
+}
+
+pub struct LowBlockchainIntWeb3 {
+    web3: Web3<Http>,
+    web3_batch: Web3<Batch<Http>>,
+    contract: Contract<Http>,
     // TODO waiting for GH-707 (note: consider to query the balances together with the id)
-    _batch_web3: Rc<Web3<Batch<T>>>,
-    contract: Contract<T>,
 }
 
-impl<T> LowBlockchainInt for LowBlockchainIntWeb3<T>
-where
-    T: BatchTransport,
-{
-    fn get_transaction_fee_balance(&self, wallet: &Wallet) -> ResultForBalance {
-        self.web3
-            .eth()
-            .balance(wallet.address(), None)
-            .map_err(|e| BlockchainError::QueryFailed(format!("{} for wallet {}", e, wallet)))
-            .wait()
+impl LowBlockchainInt for LowBlockchainIntWeb3 {
+    fn get_transaction_fee_balance(
+        &self,
+        address: Address,
+    ) -> Box<dyn Future<Item = U256, Error = BlockchainError>> {
+        Box::new(
+            self.web3
+                .eth()
+                .balance(address, None)
+                .map_err(|e| QueryFailed(e.to_string())),
+        )
     }
 
-    fn get_service_fee_balance(&self, wallet: &Wallet) -> ResultForBalance {
-        self.contract
-            .query(
-                "balanceOf",
-                wallet.address(),
-                None,
-                Options::default(),
-                None,
-            )
-            .map_err(|e| BlockchainError::QueryFailed(format!("{} for wallet {}", e, wallet)))
-            .wait()
+    fn get_service_fee_balance(
+        &self,
+        address: Address,
+    ) -> Box<dyn Future<Item = U256, Error = BlockchainError>> {
+        Box::new(
+            self.contract
+                .query("balanceOf", address, None, Options::default(), None)
+                .map_err(|e| QueryFailed(e.to_string())),
+        )
     }
 
-    fn get_block_number(&self) -> LatestBlockNumber {
-        self.web3
-            .eth()
-            .block_number()
-            .map_err(|e| BlockchainError::QueryFailed(e.to_string()))
-            .wait()
+    fn get_gas_price(&self) -> Box<dyn Future<Item = U256, Error = BlockchainError>> {
+        Box::new(
+            self.web3
+                .eth()
+                .gas_price()
+                .map_err(|e| QueryFailed(e.to_string())),
+        )
     }
 
-    fn get_transaction_id(&self, wallet: &Wallet) -> ResultForNonce {
-        self.web3
-            .eth()
-            .transaction_count(wallet.address(), Some(BlockNumber::Pending))
-            .map_err(|e| BlockchainError::QueryFailed(format!("{} for wallet {}", e, wallet)))
-            .wait()
+    fn get_block_number(&self) -> Box<dyn Future<Item = U64, Error = BlockchainError>> {
+        Box::new(
+            self.web3
+                .eth()
+                .block_number()
+                .map_err(|e| QueryFailed(e.to_string())),
+        )
+    }
+
+    fn get_transaction_id(
+        &self,
+        address: Address,
+    ) -> Box<dyn Future<Item = U256, Error = BlockchainError>> {
+        Box::new(
+            self.web3
+                .eth()
+                .transaction_count(address, Some(BlockNumber::Pending))
+                .map_err(move |e| QueryFailed(format!("{} for wallet {}", e, address))),
+        )
+    }
+
+    fn get_transaction_receipt_in_batch(
+        &self,
+        hash_vec: Vec<H256>,
+    ) -> Box<dyn Future<Item = Vec<Result<Value, Error>>, Error = BlockchainError>> {
+        hash_vec.into_iter().for_each(|hash| {
+            self.web3_batch.eth().transaction_receipt(hash);
+        });
+
+        Box::new(
+            self.web3_batch
+                .transport()
+                .submit_batch()
+                .map_err(|e| QueryFailed(e.to_string())),
+        )
+    }
+
+    fn get_contract_address(&self) -> Address {
+        self.contract.address()
+    }
+
+    fn get_transaction_logs(
+        &self,
+        filter: Filter,
+    ) -> Box<dyn Future<Item = Vec<Log>, Error = BlockchainError>> {
+        Box::new(
+            self.web3
+                .eth()
+                .logs(filter)
+                .map_err(|e| QueryFailed(e.to_string())),
+        )
+    }
+
+    fn get_web3_batch(&self) -> Web3<Batch<Http>> {
+        self.web3_batch.clone()
     }
 }
 
-impl<T> LowBlockchainIntWeb3<T>
-where
-    T: BatchTransport,
-{
-    pub fn new(web3: Rc<Web3<T>>, batch_web3: Rc<Web3<Batch<T>>>, contract: Contract<T>) -> Self {
+impl LowBlockchainIntWeb3 {
+    pub fn new(transport: Http, contract_address: Address) -> Self {
+        let web3 = Web3::new(transport.clone());
+        let web3_batch = Web3::new(Batch::new(transport));
+        let contract = Contract::from_json(web3.eth(), contract_address, CONTRACT_ABI.as_bytes())
+            .expect("Unable to initialize contract.");
+
         Self {
             web3,
-            _batch_web3: batch_web3,
+            web3_batch,
             contract,
         }
     }
@@ -79,317 +172,465 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::LowBlockchainIntWeb3;
-    use crate::blockchain::blockchain_interface::blockchain_interface_web3::{
-        CONTRACT_ABI, REQUESTS_IN_PARALLEL,
-    };
-    use crate::blockchain::blockchain_interface::lower_level_interface::{LowBlockchainInt, ResultForBalance};
-    use crate::blockchain::blockchain_interface::BlockchainError;
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::TRANSACTION_LITERAL;
+    use crate::blockchain::blockchain_interface::data_structures::errors::BlockchainError::QueryFailed;
+    use crate::blockchain::blockchain_interface::{BlockchainError, BlockchainInterface};
+    use crate::blockchain::test_utils::make_blockchain_interface_web3;
     use crate::sub_lib::wallet::Wallet;
-    use crate::test_utils::http_test_server::TestServer;
-    use crate::test_utils::make_paying_wallet;
-    use ethereum_types::U64;
-    use masq_lib::blockchains::chains::Chain;
-    use masq_lib::test_utils::utils::TEST_DEFAULT_CHAIN;
+    use crate::test_utils::make_wallet;
+    use ethereum_types::{H256, U64};
+    use futures::Future;
+    use masq_lib::test_utils::mock_blockchain_client_server::MBCSBuilder;
     use masq_lib::utils::find_free_port;
-    use serde_json::{json, Value};
-    use std::net::Ipv4Addr;
-    use std::rc::Rc;
     use std::str::FromStr;
-    use std::sync::{Arc, Mutex};
-    use web3::contract::Contract;
-    use web3::transports::{Batch, Http};
-    use web3::types::U256;
-    use web3::{BatchTransport, Web3};
-    use crate::blockchain::test_utils::TestTransport;
+    use web3::types::{BlockNumber, Bytes, FilterBuilder, Log, TransactionReceipt, U256};
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{TxReceipt, TxStatus};
 
     #[test]
-    fn low_interface_web3_transaction_fee_balance_works() {
+    fn get_transaction_fee_balance_works() {
         let port = find_free_port();
-        let test_server = TestServer::start(
-            port,
-            vec![br#"{"jsonrpc":"2.0","id":0,"result":"0xDEADBEEF"}"#.to_vec()],
-        );
-        let (_event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = make_subject(transport, chain);
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x23".to_string(), 1)
+            .start();
+        let wallet = &Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap();
+        let subject = make_blockchain_interface_web3(port);
 
         let result = subject
+            .lower_interface()
+            .get_transaction_fee_balance(wallet.address())
+            .wait();
+
+        assert_eq!(result, Ok(35.into()));
+    }
+
+    #[test]
+    fn get_transaction_fee_balance_returns_an_error_for_unintelligible_response_to_requesting_eth_balance(
+    ) {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0xFFFQ".to_string(), 0)
+            .start();
+        let subject = make_blockchain_interface_web3(port);
+
+        let result = subject
+            .lower_interface()
             .get_transaction_fee_balance(
-                &Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap(),
+                Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc")
+                    .unwrap()
+                    .address(),
             )
-            .unwrap();
+            .wait();
 
-        assert_eq!(result, U256::from(0xDEADBEEF_u64));
-        let requests = test_server.requests_so_far();
-        let bodies: Vec<Value> = requests
-            .into_iter()
-            .map(|request| serde_json::from_slice(&request.body()).unwrap())
-            .collect();
-        assert_eq!(bodies[0]["method"].to_string(), "\"eth_getBalance\"",);
-        assert_eq!(
-            bodies[0]["params"][0].to_string(),
-            "\"0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc\"",
-        );
-        assert_eq!(bodies.len(), 1)
+        match result {
+            Err(BlockchainError::QueryFailed(msg)) if msg.contains("invalid hex character: Q") => {
+                ()
+            }
+            x => panic!("Expected complaint about hex character, but got {:?}", x),
+        };
     }
 
     #[test]
-    #[should_panic(expected = "No address for an uninitialized wallet!")]
-    fn low_interface_web3_get_transaction_fee_balance_returns_err_for_an_invalid_wallet() {
-        let port = 8545;
-        let (_event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = make_subject(transport, chain);
+    fn get_gas_price_works() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x01".to_string(), 1)
+            .start();
+        let subject = make_blockchain_interface_web3(port);
 
-        let result = subject.get_transaction_fee_balance(&Wallet::new("0x_invalid_wallet_address"));
+        let result = subject.lower_interface().get_gas_price().wait().unwrap();
 
-        assert_eq!(result, Err(BlockchainError::InvalidAddress));
+        assert_eq!(result, 1.into());
     }
 
     #[test]
-    fn low_interface_web3_get_transaction_fee_balance_returns_err_for_unintelligible_response() {
-        let act = |subject: &LowBlockchainIntWeb3<Http>, wallet: &Wallet| {
-            subject.get_transaction_fee_balance(wallet)
-        };
+    fn get_gas_price_returns_error() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port).start();
+        let subject = make_blockchain_interface_web3(port);
 
-        assert_error_from_unintelligible_response(act, "invalid hex character");
+        let error = subject
+            .lower_interface()
+            .get_gas_price()
+            .wait()
+            .unwrap_err();
+
+        assert_eq!(
+            error,
+            QueryFailed("Transport error: Error(IncompleteMessage)".to_string())
+        );
     }
 
     #[test]
-    fn low_interface_web3_get_masq_balance_works() {
+    fn get_block_number_works() {
         let port = find_free_port();
-        let test_server = TestServer::start (port, vec![
-            br#"{"jsonrpc":"2.0","id":0,"result":"0x00000000000000000000000000000000000000000000000000000000DEADBEEF"}"#.to_vec()
-        ]);
-        let (_event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = make_subject(transport, chain);
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x23".to_string(), 1)
+            .start();
+        let subject = make_blockchain_interface_web3(port);
 
-        let result = subject
-            .get_service_fee_balance(
-                &Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap(),
-            )
-            .unwrap();
+        let result = subject.lower_interface().get_block_number().wait();
+
+        assert_eq!(result, Ok(35.into()));
+    }
+
+    #[test]
+    fn get_block_number_returns_an_error() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("trash".to_string(), 1)
+            .start();
+        let subject = make_blockchain_interface_web3(port);
+
+        let error = subject
+            .lower_interface()
+            .get_block_number()
+            .wait()
+            .unwrap_err();
 
-        assert_eq!(result, U256::from(0xDEADBEEF_u64));
-        let requests = test_server.requests_so_far();
-        let bodies: Vec<Value> = requests
-            .into_iter()
-            .map(|request| serde_json::from_slice(&request.body()).unwrap())
-            .collect();
-        assert_eq!(bodies[0]["method"].to_string(), "\"eth_call\"",);
-        let contract_address = chain.rec().contract;
         assert_eq!(
-            bodies[0]["params"][0]["to"].to_string(),
-            format!("\"{:?}\"", contract_address),
+            error,
+            QueryFailed(
+                "Decoder error: Error(\"0x prefix is missing\", line: 0, column: 0)".to_string()
+            )
         );
-        assert_eq!(bodies.len(), 1)
     }
 
     #[test]
-    #[should_panic(expected = "No address for an uninitialized wallet!")]
-    fn low_interface_web3_get_masq_balance_returns_err_for_an_invalid_wallet() {
-        let port = 8545;
-        let (_event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = make_subject(transport, chain);
+    fn get_transaction_id_works() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x23".to_string(), 1)
+            .start();
+        let subject = make_blockchain_interface_web3(port);
+        let wallet = &Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap();
 
-        let result = subject.get_service_fee_balance(&Wallet::new("0x_invalid_wallet_address"));
+        let result = subject
+            .lower_interface()
+            .get_transaction_id(wallet.address())
+            .wait();
 
-        assert_eq!(result, Err(BlockchainError::InvalidAddress));
+        assert_eq!(result, Ok(35.into()));
     }
 
     #[test]
-    fn low_interface_web3_get_masq_balance_returns_err_for_unintelligible_response() {
-        let act = |subject: &LowBlockchainIntWeb3<Http>, wallet: &Wallet| {
-            subject.get_service_fee_balance(wallet)
+    fn get_transaction_id_returns_an_error_for_unintelligible_response() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0xFFFQ".to_string(), 0)
+            .start();
+        let subject = make_blockchain_interface_web3(port);
+
+        let result = subject
+            .lower_interface()
+            .get_transaction_id(
+                Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc")
+                    .unwrap()
+                    .address(),
+            )
+            .wait();
+
+        match result {
+            Err(BlockchainError::QueryFailed(msg)) if msg.contains("invalid hex character: Q") => {
+                ()
+            }
+            x => panic!("Expected complaint about hex character, but got {:?}", x),
         };
+    }
 
-        assert_error_from_unintelligible_response(act, "Invalid hex");
+    #[test]
+    fn get_token_balance_can_retrieve_token_balance_of_a_wallet() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response(
+                "0x000000000000000000000000000000000000000000000000000000000000FFFF".to_string(),
+                0,
+            )
+            .start();
+        let subject = make_blockchain_interface_web3(port);
+
+        let result = subject
+            .lower_interface()
+            .get_service_fee_balance(
+                Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc")
+                    .unwrap()
+                    .address(),
+            )
+            .wait()
+            .unwrap();
+
+        assert_eq!(result, U256::from(65_535));
     }
 
     #[test]
-    fn low_interface_web3_can_fetch_latest_block_number_successfully() {
-        let prepare_params_arc = Arc::new(Mutex::new(vec![]));
-        let transport = TestTransport::default()
-            .prepare_params(&prepare_params_arc)
-            .send_result(json!("0x1e37066"));
-        let subject = make_subject(transport, TEST_DEFAULT_CHAIN);
-
-        let latest_block_number = subject.get_block_number().unwrap();
-
-        assert_eq!(latest_block_number, U64::from(0x1e37066u64));
-        let mut prepare_params = prepare_params_arc.lock().unwrap();
-        let (method_name, actual_arguments) = prepare_params.remove(0);
-        assert!(prepare_params.is_empty());
-        assert_eq!(method_name, "eth_blockNumber".to_string());
-        let expected_arguments: Vec<Value> = vec![];
-        assert_eq!(actual_arguments, expected_arguments);
+    fn get_token_balance_returns_error_for_unintelligible_response_to_token_balance() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response(
+                "0x000000000000000000000000000000000000000000000000000000000000FFFQ".to_string(),
+                0,
+            )
+            .start();
+        let expected_err_msg = "Invalid hex";
+        let subject = make_blockchain_interface_web3(port);
+
+        let result = subject
+            .lower_interface()
+            .get_service_fee_balance(
+                Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc")
+                    .unwrap()
+                    .address(),
+            )
+            .wait();
+
+        let err_msg = match result {
+            Err(BlockchainError::QueryFailed(msg)) => msg,
+            x => panic!("Expected BlockchainError::QueryFailed, but got {:?}", x),
+        };
+        assert!(
+            err_msg.contains(expected_err_msg),
+            "Expected this fragment {} in this err msg: {}",
+            expected_err_msg,
+            err_msg
+        )
     }
 
     #[test]
-    fn low_interface_web3_handles_latest_null_block_number_error() {
-        let prepare_params_arc = Arc::new(Mutex::new(vec![]));
-        let transport = TestTransport::default()
-            .prepare_params(&prepare_params_arc)
-            .send_result(Value::Null);
-        let subject = make_subject(transport, TEST_DEFAULT_CHAIN);
+    fn get_transaction_logs_works() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .raw_response(r#"{
+              "jsonrpc": "2.0",
+              "id": 1,
+              "result": [
+                {
+                  "address": "0x0000000000000000000000000070617965655f31",
+                  "blockHash": "0x7c5a35e9cb3e8ae0e221ab470abae9d446c3a5626ce6689fc777dcffcab52c70",
+                  "blockNumber": "0x5c29fb",
+                  "data": "0x0000000000000000000000003e3310720058c51f0de456e273c626cdd3",
+                  "logIndex": "0x1d",
+                  "removed": false,
+                  "topics": [
+                    "0x241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80"
+                  ],
+                  "transactionHash": "0x3dc91b98249fa9f2c5c37486a2427a3a7825be240c1c84961dfb3063d9c04d50",
+                  "transactionIndex": "0x1d"
+                },
+                {
+                  "address": "0x06012c8cf97bead5deae237070f9587f8e7a266d",
+                  "blockHash": "0x7c5a35e9cb3e8ae0e221ab470abae9d446c3a5626ce6689fc777dcffcab52c70",
+                  "blockNumber": "0x5c29fb",
+                  "data": "0x0000000000000000000000003e3310720058c51f0de456e273c626cdd3",
+                  "logIndex": "0x57",
+                  "removed": false,
+                  "topics": [
+                    "0x241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80"
+                  ],
+                  "transactionHash": "0x788b1442414cb9c9a36dba2abe250763161a6f6395788a2e808f1b34e92beec1",
+                  "transactionIndex": "0x54"
+                }
+              ]
+            }"#.to_string())
+            .start();
+        let subject = make_blockchain_interface_web3(port);
+        let contract_address = subject.chain.rec().contract;
+        let start_block = BlockNumber::Number(U64::from(100));
+        let response_block_number = BlockNumber::Number(U64::from(200));
+        let recipient = make_wallet("test_wallet").address();
+        let filter = FilterBuilder::default()
+            .address(vec![contract_address])
+            .from_block(start_block)
+            .to_block(response_block_number)
+            .topics(
+                Some(vec![TRANSACTION_LITERAL]),
+                None,
+                Some(vec![recipient.into()]),
+                None,
+            )
+            .build();
 
-        let expected_error = subject.get_block_number().unwrap_err();
+        let result = subject
+            .lower_interface()
+            .get_transaction_logs(filter)
+            .wait()
+            .unwrap();
 
+        assert_eq!(result.len(), 2);
         assert_eq!(
-            expected_error,
-            BlockchainError::QueryFailed(
-                "Decoder error: Error(\"invalid type: null, expected \
-            a 0x-prefixed hex string with length between (0; 16]\", line: 0, column: 0)"
-                    .to_string()
-            )
+            result[0],
+            Log {
+                address: make_wallet("payee_1").address(),
+                topics: vec![H256::from_str(
+                    "241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80"
+                )
+                .unwrap()],
+                data: Bytes(vec![
+                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 51, 16, 114, 0, 88, 197, 31, 13, 228,
+                    86, 226, 115, 198, 38, 205, 211
+                ]),
+                block_hash: Some(
+                    H256::from_str(
+                        "7c5a35e9cb3e8ae0e221ab470abae9d446c3a5626ce6689fc777dcffcab52c70"
+                    )
+                    .unwrap()
+                ),
+                block_number: Some(U64::from(6040059)),
+                transaction_hash: Some(
+                    H256::from_str(
+                        "3dc91b98249fa9f2c5c37486a2427a3a7825be240c1c84961dfb3063d9c04d50"
+                    )
+                    .unwrap()
+                ),
+                transaction_index: Some(U64::from(29)),
+                log_index: Some(U256::from(29)),
+                transaction_log_index: None,
+                log_type: None,
+                removed: Some(false),
+            }
         );
-        let mut prepare_params = prepare_params_arc.lock().unwrap();
-        let (method_name, actual_arguments) = prepare_params.remove(0);
-        assert!(prepare_params.is_empty());
-        assert_eq!(method_name, "eth_blockNumber".to_string());
-        let expected_arguments: Vec<Value> = vec![];
-        assert_eq!(actual_arguments, expected_arguments);
     }
 
     #[test]
-    fn low_interface_web3_can_handle_latest_string_block_number_error() {
-        let prepare_params_arc: Arc<Mutex<Vec<(String, Vec<Value>)>>> =
-            Arc::new(Mutex::new(vec![]));
-        let transport = TestTransport::default()
-            .prepare_params(&prepare_params_arc)
-            .send_result(Value::String("this is an invalid block number".to_string()));
-        let subject = make_subject(transport, TEST_DEFAULT_CHAIN);
+    fn get_transaction_logs_fails() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .raw_response(r#"{
+              "jsonrpc": "2.0",
+              "id": 1,
+              "result": [
+                {
+                  "address": "0x0000000000000000000000000070617965655f31",
+                  "blockHash": "0x7c5a35e9cb3e8ae0e221ab470abae9d446c3a5626ce6689fc777dcffcab52c70",
+                  "blockNumber": "0x5c29fb",
+                  "data": "0x0000000000000000000000003e331",
+                  "logIndex": "0x1d",
+                  "removed": false,
+                  "topics": [
+                    "0x241ea03ca20251805084d27d4440371c34a0b85ff108f6bb5611248f73818b80"
+                  ],
+                  "transactionHash": "0x3dc91b98249fa9f2c5c37486a2427a3a7825be240c1c84961dfb3063d9c04d50",
+                  "transactionIndex": "0x1d"
+                }
+              ]
+            }"#.to_string())
+            .start();
+        let subject = make_blockchain_interface_web3(port);
+        let contract_address = subject.chain.rec().contract;
+        let start_block = BlockNumber::Number(U64::from(100));
+        let response_block_number = BlockNumber::Number(U64::from(200));
+        let recipient = make_wallet("test_wallet").address();
+        let filter = FilterBuilder::default()
+            .address(vec![contract_address])
+            .from_block(start_block)
+            .to_block(response_block_number)
+            .topics(
+                Some(vec![TRANSACTION_LITERAL]),
+                None,
+                Some(vec![recipient.into()]),
+                None,
+            )
+            .build();
 
-        let expected_error = subject.get_block_number().unwrap_err();
+        let result = subject
+            .lower_interface()
+            .get_transaction_logs(filter)
+            .wait()
+            .unwrap_err();
 
         assert_eq!(
-            expected_error,
-            BlockchainError::QueryFailed(
-                "Decoder error: Error(\"0x prefix is missing\", line: 0, column: 0)".to_string()
+            result,
+            QueryFailed(
+                "Decoder error: Error(\"Invalid hex: Invalid input length\", line: 0, column: 0)"
+                    .to_string()
             )
         );
-        let mut prepare_params = prepare_params_arc.lock().unwrap();
-        let (method_name, actual_arguments) = prepare_params.remove(0);
-        assert!(prepare_params.is_empty());
-        assert_eq!(method_name, "eth_blockNumber".to_string());
-        let expected_arguments: Vec<Value> = vec![];
-        assert_eq!(actual_arguments, expected_arguments);
     }
 
     #[test]
-    fn low_interface_web3_get_transaction_id_works() {
-        let prepare_params_arc = Arc::new(Mutex::new(vec![]));
-        let send_params_arc = Arc::new(Mutex::new(vec![]));
-        let transport = TestTransport::default()
-            .prepare_params(&prepare_params_arc)
-            .send_params(&send_params_arc)
-            .send_result(json!(
-                "0x0000000000000000000000000000000000000000000000000000000000000001"
-            ));
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = make_subject(transport, chain);
-
-        let result = subject.get_transaction_id(&make_paying_wallet(b"gdasgsa"));
-
-        assert_eq!(result, Ok(U256::from(1)));
-        let mut prepare_params = prepare_params_arc.lock().unwrap();
-        let (method_name, actual_arguments) = prepare_params.remove(0);
-        assert!(prepare_params.is_empty());
-        let actual_arguments: Vec<String> = actual_arguments
-            .into_iter()
-            .map(|arg| serde_json::to_string(&arg).unwrap())
-            .collect();
-        assert_eq!(method_name, "eth_getTransactionCount".to_string());
-        assert_eq!(
-            actual_arguments,
-            vec![
-                String::from(r#""0x5c361ba8d82fcf0e5538b2a823e9d457a2296725""#),
-                String::from(r#""pending""#),
-            ]
+    fn transaction_receipt_can_be_converted_to_successful_transaction() {
+        let tx_receipt: TxReceipt = create_tx_receipt(
+            Some(U64::from(1)),
+            Some(H256::from_low_u64_be(0x1234)),
+            Some(U64::from(10)),
+            H256::from_low_u64_be(0x5678),
         );
-        let send_params = send_params_arc.lock().unwrap();
-        let rpc_call_params = vec![
-            Value::String(String::from("0x5c361ba8d82fcf0e5538b2a823e9d457a2296725")),
-            Value::String(String::from("pending")),
-        ];
-        let expected_request =
-            web3::helpers::build_request(1, "eth_getTransactionCount", rpc_call_params);
-        assert_eq!(*send_params, vec![(1, expected_request)])
+
+        assert_eq!(tx_receipt.transaction_hash, H256::from_low_u64_be(0x5678));
+        match tx_receipt.status {
+            TxStatus::Succeeded(ref block) => {
+                assert_eq!(block.block_hash, H256::from_low_u64_be(0x1234));
+                assert_eq!(block.block_number, U64::from(10));
+            }
+            _ => panic!("Expected status to be Succeeded"),
+        }
     }
 
     #[test]
-    fn low_interface_web3_get_transaction_id_handles_err() {
-        let act = |subject: &LowBlockchainIntWeb3<Http>, wallet: &Wallet| {
-            subject.get_transaction_id(wallet)
-        };
+    fn transaction_receipt_can_be_converted_to_failed_transaction() {
+        let tx_receipt: TxReceipt = create_tx_receipt(
+            Some(U64::from(0)),
+            None,
+            None,
+            H256::from_low_u64_be(0x5678),
+        );
 
-        assert_error_from_unintelligible_response(act, "invalid hex character")
+        assert_eq!(tx_receipt.transaction_hash, H256::from_low_u64_be(0x5678));
+        assert_eq!(tx_receipt.status, TxStatus::Failed);
     }
 
-    fn assert_error_from_unintelligible_response<F>(act: F, expected_err_fragment: &str)
-    where
-        F: FnOnce(&LowBlockchainIntWeb3<Http>, &Wallet) -> ResultForBalance,
-    {
-        let port = find_free_port();
-        let _test_server = TestServer::start (port, vec![
-            br#"{"jsonrpc":"2.0","id":0,"result":"0x000000000000000000000000000000000000000000000000000000000000FFFQ"}"#.to_vec()
-        ]);
-        let (_event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let wallet = Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap();
-        let subject = make_subject(transport, chain);
+    #[test]
+    fn transaction_receipt_can_be_converted_to_pending_transaction_no_status() {
+        let tx_receipt: TxReceipt =
+            create_tx_receipt(None, None, None, H256::from_low_u64_be(0x5678));
 
-        let result = act(&subject, &wallet);
+        assert_eq!(tx_receipt.transaction_hash, H256::from_low_u64_be(0x5678));
+        assert_eq!(tx_receipt.status, TxStatus::Pending);
+    }
 
-        let err_msg = match result {
-            Err(BlockchainError::QueryFailed(msg)) => msg,
-            x => panic!("Expected BlockchainError::QueryFailed, but got {:?}", x),
-        };
-        assert!(
-            err_msg.contains(expected_err_fragment),
-            "Expected this fragment \"{}\" in this err msg: {}",
-            expected_err_fragment,
-            err_msg
+    #[test]
+    fn transaction_receipt_can_be_converted_to_pending_transaction_no_block_info() {
+        let tx_receipt: TxReceipt = create_tx_receipt(
+            Some(U64::from(1)),
+            None,
+            None,
+            H256::from_low_u64_be(0x5678),
         );
-        assert!(
-            err_msg.contains("for wallet 0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc"),
-            "Expected the wallet to be cited in the err msg like \" for wallet {}\" but wasn't",
-            wallet
-        )
+
+        assert_eq!(tx_receipt.transaction_hash, H256::from_low_u64_be(0x5678));
+        assert_eq!(tx_receipt.status, TxStatus::Pending);
     }
 
-    fn make_subject<T>(transport: T, chain: Chain) -> LowBlockchainIntWeb3<T>
-    where
-        T: BatchTransport,
-    {
-        let web3 = Web3::new(transport.clone());
-        let web3_batch = Web3::new(Batch::new(transport.clone()));
-        let contract =
-            Contract::from_json(web3.eth(), chain.rec().contract, CONTRACT_ABI.as_bytes())
-                .expect("Unable to initialize contract.");
-        LowBlockchainIntWeb3::new(Rc::new(web3), Rc::new(web3_batch), contract)
+    #[test]
+    fn transaction_receipt_can_be_converted_to_pending_transaction_no_status_and_block_info() {
+        let tx_receipt: TxReceipt = create_tx_receipt(
+            Some(U64::from(1)),
+            Some(H256::from_low_u64_be(0x1234)),
+            None,
+            H256::from_low_u64_be(0x5678),
+        );
+
+        assert_eq!(tx_receipt.transaction_hash, H256::from_low_u64_be(0x5678));
+        assert_eq!(tx_receipt.status, TxStatus::Pending);
+    }
+
+    fn create_tx_receipt(
+        status: Option<U64>,
+        block_hash: Option<H256>,
+        block_number: Option<U64>,
+        transaction_hash: H256,
+    ) -> TxReceipt {
+        let receipt = TransactionReceipt {
+            status,
+            root: None,
+            block_hash,
+            block_number,
+            cumulative_gas_used: Default::default(),
+            gas_used: None,
+            contract_address: None,
+            transaction_hash,
+            transaction_index: Default::default(),
+            logs: vec![],
+            logs_bloom: Default::default(),
+        };
+        receipt.into()
     }
 }
diff --git a/node/src/blockchain/blockchain_interface/blockchain_interface_web3/mod.rs b/node/src/blockchain/blockchain_interface/blockchain_interface_web3/mod.rs
index a4425a82f..5320acd18 100644
--- a/node/src/blockchain/blockchain_interface/blockchain_interface_web3/mod.rs
+++ b/node/src/blockchain/blockchain_interface/blockchain_interface_web3/mod.rs
@@ -1,43 +1,30 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
-mod batch_payable_tools;
 pub mod lower_level_interface_web3;
-mod test_utils;
+mod utils;
 
-use crate::accountant::db_access_objects::payable_dao::{PayableAccount};
-use crate::accountant::{gwei_to_wei};
-use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::agent_web3::BlockchainAgentWeb3;
+use std::cmp::PartialEq;
 use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
-use crate::blockchain::blockchain_bridge::PendingPayableFingerprintSeeds;
-use crate::blockchain::blockchain_interface::blockchain_interface_web3::batch_payable_tools::{
-    BatchPayableTools, BatchPayableToolsReal,
-};
-use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::LowBlockchainIntWeb3;
+use crate::blockchain::blockchain_interface::data_structures::errors::{BlockchainError, PayableTransactionError};
+use crate::blockchain::blockchain_interface::data_structures::{BlockchainTransaction, ProcessedPayableFallible};
 use crate::blockchain::blockchain_interface::lower_level_interface::LowBlockchainInt;
-use crate::blockchain::blockchain_interface::{BlockchainAgentBuildError, BlockchainError, BlockchainInterface, PayableTransactionError, ResultForReceipt, RetrievedBlockchainTransactions};
-use crate::db_config::persistent_configuration::PersistentConfiguration;
-use crate::masq_lib::utils::ExpectValue;
-use crate::sub_lib::blockchain_bridge::ConsumingWalletBalances;
+use crate::blockchain::blockchain_interface::RetrievedBlockchainTransactions;
+use crate::blockchain::blockchain_interface::{BlockchainAgentBuildError, BlockchainInterface};
 use crate::sub_lib::wallet::Wallet;
-use actix::Recipient;
-use futures::Future;
+use futures::{Future};
 use indoc::indoc;
 use masq_lib::blockchains::chains::Chain;
 use masq_lib::logger::Logger;
-use serde_json::Value;
+use std::convert::{From, TryInto};
 use std::fmt::Debug;
-use std::iter::once;
-use std::rc::Rc;
-use thousands::Separable;
-use web3::contract::Contract;
-use web3::transports::{Batch, EventLoopHandle};
-use web3::types::{
-    Address, BlockNumber, Bytes, FilterBuilder, Log, SignedTransaction, TransactionParameters,
-    H160, H256, U256,
-};
-use web3::{BatchTransport, Error, Web3};
-use crate::accountant::db_access_objects::pending_payable_dao::PendingPayable;
-use crate::blockchain::blockchain_interface::data_structures::{BlockchainTransaction, ProcessedPayableFallible, RpcPayablesFailure};
+use actix::Recipient;
+use ethereum_types::U64;
+use web3::transports::{EventLoopHandle, Http};
+use web3::types::{Address, Log, H256, U256, FilterBuilder, TransactionReceipt, BlockNumber};
+use crate::accountant::db_access_objects::payable_dao::PayableAccount;
+use crate::blockchain::blockchain_bridge::{BlockMarker, BlockScanRange, PendingPayableFingerprintSeeds};
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{LowBlockchainIntWeb3, TransactionReceiptResult, TxReceipt, TxStatus};
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::utils::{create_blockchain_agent_web3, send_payables_within_batch, BlockchainAgentFutureResult};
 
 const CONTRACT_ABI: &str = indoc!(
     r#"[{
@@ -59,291 +46,243 @@ const CONTRACT_ABI: &str = indoc!(
     }]"#
 );
 
-const TRANSACTION_LITERAL: H256 = H256([
+pub const TRANSACTION_LITERAL: H256 = H256([
     0xdd, 0xf2, 0x52, 0xad, 0x1b, 0xe2, 0xc8, 0x9b, 0x69, 0xc2, 0xb0, 0x68, 0xfc, 0x37, 0x8d, 0xaa,
     0x95, 0x2b, 0xa7, 0xf1, 0x63, 0xc4, 0xa1, 0x16, 0x28, 0xf5, 0x5a, 0x4d, 0xf5, 0x23, 0xb3, 0xef,
 ]);
 
-const TRANSFER_METHOD_ID: [u8; 4] = [0xa9, 0x05, 0x9c, 0xbb];
+pub const TRANSFER_METHOD_ID: [u8; 4] = [0xa9, 0x05, 0x9c, 0xbb];
 
 pub const REQUESTS_IN_PARALLEL: usize = 1;
 
-pub struct BlockchainInterfaceWeb3<T>
-where
-    T: 'static + BatchTransport + Debug,
-{
-    logger: Logger,
+pub const FRESH_START_BLOCK: u64 = 0;
+
+pub const BLOCKCHAIN_SERVICE_URL_NOT_SPECIFIED: &str =
+    "To avoid being delinquency-banned, you should \
+restart the Node with a value for blockchain-service-url";
+
+pub struct BlockchainInterfaceWeb3 {
+    pub logger: Logger,
     chain: Chain,
-    gas_limit_const_part: u64,
+    gas_limit_const_part: u128,
     // This must not be dropped for Web3 requests to be completed
     _event_loop_handle: EventLoopHandle,
-    web3: Rc<Web3<T>>,
-    web3_batch: Rc<Web3<Batch<T>>>,
-    batch_payable_tools: Box<dyn BatchPayableTools<T>>,
-    lower_interface: Box<dyn LowBlockchainInt>,
+    transport: Http,
 }
 
-impl<T> BlockchainInterface for BlockchainInterfaceWeb3<T>
-where
-    T: 'static + BatchTransport + Debug,
-{
+pub const GWEI: U256 = U256([1_000_000_000u64, 0, 0, 0]);
+
+pub fn to_wei(gwub: u64) -> U256 {
+    let subgwei = U256::from(gwub);
+    subgwei.full_mul(GWEI).try_into().expect("Internal Error")
+}
+
+impl BlockchainInterface for BlockchainInterfaceWeb3 {
     fn contract_address(&self) -> Address {
         self.chain.rec().contract
     }
 
-    fn retrieve_transactions(
-        &self,
-        start_block: BlockNumber,
-        end_block: BlockNumber,
-        recipient: &Wallet,
-    ) -> Result<RetrievedBlockchainTransactions, BlockchainError> {
-        debug!(
-            self.logger,
-            "Retrieving transactions from start block: {:?} to end block: {:?} for: {} chain_id: {} contract: {:#x}",
-            start_block,
-            end_block,
-            recipient,
-            self.chain.rec().num_chain_id,
-            self.contract_address()
-        );
-        let filter = FilterBuilder::default()
-            .address(vec![self.contract_address()])
-            .from_block(start_block)
-            .to_block(end_block)
-            .topics(
-                Some(vec![TRANSACTION_LITERAL]),
-                None,
-                Some(vec![recipient.address().into()]),
-                None,
-            )
-            .build();
+    fn get_chain(&self) -> Chain {
+        self.chain
+    }
 
-        let fallback_start_block_number = match end_block {
-            BlockNumber::Number(eb) => Some(eb.as_u64()),
-            _ => {
-                if let BlockNumber::Number(start_block_number) = start_block {
-                    Some(start_block_number.as_u64() + 1u64)
-                } else {
-                    None
-                }
-            }
-        };
-        let block_request = self.web3_batch.eth().block_number();
-        let log_request = self.web3_batch.eth().logs(filter);
+    fn lower_interface(&self) -> Box<dyn LowBlockchainInt> {
+        Box::new(LowBlockchainIntWeb3::new(
+            self.transport.clone(),
+            self.contract_address(),
+        ))
+    }
 
+    fn retrieve_transactions(
+        &self,
+        start_block_marker: BlockMarker,
+        scan_range: BlockScanRange,
+        recipient: Address,
+    ) -> Box<dyn Future<Item = RetrievedBlockchainTransactions, Error = BlockchainError>> {
+        let lower_level_interface = self.lower_interface();
         let logger = self.logger.clone();
-        match self.web3_batch.transport().submit_batch().wait() {
-            Ok(_) => {
-                let response_block_number_opt = match block_request.wait() {
-                    Ok(block_nbr) => {
-                        debug!(logger, "Latest block number: {}", block_nbr.as_u64());
-                        Some(block_nbr.as_u64())
-                    }
-                    Err(_) => {
-                        debug!(
-                            logger,
-                            "Using fallback block number: {:?}", fallback_start_block_number
-                        );
-                        fallback_start_block_number
-                    }
+        let contract_address = lower_level_interface.get_contract_address();
+        let num_chain_id = self.chain.rec().num_chain_id;
+        let start_block_number = match start_block_marker {
+            BlockMarker::Uninitialized => self.chain.rec().contract_creation_block,
+            BlockMarker::Value(number) => number,
+        };
+        Box::new(
+            lower_level_interface.get_block_number().then(move |response_block_number_result| {
+                let end_block_marker = Self::calculate_end_block_marker(start_block_number, scan_range, response_block_number_result, &logger);
+                let end_block_number = match end_block_marker {
+                    BlockMarker::Uninitialized => { BlockNumber::Latest }
+                    BlockMarker::Value(number) => { BlockNumber::Number(U64::from(number)) }
                 };
-
-                match log_request.wait() {
-                    Ok(logs) => {
-                        let logs_len = logs.len();
-                        if logs
-                            .iter()
-                            .any(|log| log.topics.len() < 2 || log.data.0.len() > 32)
-                        {
-                            warning!(
-                                logger,
-                                "Invalid response from blockchain server: {:?}",
-                                logs
-                            );
-                            Err(BlockchainError::InvalidResponse)
-                        } else {
-                            let transactions: Vec<BlockchainTransaction> =
-                                self.extract_transactions_from_logs(logs);
-                            debug!(logger, "Retrieved transactions: {:?}", transactions);
-                            if transactions.is_empty() && logs_len != transactions.len() {
-                                warning!(
-                                    logger,
-                                    "Retrieving transactions: logs: {}, transactions: {}",
-                                    logs_len,
-                                    transactions.len()
-                                )
+                debug!(
+                    logger,
+                    "Retrieving transactions from start block: {:?} to end block: {:?} for: {} chain_id: {} contract: {:#x}",
+                    start_block_number,
+                    end_block_number,
+                    recipient,
+                    num_chain_id,
+                    contract_address
+                );
+                let filter = FilterBuilder::default()
+                    .address(vec![contract_address])
+                    .from_block(BlockNumber::Number(U64::from(start_block_number)))
+                    .to_block(end_block_number)
+                    .topics(
+                        Some(vec![TRANSACTION_LITERAL]),
+                        None,
+                        Some(vec![recipient.into()]),
+                        None,
+                    )
+                    .build();
+                lower_level_interface.get_transaction_logs(filter)
+                    .then(move |logs_result| {
+                        trace!(logger, "Transaction logs retrieval completed: {:?}", logs_result);
+
+                        match Self::handle_transaction_logs(logs_result, &logger) {
+                            Err(e) => Err(e),
+                            Ok(transactions) => {
+                                let new_start_block = Self::find_new_start_block(&transactions, start_block_marker, end_block_marker, &logger);
+
+                                Ok(RetrievedBlockchainTransactions {
+                                    new_start_block,
+                                    transactions,
+                                })
                             }
-                            // Get the largest transaction block number, unless there are no
-                            // transactions, in which case use end_block, unless get_latest_block()
-                            // was not successful.
-                            let transaction_max_block_number = self
-                                .find_largest_transaction_block_number(
-                                    response_block_number_opt,
-                                    &transactions,
-                                );
-                            debug!(
-                                logger,
-                                "Discovered transaction max block nbr: {:?}",
-                                transaction_max_block_number
-                            );
-                            Ok(RetrievedBlockchainTransactions {
-                                new_start_block: transaction_max_block_number
-                                    .map(|nsb| BlockNumber::Number((1u64 + nsb).into()))
-                                    .unwrap_or(BlockNumber::Latest),
-                                transactions,
-                            })
                         }
-                    }
-                    Err(e) => {
-                        error!(self.logger, "Retrieving transactions: {:?}", e);
-                        Err(BlockchainError::QueryFailed(e.to_string()))
-                    }
-                }
-            }
-            Err(e) => Err(BlockchainError::QueryFailed(e.to_string())),
-        }
+                    })
+            },
+            )
+        )
     }
 
     fn build_blockchain_agent(
         &self,
-        consuming_wallet: &Wallet,
-        persistent_config: &dyn PersistentConfiguration,
-    ) -> Result<Box<dyn BlockchainAgent>, BlockchainAgentBuildError> {
-        let gas_price_gwei = match persistent_config.gas_price() {
-            Ok(price) => price,
-            Err(e) => return Err(BlockchainAgentBuildError::GasPrice(e)),
-        };
-
-        let transaction_fee_balance = match self
-            .lower_interface
-            .get_transaction_fee_balance(consuming_wallet)
-        {
-            Ok(balance) => balance,
-            Err(e) => {
-                return Err(BlockchainAgentBuildError::TransactionFeeBalance(
-                    consuming_wallet.clone(),
-                    e,
-                ))
-            }
-        };
-
-        let masq_token_balance = match self
-            .lower_interface
-            .get_service_fee_balance(consuming_wallet)
-        {
-            Ok(balance) => balance,
-            Err(e) => {
-                return Err(BlockchainAgentBuildError::ServiceFeeBalance(
-                    consuming_wallet.clone(),
-                    e,
-                ))
-            }
-        };
+        consuming_wallet: Wallet,
+    ) -> Box<dyn Future<Item = Box<dyn BlockchainAgent>, Error = BlockchainAgentBuildError>> {
+        let wallet_address = consuming_wallet.address();
+        let gas_limit_const_part = self.gas_limit_const_part;
+        // TODO: Would it be better to wrap these 3 calls into a single batch call?
+        let get_gas_price = self.lower_interface().get_gas_price();
+        let get_transaction_fee_balance = self
+            .lower_interface()
+            .get_transaction_fee_balance(wallet_address);
+        let get_service_fee_balance = self
+            .lower_interface()
+            .get_service_fee_balance(wallet_address);
+        let chain = self.chain;
 
-        let pending_transaction_id = match self.lower_interface.get_transaction_id(consuming_wallet)
-        {
-            Ok(id) => id,
-            Err(e) => {
-                return Err(BlockchainAgentBuildError::TransactionID(
-                    consuming_wallet.clone(),
-                    e,
-                ))
-            }
-        };
+        Box::new(
+            get_gas_price
+                .map_err(BlockchainAgentBuildError::GasPrice)
+                .and_then(move |gas_price_wei| {
+                    get_transaction_fee_balance
+                        .map_err(move |e| {
+                            BlockchainAgentBuildError::TransactionFeeBalance(wallet_address, e)
+                        })
+                        .and_then(move |transaction_fee_balance| {
+                            get_service_fee_balance
+                                .map_err(move |e| {
+                                    BlockchainAgentBuildError::ServiceFeeBalance(wallet_address, e)
+                                })
+                                .and_then(move |masq_token_balance| {
+                                    let blockchain_agent_future_result =
+                                        BlockchainAgentFutureResult {
+                                            gas_price_wei,
+                                            transaction_fee_balance,
+                                            masq_token_balance,
+                                        };
+                                    Ok(create_blockchain_agent_web3(
+                                        gas_limit_const_part,
+                                        blockchain_agent_future_result,
+                                        consuming_wallet,
+                                        chain,
+                                    ))
+                                })
+                        })
+                }),
+        )
+    }
 
-        let consuming_wallet_balances = ConsumingWalletBalances {
-            transaction_fee_balance_in_minor_units: transaction_fee_balance,
-            masq_token_balance_in_minor_units: masq_token_balance,
-        };
-        let consuming_wallet = consuming_wallet.clone();
-
-        Ok(Box::new(BlockchainAgentWeb3::new(
-            gas_price_gwei,
-            self.gas_limit_const_part,
-            consuming_wallet,
-            consuming_wallet_balances,
-            pending_transaction_id,
-        )))
+    fn process_transaction_receipts(
+        &self,
+        transaction_hashes: Vec<H256>,
+    ) -> Box<dyn Future<Item = Vec<TransactionReceiptResult>, Error = BlockchainError>> {
+        Box::new(
+            self.lower_interface()
+                .get_transaction_receipt_in_batch(transaction_hashes.clone())
+                .map_err(move |e| e)
+                .and_then(move |batch_response| {
+                    Ok(batch_response
+                        .into_iter()
+                        .zip(transaction_hashes)
+                        .map(|(response, hash)| match response {
+                            Ok(result) => {
+                                match serde_json::from_value::<TransactionReceipt>(result) {
+                                    Ok(receipt) => {
+                                        TransactionReceiptResult::RpcResponse(receipt.into())
+                                    }
+                                    Err(e) => {
+                                        if e.to_string().contains("invalid type: null") {
+                                            TransactionReceiptResult::RpcResponse(TxReceipt {
+                                                transaction_hash: hash,
+                                                status: TxStatus::Pending,
+                                            })
+                                        } else {
+                                            TransactionReceiptResult::LocalError(e.to_string())
+                                        }
+                                    }
+                                }
+                            }
+                            Err(e) => TransactionReceiptResult::LocalError(e.to_string()),
+                        })
+                        .collect::<Vec<TransactionReceiptResult>>())
+                }),
+        )
     }
 
-    fn send_batch_of_payables(
+    fn submit_payables_in_batch(
         &self,
+        logger: Logger,
         agent: Box<dyn BlockchainAgent>,
-        new_fingerprints_recipient: &Recipient<PendingPayableFingerprintSeeds>,
-        accounts: &[PayableAccount],
-    ) -> Result<Vec<ProcessedPayableFallible>, PayableTransactionError> {
-        let consuming_wallet = agent.consuming_wallet();
-        let gas_price = agent.agreed_fee_per_computation_unit();
-        let pending_nonce = agent.pending_transaction_id();
-
-        debug!(
-            self.logger,
-            "Common attributes of payables to be transacted: sender wallet: {}, contract: {:?}, chain_id: {}, gas_price: {}",
-            consuming_wallet,
-            self.chain.rec().contract,
-            self.chain.rec().num_chain_id,
-            gas_price
-        );
-
-        let hashes_and_paid_amounts = self.sign_and_append_multiple_payments(
-            consuming_wallet,
-            gas_price,
-            pending_nonce,
-            accounts,
-        )?;
-        let timestamp = self.batch_payable_tools.batch_wide_timestamp();
-        self.batch_payable_tools
-            .send_new_payable_fingerprints_seeds(
-                timestamp,
-                new_fingerprints_recipient,
-                &hashes_and_paid_amounts,
-            );
-
-        info!(
-            self.logger,
-            "{}",
-            self.transmission_log(accounts, gas_price)
-        );
-
-        match self.batch_payable_tools.submit_batch(&self.web3_batch) {
-            Ok(responses) => Ok(Self::merged_output_data(
-                responses,
-                hashes_and_paid_amounts,
-                accounts,
-            )),
-            Err(e) => Err(Self::error_with_hashes(e, hashes_and_paid_amounts)),
-        }
-    }
+        fingerprints_recipient: Recipient<PendingPayableFingerprintSeeds>,
+        affordable_accounts: Vec<PayableAccount>,
+    ) -> Box<dyn Future<Item = Vec<ProcessedPayableFallible>, Error = PayableTransactionError>>
+    {
+        let consuming_wallet = agent.consuming_wallet().clone();
+        let web3_batch = self.lower_interface().get_web3_batch();
+        let get_transaction_id = self
+            .lower_interface()
+            .get_transaction_id(consuming_wallet.address());
+        let gas_price_wei = agent.agreed_fee_per_computation_unit();
+        let chain = agent.get_chain();
 
-    fn get_transaction_receipt(&self, hash: H256) -> ResultForReceipt {
-        self.web3
-            .eth()
-            .transaction_receipt(hash)
-            .map_err(|e| BlockchainError::QueryFailed(e.to_string()))
-            .wait()
+        Box::new(
+            get_transaction_id
+                .map_err(PayableTransactionError::TransactionID)
+                .and_then(move |pending_nonce| {
+                    send_payables_within_batch(
+                        &logger,
+                        chain,
+                        &web3_batch,
+                        consuming_wallet,
+                        gas_price_wei,
+                        pending_nonce,
+                        fingerprints_recipient,
+                        affordable_accounts,
+                    )
+                }),
+        )
     }
+}
 
-    fn lower_interface(&self) -> &dyn LowBlockchainInt {
-        &*self.lower_interface
-    }
+#[derive(Debug, Clone, PartialEq, Eq, Copy)]
+pub struct HashAndAmount {
+    pub hash: H256,
+    pub amount: u128,
 }
 
-impl<T> BlockchainInterfaceWeb3<T>
-where
-    T: 'static + BatchTransport + Debug,
-{
-    pub fn new(transport: T, event_loop_handle: EventLoopHandle, chain: Chain) -> Self {
-        let web3 = Rc::new(Web3::new(transport.clone()));
-        let web3_batch = Rc::new(Web3::new(Batch::new(transport)));
-        let batch_payable_tools = Box::new(BatchPayableToolsReal::<T>::default());
-        let contract =
-            Contract::from_json(web3.eth(), chain.rec().contract, CONTRACT_ABI.as_bytes())
-                .expect("Unable to initialize contract.");
-        let lower_level_blockchain_interface = Box::new(LowBlockchainIntWeb3::new(
-            Rc::clone(&web3),
-            Rc::clone(&web3_batch),
-            contract,
-        ));
+impl BlockchainInterfaceWeb3 {
+    pub fn new(transport: Http, event_loop_handle: EventLoopHandle, chain: Chain) -> Self {
         let gas_limit_const_part = Self::web3_gas_limit_const_part(chain);
 
         Self {
@@ -351,234 +290,11 @@ where
             chain,
             gas_limit_const_part,
             _event_loop_handle: event_loop_handle,
-            web3,
-            web3_batch,
-            lower_interface: lower_level_blockchain_interface,
-            batch_payable_tools,
-        }
-    }
-
-    fn sign_and_append_multiple_payments(
-        &self,
-        consuming_wallet: &Wallet,
-        gas_price: u64,
-        pending_nonce: U256,
-        accounts: &[PayableAccount],
-    ) -> HashAndAmountResult {
-        let init: (HashAndAmountResult, Option<U256>) =
-            (Ok(Vec::with_capacity(accounts.len())), Some(pending_nonce));
-
-        let (result, _) = accounts.iter().fold(
-            init,
-            |(processed_outputs_res, pending_nonce_opt), account| {
-                if let Ok(hashes_and_amounts) = processed_outputs_res {
-                    self.handle_payable_account(
-                        pending_nonce_opt,
-                        hashes_and_amounts,
-                        consuming_wallet,
-                        gas_price,
-                        account,
-                    )
-                } else {
-                    (processed_outputs_res, None)
-                }
-            },
-        );
-        result
-    }
-
-    fn handle_payable_account(
-        &self,
-        pending_nonce_opt: Option<U256>,
-        hashes_and_amounts: Vec<(H256, u128)>,
-        consuming_wallet: &Wallet,
-        gas_price: u64,
-        account: &PayableAccount,
-    ) -> (HashAndAmountResult, Option<U256>) {
-        let nonce = pending_nonce_opt.expectv("pending nonce");
-        let updated_collected_attributes_of_processed_payments = self.sign_and_append_payment(
-            hashes_and_amounts,
-            consuming_wallet,
-            nonce,
-            gas_price,
-            account,
-        );
-        let advanced_nonce = Self::advance_used_nonce(nonce);
-        (
-            updated_collected_attributes_of_processed_payments,
-            Some(advanced_nonce),
-        )
-    }
-
-    fn sign_and_append_payment(
-        &self,
-        mut hashes_and_amounts: Vec<(H256, u128)>,
-        consuming_wallet: &Wallet,
-        nonce: U256,
-        gas_price: u64,
-        account: &PayableAccount,
-    ) -> HashAndAmountResult {
-        debug!(
-            self.logger,
-            "Preparing payment of {} wei to {} with nonce {}",
-            account.balance_wei.separate_with_commas(),
-            account.wallet,
-            nonce
-        );
-
-        match self.handle_new_transaction(
-            &account.wallet,
-            consuming_wallet,
-            account.balance_wei,
-            nonce,
-            gas_price,
-        ) {
-            Ok(new_hash) => {
-                hashes_and_amounts.push((new_hash, account.balance_wei));
-                Ok(hashes_and_amounts)
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    fn advance_used_nonce(current_nonce: U256) -> U256 {
-        current_nonce
-            .checked_add(U256::one())
-            .expect("unexpected limits")
-    }
-
-    fn merged_output_data(
-        responses: Vec<web3::transports::Result<Value>>,
-        hashes_and_paid_amounts: Vec<(H256, u128)>,
-        accounts: &[PayableAccount],
-    ) -> Vec<ProcessedPayableFallible> {
-        let iterator_with_all_data = responses
-            .into_iter()
-            .zip(hashes_and_paid_amounts.into_iter())
-            .zip(accounts.iter());
-        iterator_with_all_data
-            .map(|((rpc_result, (hash, _)), account)| match rpc_result {
-                Ok(_) => Ok(PendingPayable {
-                    recipient_wallet: account.wallet.clone(),
-                    hash,
-                }),
-                Err(rpc_error) => Err(RpcPayablesFailure {
-                    rpc_error,
-                    recipient_wallet: account.wallet.clone(),
-                    hash,
-                }),
-            })
-            .collect()
-    }
-
-    fn error_with_hashes(
-        error: Error,
-        hashes_and_paid_amounts: Vec<(H256, u128)>,
-    ) -> PayableTransactionError {
-        let hashes = hashes_and_paid_amounts
-            .into_iter()
-            .map(|(hash, _)| hash)
-            .collect();
-        PayableTransactionError::Sending {
-            msg: error.to_string(),
-            hashes,
+            transport,
         }
     }
 
-    fn handle_new_transaction<'a>(
-        &self,
-        recipient: &'a Wallet,
-        consuming_wallet: &'a Wallet,
-        amount: u128,
-        nonce: U256,
-        gas_price: u64,
-    ) -> Result<H256, PayableTransactionError> {
-        let signed_tx =
-            self.sign_transaction(recipient, consuming_wallet, amount, nonce, gas_price)?;
-        self.batch_payable_tools
-            .append_transaction_to_batch(signed_tx.raw_transaction, &self.web3_batch);
-        Ok(signed_tx.transaction_hash)
-    }
-
-    fn sign_transaction<'a>(
-        &self,
-        recipient: &'a Wallet,
-        consuming_wallet: &'a Wallet,
-        amount: u128,
-        nonce: U256,
-        gas_price: u64,
-    ) -> Result<SignedTransaction, PayableTransactionError> {
-        let data = Self::transaction_data(recipient, amount);
-        let gas_limit = self.compute_gas_limit(data.as_slice());
-        let gas_price = gwei_to_wei::<U256, _>(gas_price);
-        let transaction_parameters = TransactionParameters {
-            nonce: Some(nonce),
-            to: Some(H160(self.contract_address().0)),
-            gas: gas_limit,
-            gas_price: Some(gas_price),
-            value: ethereum_types::U256::zero(),
-            data: Bytes(data.to_vec()),
-            chain_id: Some(self.chain.rec().num_chain_id),
-        };
-
-        let key = match consuming_wallet.prepare_secp256k1_secret() {
-            Ok(secret) => secret,
-            Err(e) => return Err(PayableTransactionError::UnusableWallet(e.to_string())),
-        };
-
-        self.batch_payable_tools
-            .sign_transaction(transaction_parameters, &self.web3_batch, &key)
-            .map_err(|e| PayableTransactionError::Signing(e.to_string()))
-    }
-
-    fn transmission_log(&self, accounts: &[PayableAccount], gas_price: u64) -> String {
-        let chain_name = self
-            .chain
-            .rec()
-            .literal_identifier
-            .chars()
-            .skip_while(|char| char != &'-')
-            .skip(1)
-            .collect::<String>();
-        let introduction = once(format!(
-            "\
-        Paying to creditors...\n\
-        Transactions in the batch:\n\
-        \n\
-        gas price:                                   {} gwei\n\
-        chain:                                       {}\n\
-        \n\
-        [wallet address]                             [payment in wei]\n",
-            gas_price, chain_name
-        ));
-        let body = accounts.iter().map(|account| {
-            format!(
-                "{}   {}\n",
-                account.wallet,
-                account.balance_wei.separate_with_commas()
-            )
-        });
-        introduction.chain(body).collect()
-    }
-
-    fn transaction_data(recipient: &Wallet, amount: u128) -> [u8; 68] {
-        let mut data = [0u8; 4 + 32 + 32];
-        data[0..4].copy_from_slice(&TRANSFER_METHOD_ID);
-        data[16..36].copy_from_slice(&recipient.address().0[..]);
-        U256::try_from(amount)
-            .expect("shouldn't overflow")
-            .to_big_endian(&mut data[36..68]);
-        data
-    }
-
-    fn compute_gas_limit(&self, data: &[u8]) -> U256 {
-        ethereum_types::U256::try_from(data.iter().fold(self.gas_limit_const_part, |acc, v| {
-            acc + if v == &0u8 { 4 } else { 68 }
-        }))
-        .expect("Internal error")
-    }
-
-    fn web3_gas_limit_const_part(chain: Chain) -> u64 {
+    pub fn web3_gas_limit_const_part(chain: Chain) -> u128 {
         match chain {
             Chain::EthMainnet | Chain::EthRopsten | Chain::Dev => 55_000,
             Chain::PolyMainnet | Chain::PolyAmoy | Chain::BaseMainnet | Chain::BaseSepolia => {
@@ -587,7 +303,7 @@ where
         }
     }
 
-    fn extract_transactions_from_logs(&self, logs: Vec<Log>) -> Vec<BlockchainTransaction> {
+    fn extract_transactions_from_logs(logs: Vec<Log>) -> Vec<BlockchainTransaction> {
         logs.iter()
             .filter_map(|log: &Log| match log.block_number {
                 None => None,
@@ -603,96 +319,148 @@ where
             .collect()
     }
 
-    fn find_largest_transaction_block_number(
-        &self,
-        response_block_number: Option<u64>,
+    fn find_highest_block_marker_from_txs(transactions: &[BlockchainTransaction]) -> BlockMarker {
+        transactions
+            .iter()
+            .fold(BlockMarker::Uninitialized, |max, tx| match max {
+                BlockMarker::Value(current_max) => {
+                    BlockMarker::Value(current_max.max(tx.block_number))
+                }
+                BlockMarker::Uninitialized => BlockMarker::Value(tx.block_number),
+            })
+    }
+
+    fn find_new_start_block(
         transactions: &[BlockchainTransaction],
-    ) -> Option<u64> {
-        if transactions.is_empty() {
-            response_block_number
+        start_block_marker: BlockMarker,
+        end_block_marker: BlockMarker,
+        logger: &Logger,
+    ) -> u64 {
+        match end_block_marker {
+            BlockMarker::Value(end_block_number) => end_block_number + 1,
+            BlockMarker::Uninitialized => {
+                match Self::find_highest_block_marker_from_txs(transactions) {
+                    BlockMarker::Value(block_number) => {
+                        debug!(
+                            logger,
+                            "Discovered new start block number from transaction logs: {:?}",
+                            block_number + 1
+                        );
+
+                        block_number + 1
+                    }
+                    BlockMarker::Uninitialized => match start_block_marker {
+                        BlockMarker::Value(start_block) => start_block + 1,
+                        BlockMarker::Uninitialized => FRESH_START_BLOCK,
+                    },
+                }
+            }
+        }
+    }
+
+    fn calculate_end_block_marker(
+        start_block: u64,
+        scan_range: BlockScanRange,
+        response_block_number_result: Result<U64, BlockchainError>,
+        logger: &Logger,
+    ) -> BlockMarker {
+        let local_end_block_marker = match scan_range {
+            BlockScanRange::NoLimit => BlockMarker::Uninitialized,
+            BlockScanRange::Range(scan_range_number) => {
+                BlockMarker::Value(start_block + scan_range_number)
+            }
+        };
+
+        match response_block_number_result {
+            Ok(response_block) => {
+                let response_block = response_block.as_u64();
+                match local_end_block_marker {
+                    BlockMarker::Uninitialized => BlockMarker::Value(response_block),
+                    BlockMarker::Value(local_end_block_number) => {
+                        BlockMarker::Value(local_end_block_number.min(response_block))
+                    }
+                }
+            }
+            Err(e) => {
+                debug!(
+                    logger,
+                    "Using locally calculated end block number: '{:?}' due to error {:?}",
+                    local_end_block_marker,
+                    e
+                );
+                local_end_block_marker
+            }
+        }
+    }
+
+    fn handle_transaction_logs(
+        logs_result: Result<Vec<Log>, BlockchainError>,
+        logger: &Logger,
+    ) -> Result<Vec<BlockchainTransaction>, BlockchainError> {
+        let logs = logs_result?;
+        let logs_len = logs.len();
+        if logs
+            .iter()
+            .any(|log| log.topics.len() < 2 || log.data.0.len() > 32)
+        {
+            warning!(
+                logger,
+                "Invalid response from blockchain server: {:?}",
+                logs
+            );
+            Err(BlockchainError::InvalidResponse)
         } else {
-            transactions
-                .iter()
-                .fold(response_block_number.unwrap_or(0u64), |a, b| {
-                    a.max(b.block_number)
-                })
-                .into()
+            let transactions: Vec<BlockchainTransaction> =
+                Self::extract_transactions_from_logs(logs);
+            debug!(logger, "Retrieved transactions: {:?}", transactions);
+            if transactions.is_empty() && logs_len != transactions.len() {
+                warning!(
+                    logger,
+                    "Retrieving transactions: logs: {}, transactions: {}",
+                    logs_len,
+                    transactions.len()
+                )
+            }
+
+            Ok(transactions)
         }
     }
 }
 
-type HashAndAmountResult = Result<Vec<(H256, u128)>, PayableTransactionError>;
-
 #[cfg(test)]
 mod tests {
-    use crate::accountant::db_access_objects::utils::from_time_t;
-    use crate::accountant::gwei_to_wei;
+    use super::*;
     use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::agent_web3::WEB3_MAXIMAL_GAS_LIMIT_MARGIN;
-    use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
-    use crate::accountant::test_utils::{
-        make_payable_account, make_payable_account_with_wallet_and_balance_and_timestamp_opt,
-    };
-    use crate::blockchain::bip32::Bip32EncryptionKeyProvider;
-    use crate::blockchain::blockchain_bridge::PendingPayableFingerprintSeeds;
-
     use crate::blockchain::blockchain_interface::blockchain_interface_web3::{
         BlockchainInterfaceWeb3, CONTRACT_ABI, REQUESTS_IN_PARALLEL, TRANSACTION_LITERAL,
         TRANSFER_METHOD_ID,
     };
-    use crate::blockchain::blockchain_interface::test_utils::{
-        test_blockchain_interface_is_connected_and_functioning, LowBlockchainIntMock,
-    };
+    use crate::blockchain::blockchain_interface::data_structures::errors::BlockchainError::QueryFailed;
+    use crate::blockchain::blockchain_interface::data_structures::BlockchainTransaction;
     use crate::blockchain::blockchain_interface::{
-        BlockchainAgentBuildError, BlockchainError, BlockchainInterface, PayableTransactionError,
+        BlockchainAgentBuildError, BlockchainError, BlockchainInterface,
         RetrievedBlockchainTransactions,
     };
     use crate::blockchain::test_utils::{
-        all_chains, make_fake_event_loop_handle, make_tx_hash, TestTransport,
+        all_chains, make_blockchain_interface_web3, ReceiptResponseBuilder,
     };
-    use crate::db_config::persistent_configuration::PersistentConfigError;
     use crate::sub_lib::blockchain_bridge::ConsumingWalletBalances;
     use crate::sub_lib::wallet::Wallet;
-    use crate::test_utils::assert_string_contains;
-    use crate::test_utils::http_test_server::TestServer;
-    use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock;
-    use crate::test_utils::recorder::{make_recorder, Recorder};
-    use crate::test_utils::unshared_test_utils::decode_hex;
-    use crate::test_utils::{make_paying_wallet, make_wallet, TestRawTransaction};
-    use actix::{Actor, System};
-    use ethereum_types::U64;
+    use crate::test_utils::make_paying_wallet;
+    use crate::test_utils::make_wallet;
     use ethsign_crypto::Keccak256;
     use futures::Future;
-    use jsonrpc_core::Version::V2;
-    use jsonrpc_core::{Call, Error as RPCError, ErrorCode, Id, MethodCall, Params};
     use masq_lib::blockchains::chains::Chain;
-    use masq_lib::logger::Logger;
     use masq_lib::test_utils::logging::{init_test_logging, TestLogHandler};
+    use masq_lib::test_utils::mock_blockchain_client_server::MBCSBuilder;
     use masq_lib::test_utils::utils::TEST_DEFAULT_CHAIN;
     use masq_lib::utils::find_free_port;
-    use serde_derive::Deserialize;
-    use serde_json::{json, Value};
     use std::net::Ipv4Addr;
-
-    use crate::accountant::db_access_objects::payable_dao::PayableAccount;
-    use crate::accountant::db_access_objects::pending_payable_dao::PendingPayable;
-    use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::test_utils::BlockchainAgentMock;
-    use crate::blockchain::blockchain_interface::blockchain_interface_web3::test_utils::{
-        make_default_signed_transaction, BatchPayableToolsMock,
-    };
-    use crate::blockchain::blockchain_interface::data_structures::{
-        BlockchainTransaction, RpcPayablesFailure,
-    };
-    use indoc::indoc;
-    use sodiumoxide::hex;
     use std::str::FromStr;
-    use std::sync::{Arc, Mutex};
-    use std::time::SystemTime;
-    use web3::transports::{Batch, Http};
-    use web3::types::{
-        Address, BlockNumber, Bytes, TransactionParameters, TransactionReceipt, H2048, H256, U256,
-    };
-    use web3::Error as Web3Error;
-    use web3::Web3;
+    use web3::transports::Http;
+    use web3::types::{H256, U256};
+    use masq_lib::constants::POLYGON_MAINNET_CONTRACT_CREATION_BLOCK;
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{TransactionBlock, TxReceipt, TxStatus};
 
     #[test]
     fn constants_are_correct() {
@@ -726,54 +494,104 @@ mod tests {
         assert_eq!(TRANSACTION_LITERAL, transaction_literal_expected);
         assert_eq!(TRANSFER_METHOD_ID, [0xa9, 0x05, 0x9c, 0xbb]);
         assert_eq!(REQUESTS_IN_PARALLEL, 1);
+        assert_eq!(
+            TRANSFER_METHOD_ID,
+            "transfer(address,uint256)".keccak256()[0..4],
+        );
+        assert_eq!(FRESH_START_BLOCK, 0);
     }
 
     #[test]
     fn blockchain_interface_web3_can_return_contract() {
         all_chains().iter().for_each(|chain| {
-            let subject = BlockchainInterfaceWeb3::new(
-                TestTransport::default(),
-                make_fake_event_loop_handle(),
-                *chain,
-            );
+            let mut subject = make_blockchain_interface_web3(find_free_port());
+            subject.chain = *chain;
 
             assert_eq!(subject.contract_address(), chain.rec().contract)
         })
     }
 
     #[test]
-    fn blockchain_interface_web3_provides_plain_rp_calls_correctly() {
-        let subject_factory = |port: u16, _chain: Chain| {
-            let chain = Chain::PolyMainnet;
-            let (event_loop_handle, transport) = Http::with_max_parallel(
-                &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
-                REQUESTS_IN_PARALLEL,
-            )
-            .unwrap();
-            Box::new(BlockchainInterfaceWeb3::new(
-                transport,
-                event_loop_handle,
-                chain,
-            )) as Box<dyn BlockchainInterface>
-        };
-
-        test_blockchain_interface_is_connected_and_functioning(subject_factory)
-    }
-
-    #[test]
-    fn blockchain_interface_web3_retrieves_transactions() {
+    fn blockchain_interface_web3_retrieves_transactions_works() {
+        let start_block_marker = BlockMarker::Value(42);
+        let scan_range = BlockScanRange::Range(1000);
+        let block_response = "0x7d0"; // 2_000
+        let expected_new_start_block = 42 + 1000 + 1;
+        let expected_log = "from start block: 42 to end block: Number(1042)";
+        assert_on_retrieves_transactions(
+            start_block_marker,
+            scan_range,
+            block_response,
+            expected_new_start_block,
+            expected_log,
+        );
+
+        let start_block_marker = BlockMarker::Uninitialized;
+        let scan_range = BlockScanRange::Range(1000);
+        let block_response = "0xe2f432"; // 14_873_650
+        let expected_new_start_block = POLYGON_MAINNET_CONTRACT_CREATION_BLOCK + 1000 + 1;
+        let expected_log = &format!(
+            "from start block: {POLYGON_MAINNET_CONTRACT_CREATION_BLOCK} to end block: Number({})",
+            POLYGON_MAINNET_CONTRACT_CREATION_BLOCK + 1000
+        );
+        assert_on_retrieves_transactions(
+            start_block_marker,
+            scan_range,
+            block_response,
+            expected_new_start_block,
+            expected_log,
+        );
+
+        let start_block_marker = BlockMarker::Value(42);
+        let scan_range = BlockScanRange::NoLimit;
+        let block_response = "0x7d0"; // 2_000
+        let expected_new_start_block = 2_000 + 1;
+        let expected_log = "from start block: 42 to end block: Number(2000)";
+        assert_on_retrieves_transactions(
+            start_block_marker,
+            scan_range,
+            block_response,
+            expected_new_start_block,
+            expected_log,
+        );
+
+        let start_block_marker = BlockMarker::Value(42);
+        let scan_range = BlockScanRange::NoLimit;
+        let block_response = "trash";
+        let expected_new_start_block = 49; // 48 was the highest number present in the transactions
+        let expected_log = "from start block: 42 to end block: Latest";
+        assert_on_retrieves_transactions(
+            start_block_marker,
+            scan_range,
+            block_response,
+            expected_new_start_block,
+            expected_log,
+        );
+    }
+
+    fn assert_on_retrieves_transactions(
+        start_block_marker: BlockMarker,
+        scan_range: BlockScanRange,
+        block_response: &str,
+        expected_new_start_block: u64,
+        expected_log: &str,
+    ) {
+        init_test_logging();
+        let test_name = "blockchain_interface_web3_retrieves_transactions";
         let to = "0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc";
         let port = find_free_port();
         #[rustfmt::skip]
-        let test_server = TestServer::start (port, vec![
-            br#"[{"jsonrpc":"2.0","id":2,"result":"0x400"},{
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response(block_response, 1)// 2000
+            .raw_response(
+                r#"{
                 "jsonrpc":"2.0",
                 "id":3,
                 "result":[
                     {
                         "address":"0xcd6c588e005032dd882cd43bf53a32129be81302",
                         "blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a",
-                        "blockNumber":"0x4be663",
+                        "blockNumber":"0x2e",
                         "data":"0x0000000000000000000000000000000000000000000000000010000000000000",
                         "logIndex":"0x0",
                         "removed":false,
@@ -788,7 +606,7 @@ mod tests {
                     {
                         "address":"0xcd6c588e005032dd882cd43bf53a32129be81302",
                         "blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732b",
-                        "blockNumber":"0x4be662",
+                        "blockNumber":"0x30",
                         "data":"0x0000000000000000000000000000000000000000000000000010000000000000",
                         "logIndex":"0x0",
                         "removed":false,
@@ -801,156 +619,99 @@ mod tests {
                         "transactionIndex":"0x0"
                     }
                 ]
-            }]"#.to_vec(),
-        ]);
-        let (event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain);
-        let end_block_nbr = 1024u64;
+            }"#.to_string()
+            )
+            .start();
+        let mut subject = make_blockchain_interface_web3(port);
+        subject.logger = Logger::new(test_name);
 
         let result = subject
             .retrieve_transactions(
-                BlockNumber::Number(42u64.into()),
-                BlockNumber::Number(end_block_nbr.into()),
-                &Wallet::from_str(&to).unwrap(),
+                start_block_marker,
+                scan_range,
+                Wallet::from_str(&to).unwrap().address(),
             )
+            .wait()
             .unwrap();
 
-        let requests = test_server.requests_so_far();
-        let bodies: Vec<String> = requests
-            .into_iter()
-            .map(|request| serde_json::from_slice(&request.body()).unwrap())
-            .map(|b: Value| serde_json::to_string(&b).unwrap())
-            .collect();
-        let expected_body_prefix = r#"[{"id":0,"jsonrpc":"2.0","method":"eth_blockNumber","params":[]},{"id":1,"jsonrpc":"2.0","method":"eth_getLogs","params":[{"address":"0x384dec25e03f94931767ce4c3556168468ba24c3","fromBlock":"0x2a","toBlock":"0x400","topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",null,"0x000000000000000000000000"#;
-        let expected_body_suffix = r#""]}]}]"#;
-        let expected_body = format!(
-            "{}{}{}",
-            expected_body_prefix,
-            &to[2..],
-            expected_body_suffix
-        );
-        assert_eq!(bodies, vec!(expected_body));
         assert_eq!(
             result,
             RetrievedBlockchainTransactions {
-                new_start_block: BlockNumber::Number(0x4be664.into()),
+                new_start_block: expected_new_start_block,
                 transactions: vec![
                     BlockchainTransaction {
-                        block_number: 0x4be663,
+                        block_number: 46,
                         from: Wallet::from_str("0x3ab28ecedea6cdb6feed398e93ae8c7b316b1182")
                             .unwrap(),
                         wei_amount: 4_503_599_627_370_496u128,
                     },
                     BlockchainTransaction {
-                        block_number: 0x4be662,
+                        block_number: 48,
                         from: Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc")
                             .unwrap(),
                         wei_amount: 4_503_599_627_370_496u128,
                     },
                 ]
             }
-        )
+        );
+        TestLogHandler::new().exists_log_containing(&format!("DEBUG: {test_name}: Retrieving transactions {expected_log} for: 0x3f69…72fc chain_id: 137 contract: 0xee9a352f6aac4af1a5b9f467f6a93e0ffbe9dd35"));
     }
 
     #[test]
     fn blockchain_interface_web3_handles_no_retrieved_transactions() {
-        let to = "0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc";
+        let to_wallet = make_paying_wallet(b"test_wallet");
         let port = find_free_port();
-        let test_server = TestServer::start(
-            port,
-            vec![br#"[{"jsonrpc":"2.0","id":2,"result":"0x400"},{"jsonrpc":"2.0","id":3,"result":[]}]"#.to_vec()],
-        );
-        let (event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let subject =
-            BlockchainInterfaceWeb3::new(transport, event_loop_handle, TEST_DEFAULT_CHAIN);
-        let end_block_nbr = 1024u64;
+        let empty_transactions_result: Vec<String> = vec![];
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x178def".to_string(), 2)
+            .ok_response(empty_transactions_result, 2)
+            .start();
+        let subject = make_blockchain_interface_web3(port);
 
         let result = subject
             .retrieve_transactions(
-                BlockNumber::Number(42u64.into()),
-                BlockNumber::Number(end_block_nbr.into()),
-                &Wallet::from_str(&to).unwrap(),
+                BlockMarker::Value(42),
+                BlockScanRange::NoLimit,
+                to_wallet.address(),
             )
-            .unwrap();
+            .wait();
 
-        let requests = test_server.requests_so_far();
-        let bodies: Vec<String> = requests
-            .into_iter()
-            .map(|request| serde_json::from_slice(&request.body()).unwrap())
-            .map(|b: Value| serde_json::to_string(&b).unwrap())
-            .collect();
-        let expected_body_prefix = r#"[{"id":0,"jsonrpc":"2.0","method":"eth_blockNumber","params":[]},{"id":1,"jsonrpc":"2.0","method":"eth_getLogs","params":[{"address":"0x384dec25e03f94931767ce4c3556168468ba24c3","fromBlock":"0x2a","toBlock":"0x400","topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",null,"0x000000000000000000000000"#;
-        let expected_body_suffix = r#""]}]}]"#;
-        let expected_body = format!(
-            "{}{}{}",
-            expected_body_prefix,
-            &to[2..],
-            expected_body_suffix
-        );
-        assert_eq!(bodies, vec!(expected_body));
         assert_eq!(
             result,
-            RetrievedBlockchainTransactions {
-                new_start_block: BlockNumber::Number((1 + end_block_nbr).into()),
+            Ok(RetrievedBlockchainTransactions {
+                new_start_block: 1543664,
                 transactions: vec![]
-            }
+            })
         );
     }
 
     #[test]
     #[should_panic(expected = "No address for an uninitialized wallet!")]
-    fn blockchain_interface_web3_retrieve_transactions_returns_an_error_if_the_to_address_is_invalid(
-    ) {
-        let port = find_free_port();
-        let (event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain);
+    fn retrieving_address_of_uninitialised_wallet_panics() {
+        let subject = Wallet::new("0x3f69f9efd4f2592fd70beecd9dce71c472fc");
 
-        let result = subject.retrieve_transactions(
-            BlockNumber::Number(42u64.into()),
-            BlockNumber::Latest,
-            &Wallet::new("0x3f69f9efd4f2592fd70beecd9dce71c472fc"),
-        );
-
-        assert_eq!(
-            result.expect_err("Expected an Err, got Ok"),
-            BlockchainError::InvalidAddress
-        );
+        subject.address();
     }
 
     #[test]
     fn blockchain_interface_web3_retrieve_transactions_returns_an_error_if_a_response_with_too_few_topics_is_returned(
     ) {
         let port = find_free_port();
-        let _test_server = TestServer::start (port, vec![
-            br#"[{"jsonrpc":"2.0","id":2,"result":"0x400"},{"jsonrpc":"2.0","id":3,"result":[{"address":"0xcd6c588e005032dd882cd43bf53a32129be81302","blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a","blockNumber":"0x4be663","data":"0x0000000000000000000000000000000000000000000000056bc75e2d63100000","logIndex":"0x0","removed":false,"topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"],"transactionHash":"0x955cec6ac4f832911ab894ce16aa22c3003f46deff3f7165b32700d2f5ff0681","transactionIndex":"0x0"}]}]"#.to_vec()
-        ]);
-        let (event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain);
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x178def", 1)
+            .raw_response(r#"{"jsonrpc":"2.0","id":3,"result":[{"address":"0xcd6c588e005032dd882cd43bf53a32129be81302","blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a","blockNumber":"0x4be663","data":"0x0000000000000000000000000000000000000000000000056bc75e2d63100000","logIndex":"0x0","removed":false,"topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"],"transactionHash":"0x955cec6ac4f832911ab894ce16aa22c3003f46deff3f7165b32700d2f5ff0681","transactionIndex":"0x0"}]}"#.to_string())
+            .start();
+        let subject = make_blockchain_interface_web3(port);
 
-        let result = subject.retrieve_transactions(
-            BlockNumber::Number(42u64.into()),
-            BlockNumber::Latest,
-            &Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap(),
-        );
+        let result = subject
+            .retrieve_transactions(
+                BlockMarker::Value(42),
+                BlockScanRange::NoLimit,
+                Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc")
+                    .unwrap()
+                    .address(),
+            )
+            .wait();
 
         assert_eq!(
             result.expect_err("Expected an Err, got Ok"),
@@ -962,22 +723,21 @@ mod tests {
     fn blockchain_interface_web3_retrieve_transactions_returns_an_error_if_a_response_with_data_that_is_too_long_is_returned(
     ) {
         let port = find_free_port();
-        let _test_server = TestServer::start(port, vec![
-            br#"[{"jsonrpc":"2.0","id":2,"result":"0x400"},{"jsonrpc":"2.0","id":3,"result":[{"address":"0xcd6c588e005032dd882cd43bf53a32129be81302","blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a","blockNumber":"0x4be663","data":"0x0000000000000000000000000000000000000000000000056bc75e2d6310000001","logIndex":"0x0","removed":false,"topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000003f69f9efd4f2592fd70be8c32ecd9dce71c472fc","0x000000000000000000000000adc1853c7859369639eb414b6342b36288fe6092"],"transactionHash":"0x955cec6ac4f832911ab894ce16aa22c3003f46deff3f7165b32700d2f5ff0681","transactionIndex":"0x0"}]}]"#.to_vec()
-        ]);
-        let (event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain);
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x178def", 1)
+            .raw_response(r#"{"jsonrpc":"2.0","id":3,"result":[{"address":"0xcd6c588e005032dd882cd43bf53a32129be81302","blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a","blockNumber":"0x4be663","data":"0x0000000000000000000000000000000000000000000000056bc75e2d6310000001","logIndex":"0x0","removed":false,"topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000003f69f9efd4f2592fd70be8c32ecd9dce71c472fc","0x000000000000000000000000adc1853c7859369639eb414b6342b36288fe6092"],"transactionHash":"0x955cec6ac4f832911ab894ce16aa22c3003f46deff3f7165b32700d2f5ff0681","transactionIndex":"0x0"}]}"#.to_string())
+            .start();
+        let subject = make_blockchain_interface_web3(port);
 
-        let result = subject.retrieve_transactions(
-            BlockNumber::Number(42u64.into()),
-            BlockNumber::Latest,
-            &Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap(),
-        );
+        let result = subject
+            .retrieve_transactions(
+                BlockMarker::Uninitialized,
+                BlockScanRange::NoLimit,
+                Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc")
+                    .unwrap()
+                    .address(),
+            )
+            .wait();
 
         assert_eq!(result, Err(BlockchainError::InvalidResponse));
     }
@@ -986,9 +746,10 @@ mod tests {
     fn blockchain_interface_web3_retrieve_transactions_ignores_transaction_logs_that_have_no_block_number(
     ) {
         let port = find_free_port();
-        let _test_server = TestServer::start (port, vec![
-            br#"[{"jsonrpc":"2.0","id":1,"result":"0x400"},{"jsonrpc":"2.0","id":2,"result":[{"address":"0xcd6c588e005032dd882cd43bf53a32129be81302","blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a","data":"0x0000000000000000000000000000000000000000000000000010000000000000","logIndex":"0x0","removed":false,"topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000003f69f9efd4f2592fd70be8c32ecd9dce71c472fc","0x000000000000000000000000adc1853c7859369639eb414b6342b36288fe6092"],"transactionHash":"0x955cec6ac4f832911ab894ce16aa22c3003f46deff3f7165b32700d2f5ff0681","transactionIndex":"0x0"}]}]"#.to_vec()
-        ]);
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x400", 1)
+            .raw_response(r#"{"jsonrpc":"2.0","id":2,"result":[{"address":"0xcd6c588e005032dd882cd43bf53a32129be81302","blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a","data":"0x0000000000000000000000000000000000000000000000000010000000000000","logIndex":"0x0","removed":false,"topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000003f69f9efd4f2592fd70be8c32ecd9dce71c472fc","0x000000000000000000000000adc1853c7859369639eb414b6342b36288fe6092"],"transactionHash":"0x955cec6ac4f832911ab894ce16aa22c3003f46deff3f7165b32700d2f5ff0681","transactionIndex":"0x0"}]}"#.to_string())
+            .start();
         init_test_logging();
         let (event_loop_handle, transport) = Http::with_max_parallel(
             &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
@@ -996,20 +757,24 @@ mod tests {
         )
         .unwrap();
 
-        let end_block_nbr = 1024u64;
+        let end_block_nbr = 1025u64;
         let subject =
             BlockchainInterfaceWeb3::new(transport, event_loop_handle, TEST_DEFAULT_CHAIN);
 
-        let result = subject.retrieve_transactions(
-            BlockNumber::Number(42u64.into()),
-            BlockNumber::Number(end_block_nbr.into()),
-            &Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap(),
-        );
+        let result = subject
+            .retrieve_transactions(
+                BlockMarker::Value(42),
+                BlockScanRange::Range(1000),
+                Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc")
+                    .unwrap()
+                    .address(),
+            )
+            .wait();
 
         assert_eq!(
             result,
             Ok(RetrievedBlockchainTransactions {
-                new_start_block: BlockNumber::Number((1 + end_block_nbr).into()),
+                new_start_block: end_block_nbr,
                 transactions: vec![]
             })
         );
@@ -1023,67 +788,29 @@ mod tests {
     fn blockchain_interface_non_clandestine_retrieve_transactions_uses_block_number_latest_as_fallback_start_block_plus_one(
     ) {
         let port = find_free_port();
-        let _test_server = TestServer::start (port, vec![
-            br#"[{"jsonrpc":"2.0","id":1,"result":"error"},{"jsonrpc":"2.0","id":2,"result":[{"address":"0xcd6c588e005032dd882cd43bf53a32129be81302","blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a","data":"0x0000000000000000000000000000000000000000000000000010000000000000","logIndex":"0x0","removed":false,"topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000003f69f9efd4f2592fd70be8c32ecd9dce71c472fc","0x000000000000000000000000adc1853c7859369639eb414b6342b36288fe6092"],"transactionHash":"0x955cec6ac4f832911ab894ce16aa22c3003f46deff3f7165b32700d2f5ff0681","transactionIndex":"0x0"}]}]"#.to_vec()
-        ]);
-        let (event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain);
-
-        let start_block = BlockNumber::Number(42u64.into());
-        let result = subject.retrieve_transactions(
-            start_block,
-            BlockNumber::Latest,
-            &Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap(),
-        );
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("trash", 1)
+            .raw_response(r#"{"jsonrpc":"2.0","id":2,"result":[{"address":"0xcd6c588e005032dd882cd43bf53a32129be81302","blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a","data":"0x0000000000000000000000000000000000000000000000000010000000000000","logIndex":"0x0","removed":false,"topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000003f69f9efd4f2592fd70be8c32ecd9dce71c472fc","0x000000000000000000000000adc1853c7859369639eb414b6342b36288fe6092"],"transactionHash":"0x955cec6ac4f832911ab894ce16aa22c3003f46deff3f7165b32700d2f5ff0681","transactionIndex":"0x0"}]}"#.to_string())
+            .start();
+        let subject = make_blockchain_interface_web3(port);
+        let start_block = 42u64;
+        let fallback_number = start_block;
 
-        let expected_fallback_start_block =
-            if let BlockNumber::Number(start_block_nbr) = start_block {
-                start_block_nbr.as_u64() + 1u64
-            } else {
-                panic!("start_block of Latest, Earliest, and Pending are not supported!")
-            };
+        let result = subject
+            .retrieve_transactions(
+                BlockMarker::Value(42),
+                BlockScanRange::NoLimit,
+                Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc")
+                    .unwrap()
+                    .address(),
+            )
+            .wait();
 
+        let expected_start_block = fallback_number + 1u64;
         assert_eq!(
             result,
             Ok(RetrievedBlockchainTransactions {
-                new_start_block: BlockNumber::Number((1 + expected_fallback_start_block).into()),
-                transactions: vec![]
-            })
-        );
-    }
-
-    #[test]
-    fn blockchain_interface_retrieve_transactions_start_and_end_blocks_can_be_latest() {
-        let port = find_free_port();
-        let contains_error_causing_to_pick_fallback_value = br#"[{"jsonrpc":"2.0","id":1,"result":"error"},{"jsonrpc":"2.0","id":2,"result":[{"address":"0xcd6c588e005032dd882cd43bf53a32129be81302","blockHash":"0x1a24b9169cbaec3f6effa1f600b70c7ab9e8e86db44062b49132a4415d26732a","data":"0x0000000000000000000000000000000000000000000000000010000000000000","logIndex":"0x0","removed":false,"topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000003f69f9efd4f2592fd70be8c32ecd9dce71c472fc","0x000000000000000000000000adc1853c7859369639eb414b6342b36288fe6092"],"transactionHash":"0x955cec6ac4f832911ab894ce16aa22c3003f46deff3f7165b32700d2f5ff0681","transactionIndex":"0x0"}]}]"#;
-        let _test_server = TestServer::start(
-            port,
-            vec![contains_error_causing_to_pick_fallback_value.to_vec()],
-        );
-        let (event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain);
-
-        let result = subject.retrieve_transactions(
-            BlockNumber::Latest,
-            BlockNumber::Latest,
-            &make_wallet("earning-wallet"),
-        );
-
-        let expected_new_start_block = BlockNumber::Latest;
-        assert_eq!(
-            result,
-            Ok(RetrievedBlockchainTransactions {
-                new_start_block: expected_new_start_block,
+                new_start_block: expected_start_block,
                 transactions: vec![]
             })
         );
@@ -1091,103 +818,61 @@ mod tests {
 
     #[test]
     fn blockchain_interface_web3_can_build_blockchain_agent() {
-        let get_transaction_fee_balance_params_arc = Arc::new(Mutex::new(vec![]));
-        let get_masq_balance_params_arc = Arc::new(Mutex::new(vec![]));
-        let get_transactions_id_params_arc = Arc::new(Mutex::new(vec![]));
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            // gas_price
+            .ok_response("0x3B9ACA00".to_string(), 0) // 1000000000
+            // transaction_fee_balance
+            .ok_response("0xFFF0".to_string(), 0) // 65520
+            // masq_balance
+            .ok_response(
+                "0x000000000000000000000000000000000000000000000000000000000000FFFF".to_string(), // 65535
+                0,
+            )
+            .start();
         let chain = Chain::PolyMainnet;
         let wallet = make_wallet("abc");
-        let persistent_config = PersistentConfigurationMock::new().gas_price_result(Ok(50));
-        let mut subject = BlockchainInterfaceWeb3::new(
-            TestTransport::default(),
-            make_fake_event_loop_handle(),
-            chain,
-        );
-        let transaction_fee_balance = U256::from(123_456_789);
-        let masq_balance = U256::from(444_444_444);
-        let transaction_id = U256::from(23);
-        let lower_blockchain_interface = LowBlockchainIntMock::default()
-            .get_transaction_fee_balance_params(&get_transaction_fee_balance_params_arc)
-            .get_transaction_fee_balance_result(Ok(transaction_fee_balance))
-            .get_masq_balance_params(&get_masq_balance_params_arc)
-            .get_masq_balance_result(Ok(masq_balance))
-            .get_transaction_id_params(&get_transactions_id_params_arc)
-            .get_transaction_id_result(Ok(transaction_id));
-        subject.lower_interface = Box::new(lower_blockchain_interface);
+        let subject = make_blockchain_interface_web3(port);
 
         let result = subject
-            .build_blockchain_agent(&wallet, &persistent_config)
+            .build_blockchain_agent(wallet.clone())
+            .wait()
             .unwrap();
 
-        let get_transaction_fee_balance_params =
-            get_transaction_fee_balance_params_arc.lock().unwrap();
-        assert_eq!(*get_transaction_fee_balance_params, vec![wallet.clone()]);
-        let get_masq_balance_params = get_masq_balance_params_arc.lock().unwrap();
-        assert_eq!(*get_masq_balance_params, vec![wallet.clone()]);
-        let get_transaction_id_params = get_transactions_id_params_arc.lock().unwrap();
-        assert_eq!(*get_transaction_id_params, vec![wallet.clone()]);
+        let expected_transaction_fee_balance = U256::from(65_520);
+        let expected_masq_balance = U256::from(65_535);
+        let expected_gas_price_wei = 1_000_000_000;
         assert_eq!(result.consuming_wallet(), &wallet);
-        assert_eq!(result.pending_transaction_id(), transaction_id);
         assert_eq!(
             result.consuming_wallet_balances(),
             ConsumingWalletBalances {
-                transaction_fee_balance_in_minor_units: transaction_fee_balance,
-                masq_token_balance_in_minor_units: masq_balance
+                transaction_fee_balance_in_minor_units: expected_transaction_fee_balance,
+                masq_token_balance_in_minor_units: expected_masq_balance
             }
         );
-        assert_eq!(result.agreed_fee_per_computation_unit(), 50);
+        assert_eq!(
+            result.agreed_fee_per_computation_unit(),
+            expected_gas_price_wei
+        );
         let expected_fee_estimation = (3
-            * (BlockchainInterfaceWeb3::<Http>::web3_gas_limit_const_part(chain)
+            * (BlockchainInterfaceWeb3::web3_gas_limit_const_part(chain)
                 + WEB3_MAXIMAL_GAS_LIMIT_MARGIN)
-            * 50) as u128;
+            * expected_gas_price_wei) as u128;
         assert_eq!(
             result.estimated_transaction_fee_total(3),
             expected_fee_estimation
         )
     }
 
-    #[test]
-    fn build_of_the_blockchain_agent_fails_on_fetching_gas_price() {
-        let chain = Chain::PolyAmoy;
-        let wallet = make_wallet("abc");
-        let persistent_config = PersistentConfigurationMock::new().gas_price_result(Err(
-            PersistentConfigError::UninterpretableValue("booga".to_string()),
-        ));
-        let subject = BlockchainInterfaceWeb3::new(
-            TestTransport::default(),
-            make_fake_event_loop_handle(),
-            chain,
-        );
-
-        let result = subject.build_blockchain_agent(&wallet, &persistent_config);
-
-        let err = match result {
-            Err(e) => e,
-            _ => panic!("we expected Err() but got Ok()"),
-        };
-        let expected_err = BlockchainAgentBuildError::GasPrice(
-            PersistentConfigError::UninterpretableValue("booga".to_string()),
-        );
-        assert_eq!(err, expected_err)
-    }
-
     fn build_of_the_blockchain_agent_fails_on_blockchain_interface_error<F>(
-        lower_blockchain_interface: LowBlockchainIntMock,
+        port: u16,
         expected_err_factory: F,
     ) where
         F: FnOnce(&Wallet) -> BlockchainAgentBuildError,
     {
-        let chain = Chain::EthMainnet;
         let wallet = make_wallet("bcd");
-        let persistent_config = PersistentConfigurationMock::new().gas_price_result(Ok(30));
-        let mut subject = BlockchainInterfaceWeb3::new(
-            TestTransport::default(),
-            make_fake_event_loop_handle(),
-            chain,
-        );
-        subject.lower_interface = Box::new(lower_blockchain_interface);
-
-        let result = subject.build_blockchain_agent(&wallet, &persistent_config);
-
+        let subject = make_blockchain_interface_web3(port);
+        let result = subject.build_blockchain_agent(wallet.clone()).wait();
         let err = match result {
             Err(e) => e,
             _ => panic!("we expected Err() but got Ok()"),
@@ -1197,465 +882,199 @@ mod tests {
     }
 
     #[test]
-    fn build_of_the_blockchain_agent_fails_on_transaction_fee_balance() {
-        let lower_interface = LowBlockchainIntMock::default()
-            .get_transaction_fee_balance_result(Err(BlockchainError::InvalidAddress));
-        let expected_err_factory = |wallet: &Wallet| {
-            BlockchainAgentBuildError::TransactionFeeBalance(
-                wallet.clone(),
-                BlockchainError::InvalidAddress,
-            )
-        };
+    fn build_of_the_blockchain_agent_fails_on_fetching_gas_price() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port).start();
+        let wallet = make_wallet("abc");
+        let subject = make_blockchain_interface_web3(port);
 
-        build_of_the_blockchain_agent_fails_on_blockchain_interface_error(
-            lower_interface,
-            expected_err_factory,
-        )
+        let err = subject.build_blockchain_agent(wallet).wait().err().unwrap();
+
+        let expected_err = BlockchainAgentBuildError::GasPrice(QueryFailed(
+            "Transport error: Error(IncompleteMessage)".to_string(),
+        ));
+        assert_eq!(err, expected_err)
     }
 
     #[test]
-    fn build_of_the_blockchain_agent_fails_on_masq_balance() {
-        let transaction_fee_balance = U256::from(123_456_789);
-        let lower_interface = LowBlockchainIntMock::default()
-            .get_transaction_fee_balance_result(Ok(transaction_fee_balance))
-            .get_masq_balance_result(Err(BlockchainError::InvalidResponse));
+    fn build_of_the_blockchain_agent_fails_on_transaction_fee_balance() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x3B9ACA00".to_string(), 0)
+            .start();
         let expected_err_factory = |wallet: &Wallet| {
-            BlockchainAgentBuildError::ServiceFeeBalance(
-                wallet.clone(),
-                BlockchainError::InvalidResponse,
+            BlockchainAgentBuildError::TransactionFeeBalance(
+                wallet.address(),
+                BlockchainError::QueryFailed(
+                    "Transport error: Error(IncompleteMessage)".to_string(),
+                ),
             )
         };
 
         build_of_the_blockchain_agent_fails_on_blockchain_interface_error(
-            lower_interface,
+            port,
             expected_err_factory,
-        )
+        );
     }
 
     #[test]
-    fn build_of_the_blockchain_agent_fails_on_transaction_id() {
-        let transaction_fee_balance = U256::from(123_456_789);
-        let masq_balance = U256::from(500_000_000);
-        let lower_interface = LowBlockchainIntMock::default()
-            .get_transaction_fee_balance_result(Ok(transaction_fee_balance))
-            .get_masq_balance_result(Ok(masq_balance))
-            .get_transaction_id_result(Err(BlockchainError::InvalidResponse));
+    fn build_of_the_blockchain_agent_fails_on_masq_balance() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x3B9ACA00".to_string(), 0)
+            .ok_response("0xFFF0".to_string(), 0)
+            .start();
         let expected_err_factory = |wallet: &Wallet| {
-            BlockchainAgentBuildError::TransactionID(
-                wallet.clone(),
-                BlockchainError::InvalidResponse,
+            BlockchainAgentBuildError::ServiceFeeBalance(
+                wallet.address(),
+                BlockchainError::QueryFailed(
+                    "Api error: Transport error: Error(IncompleteMessage)".to_string(),
+                ),
             )
         };
 
         build_of_the_blockchain_agent_fails_on_blockchain_interface_error(
-            lower_interface,
+            port,
             expected_err_factory,
         );
     }
 
     #[test]
-    fn blockchain_interface_web3_can_transfer_tokens_in_batch() {
-        //exercising also the layer of web3 functions, but the transport layer is mocked
-        init_test_logging();
-        let send_batch_params_arc = Arc::new(Mutex::new(vec![]));
-        //we compute the hashes ourselves during the batch preparation, and so we don't care about
-        //the same ones coming back with the response; we use the returned OKs as indicators of success only.
-        //Any eventual rpc errors brought back are processed as well...
-        let expected_batch_responses = vec![
-            Ok(json!("...unnecessarily important hash...")),
-            Err(web3::Error::Rpc(RPCError {
-                code: ErrorCode::ServerError(114),
-                message: "server being busy".to_string(),
-                data: None,
-            })),
-            Ok(json!("...unnecessarily important hash...")),
+    fn process_transaction_receipts_works() {
+        let port = find_free_port();
+        let tx_hash_1 =
+            H256::from_str("a128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0e")
+                .unwrap();
+        let tx_hash_2 =
+            H256::from_str("a128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0f")
+                .unwrap();
+        let tx_hash_3 =
+            H256::from_str("a128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0a")
+                .unwrap();
+        let tx_hash_4 =
+            H256::from_str("a128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0b")
+                .unwrap();
+        let tx_hash_5 =
+            H256::from_str("a128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0c")
+                .unwrap();
+        let tx_hash_6 =
+            H256::from_str("a128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0d")
+                .unwrap();
+        let tx_hash_vec = vec![
+            tx_hash_1, tx_hash_2, tx_hash_3, tx_hash_4, tx_hash_5, tx_hash_6,
         ];
-        let transport = TestTransport::default()
-            .send_batch_params(&send_batch_params_arc)
-            .send_batch_result(expected_batch_responses);
-        let (accountant, _, accountant_recording_arc) = make_recorder();
-        let actor_addr = accountant.start();
-        let fingerprint_recipient = recipient!(actor_addr, PendingPayableFingerprintSeeds);
-        let logger = Logger::new("sending_batch_payments");
-        let chain = TEST_DEFAULT_CHAIN;
-        let mut subject =
-            BlockchainInterfaceWeb3::new(transport.clone(), make_fake_event_loop_handle(), chain);
-        subject.logger = logger;
-        let amount_1 = gwei_to_wei(900_000_000_u64);
-        let account_1 = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
-            make_wallet("w123"),
-            amount_1,
-            None,
-        );
-        let amount_2 = 123_456_789;
-        let account_2 = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
-            make_wallet("w555"),
-            amount_2,
-            None,
-        );
-        let amount_3 = gwei_to_wei(33_355_666_u64);
-        let account_3 = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
-            make_wallet("w987"),
-            amount_3,
-            None,
-        );
-        let accounts_to_process = vec![account_1, account_2, account_3];
-        let consuming_wallet = make_paying_wallet(b"gdasgsa");
-        let agent = make_initialized_agent(120, consuming_wallet, U256::from(6));
-        let test_timestamp_before = SystemTime::now();
+        let block_hash =
+            H256::from_str("6d0abccae617442c26104c2bc63d1bc05e1e002e555aec4ab62a46e826b18f18")
+                .unwrap();
+        let block_number = U64::from_str("b0328d").unwrap();
+        let cumulative_gas_used = U256::from_str("60ef").unwrap();
+        let gas_used = U256::from_str("60ef").unwrap();
+        let status = U64::from(1);
+        let status_failed = U64::from(0);
+        let tx_receipt_response_not_present = ReceiptResponseBuilder::default()
+            .transaction_hash(tx_hash_4)
+            .build();
+        let tx_receipt_response_failed = ReceiptResponseBuilder::default()
+            .transaction_hash(tx_hash_5)
+            .status(status_failed)
+            .build();
+        let tx_receipt_response_success = ReceiptResponseBuilder::default()
+            .transaction_hash(tx_hash_6)
+            .block_hash(block_hash)
+            .block_number(block_number)
+            .cumulative_gas_used(cumulative_gas_used)
+            .gas_used(gas_used)
+            .status(status)
+            .build();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .begin_batch()
+            .err_response(
+                429,
+                "The requests per second (RPS) of your requests are higher than your plan allows."
+                    .to_string(),
+                7,
+            )
+            .raw_response(r#"{ "jsonrpc": "2.0", "id": 1, "result": null }"#.to_string())
+            .ok_response("trash".to_string(), 0)
+            .raw_response(tx_receipt_response_not_present)
+            .raw_response(tx_receipt_response_failed)
+            .raw_response(tx_receipt_response_success)
+            .end_batch()
+            .start();
+        let subject = make_blockchain_interface_web3(port);
 
         let result = subject
-            .send_batch_of_payables(agent, &fingerprint_recipient, &accounts_to_process)
+            .process_transaction_receipts(tx_hash_vec)
+            .wait()
             .unwrap();
 
-        let test_timestamp_after = SystemTime::now();
-        let system = System::new("can transfer tokens test");
-        System::current().stop();
-        assert_eq!(system.run(), 0);
-        let send_batch_params = send_batch_params_arc.lock().unwrap();
+        assert_eq!(result[0], TransactionReceiptResult::LocalError("RPC error: Error { code: ServerError(429), message: \"The requests per second (RPS) of your requests are higher than your plan allows.\", data: None }".to_string()));
         assert_eq!(
-            *send_batch_params,
-            vec![vec![
-                (
-                    1,
-                    Call::MethodCall(MethodCall {
-                        jsonrpc: Some(V2),
-                        method: "eth_sendRawTransaction".to_string(),
-                        params: Params::Array(vec![Value::String(
-                            "0xf8a906851bf08eb00082db6894384de\
-        c25e03f94931767ce4c3556168468ba24c380b844a9059cbb000000000000000000000000000000000000000000\
-        00000000000000773132330000000000000000000000000000000000000000000000000c7d713b49da00002aa06\
-        0b9f375c06f5641951606643d76ef999d32ae02f6b6cd62c9275ebdaa36a390a0199c3d8644c428efd5e0e0698c\
-        031172ac6873037d90dcca36a1fbf2e67960ff"
-                                .to_string()
-                        )]),
-                        id: Id::Num(1)
-                    })
-                ),
-                (
-                    2,
-                    Call::MethodCall(MethodCall {
-                        jsonrpc: Some(V2),
-                        method: "eth_sendRawTransaction".to_string(),
-                        params: Params::Array(vec![Value::String(
-                            "0xf8a907851bf08eb00082dae894384de\
-        c25e03f94931767ce4c3556168468ba24c380b844a9059cbb000000000000000000000000000000000000000000\
-        000000000000007735353500000000000000000000000000000000000000000000000000000000075bcd1529a00\
-        e61352bb2ac9b32b411206250f219b35cdc85db679f3e2416daac4f730a12f1a02c2ad62759d86942f3af2b8915\
-        ecfbaa58268010e00d32c18a49a9fc3b9bd20a"
-                                .to_string()
-                        )]),
-                        id: Id::Num(1)
-                    })
-                ),
-                (
-                    3,
-                    Call::MethodCall(MethodCall {
-                        jsonrpc: Some(V2),
-                        method: "eth_sendRawTransaction".to_string(),
-                        params: Params::Array(vec![Value::String(
-                            "0xf8a908851bf08eb00082db6894384de\
-        c25e03f94931767ce4c3556168468ba24c380b844a9059cbb000000000000000000000000000000000000000000\
-        0000000000000077393837000000000000000000000000000000000000000000000000007680cd2f2d34002aa02\
-        d300cc8ba7b63b0147727c824a54a7db9ec083273be52a32bdca72657a3e310a042a17224b35e7036d84976a23f\
-        be8b1a488b2bcabed1e4a2b0b03f0c9bbc38e9"
-                                .to_string()
-                        )]),
-                        id: Id::Num(1)
-                    })
-                )
-            ]]
-        );
-        let check_expected_successful_request = |expected_hash: H256, idx: usize| {
-            let pending_payable = match &result[idx]{
-                Ok(pp) => pp,
-                Err(RpcPayablesFailure { rpc_error, recipient_wallet: recipient, hash }) => panic!(
-                    "we expected correct pending payable but got one with rpc_error: {:?} and hash: {} for recipient: {}",
-                    rpc_error, hash, recipient
-                ),
-            };
-            let hash = pending_payable.hash;
-            assert_eq!(hash, expected_hash)
-        };
-        //first successful request
-        let expected_hash_1 =
-            H256::from_str("26e5e0cec02023e40faff67e88e3cf48a98574b5f9fdafc03ef42cad96dae1c1")
-                .unwrap();
-        check_expected_successful_request(expected_hash_1, 0);
-        //failing request
-        let pending_payable_fallible_2 = &result[1];
-        let (rpc_error, recipient_2, hash_2) = match pending_payable_fallible_2 {
-            Ok(pp) => panic!(
-                "we expected failing pending payable but got a good one: {:?}",
-                pp
-            ),
-            Err(RpcPayablesFailure {
-                rpc_error,
-                recipient_wallet: recipient,
-                hash,
-            }) => (rpc_error, recipient, hash),
-        };
-        assert_eq!(
-            rpc_error,
-            &web3::Error::Rpc(RPCError {
-                code: ErrorCode::ServerError(114),
-                message: "server being busy".to_string(),
-                data: None
+            result[1],
+            TransactionReceiptResult::RpcResponse(TxReceipt {
+                transaction_hash: tx_hash_2,
+                status: TxStatus::Pending
             })
         );
-        let expected_hash_2 =
-            H256::from_str("57e7c9a5f6af1ab3363e323d59c2c9d1144bbb1a7c2065eeb6696d4e302e67f2")
-                .unwrap();
-        assert_eq!(hash_2, &expected_hash_2);
-        assert_eq!(recipient_2, &make_wallet("w555"));
-        //second_succeeding_request
-        let expected_hash_3 =
-            H256::from_str("a472e3b81bc167140a217447d9701e9ed2b65252f1428f7779acc3710a9ede44")
-                .unwrap();
-        check_expected_successful_request(expected_hash_3, 2);
-        let accountant_recording = accountant_recording_arc.lock().unwrap();
-        assert_eq!(accountant_recording.len(), 1);
-        let initiate_fingerprints_msg =
-            accountant_recording.get_record::<PendingPayableFingerprintSeeds>(0);
-        let actual_common_timestamp = initiate_fingerprints_msg.batch_wide_timestamp;
-        assert!(
-            test_timestamp_before <= actual_common_timestamp
-                && actual_common_timestamp <= test_timestamp_after
-        );
         assert_eq!(
-            initiate_fingerprints_msg,
-            &PendingPayableFingerprintSeeds {
-                batch_wide_timestamp: actual_common_timestamp,
-                hashes_and_balances: vec![
-                    (expected_hash_1, gwei_to_wei(900_000_000_u64)),
-                    (expected_hash_2, 123_456_789),
-                    (expected_hash_3, gwei_to_wei(33_355_666_u64))
-                ]
-            }
-        );
-        let log_handler = TestLogHandler::new();
-        log_handler.exists_log_containing("DEBUG: sending_batch_payments: \
-        Common attributes of payables to be transacted: sender wallet: 0x5c361ba8d82fcf0e5538b2a823e9d457a2296725, contract: \
-          0x384dec25e03f94931767ce4c3556168468ba24c3, chain_id: 3, gas_price: 120");
-        log_handler.exists_log_containing(
-            "DEBUG: sending_batch_payments: Preparing payment of 900,000,000,000,000,000 wei \
-        to 0x0000000000000000000000000000000077313233 with nonce 6",
+            result[2],
+            TransactionReceiptResult::LocalError(
+                "invalid type: string \"trash\", expected struct Receipt".to_string()
+            )
         );
-        log_handler.exists_log_containing(
-            "DEBUG: sending_batch_payments: Preparing payment of 123,456,789 wei \
-        to 0x0000000000000000000000000000000077353535 with nonce 7",
+        assert_eq!(
+            result[3],
+            TransactionReceiptResult::RpcResponse(TxReceipt {
+                transaction_hash: tx_hash_4,
+                status: TxStatus::Pending
+            })
         );
-        log_handler.exists_log_containing(
-            "DEBUG: sending_batch_payments: Preparing payment of 33,355,666,000,000,000 wei \
-        to 0x0000000000000000000000000000000077393837 with nonce 8",
+        assert_eq!(
+            result[4],
+            TransactionReceiptResult::RpcResponse(TxReceipt {
+                transaction_hash: tx_hash_5,
+                status: TxStatus::Failed,
+            })
         );
-        log_handler.exists_log_containing(
-            "INFO: sending_batch_payments: Paying to creditors...\n\
-        Transactions in the batch:\n\
-        \n\
-        gas price:                                   120 gwei\n\
-        chain:                                       ropsten\n\
-        \n\
-        [wallet address]                             [payment in wei]\n\
-        0x0000000000000000000000000000000077313233   900,000,000,000,000,000\n\
-        0x0000000000000000000000000000000077353535   123,456,789\n\
-        0x0000000000000000000000000000000077393837   33,355,666,000,000,000\n",
+        assert_eq!(
+            result[5],
+            TransactionReceiptResult::RpcResponse(TxReceipt {
+                transaction_hash: tx_hash_6,
+                status: TxStatus::Succeeded(TransactionBlock {
+                    block_hash,
+                    block_number,
+                }),
+            })
         );
     }
 
     #[test]
-    fn send_payables_within_batch_components_are_used_together_properly() {
-        let sign_transaction_params_arc = Arc::new(Mutex::new(vec![]));
-        let append_transaction_to_batch_params_arc = Arc::new(Mutex::new(vec![]));
-        let new_payable_fingerprint_params_arc = Arc::new(Mutex::new(vec![]));
-        let submit_batch_params_arc: Arc<Mutex<Vec<Web3<Batch<TestTransport>>>>> =
-            Arc::new(Mutex::new(vec![]));
-        let reference_counter_arc = Arc::new(());
-        let (accountant, _, accountant_recording_arc) = make_recorder();
-        let initiate_fingerprints_recipient = accountant.start().recipient();
-        let consuming_wallet_secret = b"consuming_wallet_0123456789abcde";
-        let secret_key =
-            (&Bip32EncryptionKeyProvider::from_raw_secret(consuming_wallet_secret).unwrap()).into();
-        let batch_wide_timestamp_expected = SystemTime::now();
-        let transport = TestTransport::default().initiate_reference_counter(&reference_counter_arc);
-        let chain = Chain::EthMainnet;
-        let mut subject =
-            BlockchainInterfaceWeb3::new(transport, make_fake_event_loop_handle(), chain);
-        let first_transaction_params_expected = TransactionParameters {
-            nonce: Some(U256::from(4)),
-            to: Some(subject.contract_address()),
-            gas: U256::from(56_552),
-            gas_price: Some(U256::from(123000000000_u64)),
-            value: U256::from(0),
-            data: Bytes(vec![
-                169, 5, 156, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                99, 114, 101, 100, 105, 116, 111, 114, 51, 50, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77, 149, 149, 231, 24,
-            ]),
-            chain_id: Some(chain.rec().num_chain_id),
-        };
-        let first_signed_transaction = subject
-            .web3
-            .accounts()
-            .sign_transaction(first_transaction_params_expected.clone(), &secret_key)
-            .wait()
-            .unwrap();
-        let second_transaction_params_expected = TransactionParameters {
-            nonce: Some(U256::from(5)),
-            to: Some(subject.contract_address()),
-            gas: U256::from(56_552),
-            gas_price: Some(U256::from(123000000000_u64)),
-            value: U256::from(0),
-            data: Bytes(vec![
-                169, 5, 156, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                99, 114, 101, 100, 105, 116, 111, 114, 49, 50, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 156, 231, 56, 4,
-            ]),
-            chain_id: Some(chain.rec().num_chain_id),
-        };
-        let second_signed_transaction = subject
-            .web3
-            .accounts()
-            .sign_transaction(second_transaction_params_expected.clone(), &secret_key)
-            .wait()
-            .unwrap();
-        let first_hash = first_signed_transaction.transaction_hash;
-        let second_hash = second_signed_transaction.transaction_hash;
-        //technically, the JSON values in the correct responses don't matter, we only check for errors if any came back
-        let rpc_responses = vec![
-            Ok(Value::String((&first_hash.to_string()[2..]).to_string())),
-            Ok(Value::String((&second_hash.to_string()[2..]).to_string())),
-        ];
-        let batch_payables_tools = BatchPayableToolsMock::default()
-            .sign_transaction_params(&sign_transaction_params_arc)
-            .sign_transaction_result(Ok(first_signed_transaction.clone()))
-            .sign_transaction_result(Ok(second_signed_transaction.clone()))
-            .batch_wide_timestamp_result(batch_wide_timestamp_expected)
-            .send_new_payable_fingerprint_credentials_params(&new_payable_fingerprint_params_arc)
-            .append_transaction_to_batch_params(&append_transaction_to_batch_params_arc)
-            .submit_batch_params(&submit_batch_params_arc)
-            .submit_batch_result(Ok(rpc_responses));
-        subject.batch_payable_tools = Box::new(batch_payables_tools);
-        let consuming_wallet = make_paying_wallet(consuming_wallet_secret);
-        let first_payment_amount = 333_222_111_000;
-        let first_creditor_wallet = make_wallet("creditor321");
-        let first_account = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
-            first_creditor_wallet.clone(),
-            first_payment_amount,
-            None,
-        );
-        let second_payment_amount = 11_222_333_444;
-        let second_creditor_wallet = make_wallet("creditor123");
-        let second_account = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
-            second_creditor_wallet.clone(),
-            second_payment_amount,
-            None,
-        );
-        let agent = make_initialized_agent(123, consuming_wallet, U256::from(4));
+    fn process_transaction_receipts_fails_on_submit_batch() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port).start();
+        let subject = make_blockchain_interface_web3(port);
+        let tx_hash_1 =
+            H256::from_str("a128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0e")
+                .unwrap();
+        let tx_hash_2 =
+            H256::from_str("a128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0f")
+                .unwrap();
+        let tx_hash_vec = vec![tx_hash_1, tx_hash_2];
 
-        let result = subject.send_batch_of_payables(
-            agent,
-            &initiate_fingerprints_recipient,
-            &vec![first_account, second_account],
-        );
+        let error = subject
+            .process_transaction_receipts(tx_hash_vec)
+            .wait()
+            .unwrap_err();
 
-        let first_resulting_pending_payable = PendingPayable {
-            recipient_wallet: first_creditor_wallet.clone(),
-            hash: first_hash,
-        };
-        let second_resulting_pending_payable = PendingPayable {
-            recipient_wallet: second_creditor_wallet.clone(),
-            hash: second_hash,
-        };
-        assert_eq!(
-            result,
-            Ok(vec![
-                Ok(first_resulting_pending_payable),
-                Ok(second_resulting_pending_payable)
-            ])
-        );
-        let mut sign_transaction_params = sign_transaction_params_arc.lock().unwrap();
-        let (first_transaction_params_actual, web3, secret) = sign_transaction_params.remove(0);
-        assert_eq!(
-            first_transaction_params_actual,
-            first_transaction_params_expected
-        );
-        let check_web3_origin = |web3: &Web3<Batch<TestTransport>>| {
-            let ref_count_before_clone = Arc::strong_count(&reference_counter_arc);
-            let _new_ref = web3.clone();
-            let ref_count_after_clone = Arc::strong_count(&reference_counter_arc);
-            assert_eq!(ref_count_after_clone, ref_count_before_clone + 1);
-        };
-        check_web3_origin(&web3);
-        assert_eq!(
-            secret,
-            (&Bip32EncryptionKeyProvider::from_raw_secret(&consuming_wallet_secret.keccak256())
-                .unwrap())
-                .into()
-        );
-        let (second_transaction_params_actual, web3_from_st_call, secret) =
-            sign_transaction_params.remove(0);
         assert_eq!(
-            second_transaction_params_actual,
-            second_transaction_params_expected
+            error,
+            QueryFailed("Transport error: Error(IncompleteMessage)".to_string())
         );
-        check_web3_origin(&web3_from_st_call);
-        assert_eq!(
-            secret,
-            (&Bip32EncryptionKeyProvider::from_raw_secret(&consuming_wallet_secret.keccak256())
-                .unwrap())
-                .into()
-        );
-        assert!(sign_transaction_params.is_empty());
-        let new_payable_fingerprint_params = new_payable_fingerprint_params_arc.lock().unwrap();
-        let (batch_wide_timestamp, recipient, actual_pending_payables) =
-            &new_payable_fingerprint_params[0];
-        assert_eq!(batch_wide_timestamp, &batch_wide_timestamp_expected);
-        assert_eq!(
-            actual_pending_payables,
-            &vec![
-                (first_hash, first_payment_amount),
-                (second_hash, second_payment_amount)
-            ]
-        );
-        let mut append_transaction_to_batch_params =
-            append_transaction_to_batch_params_arc.lock().unwrap();
-        let (bytes_first_payment, web3_from_ertb_call_1) =
-            append_transaction_to_batch_params.remove(0);
-        check_web3_origin(&web3_from_ertb_call_1);
-        assert_eq!(
-            bytes_first_payment,
-            first_signed_transaction.raw_transaction
-        );
-        let (bytes_second_payment, web3_from_ertb_call_2) =
-            append_transaction_to_batch_params.remove(0);
-        check_web3_origin(&web3_from_ertb_call_2);
-        assert_eq!(
-            bytes_second_payment,
-            second_signed_transaction.raw_transaction
-        );
-        assert_eq!(append_transaction_to_batch_params.len(), 0);
-        let submit_batch_params = submit_batch_params_arc.lock().unwrap();
-        let web3_from_sb_call = &submit_batch_params[0];
-        assert_eq!(submit_batch_params.len(), 1);
-        check_web3_origin(&web3_from_sb_call);
-        assert!(accountant_recording_arc.lock().unwrap().is_empty());
-        let system =
-            System::new("send_payables_within_batch_components_are_used_together_properly");
-        let probe_message = PendingPayableFingerprintSeeds {
-            batch_wide_timestamp: SystemTime::now(),
-            hashes_and_balances: vec![],
-        };
-        recipient.try_send(probe_message).unwrap();
-        System::current().stop();
-        system.run();
-        let accountant_recording = accountant_recording_arc.lock().unwrap();
-        assert_eq!(accountant_recording.len(), 1)
     }
 
     #[test]
     fn web3_gas_limit_const_part_returns_reasonable_values() {
-        type Subject = BlockchainInterfaceWeb3<Http>;
+        type Subject = BlockchainInterfaceWeb3;
         assert_eq!(
             Subject::web3_gas_limit_const_part(Chain::EthMainnet),
             55_000
@@ -1677,638 +1096,115 @@ mod tests {
     }
 
     #[test]
-    fn gas_limit_for_polygon_mainnet_lies_within_limits_for_raw_transaction() {
-        test_gas_limit_is_between_limits(Chain::PolyMainnet);
-    }
+    fn calculate_end_block_marker_works() {
+        let logger = Logger::new("calculate_end_block_marker_works");
 
-    #[test]
-    fn gas_limit_for_eth_mainnet_lies_within_limits_for_raw_transaction() {
-        test_gas_limit_is_between_limits(Chain::EthMainnet)
-    }
-
-    fn test_gas_limit_is_between_limits(chain: Chain) {
-        let sign_transaction_params_arc = Arc::new(Mutex::new(vec![]));
-        let transport = TestTransport::default();
-        let mut subject =
-            BlockchainInterfaceWeb3::new(transport, make_fake_event_loop_handle(), chain);
-        let not_under_this_value =
-            BlockchainInterfaceWeb3::<Http>::web3_gas_limit_const_part(chain);
-        let not_above_this_value = not_under_this_value + WEB3_MAXIMAL_GAS_LIMIT_MARGIN;
-        let consuming_wallet_secret_raw_bytes = b"my-wallet";
-        let batch_payable_tools = BatchPayableToolsMock::<TestTransport>::default()
-            .sign_transaction_params(&sign_transaction_params_arc)
-            .sign_transaction_result(Ok(make_default_signed_transaction()));
-        subject.batch_payable_tools = Box::new(batch_payable_tools);
-        let consuming_wallet = make_paying_wallet(consuming_wallet_secret_raw_bytes);
-        let gas_price = 123;
-        let nonce = U256::from(5);
-
-        let _ = subject.sign_transaction(
-            &make_wallet("wallet1"),
-            &consuming_wallet,
-            1_000_000_000,
-            nonce,
-            gas_price,
-        );
+        type Subject = BlockchainInterfaceWeb3;
 
-        let mut sign_transaction_params = sign_transaction_params_arc.lock().unwrap();
-        let (transaction_params, _, secret) = sign_transaction_params.remove(0);
-        assert!(sign_transaction_params.is_empty());
-        assert!(
-            transaction_params.gas >= U256::from(not_under_this_value),
-            "actual gas limit {} isn't above or equal {}",
-            transaction_params.gas,
-            not_under_this_value
-        );
-        assert!(
-            transaction_params.gas <= U256::from(not_above_this_value),
-            "actual gas limit {} isn't below or equal {}",
-            transaction_params.gas,
-            not_above_this_value
-        );
         assert_eq!(
-            secret,
-            (&Bip32EncryptionKeyProvider::from_raw_secret(
-                &consuming_wallet_secret_raw_bytes.keccak256()
-            )
-            .unwrap())
-                .into()
+            Subject::calculate_end_block_marker(
+                50,
+                BlockScanRange::NoLimit,
+                Err(BlockchainError::InvalidResponse),
+                &logger
+            ),
+            BlockMarker::Uninitialized
         );
-    }
-
-    #[test]
-    fn signing_error_terminates_iteration_over_accounts_and_propagates_it_all_way_up_and_out() {
-        let transport = TestTransport::default();
-        let chain = Chain::PolyAmoy;
-        let batch_payable_tools = BatchPayableToolsMock::<TestTransport>::default()
-            .sign_transaction_result(Err(Web3Error::Signing(
-                secp256k1secrets::Error::InvalidSecretKey,
-            )))
-            //we return after meeting the first result
-            .sign_transaction_result(Err(Web3Error::Internal));
-        let mut subject =
-            BlockchainInterfaceWeb3::new(transport, make_fake_event_loop_handle(), chain);
-        subject.batch_payable_tools = Box::new(batch_payable_tools);
-        let recipient = Recorder::new().start().recipient();
-        let consuming_wallet = make_paying_wallet(&b"consume, you greedy fool!"[..]);
-        let accounts = vec![make_payable_account(5555), make_payable_account(6666)];
-        let agent = make_initialized_agent(123, consuming_wallet, U256::from(4));
-
-        let result = subject.send_batch_of_payables(agent, &recipient, &accounts);
-
         assert_eq!(
-            result,
-            Err(PayableTransactionError::Signing(
-                "Signing error: secp: malformed or out-of-range \
-            secret key"
-                    .to_string()
-            ))
-        )
-    }
-
-    #[test]
-    fn send_batch_of_payables_fails_on_badly_prepared_consuming_wallet_without_secret() {
-        let transport = TestTransport::default();
-        let incomplete_consuming_wallet =
-            Wallet::from_str("0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc").unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = BlockchainInterfaceWeb3::new(transport, make_fake_event_loop_handle(), chain);
-        let system = System::new("test");
-        let (accountant, _, accountant_recording_arc) = make_recorder();
-        let recipient = accountant.start().recipient();
-        let account = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
-            make_wallet("blah123"),
-            9000,
-            None,
-        );
-        let agent = make_initialized_agent(123, incomplete_consuming_wallet, U256::from(1));
-
-        let result = subject.send_batch_of_payables(agent, &recipient, &vec![account]);
-
-        System::current().stop();
-        system.run();
-        assert_eq!(result,
-                   Err(PayableTransactionError::UnusableWallet("Cannot sign with non-keypair wallet: Address(0x3f69f9efd4f2592fd70be8c32ecd9dce71c472fc).".to_string()))
-        );
-        let accountant_recording = accountant_recording_arc.lock().unwrap();
-        assert_eq!(accountant_recording.len(), 0)
-    }
-
-    #[test]
-    fn send_batch_of_payables_fails_on_sending() {
-        let transport = TestTransport::default();
-        let hash = make_tx_hash(123);
-        let mut signed_transaction = make_default_signed_transaction();
-        signed_transaction.transaction_hash = hash;
-        let batch_payable_tools = BatchPayableToolsMock::<TestTransport>::default()
-            .sign_transaction_result(Ok(signed_transaction))
-            .batch_wide_timestamp_result(SystemTime::now())
-            .submit_batch_result(Err(Web3Error::Transport("Transaction crashed".to_string())));
-        let consuming_wallet_secret_raw_bytes = b"okay-wallet";
-        let chain = Chain::PolyAmoy;
-        let mut subject =
-            BlockchainInterfaceWeb3::new(transport, make_fake_event_loop_handle(), chain);
-        subject.batch_payable_tools = Box::new(batch_payable_tools);
-        let unimportant_recipient = Recorder::new().start().recipient();
-        let account = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
-            make_wallet("blah123"),
-            5000,
-            None,
+            Subject::calculate_end_block_marker(
+                50,
+                BlockScanRange::NoLimit,
+                Ok(1000.into()),
+                &logger
+            ),
+            BlockMarker::Value(1000)
         );
-        let consuming_wallet = make_paying_wallet(consuming_wallet_secret_raw_bytes);
-        let agent = make_initialized_agent(120, consuming_wallet, U256::from(6));
-
-        let result = subject.send_batch_of_payables(agent, &unimportant_recipient, &vec![account]);
-
         assert_eq!(
-            result,
-            Err(PayableTransactionError::Sending {
-                msg: "Transport error: Transaction crashed".to_string(),
-                hashes: vec![hash]
-            })
+            Subject::calculate_end_block_marker(
+                50,
+                BlockScanRange::Range(100),
+                Err(BlockchainError::InvalidResponse),
+                &logger
+            ),
+            BlockMarker::Value(150)
         );
-    }
-
-    #[test]
-    fn sign_transaction_fails_on_signing_itself() {
-        let transport = TestTransport::default();
-        let batch_payable_tools = BatchPayableToolsMock::<TestTransport>::default()
-            .sign_transaction_result(Err(Web3Error::Signing(
-                secp256k1secrets::Error::InvalidSecretKey,
-            )));
-        let consuming_wallet_secret_raw_bytes = b"okay-wallet";
-        let chain = Chain::PolyAmoy;
-        let mut subject =
-            BlockchainInterfaceWeb3::new(transport, make_fake_event_loop_handle(), chain);
-        subject.batch_payable_tools = Box::new(batch_payable_tools);
-        let recipient = make_wallet("unlucky man");
-        let consuming_wallet = make_paying_wallet(consuming_wallet_secret_raw_bytes);
-        let gas_price = 123;
-        let nonce = U256::from(1);
-
-        let result =
-            subject.sign_transaction(&recipient, &consuming_wallet, 444444, nonce, gas_price);
-
         assert_eq!(
-            result,
-            Err(PayableTransactionError::Signing(
-                "Signing error: secp: malformed or out-of-range secret key".to_string()
-            ))
-        );
-    }
-
-    fn test_consuming_wallet_with_secret() -> Wallet {
-        let key_pair = Bip32EncryptionKeyProvider::from_raw_secret(
-            &decode_hex("97923d8fd8de4a00f912bfb77ef483141dec551bd73ea59343ef5c4aac965d04")
-                .unwrap(),
-        )
-        .unwrap();
-        Wallet::from(key_pair)
-    }
-
-    fn test_recipient_wallet() -> Wallet {
-        let hex_part = &"0x7788df76BBd9a0C7c3e5bf0f77bb28C60a167a7b"[2..];
-        let recipient_address_bytes = decode_hex(hex_part).unwrap();
-        let address = Address::from_slice(&recipient_address_bytes);
-        Wallet::from(address)
-    }
-
-    fn assert_that_signed_transactions_agrees_with_template(
-        chain: Chain,
-        nonce: u64,
-        template: &[u8],
-    ) {
-        let transport = TestTransport::default();
-        let subject = BlockchainInterfaceWeb3::new(transport, make_fake_event_loop_handle(), chain);
-        let consuming_wallet = test_consuming_wallet_with_secret();
-        let recipient_wallet = test_recipient_wallet();
-        let nonce_correct_type = U256::from(nonce);
-        let gas_price = match chain {
-            Chain::EthMainnet | Chain::EthRopsten | Chain::Dev => 110,
-            Chain::PolyMainnet | Chain::PolyAmoy => 55,
-            // It performs on even cheaper fees, but we're
-            // limited by the units here
-            Chain::BaseMainnet | Chain::BaseSepolia => 1,
-        };
-        let payment_size_wei = gwei_to_wei(1_000_u64);
-        let payable_account = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
-            recipient_wallet,
-            payment_size_wei,
-            None,
+            Subject::calculate_end_block_marker(
+                50,
+                BlockScanRange::Range(100),
+                Ok(120.into()),
+                &logger
+            ),
+            BlockMarker::Value(120)
         );
-
-        let signed_transaction = subject
-            .sign_transaction(
-                &payable_account.wallet,
-                &consuming_wallet,
-                payable_account.balance_wei,
-                nonce_correct_type,
-                gas_price,
-            )
-            .unwrap();
-
-        let byte_set_to_compare = signed_transaction.raw_transaction.0;
         assert_eq!(
-            byte_set_to_compare,
-            template,
-            "Actual signed transaction {} does not match {} as expected",
-            hex::encode(byte_set_to_compare.clone()),
-            hex::encode(template.to_vec())
-        )
-    }
-
-    // Transaction with this input was verified on the test network
-    #[test]
-    fn web3_interface_signing_a_transaction_works_for_polygon_amoy() {
-        let chain = Chain::PolyAmoy;
-        let nonce = 4;
-        let signed_transaction_data = "\
-        f8ad04850cce4166008301198094d98c3ebd6b7f9b7cda2449ecac00d1e5f47a819380b844a9059cbb000000000\
-        0000000000000007788df76bbd9a0c7c3e5bf0f77bb28c60a167a7b000000000000000000000000000000000000\
-        000000000000000000e8d4a5100083027127a0ddd78a41c42b7a409c281292f7c6aedefab8b461d87371fe402b4\
-        b0804a092f2a04b1b599ac2c1ff07bb3d40d3698c454691c3b70d99f1e5d840c852e968c96a10";
-        let in_bytes = decode_hex(signed_transaction_data).unwrap();
-
-        assert_that_signed_transactions_agrees_with_template(chain, nonce, &in_bytes)
-    }
-
-    #[test]
-    fn web3_interface_signing_a_transaction_works_for_base_sepolia() {
-        let chain = Chain::BaseSepolia;
-        let nonce = 2;
-        let signed_transaction_data = "\
-        f8ac02843b9aca008301198094898e1ce720084a902bc37dd822ed6d6a5f027e1080b844a9059cbb00000000000\
-        00000000000007788df76bbd9a0c7c3e5bf0f77bb28c60a167a7b00000000000000000000000000000000000000\
-        0000000000000000e8d4a510008302948ca07b57223b566ade08ec817770c8b9ae94373edbefc13372c3463cf7b\
-        6ce542231a020991f2ff180a12cbc2745465a4e710da294b890901a3887519b191c3a69cd4f";
-        let in_bytes = decode_hex(signed_transaction_data).unwrap();
-
-        assert_that_signed_transactions_agrees_with_template(chain, nonce, &in_bytes)
-    }
-
-    // Transaction with this input was verified on the test network
-    #[test]
-    fn web3_interface_signing_a_transaction_works_for_eth_ropsten() {
-        let chain = Chain::EthRopsten;
-        let nonce = 1;
-        let signed_transaction_data = "\
-        f8a90185199c82cc0082dee894384dec25e03f94931767ce4c3556168468ba24c380b844a9059cbb00000000000\
-        00000000000007788df76bbd9a0c7c3e5bf0f77bb28c60a167a7b00000000000000000000000000000000000000\
-        0000000000000000e8d4a510002aa0635fbb3652e1c3063afac6ffdf47220e0431825015aef7daff9251694e449\
-        bfca00b2ed6d556bd030ac75291bf58817da15a891cd027a4c261bb80b51f33b78adf";
-        let in_bytes = decode_hex(signed_transaction_data).unwrap();
-
-        assert_that_signed_transactions_agrees_with_template(chain, nonce, &in_bytes)
-    }
-
-    // Unconfirmed on the real network
-    #[test]
-    fn web3_interface_signing_a_transaction_for_polygon_mainnet() {
-        let chain = Chain::PolyMainnet;
-        let nonce = 10;
-        let signed_transaction_data = "f8ac0a850cce4166008301198094ee9a352f6aac4af1a5b9f467f6a\
-        93e0ffbe9dd3580b844a9059cbb0000000000000000000000007788df76bbd9a0c7c3e5bf0f77bb28c60a167a7b\
-        000000000000000000000000000000000000000000000000000000e8d4a51000820135a0c89f4dca80c3437a23c\
-        c1a41ab59fd5206b0c0e1293d975242e8482c44838c75a075429a84b761db83d648dc4298480f6b2cedc110c134\
-        065ed8955e66c7504469";
-        let in_bytes = decode_hex(signed_transaction_data).unwrap();
-
-        assert_that_signed_transactions_agrees_with_template(chain, nonce, &in_bytes)
-    }
-
-    // Unconfirmed on the real network
-    #[test]
-    fn web3_interface_signing_a_transaction_for_eth_mainnet() {
-        let chain = Chain::EthMainnet;
-        let nonce = 10;
-        let signed_transaction_data = "f8a90a85199c82cc0082dee89406f3c323f0238c72bf35011071f2b\
-        5b7f43a054c80b844a9059cbb0000000000000000000000007788df76bbd9a0c7c3e5bf0f77bb28c60a167a7b00\
-        0000000000000000000000000000000000000000000000000000e8d4a5100026a0c79b4c6a27e303975a75f5d35\
-        662bb757867a583634824d30ae0fc6833c8e69ea054128cf87716c10e94fd303bb90b26986796783c4a389fce16\
-        0f49ad990b4c4a";
-        let in_bytes = decode_hex(signed_transaction_data).unwrap();
-
-        assert_that_signed_transactions_agrees_with_template(chain, nonce, &in_bytes)
-    }
-
-    // Unconfirmed on the real network
-    #[test]
-    fn web3_interface_signing_a_transaction_for_base_mainnet() {
-        let chain = Chain::BaseMainnet;
-        let nonce = 124;
-        let signed_transaction_data = "f8ab7c843b9aca00830119809445d9c101a3870ca5024582fd788f4\
-        e1e8f7971c380b844a9059cbb0000000000000000000000007788df76bbd9a0c7c3e5bf0f77bb28c60a167a7b00\
-        0000000000000000000000000000000000000000000000000000e8d4a5100082422da0587b5f8401225d5cf6267\
-        6f51f376f085805851e2e59c5253eb2834612295bdba05b6963872bac7eeafb38191079e8c8df919c193839022b\
-        d57b91ace5a8638034";
-        let in_bytes = decode_hex(signed_transaction_data).unwrap();
-
-        assert_that_signed_transactions_agrees_with_template(chain, nonce, &in_bytes)
-    }
-
-    // Adapted test from old times when we had our own signing method.
-    // Don't have data for new chains, so I omit them in this kind of tests
-    #[test]
-    fn signs_various_transactions_for_eth_mainnet() {
-        let signatures = &[
-            &[
-                248, 108, 9, 133, 4, 168, 23, 200, 0, 130, 82, 8, 148, 53, 53, 53, 53, 53, 53, 53,
-                53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 136, 13, 224, 182, 179, 167,
-                100, 0, 0, 128, 37, 160, 40, 239, 97, 52, 11, 217, 57, 188, 33, 149, 254, 83, 117,
-                103, 134, 96, 3, 225, 161, 93, 60, 113, 255, 99, 225, 89, 6, 32, 170, 99, 98, 118,
-                160, 103, 203, 233, 216, 153, 127, 118, 26, 236, 183, 3, 48, 75, 56, 0, 204, 245,
-                85, 201, 243, 220, 100, 33, 75, 41, 127, 177, 150, 106, 59, 109, 131,
-            ][..],
-            &[
-                248, 106, 128, 134, 213, 86, 152, 55, 36, 49, 131, 30, 132, 128, 148, 240, 16, 159,
-                200, 223, 40, 48, 39, 182, 40, 92, 200, 137, 245, 170, 98, 78, 172, 31, 85, 132,
-                59, 154, 202, 0, 128, 37, 160, 9, 235, 182, 202, 5, 122, 5, 53, 214, 24, 100, 98,
-                188, 11, 70, 91, 86, 28, 148, 162, 149, 189, 176, 98, 31, 193, 146, 8, 171, 20,
-                154, 156, 160, 68, 15, 253, 119, 92, 233, 26, 131, 58, 180, 16, 119, 114, 4, 213,
-                52, 26, 111, 159, 169, 18, 22, 166, 243, 238, 44, 5, 31, 234, 106, 4, 40,
-            ][..],
-            &[
-                248, 117, 128, 134, 9, 24, 78, 114, 160, 0, 130, 39, 16, 128, 128, 164, 127, 116,
-                101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 96, 0, 87, 38, 160, 122, 155, 12, 58, 133, 108, 183, 145, 181,
-                210, 141, 44, 236, 17, 96, 40, 55, 87, 204, 250, 142, 83, 122, 168, 250, 5, 113,
-                172, 203, 5, 12, 181, 160, 9, 100, 95, 141, 167, 178, 53, 101, 115, 131, 83, 172,
-                199, 242, 208, 96, 246, 121, 25, 18, 211, 89, 60, 94, 165, 169, 71, 3, 176, 157,
-                167, 50,
-            ][..],
-        ];
-        assert_signature(Chain::EthMainnet, signatures)
-    }
-
-    // Adapted test from old times when we had our own signing method.
-    // Don't have data for new chains, so I omit them in this kind of tests
-    #[test]
-    fn signs_various_transactions_for_ropsten() {
-        let signatures = &[
-            &[
-                248, 108, 9, 133, 4, 168, 23, 200, 0, 130, 82, 8, 148, 53, 53, 53, 53, 53, 53, 53,
-                53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 136, 13, 224, 182, 179, 167,
-                100, 0, 0, 128, 41, 160, 8, 220, 80, 201, 100, 41, 178, 35, 151, 227, 210, 85, 27,
-                41, 27, 82, 217, 176, 64, 92, 205, 10, 195, 169, 66, 91, 213, 199, 124, 52, 3, 192,
-                160, 94, 220, 102, 179, 128, 78, 150, 78, 230, 117, 10, 10, 32, 108, 241, 50, 19,
-                148, 198, 6, 147, 110, 175, 70, 157, 72, 31, 216, 193, 229, 151, 115,
-            ][..],
-            &[
-                248, 106, 128, 134, 213, 86, 152, 55, 36, 49, 131, 30, 132, 128, 148, 240, 16, 159,
-                200, 223, 40, 48, 39, 182, 40, 92, 200, 137, 245, 170, 98, 78, 172, 31, 85, 132,
-                59, 154, 202, 0, 128, 41, 160, 186, 65, 161, 205, 173, 93, 185, 43, 220, 161, 63,
-                65, 19, 229, 65, 186, 247, 197, 132, 141, 184, 196, 6, 117, 225, 181, 8, 81, 198,
-                102, 150, 198, 160, 112, 126, 42, 201, 234, 236, 168, 183, 30, 214, 145, 115, 201,
-                45, 191, 46, 3, 113, 53, 80, 203, 164, 210, 112, 42, 182, 136, 223, 125, 232, 21,
-                205,
-            ][..],
-            &[
-                248, 117, 128, 134, 9, 24, 78, 114, 160, 0, 130, 39, 16, 128, 128, 164, 127, 116,
-                101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 96, 0, 87, 41, 160, 146, 204, 57, 32, 218, 236, 59, 94, 106, 72,
-                174, 211, 223, 160, 122, 186, 126, 44, 200, 41, 222, 117, 117, 177, 189, 78, 203,
-                8, 172, 155, 219, 66, 160, 83, 82, 37, 6, 243, 61, 188, 102, 176, 132, 102, 74,
-                111, 180, 105, 33, 122, 106, 109, 73, 180, 65, 10, 117, 175, 190, 19, 196, 17, 128,
-                193, 75,
-            ][..],
-        ];
-        assert_signature(Chain::EthRopsten, signatures)
-    }
-
-    #[derive(Deserialize)]
-    struct Signing {
-        signed: Vec<u8>,
-        private_key: H256,
-    }
-
-    fn assert_signature(chain: Chain, slice_of_slices: &[&[u8]]) {
-        let first_part_tx_1 = r#"[{"nonce": "0x9", "gasPrice": "0x4a817c800", "gasLimit": "0x5208", "to": "0x3535353535353535353535353535353535353535", "value": "0xde0b6b3a7640000", "data": []}, {"private_key": "0x4646464646464646464646464646464646464646464646464646464646464646", "signed": "#;
-        let first_part_tx_2 = r#"[{"nonce": "0x0", "gasPrice": "0xd55698372431", "gasLimit": "0x1e8480", "to": "0xF0109fC8DF283027b6285cc889F5aA624EaC1F55", "value": "0x3b9aca00", "data": []}, {"private_key": "0x4c0883a69102937d6231471b5dbb6204fe5129617082792ae468d01a3f362318", "signed": "#;
-        let first_part_tx_3 = r#"[{"nonce": "0x00", "gasPrice": "0x09184e72a000", "gasLimit": "0x2710", "to": null, "value": "0x00", "data": [127,116,101,115,116,50,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,87]}, {"private_key": "0xe331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109", "signed": "#;
-        fn compose(first_part: &str, slice: &[u8]) -> String {
-            let third_part_jrc = "}]";
-            format!("{}{:?}{}", first_part, slice, third_part_jrc)
-        }
-        let all_transactions = format!(
-            "[{}]",
-            vec![first_part_tx_1, first_part_tx_2, first_part_tx_3]
-                .iter()
-                .zip(slice_of_slices.iter())
-                .zip(0usize..2)
-                .fold(String::new(), |so_far, actual| [
-                    so_far,
-                    compose(actual.0 .0, actual.0 .1)
-                ]
-                .join(if actual.1 == 0 { "" } else { ", " }))
-        );
-        let txs: Vec<(TestRawTransaction, Signing)> =
-            serde_json::from_str(&all_transactions).unwrap();
-        let constant_parts = &[
-            &[
-                248u8, 108, 9, 133, 4, 168, 23, 200, 0, 130, 82, 8, 148, 53, 53, 53, 53, 53, 53,
-                53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 136, 13, 224, 182, 179,
-                167, 100, 0, 0, 128,
-            ][..],
-            &[
-                248, 106, 128, 134, 213, 86, 152, 55, 36, 49, 131, 30, 132, 128, 148, 240, 16, 159,
-                200, 223, 40, 48, 39, 182, 40, 92, 200, 137, 245, 170, 98, 78, 172, 31, 85, 132,
-                59, 154, 202, 0, 128,
-            ][..],
-            &[
-                248, 117, 128, 134, 9, 24, 78, 114, 160, 0, 130, 39, 16, 128, 128, 164, 127, 116,
-                101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 96, 0, 87,
-            ][..],
-        ];
-        let transport = TestTransport::default();
-        let subject = BlockchainInterfaceWeb3::new(transport, make_fake_event_loop_handle(), chain);
-        let lengths_of_constant_parts: Vec<usize> =
-            constant_parts.iter().map(|part| part.len()).collect();
-        for (((tx, signed), length), constant_part) in txs
-            .iter()
-            .zip(lengths_of_constant_parts)
-            .zip(constant_parts)
-        {
-            let secret = Wallet::from(
-                Bip32EncryptionKeyProvider::from_raw_secret(&signed.private_key.0.as_ref())
-                    .unwrap(),
-            )
-            .prepare_secp256k1_secret()
-            .unwrap();
-            let tx_params = from_raw_transaction_to_transaction_parameters(tx, chain);
-            let sign = subject
-                .web3
-                .accounts()
-                .sign_transaction(tx_params, &secret)
-                .wait()
-                .unwrap();
-            let signed_data_bytes = sign.raw_transaction.0;
-            assert_eq!(signed_data_bytes, signed.signed);
-            assert_eq!(signed_data_bytes[..length], **constant_part)
-        }
-    }
-
-    fn from_raw_transaction_to_transaction_parameters(
-        raw_transaction: &TestRawTransaction,
-        chain: Chain,
-    ) -> TransactionParameters {
-        TransactionParameters {
-            nonce: Some(raw_transaction.nonce),
-            to: raw_transaction.to,
-            gas: raw_transaction.gas_limit,
-            gas_price: Some(raw_transaction.gas_price),
-            value: raw_transaction.value,
-            data: Bytes(raw_transaction.data.clone()),
-            chain_id: Some(chain.rec().num_chain_id),
-        }
-    }
-
-    #[test]
-    fn blockchain_interface_web3_can_fetch_transaction_receipt() {
-        let port = find_free_port();
-        let _test_server = TestServer::start (port, vec![
-            br#"{"jsonrpc":"2.0","id":2,"result":{"transactionHash":"0xa128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0e","blockHash":"0x6d0abccae617442c26104c2bc63d1bc05e1e002e555aec4ab62a46e826b18f18","blockNumber":"0xb0328d","contractAddress":null,"cumulativeGasUsed":"0x60ef","effectiveGasPrice":"0x22ecb25c00","from":"0x7424d05b59647119b01ff81e2d3987b6c358bf9c","gasUsed":"0x60ef","logs":[],"logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000","status":"0x0","to":"0x384dec25e03f94931767ce4c3556168468ba24c3","transactionIndex":"0x0","type":"0x0"}}"#
-                .to_vec()
-        ]);
-        let (event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain);
-        let tx_hash =
-            H256::from_str("a128f9ca1e705cc20a936a24a7fa1df73bad6e0aaf58e8e6ffcc154a7cff6e0e")
-                .unwrap();
-
-        let result = subject.get_transaction_receipt(tx_hash);
-
-        let expected_receipt = TransactionReceipt{
-            transaction_hash: tx_hash,
-            transaction_index: Default::default(),
-            block_hash: Some(H256::from_str("6d0abccae617442c26104c2bc63d1bc05e1e002e555aec4ab62a46e826b18f18").unwrap()),
-            block_number:Some(U64::from_str("b0328d").unwrap()),
-            cumulative_gas_used: U256::from_str("60ef").unwrap(),
-            gas_used: Some(U256::from_str("60ef").unwrap()),
-            contract_address: None,
-            logs: vec![],
-            status: Some(U64::from(0)),
-            root: None,
-            logs_bloom: H2048::from_str("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000").unwrap()
-        };
-        assert_eq!(result, Ok(Some(expected_receipt)));
-    }
-
-    #[test]
-    fn get_transaction_receipt_handles_errors() {
-        let port = find_free_port();
-        let (event_loop_handle, transport) = Http::with_max_parallel(
-            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
-            REQUESTS_IN_PARALLEL,
-        )
-        .unwrap();
-        let chain = TEST_DEFAULT_CHAIN;
-        let subject = BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain);
-        let tx_hash = make_tx_hash(4564546);
-
-        let actual_error = subject.get_transaction_receipt(tx_hash).unwrap_err();
-        let error_message = if let BlockchainError::QueryFailed(em) = actual_error {
-            em
-        } else {
-            panic!("Expected BlockchainError::QueryFailed(msg)");
-        };
-        assert_string_contains(
-            error_message.as_str(),
-            "Transport error: Error(Connect, Os { code: ",
-        );
-        assert_string_contains(
-            error_message.as_str(),
-            ", kind: ConnectionRefused, message: ",
+            Subject::calculate_end_block_marker(
+                50,
+                BlockScanRange::Range(10),
+                Ok(120.into()),
+                &logger
+            ),
+            BlockMarker::Value(50 + 10)
         );
     }
 
     #[test]
-    fn advance_used_nonce() {
-        let initial_nonce = U256::from(55);
-
-        let result = BlockchainInterfaceWeb3::<TestTransport>::advance_used_nonce(initial_nonce);
-
-        assert_eq!(result, U256::from(56))
-    }
-
-    #[test]
-    fn output_by_joining_sources_works() {
-        let accounts = vec![
-            PayableAccount {
-                wallet: make_wallet("4567"),
-                balance_wei: 2_345_678,
-                last_paid_timestamp: from_time_t(4500000),
-                pending_payable_opt: None,
+    fn find_new_start_block_works() {
+        let logger = Logger::new("find_new_start_block_works");
+        let transactions = vec![
+            BlockchainTransaction {
+                block_number: 10,
+                from: make_wallet("wallet_1"),
+                wei_amount: 1000,
             },
-            PayableAccount {
-                wallet: make_wallet("5656"),
-                balance_wei: 6_543_210,
-                last_paid_timestamp: from_time_t(333000),
-                pending_payable_opt: None,
+            BlockchainTransaction {
+                block_number: 60,
+                from: make_wallet("wallet_1"),
+                wei_amount: 500,
             },
         ];
-        let fingerprint_inputs = vec![
-            (make_tx_hash(444), 2_345_678),
-            (make_tx_hash(333), 6_543_210),
-        ];
-        let responses = vec![
-            Ok(Value::String(String::from("blah"))),
-            Err(web3::Error::Rpc(RPCError {
-                code: ErrorCode::ParseError,
-                message: "I guess we've got a problem".to_string(),
-                data: None,
-            })),
-        ];
 
-        let result = BlockchainInterfaceWeb3::<TestTransport>::merged_output_data(
-            responses,
-            fingerprint_inputs,
-            &accounts,
-        );
+        type Subject = BlockchainInterfaceWeb3;
 
+        // Case 1: end_block_marker is Value
         assert_eq!(
-            result,
-            vec![
-                Ok(PendingPayable {
-                    recipient_wallet: make_wallet("4567"),
-                    hash: make_tx_hash(444)
-                }),
-                Err(RpcPayablesFailure {
-                    rpc_error: web3::Error::Rpc(RPCError {
-                        code: ErrorCode::ParseError,
-                        message: "I guess we've got a problem".to_string(),
-                        data: None,
-                    }),
-                    recipient_wallet: make_wallet("5656"),
-                    hash: make_tx_hash(333)
-                })
-            ]
-        )
-    }
-
-    fn make_initialized_agent(
-        gas_price_gwei: u64,
-        consuming_wallet: Wallet,
-        nonce: U256,
-    ) -> Box<dyn BlockchainAgent> {
-        Box::new(
-            BlockchainAgentMock::default()
-                .consuming_wallet_result(consuming_wallet)
-                .agreed_fee_per_computation_unit_result(gas_price_gwei)
-                .pending_transaction_id_result(nonce),
-        )
-    }
-
-    #[test]
-    fn hash_the_smart_contract_transfer_function_signature() {
+            Subject::find_new_start_block(
+                &[],
+                BlockMarker::Uninitialized,
+                BlockMarker::Value(100),
+                &logger
+            ),
+            101
+        );
+        // Case 2: end_block_marker is Uninitialized, highest block in transactions is Value
         assert_eq!(
-            "transfer(address,uint256)".keccak256()[0..4],
-            TRANSFER_METHOD_ID,
+            Subject::find_new_start_block(
+                &transactions,
+                BlockMarker::Uninitialized,
+                BlockMarker::Uninitialized,
+                &logger
+            ),
+            61
+        );
+        // Case 3: end_block_marker is Uninitialized, highest block in transactions is Uninitialized, start_block_marker is Value
+        assert_eq!(
+            Subject::find_new_start_block(
+                &[],
+                BlockMarker::Value(50),
+                BlockMarker::Uninitialized,
+                &logger
+            ),
+            51
+        );
+        // Case 4: end_block_marker is Uninitialized, highest block in transactions is Uninitialized, start_block_marker is Uninitialized
+        assert_eq!(
+            Subject::find_new_start_block(
+                &[],
+                BlockMarker::Uninitialized,
+                BlockMarker::Uninitialized,
+                &logger
+            ),
+            FRESH_START_BLOCK
         );
     }
 }
diff --git a/node/src/blockchain/blockchain_interface/blockchain_interface_web3/test_utils.rs b/node/src/blockchain/blockchain_interface/blockchain_interface_web3/test_utils.rs
deleted file mode 100644
index 55f9fbce7..000000000
--- a/node/src/blockchain/blockchain_interface/blockchain_interface_web3/test_utils.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright (c) 2023, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
-
-#![cfg(test)]
-
-use crate::blockchain::blockchain_bridge::PendingPayableFingerprintSeeds;
-use crate::blockchain::blockchain_interface::blockchain_interface_web3::batch_payable_tools::BatchPayableTools;
-use actix::Recipient;
-use jsonrpc_core as rpc;
-use std::cell::RefCell;
-use std::sync::{Arc, Mutex};
-use std::time::SystemTime;
-use web3::transports::Batch;
-use web3::types::{Bytes, SignedTransaction, TransactionParameters, H256};
-use web3::{BatchTransport, Error as Web3Error, Web3};
-
-#[derive(Default)]
-pub struct BatchPayableToolsMock<T: BatchTransport> {
-    sign_transaction_params: Arc<
-        Mutex<
-            Vec<(
-                TransactionParameters,
-                Web3<Batch<T>>,
-                secp256k1secrets::key::SecretKey,
-            )>,
-        >,
-    >,
-    sign_transaction_results: RefCell<Vec<Result<SignedTransaction, Web3Error>>>,
-    append_transaction_to_batch_params: Arc<Mutex<Vec<(Bytes, Web3<Batch<T>>)>>>,
-    //append_transaction_to_batch returns just the unit type
-    //batch_wide_timestamp doesn't have params
-    batch_wide_timestamp_results: RefCell<Vec<SystemTime>>,
-    send_new_payable_fingerprints_seeds_params: Arc<
-        Mutex<
-            Vec<(
-                SystemTime,
-                Recipient<PendingPayableFingerprintSeeds>,
-                Vec<(H256, u128)>,
-            )>,
-        >,
-    >,
-    //new_payable_fingerprints returns just the unit type
-    submit_batch_params: Arc<Mutex<Vec<Web3<Batch<T>>>>>,
-    submit_batch_results:
-        RefCell<Vec<Result<Vec<web3::transports::Result<rpc::Value>>, Web3Error>>>,
-}
-
-impl<T: BatchTransport> BatchPayableTools<T> for BatchPayableToolsMock<T> {
-    fn sign_transaction(
-        &self,
-        transaction_params: TransactionParameters,
-        web3: &Web3<Batch<T>>,
-        key: &secp256k1secrets::key::SecretKey,
-    ) -> Result<SignedTransaction, Web3Error> {
-        self.sign_transaction_params.lock().unwrap().push((
-            transaction_params.clone(),
-            web3.clone(),
-            key.clone(),
-        ));
-        self.sign_transaction_results.borrow_mut().remove(0)
-    }
-
-    fn append_transaction_to_batch(&self, signed_transaction: Bytes, web3: &Web3<Batch<T>>) {
-        self.append_transaction_to_batch_params
-            .lock()
-            .unwrap()
-            .push((signed_transaction, web3.clone()));
-    }
-
-    fn batch_wide_timestamp(&self) -> SystemTime {
-        self.batch_wide_timestamp_results.borrow_mut().remove(0)
-    }
-
-    fn send_new_payable_fingerprints_seeds(
-        &self,
-        batch_wide_timestamp: SystemTime,
-        pp_fingerprint_sub: &Recipient<PendingPayableFingerprintSeeds>,
-        hashes_and_balances: &[(H256, u128)],
-    ) {
-        self.send_new_payable_fingerprints_seeds_params
-            .lock()
-            .unwrap()
-            .push((
-                batch_wide_timestamp,
-                (*pp_fingerprint_sub).clone(),
-                hashes_and_balances.to_vec(),
-            ));
-    }
-
-    fn submit_batch(
-        &self,
-        web3: &Web3<Batch<T>>,
-    ) -> Result<Vec<web3::transports::Result<rpc::Value>>, Web3Error> {
-        self.submit_batch_params.lock().unwrap().push(web3.clone());
-        self.submit_batch_results.borrow_mut().remove(0)
-    }
-}
-
-impl<T: BatchTransport> BatchPayableToolsMock<T> {
-    pub fn sign_transaction_params(
-        mut self,
-        params: &Arc<
-            Mutex<
-                Vec<(
-                    TransactionParameters,
-                    Web3<Batch<T>>,
-                    secp256k1secrets::key::SecretKey,
-                )>,
-            >,
-        >,
-    ) -> Self {
-        self.sign_transaction_params = params.clone();
-        self
-    }
-
-    pub fn sign_transaction_result(self, result: Result<SignedTransaction, Web3Error>) -> Self {
-        self.sign_transaction_results.borrow_mut().push(result);
-        self
-    }
-
-    pub fn batch_wide_timestamp_result(self, result: SystemTime) -> Self {
-        self.batch_wide_timestamp_results.borrow_mut().push(result);
-        self
-    }
-
-    pub fn send_new_payable_fingerprint_credentials_params(
-        mut self,
-        params: &Arc<
-            Mutex<
-                Vec<(
-                    SystemTime,
-                    Recipient<PendingPayableFingerprintSeeds>,
-                    Vec<(H256, u128)>,
-                )>,
-            >,
-        >,
-    ) -> Self {
-        self.send_new_payable_fingerprints_seeds_params = params.clone();
-        self
-    }
-
-    pub fn append_transaction_to_batch_params(
-        mut self,
-        params: &Arc<Mutex<Vec<(Bytes, Web3<Batch<T>>)>>>,
-    ) -> Self {
-        self.append_transaction_to_batch_params = params.clone();
-        self
-    }
-
-    pub fn submit_batch_params(mut self, params: &Arc<Mutex<Vec<Web3<Batch<T>>>>>) -> Self {
-        self.submit_batch_params = params.clone();
-        self
-    }
-
-    pub fn submit_batch_result(
-        self,
-        result: Result<Vec<web3::transports::Result<rpc::Value>>, Web3Error>,
-    ) -> Self {
-        self.submit_batch_results.borrow_mut().push(result);
-        self
-    }
-}
-
-pub fn make_default_signed_transaction() -> SignedTransaction {
-    SignedTransaction {
-        message_hash: Default::default(),
-        v: 0,
-        r: Default::default(),
-        s: Default::default(),
-        raw_transaction: Default::default(),
-        transaction_hash: Default::default(),
-    }
-}
diff --git a/node/src/blockchain/blockchain_interface/blockchain_interface_web3/utils.rs b/node/src/blockchain/blockchain_interface/blockchain_interface_web3/utils.rs
new file mode 100644
index 000000000..2be7d5977
--- /dev/null
+++ b/node/src/blockchain/blockchain_interface/blockchain_interface_web3/utils.rs
@@ -0,0 +1,1062 @@
+// Copyright (c) 2024, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
+
+use crate::accountant::db_access_objects::payable_dao::PayableAccount;
+use crate::accountant::db_access_objects::pending_payable_dao::PendingPayable;
+use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::agent_web3::BlockchainAgentWeb3;
+use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
+use crate::blockchain::blockchain_bridge::PendingPayableFingerprintSeeds;
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::{
+    BlockchainInterfaceWeb3, HashAndAmount, TRANSFER_METHOD_ID,
+};
+use crate::blockchain::blockchain_interface::data_structures::errors::PayableTransactionError;
+use crate::blockchain::blockchain_interface::data_structures::{
+    ProcessedPayableFallible, RpcPayableFailure,
+};
+use crate::sub_lib::blockchain_bridge::ConsumingWalletBalances;
+use crate::sub_lib::wallet::Wallet;
+use actix::Recipient;
+use futures::Future;
+use masq_lib::blockchains::chains::Chain;
+use masq_lib::logger::Logger;
+use secp256k1secrets::SecretKey;
+use serde_json::Value;
+use std::iter::once;
+use std::time::SystemTime;
+use thousands::Separable;
+use web3::transports::{Batch, Http};
+use web3::types::{Bytes, SignedTransaction, TransactionParameters, U256};
+use web3::Error as Web3Error;
+use web3::Web3;
+
+#[derive(Debug)]
+pub struct BlockchainAgentFutureResult {
+    pub gas_price_wei: U256,
+    pub transaction_fee_balance: U256,
+    pub masq_token_balance: U256,
+}
+pub fn advance_used_nonce(current_nonce: U256) -> U256 {
+    current_nonce
+        .checked_add(U256::one())
+        .expect("unexpected limits")
+}
+
+fn error_with_hashes(
+    error: Web3Error,
+    hashes_and_paid_amounts: Vec<HashAndAmount>,
+) -> PayableTransactionError {
+    let hashes = hashes_and_paid_amounts
+        .into_iter()
+        .map(|hash_and_amount| hash_and_amount.hash)
+        .collect();
+    PayableTransactionError::Sending {
+        msg: error.to_string(),
+        hashes,
+    }
+}
+
+pub fn merged_output_data(
+    responses: Vec<web3::transports::Result<Value>>,
+    hashes_and_paid_amounts: Vec<HashAndAmount>,
+    accounts: Vec<PayableAccount>,
+) -> Vec<ProcessedPayableFallible> {
+    let iterator_with_all_data = responses
+        .into_iter()
+        .zip(hashes_and_paid_amounts.into_iter())
+        .zip(accounts.iter());
+    iterator_with_all_data
+        .map(
+            |((rpc_result, hash_and_amount), account)| match rpc_result {
+                Ok(_rpc_result) => {
+                    // TODO: GH-547: This rpc_result should be validated
+                    ProcessedPayableFallible::Correct(PendingPayable {
+                        recipient_wallet: account.wallet.clone(),
+                        hash: hash_and_amount.hash,
+                    })
+                }
+                Err(rpc_error) => ProcessedPayableFallible::Failed(RpcPayableFailure {
+                    rpc_error,
+                    recipient_wallet: account.wallet.clone(),
+                    hash: hash_and_amount.hash,
+                }),
+            },
+        )
+        .collect()
+}
+
+pub fn transmission_log(
+    chain: Chain,
+    accounts: &[PayableAccount],
+    gas_price_in_wei: u128,
+) -> String {
+    let chain_name = chain
+        .rec()
+        .literal_identifier
+        .chars()
+        .skip_while(|char| char != &'-')
+        .skip(1)
+        .collect::<String>();
+    let introduction = once(format!(
+        "\
+        Paying to creditors...\n\
+        Transactions in the batch:\n\
+        \n\
+        gas price:                                   {} wei\n\
+        chain:                                       {}\n\
+        \n\
+        [wallet address]                             [payment in wei]\n",
+        gas_price_in_wei, chain_name
+    ));
+    let body = accounts.iter().map(|account| {
+        format!(
+            "{}   {}\n",
+            account.wallet,
+            account.balance_wei.separate_with_commas()
+        )
+    });
+    introduction.chain(body).collect()
+}
+
+pub fn sign_transaction_data(amount: u128, recipient_wallet: Wallet) -> [u8; 68] {
+    let mut data = [0u8; 4 + 32 + 32];
+    data[0..4].copy_from_slice(&TRANSFER_METHOD_ID);
+    data[16..36].copy_from_slice(&recipient_wallet.address().0[..]);
+    U256::from(amount).to_big_endian(&mut data[36..68]);
+    data
+}
+
+pub fn gas_limit(data: [u8; 68], chain: Chain) -> U256 {
+    let base_gas_limit = BlockchainInterfaceWeb3::web3_gas_limit_const_part(chain);
+    ethereum_types::U256::try_from(data.iter().fold(base_gas_limit, |acc, v| {
+        acc + if v == &0u8 { 4 } else { 68 }
+    }))
+    .expect("Internal error")
+}
+
+pub fn sign_transaction(
+    chain: Chain,
+    web3_batch: &Web3<Batch<Http>>,
+    recipient_wallet: Wallet,
+    consuming_wallet: Wallet,
+    amount: u128,
+    nonce: U256,
+    gas_price_in_wei: u128,
+) -> SignedTransaction {
+    let data = sign_transaction_data(amount, recipient_wallet);
+    let gas_limit = gas_limit(data, chain);
+    // Warning: If you set gas_price or nonce to None in transaction_parameters, sign_transaction will start making RPC calls which we don't want (Do it at your own risk).
+    let transaction_parameters = TransactionParameters {
+        nonce: Some(nonce),
+        to: Some(chain.rec().contract),
+        gas: gas_limit,
+        gas_price: Some(U256::from(gas_price_in_wei)),
+        value: ethereum_types::U256::zero(),
+        data: Bytes(data.to_vec()),
+        chain_id: Some(chain.rec().num_chain_id),
+    };
+    let key = consuming_wallet
+        .prepare_secp256k1_secret()
+        .expect("Consuming wallet doesn't contain a secret key");
+
+    sign_transaction_locally(web3_batch, transaction_parameters, &key)
+}
+
+pub fn sign_transaction_locally(
+    web3_batch: &Web3<Batch<Http>>,
+    transaction_parameters: TransactionParameters,
+    key: &SecretKey,
+) -> SignedTransaction {
+    if transaction_parameters.nonce.is_none()
+        || transaction_parameters.chain_id.is_none()
+        || transaction_parameters.gas_price.is_none()
+    {
+        panic!("We don't want to fetch any values while signing");
+    }
+
+    // This wait call doesn't actually make any RPC call as long as nonce, chain_id & gas_price are set.
+    web3_batch
+        .accounts()
+        .sign_transaction(transaction_parameters, key)
+        .wait()
+        .expect("Web call wasn't allowed")
+}
+
+pub fn sign_and_append_payment(
+    chain: Chain,
+    web3_batch: &Web3<Batch<Http>>,
+    recipient: &PayableAccount,
+    consuming_wallet: Wallet,
+    nonce: U256,
+    gas_price_in_wei: u128,
+) -> HashAndAmount {
+    let signed_tx = sign_transaction(
+        chain,
+        web3_batch,
+        recipient.wallet.clone(),
+        consuming_wallet,
+        recipient.balance_wei,
+        nonce,
+        gas_price_in_wei,
+    );
+    append_signed_transaction_to_batch(web3_batch, signed_tx.raw_transaction);
+
+    HashAndAmount {
+        hash: signed_tx.transaction_hash,
+        amount: recipient.balance_wei,
+    }
+}
+
+pub fn append_signed_transaction_to_batch(web3_batch: &Web3<Batch<Http>>, raw_transaction: Bytes) {
+    // This function only prepares a raw transaction for a batch call and doesn't actually send it right here.
+    web3_batch.eth().send_raw_transaction(raw_transaction);
+}
+
+pub fn sign_and_append_multiple_payments(
+    logger: &Logger,
+    chain: Chain,
+    web3_batch: &Web3<Batch<Http>>,
+    consuming_wallet: Wallet,
+    gas_price_in_wei: u128,
+    mut pending_nonce: U256,
+    accounts: &[PayableAccount],
+) -> Vec<HashAndAmount> {
+    let mut hash_and_amount_list = vec![];
+    accounts.iter().for_each(|payable| {
+        debug!(
+            logger,
+            "Preparing payable future of {} wei to {} with nonce {}",
+            payable.balance_wei.separate_with_commas(),
+            payable.wallet,
+            pending_nonce
+        );
+
+        let hash_and_amount = sign_and_append_payment(
+            chain,
+            web3_batch,
+            payable,
+            consuming_wallet.clone(),
+            pending_nonce,
+            gas_price_in_wei,
+        );
+
+        pending_nonce = advance_used_nonce(pending_nonce);
+        hash_and_amount_list.push(hash_and_amount);
+    });
+    hash_and_amount_list
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn send_payables_within_batch(
+    logger: &Logger,
+    chain: Chain,
+    web3_batch: &Web3<Batch<Http>>,
+    consuming_wallet: Wallet,
+    gas_price_in_wei: u128,
+    pending_nonce: U256,
+    new_fingerprints_recipient: Recipient<PendingPayableFingerprintSeeds>,
+    accounts: Vec<PayableAccount>,
+) -> Box<dyn Future<Item = Vec<ProcessedPayableFallible>, Error = PayableTransactionError> + 'static>
+{
+    debug!(
+            logger,
+            "Common attributes of payables to be transacted: sender wallet: {}, contract: {:?}, chain_id: {}, gas_price: {}",
+            consuming_wallet,
+            chain.rec().contract,
+            chain.rec().num_chain_id,
+            gas_price_in_wei
+        );
+
+    let hashes_and_paid_amounts = sign_and_append_multiple_payments(
+        logger,
+        chain,
+        web3_batch,
+        consuming_wallet,
+        gas_price_in_wei,
+        pending_nonce,
+        &accounts,
+    );
+
+    let timestamp = SystemTime::now();
+    let hashes_and_paid_amounts_error = hashes_and_paid_amounts.clone();
+    let hashes_and_paid_amounts_ok = hashes_and_paid_amounts.clone();
+
+    // TODO: We are sending hashes_and_paid_amounts to the Accountant even if the payments fail.
+    new_fingerprints_recipient
+        .try_send(PendingPayableFingerprintSeeds {
+            batch_wide_timestamp: timestamp,
+            hashes_and_balances: hashes_and_paid_amounts,
+        })
+        .expect("Accountant is dead");
+
+    info!(
+        logger,
+        "{}",
+        transmission_log(chain, &accounts, gas_price_in_wei)
+    );
+
+    Box::new(
+        web3_batch
+            .transport()
+            .submit_batch()
+            .map_err(|e| error_with_hashes(e, hashes_and_paid_amounts_error))
+            .and_then(move |batch_response| {
+                Ok(merged_output_data(
+                    batch_response,
+                    hashes_and_paid_amounts_ok,
+                    accounts,
+                ))
+            }),
+    )
+}
+
+pub fn create_blockchain_agent_web3(
+    gas_limit_const_part: u128,
+    blockchain_agent_future_result: BlockchainAgentFutureResult,
+    wallet: Wallet,
+    chain: Chain,
+) -> Box<dyn BlockchainAgent> {
+    Box::new(BlockchainAgentWeb3::new(
+        blockchain_agent_future_result.gas_price_wei.as_u128(),
+        gas_limit_const_part,
+        wallet,
+        ConsumingWalletBalances {
+            transaction_fee_balance_in_minor_units: blockchain_agent_future_result
+                .transaction_fee_balance,
+            masq_token_balance_in_minor_units: blockchain_agent_future_result.masq_token_balance,
+        },
+        chain,
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::accountant::db_access_objects::utils::from_time_t;
+    use crate::accountant::gwei_to_wei;
+    use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::agent_web3::WEB3_MAXIMAL_GAS_LIMIT_MARGIN;
+    use crate::accountant::test_utils::{
+        make_payable_account, make_payable_account_with_wallet_and_balance_and_timestamp_opt,
+    };
+    use crate::blockchain::bip32::Bip32EncryptionKeyProvider;
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::{
+        BlockchainInterfaceWeb3, REQUESTS_IN_PARALLEL,
+    };
+    use crate::blockchain::blockchain_interface::data_structures::errors::PayableTransactionError::Sending;
+    use crate::blockchain::blockchain_interface::data_structures::ProcessedPayableFallible::{
+        Correct, Failed,
+    };
+    use crate::blockchain::test_utils::{
+        make_tx_hash, transport_error_code, transport_error_message,
+    };
+    use crate::sub_lib::wallet::Wallet;
+    use crate::test_utils::make_paying_wallet;
+    use crate::test_utils::make_wallet;
+    use crate::test_utils::recorder::make_recorder;
+    use crate::test_utils::unshared_test_utils::decode_hex;
+    use actix::{Actor, System};
+    use ethabi::Address;
+    use ethereum_types::H256;
+    use jsonrpc_core::ErrorCode::ServerError;
+    use jsonrpc_core::{Error, ErrorCode};
+    use masq_lib::constants::{DEFAULT_CHAIN, DEFAULT_GAS_PRICE};
+    use masq_lib::test_utils::logging::{init_test_logging, TestLogHandler};
+    use masq_lib::test_utils::mock_blockchain_client_server::MBCSBuilder;
+    use masq_lib::test_utils::utils::TEST_DEFAULT_CHAIN;
+    use masq_lib::utils::find_free_port;
+    use serde_json::Value;
+    use std::net::Ipv4Addr;
+    use std::str::FromStr;
+    use std::time::SystemTime;
+    use web3::api::Namespace;
+    use web3::Error::Rpc;
+
+    #[test]
+    fn sign_and_append_payment_works() {
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .begin_batch()
+            .ok_response(
+                "0x94881436a9c89f48b01651ff491c69e97089daf71ab8cfb240243d7ecf9b38b2".to_string(),
+                7,
+            )
+            .end_batch()
+            .start();
+        let (_event_loop_handle, transport) = Http::with_max_parallel(
+            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
+            REQUESTS_IN_PARALLEL,
+        )
+        .unwrap();
+        let pending_nonce = 1;
+        let chain = DEFAULT_CHAIN;
+        let gas_price_in_gwei = DEFAULT_GAS_PRICE;
+        let consuming_wallet = make_paying_wallet(b"paying_wallet");
+        let account = make_payable_account(1);
+        let web3_batch = Web3::new(Batch::new(transport));
+
+        let result = sign_and_append_payment(
+            chain,
+            &web3_batch,
+            &account,
+            consuming_wallet,
+            pending_nonce.into(),
+            gwei_to_wei(gas_price_in_gwei),
+        );
+
+        let mut batch_result = web3_batch.eth().transport().submit_batch().wait().unwrap();
+        assert_eq!(
+            result,
+            HashAndAmount {
+                hash: H256::from_str(
+                    "94881436a9c89f48b01651ff491c69e97089daf71ab8cfb240243d7ecf9b38b2"
+                )
+                .unwrap(),
+                amount: account.balance_wei
+            }
+        );
+        assert_eq!(
+            batch_result.pop().unwrap().unwrap(),
+            Value::String(
+                "0x94881436a9c89f48b01651ff491c69e97089daf71ab8cfb240243d7ecf9b38b2".to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn send_and_append_multiple_payments_works() {
+        let port = find_free_port();
+        let logger = Logger::new("send_and_append_multiple_payments_works");
+        let (_event_loop_handle, transport) = Http::with_max_parallel(
+            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
+            REQUESTS_IN_PARALLEL,
+        )
+        .unwrap();
+        let web3_batch = Web3::new(Batch::new(transport));
+        let chain = DEFAULT_CHAIN;
+        let gas_price_in_gwei = DEFAULT_GAS_PRICE;
+        let pending_nonce = 1;
+        let consuming_wallet = make_paying_wallet(b"paying_wallet");
+        let account_1 = make_payable_account(1);
+        let account_2 = make_payable_account(2);
+        let accounts = vec![account_1, account_2];
+
+        let result = sign_and_append_multiple_payments(
+            &logger,
+            chain,
+            &web3_batch,
+            consuming_wallet,
+            gwei_to_wei(gas_price_in_gwei),
+            pending_nonce.into(),
+            &accounts,
+        );
+
+        assert_eq!(
+            result,
+            vec![
+                HashAndAmount {
+                    hash: H256::from_str(
+                        "94881436a9c89f48b01651ff491c69e97089daf71ab8cfb240243d7ecf9b38b2"
+                    )
+                    .unwrap(),
+                    amount: 1000000000
+                },
+                HashAndAmount {
+                    hash: H256::from_str(
+                        "3811874d2b73cecd51234c94af46bcce918d0cb4de7d946c01d7da606fe761b5"
+                    )
+                    .unwrap(),
+                    amount: 2000000000
+                }
+            ]
+        );
+    }
+
+    #[test]
+    fn transmission_log_just_works() {
+        init_test_logging();
+        let test_name = "transmission_log_just_works";
+        let gas_price = 120;
+        let logger = Logger::new(test_name);
+        let amount_1 = gwei_to_wei(900_000_000_u64);
+        let account_1 = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
+            make_wallet("w123"),
+            amount_1,
+            None,
+        );
+        let amount_2 = 123_456_789_u128;
+        let account_2 = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
+            make_wallet("w555"),
+            amount_2,
+            None,
+        );
+        let amount_3 = gwei_to_wei(33_355_666_u64);
+        let account_3 = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
+            make_wallet("w987"),
+            amount_3,
+            None,
+        );
+        let accounts_to_process = vec![account_1, account_2, account_3];
+
+        info!(
+            logger,
+            "{}",
+            transmission_log(TEST_DEFAULT_CHAIN, &accounts_to_process, gas_price)
+        );
+
+        let log_handler = TestLogHandler::new();
+        log_handler.exists_log_containing(
+            "INFO: transmission_log_just_works: Paying to creditors...\n\
+        Transactions in the batch:\n\
+        \n\
+        gas price:                                   120 wei\n\
+        chain:                                       ropsten\n\
+        \n\
+        [wallet address]                             [payment in wei]\n\
+        0x0000000000000000000000000000000077313233   900,000,000,000,000,000\n\
+        0x0000000000000000000000000000000077353535   123,456,789\n\
+        0x0000000000000000000000000000000077393837   33,355,666,000,000,000\n",
+        );
+    }
+
+    #[test]
+    fn output_by_joining_sources_works() {
+        let accounts = vec![
+            PayableAccount {
+                wallet: make_wallet("4567"),
+                balance_wei: 2_345_678,
+                last_paid_timestamp: from_time_t(4500000),
+                pending_payable_opt: None,
+            },
+            PayableAccount {
+                wallet: make_wallet("5656"),
+                balance_wei: 6_543_210,
+                last_paid_timestamp: from_time_t(333000),
+                pending_payable_opt: None,
+            },
+        ];
+        let fingerprint_inputs = vec![
+            HashAndAmount {
+                hash: make_tx_hash(444),
+                amount: 2_345_678,
+            },
+            HashAndAmount {
+                hash: make_tx_hash(333),
+                amount: 6_543_210,
+            },
+        ];
+        let responses = vec![
+            Ok(Value::String(String::from("blah"))),
+            Err(web3::Error::Rpc(Error {
+                code: ErrorCode::ParseError,
+                message: "I guess we've got a problem".to_string(),
+                data: None,
+            })),
+        ];
+
+        let result = merged_output_data(responses, fingerprint_inputs, accounts.to_vec());
+
+        assert_eq!(
+            result,
+            vec![
+                Correct(PendingPayable {
+                    recipient_wallet: make_wallet("4567"),
+                    hash: make_tx_hash(444)
+                }),
+                Failed(RpcPayableFailure {
+                    rpc_error: web3::Error::Rpc(Error {
+                        code: ErrorCode::ParseError,
+                        message: "I guess we've got a problem".to_string(),
+                        data: None,
+                    }),
+                    recipient_wallet: make_wallet("5656"),
+                    hash: make_tx_hash(333)
+                })
+            ]
+        )
+    }
+
+    fn execute_send_payables_test(
+        test_name: &str,
+        accounts: Vec<PayableAccount>,
+        expected_result: Result<Vec<ProcessedPayableFallible>, PayableTransactionError>,
+        port: u16,
+    ) {
+        init_test_logging();
+        let (_event_loop_handle, transport) = Http::with_max_parallel(
+            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
+            REQUESTS_IN_PARALLEL,
+        )
+        .unwrap();
+        let gas_price = 1_000_000_000;
+        let pending_nonce: U256 = 1.into();
+        let web3_batch = Web3::new(Batch::new(transport));
+        let (accountant, _, accountant_recording) = make_recorder();
+        let logger = Logger::new(test_name);
+        let chain = DEFAULT_CHAIN;
+        let consuming_wallet = make_paying_wallet(b"consuming_wallet");
+        let new_fingerprints_recipient = accountant.start().recipient();
+        let system = System::new(test_name);
+        let timestamp_before = SystemTime::now();
+
+        let result = send_payables_within_batch(
+            &logger,
+            chain,
+            &web3_batch,
+            consuming_wallet.clone(),
+            gas_price,
+            pending_nonce,
+            new_fingerprints_recipient,
+            accounts.clone(),
+        )
+        .wait();
+
+        System::current().stop();
+        system.run();
+        let timestamp_after = SystemTime::now();
+        let accountant_recording_result = accountant_recording.lock().unwrap();
+        let ppfs_message =
+            accountant_recording_result.get_record::<PendingPayableFingerprintSeeds>(0);
+        assert_eq!(accountant_recording_result.len(), 1);
+        assert!(timestamp_before <= ppfs_message.batch_wide_timestamp);
+        assert!(timestamp_after >= ppfs_message.batch_wide_timestamp);
+        let tlh = TestLogHandler::new();
+        tlh.exists_log_containing(
+            &format!("DEBUG: {test_name}: Common attributes of payables to be transacted: sender wallet: {}, contract: {:?}, chain_id: {}, gas_price: {}",
+                     consuming_wallet,
+                     chain.rec().contract,
+                     chain.rec().num_chain_id,
+                     gas_price
+            )
+        );
+        tlh.exists_log_containing(&format!(
+            "INFO: {test_name}: {}",
+            transmission_log(chain, &accounts, gas_price)
+        ));
+        assert_eq!(result, expected_result);
+    }
+
+    #[test]
+    fn send_payables_within_batch_works() {
+        let accounts = vec![make_payable_account(1), make_payable_account(2)];
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .begin_batch()
+            // TODO: GH-547: This rpc_result should be validated in production code.
+            .ok_response("irrelevant_ok_rpc_response".to_string(), 7)
+            .ok_response("irrelevant_ok_rpc_response_2".to_string(), 8)
+            .end_batch()
+            .start();
+        let expected_result = Ok(vec![
+            Correct(PendingPayable {
+                recipient_wallet: accounts[0].wallet.clone(),
+                hash: H256::from_str(
+                    "35f42b260f090a559e8b456718d9c91a9da0f234ed0a129b9d5c4813b6615af4",
+                )
+                .unwrap(),
+            }),
+            Correct(PendingPayable {
+                recipient_wallet: accounts[1].wallet.clone(),
+                hash: H256::from_str(
+                    "7f3221109e4f1de8ba1f7cd358aab340ecca872a1456cb1b4f59ca33d3e22ee3",
+                )
+                .unwrap(),
+            }),
+        ]);
+
+        execute_send_payables_test(
+            "send_payables_within_batch_works",
+            accounts,
+            expected_result,
+            port,
+        );
+    }
+
+    #[test]
+    fn send_payables_within_batch_fails_on_submit_batch_call() {
+        let accounts = vec![make_payable_account(1), make_payable_account(2)];
+        let os_code = transport_error_code();
+        let os_msg = transport_error_message();
+        let port = find_free_port();
+        let expected_result = Err(Sending {
+            msg: format!("Transport error: Error(Connect, Os {{ code: {}, kind: ConnectionRefused, message: {:?} }})", os_code, os_msg).to_string(),
+            hashes: vec![
+                H256::from_str("35f42b260f090a559e8b456718d9c91a9da0f234ed0a129b9d5c4813b6615af4").unwrap(),
+                H256::from_str("7f3221109e4f1de8ba1f7cd358aab340ecca872a1456cb1b4f59ca33d3e22ee3").unwrap()
+            ],
+        });
+
+        execute_send_payables_test(
+            "send_payables_within_batch_fails_on_submit_batch_call",
+            accounts,
+            expected_result,
+            port,
+        );
+    }
+
+    #[test]
+    fn send_payables_within_batch_all_payments_fail() {
+        let accounts = vec![make_payable_account(1), make_payable_account(2)];
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .begin_batch()
+            .err_response(
+                429,
+                "The requests per second (RPS) of your requests are higher than your plan allows."
+                    .to_string(),
+                7,
+            )
+            .err_response(
+                429,
+                "The requests per second (RPS) of your requests are higher than your plan allows."
+                    .to_string(),
+                8,
+            )
+            .end_batch()
+            .start();
+        let expected_result = Ok(vec![
+            Failed(RpcPayableFailure {
+                rpc_error: Rpc(Error {
+                    code: ServerError(429),
+                    message: "The requests per second (RPS) of your requests are higher than your plan allows.".to_string(),
+                    data: None,
+                }),
+                recipient_wallet: accounts[0].wallet.clone(),
+                hash: H256::from_str("35f42b260f090a559e8b456718d9c91a9da0f234ed0a129b9d5c4813b6615af4").unwrap(),
+            }),
+            Failed(RpcPayableFailure {
+                rpc_error: Rpc(Error {
+                    code: ServerError(429),
+                    message: "The requests per second (RPS) of your requests are higher than your plan allows.".to_string(),
+                    data: None,
+                }),
+                recipient_wallet: accounts[1].wallet.clone(),
+                hash: H256::from_str("7f3221109e4f1de8ba1f7cd358aab340ecca872a1456cb1b4f59ca33d3e22ee3").unwrap(),
+            }),
+        ]);
+
+        execute_send_payables_test(
+            "send_payables_within_batch_all_payments_fail",
+            accounts,
+            expected_result,
+            port,
+        );
+    }
+
+    #[test]
+    fn send_payables_within_batch_one_payment_works_the_other_fails() {
+        let accounts = vec![make_payable_account(1), make_payable_account(2)];
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .begin_batch()
+            .ok_response("rpc_result".to_string(), 7)
+            .err_response(
+                429,
+                "The requests per second (RPS) of your requests are higher than your plan allows."
+                    .to_string(),
+                7,
+            )
+            .end_batch()
+            .start();
+        let expected_result = Ok(vec![
+            Correct(PendingPayable {
+                recipient_wallet: accounts[0].wallet.clone(),
+                hash: H256::from_str("35f42b260f090a559e8b456718d9c91a9da0f234ed0a129b9d5c4813b6615af4").unwrap(),
+            }),
+            Failed(RpcPayableFailure {
+                rpc_error: Rpc(Error {
+                    code: ServerError(429),
+                    message: "The requests per second (RPS) of your requests are higher than your plan allows.".to_string(),
+                    data: None,
+                }),
+                recipient_wallet: accounts[1].wallet.clone(),
+                hash: H256::from_str("7f3221109e4f1de8ba1f7cd358aab340ecca872a1456cb1b4f59ca33d3e22ee3").unwrap(),
+            }),
+        ]);
+
+        execute_send_payables_test(
+            "send_payables_within_batch_one_payment_works_the_other_fails",
+            accounts,
+            expected_result,
+            port,
+        );
+    }
+
+    #[test]
+    fn advance_used_nonce_works() {
+        let initial_nonce = U256::from(55);
+
+        let result = advance_used_nonce(initial_nonce);
+
+        assert_eq!(result, U256::from(56))
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Consuming wallet doesn't contain a secret key: Signature(\"Cannot sign with non-keypair wallet: Address(0x000000000000000000006261645f77616c6c6574).\")"
+    )]
+    fn sign_transaction_panics_due_to_lack_of_secret_key() {
+        let port = find_free_port();
+        let (_event_loop_handle, transport) = Http::with_max_parallel(
+            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
+            REQUESTS_IN_PARALLEL,
+        )
+        .unwrap();
+        let recipient_wallet = make_wallet("unlucky man");
+        let consuming_wallet = make_wallet("bad_wallet");
+        let gas_price = 123_000_000_000;
+        let nonce = U256::from(1);
+
+        sign_transaction(
+            Chain::PolyAmoy,
+            &Web3::new(Batch::new(transport)),
+            recipient_wallet,
+            consuming_wallet,
+            444444,
+            nonce,
+            gas_price,
+        );
+    }
+
+    #[test]
+    fn sign_transaction_just_works() {
+        let port = find_free_port();
+        let (_event_loop_handle, transport) = Http::with_max_parallel(
+            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
+            REQUESTS_IN_PARALLEL,
+        )
+        .unwrap();
+        let web3 = Web3::new(transport.clone());
+        let chain = DEFAULT_CHAIN;
+        let amount = 11_222_333_444;
+        let gas_price_in_wei = 123 * 10_u128.pow(18);
+        let nonce = U256::from(5);
+        let recipient_wallet = make_wallet("recipient_wallet");
+        let consuming_wallet = make_paying_wallet(b"consuming_wallet");
+        let consuming_wallet_secret_key = consuming_wallet.prepare_secp256k1_secret().unwrap();
+        let data = sign_transaction_data(amount, recipient_wallet.clone());
+        let tx_parameters = TransactionParameters {
+            nonce: Some(nonce),
+            to: Some(chain.rec().contract),
+            gas: gas_limit(data, chain),
+            gas_price: Some(U256::from(gas_price_in_wei)),
+            value: U256::zero(),
+            data: Bytes(data.to_vec()),
+            chain_id: Some(chain.rec().num_chain_id),
+        };
+        let result = sign_transaction(
+            chain,
+            &Web3::new(Batch::new(transport)),
+            recipient_wallet,
+            consuming_wallet,
+            amount,
+            nonce,
+            gas_price_in_wei,
+        );
+
+        let expected_tx_result = web3
+            .accounts()
+            .sign_transaction(tx_parameters, &consuming_wallet_secret_key)
+            .wait()
+            .unwrap();
+
+        assert_eq!(result, expected_tx_result);
+    }
+
+    #[test]
+    #[should_panic(expected = "We don't want to fetch any values while signing")]
+    fn sign_transaction_locally_panics_on_signed_transaction() {
+        let port = find_free_port();
+        let (_event_loop_handle, transport) = Http::with_max_parallel(
+            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
+            REQUESTS_IN_PARALLEL,
+        )
+        .unwrap();
+        let chain = DEFAULT_CHAIN;
+        let amount = 11_222_333_444;
+        let gas_limit = U256::from(5);
+        let gas_price = U256::from(5);
+        let recipient_wallet = make_wallet("recipient_wallet");
+        let consuming_wallet = make_paying_wallet(b"consuming_wallet");
+        let data = sign_transaction_data(amount, recipient_wallet);
+        // sign_transaction makes a blockchain call because nonce is set to None
+        let transaction_parameters = TransactionParameters {
+            nonce: None,
+            to: Some(chain.rec().contract),
+            gas: gas_limit,
+            gas_price: Some(gas_price),
+            value: U256::zero(),
+            data: Bytes(data.to_vec()),
+            chain_id: Some(chain.rec().num_chain_id),
+        };
+        let key = consuming_wallet
+            .prepare_secp256k1_secret()
+            .expect("Consuming wallet doesn't contain a secret key");
+
+        let _result = sign_transaction_locally(
+            &Web3::new(Batch::new(transport)),
+            transaction_parameters,
+            &key,
+        );
+    }
+
+    //with a real confirmation through a transaction sent with this data to the network
+    #[test]
+    fn web3_interface_signing_a_transaction_works_for_polygon_amoy() {
+        let chain = Chain::PolyAmoy;
+        let nonce = 4;
+        let signed_transaction_data = "f8ad04850ba43b74008301198094d98c3ebd6b7f9b7cda2449ecac00d1e5f47a819380b844a9\
+        059cbb0000000000000000000000007788df76bbd9a0c7c3e5bf0f77bb28c60a167a7b0000000000000000000000000000000000000000000\
+        00000000000e8d4a5100083027127a0ef0873170be31c30f532edf3c97fe8a1d577859fd4045b060007cf9e75bda875a01e4a3f7e06d12b22\
+        68d9889e279643ad8e1d291bca8f9f741bd6ec1aca2c0766";
+        let in_bytes = decode_hex(signed_transaction_data).unwrap();
+
+        assert_that_signed_transactions_agrees_with_template(chain, nonce, &in_bytes)
+    }
+
+    //with a real confirmation through a transaction sent with this data to the network
+    #[test]
+    fn web3_interface_signing_a_transaction_works_for_eth_ropsten() {
+        let chain = Chain::EthRopsten;
+        let nonce = 1; //must stay like this!
+        let signed_transaction_data = "f8a90185199c82cc0082dee894384dec25e03f94931767ce4c3556168468ba24c380b844a9059cb\
+        b0000000000000000000000007788df76bbd9a0c7c3e5bf0f77bb28c60a167a7b000000000000000000000000000000000000000000000000000\
+        000e8d4a510002aa0635fbb3652e1c3063afac6ffdf47220e0431825015aef7daff9251694e449bfca00b2ed6d556bd030ac75291bf58817da15\
+        a891cd027a4c261bb80b51f33b78adf";
+        let in_bytes = decode_hex(signed_transaction_data).unwrap();
+
+        assert_that_signed_transactions_agrees_with_template(chain, nonce, &in_bytes)
+    }
+
+    //not confirmed on the real network
+    #[test]
+    fn web3_interface_signing_a_transaction_for_polygon_mainnet() {
+        let chain = Chain::PolyMainnet;
+        let nonce = 10;
+        //generated locally
+        let signed_transaction_data = [
+            248, 172, 10, 133, 11, 164, 59, 116, 0, 131, 1, 25, 128, 148, 238, 154, 53, 47, 106,
+            172, 74, 241, 165, 185, 244, 103, 246, 169, 62, 15, 251, 233, 221, 53, 128, 184, 68,
+            169, 5, 156, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 119, 136, 223, 118, 187, 217,
+            160, 199, 195, 229, 191, 15, 119, 187, 40, 198, 10, 22, 122, 123, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, 212, 165, 16, 0, 130,
+            1, 53, 160, 7, 203, 40, 44, 202, 233, 15, 5, 64, 218, 199, 239, 94, 126, 152, 2, 108,
+            30, 157, 75, 124, 129, 117, 27, 109, 163, 132, 27, 11, 123, 137, 10, 160, 18, 170, 130,
+            198, 73, 190, 158, 235, 0, 77, 118, 213, 244, 229, 225, 143, 156, 214, 219, 204, 193,
+            155, 199, 164, 162, 31, 134, 51, 139, 130, 152, 104,
+        ];
+
+        assert_that_signed_transactions_agrees_with_template(chain, nonce, &signed_transaction_data)
+    }
+
+    //not confirmed on the real network
+    #[test]
+    fn web3_interface_signing_a_transaction_for_eth_mainnet() {
+        let chain = Chain::EthMainnet;
+        let nonce = 10;
+        //generated locally
+        let signed_transaction_data = [
+            248, 169, 10, 133, 25, 156, 130, 204, 0, 130, 222, 232, 148, 6, 243, 195, 35, 240, 35,
+            140, 114, 191, 53, 1, 16, 113, 242, 181, 183, 244, 58, 5, 76, 128, 184, 68, 169, 5,
+            156, 187, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 119, 136, 223, 118, 187, 217, 160, 199,
+            195, 229, 191, 15, 119, 187, 40, 198, 10, 22, 122, 123, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, 212, 165, 16, 0, 38, 160, 199,
+            155, 76, 106, 39, 227, 3, 151, 90, 117, 245, 211, 86, 98, 187, 117, 120, 103, 165, 131,
+            99, 72, 36, 211, 10, 224, 252, 104, 51, 200, 230, 158, 160, 84, 18, 140, 248, 119, 22,
+            193, 14, 148, 253, 48, 59, 185, 11, 38, 152, 103, 150, 120, 60, 74, 56, 159, 206, 22,
+            15, 73, 173, 153, 11, 76, 74,
+        ];
+
+        assert_that_signed_transactions_agrees_with_template(chain, nonce, &signed_transaction_data)
+    }
+
+    #[test]
+    fn gas_limit_for_polygon_mumbai_lies_within_limits_for_raw_transaction() {
+        test_gas_limit_is_between_limits(Chain::PolyAmoy);
+    }
+
+    #[test]
+    fn gas_limit_for_polygon_mainnet_lies_within_limits_for_raw_transaction() {
+        test_gas_limit_is_between_limits(Chain::PolyMainnet);
+    }
+
+    #[test]
+    fn gas_limit_for_eth_mainnet_lies_within_limits_for_raw_transaction() {
+        test_gas_limit_is_between_limits(Chain::EthMainnet)
+    }
+
+    fn assert_that_signed_transactions_agrees_with_template(
+        chain: Chain,
+        nonce: u64,
+        template: &[u8],
+    ) {
+        const TEST_PAYMENT_AMOUNT: u128 = 1_000_000_000_000;
+        const TEST_GAS_PRICE_ETH: u64 = 110;
+        const TEST_GAS_PRICE_POLYGON: u64 = 50;
+
+        let port = find_free_port();
+        let (_event_loop_handle, transport) = Http::with_max_parallel(
+            &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port),
+            REQUESTS_IN_PARALLEL,
+        )
+        .unwrap();
+        let consuming_wallet = {
+            let key_pair = Bip32EncryptionKeyProvider::from_raw_secret(
+                &decode_hex("97923d8fd8de4a00f912bfb77ef483141dec551bd73ea59343ef5c4aac965d04")
+                    .unwrap(),
+            )
+            .unwrap();
+            Wallet::from(key_pair)
+        };
+        let recipient_wallet = {
+            let hex_part = &"0x7788df76BBd9a0C7c3e5bf0f77bb28C60a167a7b"[2..];
+            let recipient_address_bytes = decode_hex(hex_part).unwrap();
+            let address = Address::from_slice(&recipient_address_bytes);
+            Wallet::from(address)
+        };
+        let nonce_correct_type = U256::from(nonce);
+        let gas_price_in_gwei = match chain {
+            Chain::EthMainnet => TEST_GAS_PRICE_ETH,
+            Chain::EthRopsten => TEST_GAS_PRICE_ETH,
+            Chain::PolyMainnet => TEST_GAS_PRICE_POLYGON,
+            Chain::PolyAmoy => TEST_GAS_PRICE_POLYGON,
+            _ => panic!("isn't our interest in this test"),
+        };
+        let payable_account = make_payable_account_with_wallet_and_balance_and_timestamp_opt(
+            recipient_wallet,
+            TEST_PAYMENT_AMOUNT,
+            None,
+        );
+
+        let signed_transaction = sign_transaction(
+            chain,
+            &Web3::new(Batch::new(transport)),
+            payable_account.wallet,
+            consuming_wallet,
+            payable_account.balance_wei,
+            nonce_correct_type,
+            gwei_to_wei(gas_price_in_gwei),
+        );
+
+        let byte_set_to_compare = signed_transaction.raw_transaction.0;
+        assert_eq!(byte_set_to_compare.as_slice(), template)
+    }
+
+    fn test_gas_limit_is_between_limits(chain: Chain) {
+        let not_under_this_value = BlockchainInterfaceWeb3::web3_gas_limit_const_part(chain);
+        let not_above_this_value = not_under_this_value + WEB3_MAXIMAL_GAS_LIMIT_MARGIN;
+        let data = sign_transaction_data(1_000_000_000, make_wallet("wallet1"));
+
+        let gas_limit = gas_limit(data, chain);
+
+        assert!(
+            gas_limit >= U256::from(not_under_this_value),
+            "actual gas limit {} isn't above or equal {}",
+            gas_limit,
+            not_under_this_value
+        );
+        assert!(
+            gas_limit <= U256::from(not_above_this_value),
+            "actual gas limit {} isn't below or equal {}",
+            gas_limit,
+            not_above_this_value
+        );
+    }
+}
diff --git a/node/src/blockchain/blockchain_interface/data_structures/errors.rs b/node/src/blockchain/blockchain_interface/data_structures/errors.rs
index e4649c744..3084accfb 100644
--- a/node/src/blockchain/blockchain_interface/data_structures/errors.rs
+++ b/node/src/blockchain/blockchain_interface/data_structures/errors.rs
@@ -1,13 +1,11 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
 use crate::accountant::comma_joined_stringifiable;
-use crate::db_config::persistent_configuration::PersistentConfigError;
-use crate::sub_lib::wallet::Wallet;
 use itertools::Either;
 use std::fmt;
 use std::fmt::{Display, Formatter};
 use variant_count::VariantCount;
-use web3::types::{TransactionReceipt, H256};
+use web3::types::{Address, H256};
 
 const BLOCKCHAIN_SERVICE_URL_NOT_SPECIFIED: &str = "Uninitialized blockchain interface. To avoid \
 being delinquency-banned, you should restart the Node with a value for blockchain-service-url";
@@ -36,13 +34,10 @@ impl Display for BlockchainError {
     }
 }
 
-pub type BlockchainResult<T> = Result<T, BlockchainError>;
-pub type ResultForReceipt = BlockchainResult<Option<TransactionReceipt>>;
-
 #[derive(Clone, Debug, PartialEq, Eq, VariantCount)]
 pub enum PayableTransactionError {
     MissingConsumingWallet,
-    GasPriceQueryFailed(String),
+    GasPriceQueryFailed(BlockchainError),
     TransactionID(BlockchainError),
     UnusableWallet(String),
     Signing(String),
@@ -83,31 +78,25 @@ impl Display for PayableTransactionError {
 
 #[derive(Clone, Debug, PartialEq, Eq, VariantCount)]
 pub enum BlockchainAgentBuildError {
-    GasPrice(PersistentConfigError),
-    TransactionFeeBalance(Wallet, BlockchainError),
-    ServiceFeeBalance(Wallet, BlockchainError),
-    TransactionID(Wallet, BlockchainError),
+    GasPrice(BlockchainError),
+    TransactionFeeBalance(Address, BlockchainError),
+    ServiceFeeBalance(Address, BlockchainError),
     UninitializedBlockchainInterface,
 }
 
 impl Display for BlockchainAgentBuildError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let preformatted_or_complete = match self {
-            Self::GasPrice(persistent_config_e) => Either::Left(format!(
-                "gas price from the database: {:?}",
-                persistent_config_e
-            )),
-            Self::TransactionFeeBalance(wallet, blockchain_e) => Either::Left(format!(
-                "transaction fee balance for our earning wallet {} due to: {}",
-                wallet, blockchain_e
-            )),
-            Self::ServiceFeeBalance(wallet, blockchain_e) => Either::Left(format!(
-                "masq balance for our earning wallet {} due to {}",
-                wallet, blockchain_e
+            Self::GasPrice(blockchain_e) => {
+                Either::Left(format!("gas price due to: {:?}", blockchain_e))
+            }
+            Self::TransactionFeeBalance(address, blockchain_e) => Either::Left(format!(
+                "transaction fee balance for our earning wallet {:#x} due to: {}",
+                address, blockchain_e
             )),
-            Self::TransactionID(wallet, blockchain_e) => Either::Left(format!(
-                "transaction id for our earning wallet {} due to {}",
-                wallet, blockchain_e
+            Self::ServiceFeeBalance(address, blockchain_e) => Either::Left(format!(
+                "masq balance for our earning wallet {:#x} due to {}",
+                address, blockchain_e
             )),
             Self::UninitializedBlockchainInterface => {
                 Either::Right(BLOCKCHAIN_SERVICE_URL_NOT_SPECIFIED.to_string())
@@ -127,12 +116,11 @@ impl Display for BlockchainAgentBuildError {
 
 #[cfg(test)]
 mod tests {
-    use crate::blockchain::blockchain_interface::data_structures::errors::BLOCKCHAIN_SERVICE_URL_NOT_SPECIFIED;
-    use crate::blockchain::blockchain_interface::{
-        BlockchainAgentBuildError, BlockchainError, PayableTransactionError,
+    use crate::blockchain::blockchain_interface::data_structures::errors::{
+        PayableTransactionError, BLOCKCHAIN_SERVICE_URL_NOT_SPECIFIED,
     };
+    use crate::blockchain::blockchain_interface::{BlockchainAgentBuildError, BlockchainError};
     use crate::blockchain::test_utils::make_tx_hash;
-    use crate::db_config::persistent_configuration::PersistentConfigError;
     use crate::test_utils::make_wallet;
     use masq_lib::utils::{slice_of_strs_to_vec_of_strings, to_string};
 
@@ -180,9 +168,9 @@ mod tests {
     fn payable_payment_error_implements_display() {
         let original_errors = [
             PayableTransactionError::MissingConsumingWallet,
-            PayableTransactionError::GasPriceQueryFailed(
+            PayableTransactionError::GasPriceQueryFailed(BlockchainError::QueryFailed(
                 "Gas halves shut, no drop left".to_string(),
-            ),
+            )),
             PayableTransactionError::TransactionID(BlockchainError::InvalidResponse),
             PayableTransactionError::UnusableWallet(
                 "This is a LEATHER wallet, not LEDGER wallet, stupid.".to_string(),
@@ -208,7 +196,7 @@ mod tests {
             actual_error_msgs,
             slice_of_strs_to_vec_of_strings(&[
                 "Missing consuming wallet to pay payable from",
-                "Unsuccessful gas price query: \"Gas halves shut, no drop left\"",
+                "Unsuccessful gas price query: \"Blockchain error: Query failed: Gas halves shut, no drop left\"",
                 "Transaction id fetching failed: Blockchain error: Invalid response",
                 "Unusable wallet for signing payable transactions: \"This is a LEATHER wallet, not \
                 LEDGER wallet, stupid.\"",
@@ -225,16 +213,15 @@ mod tests {
     fn blockchain_agent_build_error_implements_display() {
         let wallet = make_wallet("abc");
         let original_errors = [
-            BlockchainAgentBuildError::GasPrice(PersistentConfigError::NotPresent),
+            BlockchainAgentBuildError::GasPrice(BlockchainError::InvalidResponse),
             BlockchainAgentBuildError::TransactionFeeBalance(
-                wallet.clone(),
+                wallet.address(),
                 BlockchainError::InvalidResponse,
             ),
             BlockchainAgentBuildError::ServiceFeeBalance(
-                wallet.clone(),
+                wallet.address(),
                 BlockchainError::InvalidAddress,
             ),
-            BlockchainAgentBuildError::TransactionID(wallet.clone(), BlockchainError::InvalidUrl),
             BlockchainAgentBuildError::UninitializedBlockchainInterface,
         ];
 
@@ -248,13 +235,11 @@ mod tests {
         assert_eq!(
             actual_error_msgs,
             slice_of_strs_to_vec_of_strings(&[
-                "Blockchain agent construction failed at fetching gas price from the database: NotPresent",
+                "Blockchain agent construction failed at fetching gas price due to: InvalidResponse",
                 "Blockchain agent construction failed at fetching transaction fee balance for our earning \
                 wallet 0x0000000000000000000000000000000000616263 due to: Blockchain error: Invalid response",
                 "Blockchain agent construction failed at fetching masq balance for our earning wallet \
                 0x0000000000000000000000000000000000616263 due to Blockchain error: Invalid address",
-                "Blockchain agent construction failed at fetching transaction id for our earning wallet \
-                0x0000000000000000000000000000000000616263 due to Blockchain error: Invalid url",
                 BLOCKCHAIN_SERVICE_URL_NOT_SPECIFIED
             ])
         )
diff --git a/node/src/blockchain/blockchain_interface/data_structures/mod.rs b/node/src/blockchain/blockchain_interface/data_structures/mod.rs
index d8b86d5d9..4894b3563 100644
--- a/node/src/blockchain/blockchain_interface/data_structures/mod.rs
+++ b/node/src/blockchain/blockchain_interface/data_structures/mod.rs
@@ -1,9 +1,12 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
 pub mod errors;
+
 use crate::accountant::db_access_objects::pending_payable_dao::PendingPayable;
 use crate::sub_lib::wallet::Wallet;
-use web3::types::{BlockNumber, H256};
+use std::fmt;
+use std::fmt::Formatter;
+use web3::types::H256;
 use web3::Error;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -13,17 +16,31 @@ pub struct BlockchainTransaction {
     pub wei_amount: u128,
 }
 
-#[derive(Clone, Debug, PartialEq)]
+impl fmt::Display for BlockchainTransaction {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
+        write!(
+            f,
+            "{}wei from {} ({})",
+            self.wei_amount, self.from, self.block_number
+        )
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct RetrievedBlockchainTransactions {
-    pub new_start_block: BlockNumber,
+    pub new_start_block: u64,
     pub transactions: Vec<BlockchainTransaction>,
 }
 
-pub type ProcessedPayableFallible = Result<PendingPayable, RpcPayablesFailure>;
-
 #[derive(Debug, PartialEq, Clone)]
-pub struct RpcPayablesFailure {
+pub struct RpcPayableFailure {
     pub rpc_error: Error,
     pub recipient_wallet: Wallet,
     pub hash: H256,
 }
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum ProcessedPayableFallible {
+    Correct(PendingPayable),
+    Failed(RpcPayableFailure),
+}
diff --git a/node/src/blockchain/blockchain_interface/lower_level_interface.rs b/node/src/blockchain/blockchain_interface/lower_level_interface.rs
index 7300a7ef8..c8653f985 100644
--- a/node/src/blockchain/blockchain_interface/lower_level_interface.rs
+++ b/node/src/blockchain/blockchain_interface/lower_level_interface.rs
@@ -1,21 +1,47 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
-use crate::blockchain::blockchain_interface::data_structures::errors::BlockchainResult;
-use crate::sub_lib::wallet::Wallet;
-use ethereum_types::U64;
-use web3::types::U256;
+use crate::blockchain::blockchain_interface::data_structures::errors::BlockchainError;
+use ethereum_types::{H256, U64};
+use futures::Future;
+use serde_json::Value;
+use web3::transports::{Batch, Http};
+use web3::types::{Address, Filter, Log, U256};
+use web3::{Error, Web3};
 
 pub trait LowBlockchainInt {
-    fn get_transaction_fee_balance(&self, wallet: &Wallet) -> ResultForBalance;
+    // TODO: GH-495 The data structures in this trait are not generic, will need associated_type_defaults to implement it.
+    // see issue #29661 <https://github.com/rust-lang/rust/issues/29661> for more information
 
-    fn get_service_fee_balance(&self, wallet: &Wallet) -> ResultForBalance;
+    fn get_transaction_fee_balance(
+        &self,
+        address: Address,
+    ) -> Box<dyn Future<Item = U256, Error = BlockchainError>>;
 
-    fn get_block_number(&self) -> LatestBlockNumber;
+    fn get_service_fee_balance(
+        &self,
+        address: Address,
+    ) -> Box<dyn Future<Item = U256, Error = BlockchainError>>;
 
-    fn get_transaction_id(&self, wallet: &Wallet) -> ResultForNonce;
-}
+    fn get_gas_price(&self) -> Box<dyn Future<Item = U256, Error = BlockchainError>>;
+
+    fn get_block_number(&self) -> Box<dyn Future<Item = U64, Error = BlockchainError>>;
+
+    fn get_transaction_id(
+        &self,
+        address: Address,
+    ) -> Box<dyn Future<Item = U256, Error = BlockchainError>>;
+
+    fn get_transaction_receipt_in_batch(
+        &self,
+        hash_vec: Vec<H256>,
+    ) -> Box<dyn Future<Item = Vec<Result<Value, Error>>, Error = BlockchainError>>;
 
-pub type ResultForBalance = BlockchainResult<web3::types::U256>;
-pub type ResultForBothBalances = BlockchainResult<(web3::types::U256, web3::types::U256)>;
-pub type ResultForNonce = BlockchainResult<U256>;
-pub type LatestBlockNumber = BlockchainResult<U64>;
+    fn get_contract_address(&self) -> Address;
+
+    fn get_transaction_logs(
+        &self,
+        filter: Filter,
+    ) -> Box<dyn Future<Item = Vec<Log>, Error = BlockchainError>>;
+
+    fn get_web3_batch(&self) -> Web3<Batch<Http>>;
+}
diff --git a/node/src/blockchain/blockchain_interface/mod.rs b/node/src/blockchain/blockchain_interface/mod.rs
index d41513d3a..ef1e8d373 100644
--- a/node/src/blockchain/blockchain_interface/mod.rs
+++ b/node/src/blockchain/blockchain_interface/mod.rs
@@ -1,52 +1,55 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
-pub mod blockchain_interface_null;
 pub mod blockchain_interface_web3;
 pub mod data_structures;
 pub mod lower_level_interface;
-pub mod test_utils;
 
-use crate::accountant::db_access_objects::payable_dao::PayableAccount;
+use actix::Recipient;
+use ethereum_types::H256;
 use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
-use crate::blockchain::blockchain_bridge::PendingPayableFingerprintSeeds;
-use crate::blockchain::blockchain_interface::data_structures::errors::{
-    BlockchainAgentBuildError, BlockchainError, PayableTransactionError, ResultForReceipt,
-};
-use crate::blockchain::blockchain_interface::data_structures::{
-    ProcessedPayableFallible, RetrievedBlockchainTransactions,
-};
+use crate::blockchain::blockchain_interface::data_structures::errors::{BlockchainAgentBuildError, BlockchainError, PayableTransactionError};
+use crate::blockchain::blockchain_interface::data_structures::{ProcessedPayableFallible, RetrievedBlockchainTransactions};
 use crate::blockchain::blockchain_interface::lower_level_interface::LowBlockchainInt;
-use crate::db_config::persistent_configuration::PersistentConfiguration;
 use crate::sub_lib::wallet::Wallet;
-use actix::Recipient;
-use web3::types::{Address, BlockNumber, H256};
+use futures::Future;
+use masq_lib::blockchains::chains::Chain;
+use web3::types::Address;
+use masq_lib::logger::Logger;
+use crate::accountant::db_access_objects::payable_dao::PayableAccount;
+use crate::blockchain::blockchain_bridge::{BlockMarker, BlockScanRange, PendingPayableFingerprintSeeds};
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::TransactionReceiptResult;
 
 pub trait BlockchainInterface {
     fn contract_address(&self) -> Address;
 
+    fn get_chain(&self) -> Chain;
+
+    fn lower_interface(&self) -> Box<dyn LowBlockchainInt>;
+
     fn retrieve_transactions(
         &self,
-        start_block: BlockNumber,
-        end_block: BlockNumber,
-        recipient: &Wallet,
-    ) -> Result<RetrievedBlockchainTransactions, BlockchainError>;
+        start_block: BlockMarker,
+        scan_range: BlockScanRange,
+        recipient: Address,
+    ) -> Box<dyn Future<Item = RetrievedBlockchainTransactions, Error = BlockchainError>>;
 
     fn build_blockchain_agent(
         &self,
-        consuming_wallet: &Wallet,
-        persistent_config: &dyn PersistentConfiguration,
-    ) -> Result<Box<dyn BlockchainAgent>, BlockchainAgentBuildError>;
+        consuming_wallet: Wallet,
+    ) -> Box<dyn Future<Item = Box<dyn BlockchainAgent>, Error = BlockchainAgentBuildError>>;
 
-    fn send_batch_of_payables(
+    fn process_transaction_receipts(
         &self,
-        agent: Box<dyn BlockchainAgent>,
-        new_fingerprints_recipient: &Recipient<PendingPayableFingerprintSeeds>,
-        accounts: &[PayableAccount],
-    ) -> Result<Vec<ProcessedPayableFallible>, PayableTransactionError>;
-
-    fn get_transaction_receipt(&self, hash: H256) -> ResultForReceipt;
+        transaction_hashes: Vec<H256>,
+    ) -> Box<dyn Future<Item = Vec<TransactionReceiptResult>, Error = BlockchainError>>;
 
-    fn lower_interface(&self) -> &dyn LowBlockchainInt;
+    fn submit_payables_in_batch(
+        &self,
+        logger: Logger,
+        agent: Box<dyn BlockchainAgent>,
+        fingerprints_recipient: Recipient<PendingPayableFingerprintSeeds>,
+        affordable_accounts: Vec<PayableAccount>,
+    ) -> Box<dyn Future<Item = Vec<ProcessedPayableFallible>, Error = PayableTransactionError>>;
 
     as_any_ref_in_trait!();
 }
diff --git a/node/src/blockchain/blockchain_interface/test_utils.rs b/node/src/blockchain/blockchain_interface/test_utils.rs
deleted file mode 100644
index 6588047cd..000000000
--- a/node/src/blockchain/blockchain_interface/test_utils.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
-
-#![cfg(test)]
-
-use crate::blockchain::blockchain_interface::lower_level_interface::{
-    LatestBlockNumber, LowBlockchainInt, ResultForBalance, ResultForNonce,
-};
-use crate::blockchain::blockchain_interface::BlockchainInterface;
-use crate::sub_lib::wallet::Wallet;
-use crate::test_utils::http_test_server::TestServer;
-use crate::test_utils::make_wallet;
-use masq_lib::blockchains::chains::Chain;
-use masq_lib::utils::find_free_port;
-use serde_json::Value;
-use std::cell::RefCell;
-use std::sync::{Arc, Mutex};
-
-#[derive(Default)]
-pub struct LowBlockchainIntMock {
-    get_transaction_fee_balance_params: Arc<Mutex<Vec<Wallet>>>,
-    get_transaction_fee_balance_results: RefCell<Vec<ResultForBalance>>,
-    get_masq_balance_params: Arc<Mutex<Vec<Wallet>>>,
-    get_masq_balance_results: RefCell<Vec<ResultForBalance>>,
-    get_block_number_results: RefCell<Vec<LatestBlockNumber>>,
-    get_transaction_id_params: Arc<Mutex<Vec<Wallet>>>,
-    get_transaction_id_results: RefCell<Vec<ResultForNonce>>,
-}
-
-impl LowBlockchainInt for LowBlockchainIntMock {
-    fn get_transaction_fee_balance(&self, address: &Wallet) -> ResultForBalance {
-        self.get_transaction_fee_balance_params
-            .lock()
-            .unwrap()
-            .push(address.clone());
-        self.get_transaction_fee_balance_results
-            .borrow_mut()
-            .remove(0)
-    }
-
-    fn get_service_fee_balance(&self, address: &Wallet) -> ResultForBalance {
-        self.get_masq_balance_params
-            .lock()
-            .unwrap()
-            .push(address.clone());
-        self.get_masq_balance_results.borrow_mut().remove(0)
-    }
-
-    fn get_block_number(&self) -> LatestBlockNumber {
-        self.get_block_number_results.borrow_mut().remove(0)
-    }
-
-    fn get_transaction_id(&self, address: &Wallet) -> ResultForNonce {
-        self.get_transaction_id_params
-            .lock()
-            .unwrap()
-            .push(address.clone());
-        self.get_transaction_id_results.borrow_mut().remove(0)
-    }
-}
-
-impl LowBlockchainIntMock {
-    pub fn get_transaction_fee_balance_params(mut self, params: &Arc<Mutex<Vec<Wallet>>>) -> Self {
-        self.get_transaction_fee_balance_params = params.clone();
-        self
-    }
-
-    pub fn get_transaction_fee_balance_result(self, result: ResultForBalance) -> Self {
-        self.get_transaction_fee_balance_results
-            .borrow_mut()
-            .push(result);
-        self
-    }
-
-    pub fn get_masq_balance_params(mut self, params: &Arc<Mutex<Vec<Wallet>>>) -> Self {
-        self.get_masq_balance_params = params.clone();
-        self
-    }
-
-    pub fn get_masq_balance_result(self, result: ResultForBalance) -> Self {
-        self.get_masq_balance_results.borrow_mut().push(result);
-        self
-    }
-
-    pub fn get_block_number_result(self, result: LatestBlockNumber) -> Self {
-        self.get_block_number_results.borrow_mut().push(result);
-        self
-    }
-
-    pub fn get_transaction_id_params(mut self, params: &Arc<Mutex<Vec<Wallet>>>) -> Self {
-        self.get_transaction_id_params = params.clone();
-        self
-    }
-
-    pub fn get_transaction_id_result(self, result: ResultForNonce) -> Self {
-        self.get_transaction_id_results.borrow_mut().push(result);
-        self
-    }
-}
-
-pub fn test_blockchain_interface_is_connected_and_functioning<F>(subject_factory: F)
-where
-    F: Fn(u16, Chain) -> Box<dyn BlockchainInterface>,
-{
-    let port = find_free_port();
-    let test_server = TestServer::start(
-        port,
-        vec![br#"{"jsonrpc":"2.0","id":0,"result":someGarbage}"#.to_vec()],
-    );
-    let wallet = make_wallet("123");
-    let chain = Chain::PolyMainnet;
-    let subject = subject_factory(port, chain);
-
-    // no assertion for the result, we anticipate an error from a badly formatted response from the server;
-    // yet enough to prove we have a proper connection
-    let _ = subject.lower_interface().get_service_fee_balance(&wallet);
-
-    let requests = test_server.requests_so_far();
-    let bodies: Vec<Value> = requests
-        .into_iter()
-        .map(|request| serde_json::from_slice(&request.body()).unwrap())
-        .collect();
-    assert_eq!(
-        bodies[0]["params"][0]["data"].to_string()[35..75],
-        wallet.to_string()[2..]
-    );
-    assert_eq!(
-        bodies[0]["params"][0]["to"],
-        format!("{:?}", chain.rec().contract)
-    );
-}
diff --git a/node/src/blockchain/blockchain_interface_initializer.rs b/node/src/blockchain/blockchain_interface_initializer.rs
index 7448420a3..ee87519a0 100644
--- a/node/src/blockchain/blockchain_interface_initializer.rs
+++ b/node/src/blockchain/blockchain_interface_initializer.rs
@@ -46,21 +46,48 @@ mod tests {
     use crate::blockchain::blockchain_interface_initializer::BlockchainInterfaceInitializer;
     use masq_lib::blockchains::chains::Chain;
 
+    use futures::Future;
     use std::net::Ipv4Addr;
+    use web3::transports::Http;
 
-    use crate::blockchain::blockchain_interface::test_utils::test_blockchain_interface_is_connected_and_functioning;
-
+    use crate::blockchain::blockchain_interface::blockchain_interface_web3::{
+        BlockchainInterfaceWeb3, REQUESTS_IN_PARALLEL,
+    };
+    use crate::blockchain::blockchain_interface::BlockchainInterface;
+    use crate::test_utils::make_wallet;
     use masq_lib::constants::DEFAULT_CHAIN;
+    use masq_lib::test_utils::mock_blockchain_client_server::MBCSBuilder;
+    use masq_lib::utils::find_free_port;
 
     #[test]
     fn initialize_web3_interface_works() {
-        let subject_factory = |port: u16, chain: Chain| {
-            let subject = BlockchainInterfaceInitializer {};
-            let server_url = &format!("http://{}:{}", &Ipv4Addr::LOCALHOST.to_string(), port);
-            subject.initialize_web3_interface(server_url, chain)
-        };
+        let port = find_free_port();
+        let _blockchain_client_server = MBCSBuilder::new(port)
+            .ok_response("0x3B9ACA00".to_string(), 0) // gas_price = 10000000000
+            .ok_response("0xFF40".to_string(), 0)
+            .ok_response(
+                "0x000000000000000000000000000000000000000000000000000000000000FFFF".to_string(),
+                0,
+            )
+            .ok_response("0x23".to_string(), 1)
+            .start();
+        let wallet = make_wallet("123");
+        let chain = Chain::PolyMainnet;
+        let server_url = &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port);
+        let (event_loop_handle, transport) =
+            Http::with_max_parallel(server_url, REQUESTS_IN_PARALLEL).unwrap();
+        let subject = BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain);
+
+        let blockchain_agent = subject
+            .build_blockchain_agent(wallet.clone())
+            .wait()
+            .unwrap();
 
-        test_blockchain_interface_is_connected_and_functioning(subject_factory)
+        assert_eq!(blockchain_agent.consuming_wallet(), &wallet);
+        assert_eq!(
+            blockchain_agent.agreed_fee_per_computation_unit(),
+            1_000_000_000
+        );
     }
 
     #[test]
diff --git a/node/src/blockchain/mod.rs b/node/src/blockchain/mod.rs
index 937380fd1..4c51e726e 100644
--- a/node/src/blockchain/mod.rs
+++ b/node/src/blockchain/mod.rs
@@ -1,5 +1,4 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
-
 pub mod bip32;
 pub mod bip39;
 pub mod blockchain_bridge;
@@ -7,6 +6,5 @@ pub mod blockchain_interface;
 pub mod blockchain_interface_initializer;
 pub mod payer;
 pub mod signature;
-
 #[cfg(test)]
 pub mod test_utils;
diff --git a/node/src/blockchain/test_utils.rs b/node/src/blockchain/test_utils.rs
index 16f7d21da..4124e283a 100644
--- a/node/src/blockchain/test_utils.rs
+++ b/node/src/blockchain/test_utils.rs
@@ -2,38 +2,21 @@
 
 #![cfg(test)]
 
-use crate::accountant::db_access_objects::payable_dao::PayableAccount;
-use crate::accountant::scanners::mid_scan_msg_handling::payable_scanner::blockchain_agent::BlockchainAgent;
-use crate::blockchain::blockchain_bridge::PendingPayableFingerprintSeeds;
-use crate::blockchain::blockchain_interface::blockchain_interface_web3::REQUESTS_IN_PARALLEL;
-use crate::blockchain::blockchain_interface::data_structures::errors::{
-    BlockchainAgentBuildError, BlockchainError, PayableTransactionError, ResultForReceipt,
+use crate::blockchain::blockchain_interface::blockchain_interface_web3::{
+    BlockchainInterfaceWeb3, REQUESTS_IN_PARALLEL,
 };
-use crate::blockchain::blockchain_interface::data_structures::{
-    ProcessedPayableFallible, RetrievedBlockchainTransactions,
-};
-use crate::blockchain::blockchain_interface::lower_level_interface::LowBlockchainInt;
-use crate::blockchain::blockchain_interface::test_utils::LowBlockchainIntMock;
-use crate::blockchain::blockchain_interface::BlockchainInterface;
-use crate::db_config::persistent_configuration::PersistentConfiguration;
-use crate::set_arbitrary_id_stamp_in_mock_impl;
-use crate::sub_lib::wallet::Wallet;
-use crate::test_utils::unshared_test_utils::arbitrary_id_stamp::ArbitraryIdStamp;
-use actix::Recipient;
 use bip39::{Language, Mnemonic, Seed};
-use ethereum_types::{BigEndianHash, H256};
-use jsonrpc_core as rpc;
+use ethabi::Hash;
+use ethereum_types::{BigEndianHash, H160, H256, U64};
 use lazy_static::lazy_static;
 use masq_lib::blockchains::chains::Chain;
 use masq_lib::utils::to_string;
-use std::cell::RefCell;
-use std::collections::VecDeque;
+use serde::Serialize;
+use serde_derive::Deserialize;
 use std::fmt::Debug;
-use std::sync::{Arc, Mutex};
+use std::net::Ipv4Addr;
 use web3::transports::{EventLoopHandle, Http};
-use web3::types::{Address, BlockNumber, U256};
-use web3::{BatchTransport, Error as Web3Error};
-use web3::{RequestId, Transport};
+use web3::types::{Index, Log, SignedTransaction, TransactionReceipt, H2048, U256};
 
 lazy_static! {
     static ref BIG_MEANINGLESS_PHRASE: Vec<&'static str> = vec![
@@ -56,264 +39,132 @@ pub fn make_meaningless_seed() -> Seed {
     Seed::new(&mnemonic, "passphrase")
 }
 
-#[derive(Default)]
-pub struct BlockchainInterfaceMock {
-    retrieve_transactions_parameters: Arc<Mutex<Vec<(BlockNumber, BlockNumber, Wallet)>>>,
-    retrieve_transactions_results:
-        RefCell<Vec<Result<RetrievedBlockchainTransactions, BlockchainError>>>,
-    build_blockchain_agent_params: Arc<Mutex<Vec<(Wallet, ArbitraryIdStamp)>>>,
-    build_blockchain_agent_results:
-        RefCell<Vec<Result<Box<dyn BlockchainAgent>, BlockchainAgentBuildError>>>,
-    send_batch_of_payables_params: Arc<
-        Mutex<
-            Vec<(
-                ArbitraryIdStamp,
-                Recipient<PendingPayableFingerprintSeeds>,
-                Vec<PayableAccount>,
-            )>,
-        >,
-    >,
-    send_batch_of_payables_results:
-        RefCell<Vec<Result<Vec<ProcessedPayableFallible>, PayableTransactionError>>>,
-    get_transaction_receipt_params: Arc<Mutex<Vec<H256>>>,
-    get_transaction_receipt_results: RefCell<Vec<ResultForReceipt>>,
-    lower_interface_result: Option<Box<LowBlockchainIntMock>>,
-    arbitrary_id_stamp_opt: Option<ArbitraryIdStamp>,
-}
-
-impl BlockchainInterface for BlockchainInterfaceMock {
-    fn contract_address(&self) -> Address {
-        unimplemented!("not needed so far")
-    }
-
-    fn retrieve_transactions(
-        &self,
-        start_block: BlockNumber,
-        end_block: BlockNumber,
-        recipient: &Wallet,
-    ) -> Result<RetrievedBlockchainTransactions, BlockchainError> {
-        self.retrieve_transactions_parameters.lock().unwrap().push((
-            start_block,
-            end_block,
-            recipient.clone(),
-        ));
-        self.retrieve_transactions_results.borrow_mut().remove(0)
-    }
+pub fn make_blockchain_interface_web3(port: u16) -> BlockchainInterfaceWeb3 {
+    let chain = Chain::PolyMainnet;
+    let (event_loop_handle, transport) = Http::with_max_parallel(
+        &format!("http://{}:{}", &Ipv4Addr::LOCALHOST, port),
+        REQUESTS_IN_PARALLEL,
+    )
+    .unwrap();
 
-    fn build_blockchain_agent(
-        &self,
-        consuming_wallet: &Wallet,
-        persistent_config: &dyn PersistentConfiguration,
-    ) -> Result<Box<dyn BlockchainAgent>, BlockchainAgentBuildError> {
-        self.build_blockchain_agent_params.lock().unwrap().push((
-            consuming_wallet.clone(),
-            persistent_config.arbitrary_id_stamp(),
-        ));
-        self.build_blockchain_agent_results.borrow_mut().remove(0)
-    }
-
-    fn send_batch_of_payables(
-        &self,
-        agent: Box<dyn BlockchainAgent>,
-        new_fingerprints_recipient: &Recipient<PendingPayableFingerprintSeeds>,
-        accounts: &[PayableAccount],
-    ) -> Result<Vec<ProcessedPayableFallible>, PayableTransactionError> {
-        self.send_batch_of_payables_params.lock().unwrap().push((
-            agent.arbitrary_id_stamp(),
-            new_fingerprints_recipient.clone(),
-            accounts.to_vec(),
-        ));
-        self.send_batch_of_payables_results.borrow_mut().remove(0)
-    }
+    BlockchainInterfaceWeb3::new(transport, event_loop_handle, chain)
+}
 
-    fn get_transaction_receipt(&self, hash: H256) -> ResultForReceipt {
-        self.get_transaction_receipt_params
-            .lock()
-            .unwrap()
-            .push(hash);
-        self.get_transaction_receipt_results.borrow_mut().remove(0)
-    }
+#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
+pub struct RpcResponse<S: Serialize> {
+    #[serde(rename = "jsonrpc")]
+    json_rpc: String,
+    id: u8,
+    result: S,
+}
 
-    fn lower_interface(&self) -> &dyn LowBlockchainInt {
-        self.lower_interface_result.as_ref().unwrap().as_ref()
-    }
+#[derive(Default)]
+pub struct ReceiptResponseBuilder {
+    transaction_hash_opt: Option<Hash>,
+    transaction_index_opt: Option<Index>,
+    block_hash_opt: Option<Hash>,
+    block_number_opt: Option<U64>,
+    cumulative_gas_used_opt: Option<U256>,
+    gas_used_opt: Option<U256>,
+    contract_address_opt: Option<H160>,
+    logs_opt: Option<Vec<Log>>,
+    status_opt: Option<U64>,
+    root_opt: Option<Hash>,
+    logs_bloom_opt: Option<H2048>,
 }
 
-impl BlockchainInterfaceMock {
-    pub fn retrieve_transactions_params(
-        mut self,
-        params: &Arc<Mutex<Vec<(BlockNumber, BlockNumber, Wallet)>>>,
-    ) -> Self {
-        self.retrieve_transactions_parameters = params.clone();
+impl ReceiptResponseBuilder {
+    pub fn transaction_hash(mut self, hash: Hash) -> ReceiptResponseBuilder {
+        self.transaction_hash_opt = Some(hash);
         self
     }
 
-    pub fn retrieve_transactions_result(
-        self,
-        result: Result<RetrievedBlockchainTransactions, BlockchainError>,
-    ) -> Self {
-        self.retrieve_transactions_results.borrow_mut().push(result);
+    pub fn transaction_index(mut self, index: Index) -> ReceiptResponseBuilder {
+        self.transaction_index_opt = Some(index);
         self
     }
 
-    pub fn build_blockchain_agent_params(
-        mut self,
-        params: &Arc<Mutex<Vec<(Wallet, ArbitraryIdStamp)>>>,
-    ) -> Self {
-        self.build_blockchain_agent_params = params.clone();
+    pub fn block_hash(mut self, hash: Hash) -> ReceiptResponseBuilder {
+        self.block_hash_opt = Some(hash);
         self
     }
 
-    pub fn build_blockchain_agent_result(
-        self,
-        result: Result<Box<dyn BlockchainAgent>, BlockchainAgentBuildError>,
-    ) -> Self {
-        self.build_blockchain_agent_results
-            .borrow_mut()
-            .push(result);
+    pub fn block_number(mut self, number: U64) -> ReceiptResponseBuilder {
+        self.block_number_opt = Some(number);
         self
     }
 
-    pub fn send_batch_of_payables_params(
-        mut self,
-        params: &Arc<
-            Mutex<
-                Vec<(
-                    ArbitraryIdStamp,
-                    Recipient<PendingPayableFingerprintSeeds>,
-                    Vec<PayableAccount>,
-                )>,
-            >,
-        >,
-    ) -> Self {
-        self.send_batch_of_payables_params = params.clone();
+    pub fn cumulative_gas_used(mut self, number: U256) -> ReceiptResponseBuilder {
+        self.cumulative_gas_used_opt = Some(number);
         self
     }
 
-    pub fn send_batch_of_payables_result(
-        self,
-        result: Result<Vec<ProcessedPayableFallible>, PayableTransactionError>,
-    ) -> Self {
-        self.send_batch_of_payables_results
-            .borrow_mut()
-            .push(result);
+    pub fn gas_used(mut self, number: U256) -> ReceiptResponseBuilder {
+        self.gas_used_opt = Some(number);
         self
     }
 
-    pub fn get_transaction_receipt_params(mut self, params: &Arc<Mutex<Vec<H256>>>) -> Self {
-        self.get_transaction_receipt_params = params.clone();
+    pub fn contract_address(mut self, hash: H160) -> ReceiptResponseBuilder {
+        self.contract_address_opt = Some(hash);
         self
     }
 
-    pub fn get_transaction_receipt_result(self, result: ResultForReceipt) -> Self {
-        self.get_transaction_receipt_results
-            .borrow_mut()
-            .push(result);
+    pub fn logs(mut self, logs: Vec<Log>) -> ReceiptResponseBuilder {
+        self.logs_opt = Some(logs);
         self
     }
 
-    pub fn lower_interface_results(
-        mut self,
-        aggregated_results: Box<LowBlockchainIntMock>,
-    ) -> Self {
-        self.lower_interface_result = Some(aggregated_results);
+    pub fn status(mut self, number: U64) -> ReceiptResponseBuilder {
+        self.status_opt = Some(number);
         self
     }
 
-    set_arbitrary_id_stamp_in_mock_impl!();
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct TestTransport {
-    // neither prepare_results or send_results can be effectively implemented the traditional way,
-    // their queue would never progress and would return always the first prepared result despite
-    // taking multiple calls; the reason is that the Web3 library tends to clone (!!) the transport
-    // and by doing that, removing one element affects just the current clone, and next time an intact
-    // version of the same full queue will come in again as another individualistic clone
-    prepare_params: Arc<Mutex<Vec<(String, Vec<rpc::Value>)>>>,
-    send_params: Arc<Mutex<Vec<(RequestId, rpc::Call)>>>,
-    send_results: RefCell<VecDeque<rpc::Value>>,
-    send_batch_params: Arc<Mutex<Vec<Vec<(RequestId, rpc::Call)>>>>,
-    send_batch_results: RefCell<Vec<Vec<Result<rpc::Value, web3::Error>>>>,
-    //to check inheritance from a certain descendant, be proving a relation with reference counting
-    reference_counter_opt: Option<Arc<()>>,
-}
-
-impl Transport for TestTransport {
-    type Out = web3::Result<rpc::Value>;
-
-    fn prepare(&self, method: &str, params: Vec<rpc::Value>) -> (RequestId, rpc::Call) {
-        let request = web3::helpers::build_request(1, method, params.clone());
-        let mut prepare_params = self.prepare_params.lock().unwrap();
-        prepare_params.push((method.to_string(), params));
-        (prepare_params.len(), request)
+    pub fn root(mut self, hash: Hash) -> ReceiptResponseBuilder {
+        self.root_opt = Some(hash);
+        self
     }
 
-    fn send(&self, id: RequestId, request: rpc::Call) -> Self::Out {
-        self.send_params.lock().unwrap().push((id, request.clone()));
-        match self.send_results.borrow_mut().pop_front() {
-            Some(response) => Box::new(futures::finished(response)),
-            None => {
-                println!("Unexpected request (id: {:?}): {:?}", id, request);
-                Box::new(futures::failed(Web3Error::Unreachable))
-            }
-        }
+    pub fn logs_bloom(mut self, bloom: H2048) -> ReceiptResponseBuilder {
+        self.logs_bloom_opt = Some(bloom);
+        self
     }
-}
 
-impl BatchTransport for TestTransport {
-    type Batch = web3::Result<Vec<Result<rpc::Value, web3::Error>>>;
-
-    fn send_batch<T>(&self, requests: T) -> Self::Batch
-    where
-        T: IntoIterator<Item = (RequestId, rpc::Call)>,
-    {
-        self.send_batch_params
-            .lock()
-            .unwrap()
-            .push(requests.into_iter().collect());
-        let response = self.send_batch_results.borrow_mut().remove(0);
-        Box::new(futures::finished(response))
-    }
-}
+    pub fn build(self) -> String {
+        let mut transaction_receipt = TransactionReceipt::default();
 
-impl TestTransport {
-    pub fn prepare_params(mut self, params: &Arc<Mutex<Vec<(String, Vec<rpc::Value>)>>>) -> Self {
-        self.prepare_params = params.clone();
-        self
-    }
+        if let Some(transaction_hash) = self.transaction_hash_opt {
+            transaction_receipt.transaction_hash = transaction_hash;
+        }
 
-    //why prepare_result missing? Look up for a comment at the struct
+        if let Some(index) = self.transaction_index_opt {
+            transaction_receipt.transaction_index = index;
+        }
 
-    pub fn send_params(mut self, params: &Arc<Mutex<Vec<(RequestId, rpc::Call)>>>) -> Self {
-        self.send_params = params.clone();
-        self
-    }
+        if let Some(cumulative_gas_used) = self.cumulative_gas_used_opt {
+            transaction_receipt.cumulative_gas_used = cumulative_gas_used;
+        }
 
-    pub fn send_result(self, rpc_call_response: rpc::Value) -> Self {
-        self.send_results.borrow_mut().push_back(rpc_call_response);
-        self
-    }
+        if let Some(logs) = self.logs_opt {
+            transaction_receipt.logs = logs;
+        }
 
-    pub fn send_batch_params(
-        mut self,
-        params: &Arc<Mutex<Vec<Vec<(RequestId, rpc::Call)>>>>,
-    ) -> Self {
-        self.send_batch_params = params.clone();
-        self
-    }
+        if let Some(bloom) = self.logs_bloom_opt {
+            transaction_receipt.logs_bloom = bloom;
+        }
 
-    pub fn send_batch_result(
-        self,
-        batched_responses: Vec<Result<rpc::Value, web3::Error>>,
-    ) -> Self {
-        self.send_batch_results.borrow_mut().push(batched_responses);
-        self
-    }
+        transaction_receipt.block_hash = self.block_hash_opt;
+        transaction_receipt.block_number = self.block_number_opt;
+        transaction_receipt.gas_used = self.gas_used_opt;
+        transaction_receipt.contract_address = self.contract_address_opt;
+        transaction_receipt.status = self.status_opt;
+        transaction_receipt.root = self.root_opt;
 
-    pub fn initiate_reference_counter(mut self, reference_arc: &Arc<()>) -> Self {
-        self.reference_counter_opt = Some(reference_arc.clone());
-        self
+        let rpc_response = RpcResponse {
+            json_rpc: "2.0".to_string(),
+            id: 1,
+            result: transaction_receipt,
+        };
+        serde_json::to_string(&rpc_response).unwrap()
     }
 }
 
@@ -323,6 +174,17 @@ pub fn make_fake_event_loop_handle() -> EventLoopHandle {
         .0
 }
 
+pub fn make_default_signed_transaction() -> SignedTransaction {
+    SignedTransaction {
+        message_hash: Default::default(),
+        v: 0,
+        r: Default::default(),
+        s: Default::default(),
+        raw_transaction: Default::default(),
+        transaction_hash: Default::default(),
+    }
+}
+
 pub fn make_tx_hash(base: u32) -> H256 {
     H256::from_uint(&U256::from(base))
 }
@@ -335,3 +197,23 @@ pub fn all_chains() -> [Chain; 4] {
         Chain::Dev,
     ]
 }
+
+pub fn transport_error_code() -> u16 {
+    if cfg!(target_os = "windows") {
+        10061
+    } else if cfg!(target_os = "macos") {
+        61
+    } else if cfg!(target_os = "linux") {
+        111
+    } else {
+        0
+    }
+}
+
+pub fn transport_error_message() -> String {
+    if cfg!(target_os = "windows") {
+        "No connection could be made because the target machine actively refused it.".to_string()
+    } else {
+        "Connection refused".to_string()
+    }
+}
diff --git a/node/src/bootstrapper.rs b/node/src/bootstrapper.rs
index 358d21c40..2ef265e69 100644
--- a/node/src/bootstrapper.rs
+++ b/node/src/bootstrapper.rs
@@ -611,7 +611,7 @@ impl Bootstrapper {
     fn start_actors_and_return_shp_subs(&self) -> StreamHandlerPoolSubs {
         self.actor_system_factory.make_and_start_actors(
             self.config.clone(),
-            Box::new(ActorFactoryReal {}),
+            Box::new(ActorFactoryReal::new()),
             initialize_database(
                 &self.config.data_directory,
                 DbInitializationConfig::panic_on_migration(),
diff --git a/node/src/dispatcher.rs b/node/src/dispatcher.rs
index 2a6a8b9d9..b3de16740 100644
--- a/node/src/dispatcher.rs
+++ b/node/src/dispatcher.rs
@@ -608,7 +608,7 @@ mod tests {
         };
         // Here dispatcher takes what it needs from the BootstrapperConfig
         let (dispatcher_subs, _) =
-            ActorFactoryReal {}.make_and_start_dispatcher(&bootstrapper_config);
+            ActorFactoryReal::new().make_and_start_dispatcher(&bootstrapper_config);
         let peer_actors = peer_actors_builder().ui_gateway(ui_gateway).build();
         dispatcher_subs
             .bind
@@ -653,7 +653,7 @@ mod tests {
         };
         // Here dispatcher doesn't get what it needs from the BootstrapperConfig
         let (dispatcher_subs, _) =
-            ActorFactoryReal {}.make_and_start_dispatcher(&bootstrapper_config);
+            ActorFactoryReal::new().make_and_start_dispatcher(&bootstrapper_config);
         let peer_actors = peer_actors_builder().ui_gateway(ui_gateway).build();
         dispatcher_subs
             .bind
@@ -698,7 +698,7 @@ mod tests {
         };
         // Here dispatcher doesn't get what it needs from the BootstrapperConfig
         let (dispatcher_subs, _) =
-            ActorFactoryReal {}.make_and_start_dispatcher(&bootstrapper_config);
+            ActorFactoryReal::new().make_and_start_dispatcher(&bootstrapper_config);
         let peer_actors = peer_actors_builder().ui_gateway(ui_gateway).build();
         dispatcher_subs
             .bind
@@ -750,7 +750,7 @@ mod tests {
             body: UiDescriptorRequest {}.tmb(4321),
         };
         let (dispatcher_subs, _) =
-            ActorFactoryReal {}.make_and_start_dispatcher(&bootstrapper_config);
+            ActorFactoryReal::new().make_and_start_dispatcher(&bootstrapper_config);
         let peer_actors = peer_actors_builder().ui_gateway(ui_gateway).build();
         dispatcher_subs
             .bind
diff --git a/node/src/lib.rs b/node/src/lib.rs
index 6e4275959..b13d219b1 100644
--- a/node/src/lib.rs
+++ b/node/src/lib.rs
@@ -6,6 +6,7 @@ pub mod sub_lib;
 
 #[macro_use]
 extern crate masq_lib;
+extern crate core;
 
 #[cfg(test)]
 mod node_test_utils;
diff --git a/node/src/neighborhood/mod.rs b/node/src/neighborhood/mod.rs
index 8bb2aef1a..e46e2abce 100644
--- a/node/src/neighborhood/mod.rs
+++ b/node/src/neighborhood/mod.rs
@@ -839,7 +839,7 @@ impl Neighborhood {
                     Err(PersistentConfigError::DatabaseError(msg))
                         if &msg == "database is locked" =>
                     {
-                        warning! (
+                        warning!(
                         self.logger,
                         "Could not persist immediate-neighbor changes: database locked - skipping"
                     )
@@ -2590,9 +2590,9 @@ mod tests {
         system.run(); // If this never halts, it's because the Neighborhood isn't properly killing its actor
 
         let tlh = TestLogHandler::new();
-        tlh.exists_log_containing ("WARN: Neighborhood: Node at 3.4.5.6 refused Debut: No neighbors for Introduction or Pass");
-        tlh.exists_log_containing ("WARN: Neighborhood: Node at 4.5.6.7 refused Debut: Node owner manually rejected your Debut");
-        tlh.exists_log_containing ("ERROR: Neighborhood: None of the Nodes listed in the --neighbors parameter could accept your Debut; shutting down");
+        tlh.exists_log_containing("WARN: Neighborhood: Node at 3.4.5.6 refused Debut: No neighbors for Introduction or Pass");
+        tlh.exists_log_containing("WARN: Neighborhood: Node at 4.5.6.7 refused Debut: Node owner manually rejected your Debut");
+        tlh.exists_log_containing("ERROR: Neighborhood: None of the Nodes listed in the --neighbors parameter could accept your Debut; shutting down");
     }
 
     #[test]
@@ -3387,7 +3387,7 @@ mod tests {
         assert_eq!(
             new_undesirability,
             1_000_000 // existing undesirability
-                + rate_pack.routing_charge (1_000) as i64 // charge to route packet
+                + rate_pack.routing_charge(1_000) as i64 // charge to route packet
         );
     }
 
@@ -3410,7 +3410,7 @@ mod tests {
         assert_eq!(
             new_undesirability,
             1_000_000 // existing undesirability
-                    + rate_pack.exit_charge (1_000) as i64 // charge to exit request
+                + rate_pack.exit_charge(1_000) as i64 // charge to exit request
         );
     }
 
@@ -3438,8 +3438,8 @@ mod tests {
         assert_eq!(
             new_undesirability,
             1_000_000 // existing undesirability
-                    + rate_pack.exit_charge (1_000) as i64 // charge to exit request
-                    + UNREACHABLE_HOST_PENALTY // because host is blacklisted
+                + rate_pack.exit_charge(1_000) as i64 // charge to exit request
+                + UNREACHABLE_HOST_PENALTY // because host is blacklisted
         );
         TestLogHandler::new().exists_log_containing(
             "TRACE: Neighborhood: Node with PubKey 0x02030405 \
@@ -3487,8 +3487,8 @@ mod tests {
         let rate_pack = node_record.rate_pack();
         assert_eq!(
             initial_undesirability,
-            rate_pack.exit_charge (1_000) as i64 // charge to exit response
-                + rate_pack.routing_charge (1_000) as i64 // charge to route response
+            rate_pack.exit_charge(1_000) as i64 // charge to exit response
+                + rate_pack.routing_charge(1_000) as i64 // charge to route response
         );
     }
 
@@ -3511,7 +3511,7 @@ mod tests {
         assert_eq!(
             new_undesirability,
             1_000_000 // existing undesirability
-                + rate_pack.routing_charge (1_000) as i64 // charge to route response
+                + rate_pack.routing_charge(1_000) as i64 // charge to route response
         );
     }
 
@@ -5033,7 +5033,7 @@ mod tests {
                     },
                     earning_wallet.clone(),
                     consuming_wallet.clone(),
-                    "neighborhood_sends_node_query_response_with_none_when_key_query_matches_no_configured_data"
+                    "neighborhood_sends_node_query_response_with_none_when_key_query_matches_no_configured_data",
                 ),
             );
             let addr: Addr<Neighborhood> = subject.start();
@@ -5095,7 +5095,7 @@ mod tests {
                     },
                     earning_wallet.clone(),
                     consuming_wallet.clone(),
-                    "neighborhood_sends_node_query_response_with_result_when_key_query_matches_configured_data"
+                    "neighborhood_sends_node_query_response_with_result_when_key_query_matches_configured_data",
                 ),
             );
             subject
@@ -5162,7 +5162,7 @@ mod tests {
                     },
                     earning_wallet.clone(),
                     consuming_wallet.clone(),
-                    "neighborhood_sends_node_query_response_with_none_when_ip_address_query_matches_no_configured_data"
+                    "neighborhood_sends_node_query_response_with_none_when_ip_address_query_matches_no_configured_data",
                 ),
             );
             let addr: Addr<Neighborhood> = subject.start();
@@ -5226,7 +5226,7 @@ mod tests {
                 },
                 node_record.earning_wallet(),
                 None,
-                "neighborhood_sends_node_query_response_with_result_when_ip_address_query_matches_configured_data"
+                "neighborhood_sends_node_query_response_with_result_when_ip_address_query_matches_configured_data",
             );
             let mut subject = Neighborhood::new(cryptde, &config);
             subject
diff --git a/node/src/proxy_server/mod.rs b/node/src/proxy_server/mod.rs
index 9a519c90e..d2f6d5c97 100644
--- a/node/src/proxy_server/mod.rs
+++ b/node/src/proxy_server/mod.rs
@@ -50,8 +50,9 @@ use masq_lib::ui_gateway::NodeFromUiMessage;
 use masq_lib::utils::MutabilityConflictHelper;
 use regex::Regex;
 use std::collections::HashMap;
-use std::net::SocketAddr;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::rc::Rc;
+use std::str::FromStr;
 use std::time::{Duration, SystemTime};
 use tokio::prelude::Future;
 
@@ -1130,7 +1131,14 @@ impl IBCDHelper for IBCDHelperReal {
         let stream_key = proxy.find_or_generate_stream_key(&msg);
         let timestamp = msg.timestamp;
         let payload = match proxy.make_payload(msg, &stream_key) {
-            Ok(payload) => payload,
+            Ok(payload) => {
+                if let Some(hostname) = &payload.target_hostname {
+                    if let Err(e) = Hostname::new(hostname).validate_hostname() {
+                        return Err(format!("Request to wildcard IP detected - {} (Most likely because Blockchain Service URL is not set)", e));
+                    }
+                }
+                payload
+            }
             Err(e) => return Err(e),
         };
 
@@ -1277,7 +1285,6 @@ struct Hostname {
 }
 
 impl Hostname {
-    #[allow(dead_code)]
     fn new(raw_url: &str) -> Self {
         let regex = Regex::new(
             r"^((http[s]?|ftp):/)?/?([^:/\s]+)((/\w+)*/)([\w\-.]+[^#?\s]+)(.*)?(#[\w\-]+)?$",
@@ -1292,6 +1299,44 @@ impl Hostname {
         };
         Self { hostname }
     }
+
+    fn validate_hostname(&self) -> Result<(), String> {
+        match IpAddr::from_str(&self.hostname) {
+            Ok(ip_addr) => match ip_addr {
+                IpAddr::V4(ipv4addr) => Self::validate_ipv4(ipv4addr),
+                IpAddr::V6(ipv6addr) => Self::validate_ipv6(ipv6addr),
+            },
+            Err(_) => Self::validate_raw_string(&self.hostname),
+        }
+    }
+
+    fn validate_ipv4(addr: Ipv4Addr) -> Result<(), String> {
+        // TODO: 127.0.0.1 is being used in integration tests, that's why it's not here,
+        // but we should invalidate that IP too for safety
+        if addr.octets() == [0, 0, 0, 0] {
+            Err("0.0.0.0".to_string())
+        } else {
+            Ok(())
+        }
+    }
+
+    fn validate_ipv6(addr: Ipv6Addr) -> Result<(), String> {
+        if addr.segments() == [0, 0, 0, 0, 0, 0, 0, 0] {
+            Err("::".to_string())
+        } else if addr.segments() == [0, 0, 0, 0, 0, 0, 0, 1] {
+            Err("::1".to_string())
+        } else {
+            Ok(())
+        }
+    }
+
+    fn validate_raw_string(name: &str) -> Result<(), String> {
+        if name == "localhost" {
+            Err("localhost".to_string())
+        } else {
+            Ok(())
+        }
+    }
 }
 
 #[cfg(test)]
@@ -2601,6 +2646,47 @@ mod tests {
         );
     }
 
+    #[test]
+    fn proxy_server_sends_a_message_with_error_when_quad_zeros_are_detected() {
+        init_test_logging();
+        let test_name = "proxy_server_sends_a_message_with_error_when_quad_zeros_are_detected";
+        let cryptde = main_cryptde();
+        let http_request = b"GET /index.html HTTP/1.1\r\nHost: 0.0.0.0\r\n\r\n";
+        let socket_addr = SocketAddr::from_str("1.2.3.4:5678").unwrap();
+        let stream_key = StreamKey::make_meaningless_stream_key();
+        let expected_data = http_request.to_vec();
+        let msg_from_dispatcher = InboundClientData {
+            timestamp: SystemTime::now(),
+            peer_addr: socket_addr.clone(),
+            reception_port: Some(HTTP_PORT),
+            sequence_number: Some(0),
+            last_data: true,
+            is_clandestine: false,
+            data: expected_data.clone(),
+        };
+        let stream_key_factory = StreamKeyFactoryMock::new().make_result(stream_key);
+        let system = System::new(test_name);
+        let mut subject = ProxyServer::new(
+            cryptde,
+            alias_cryptde(),
+            true,
+            Some(STANDARD_CONSUMING_WALLET_BALANCE),
+            false,
+        );
+        subject.stream_key_factory = Box::new(stream_key_factory);
+        subject.logger = Logger::new(test_name);
+        let subject_addr: Addr<ProxyServer> = subject.start();
+        let peer_actors = peer_actors_builder().build();
+        subject_addr.try_send(BindMessage { peer_actors }).unwrap();
+
+        subject_addr.try_send(msg_from_dispatcher).unwrap();
+
+        System::current().stop();
+        system.run();
+
+        TestLogHandler::new().exists_log_containing(&format!("ERROR: {test_name}: Request to wildcard IP detected - 0.0.0.0 (Most likely because Blockchain Service URL is not set)"));
+    }
+
     #[test]
     fn proxy_server_uses_existing_route() {
         let main_cryptde = main_cryptde();
@@ -6191,6 +6277,39 @@ mod tests {
         assert_eq!(expected_result, clean_hostname);
     }
 
+    #[test]
+    fn hostname_is_valid_works() {
+        // IPv4
+        assert_eq!(
+            Hostname::new("0.0.0.0").validate_hostname(),
+            Err("0.0.0.0".to_string())
+        );
+        assert_eq!(Hostname::new("192.168.1.158").validate_hostname(), Ok(()));
+        // IPv6
+        assert_eq!(
+            Hostname::new("0:0:0:0:0:0:0:0").validate_hostname(),
+            Err("::".to_string())
+        );
+        assert_eq!(
+            Hostname::new("0:0:0:0:0:0:0:1").validate_hostname(),
+            Err("::1".to_string())
+        );
+        assert_eq!(
+            Hostname::new("2001:0db8:85a3:0000:0000:8a2e:0370:7334").validate_hostname(),
+            Ok(())
+        );
+        // Hostname
+        assert_eq!(
+            Hostname::new("localhost").validate_hostname(),
+            Err("localhost".to_string())
+        );
+        assert_eq!(Hostname::new("example.com").validate_hostname(), Ok(()));
+        assert_eq!(
+            Hostname::new("https://example.com").validate_hostname(),
+            Ok(())
+        );
+    }
+
     #[test]
     #[should_panic(
         expected = "ProxyServer should never get ShutdownStreamMsg about clandestine stream"
diff --git a/node/src/sub_lib/blockchain_bridge.rs b/node/src/sub_lib/blockchain_bridge.rs
index 6d43ea47b..2ec840cc9 100644
--- a/node/src/sub_lib/blockchain_bridge.rs
+++ b/node/src/sub_lib/blockchain_bridge.rs
@@ -85,10 +85,12 @@ impl ConsumingWalletBalances {
 mod tests {
     use crate::actor_system_factory::SubsFactory;
     use crate::blockchain::blockchain_bridge::{BlockchainBridge, BlockchainBridgeSubsFactoryReal};
-    use crate::blockchain::test_utils::BlockchainInterfaceMock;
+    use crate::blockchain::test_utils::make_blockchain_interface_web3;
     use crate::test_utils::persistent_configuration_mock::PersistentConfigurationMock;
     use crate::test_utils::recorder::{make_blockchain_bridge_subs_from_recorder, Recorder};
-    use actix::Actor;
+    use actix::{Actor, System};
+    use masq_lib::utils::find_free_port;
+    use std::sync::{Arc, Mutex};
 
     #[test]
     fn blockchain_bridge_subs_debug() {
@@ -102,17 +104,20 @@ mod tests {
     #[test]
     fn blockchain_bridge_subs_factory_produces_proper_subs() {
         let subject = BlockchainBridgeSubsFactoryReal {};
-        let blockchain_interface = BlockchainInterfaceMock::default();
+        let blockchain_interface = make_blockchain_interface_web3(find_free_port());
         let persistent_config = PersistentConfigurationMock::new();
         let accountant = BlockchainBridge::new(
             Box::new(blockchain_interface),
-            Box::new(persistent_config),
+            Arc::new(Mutex::new(persistent_config)),
             false,
         );
+        let system = System::new("blockchain_bridge_subs_factory_produces_proper_subs");
         let addr = accountant.start();
 
         let subs = subject.make(&addr);
 
+        System::current().stop();
+        system.run();
         assert_eq!(subs, BlockchainBridge::make_subs_from(&addr))
     }
 }
diff --git a/node/src/sub_lib/wallet.rs b/node/src/sub_lib/wallet.rs
index feb0667ec..4663e4938 100644
--- a/node/src/sub_lib/wallet.rs
+++ b/node/src/sub_lib/wallet.rs
@@ -128,7 +128,7 @@ impl Wallet {
             WalletKind::Address(address) => H160(address.0),
             WalletKind::PublicKey(public) => H160(*public.address()),
             WalletKind::SecretKey(key_provider) => key_provider.address(),
-            WalletKind::Uninitialized => panic!("No address for an uninitialized wallet!"),
+            WalletKind::Uninitialized => panic!("No address for an uninitialized wallet!"), // TODO: If we can get rid of it, it'll be awesome!
         }
     }
 
diff --git a/node/src/test_utils/http_test_server.rs b/node/src/test_utils/http_test_server.rs
deleted file mode 100644
index 56e0daddf..000000000
--- a/node/src/test_utils/http_test_server.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
-
-#![cfg(test)]
-
-use crossbeam_channel::{unbounded, Receiver};
-use simple_server::{Request, Server};
-use std::io::Write;
-use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream};
-use std::ops::Add;
-use std::sync::{Arc, Mutex};
-use std::thread;
-use std::time::{Duration, Instant};
-
-pub struct TestServer {
-    port: u16,
-    rx: Receiver<Request<Vec<u8>>>,
-}
-
-impl Drop for TestServer {
-    fn drop(&mut self) {
-        self.stop();
-    }
-}
-
-impl TestServer {
-    pub fn start(port: u16, bodies: Vec<Vec<u8>>) -> Self {
-        std::env::set_var("SIMPLESERVER_THREADS", "1");
-        let (tx, rx) = unbounded();
-        let _ = thread::spawn(move || {
-            let bodies_arc = Arc::new(Mutex::new(bodies));
-            Server::new(move |req, mut rsp| {
-                if req.headers().get("X-Quit").is_some() {
-                    panic!("Server stop requested");
-                }
-                tx.send(req).unwrap();
-                let body = bodies_arc.lock().unwrap().remove(0);
-                Ok(rsp.body(body)?)
-            })
-            .listen(&Ipv4Addr::LOCALHOST.to_string(), &format!("{}", port));
-        });
-        let deadline = Instant::now().add(Duration::from_secs(5));
-        loop {
-            thread::sleep(Duration::from_millis(10));
-            match TcpStream::connect(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port)) {
-                Ok(_) => break,
-                Err(e) => eprintln!("No: {:?}", e),
-            }
-            if Instant::now().gt(&deadline) {
-                panic!("TestServer still not started after 5sec");
-            }
-        }
-        TestServer { port, rx }
-    }
-
-    pub fn requests_so_far(&self) -> Vec<Request<Vec<u8>>> {
-        let mut requests = vec![];
-        while let Ok(request) = self.rx.try_recv() {
-            requests.push(request);
-        }
-        return requests;
-    }
-
-    fn stop(&mut self) {
-        let mut stream =
-            match TcpStream::connect(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), self.port)) {
-                Ok(s) => s,
-                Err(_) => return,
-            };
-        stream
-            .write(b"DELETE /irrelevant.htm HTTP/1.1\r\nX-Quit: Yes")
-            .unwrap();
-    }
-}
diff --git a/node/src/test_utils/mod.rs b/node/src/test_utils/mod.rs
index edeee2851..ab99d59d9 100644
--- a/node/src/test_utils/mod.rs
+++ b/node/src/test_utils/mod.rs
@@ -7,7 +7,6 @@ pub mod automap_mocks;
 pub mod data_hunk;
 pub mod data_hunk_framer;
 pub mod database_utils;
-pub mod http_test_server;
 pub mod little_tcp_server;
 pub mod logfile_name_guard;
 pub mod neighborhood_test_utils;
diff --git a/node/src/test_utils/persistent_configuration_mock.rs b/node/src/test_utils/persistent_configuration_mock.rs
index d50613392..4906c835c 100644
--- a/node/src/test_utils/persistent_configuration_mock.rs
+++ b/node/src/test_utils/persistent_configuration_mock.rs
@@ -678,6 +678,8 @@ impl PersistentConfigurationMock {
 
     set_arbitrary_id_stamp_in_mock_impl!();
 
+    // result_from allows a tester to push only a single value that can then be called multiple times.
+    // as opposed to pushing the same value for every call.
     fn result_from<T: Clone>(results: &RefCell<Vec<T>>) -> T {
         let mut borrowed = results.borrow_mut();
         if borrowed.is_empty() {
diff --git a/node/tests/connection_shutdown_test.rs b/node/tests/connection_shutdown_test.rs
index 24cd9d25c..04e6e2417 100644
--- a/node/tests/connection_shutdown_test.rs
+++ b/node/tests/connection_shutdown_test.rs
@@ -2,6 +2,7 @@
 
 pub mod utils;
 
+use crate::utils::CommandConfig;
 use crossbeam_channel::{unbounded, Sender};
 use masq_lib::utils::find_free_port;
 use std::io::{Read, Write};
@@ -14,9 +15,10 @@ use std::{io, thread};
 // 'node' below must not be named '_' alone or disappear, or the MASQNode will be immediately reclaimed.
 #[test]
 fn proxy_client_stream_reader_dies_when_client_stream_is_killed_integration() {
+    let ui_port = find_free_port();
     let _node = utils::MASQNode::start_standard(
         "proxy_client_stream_reader_dies_when_client_stream_is_killed_integration",
-        None,
+        Some(CommandConfig::new().pair("--ui-port", &ui_port.to_string())),
         true,
         true,
         false,
diff --git a/node/tests/initialization_test.rs b/node/tests/initialization_test.rs
index e6b88708f..3ea97ab04 100644
--- a/node/tests/initialization_test.rs
+++ b/node/tests/initialization_test.rs
@@ -76,6 +76,7 @@ fn initialization_sequence_integration() {
             ("neighborhood-mode", Some("zero-hop")),
             ("log-level", Some("trace")),
             ("data-directory", Some(&data_directory.to_str().unwrap())),
+            ("blockchain-service-url", Some("https://example.com")),
         ]))
         .unwrap();
     let financials_request = UiFinancialsRequest {
diff --git a/node/tests/ui_gateway_test.rs b/node/tests/ui_gateway_test.rs
index 4398a3c20..042cfda42 100644
--- a/node/tests/ui_gateway_test.rs
+++ b/node/tests/ui_gateway_test.rs
@@ -120,6 +120,7 @@ fn daemon_does_not_allow_node_to_keep_his_client_alive_integration() {
             ("chain", Some("polygon-mainnet")),
             ("neighborhood-mode", Some("standard")),
             ("log-level", Some("trace")),
+            ("blockchain-service-url", Some("https://example.com")),
             ("data-directory", Some(&data_directory.to_str().unwrap())),
         ]))
         .unwrap();
diff --git a/node/tests/utils.rs b/node/tests/utils.rs
index e397af6fe..adeec8c7e 100644
--- a/node/tests/utils.rs
+++ b/node/tests/utils.rs
@@ -485,6 +485,10 @@ impl MASQNode {
                 "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC",
             )
             .pair("--log-level", "trace")
+            .pair(
+                "--blockchain-service-url",
+                "https://nonexistentblockchainservice.com",
+            )
             .args
     }