feat: add batch_transaction_get_merkle

- adds the new batch method for `blockchain.transaction.get_merkle`.
- adds a new test for `batch_transaction_get_merkle` with 3 different
  txids and block_heights.

Author: oleonardolima

src/api.rs

@@ -145,6 +145,17 @@ where
         (**self).transaction_get_merkle(txid, height)
     }
 
+    fn batch_transaction_get_merkle<'s, I>(
+        &self,
+        txids_and_heights: I,
+    ) -> Result<Vec<GetMerkleRes>, Error>
+    where
+        I: IntoIterator + Clone,
+        I::Item: Borrow<&'s (Txid, usize)>,
+    {
+        (**self).batch_transaction_get_merkle(txids_and_heights)
+    }
+
     fn txid_from_pos(&self, height: usize, tx_pos: usize) -> Result<Txid, Error> {
         (**self).txid_from_pos(height, tx_pos)
     }
@@ -362,6 +373,17 @@ pub trait ElectrumApi {
     /// Returns the merkle path for the transaction `txid` confirmed in the block at `height`.
     fn transaction_get_merkle(&self, txid: &Txid, height: usize) -> Result<GetMerkleRes, Error>;
 
+    /// Batch version of [`transaction_get_merkle`](#method.transaction_get_merkle).
+    ///
+    /// Take a list of `(txid, height)`, for transactions with `txid` confirmed in the block at `height`.
+    fn batch_transaction_get_merkle<'s, I>(
+        &self,
+        txids_and_heights: I,
+    ) -> Result<Vec<GetMerkleRes>, Error>
+    where
+        I: IntoIterator + Clone,
+        I::Item: Borrow<&'s (Txid, usize)>;
+
     /// Returns a transaction hash, given a block `height` and a `tx_pos` in the block.
     fn txid_from_pos(&self, height: usize, tx_pos: usize) -> Result<Txid, Error>;
 
@@ -558,6 +580,17 @@ mod test {
             unreachable!()
         }
 
+        fn batch_transaction_get_merkle<'s, I>(
+            &self,
+            _: I,
+        ) -> Result<Vec<crate::GetMerkleRes>, crate::Error>
+        where
+            I: IntoIterator + Clone,
+            I::Item: std::borrow::Borrow<&'s (bitcoin::Txid, usize)>,
+        {
+            unreachable!()
+        }
+
         fn txid_from_pos(&self, _: usize, _: usize) -> Result<bitcoin::Txid, super::Error> {
             unreachable!()
         }

src/batch.rs

@@ -62,6 +62,17 @@ impl Batch {
             .push((String::from("blockchain.transaction.get"), params));
     }
 
+    /// Add one `blockchain.transaction.get_merkle` request to the batch queue
+    pub fn transaction_get_merkle(&mut self, tx_hash_and_height: &(Txid, usize)) {
+        let (tx_hash, height) = tx_hash_and_height;
+        let params = vec![
+            Param::String(format!("{:x}", tx_hash)),
+            Param::Usize(*height),
+        ];
+        self.calls
+            .push((String::from("blockchain.transaction.get_merkle"), params));
+    }
+
     /// Add one `blockchain.estimatefee` request to the batch queue
     pub fn estimate_fee(&mut self, number: usize) {
         let params = vec![Param::Usize(number)];

src/client.rs

@@ -327,6 +327,22 @@ impl ElectrumApi for Client {
         impl_inner_call!(self, transaction_get_merkle, txid, height)
     }
 
+    #[inline]
+    fn batch_transaction_get_merkle<'s, I>(
+        &self,
+        txids_and_heights: I,
+    ) -> Result<Vec<GetMerkleRes>, Error>
+    where
+        I: IntoIterator + Clone,
+        I::Item: Borrow<&'s (Txid, usize)>,
+    {
+        impl_inner_call!(
+            self,
+            batch_transaction_get_merkle,
+            txids_and_heights.clone()
+        )
+    }
+
     #[inline]
     fn txid_from_pos(&self, height: usize, tx_pos: usize) -> Result<Txid, Error> {
         impl_inner_call!(self, txid_from_pos, height, tx_pos)

src/raw_client.rs

@@ -1102,6 +1102,17 @@ impl<T: Read + Write> ElectrumApi for RawClient<T> {
         Ok(serde_json::from_value(result)?)
     }
 
+    fn batch_transaction_get_merkle<'s, I>(
+        &self,
+        txids_and_hashes: I,
+    ) -> Result<Vec<GetMerkleRes>, Error>
+    where
+        I: IntoIterator + Clone,
+        I::Item: Borrow<&'s (Txid, usize)>,
+    {
+        impl_batch_call!(self, txids_and_hashes, transaction_get_merkle)
+    }
+
     fn txid_from_pos(&self, height: usize, tx_pos: usize) -> Result<Txid, Error> {
         let params = vec![Param::Usize(height), Param::Usize(tx_pos)];
         let req = Request::new_id(
@@ -1448,6 +1459,95 @@ mod test {
         ));
     }
 
+    #[test]
+    fn test_batch_transaction_get_merkle() {
+        use bitcoin::Txid;
+
+        let client = RawClient::new(get_test_server(), None).unwrap();
+
+        let txid_1 =
+            Txid::from_str("1f7ff3c407f33eabc8bec7d2cc230948f2249ec8e591bcf6f971ca9366c8788d")
+                .unwrap();
+        let block_height_1 = 630000;
+
+        let merkle_1_pos = 68;
+        let merkle_1_bytes = [
+            34, 65, 51, 64, 49, 139, 115, 189, 185, 246, 70, 225, 168, 193, 217, 195, 47, 66, 179,
+            240, 153, 24, 114, 215, 144, 196, 212, 41, 39, 155, 246, 25,
+        ];
+
+        let txid_2 =
+            Txid::from_str("70a8639bc9b743c0610d1231103a2f8e99f4a25670946b91f16c55a5373b37d1")
+                .unwrap();
+        let block_height_2 = 630001;
+
+        let merkle_2_pos = 25;
+        let merkle_2_bytes = [
+            169, 100, 34, 99, 168, 101, 25, 168, 184, 90, 77, 50, 151, 245, 130, 101, 193, 229,
+            136, 128, 63, 110, 241, 19, 242, 59, 184, 137, 245, 249, 188, 110,
+        ];
+
+        let txid_3 =
+            Txid::from_str("a0db149ace545beabbd87a8d6b20ffd6aa3b5a50e58add49a3d435f898c272cf")
+                .unwrap();
+        let block_height_3 = 840000;
+
+        let merkle_3_pos = 0;
+        let merkle_3_bytes = [
+            43, 184, 95, 75, 0, 75, 230, 218, 84, 247, 102, 193, 124, 30, 133, 81, 135, 50, 113,
+            18, 194, 49, 239, 47, 243, 94, 186, 208, 234, 103, 198, 158,
+        ];
+
+        let txids_and_heights = vec![
+            (txid_1, block_height_1),
+            (txid_2, block_height_2),
+            (txid_3, block_height_3),
+        ];
+        let resp = client
+            .batch_transaction_get_merkle(&txids_and_heights)
+            .unwrap();
+
+        assert_eq!(resp[0].block_height, block_height_1);
+        assert_eq!(resp[0].pos, merkle_1_pos);
+        assert_eq!(resp[0].merkle.len(), 12);
+        assert_eq!(resp[0].merkle[0], merkle_1_bytes);
+
+        assert_eq!(resp[1].block_height, block_height_2);
+        assert_eq!(resp[1].pos, merkle_2_pos);
+        assert_eq!(resp[1].merkle.len(), 12);
+        assert_eq!(resp[1].merkle[0], merkle_2_bytes);
+
+        assert_eq!(resp[2].block_height, block_height_3);
+        assert_eq!(resp[2].pos, merkle_3_pos);
+        assert_eq!(resp[2].merkle.len(), 12);
+        assert_eq!(resp[2].merkle[0], merkle_3_bytes);
+
+        for (i, res) in resp.iter().enumerate() {
+            // Check we can verify the merkle proof validity, but fail if we supply wrong data.
+            let block_header = client.block_header(res.block_height).unwrap();
+            assert!(utils::validate_merkle_proof(
+                &txids_and_heights[i].0,
+                &block_header.merkle_root,
+                res
+            ));
+
+            let mut fail_res = res.clone();
+            fail_res.pos = 13;
+            assert!(!utils::validate_merkle_proof(
+                &txids_and_heights[i].0,
+                &block_header.merkle_root,
+                &fail_res
+            ));
+
+            let fail_block_header = client.block_header(res.block_height + 1).unwrap();
+            assert!(!utils::validate_merkle_proof(
+                &txids_and_heights[i].0,
+                &fail_block_header.merkle_root,
+                res
+            ));
+        }
+    }
+
     #[test]
     fn test_txid_from_pos() {
         use bitcoin::Txid;