feat(client): add get_scripthash_stats

Author: luisschwab

src/async.rs

@@ -15,23 +15,20 @@ use std::collections::HashMap;
 use std::marker::PhantomData;
 use std::str::FromStr;
 
+use bitcoin::block::Header as BlockHeader;
 use bitcoin::consensus::{deserialize, serialize, Decodable, Encodable};
 use bitcoin::hashes::{sha256, Hash};
 use bitcoin::hex::{DisplayHex, FromHex};
-use bitcoin::Address;
-use bitcoin::{
-    block::Header as BlockHeader, Block, BlockHash, MerkleBlock, Script, Transaction, Txid,
-};
+use bitcoin::{Address, Block, BlockHash, MerkleBlock, Script, Transaction, Txid};
 
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
 
 use reqwest::{header, Client, Response};
 
-use crate::api::AddressStats;
 use crate::{
-    BlockStatus, BlockSummary, Builder, Error, MerkleProof, OutputSpendStatus, OutputStatus, Tx,
-    TxStatus, Utxo, BASE_BACKOFF_MILLIS, RETRYABLE_ERROR_CODES,
+    AddressStats, BlockStatus, BlockSummary, Builder, Error, MerkleProof, OutputSpendStatus,
+    OutputStatus, ScriptHashStats, Tx, TxStatus, Utxo, BASE_BACKOFF_MILLIS, RETRYABLE_ERROR_CODES,
 };
 
 #[derive(Debug, Clone)]
@@ -397,6 +394,13 @@ impl<S: Sleeper> AsyncClient<S> {
         self.get_response_json(&path).await
     }
 
+    /// Get statistics about a particular [`Script`] hash's confirmed and mempool transactions.
+    pub async fn get_scripthash_stats(&self, script: &Script) -> Result<ScriptHashStats, Error> {
+        let script_hash = sha256::Hash::hash(script.as_bytes());
+        let path = format!("/scripthash/{script_hash}");
+        self.get_response_json(&path).await
+    }
+
     /// Get transaction history for the specified address/scripthash, sorted with newest first.
     ///
     /// Returns up to 50 mempool transactions plus the first 25 confirmed transactions.

src/blocking.rs

@@ -21,18 +21,15 @@ use log::{debug, error, info, trace};
 
 use minreq::{Proxy, Request, Response};
 
+use bitcoin::block::Header as BlockHeader;
 use bitcoin::consensus::{deserialize, serialize, Decodable};
 use bitcoin::hashes::{sha256, Hash};
 use bitcoin::hex::{DisplayHex, FromHex};
-use bitcoin::Address;
-use bitcoin::{
-    block::Header as BlockHeader, Block, BlockHash, MerkleBlock, Script, Transaction, Txid,
-};
+use bitcoin::{Address, Block, BlockHash, MerkleBlock, Script, Transaction, Txid};
 
-use crate::api::AddressStats;
 use crate::{
-    BlockStatus, BlockSummary, Builder, Error, MerkleProof, OutputSpendStatus, OutputStatus, Tx,
-    TxStatus, Utxo, BASE_BACKOFF_MILLIS, RETRYABLE_ERROR_CODES,
+    AddressStats, BlockStatus, BlockSummary, Builder, Error, MerkleProof, OutputSpendStatus,
+    OutputStatus, ScriptHashStats, Tx, TxStatus, Utxo, BASE_BACKOFF_MILLIS, RETRYABLE_ERROR_CODES,
 };
 
 #[derive(Debug, Clone)]
@@ -331,6 +328,13 @@ impl BlockingClient {
         self.get_response_json(&path)
     }
 
+    /// Get statistics about a particular [`Script`] hash's confirmed and mempool transactions.
+    pub fn get_scripthash_stats(&self, script: &Script) -> Result<ScriptHashStats, Error> {
+        let script_hash = sha256::Hash::hash(script.as_bytes());
+        let path = format!("/scripthash/{script_hash}");
+        self.get_response_json(&path)
+    }
+
     /// Get transaction history for the specified address/scripthash, sorted with newest first.
     ///
     /// Returns up to 50 mempool transactions plus the first 25 confirmed transactions.

src/lib.rs

@@ -1013,6 +1013,142 @@ mod test {
         assert_eq!(address_stats_async.chain_stats.funded_txo_sum, 1000);
     }
 
+    #[cfg(all(feature = "blocking", feature = "async"))]
+    #[tokio::test]
+    async fn test_get_scripthash_stats() {
+        let (blocking_client, async_client) = setup_clients().await;
+
+        // Create an address of each type.
+        let address_legacy = BITCOIND
+            .client
+            .new_address_with_type(AddressType::Legacy)
+            .unwrap();
+        let address_p2sh_segwit = BITCOIND
+            .client
+            .new_address_with_type(AddressType::P2shSegwit)
+            .unwrap();
+        let address_bech32 = BITCOIND
+            .client
+            .new_address_with_type(AddressType::Bech32)
+            .unwrap();
+        let address_bech32m = BITCOIND
+            .client
+            .new_address_with_type(AddressType::Bech32m)
+            .unwrap();
+
+        // Send a transaction to each address.
+        let _txid = BITCOIND
+            .client
+            .send_to_address(&address_legacy, Amount::from_sat(1000))
+            .unwrap()
+            .txid()
+            .unwrap();
+        let _txid = BITCOIND
+            .client
+            .send_to_address(&address_p2sh_segwit, Amount::from_sat(1000))
+            .unwrap()
+            .txid()
+            .unwrap();
+        let _txid = BITCOIND
+            .client
+            .send_to_address(&address_bech32, Amount::from_sat(1000))
+            .unwrap()
+            .txid()
+            .unwrap();
+        let _txid = BITCOIND
+            .client
+            .send_to_address(&address_bech32m, Amount::from_sat(1000))
+            .unwrap()
+            .txid()
+            .unwrap();
+
+        let _miner = MINER.lock().await;
+        generate_blocks_and_wait(1);
+
+        // Derive each addresses script.
+        let script_legacy = address_legacy.script_pubkey();
+        let script_p2sh_segwit = address_p2sh_segwit.script_pubkey();
+        let script_bech32 = address_bech32.script_pubkey();
+        let script_bech32m = address_bech32m.script_pubkey();
+
+        // P2PKH
+        let scripthash_stats_blocking_legacy = blocking_client
+            .get_scripthash_stats(&script_legacy)
+            .unwrap();
+        let scripthash_stats_async_legacy = async_client
+            .get_scripthash_stats(&script_legacy)
+            .await
+            .unwrap();
+        assert_eq!(
+            scripthash_stats_blocking_legacy,
+            scripthash_stats_async_legacy
+        );
+        assert_eq!(
+            scripthash_stats_blocking_legacy.chain_stats.funded_txo_sum,
+            1000
+        );
+        assert_eq!(scripthash_stats_blocking_legacy.chain_stats.tx_count, 1);
+
+        // P2SH-P2WSH
+        let scripthash_stats_blocking_p2sh_segwit = blocking_client
+            .get_scripthash_stats(&script_p2sh_segwit)
+            .unwrap();
+        let scripthash_stats_async_p2sh_segwit = async_client
+            .get_scripthash_stats(&script_p2sh_segwit)
+            .await
+            .unwrap();
+        assert_eq!(
+            scripthash_stats_blocking_p2sh_segwit,
+            scripthash_stats_async_p2sh_segwit
+        );
+        assert_eq!(
+            scripthash_stats_blocking_p2sh_segwit
+                .chain_stats
+                .funded_txo_sum,
+            1000
+        );
+        assert_eq!(
+            scripthash_stats_blocking_p2sh_segwit.chain_stats.tx_count,
+            1
+        );
+
+        // P2WPKH / P2WSH
+        let scripthash_stats_blocking_bech32 = blocking_client
+            .get_scripthash_stats(&script_bech32)
+            .unwrap();
+        let scripthash_stats_async_bech32 = async_client
+            .get_scripthash_stats(&script_bech32)
+            .await
+            .unwrap();
+        assert_eq!(
+            scripthash_stats_blocking_bech32,
+            scripthash_stats_async_bech32
+        );
+        assert_eq!(
+            scripthash_stats_blocking_bech32.chain_stats.funded_txo_sum,
+            1000
+        );
+        assert_eq!(scripthash_stats_blocking_bech32.chain_stats.tx_count, 1);
+
+        // P2TR
+        let scripthash_stats_blocking_bech32m = blocking_client
+            .get_scripthash_stats(&script_bech32m)
+            .unwrap();
+        let scripthash_stats_async_bech32m = async_client
+            .get_scripthash_stats(&script_bech32m)
+            .await
+            .unwrap();
+        assert_eq!(
+            scripthash_stats_blocking_bech32m,
+            scripthash_stats_async_bech32m
+        );
+        assert_eq!(
+            scripthash_stats_blocking_bech32m.chain_stats.funded_txo_sum,
+            1000
+        );
+        assert_eq!(scripthash_stats_blocking_bech32m.chain_stats.tx_count, 1);
+    }
+
     #[cfg(all(feature = "blocking", feature = "async"))]
     #[tokio::test]
     async fn test_get_address_txs() {