v17: Add support for blockchain methods

Add support to the `v17` client and integration tests for the following
methods (all from the `blockchain` section):

- `getblockcount`
- `getblockhash`
- `getblockheader`

Author: tcharding

client/src/client_sync/v17/blockchain.rs

@@ -70,6 +70,50 @@ macro_rules! impl_client_v17__getblockchaininfo {
     };
 }
 
+/// Implements bitcoind JSON-RPC API method `getblockcount`
+#[macro_export]
+macro_rules! impl_client_v17__getblockcount {
+    () => {
+        impl Client {
+            pub fn get_block_count(&self) -> Result<GetBlockCount> {
+                self.call("getblockcount", &[])
+            }
+        }
+    };
+}
+
+/// Implements bitcoind JSON-RPC API method `getblockhash`
+#[macro_export]
+macro_rules! impl_client_v17__getblockhash {
+    () => {
+        impl Client {
+            pub fn get_block_hash(&self, height: u64) -> Result<GetBlockHash> {
+                self.call("getblockhash", &[into_json(height)?])
+            }
+        }
+    };
+}
+
+/// Implements bitcoind JSON-RPC API method `getblockheader`
+#[macro_export]
+macro_rules! impl_client_v17__getblockheader {
+    () => {
+        impl Client {
+            pub fn get_block_header(&self, hash: &BlockHash) -> Result<GetBlockHeader> {
+                self.call("getblockheader", &[into_json(hash)?, into_json(false)?])
+            }
+
+            // This is the same as calling getblockheader with verbose==true.
+            pub fn get_block_header_verbose(
+                &self,
+                hash: &BlockHash,
+            ) -> Result<GetBlockHeaderVerbose> {
+                self.call("getblockheader", &[into_json(hash)?])
+            }
+        }
+    };
+}
+
 /// Implements bitcoind JSON-RPC API method `gettxout`
 #[macro_export]
 macro_rules! impl_client_v17__gettxout {

client/src/client_sync/v17/mod.rs

@@ -25,6 +25,9 @@ crate::impl_client_v17__getblockchaininfo!();
 crate::impl_client_v17__getbestblockhash!();
 crate::impl_client_v17__getblock!();
 crate::impl_client_v17__gettxout!();
+crate::impl_client_v17__getblockcount!();
+crate::impl_client_v17__getblockhash!();
+crate::impl_client_v17__getblockheader!();
 
 // == Control ==
 crate::impl_client_v17__stop!();

integration_test/src/v17/blockchain.rs

@@ -81,6 +81,56 @@ macro_rules! impl_test_v17__getblockchaininfo {
     };
 }
 
+/// Requires `Client` to be in scope and to implement `getblockcount`.
+#[macro_export]
+macro_rules! impl_test_v17__getblockcount {
+    () => {
+        #[test]
+        fn get_block_count() {
+            let bitcoind = $crate::bitcoind_no_wallet();
+            let json = bitcoind.client.get_block_count().expect("getblockcount");
+            let _ = json.into_model();
+        }
+    };
+}
+
+/// Requires `Client` to be in scope and to implement `getblockhash`.
+#[macro_export]
+macro_rules! impl_test_v17__getblockhash {
+    () => {
+        #[test]
+        fn get_block_hash() {
+            let bitcoind = $crate::bitcoind_no_wallet();
+            let json = bitcoind.client.get_block_hash(0).expect("getblockhash");
+            assert!(json.into_model().is_ok());
+        }
+    };
+}
+
+/// Requires `Client` to be in scope and to implement `getblockheader`.
+#[macro_export]
+macro_rules! impl_test_v17__getblockheader {
+    () => {
+        #[test]
+        fn get_block_header() { // verbose = false
+            let bitcoind = $crate::bitcoind_no_wallet();
+            let json = bitcoind.client.get_block_hash(0).expect("getblockhash");
+            let hash = json.block_hash().expect("failed to get block hash");
+            let json = bitcoind.client.get_block_header(&hash).expect("getblockheader");
+            assert!(json.into_model().is_ok());
+        }
+
+        #[test]
+        fn get_block_header_verbose() { // verbose = true
+            let bitcoind = $crate::bitcoind_no_wallet();
+            let json = bitcoind.client.get_block_hash(0).expect("getblockhash");
+            let hash = json.block_hash().expect("failed to get block hash");
+            let json = bitcoind.client.get_block_header_verbose(&hash).expect("getblockheader");
+            assert!(json.into_model().is_ok());
+        }
+    };
+}
+
 /// Requires `Client` to be in scope and to implement `get_tx_out`.
 #[macro_export]
 macro_rules! impl_test_v17__gettxout {

integration_test/tests/v17_api.rs

@@ -12,6 +12,9 @@ mod blockchain {
     impl_test_v17__getblock_verbosity_0!();
     impl_test_v17__getblock_verbosity_1!();
     impl_test_v17__getblockchaininfo!();
+    impl_test_v17__getblockcount!();
+    impl_test_v17__getblockhash!();
+    impl_test_v17__getblockheader!();
 }
 
 // == Control ==

json/src/model/blockchain.rs

@@ -9,7 +9,8 @@ use std::collections::BTreeMap;
 
 use bitcoin::address::NetworkUnchecked;
 use bitcoin::{
-    block, Address, Block, BlockHash, CompactTarget, Network, TxOut, Txid, Weight, Work,
+    block, Address, Block, BlockHash, CompactTarget, Network, TxMerkleNode, TxOut, Txid, Weight,
+    Work,
 };
 use serde::{Deserialize, Serialize};
 
@@ -176,6 +177,51 @@ pub struct Bip9SoftforkStatistics {
     pub possible: Option<bool>,
 }
 
+/// Models the result of JSON-RPC method `getblockcount`.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+pub struct GetBlockCount(pub u64);
+
+/// Models the result of JSON-RPC method `getblockhash`.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+pub struct GetBlockHash(pub BlockHash);
+
+/// Models the result of JSON-RPC method `getblockheader`.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+pub struct GetBlockHeader(pub block::Header);
+
+/// Models the result of JSON-RPC method `getblockheader`.
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+pub struct GetBlockHeaderVerbose {
+    /// the block hash (same as provided).
+    pub hash: BlockHash,
+    /// The number of confirmations, or -1 if the block is not on the main chain.
+    pub confirmations: i64,
+    /// The block height or index.
+    pub height: u64,
+    /// Block version, now repurposed for soft fork signalling.
+    pub version: block::Version,
+    /// The root hash of the Merkle tree of transactions in the block.
+    pub merkle_root: TxMerkleNode,
+    /// The timestamp of the block, as claimed by the miner (seconds since epoch (Jan 1 1970 GMT).
+    pub time: u64,
+    /// The median block time in seconds since epoch (Jan 1 1970 GMT).
+    pub median_time: u64,
+    /// The nonce.
+    pub nonce: u64,
+    /// The target value below which the blockhash must lie.
+    pub bits: CompactTarget,
+    /// The difficulty.
+    pub difficulty: f64,
+    /// Expected number of hashes required to produce the current chain.
+    pub chainwork: Work,
+    /// The number of transactions in the block.
+    pub n_tx: u32,
+    /// The hash of the previous block (if available).
+    pub previous_block_hash: Option<BlockHash>,
+    /// The hash of the next block (if available).
+    pub next_block_hash: Option<BlockHash>,
+}
+
 /// Models the result of JSON-RPC method `gettxout`.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct GetTxOut {

json/src/model/mod.rs

@@ -27,8 +27,8 @@ mod zmq;
 pub use self::{
     blockchain::{
         Bip9SoftforkInfo, Bip9SoftforkStatistics, Bip9SoftforkStatus, GetBestBlockHash,
-        GetBlockVerbosityOne, GetBlockVerbosityZero, GetBlockchainInfo, GetTxOut, Softfork,
-        SoftforkType,
+        GetBlockCount, GetBlockHash, GetBlockHeader, GetBlockHeaderVerbose, GetBlockVerbosityOne,
+        GetBlockVerbosityZero, GetBlockchainInfo, GetTxOut, Softfork, SoftforkType,
     },
     generating::GenerateToAddress,
     network::{GetNetworkInfo, GetNetworkInfoAddress, GetNetworkInfoNetwork},