Enable tests in Liquid mode

Using the `elementsd` crate to spawn a regtest elements envirnoment.

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" ] }
+elementsd = { version = "0.3.0", features = [ "0_21_0" ] }
 electrumd = { version = "0.1.0", features = [ "4_1_5" ] }
 ureq = { version = "2.4", default-features = false, features = [ "json" ] }
 tempfile = "3.0"
@@ -83,4 +84,9 @@ rev = "d988bd7ed9cf539b8fea0da042efa5a4e1eef86f"
 # not yet published on crates.io
 [patch.crates-io.electrumd]
 git = "https://github.com/shesek/electrumd"
-rev = "ea32146dc1db378d4444cd713a27a8ea3919c4c0"
+rev = "ea32146dc1db378d4444cd713a27a8ea3919c4c0"
+
+# pending https://github.com/RCasatta/elementsd/pull/1
+[patch.crates-io.elementsd]
+git = "https://github.com/shesek/elementsd"
+rev = "86d9c3d480f72963c81671705ac84af89d4d1b4b"

Cargo.toml

@@ -2,14 +2,19 @@ use std::sync::{Arc, Once, RwLock};
 use std::{env, net};
 
 use stderrlog::StdErrLog;
+use tempfile::TempDir;
 
-use bitcoind::{
-    bitcoincore_rpc::{self, RpcApi},
-    BitcoinD,
-};
+use serde_json::{json, Value};
+
+#[cfg(not(feature = "liquid"))]
+use bitcoind::{self as noded, BitcoinD as NodeD};
+#[cfg(feature = "liquid")]
+use elementsd::{self as noded, ElementsD as NodeD};
+
+use noded::bitcoincore_rpc::{self, RpcApi};
 
 use electrs::{
-    chain::{self, Network},
+    chain::{self, Address, BlockHash, Network, Txid},
     config::{self, Config},
     daemon::Daemon,
     electrum::RPC as ElectrumRPC,
@@ -18,28 +23,49 @@ use electrs::{
     rest,
     signal::Waiter,
 };
-use tempfile::TempDir;
 
 pub fn init_tester() -> Result<TestRunner> {
     let log = init_log();
 
-    let mut bitcoind_conf = bitcoind::Conf::default();
-    bitcoind_conf.view_stdout = true;
+    // Setup the bitcoind/elementsd config
+    let mut node_conf = noded::Conf::default();
+    {
+        #[cfg(not(feature = "liquid"))]
+        let node_conf = &mut node_conf;
+        #[cfg(feature = "liquid")]
+        let node_conf = &mut node_conf.0;
+
+        #[cfg(feature = "liquid")]
+        {
+            node_conf.args.push("-anyonecanspendaremine=1");
+        }
+
+        node_conf.view_stdout = true;
+    }
+
+    // Setup node
+    let node = NodeD::with_conf(noded::downloaded_exe_path().unwrap(), &node_conf).unwrap();
+
+    #[cfg(not(feature = "liquid"))]
+    let (node_client, params) = (&node.client, &node.params);
+    #[cfg(feature = "liquid")]
+    let (node_client, params) = (node.client(), &node.params());
 
-    let bitcoind =
-        BitcoinD::with_conf(bitcoind::downloaded_exe_path().unwrap(), &bitcoind_conf).unwrap();
+    log::info!("node params: {:?}", params);
 
-    init_node(&bitcoind.client).chain_err(|| "failed initializing node")?;
+    generate(node_client, 101).chain_err(|| "failed initializing blocks")?;
 
-    log::info!("bitcoind: {:?}", bitcoind.params);
+    // Needed to claim the initialfreecoins are our own
+    // See https://github.com/ElementsProject/elements/issues/956
+    #[cfg(feature = "liquid")]
+    node_client.call::<Value>("rescanblockchain", &[])?;
 
     #[cfg(not(feature = "liquid"))]
     let network_type = Network::Regtest;
     #[cfg(feature = "liquid")]
     let network_type = Network::LiquidRegtest;
 
-    let daemon_subdir = bitcoind
-        .params
+    let daemon_subdir = params
         .datadir
         .join(config::get_network_subdir(network_type).unwrap());
 
@@ -51,7 +77,7 @@ pub fn init_tester() -> Result<TestRunner> {
         db_path: electrsdb.path().to_path_buf(),
         daemon_dir: daemon_subdir.clone(),
         blocks_dir: daemon_subdir.join("blocks"),
-        daemon_rpc_addr: bitcoind.params.rpc_socket.into(),
+        daemon_rpc_addr: params.rpc_socket.into(),
         cookie: None,
         electrum_rpc_addr: rand_available_addr(),
         http_addr: rand_available_addr(),
@@ -134,7 +160,7 @@ pub fn init_tester() -> Result<TestRunner> {
 
     Ok(TestRunner {
         config,
-        bitcoind,
+        node,
         _electrsdb: electrsdb,
         indexer,
         query,
@@ -146,7 +172,8 @@ pub fn init_tester() -> Result<TestRunner> {
 
 pub struct TestRunner {
     config: Arc<Config>,
-    bitcoind: BitcoinD,
+    /// bitcoind::BitcoinD or an elementsd::ElementsD in liquid mode
+    node: NodeD,
     _electrsdb: TempDir, // rm'd when dropped
     indexer: Indexer,
     query: Arc<Query>,
@@ -156,8 +183,11 @@ pub struct TestRunner {
 }
 
 impl TestRunner {
-    pub fn bitcoind(&self) -> &bitcoincore_rpc::Client {
-        &self.bitcoind.client
+    pub fn node_client(&self) -> &bitcoincore_rpc::Client {
+        #[cfg(not(feature = "liquid"))]
+        return &self.node.client;
+        #[cfg(feature = "liquid")]
+        return &self.node.client();
     }
 
     pub fn sync(&mut self) -> Result<()> {
@@ -169,18 +199,17 @@ impl TestRunner {
         Ok(())
     }
 
-    pub fn mine(&mut self) -> Result<chain::BlockHash> {
-        let addr = self.bitcoind.client.get_new_address(None, None)?;
-        let mut generated = self.bitcoind.client.generate_to_address(1, &addr)?;
+    pub fn mine(&mut self) -> Result<BlockHash> {
+        let mut generated = generate(self.node_client(), 1)?;
         self.sync()?;
         Ok(generated.remove(0))
     }
 
-    pub fn send(&mut self, addr: &chain::Address, amount: bitcoin::Amount) -> Result<chain::Txid> {
-        let txid = self
-            .bitcoind
-            .client
-            .send_to_address(addr, amount, None, None, None, None, None, None)?;
+    pub fn send(&mut self, addr: &Address, amount: bitcoin::Amount) -> Result<Txid> {
+        let txid = self.node_client().call(
+            "sendtoaddress",
+            &[addr.to_string().into(), json!(amount.as_btc())],
+        )?;
         self.sync()?;
         Ok(txid)
     }
@@ -206,10 +235,15 @@ pub fn init_electrum_tester() -> Result<(ElectrumRPC, net::SocketAddr, TestRunne
     Ok((electrum_server, tester.config.electrum_rpc_addr, tester))
 }
 
-fn init_node(client: &bitcoincore_rpc::Client) -> bitcoincore_rpc::Result<()> {
-    let addr = client.get_new_address(None, None)?;
-    client.generate_to_address(101, &addr)?;
-    Ok(())
+fn generate(
+    client: &bitcoincore_rpc::Client,
+    num_blocks: u32,
+) -> bitcoincore_rpc::Result<Vec<BlockHash>> {
+    let addr = client.call::<Address>("getnewaddress", &[])?;
+    client.call(
+        "generatetoaddress",
+        &[num_blocks.into(), addr.to_string().into()],
+    )
 }
 
 fn init_log() -> StdErrLog {
@@ -256,6 +290,10 @@ error_chain::error_chain! {
             description("ureq error")
             display("ureq error: {:?}", e)
         }
+        Json(e: serde_json::Error) {
+            description("JSON error")
+            display("JSON error: {:?}", e)
+        }
     }
 }
 
@@ -284,3 +322,8 @@ impl From<ureq::Error> for Error {
         Error::from(ErrorKind::Ureq(e))
     }
 }
+impl From<serde_json::Error> for Error {
+    fn from(e: serde_json::Error) -> Self {
+        Error::from(ErrorKind::Json(e))
+    }
+}

tests/common.rs

@@ -100,14 +100,14 @@ fn test_electrum() -> Result<()> {
     // Send an outgoing payment
     electrum_wallet.call(
         "broadcast",
-        &json!([ electrum_wallet.call(
+        &json!([electrum_wallet.call(
             "payto",
             &json!({
-                "destination": tester.bitcoind().get_new_address(None, None)?,
+                "destination": tester.node_client().get_new_address(None, None)?,
                 "amount": 0.16,
                 "fee": 0.001,
             }),
-        )? ]),
+        )?]),
     )?;
     notify_wallet();
     assert_balance(0.3, -0.161);

tests/electrum.rs

@@ -2,6 +2,8 @@ use bitcoind::bitcoincore_rpc::RpcApi;
 use serde_json::Value;
 use std::collections::HashSet;
 
+use electrs::chain::{Address, Txid};
+
 mod common;
 
 use common::Result;
@@ -22,8 +24,23 @@ fn test_rest() -> Result<()> {
             .into_string()?)
     };
 
+    let newaddress = || -> Result<Address> {
+        let addr = tester.node_client().call::<Address>("getnewaddress", &[])?;
+        // On Liquid, return the unconfidential address, so that the tests below work
+        // on both Bitcoin and Liquid mode. The Liquid-specific functionality, including
+        // confidentially, is tested separately below.
+        #[cfg(feature = "liquid")]
+        let addr = {
+            let mut info = tester
+                .node_client()
+                .call::<Value>("getaddressinfo", &[addr.to_string().into()])?;
+            serde_json::from_value(info["unconfidential"].take())?
+        };
+        Ok(addr)
+    };
+
     // Send transaction and confirm it
-    let addr1 = tester.bitcoind().get_new_address(None, None)?;
+    let addr1 = newaddress()?;
     let txid1_confirmed = tester.send(&addr1, "1.19123 BTC".parse().unwrap())?;
     tester.mine()?;
 
@@ -32,6 +49,7 @@ fn test_rest() -> Result<()> {
 
     // Test GET /tx/:txid
     let res = get_json(&format!("/tx/{}", txid1_confirmed))?;
+    log::debug!("tx: {:#?}", res);
     let outs = res["vout"].as_array().expect("array of outs");
     assert!(outs.iter().any(|vout| {
         vout["scriptpubkey_address"].as_str() == Some(&addr1.to_string())
@@ -50,11 +68,13 @@ fn test_rest() -> Result<()> {
     // Test GET /address/:address
     let res = get_json(&format!("/address/{}", addr1))?;
     assert_eq!(res["chain_stats"]["funded_txo_count"].as_u64(), Some(1));
+    #[cfg(not(feature = "liquid"))]
     assert_eq!(
         res["chain_stats"]["funded_txo_sum"].as_u64(),
         Some(119123000)
     );
     assert_eq!(res["mempool_stats"]["funded_txo_count"].as_u64(), Some(1));
+    #[cfg(not(feature = "liquid"))]
     assert_eq!(
         res["mempool_stats"]["funded_txo_sum"].as_u64(),
         Some(71130000)
@@ -66,7 +86,7 @@ fn test_rest() -> Result<()> {
     let mut txids = txs
         .iter()
         .map(|tx| tx["txid"].as_str().unwrap().parse().unwrap())
-        .collect::<HashSet<electrs::chain::Txid>>();
+        .collect::<HashSet<Txid>>();
     assert!(txids.remove(&txid1_confirmed));
     assert!(txids.remove(&txid2_mempool));
     assert!(txids.is_empty());
@@ -79,7 +99,7 @@ fn test_rest() -> Result<()> {
     assert_eq!(found[0].as_str(), Some(addr1.to_string().as_str()));
 
     // Test GET /blocks/tip/hash
-    let bestblockhash = tester.bitcoind().get_best_block_hash()?;
+    let bestblockhash = tester.node_client().get_best_block_hash()?;
     let res = get_plain("/blocks/tip/hash")?;
     assert_eq!(res, bestblockhash.to_string());
 
@@ -88,7 +108,7 @@ fn test_rest() -> Result<()> {
     assert_eq!(res, bestblockhash.to_string());
 
     // Test GET /blocks/tip/height
-    let bestblockheight = tester.bitcoind().get_block_count()?;
+    let bestblockheight = tester.node_client().get_block_count()?;
     let res = get_plain("/blocks/tip/height")?;
     assert_eq!(
         res.parse::<u64>().expect("tip block height as an int"),
@@ -124,7 +144,7 @@ fn test_rest() -> Result<()> {
     assert_eq!(res["id"].as_str(), Some(blockhash.to_string().as_str()));
     assert_eq!(
         res["height"].as_u64(),
-        Some(tester.bitcoind().get_block_count()?)
+        Some(tester.node_client().get_block_count()?)
     );
     assert_eq!(res["tx_count"].as_u64(), Some(2));