Add get_address_stats and get_address_txns endpoints

Author: praveenperera

src/api.rs

@@ -97,6 +97,31 @@ pub struct BlockSummary {
     pub merkle_root: bitcoin::hash_types::TxMerkleNode,
 }
 
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
+pub struct AddressStats {
+    pub address: String,
+    pub chain_stats: ChainStats,
+    pub mempool_stats: MempoolStats,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize)]
+pub struct ChainStats {
+    pub funded_txo_count: u32,
+    pub funded_txo_sum: u64,
+    pub spent_txo_count: u32,
+    pub spent_txo_sum: u64,
+    pub tx_count: u32,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize)]
+pub struct MempoolStats {
+    pub funded_txo_count: u32,
+    pub funded_txo_sum: u64,
+    pub spent_txo_count: u32,
+    pub spent_txo_sum: u64,
+    pub tx_count: u32,
+}
+
 impl Tx {
     pub fn to_tx(&self) -> Transaction {
         Transaction {

src/async.rs

@@ -12,6 +12,7 @@
 //! Esplora by way of `reqwest` HTTP client.
 
 use async_std::task;
+use bitcoin::Address;
 use std::collections::HashMap;
 use std::str::FromStr;
 
@@ -27,6 +28,7 @@ use log::{debug, error, info, trace};
 
 use reqwest::{header, Client, Response};
 
+use crate::api::AddressStats;
 use crate::{
     BlockStatus, BlockSummary, Builder, Error, MerkleProof, OutputStatus, Tx, TxStatus,
     BASE_BACKOFF_MILLIS, RETRYABLE_ERROR_CODES,
@@ -378,6 +380,20 @@ impl AsyncClient {
             .map(|block_hash| BlockHash::from_str(&block_hash).map_err(Error::HexToArray))?
     }
 
+    /// Get information about a specific address, includes confirmed balance and transactions in
+    /// the mempool.
+    pub async fn get_address_stats(&self, address: &Address) -> Result<AddressStats, Error> {
+        let path = format!("/address/{address}");
+        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.
+    pub async fn get_address_txns(&self, address: &Address) -> Result<Vec<Tx>, Error> {
+        let path = format!("/address/{address}/txs");
+        self.get_response_json(&path).await
+    }
+
     /// Get confirmed transaction history for the specified address/scripthash,
     /// sorted with newest first. Returns 25 transactions per page.
     /// More can be requested by specifying the last txid seen by the previous

src/blocking.rs

@@ -16,6 +16,7 @@ use std::convert::TryFrom;
 use std::str::FromStr;
 use std::thread;
 
+use bitcoin::Address;
 #[allow(unused_imports)]
 use log::{debug, error, info, trace};
 
@@ -28,6 +29,7 @@ use bitcoin::{
     block::Header as BlockHeader, Block, BlockHash, MerkleBlock, Script, Transaction, Txid,
 };
 
+use crate::api::AddressStats;
 use crate::{
     BlockStatus, BlockSummary, Builder, Error, MerkleProof, OutputStatus, Tx, TxStatus,
     BASE_BACKOFF_MILLIS, RETRYABLE_ERROR_CODES,
@@ -317,6 +319,20 @@ impl BlockingClient {
         self.get_response_json("/fee-estimates")
     }
 
+    /// Get information about a specific address, includes confirmed balance and transactions in
+    /// the mempool.
+    pub fn get_address_stats(&self, address: &Address) -> Result<AddressStats, Error> {
+        let path = format!("/address/{address}");
+        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.
+    pub fn get_address_txns(&self, address: &Address) -> Result<Vec<Tx>, Error> {
+        let path = format!("/address/{address}/txs");
+        self.get_response_json(&path)
+    }
+
     /// Get confirmed transaction history for the specified address/scripthash,
     /// sorted with newest first. Returns 25 transactions per page.
     /// More can be requested by specifying the last txid seen by the previous

src/lib.rs

@@ -992,4 +992,79 @@ mod test {
         let tx_async = async_client.get_tx(&txid).await.unwrap();
         assert_eq!(tx, tx_async);
     }
+
+    #[cfg(all(feature = "blocking", feature = "async"))]
+    #[tokio::test]
+    async fn test_get_address_stats() {
+        let (blocking_client, async_client) = setup_clients().await;
+
+        let address = BITCOIND
+            .client
+            .get_new_address(Some("test"), Some(AddressType::Legacy))
+            .unwrap()
+            .assume_checked();
+
+        let _txid = BITCOIND
+            .client
+            .send_to_address(
+                &address,
+                Amount::from_sat(1000),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            )
+            .unwrap();
+
+        let address_blocking = blocking_client.get_address_stats(&address).unwrap();
+        let address_async = async_client.get_address_stats(&address).await.unwrap();
+        assert_eq!(address_blocking, address_async);
+        assert_eq!(address_async.chain_stats.funded_txo_count, 0);
+
+        let _miner = MINER.lock().await;
+        generate_blocks_and_wait(1);
+
+        let address_blocking = blocking_client.get_address_stats(&address).unwrap();
+        let address_async = async_client.get_address_stats(&address).await.unwrap();
+        assert_eq!(address_blocking, address_async);
+        assert_eq!(address_async.chain_stats.funded_txo_count, 1);
+        assert_eq!(address_async.chain_stats.funded_txo_sum, 1000);
+    }
+
+    #[cfg(all(feature = "blocking", feature = "async"))]
+    #[tokio::test]
+    async fn test_get_address_txns() {
+        let (blocking_client, async_client) = setup_clients().await;
+
+        let address = BITCOIND
+            .client
+            .get_new_address(Some("test"), Some(AddressType::Legacy))
+            .unwrap()
+            .assume_checked();
+
+        let txid = BITCOIND
+            .client
+            .send_to_address(
+                &address,
+                Amount::from_sat(1000),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            )
+            .unwrap();
+
+        let _miner = MINER.lock().await;
+        generate_blocks_and_wait(1);
+
+        let address_txns_blocking = blocking_client.get_address_txns(&address).unwrap();
+        let address_txns_async = async_client.get_address_txns(&address).await.unwrap();
+
+        assert_eq!(address_txns_blocking, address_txns_async);
+        assert_eq!(address_txns_async[0].txid, txid);
+    }
 }