Use trait methods for RPCs

Use trait methods instead of inherent methods to define the RPCs to
better allow downstream clients that define their own RPCs. This helps
when different implementations of the ones defined in the client are
required.

Author: jamillambert

client/src/bdk_client/error.rs client/src/client_async/error.rsclient/src/bdk_client/error.rs renamed to client/src/client_async/error.rs

@@ -10,8 +10,10 @@ use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 
-pub use crate::bdk_client::error::Error;
-use crate::bdk_client::error::UnexpectedServerVersionError;
+pub use rpcs::BitcoinRpcs;
+
+pub use self::error::Error;
+use self::error::UnexpectedServerVersionError;
 
 /// Crate-specific Result type.
 ///
@@ -51,7 +53,7 @@ pub struct Client {
 
 impl fmt::Debug for Client {
     fn fmt(&self, f: &mut fmt::Formatter) -> core::fmt::Result {
-        write!(f, "corepc_client::bdk_client::Client({:?})", self.inner)
+        write!(f, "corepc_client::client_async::Client({:?})", self.inner)
     }
 }
 
@@ -103,6 +105,19 @@ impl Client {
         Ok(resp?.result()?)
     }
 
+    /// Returns the version integer reported by the server (e.g. `250200` for v25.2.0).
+    pub 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
+        // supported version range.
+        #[derive(serde::Deserialize)]
+        struct NetworkVersion {
+            version: usize,
+        }
+        let json: NetworkVersion = self.call("getnetworkinfo", &[]).await?;
+        Ok(json.version)
+    }
+
     /// Checks that the JSON-RPC endpoint is for a `bitcoind` instance with the expected version.
     ///
     /// # Parameters
@@ -121,7 +136,7 @@ impl Client {
 }
 
 /// Shorthand for converting a variable into a `serde_json::Value`.
-pub(crate) fn into_json<T>(val: T) -> Result<serde_json::Value>
+pub fn into_json<T>(val: T) -> Result<serde_json::Value>
 where
     T: serde::ser::Serialize,
 {

client/src/bdk_client/mod.rs client/src/client_async/mod.rsclient/src/bdk_client/mod.rs renamed to client/src/client_async/mod.rs

@@ -1,53 +1,83 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! RPC set used by BDK.
-//! All functions return the version nonspecific, strongly typed types.
+//! RPC methods for the async Bitcoin Core client.
 
 use bitcoin::{block, Block, BlockHash, Transaction, Txid};
 use serde_json::value::RawValue;
 
-use crate::bdk_client::{into_json, Client, Result};
+use super::{into_json, Client, Result};
 use crate::types::model::{GetBlockFilter, GetBlockHeaderVerbose, GetBlockVerboseOne};
 
-impl Client {
+/// Bitcoin Core RPC methods (v25 to v30).
+///
+/// This trait exposes the Bitcoin Core RPC methods available on [`Client`]. Downstream users
+/// can define their own extension traits with additional methods without risk of
+/// name collision with the methods defined here.
+// `async fn` in traits produces non-`Send` futures by default; we suppress this lint because
+// `BitcoinRpcs` is intended only for use with concrete types (never `dyn BitcoinRpcs`).
+#[allow(async_fn_in_trait)]
+pub trait BitcoinRpcs {
     /// Gets a block by blockhash.
-    pub async fn get_block(&self, hash: &BlockHash) -> Result<Block> {
+    async fn get_block(&self, hash: &BlockHash) -> Result<Block>;
+
+    /// Gets the block count.
+    async fn get_block_count(&self) -> Result<u64>;
+
+    /// Gets the block hash for a height.
+    async fn get_block_hash(&self, height: u32) -> Result<BlockHash>;
+
+    /// Gets the hash of the chain tip.
+    async fn get_best_block_hash(&self) -> Result<BlockHash>;
+
+    /// Gets the block header by blockhash.
+    async fn get_block_header(&self, hash: &BlockHash) -> Result<block::Header>;
+
+    /// Gets the block header with verbose output.
+    async fn get_block_header_verbose(&self, hash: &BlockHash) -> Result<GetBlockHeaderVerbose>;
+
+    /// Gets a block by blockhash with verbose set to 1.
+    async fn get_block_verbose(&self, hash: &BlockHash) -> Result<GetBlockVerboseOne>;
+
+    /// Gets the block filter for a blockhash.
+    async fn get_block_filter(&self, hash: &BlockHash) -> Result<GetBlockFilter>;
+
+    /// 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>;
+}
+
+impl BitcoinRpcs for Client {
+    async fn get_block(&self, hash: &BlockHash) -> Result<Block> {
         let json: crate::types::v25::GetBlockVerboseZero =
             self.call("getblock", &[into_json(hash)?, into_json(0)?]).await?;
         Ok(json.into_model()?.0)
     }
 
-    /// Gets the block count.
-    pub async fn get_block_count(&self) -> Result<u64> {
+    async fn get_block_count(&self) -> Result<u64> {
         let json: crate::types::v25::GetBlockCount = self.call("getblockcount", &[]).await?;
         Ok(json.into_model().0)
     }
 
-    /// Gets the block hash for a height.
-    pub async fn get_block_hash(&self, height: u32) -> Result<BlockHash> {
+    async fn get_block_hash(&self, height: u32) -> Result<BlockHash> {
         let json: crate::types::v25::GetBlockHash =
             self.call("getblockhash", &[into_json(height)?]).await?;
         Ok(json.into_model()?.0)
     }
 
-    /// Gets the hash of the chain tip.
-    pub async fn get_best_block_hash(&self) -> Result<BlockHash> {
+    async fn get_best_block_hash(&self) -> Result<BlockHash> {
         let json: crate::types::v25::GetBestBlockHash = self.call("getbestblockhash", &[]).await?;
         Ok(json.into_model()?.0)
     }
 
-    /// Gets the block header by blockhash.
-    pub async fn get_block_header(&self, hash: &BlockHash) -> Result<block::Header> {
+    async fn get_block_header(&self, hash: &BlockHash) -> Result<block::Header> {
         let json: crate::types::v25::GetBlockHeader =
             self.call("getblockheader", &[into_json(hash)?, into_json(false)?]).await?;
         Ok(json.into_model()?.0)
     }
 
-    /// Gets the block header with verbose output.
-    pub async fn get_block_header_verbose(
-        &self,
-        hash: &BlockHash,
-    ) -> Result<GetBlockHeaderVerbose> {
+    async fn get_block_header_verbose(&self, hash: &BlockHash) -> Result<GetBlockHeaderVerbose> {
         let raw: Box<RawValue> =
             self.call("getblockheader", &[into_json(hash)?, into_json(true)?]).await?;
 
@@ -61,8 +91,7 @@ impl Client {
         }
     }
 
-    /// Gets a block by blockhash with verbose set to 1.
-    pub async fn get_block_verbose(&self, hash: &BlockHash) -> Result<GetBlockVerboseOne> {
+    async fn get_block_verbose(&self, hash: &BlockHash) -> Result<GetBlockVerboseOne> {
         let raw: Box<RawValue> = self.call("getblock", &[into_json(hash)?, into_json(1)?]).await?;
 
         if let Ok(json) = serde_json::from_str::<crate::types::v29::GetBlockVerboseOne>(raw.get()) {
@@ -73,36 +102,20 @@ impl Client {
         }
     }
 
-    /// Gets the block filter for a blockhash.
-    pub async fn get_block_filter(&self, hash: &BlockHash) -> Result<GetBlockFilter> {
+    async fn get_block_filter(&self, hash: &BlockHash) -> Result<GetBlockFilter> {
         let json: crate::types::v25::GetBlockFilter =
             self.call("getblockfilter", &[into_json(hash)?]).await?;
         Ok(json.into_model()?)
     }
 
-    /// Gets the transaction IDs currently in the mempool.
-    pub async fn get_raw_mempool(&self) -> Result<Vec<Txid>> {
+    async fn get_raw_mempool(&self) -> Result<Vec<Txid>> {
         let json: crate::types::v25::GetRawMempool = self.call("getrawmempool", &[]).await?;
         Ok(json.into_model()?.0)
     }
 
-    /// Gets the raw transaction by txid.
-    pub async fn get_raw_transaction(&self, txid: &Txid) -> Result<Transaction> {
+    async fn get_raw_transaction(&self, txid: &Txid) -> Result<Transaction> {
         let json: crate::types::v25::GetRawTransaction =
             self.call("getrawtransaction", &[into_json(txid)?]).await?;
         Ok(json.into_model()?.0)
     }
-
-    /// Returns the version integer reported by the server (e.g. `250200` for v25.2.0).
-    pub 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
-        // supported version range.
-        #[derive(serde::Deserialize)]
-        struct NetworkVersion {
-            version: usize,
-        }
-        let json: NetworkVersion = self.call("getnetworkinfo", &[]).await?;
-        Ok(json.version)
-    }
 }

client/src/bdk_client/rpcs.rs client/src/client_async/rpcs.rsclient/src/bdk_client/rpcs.rs renamed to client/src/client_async/rpcs.rs

@@ -16,4 +16,4 @@ pub(crate) mod error;
 pub mod client_sync;
 
 #[cfg(feature = "client-async")]
-pub mod bdk_client;
+pub mod client_async;

client/src/lib.rs

@@ -8,7 +8,7 @@
 use bitcoin::address::KnownHrp;
 use bitcoin::{Address, CompressedPublicKey, PrivateKey};
 use bitcoind::mtype;
-use corepc_client::bdk_client::{Auth, Client, Error as AsyncClientError};
+use corepc_client::client_async::{Auth, BitcoinRpcs as _, Client, Error as AsyncClientError};
 use integration_test::{BitcoinD, BitcoinDExt as _, Wallet};
 
 fn async_client_for(node: &BitcoinD) -> Client {