feat(client): add get_block_txs

Author: luisschwab

src/async.rs

@@ -473,6 +473,24 @@ impl<S: Sleeper> AsyncClient<S> {
         self.get_response_json(&path).await
     }
 
+    /// Get up to 25 [`Transaction`]s from a [`Block`], given it's [`BlockHash`],
+    /// beginning at `start_index` (starts from 0 if `start_index` is `None`).
+    ///
+    /// The `start_index` value MUST be a multiple of 25,
+    /// even though this is not documented on the Esplora specification.
+    pub async fn get_block_txs(
+        &self,
+        blockhash: &BlockHash,
+        start_index: Option<u32>,
+    ) -> Result<Vec<Tx>, Error> {
+        let path = match start_index {
+            None => format!("/block/{blockhash}/txs"),
+            Some(start_index) => format!("/block/{blockhash}/txs/{start_index}"),
+        };
+
+        self.get_response_json(&path).await
+    }
+
     /// Gets some recent block summaries starting at the tip or at `height` if
     /// provided.
     ///

src/blocking.rs

@@ -401,6 +401,24 @@ impl BlockingClient {
         self.get_response_json(&path)
     }
 
+    /// Get up to 25 [`Transaction`]s from a [`Block`], given it's [`BlockHash`],
+    /// beginning at `start_index` (starts from 0 if `start_index` is `None`).
+    ///
+    /// The `start_index` value MUST be a multiple of 25,
+    /// even though this is not documented on the Esplora specification.
+    pub fn get_block_txs(
+        &self,
+        blockhash: &BlockHash,
+        start_index: Option<u32>,
+    ) -> Result<Vec<Tx>, Error> {
+        let path = match start_index {
+            None => format!("/block/{blockhash}/txs"),
+            Some(start_index) => format!("/block/{blockhash}/txs/{start_index}"),
+        };
+
+        self.get_response_json(&path)
+    }
+
     /// Gets some recent block summaries starting at the tip or at `height` if
     /// provided.
     ///

src/lib.rs

@@ -266,6 +266,7 @@ mod test {
     use super::*;
     use electrsd::{corepc_node, ElectrsD};
     use lazy_static::lazy_static;
+    use std::collections::HashSet;
     use std::env;
     use std::str::FromStr;
     use tokio::sync::Mutex;
@@ -1028,6 +1029,83 @@ mod test {
             });
     }
 
+    #[cfg(all(feature = "blocking", feature = "async"))]
+    #[tokio::test]
+    async fn test_get_block_txs() {
+        let (blocking_client, async_client) = setup_clients().await;
+        let address = BITCOIND
+            .client
+            .new_address_with_type(AddressType::Legacy)
+            .unwrap();
+        // Create 30 transactions and mine a block.
+        let mut mined_txids = Vec::new();
+        for _ in 0..30 {
+            let txid = BITCOIND
+                .client
+                .send_to_address(&address, Amount::from_sat(1000))
+                .unwrap()
+                .txid()
+                .unwrap();
+            mined_txids.push(txid);
+        }
+        let _miner = MINER.lock().await;
+        generate_blocks_and_wait(1);
+        tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+        // Get the chain tip's blockhash.
+        let blockhash = blocking_client.get_tip_hash().unwrap();
+        let txs_blocking = blocking_client.get_block_txs(&blockhash, None).unwrap();
+        let txs_async = async_client.get_block_txs(&blockhash, None).await.unwrap();
+
+        let txs_blocking: Vec<Transaction> = txs_blocking
+            .into_iter()
+            .map(|esplora_tx| esplora_tx.to_tx())
+            .collect();
+        let txs_async: Vec<Transaction> = txs_async
+            .into_iter()
+            .map(|esplora_tx| esplora_tx.to_tx())
+            .collect();
+
+        // Assert that we only get 25 transactions, as per the Esplora specification.
+        assert_eq!(txs_blocking.len(), 25);
+        assert_eq!(txs_blocking, txs_async);
+
+        // Compare the received transactions (skipping the coinbase transaction).
+        // All 24 non-coinbase transactions should be from our expected set.
+        let expected_txids: HashSet<Txid> = mined_txids.iter().copied().collect();
+        let received_txids: HashSet<Txid> = txs_blocking
+            .iter()
+            .skip(1)
+            .map(|tx| tx.compute_txid())
+            .collect();
+        assert_eq!(received_txids.len(), 24);
+        assert!(received_txids.is_subset(&expected_txids));
+
+        let txs_blocking_offset: Vec<Transaction> = blocking_client
+            .get_block_txs(&blockhash, Some(25))
+            .unwrap()
+            .into_iter()
+            .map(|esplora_tx| esplora_tx.to_tx())
+            .collect();
+        let txs_async_offset: Vec<Transaction> = async_client
+            .get_block_txs(&blockhash, Some(25))
+            .await
+            .unwrap()
+            .into_iter()
+            .map(|esplora_tx| esplora_tx.to_tx())
+            .collect();
+
+        // 31 transactions on the block minus `start_index` of 25 yields 6 transactions.
+        assert_eq!(txs_blocking_offset.len(), 6);
+        assert_eq!(txs_blocking_offset, txs_async_offset);
+
+        // Compare the expected and received transactions from index 25 through 30.
+        let received_offset_txids: HashSet<Txid> = txs_blocking_offset
+            .iter()
+            .map(|tx| tx.compute_txid())
+            .collect();
+        assert!(received_offset_txids.is_subset(&expected_txids));
+    }
+
     #[cfg(all(feature = "blocking", feature = "async"))]
     #[tokio::test]
     async fn test_get_blocks() {