Add integration tests for the Electrum JSON-RPC API

Using the headless Electrum wallet daemon:
https://electrum.readthedocs.io/en/latest/jsonrpc.html

Author: shesek

Cargo.lock

@@ -62,6 +62,7 @@ electrum-client = { version = "0.8", optional = true }
 
 [dev-dependencies]
 bitcoind = { version = "0.20.0", features = [ "22_0" ] }
+electrumd = { version = "0.1.0", features = [ "4_1_5" ] }
 ureq = { version = "2.4", default-features = false, features = [ "json" ] }
 tempfile = "3.0"
 
@@ -78,3 +79,7 @@ rev = "d3792352992a539afffbe11501d1aff9fd5b919d" # add-peer branch
 [patch.crates-io.elements]
 git = "https://github.com/ElementsProject/rust-elements"
 rev = "d988bd7ed9cf539b8fea0da042efa5a4e1eef86f"
+
+[patch.crates-io.electrumd]
+git = "https://github.com/shesek/electrumd"
+rev = "ea32146dc1db378d4444cd713a27a8ea3919c4c0"

Cargo.toml

@@ -243,6 +243,11 @@ error_chain::error_chain! {
             display("Bitcoind RPC error: {:?}", e)
         }
 
+        ElectrumD(e: electrumd::Error) {
+            description("Electrum wallet RPC error")
+            display("Electrum wallet RPC error: {:?}", e)
+        }
+
         Io(e: std::io::Error) {
             description("IO error")
             display("IO error: {:?}", e)
@@ -264,6 +269,11 @@ impl From<bitcoind::bitcoincore_rpc::Error> for Error {
         Error::from(ErrorKind::BitcoindRpc(e))
     }
 }
+impl From<electrumd::Error> for Error {
+    fn from(e: electrumd::Error) -> Self {
+        Error::from(ErrorKind::ElectrumD(e))
+    }
+}
 impl From<std::io::Error> for Error {
     fn from(e: std::io::Error) -> Self {
         Error::from(ErrorKind::Io(e))

tests/common.rs

@@ -0,0 +1,120 @@
+mod common;
+use common::Result;
+
+use bitcoind::bitcoincore_rpc::RpcApi;
+use electrumd::jsonrpc::serde_json::json;
+use electrumd::ElectrumD;
+
+use electrs::chain::Address;
+
+#[test]
+fn test_electrum() -> Result<()> {
+    // Spawn the Electrs Electrum RPC server
+    let (electrum_server, electrum_addr, mut tester) = common::init_electrum_tester().unwrap();
+
+    // Spawn headless Electrum wallet RPC server
+    let mut electrum_wallet_conf = electrumd::Conf::default();
+    let server_arg = format!("{}:t", electrum_addr.to_string());
+    electrum_wallet_conf.args = vec!["-v", "--server", &server_arg];
+    electrum_wallet_conf.view_stdout = true;
+    let electrum_wallet =
+        ElectrumD::with_conf(electrumd::downloaded_exe_path()?, &electrum_wallet_conf)?;
+
+    let notify_wallet = || {
+        electrum_server.notify();
+        std::thread::sleep(std::time::Duration::from_millis(200));
+    };
+
+    let assert_balance = |confirmed: f64, unconfirmed: f64| {
+        let balance = electrum_wallet.call("getbalance", &json!([])).unwrap();
+        log::info!("balance: {}", balance);
+
+        assert_eq!(
+            balance["confirmed"].as_str(),
+            Some(confirmed.to_string().as_str())
+        );
+        if unconfirmed != 0.0 {
+            assert_eq!(
+                balance["unconfirmed"].as_str(),
+                Some(unconfirmed.to_string().as_str())
+            );
+        } else {
+            assert!(balance["unconfirmed"].is_null())
+        }
+    };
+
+    let newaddress = || -> Address {
+        electrum_wallet
+            .call("createnewaddress", &json!([]))
+            .unwrap()
+            .as_str()
+            .expect("missing address")
+            .parse()
+            .expect("valid address")
+    };
+
+    log::info!(
+        "Electrum wallet version: {:?}",
+        electrum_wallet.call("version", &json!([]))?
+    );
+
+    // Send some funds and verify that the balance checks out
+    let addr1 = newaddress();
+    let addr2 = newaddress();
+
+    assert_balance(0.0, 0.0);
+
+    let txid1 = tester.send(&addr1, "0.1 BTC".parse().unwrap())?;
+    notify_wallet();
+    assert_balance(0.0, 0.1);
+
+    tester.mine()?;
+    notify_wallet();
+    assert_balance(0.1, 0.0);
+
+    let txid2 = tester.send(&addr2, "0.2 BTC".parse().unwrap())?;
+    notify_wallet();
+    assert_balance(0.1, 0.2);
+
+    tester.mine()?;
+    notify_wallet();
+    assert_balance(0.3, 0.0);
+
+    // Verify that the transaction history checks out
+    let history = electrum_wallet.call("onchain_history", &json!([]))?;
+    log::debug!("history = {:#?}", history);
+    assert_eq!(
+        history["transactions"][0]["txid"].as_str(),
+        Some(txid1.to_string().as_str())
+    );
+    assert_eq!(history["transactions"][0]["height"].as_u64(), Some(102));
+    assert_eq!(history["transactions"][0]["bc_value"].as_str(), Some("0.1"));
+
+    assert_eq!(
+        history["transactions"][1]["txid"].as_str(),
+        Some(txid2.to_string().as_str())
+    );
+    assert_eq!(history["transactions"][1]["height"].as_u64(), Some(103));
+    assert_eq!(history["transactions"][1]["bc_value"].as_str(), Some("0.2"));
+
+    // Send an outgoing payment
+    electrum_wallet.call(
+        "broadcast",
+        &json!([ electrum_wallet.call(
+            "payto",
+            &json!({
+                "destination": tester.bitcoind().get_new_address(None, None)?,
+                "amount": 0.16,
+                "fee": 0.001,
+            }),
+        )? ]),
+    )?;
+    notify_wallet();
+    assert_balance(0.3, -0.161);
+
+    tester.mine()?;
+    notify_wallet();
+    assert_balance(0.139, 0.0);
+
+    Ok(())
+}

tests/electrum.rs

@@ -7,7 +7,7 @@ mod common;
 use common::Result;
 
 #[test]
-fn test() -> Result<()> {
+fn test_rest() -> Result<()> {
     let (rest_handle, rest_addr, mut tester) = common::init_rest_tester().unwrap();
 
     let get_json = |path: &str| -> Result<Value> {