Depend on bitcoin v0.32.0

Depend on the latest release of `rust-bitcoin`.

Author: tcharding

client/examples/test_against_node.rs

@@ -37,8 +37,8 @@ fn main_result() -> Result<(), Error> {
 
     let bitcoin_block: bitcoin::Block = rpc.get_by_id(&best_block_hash)?;
     println!("best block hash by `get`: {}", bitcoin_block.header.prev_blockhash);
-    let bitcoin_tx: bitcoin::Transaction = rpc.get_by_id(&bitcoin_block.txdata[0].txid())?;
-    println!("tx by `get`: {}", bitcoin_tx.txid());
+    let bitcoin_tx: bitcoin::Transaction = rpc.get_by_id(&bitcoin_block.txdata[0].compute_txid())?;
+    println!("tx by `get`: {}", bitcoin_tx.compute_txid());
 
     Ok(())
 }

client/src/client.rs

@@ -15,7 +15,8 @@ use std::iter::FromIterator;
 use std::path::PathBuf;
 use std::{fmt, result};
 
-use crate::{bitcoin, deserialize_hex};
+use crate::bitcoin;
+use crate::bitcoin::consensus::encode;
 use bitcoin::hex::DisplayHex;
 use jsonrpc;
 use serde;
@@ -163,7 +164,7 @@ pub trait RawTx: Sized + Clone {
 
 impl<'a> RawTx for &'a Transaction {
     fn raw_hex(self) -> String {
-        bitcoin::consensus::encode::serialize_hex(self)
+        encode::serialize_hex(self)
     }
 }
 
@@ -333,7 +334,7 @@ pub trait RpcApi: Sized {
 
     fn get_block(&self, hash: &bitcoin::BlockHash) -> Result<Block> {
         let hex: String = self.call("getblock", &[into_json(hash)?, 0.into()])?;
-        deserialize_hex(&hex)
+        Ok(encode::deserialize_hex(&hex)?)
     }
 
     fn get_block_hex(&self, hash: &bitcoin::BlockHash) -> Result<String> {
@@ -347,7 +348,7 @@ pub trait RpcApi: Sized {
 
     fn get_block_header(&self, hash: &bitcoin::BlockHash) -> Result<bitcoin::block::Header> {
         let hex: String = self.call("getblockheader", &[into_json(hash)?, false.into()])?;
-        deserialize_hex(&hex)
+        Ok(encode::deserialize_hex(&hex)?)
     }
 
     fn get_block_header_info(
@@ -491,7 +492,7 @@ pub trait RpcApi: Sized {
     ) -> Result<Transaction> {
         let mut args = [into_json(txid)?, into_json(false)?, opt_into_json(block_hash)?];
         let hex: String = self.call("getrawtransaction", handle_defaults(&mut args, &[null()]))?;
-        deserialize_hex(&hex)
+        Ok(encode::deserialize_hex(&hex)?)
     }
 
     fn get_raw_transaction_hex(
@@ -788,7 +789,7 @@ pub trait RpcApi: Sized {
         replaceable: Option<bool>,
     ) -> Result<Transaction> {
         let hex: String = self.create_raw_transaction_hex(utxos, outs, locktime, replaceable)?;
-        deserialize_hex(&hex)
+        Ok(encode::deserialize_hex(&hex)?)
     }
 
     fn decode_raw_transaction<R: RawTx>(

client/src/error.rs

@@ -22,7 +22,7 @@ pub enum Error {
     JsonRpc(jsonrpc::error::Error),
     Hex(hex::HexToBytesError),
     Json(serde_json::error::Error),
-    BitcoinSerialization(bitcoin::consensus::encode::Error),
+    BitcoinSerialization(bitcoin::consensus::encode::FromHexError),
     Secp256k1(secp256k1::Error),
     Io(io::Error),
     InvalidAmount(bitcoin::amount::ParseAmountError),
@@ -51,8 +51,8 @@ impl From<serde_json::error::Error> for Error {
     }
 }
 
-impl From<bitcoin::consensus::encode::Error> for Error {
-    fn from(e: bitcoin::consensus::encode::Error) -> Error {
+impl From<bitcoin::consensus::encode::FromHexError> for Error {
+    fn from(e: bitcoin::consensus::encode::FromHexError) -> Error {
         Error::BitcoinSerialization(e)
     }
 }

client/src/lib.rs

@@ -27,8 +27,6 @@ pub extern crate jsonrpc;
 pub extern crate bitcoincore_rpc_json;
 pub use crate::json::bitcoin;
 pub use bitcoincore_rpc_json as json;
-use json::bitcoin::consensus::{Decodable, ReadExt};
-use json::bitcoin::hex::HexToBytesIter;
 
 mod client;
 mod error;
@@ -37,15 +35,3 @@ mod queryable;
 pub use crate::client::*;
 pub use crate::error::Error;
 pub use crate::queryable::*;
-
-fn deserialize_hex<T: Decodable>(hex: &str) -> Result<T> {
-    let mut reader = HexToBytesIter::new(&hex)?;
-    let object = Decodable::consensus_decode(&mut reader)?;
-    if reader.read_u8().is_ok() {
-        Err(Error::BitcoinSerialization(bitcoin::consensus::encode::Error::ParseFailed(
-            "data not consumed entirely when explicitly deserializing",
-        )))
-    } else {
-        Ok(object)
-    }
-}

client/src/queryable.rs

@@ -28,8 +28,7 @@ impl<C: RpcApi> Queryable<C> for bitcoin::block::Block {
     fn query(rpc: &C, id: &Self::Id) -> Result<Self> {
         let rpc_name = "getblock";
         let hex: String = rpc.call(rpc_name, &[serde_json::to_value(id)?, 0.into()])?;
-        let bytes: Vec<u8> = bitcoin::hashes::hex::FromHex::from_hex(&hex)?;
-        Ok(bitcoin::consensus::encode::deserialize(&bytes)?)
+        Ok(bitcoin::consensus::encode::deserialize_hex(&hex)?)
     }
 }
 
@@ -39,8 +38,7 @@ impl<C: RpcApi> Queryable<C> for bitcoin::transaction::Transaction {
     fn query(rpc: &C, id: &Self::Id) -> Result<Self> {
         let rpc_name = "getrawtransaction";
         let hex: String = rpc.call(rpc_name, &[serde_json::to_value(id)?])?;
-        let bytes: Vec<u8> = bitcoin::hashes::hex::FromHex::from_hex(&hex)?;
-        Ok(bitcoin::consensus::encode::deserialize(&bytes)?)
+        Ok(bitcoin::consensus::encode::deserialize_hex(&hex)?)
     }
 }
 

integration_test/Cargo.toml

@@ -6,6 +6,6 @@ edition = "2018"
 
 [dependencies]
 bitcoincore-rpc = { path = "../client" }
-bitcoin = { version = "0.31.0", features = ["serde", "rand"]}
+bitcoin = { version = "0.32.0", features = ["serde", "rand"]}
 lazy_static = "1.4.0"
 log = "0.4"

integration_test/src/main.rs

@@ -28,7 +28,7 @@ use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::Hash;
 use bitcoin::{secp256k1, ScriptBuf, sighash};
 use bitcoin::{
-    transaction, Address, Amount, Network, OutPoint, PrivateKey, Sequence, SignedAmount,
+    transaction, Address, Amount, CompressedPublicKey, Network, OutPoint, PrivateKey, Sequence, SignedAmount,
     Transaction, TxIn, TxOut, Txid, Witness,
 };
 use bitcoincore_rpc::bitcoincore_rpc_json::{
@@ -268,7 +268,8 @@ fn test_get_raw_change_address(cl: &Client) {
 fn test_dump_private_key(cl: &Client) {
     let addr = cl.get_new_address(None, Some(json::AddressType::Bech32)).unwrap().assume_checked();
     let sk = cl.dump_private_key(&addr).unwrap();
-    assert_eq!(addr, Address::p2wpkh(&sk.public_key(&SECP), *NET).unwrap());
+    let pk = CompressedPublicKey::from_private_key(&SECP, &sk).unwrap();
+    assert_eq!(addr, Address::p2wpkh(&pk, *NET));
 }
 
 fn test_generate(cl: &Client) {
@@ -571,11 +572,12 @@ fn test_get_block_filter(cl: &Client) {
 
 fn test_sign_raw_transaction_with_send_raw_transaction(cl: &Client) {
     let sk = PrivateKey {
-        network: Network::Regtest,
+        network: Network::Regtest.into(),
         inner: secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng()),
         compressed: true,
     };
-    let addr = Address::p2wpkh(&sk.public_key(&SECP), Network::Regtest).unwrap();
+    let pk = CompressedPublicKey::from_private_key(&SECP, &sk).unwrap();
+    let addr = Address::p2wpkh(&pk, Network::Regtest);
 
     let options = json::ListUnspentQueryOptions {
         minimum_amount: Some(btc(2)),
@@ -694,7 +696,7 @@ fn test_decode_raw_transaction(cl: &Client) {
 
     let decoded_transaction = cl.decode_raw_transaction(hex, None).unwrap();
 
-    assert_eq!(tx.txid(), decoded_transaction.txid);
+    assert_eq!(tx.compute_txid(), decoded_transaction.txid);
     assert_eq!(500_000, decoded_transaction.locktime);
 
     assert_eq!(decoded_transaction.vin[0].txid.unwrap(), unspent.txid);
@@ -984,7 +986,7 @@ fn test_list_received_by_address(cl: &Client) {
 
 fn test_import_public_key(cl: &Client) {
     let sk = PrivateKey {
-        network: Network::Regtest,
+        network: Network::Regtest.into(),
         inner: secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng()),
         compressed: true,
     };
@@ -995,7 +997,7 @@ fn test_import_public_key(cl: &Client) {
 
 fn test_import_priv_key(cl: &Client) {
     let sk = PrivateKey {
-        network: Network::Regtest,
+        network: Network::Regtest.into(),
         inner: secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng()),
         compressed: true,
     };
@@ -1006,7 +1008,7 @@ fn test_import_priv_key(cl: &Client) {
 
 fn test_import_address(cl: &Client) {
     let sk = PrivateKey {
-        network: Network::Regtest,
+        network: Network::Regtest.into(),
         inner: secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng()),
         compressed: true,
     };
@@ -1018,7 +1020,7 @@ fn test_import_address(cl: &Client) {
 
 fn test_import_address_script(cl: &Client) {
     let sk = PrivateKey {
-        network: Network::Regtest,
+        network: Network::Regtest.into(),
         inner: secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng()),
         compressed: true,
     };

json/Cargo.toml

@@ -23,4 +23,4 @@ path = "src/lib.rs"
 serde = { version = "1", features = [ "derive" ] }
 serde_json = "1"
 
-bitcoin = { version = "0.31.0", features = ["serde", "rand-std"]}
+bitcoin = { version = "0.32.0", features = ["serde", "rand-std"]}