refactor(core-rpc): Update bitcoind_rpc dependants

- after updating bitcoind_rpc with bdk-
bitcoind-client, the random fn became unvailable
in chain, so I enabled the rand-std feature
- also updated the random fn to use the one
available in chain through bitcoin

Author: tvpeter

crates/bitcoind_rpc/src/lib.rs

@@ -38,10 +38,10 @@ pub struct Emitter {
     /// that the block is no longer in the best chain, it will be popped off from here.
     last_cp: CheckPoint<BlockHash>,
 
-    /// The block header result returned from rpc of the last-emitted block. As this result contains the
-    /// next block's block hash (which we use to fetch the next block), we set this to `None`
-    /// whenever there are no more blocks, or the next block is no longer in the best chain. This
-    /// gives us an opportunity to re-fetch this result.
+    /// The block header result returned from rpc of the last-emitted block. As this result
+    /// contains the next block's block hash (which we use to fetch the next block), we set
+    /// this to `None` whenever there are no more blocks, or the next block is no longer in the
+    /// best chain. This gives us an opportunity to re-fetch this result.
     last_block: Option<GetBlockHeaderVerbose>,
 
     /// The last snapshot of mempool transactions.

crates/bitcoind_rpc/tests/common/mod.rs

@@ -2,10 +2,11 @@ use bdk_bitcoind_client::Auth;
 use bdk_testenv::anyhow;
 use bdk_testenv::TestEnv;
 
-/// This trait is used for testing. It allows creating a new [`bdk_bitcoind_client::Client`] connected
-/// to the instance of bitcoind running in the test environment. This way the `TestEnv` and the
-/// `Emitter` aren't required to share the same client. In the future when we no longer depend on
-/// `bitcoincore-rpc`, this can be updated to return the production client that is used by BDK.
+/// This trait is used for testing. It allows creating a new [`bdk_bitcoind_client::Client`]
+/// connected to the instance of bitcoind running in the test environment. This way the `TestEnv`
+/// and the `Emitter` aren't required to share the same client. In the future when we no longer
+/// depend on `bitcoincore-rpc`, this can be updated to return the production client that is used by
+/// BDK.
 pub trait ClientExt {
     /// Creates a new [`bdk_bitcoin_client::Client`] connected to the current node instance.
     fn get_rpc_client(&self) -> anyhow::Result<bdk_bitcoind_client::Client>;

crates/bitcoind_rpc/tests/test_emitter.rs

@@ -1,15 +1,18 @@
 use std::collections::BTreeSet;
 
-use bdk_bitcoind_client::jsonrpc::serde_json;
 use bdk_bitcoind_rpc::{Emitter, NO_EXPECTED_MEMPOOL_TXS};
 use bdk_chain::{
     bitcoin::{Address, Amount, Txid},
     local_chain::{CheckPoint, LocalChain},
     spk_txout::SpkTxOutIndex,
     Balance, BlockId, CanonicalizationParams, IndexedTxGraph, Merge,
 };
-use bdk_testenv::{anyhow, TestEnv};
-use bitcoin::{hashes::Hash, Block, Network, OutPoint, ScriptBuf, WScriptHash};
+use bdk_testenv::{
+    anyhow,
+    corepc_node::{Input, Output},
+    TestEnv,
+};
+use bitcoin::{hashes::Hash, Block, Network, ScriptBuf, WScriptHash};
 
 use crate::common::ClientExt;
 
@@ -180,8 +183,6 @@ fn test_into_tx_graph() -> anyhow::Result<()> {
     // send 3 txs to a tracked address, these txs will be in the mempool
     let exp_txids = {
         let mut txids = BTreeSet::new();
-        let client = ClientExt::get_rpc_client(&env)?;
-
         for _ in 0..3 {
             txids.insert(
                 env.rpc_client()

crates/bitcoind_rpc/tests/test_filter_iter.rs

@@ -20,8 +20,10 @@ fn testenv() -> anyhow::Result<TestEnv> {
 #[test]
 fn filter_iter_matches_blocks() -> anyhow::Result<()> {
     let env = testenv()?;
-    let addr = ClientExt::get_rpc_client(&env)?
-        .get_new_address(None, None)
+    let addr = env
+        .rpc_client()
+        .get_new_address(None, None)?
+        .address()?
         .assume_checked();
 
     let _ = env.mine_blocks(100, Some(addr.clone()))?;

crates/testenv/Cargo.toml

@@ -26,7 +26,7 @@ bdk_testenv = { path = "." }
 [features]
 default = ["std", "download"]
 download = ["electrsd/corepc-node_28_2", "electrsd/esplora_a33e97e1"]
-std = ["bdk_chain/std"]
+std = ["bdk_chain/std", "bitcoin/rand-std"]
 serde = ["bdk_chain/serde"]
 
 [package.metadata.docs.rs]

examples/example_bitcoind_rpc_polling/src/main.rs

@@ -8,12 +8,16 @@ use std::{
 };
 
 use bdk_bitcoind_rpc::{
-    bitcoincore_rpc::{Auth, Client, RpcApi},
+    bdk_bitcoind_client::{jsonrpc::serde_json::json, Auth, Client},
     Emitter,
 };
-use bdk_chain::{bitcoin::Block, local_chain, CanonicalizationParams, Merge};
+
+use bdk_chain::{
+    bitcoin::{Block, Txid},
+    local_chain, CanonicalizationParams, Merge,
+};
 use example_cli::{
-    anyhow,
+    anyhow::{self, Ok},
     clap::{self, Args, Subcommand},
     ChangeSet, Keychain,
 };
@@ -70,16 +74,14 @@ impl From<RpcArgs> for Auth {
 
 impl RpcArgs {
     fn new_client(&self) -> anyhow::Result<Client> {
-        Ok(Client::new(
-            &self.url,
-            match (&self.rpc_cookie, &self.rpc_user, &self.rpc_password) {
-                (None, None, None) => Auth::None,
-                (Some(path), _, _) => Auth::CookieFile(path.clone()),
-                (_, Some(user), Some(pass)) => Auth::UserPass(user.clone(), pass.clone()),
-                (_, Some(_), None) => panic!("rpc auth: missing rpc_pass"),
-                (_, None, Some(_)) => panic!("rpc auth: missing rpc_user"),
-            },
-        )?)
+        let auth = match (&self.rpc_cookie, &self.rpc_user, &self.rpc_password) {
+            (None, None, None) => Auth::None,
+            (Some(path), _, _) => Auth::CookieFile(path.clone()),
+            (_, Some(user), Some(pass)) => Auth::UserPass(user.clone(), pass.clone()),
+            (_, Some(_), None) => panic!("rpc auth: missing rpc_pass"),
+            (_, None, Some(_)) => panic!("rpc auth: missing rpc_user"),
+        };
+        Ok(Client::with_auth(&self.url, auth)?)
     }
 }
 
@@ -122,7 +124,7 @@ fn main() -> anyhow::Result<()> {
                 network,
                 |rpc_args, tx| {
                     let client = rpc_args.new_client()?;
-                    client.send_raw_transaction(tx)?;
+                    let _txid: Txid = client.call("sendrawtransaction", &[json!(tx)])?;
                     Ok(())
                 },
                 general_cmd,
@@ -141,7 +143,7 @@ fn main() -> anyhow::Result<()> {
                 let chain = chain.lock().unwrap();
                 let graph = graph.lock().unwrap();
                 Emitter::new(
-                    &rpc_client,
+                    rpc_client,
                     chain.tip(),
                     fallback_height,
                     graph
@@ -241,12 +243,13 @@ fn main() -> anyhow::Result<()> {
             } = rpc_args;
             let sigterm_flag = start_ctrlc_handler();
 
-            let rpc_client = Arc::new(rpc_args.new_client()?);
+            let emitter_rpc_client = rpc_args.new_client()?;
+            let rpc_client = rpc_args.new_client()?;
             let mut emitter = {
                 let chain = chain.lock().unwrap();
                 let graph = graph.lock().unwrap();
                 Emitter::new(
-                    rpc_client.clone(),
+                    emitter_rpc_client,
                     chain.tip(),
                     fallback_height,
                     graph
@@ -267,7 +270,7 @@ fn main() -> anyhow::Result<()> {
             );
             let (tx, rx) = std::sync::mpsc::sync_channel::<Emission>(CHANNEL_BOUND);
             let emission_jh = std::thread::spawn(move || -> anyhow::Result<()> {
-                let mut block_count = rpc_client.get_block_count()? as u32;
+                let mut block_count = rpc_client.get_block_count()?;
                 tx.send(Emission::Tip(block_count))?;
 
                 loop {
@@ -278,7 +281,7 @@ fn main() -> anyhow::Result<()> {
                                 break;
                             }
                             if height > block_count {
-                                block_count = rpc_client.get_block_count()? as u32;
+                                block_count = rpc_client.get_block_count()?;
                                 tx.send(Emission::Tip(block_count))?;
                             }
                             tx.send(Emission::Block(block_emission))?;