deps(bdk_testenv): bump electrsd to 0.32.0

Author: oleonardolima

crates/testenv/Cargo.toml

@@ -17,14 +17,15 @@ workspace = true
 
 [dependencies]
 bdk_chain = { path = "../chain", version = "0.21.1", default-features = false }
-electrsd = { version = "0.28.0", features = [ "legacy" ], default-features = false }
+electrsd = { version = "0.32.0", features = [ "legacy" ], default-features = false }
+serde = { version = "^1.0", features = ["derive"] }
 
 [dev-dependencies]
 bdk_testenv = { path = "." }
 
 [features]
 default = ["std", "download"]
-download = ["electrsd/bitcoind_25_0", "electrsd/esplora_a33e97e1"]
+download = ["electrsd/corepc-node_28_0", "electrsd/esplora_a33e97e1"]
 std = ["bdk_chain/std"]
 serde = ["bdk_chain/serde"]
 

crates/testenv/src/lib.rs

@@ -9,32 +9,29 @@ use bdk_chain::{
     local_chain::CheckPoint,
     BlockId,
 };
-use bitcoincore_rpc::{
-    bitcoincore_rpc_json::{GetBlockTemplateModes, GetBlockTemplateRules},
-    RpcApi,
-};
-use electrsd::bitcoind::anyhow::Context;
+use electrsd::corepc_node::anyhow::Context;
 
 pub use electrsd;
-pub use electrsd::bitcoind;
-pub use electrsd::bitcoind::anyhow;
-pub use electrsd::bitcoind::bitcoincore_rpc;
+pub use electrsd::corepc_client;
+pub use electrsd::corepc_node;
+pub use electrsd::corepc_node::anyhow;
 pub use electrsd::electrum_client;
 use electrsd::electrum_client::ElectrumApi;
+use serde::{Deserialize, Serialize};
 use std::time::Duration;
 
 /// Struct for running a regtest environment with a single `bitcoind` node with an `electrs`
 /// instance connected to it.
 pub struct TestEnv {
-    pub bitcoind: electrsd::bitcoind::BitcoinD,
+    pub bitcoind: electrsd::corepc_node::Node,
     pub electrsd: electrsd::ElectrsD,
 }
 
 /// Configuration parameters.
 #[derive(Debug)]
 pub struct Config<'a> {
     /// [`bitcoind::Conf`]
-    pub bitcoind: bitcoind::Conf<'a>,
+    pub bitcoind: corepc_node::Conf<'a>,
     /// [`electrsd::Conf`]
     pub electrsd: electrsd::Conf<'a>,
 }
@@ -44,7 +41,7 @@ impl Default for Config<'_> {
     /// which is required for testing `bdk_esplora`.
     fn default() -> Self {
         Self {
-            bitcoind: bitcoind::Conf::default(),
+            bitcoind: corepc_node::Conf::default(),
             electrsd: {
                 let mut conf = electrsd::Conf::default();
                 conf.http_enabled = true;
@@ -54,6 +51,22 @@ impl Default for Config<'_> {
     }
 }
 
+/// A minimal model of the result of "getblocktemplate", with only used fields
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct GetBlockTemplateResult {
+    /// The compressed difficulty in hexadecimal
+    pub bits: String,
+    /// The previous block hash the current template is mining on
+    #[serde(rename = "hash")]
+    pub previous_block_hash: bdk_chain::bitcoin::BlockHash,
+    /// The height of the block we will be mining: `current height + 1`
+    pub height: u64,
+    /// The minimum timestamp appropriate for the next block time. Expressed as
+    /// UNIX timestamp.
+    #[serde(rename = "mintime")]
+    pub min_time: u64,
+}
+
 impl TestEnv {
     /// Construct a new [`TestEnv`] instance with the default configuration used by BDK.
     pub fn new() -> anyhow::Result<Self> {
@@ -64,11 +77,11 @@ impl TestEnv {
     pub fn new_with_config(config: Config) -> anyhow::Result<Self> {
         let bitcoind_exe = match std::env::var("BITCOIND_EXE") {
             Ok(path) => path,
-            Err(_) => bitcoind::downloaded_exe_path().context(
+            Err(_) => corepc_node::downloaded_exe_path().context(
                 "you need to provide an env var BITCOIND_EXE or specify a bitcoind version feature",
             )?,
         };
-        let bitcoind = bitcoind::BitcoinD::with_conf(bitcoind_exe, &config.bitcoind)?;
+        let bitcoind = corepc_node::Node::with_conf(bitcoind_exe, &config.bitcoind)?;
 
         let electrs_exe = match std::env::var("ELECTRS_EXE") {
             Ok(path) => path,
@@ -86,7 +99,7 @@ impl TestEnv {
     }
 
     /// Exposes the [`RpcApi`] calls from [`bitcoincore_rpc`].
-    pub fn rpc_client(&self) -> &impl RpcApi {
+    pub fn rpc_client(&self) -> &corepc_node::Client {
         &self.bitcoind.client
     }
 
@@ -117,26 +130,28 @@ impl TestEnv {
     ) -> anyhow::Result<Vec<BlockHash>> {
         let coinbase_address = match address {
             Some(address) => address,
-            None => self
-                .bitcoind
-                .client
-                .get_new_address(None, None)?
-                .assume_checked(),
+            None => self.bitcoind.client.new_address()?,
         };
         let block_hashes = self
             .bitcoind
             .client
-            .generate_to_address(count as _, &coinbase_address)?;
+            .generate_to_address(count as _, &coinbase_address)?
+            .into_model()?
+            .0;
         Ok(block_hashes)
     }
 
+    fn get_block_template(&self) -> anyhow::Result<GetBlockTemplateResult> {
+        let argument = r#"{"mode": "template", "rules": "segwit", "capabilities": []}"#;
+        Ok(self.bitcoind.client.call::<GetBlockTemplateResult>(
+            "getblocktemplate",
+            &[corepc_node::serde_json::to_value(argument)?],
+        )?)
+    }
+
     /// Mine a block that is guaranteed to be empty even with transactions in the mempool.
     pub fn mine_empty_block(&self) -> anyhow::Result<(usize, BlockHash)> {
-        let bt = self.bitcoind.client.get_block_template(
-            GetBlockTemplateModes::Template,
-            &[GetBlockTemplateRules::SegWit],
-            &[],
-        )?;
+        let bt = self.get_block_template()?;
 
         let txdata = vec![Transaction {
             version: transaction::Version::ONE,
@@ -145,7 +160,7 @@ impl TestEnv {
                 previous_output: bdk_chain::bitcoin::OutPoint::default(),
                 script_sig: ScriptBuf::builder()
                     .push_int(bt.height as _)
-                    // randomn number so that re-mining creates unique block
+                    // random number so that re-mining creates unique block
                     .push_int(random())
                     .into_script(),
                 sequence: bdk_chain::bitcoin::Sequence::default(),
@@ -157,11 +172,11 @@ impl TestEnv {
             }],
         }];
 
-        let bits: [u8; 4] = bt
-            .bits
-            .clone()
-            .try_into()
-            .expect("rpc provided us with invalid bits");
+        let bits: [u8; 4] =
+            bdk_chain::bitcoin::consensus::encode::deserialize_hex::<Vec<u8>>(&bt.bits)?
+                .clone()
+                .try_into()
+                .expect("rpc provided us with invalid bits");
 
         let mut block = Block {
             header: Header {
@@ -184,7 +199,15 @@ impl TestEnv {
             }
         }
 
-        self.bitcoind.client.submit_block(&block)?;
+        let block_hex: String = bdk_chain::bitcoin::consensus::encode::serialize_hex(&block);
+        match self.bitcoind.client.call(
+            "submitblock",
+            &[corepc_node::serde_json::to_value(block_hex)?],
+        ) {
+            Ok(corepc_node::serde_json::Value::Null) => Ok(()),
+            Ok(res) => Err(corepc_client::client_sync::Error::Returned(res.to_string())),
+            Err(err) => Err(err.into()),
+        }?;
         Ok((bt.height as usize, block.block_hash()))
     }
 
@@ -235,18 +258,16 @@ impl TestEnv {
 
     /// Invalidate a number of blocks of a given size `count`.
     pub fn invalidate_blocks(&self, count: usize) -> anyhow::Result<()> {
-        let mut hash = self.bitcoind.client.get_best_block_hash()?;
+        let mut hash = self.bitcoind.client.get_best_block_hash()?.block_hash()?;
         for _ in 0..count {
-            let prev_hash = self
-                .bitcoind
-                .client
-                .get_block_info(&hash)?
-                .previousblockhash;
-            self.bitcoind.client.invalidate_block(&hash)?;
-            match prev_hash {
-                Some(prev_hash) => hash = prev_hash,
-                None => break,
-            }
+            let prev_hash = self.bitcoind.client.get_block(hash)?.header.prev_blockhash;
+            self.bitcoind.client.invalidate_block(hash)?;
+            hash = prev_hash
+            // TODO: (@leonardo) It requires a double check if there is any side-effect with this break removal.
+            // match prev_hash {
+            //     Some(prev_hash) => hash = prev_hash,
+            //     None => break,
+            // }
         }
         Ok(())
     }
@@ -287,7 +308,8 @@ impl TestEnv {
         let txid = self
             .bitcoind
             .client
-            .send_to_address(address, amount, None, None, None, None, None, None)?;
+            .send_to_address(address, amount)?
+            .txid()?;
         Ok(txid)
     }
 
@@ -298,14 +320,19 @@ impl TestEnv {
                 .client
                 .get_block_hash(height as u64)
                 .ok()
-                .map(|hash| BlockId { height, hash })
+                .map(|get_block_hash| {
+                    let hash = get_block_hash
+                        .block_hash()
+                        .expect("should `successfully convert to `BlockHash` from `GetBlockHash`");
+                    BlockId { height, hash }
+                })
         }))
         .expect("must craft tip")
     }
 
     /// Get the genesis hash of the blockchain.
     pub fn genesis_hash(&self) -> anyhow::Result<BlockHash> {
-        let hash = self.bitcoind.client.get_block_hash(0)?;
+        let hash = self.bitcoind.client.get_block_hash(0)?.into_model()?.0;
         Ok(hash)
     }
 }
@@ -314,7 +341,7 @@ impl TestEnv {
 mod test {
     use crate::TestEnv;
     use core::time::Duration;
-    use electrsd::bitcoind::{anyhow::Result, bitcoincore_rpc::RpcApi};
+    use electrsd::corepc_node::anyhow::Result;
 
     /// This checks that reorgs initiated by `bitcoind` is detected by our `electrsd` instance.
     #[test]
@@ -324,15 +351,15 @@ mod test {
         // Mine some blocks.
         env.mine_blocks(101, None)?;
         env.wait_until_electrum_sees_block(Duration::from_secs(6))?;
-        let height = env.bitcoind.client.get_block_count()?;
+        let height = env.bitcoind.client.get_block_count()?.into_model().0;
         let blocks = (0..=height)
             .map(|i| env.bitcoind.client.get_block_hash(i))
             .collect::<Result<Vec<_>, _>>()?;
 
         // Perform reorg on six blocks.
         env.reorg(6)?;
         env.wait_until_electrum_sees_block(Duration::from_secs(6))?;
-        let reorged_height = env.bitcoind.client.get_block_count()?;
+        let reorged_height = env.bitcoind.client.get_block_count()?.into_model().0;
         let reorged_blocks = (0..=height)
             .map(|i| env.bitcoind.client.get_block_hash(i))
             .collect::<Result<Vec<_>, _>>()?;