integration_test: Add explicit types everywhere

Fixes #612

Author: alexgrad42

integration_test/src/lib.rs

@@ -4,13 +4,15 @@ use std::path::PathBuf;
 
 use bitcoin::bip32::{Fingerprint, Xpriv, Xpub};
 use bitcoin::secp256k1::{Secp256k1, XOnlyPublicKey};
-use bitcoin::Network;
+use bitcoin::{Address, Block, BlockHash, Network, Transaction};
+use bitcoind::vtype::GetPeerInfo;
 use bitcoind::{Conf, P2P};
 use rand::distributions::Alphanumeric;
 use rand::Rng;
 
 #[rustfmt::skip]    // Keep public re-exports separate.
-pub use bitcoind::BitcoinD; // Re-export this to make test imports more terse.
+pub use bitcoind::BitcoinD;
+// Re-export this to make test imports more terse.
 
 /// Initialize a logger (configure with `RUST_LOG=trace cargo test`).
 #[allow(dead_code)] // Not all tests use this function.
@@ -76,19 +78,19 @@ impl BitcoinDExt for BitcoinD {
     }
 
     fn fund_wallet(&self) {
-        let address = self.client.new_address().expect("failed to get new address");
+        let address: Address = self.client.new_address().expect("failed to get new address");
         self.client.generate_to_address(101, &address).expect("failed to generate to address");
     }
 
     fn mine_a_block(&self) {
-        let address = self.client.new_address().expect("failed to get new address");
+        let address: Address = self.client.new_address().expect("failed to get new address");
         self.client.generate_to_address(1, &address).expect("failed to generate to address");
     }
 
     fn create_mempool_transaction(&self) -> (bitcoin::Address, bitcoin::Txid) {
         const MILLION_SATS: bitcoin::Amount = bitcoin::Amount::from_sat(1000000);
 
-        let address = self.client.new_address().expect("failed to get new address");
+        let address: Address = self.client.new_address().expect("failed to get new address");
 
         let txid = self
             .client
@@ -103,15 +105,15 @@ impl BitcoinDExt for BitcoinD {
         let (address, _) = self.create_mempool_transaction();
         self.mine_a_block();
 
-        let best_block_hash = self.client.best_block_hash().expect("best_block_hash");
-        let best_block = self.client.get_block(best_block_hash).expect("best_block");
-        let tx = best_block.txdata[1].clone();
+        let best_block_hash: BlockHash = self.client.best_block_hash().expect("best_block_hash");
+        let best_block: Block = self.client.get_block(best_block_hash).expect("best_block");
+        let tx: Transaction = best_block.txdata[1].clone();
 
         (address, tx)
     }
 
     fn peers_connected(&self) -> usize {
-        let json = self.client.get_peer_info().expect("get_peer_info");
+        let json: GetPeerInfo = self.client.get_peer_info().expect("get_peer_info");
         json.0.len()
     }
 }

integration_test/tests/blockchain.rs

@@ -6,7 +6,7 @@
 
 #[cfg(feature = "v30_and_below")]
 use bitcoin::consensus::encode;
-use bitcoin::hex;
+use bitcoin::{hex, Address, BlockHash, Transaction, Txid};
 use bitcoind::vtype::*; // All the version specific types.
 use bitcoind::{mtype, Input, Output};
 use integration_test::{BitcoinD, BitcoinDExt as _, Wallet};
@@ -144,7 +144,7 @@ fn blockchain__get_best_block_hash__modelled() {
 #[cfg(feature = "v30_and_below")]
 fn blockchain__get_block__modelled() {
     let node = BitcoinD::with_wallet(Wallet::None, &[]);
-    let block_hash = node.client.best_block_hash().expect("best_block_hash failed");
+    let block_hash: BlockHash = node.client.best_block_hash().expect("best_block_hash failed");
 
     let json: GetBlockVerboseZero =
         node.client.get_block_verbose_zero(block_hash).expect("getblock verbose=0");
@@ -161,7 +161,7 @@ fn blockchain__get_block__modelled() {
         let node = BitcoinD::with_wallet(Wallet::Default, &[]);
         node.fund_wallet();
         let (_address, mined_tx) = node.create_mined_transaction();
-        let block_hash = node.client.best_block_hash().expect("best_block_hash failed");
+        let block_hash: BlockHash = node.client.best_block_hash().expect("best_block_hash failed");
 
         let json: GetBlockVerboseTwo =
             node.client.get_block_verbose_two(block_hash).expect("getblock verbose=2");
@@ -228,7 +228,7 @@ fn blockchain__get_block_count__modelled() {
 fn blockchain__get_block_filter__modelled() {
     let node = BitcoinD::with_wallet(Wallet::Default, &["-blockfilterindex"]);
     node.mine_a_block();
-    let hash = node.client.best_block_hash().expect("best_block_hash failed");
+    let hash: BlockHash = node.client.best_block_hash().expect("best_block_hash failed");
 
     let json: GetBlockFilter = node.client.get_block_filter(hash).expect("getblockfilter");
     let model: Result<mtype::GetBlockFilter, GetBlockFilterError> = json.into_model();
@@ -279,7 +279,7 @@ fn blockchain__get_block_hash__modelled() {
 #[test]
 fn blockchain__get_block_header__modelled() {
     let node = BitcoinD::with_wallet(Wallet::None, &[]);
-    let block_hash = node.client.best_block_hash().expect("best_block_hash failed");
+    let block_hash: BlockHash = node.client.best_block_hash().expect("best_block_hash failed");
 
     // verbose = false
     let json: GetBlockHeader = node.client.get_block_header(&block_hash).expect("getblockheader");
@@ -321,7 +321,7 @@ fn get_block_stats_by_height(node: &BitcoinD) {
 }
 
 fn get_block_stats_by_block_hash(node: &BitcoinD) {
-    let block_hash = node.client.best_block_hash().expect("best_block_hash failed");
+    let block_hash: BlockHash = node.client.best_block_hash().expect("best_block_hash failed");
     let json: GetBlockStats =
         node.client.get_block_stats_by_block_hash(&block_hash, None).expect("getblockstats");
 
@@ -396,7 +396,7 @@ fn blockchain__get_deployment_info__modelled() {
         .expect("best_block_hash failed")
         .block_hash()
         .expect("block_hash parse failed");
-    let tip_block_hash = node.client.best_block_hash().expect("best_block_hash failed");
+    let tip_block_hash: BlockHash = node.client.best_block_hash().expect("best_block_hash failed");
 
     let json: GetDeploymentInfo =
         node.client.get_deployment_info(&first_block_hash).expect("getdeploymentinfo");
@@ -427,7 +427,8 @@ fn blockchain__get_descriptor_activity__modelled() {
 
         #[cfg(not(feature = "v29_and_below"))]
         {
-            let block_hash = node.client.best_block_hash().expect("best_block_hash failed");
+            let block_hash: BlockHash =
+                node.client.best_block_hash().expect("best_block_hash failed");
             node.client
                 .get_descriptor_activity(
                     &[block_hash],
@@ -639,7 +640,7 @@ fn blockchain__import_mempool() {
     node.fund_wallet();
     let (_address, _tx) = node.create_mined_transaction();
 
-    let mempool_path = node.client.save_mempool().expect("savemempool");
+    let mempool_path: () = node.client.save_mempool().expect("savemempool");
 
     let _: () = node.client.import_mempool(&mempool_path.filename).expect("importmempool");
 }
@@ -648,7 +649,7 @@ fn blockchain__import_mempool() {
 fn blockchain__precious_block() {
     let node = BitcoinD::with_wallet(Wallet::Default, &[]);
     node.mine_a_block();
-    let hash = node.client.best_block_hash().expect("best_block_hash failed");
+    let hash: BlockHash = node.client.best_block_hash().expect("best_block_hash failed");
     node.mine_a_block();
 
     let _: () = node.client.precious_block(hash).expect("preciousblock");
@@ -659,7 +660,7 @@ fn blockchain__prune_blockchain() {
     const NBLOCKS: usize = 1;
 
     let node = BitcoinD::with_wallet(Wallet::Default, &["-prune=550"]);
-    let address = node.client.new_address().expect("Failed to get new address");
+    let address: Address = node.client.new_address().expect("Failed to get new address");
 
     let gen_result = node
         .client
@@ -754,13 +755,13 @@ fn blockchain__verify_tx_out_proof__modelled() {
     node.fund_wallet();
 
     let (_address, tx) = node.create_mined_transaction();
-    let txid = tx.compute_txid();
+    let txid: Txid = tx.compute_txid();
 
-    let proof = node.client.get_tx_out_proof(&[txid]).expect("gettxoutproof");
+    let proof: String = node.client.get_tx_out_proof(&[txid]).expect("gettxoutproof");
 
     let json: VerifyTxOutProof = node.client.verify_tx_out_proof(&proof).expect("verifytxoutproof");
     let model: Result<mtype::VerifyTxOutProof, hex::HexToArrayError> = json.into_model();
-    let txids = model.unwrap();
+    let txids: mtype::VerifyTxOutProof = model.unwrap();
 
     // sanity check
     assert_eq!(txids.0.len(), 1);
@@ -771,7 +772,7 @@ fn blockchain__wait_for_block__modelled() {
     let node = BitcoinD::with_wallet(Wallet::Default, &[]);
     node.fund_wallet();
     let (_address, _tx) = node.create_mined_transaction();
-    let block_hash = node.client.best_block_hash().expect("bestblockhash");
+    let block_hash: BlockHash = node.client.best_block_hash().expect("bestblockhash");
 
     let json: WaitForBlock = node.client.wait_for_block(&block_hash).expect("waitforblock");
     let model: Result<mtype::WaitForBlock, WaitForBlockError> = json.into_model();
@@ -784,8 +785,8 @@ fn blockchain__wait_for_block_height__modelled() {
     let node = BitcoinD::with_wallet(Wallet::Default, &[]);
     node.fund_wallet();
     let (_address, _tx) = node.create_mined_transaction();
-    let height = node.client.get_block_count().expect("getblockcount").0;
-    let block_hash = node.client.best_block_hash().expect("bestblockhash");
+    let height: u64 = node.client.get_block_count().expect("getblockcount").0;
+    let block_hash: BlockHash = node.client.best_block_hash().expect("bestblockhash");
     let target_height = height;
 
     let json: WaitForBlockHeight =
@@ -826,16 +827,16 @@ fn blockchain__wait_for_new_block__modelled() {
 /// Returns the child's txid.
 fn create_child_spending_parent(node: &BitcoinD, parent_txid: bitcoin::Txid) -> bitcoin::Txid {
     let inputs = vec![Input { txid: parent_txid, vout: 0, sequence: None }];
-    let spend_address = node.client.new_address().expect("newaddress");
+    let spend_address: Address = node.client.new_address().expect("newaddress");
     let outputs = vec![Output::new(spend_address, bitcoin::Amount::from_sat(100_000))];
 
     let raw: CreateRawTransaction =
         node.client.create_raw_transaction(&inputs, &outputs).expect("createrawtransaction");
-    let unsigned = raw.transaction().expect("raw.transaction");
+    let unsigned: Transaction = raw.transaction().expect("raw.transaction");
 
     let funded: FundRawTransaction =
         node.client.fund_raw_transaction(&unsigned).expect("fundrawtransaction");
-    let funded_tx = funded.transaction().expect("funded.transaction");
+    let funded_tx: Transaction = funded.transaction().expect("funded.transaction");
 
     let signed: SignRawTransaction = node
         .client
@@ -844,7 +845,8 @@ fn create_child_spending_parent(node: &BitcoinD, parent_txid: bitcoin::Txid) ->
     let sign_raw_transaction =
         signed.into_model().expect("SignRawTransactionWithWallet into model");
     let child_txid = sign_raw_transaction.tx.compute_txid();
-    let _ = node.client.send_raw_transaction(&sign_raw_transaction.tx).expect("sendrawtransaction");
+    let _: SendRawTransaction =
+        node.client.send_raw_transaction(&sign_raw_transaction.tx).expect("sendrawtransaction");
 
     child_txid
 }