Add async client getblockchaininfo and gettxout

Add these two RPCs to the async client Trait and
tests.

Assisted-by: GPT-5.4

Author: jamillambert

client/src/client_async/rpcs.rs

@@ -3,11 +3,13 @@
 //! RPC methods for the async Bitcoin Core client.
 //! All functions return the version nonspecific, strongly typed types.
 
-use bitcoin::{block, Block, BlockHash, Transaction, Txid};
+use bitcoin::{block, Block, BlockHash, OutPoint, Transaction, Txid};
 use serde_json::value::RawValue;
 
 use super::{into_json, Client, IntoModelError, Result};
-use crate::types::model::{GetBlockFilter, GetBlockHeaderVerbose, GetBlockVerboseOne};
+use crate::types::model::{
+    GetBlockFilter, GetBlockHeaderVerbose, GetBlockVerboseOne, GetBlockchainInfo, GetTxOut,
+};
 
 /// Bitcoin Core RPC methods (v25 to v30).
 ///
@@ -42,12 +44,22 @@ pub trait BitcoinRpcs {
     /// Gets the block filter for a blockhash.
     async fn get_block_filter(&self, hash: &BlockHash) -> Result<GetBlockFilter>;
 
+    /// Gets information about the current state of the blockchain.
+    async fn get_blockchain_info(&self) -> Result<GetBlockchainInfo>;
+
     /// Gets the transaction IDs currently in the mempool.
     async fn get_raw_mempool(&self) -> Result<Vec<Txid>>;
 
     /// Gets the raw transaction by txid.
     async fn get_raw_transaction(&self, txid: &Txid) -> Result<Transaction>;
 
+    /// Gets details about an unspent transaction output.
+    async fn get_tx_out(
+        &self,
+        outpoint: &OutPoint,
+        include_mempool: bool,
+    ) -> Result<Option<GetTxOut>>;
+
     /// Returns the version integer reported by the server (e.g. `250200` for v25.2.0).
     async fn server_version(&self) -> Result<usize>;
 }
@@ -112,6 +124,21 @@ impl BitcoinRpcs for Client {
         Ok(json.into_model().map_err(|e| IntoModelError::new("`getblockfilter`", e))?)
     }
 
+    async fn get_blockchain_info(&self) -> Result<GetBlockchainInfo> {
+        let raw: Box<RawValue> = self.call("getblockchaininfo", &[]).await?;
+
+        if let Ok(json) = serde_json::from_str::<crate::types::v29::GetBlockchainInfo>(raw.get()) {
+            Ok(json.into_model().map_err(|e| IntoModelError::new("`getblockchaininfo`", e))?)
+        } else if let Ok(json) =
+            serde_json::from_str::<crate::types::v28::GetBlockchainInfo>(raw.get())
+        {
+            Ok(json.into_model().map_err(|e| IntoModelError::new("`getblockchaininfo`", e))?)
+        } else {
+            let json: crate::types::v25::GetBlockchainInfo = serde_json::from_str(raw.get())?;
+            Ok(json.into_model().map_err(|e| IntoModelError::new("`getblockchaininfo`", e))?)
+        }
+    }
+
     async fn get_raw_mempool(&self) -> Result<Vec<Txid>> {
         let json: crate::types::v25::GetRawMempool = self.call("getrawmempool", &[]).await?;
         Ok(json.into_model().map_err(|e| IntoModelError::new("`getrawmempool`", e))?.0)
@@ -123,6 +150,28 @@ impl BitcoinRpcs for Client {
         Ok(json.into_model().map_err(|e| IntoModelError::new("`getrawtransaction`", e))?.0)
     }
 
+    async fn get_tx_out(
+        &self,
+        outpoint: &OutPoint,
+        include_mempool: bool,
+    ) -> Result<Option<GetTxOut>> {
+        let json: Option<crate::types::v25::GetTxOut> = self
+            .call(
+                "gettxout",
+                &[
+                    into_json(outpoint.txid)?,
+                    into_json(outpoint.vout)?,
+                    into_json(include_mempool)?,
+                ],
+            )
+            .await?;
+        match json {
+            None => Ok(None),
+            Some(json) =>
+                Ok(Some(json.into_model().map_err(|e| IntoModelError::new("`gettxout`", e))?)),
+        }
+    }
+
     async fn server_version(&self) -> Result<usize> {
         // Use a minimal type to read only the `version` field; the shape of other fields
         // (e.g. `warnings` changed from String to Vec<String> at v28) differs across the

integration_test/tests/bdk_client.rs

@@ -98,6 +98,19 @@ async fn async__get_block_header__modelled() {
     assert_eq!(model.height, 0);
 }
 
+#[tokio::test]
+async fn async__get_blockchain_info__modelled() {
+    let node = BitcoinD::with_wallet(Wallet::None, &["-prune=10000"]);
+    let client = async_client_for(&node);
+
+    let model: Result<mtype::GetBlockchainInfo, AsyncClientError> =
+        client.get_blockchain_info().await;
+    let model = model.unwrap();
+
+    assert_eq!(model.blocks, 0);
+    assert!(model.pruned);
+}
+
 #[tokio::test]
 async fn async__get_raw_mempool__modelled() {
     let node = BitcoinD::with_wallet(Wallet::None, &[]);
@@ -129,6 +142,24 @@ async fn async__get_raw_transaction__modelled() {
     assert_eq!(model.compute_txid(), txid);
 }
 
+#[tokio::test]
+async fn async__get_tx_out__modelled() {
+    let node = BitcoinD::with_wallet(Wallet::Default, &[]);
+    node.fund_wallet();
+    let client = async_client_for(&node);
+    let (_address, tx) = node.create_mined_transaction();
+    let txid = tx.compute_txid();
+
+    let model: Result<Option<mtype::GetTxOut>, AsyncClientError> =
+        client.get_tx_out(&bitcoin::OutPoint { txid, vout: 1 }, true).await;
+    let model = model.unwrap().expect("unspent output");
+    assert!(!model.coinbase);
+
+    let missing: Result<Option<mtype::GetTxOut>, AsyncClientError> =
+        client.get_tx_out(&bitcoin::OutPoint { txid, vout: 2 }, true).await;
+    assert!(missing.unwrap().is_none());
+}
+
 fn auth_for(node: &BitcoinD) -> Auth { Auth::CookieFile(node.params.cookie_file.clone()) }
 
 #[tokio::test]