Merge #103: upgrade bitcoin dep to 0.30.0

c925a91 upgrade bitcoin dep to 0.30.0 (Riccardo Casatta)

Pull request description:

ACKs for top commit:
  danielabrozzoni:
    ACK c925a91

Tree-SHA512: 2b9b7756639af4d931213046866dc36ebee2a5adcbd01c906e27990696b07f1bcf87c2ee009a959f96b17407637801b856e8d4fb9a933fab148f22a619a0d586

Author: danielabrozzoni

Cargo.toml

@@ -18,7 +18,8 @@ path = "src/lib.rs"
 
 [dependencies]
 log = "^0.4"
-bitcoin = { version = "^0.29", features = ["serde"] }
+bitcoin = { version = "^0.30", features = ["serde"] }
+bitcoin-private = "0.1.0"
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1.0" }
 

src/api.rs

@@ -4,15 +4,15 @@ use std::borrow::Borrow;
 use std::convert::TryInto;
 
 use bitcoin::consensus::encode::{deserialize, serialize};
-use bitcoin::{BlockHeader, Script, Transaction, Txid};
+use bitcoin::{block, Script, Transaction, Txid};
 
 use batch::Batch;
 use types::*;
 
 /// API calls exposed by an Electrum client
 pub trait ElectrumApi {
     /// Gets the block header for height `height`.
-    fn block_header(&self, height: usize) -> Result<BlockHeader, Error> {
+    fn block_header(&self, height: usize) -> Result<block::Header, Error> {
         Ok(deserialize(&self.block_header_raw(height)?)?)
     }
 
@@ -51,7 +51,7 @@ pub trait ElectrumApi {
     /// Batch version of [`block_header`](#method.block_header).
     ///
     /// Takes a list of `heights` of blocks and returns a list of headers.
-    fn batch_block_header<I>(&self, heights: I) -> Result<Vec<BlockHeader>, Error>
+    fn batch_block_header<I>(&self, heights: I) -> Result<Vec<block::Header>, Error>
     where
         I: IntoIterator + Clone,
         I::Item: Borrow<u32>,

src/batch.rs

@@ -2,9 +2,6 @@
 //!
 //! This module contains definitions and helper functions used when making batch calls.
 
-use std::borrow::Borrow;
-
-use bitcoin::hashes::hex::ToHex;
 use bitcoin::{Script, Txid};
 
 use types::{Call, Param, ToElectrumScriptHash};
@@ -54,7 +51,7 @@ impl Batch {
 
     /// Add one `blockchain.transaction.get` request to the batch queue
     pub fn transaction_get(&mut self, tx_hash: &Txid) {
-        let params = vec![Param::String(tx_hash.to_hex())];
+        let params = vec![Param::String(format!("{:x}", tx_hash))];
         self.calls
             .push((String::from("blockchain.transaction.get"), params));
     }

src/config.rs

@@ -1,4 +1,3 @@
-use crate::Error;
 use std::time::Duration;
 
 #[derive(Debug, Clone)]

src/lib.rs

@@ -20,6 +20,7 @@
 //! ```
 
 pub extern crate bitcoin;
+extern crate bitcoin_private;
 extern crate core;
 extern crate log;
 #[cfg(feature = "use-openssl")]

src/raw_client.rs

@@ -16,8 +16,9 @@ use std::time::Duration;
 use log::{debug, error, info, trace, warn};
 
 use bitcoin::consensus::encode::deserialize;
-use bitcoin::hashes::hex::{FromHex, ToHex};
+use bitcoin::hashes::hex::FromHex;
 use bitcoin::{Script, Txid};
+use bitcoin_private::hex::exts::DisplayHex;
 
 #[cfg(feature = "use-openssl")]
 use openssl::ssl::{SslConnector, SslMethod, SslStream, SslVerifyMode};
@@ -974,7 +975,7 @@ impl<T: Read + Write> ElectrumApi for RawClient<T> {
     }
 
     fn transaction_get_raw(&self, txid: &Txid) -> Result<Vec<u8>, Error> {
-        let params = vec![Param::String(txid.to_hex())];
+        let params = vec![Param::String(format!("{:x}", txid))];
         let req = Request::new_id(
             self.last_id.fetch_add(1, Ordering::SeqCst),
             "blockchain.transaction.get",
@@ -1023,7 +1024,7 @@ impl<T: Read + Write> ElectrumApi for RawClient<T> {
     }
 
     fn transaction_broadcast_raw(&self, raw_tx: &[u8]) -> Result<Txid, Error> {
-        let params = vec![Param::String(raw_tx.to_hex())];
+        let params = vec![Param::String(raw_tx.to_lower_hex_string())];
         let req = Request::new_id(
             self.last_id.fetch_add(1, Ordering::SeqCst),
             "blockchain.transaction.broadcast",
@@ -1035,7 +1036,7 @@ impl<T: Read + Write> ElectrumApi for RawClient<T> {
     }
 
     fn transaction_get_merkle(&self, txid: &Txid, height: usize) -> Result<GetMerkleRes, Error> {
-        let params = vec![Param::String(txid.to_hex()), Param::Usize(height)];
+        let params = vec![Param::String(format!("{:x}", txid)), Param::Usize(height)];
         let req = Request::new_id(
             self.last_id.fetch_add(1, Ordering::SeqCst),
             "blockchain.transaction.get_merkle",
@@ -1076,6 +1077,8 @@ impl<T: Read + Write> ElectrumApi for RawClient<T> {
 
 #[cfg(test)]
 mod test {
+    use std::str::FromStr;
+
     use super::RawClient;
     use api::ElectrumApi;
 
@@ -1119,7 +1122,7 @@ mod test {
         let client = RawClient::new(get_test_server(), None).unwrap();
 
         let resp = client.block_header(0).unwrap();
-        assert_eq!(resp.version, 0x01);
+        assert_eq!(resp.version, bitcoin::block::Version::ONE);
         assert_eq!(resp.time, 1231006505);
         assert_eq!(resp.nonce, 0x7c2bac1d);
     }
@@ -1160,7 +1163,9 @@ mod test {
 
         // Realistically nobody will ever spend from this address, so we can expect the balance to
         // increase over time
-        let addr = bitcoin::Address::from_str("1CounterpartyXXXXXXXXXXXXXXXUWLpVr").unwrap();
+        let addr = bitcoin::Address::from_str("1CounterpartyXXXXXXXXXXXXXXXUWLpVr")
+            .unwrap()
+            .assume_checked();
         let resp = client.script_get_balance(&addr.script_pubkey()).unwrap();
         assert!(resp.confirmed >= 213091301265);
     }
@@ -1169,38 +1174,40 @@ mod test {
     fn test_script_get_history() {
         use std::str::FromStr;
 
-        use bitcoin::hashes::hex::FromHex;
         use bitcoin::Txid;
 
         let client = RawClient::new(get_test_server(), None).unwrap();
 
         // Mt.Gox hack address
         let addr = bitcoin::Address::from_str("1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF").unwrap();
-        let resp = client.script_get_history(&addr.script_pubkey()).unwrap();
+        let resp = client
+            .script_get_history(&addr.payload.script_pubkey())
+            .unwrap();
 
         assert!(resp.len() >= 328);
         assert_eq!(
             resp[0].tx_hash,
-            Txid::from_hex("e67a0550848b7932d7796aeea16ab0e48a5cfe81c4e8cca2c5b03e0416850114")
+            Txid::from_str("e67a0550848b7932d7796aeea16ab0e48a5cfe81c4e8cca2c5b03e0416850114")
                 .unwrap()
         );
     }
 
     #[test]
     fn test_script_list_unspent() {
-        use bitcoin::hashes::hex::FromHex;
         use bitcoin::Txid;
         use std::str::FromStr;
 
         let client = RawClient::new(get_test_server(), None).unwrap();
 
         // Mt.Gox hack address
         let addr = bitcoin::Address::from_str("1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF").unwrap();
-        let resp = client.script_list_unspent(&addr.script_pubkey()).unwrap();
+        let resp = client
+            .script_list_unspent(&addr.payload.script_pubkey())
+            .unwrap();
 
         assert!(resp.len() >= 329);
         let txid = "e67a0550848b7932d7796aeea16ab0e48a5cfe81c4e8cca2c5b03e0416850114";
-        let txid = Txid::from_hex(txid).unwrap();
+        let txid = Txid::from_str(txid).unwrap();
         let txs: Vec<_> = resp.iter().filter(|e| e.tx_hash == txid).collect();
         assert_eq!(txs.len(), 1);
         assert_eq!(txs[0].value, 7995600000000);
@@ -1217,9 +1224,12 @@ mod test {
         // Mt.Gox hack address
         let script_1 = bitcoin::Address::from_str("1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF")
             .unwrap()
+            .payload
             .script_pubkey();
 
-        let resp = client.batch_script_list_unspent(vec![&script_1]).unwrap();
+        let resp = client
+            .batch_script_list_unspent(vec![script_1.as_script()])
+            .unwrap();
         assert_eq!(resp.len(), 1);
         assert!(resp[0].len() >= 329);
     }
@@ -1236,31 +1246,29 @@ mod test {
 
     #[test]
     fn test_transaction_get() {
-        use bitcoin::hashes::hex::FromHex;
         use bitcoin::Txid;
 
         let client = RawClient::new(get_test_server(), None).unwrap();
 
         let resp = client
             .transaction_get(
-                &Txid::from_hex("cc2ca076fd04c2aeed6d02151c447ced3d09be6fb4d4ef36cb5ed4e7a3260566")
+                &Txid::from_str("cc2ca076fd04c2aeed6d02151c447ced3d09be6fb4d4ef36cb5ed4e7a3260566")
                     .unwrap(),
             )
             .unwrap();
         assert_eq!(resp.version, 1);
-        assert_eq!(resp.lock_time.to_u32(), 0);
+        assert_eq!(resp.lock_time.to_consensus_u32(), 0);
     }
 
     #[test]
     fn test_transaction_get_raw() {
-        use bitcoin::hashes::hex::FromHex;
         use bitcoin::Txid;
 
         let client = RawClient::new(get_test_server(), None).unwrap();
 
         let resp = client
             .transaction_get_raw(
-                &Txid::from_hex("cc2ca076fd04c2aeed6d02151c447ced3d09be6fb4d4ef36cb5ed4e7a3260566")
+                &Txid::from_str("cc2ca076fd04c2aeed6d02151c447ced3d09be6fb4d4ef36cb5ed4e7a3260566")
                     .unwrap(),
             )
             .unwrap();
@@ -1288,14 +1296,13 @@ mod test {
 
     #[test]
     fn test_transaction_get_merkle() {
-        use bitcoin::hashes::hex::FromHex;
         use bitcoin::Txid;
 
         let client = RawClient::new(get_test_server(), None).unwrap();
 
         let resp = client
             .transaction_get_merkle(
-                &Txid::from_hex("cc2ca076fd04c2aeed6d02151c447ced3d09be6fb4d4ef36cb5ed4e7a3260566")
+                &Txid::from_str("cc2ca076fd04c2aeed6d02151c447ced3d09be6fb4d4ef36cb5ed4e7a3260566")
                     .unwrap(),
                 630000,
             )
@@ -1336,7 +1343,9 @@ mod test {
         let addr = bitcoin::Address::from_str("1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF").unwrap();
 
         // Just make sure that the call returns Ok(something)
-        client.script_subscribe(&addr.script_pubkey()).unwrap();
+        client
+            .script_subscribe(&addr.payload.script_pubkey())
+            .unwrap();
     }
 
     #[test]

src/types.rs

@@ -9,10 +9,11 @@ use std::sync::Arc;
 
 use bitcoin::blockdata::block;
 use bitcoin::consensus::encode::deserialize;
-use bitcoin::hashes::hex::{FromHex, ToHex};
+use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::{sha256, Hash};
 use bitcoin::{Script, Txid};
 
+use bitcoin_private::hex::exts::DisplayHex;
 use serde::{de, Deserialize, Serialize};
 
 static JSONRPC_2_0: &str = "2.0";
@@ -86,6 +87,12 @@ impl From<[u8; 32]> for Hex32Bytes {
     }
 }
 
+impl Hex32Bytes {
+    pub(crate) fn to_hex(&self) -> String {
+        self.0.to_lower_hex_string()
+    }
+}
+
 /// Format used by the Electrum server to identify an address. The reverse sha256 hash of the
 /// scriptPubKey. Documented [here](https://electrumx.readthedocs.io/en/latest/protocol-basics.html#script-hashes).
 pub type ScriptHash = Hex32Bytes;
@@ -102,7 +109,7 @@ pub trait ToElectrumScriptHash {
 
 impl ToElectrumScriptHash for Script {
     fn to_electrum_scripthash(&self) -> ScriptHash {
-        let mut result = sha256::Hash::hash(self.as_bytes()).into_inner();
+        let mut result = sha256::Hash::hash(self.as_bytes()).to_byte_array();
         result.reverse();
 
         result.into()
@@ -122,7 +129,7 @@ fn to_hex<S>(bytes: &[u8], serializer: S) -> std::result::Result<S::Ok, S::Error
 where
     S: serde::ser::Serializer,
 {
-    serializer.serialize_str(&bytes.to_hex())
+    serializer.serialize_str(&bytes.to_lower_hex_string())
 }
 
 fn from_hex_array<'de, T, D>(deserializer: D) -> Result<Vec<T>, D::Error>
@@ -145,7 +152,7 @@ where
     Ok(answer)
 }
 
-fn from_hex_header<'de, D>(deserializer: D) -> Result<block::BlockHeader, D::Error>
+fn from_hex_header<'de, D>(deserializer: D) -> Result<block::Header, D::Error>
 where
     D: de::Deserializer<'de>,
 {
@@ -208,7 +215,7 @@ pub struct GetHeadersRes {
     pub raw_headers: Vec<u8>,
     /// Array of block headers.
     #[serde(skip)]
-    pub headers: Vec<block::BlockHeader>,
+    pub headers: Vec<block::Header>,
 }
 
 /// Response to a [`script_get_balance`](../client/struct.Client.html#method.script_get_balance) request.
@@ -241,7 +248,7 @@ pub struct HeaderNotification {
     pub height: usize,
     /// Newly added header.
     #[serde(rename = "hex", deserialize_with = "from_hex_header")]
-    pub header: block::BlockHeader,
+    pub header: block::Header,
 }
 
 /// Notification of a new block header with the header encoded as raw bytes