Merge pull request #13 from serejkaaa512/feature/update_deps

updated bitcoin version to 0.23

Author: stevenroose

Cargo.toml

@@ -11,15 +11,13 @@ keywords = [ "crypto", "bitcoin" ]
 readme = "README.md"
 
 [dependencies]
-bitcoin = { version= "0.21", features=["serde"]}
-bitcoin_hashes={version="0.7", features=["serde"]}
-secp256k1 = "0.15"
+bitcoin = { version= "0.23", features=["use-serde"]}
 rand="0.7"
 rust-crypto = "0.2"
 serde = "1"
 serde_derive = "1"
 
 [dev-dependencies]
-bitcoin = { version= "0.21", features=["serde", "bitcoinconsensus"]}
+bitcoin = { version= "0.23", features=["use-serde", "bitcoinconsensus"]}
 serde_json="1"
 hex = "0.3"

src/account.rs

@@ -18,6 +18,7 @@
 //!
 //! Accounts compatible with BIP32, BIP39, BIP44, BIP49, BIP84
 //!
+use bitcoin::hashes::{hash160, Hash};
 use bitcoin::util::bip32::ExtendedPubKey;
 use bitcoin::{
     blockdata::script::Builder,
@@ -30,7 +31,6 @@ use bitcoin::{
     util::bip32::{ChildNumber, ExtendedPrivKey},
     Address, OutPoint, PrivateKey, PublicKey, Script, Transaction,
 };
-use bitcoin_hashes::{hash160, Hash};
 use crypto::{
     aes, blockmodes, buffer,
     buffer::{BufferResult, ReadBuffer, WriteBuffer},
@@ -885,7 +885,6 @@ mod test {
     use bitcoin::blockdata::transaction::{OutPoint, TxIn, TxOut};
     use bitcoin::network::constants::Network;
     use bitcoin::util::bip32::ChildNumber;
-    use bitcoin_hashes::sha256d;
     use hex::decode;
     use rand::Rng;
     use serde_json::Value;
@@ -920,7 +919,7 @@ mod test {
         let input_transaction = Transaction {
             input: vec![TxIn {
                 previous_output: OutPoint {
-                    txid: sha256d::Hash::default(),
+                    txid: bitcoin::Txid::default(),
                     vout: 0,
                 },
                 sequence: RBF,
@@ -990,7 +989,7 @@ mod test {
         let input_transaction = Transaction {
             input: vec![TxIn {
                 previous_output: OutPoint {
-                    txid: sha256d::Hash::default(),
+                    txid: bitcoin::Txid::default(),
                     vout: 0,
                 },
                 sequence: RBF,
@@ -1060,7 +1059,7 @@ mod test {
         let input_transaction = Transaction {
             input: vec![TxIn {
                 previous_output: OutPoint {
-                    txid: sha256d::Hash::default(),
+                    txid: bitcoin::Txid::default(),
                     vout: 0,
                 },
                 sequence: RBF,
@@ -1144,7 +1143,7 @@ mod test {
         let input_transaction = Transaction {
             input: vec![TxIn {
                 previous_output: OutPoint {
-                    txid: sha256d::Hash::default(),
+                    txid: bitcoin::Txid::default(),
                     vout: 0,
                 },
                 sequence: RBF,
@@ -1232,7 +1231,7 @@ mod test {
         let input_transaction = Transaction {
             input: vec![TxIn {
                 previous_output: OutPoint {
-                    txid: sha256d::Hash::default(),
+                    txid: bitcoin::Txid::default(),
                     vout: 0,
                 },
                 sequence: RBF,

src/coins.rs

@@ -22,7 +22,6 @@ use std::collections::HashMap;
 
 use bitcoin::Block;
 use bitcoin::{OutPoint, Script, Transaction, TxOut};
-use bitcoin_hashes::sha256d;
 use rand::thread_rng;
 
 use account::{KeyDerivation, MasterAccount};
@@ -44,7 +43,7 @@ pub struct Coins {
     /// confirmed coins (these have SPV proofs)
     confirmed: HashMap<OutPoint, Coin>,
     /// SPV proofs of transactions confirming coins
-    proofs: HashMap<sha256d::Hash, ProvedTransaction>,
+    proofs: HashMap<bitcoin::Txid, ProvedTransaction>,
 }
 
 impl Coins {
@@ -130,13 +129,13 @@ impl Coins {
         &self.unconfirmed
     }
 
-    pub fn proofs(&self) -> &HashMap<sha256d::Hash, ProvedTransaction> {
+    pub fn proofs(&self) -> &HashMap<bitcoin::Txid, ProvedTransaction> {
         &self.proofs
     }
 
     pub fn available_balance<H>(&self, height: u32, block_height: H) -> u64
     where
-        H: Fn(&sha256d::Hash) -> Option<u32>,
+        H: Fn(&bitcoin::BlockHash) -> Option<u32>,
     {
         self.available_coins(height, block_height)
             .iter()
@@ -146,7 +145,7 @@ impl Coins {
 
     pub fn available_coins<H>(&self, height: u32, block_height: H) -> Vec<(OutPoint, Coin, u32)>
     where
-        H: Fn(&sha256d::Hash) -> Option<u32>,
+        H: Fn(&bitcoin::BlockHash) -> Option<u32>,
     {
         self.confirmed
             .iter()
@@ -182,7 +181,7 @@ impl Coins {
     }
 
     /// unwind the tip of the trunk
-    pub fn unwind_tip(&mut self, block_hash: &sha256d::Hash) {
+    pub fn unwind_tip(&mut self, block_hash: &bitcoin::BlockHash) {
         // this means we might have lost control of coins at least temporarily
         let lost_coins = self
             .proofs
@@ -280,7 +279,7 @@ impl Coins {
         block_height: H,
     ) -> Vec<(OutPoint, Coin, u32)>
     where
-        H: Fn(&sha256d::Hash) -> Option<u32>,
+        H: Fn(&bitcoin::BlockHash) -> Option<u32>,
     {
         use rand::prelude::SliceRandom;
         // TODO: knapsack
@@ -326,17 +325,16 @@ mod test {
     use bitcoin::blockdata::script::Builder;
     use bitcoin::util::bip32::ExtendedPubKey;
     use bitcoin::{
-        network::constants::Network, util::hash::MerkleRoot, Address, BitcoinHash, Block,
-        BlockHeader, OutPoint, Transaction, TxIn, TxOut,
+        network::constants::Network, Address, BitcoinHash, Block, BlockHeader, OutPoint,
+        Transaction, TxIn, TxOut,
     };
-    use bitcoin_hashes::sha256d;
 
     use account::{Account, AccountAddressType, MasterAccount, Unlocker};
     use coins::Coins;
 
     const NEW_COINS: u64 = 5000000000;
 
-    fn new_block(prev: &sha256d::Hash) -> Block {
+    fn new_block(prev: &bitcoin::BlockHash) -> Block {
         Block {
             header: BlockHeader {
                 version: 1,
@@ -347,7 +345,7 @@ mod test {
                 nonce: 0,
                 bits: 0x1d00ffff,
                 prev_blockhash: prev.clone(),
-                merkle_root: sha256d::Hash::default(),
+                merkle_root: bitcoin::TxMerkleNode::default(),
             },
             txdata: Vec::new(),
         }
@@ -361,7 +359,7 @@ mod test {
                 sequence: 0xffffffff,
                 witness: Vec::new(),
                 previous_output: OutPoint {
-                    txid: sha256d::Hash::default(),
+                    txid: bitcoin::Txid::default(),
                     vout: 0,
                 },
                 script_sig: Builder::new().push_int(height as i64).into_script(),
@@ -390,7 +388,7 @@ mod test {
         master
     }
 
-    fn mine(tip: &sha256d::Hash, height: u32, miner: Address) -> Block {
+    fn mine(tip: &bitcoin::BlockHash, height: u32, miner: Address) -> Block {
         let mut block = new_block(tip);
         add_tx(&mut block, coin_base(miner, height));
         block

src/context.rs

@@ -16,12 +16,12 @@
 //!
 //! # Key derivation
 //!
+use bitcoin::secp256k1::{All, Message, Secp256k1, Signature};
 use bitcoin::{
     network::constants::Network,
     util::bip32::{ChildNumber, ExtendedPrivKey, ExtendedPubKey},
     PrivateKey, PublicKey,
 };
-use secp256k1::{All, Message, Secp256k1, Signature};
 
 use account::Seed;
 use error::Error;

src/error.rs

@@ -39,7 +39,7 @@ pub enum Error {
     /// key derivation error
     KeyDerivation(bip32::Error),
     /// sekp256k1 error
-    SecpError(secp256k1::Error),
+    SecpError(bitcoin::secp256k1::Error),
     /// cipher error
     SymmetricCipherError(symmetriccipher::SymmetricCipherError),
 }
@@ -135,8 +135,8 @@ impl convert::From<symmetriccipher::SymmetricCipherError> for Error {
     }
 }
 
-impl convert::From<secp256k1::Error> for Error {
-    fn from(err: secp256k1::Error) -> Error {
+impl convert::From<bitcoin::secp256k1::Error> for Error {
+    fn from(err: bitcoin::secp256k1::Error) -> Error {
         Error::SecpError(err)
     }
 }

src/lib.rs

@@ -22,12 +22,10 @@
 #![forbid(unsafe_code)]
 
 extern crate bitcoin;
-extern crate bitcoin_hashes;
 extern crate crypto;
 #[cfg(test)]
 extern crate hex;
 extern crate rand;
-extern crate secp256k1;
 extern crate serde;
 #[macro_use]
 extern crate serde_derive;

src/mnemonic.rs

@@ -18,24 +18,29 @@
 //!
 //! TREZOR compatible mnemonic in english
 //!
+use account::{MasterKeyEntropy, Seed};
 use bitcoin::util::bip158::{BitStreamReader, BitStreamWriter};
-use account::{Seed, MasterKeyEntropy};
 use crypto::{
     digest::Digest,
     hmac::Hmac,
     pbkdf2::pbkdf2,
     sha2::{Sha256, Sha512},
 };
 use error::Error;
-use std::io::Cursor;
 use rand::{thread_rng, RngCore};
+use std::io::Cursor;
 
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub struct Mnemonic(Vec<usize>);
 
 impl ToString for Mnemonic {
     fn to_string(&self) -> String {
-        self.0.iter().map(|i| WORDS[*i]).collect::<Vec<_>>().as_slice().join(" ")
+        self.0
+            .iter()
+            .map(|i| WORDS[*i])
+            .collect::<Vec<_>>()
+            .as_slice()
+            .join(" ")
     }
 }
 
@@ -74,7 +79,7 @@ impl Mnemonic {
         }
         writer.flush().unwrap();
         let l = data.len();
-        let (payload, checksum) = data.split_at(l - if l > 33 {2} else {1});
+        let (payload, checksum) = data.split_at(l - if l > 33 { 2 } else { 1 });
         if Self::checksum(payload).as_slice() != checksum {
             return Err(Error::Mnemonic("Checksum failed"));
         }
@@ -86,9 +91,9 @@ impl Mnemonic {
         let len = match entropy {
             MasterKeyEntropy::Sufficient => 16,
             MasterKeyEntropy::Double => 32,
-            MasterKeyEntropy::Paranoid => 64
+            MasterKeyEntropy::Paranoid => 64,
         };
-        let mut random = vec!(0u8; len);
+        let mut random = vec![0u8; len];
         thread_rng().fill_bytes(random.as_mut_slice());
         Self::new(random.as_slice())
     }
@@ -112,7 +117,7 @@ impl Mnemonic {
         Ok(Mnemonic(mnemonic))
     }
 
-    pub fn extend (&self) -> Result<Mnemonic, Error> {
+    pub fn extend(&self) -> Result<Mnemonic, Error> {
         if self.0.len() != 12 {
             return Err(Error::Mnemonic(
                 "Can only extend mnemonic of 12 words to 24 words",
@@ -148,7 +153,7 @@ impl Mnemonic {
         sha2.result(&mut hash);
         let mut check_cursor = Cursor::new(&hash);
         let mut check_reader = BitStreamReader::new(&mut check_cursor);
-        for _ in 0..data.len()/4 {
+        for _ in 0..data.len() / 4 {
             writer.write(check_reader.read(1).unwrap(), 1).unwrap();
         }
         writer.flush().unwrap();
@@ -224,7 +229,11 @@ mod test {
         let short = Mnemonic::new_random(MasterKeyEntropy::Sufficient).unwrap();
         let extended = short.extend().unwrap();
         let check = Mnemonic::from_str(extended.to_string().as_str()).unwrap();
-        assert!(short.iter().zip(check.iter()).take(12).all(|(a, b)| *a == *b));
+        assert!(short
+            .iter()
+            .zip(check.iter())
+            .take(12)
+            .all(|(a, b)| *a == *b));
     }
 }
 

src/proved.rs

@@ -18,15 +18,15 @@
 //!
 //!
 
+use bitcoin::hashes::{sha256d, Hash, HashEngine};
 use bitcoin::{BitcoinHash, Block, Transaction};
-use bitcoin_hashes::{sha256d, Hash, HashEngine};
 
 /// A confirmed transaction with its SPV proof
 #[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
 pub struct ProvedTransaction {
     transaction: Transaction,
     merkle_path: Vec<(bool, sha256d::Hash)>,
-    block_hash: sha256d::Hash,
+    block_hash: bitcoin::BlockHash,
 }
 
 impl ProvedTransaction {
@@ -43,25 +43,26 @@ impl ProvedTransaction {
         self.transaction.clone()
     }
 
-    pub fn get_block_hash(&self) -> &sha256d::Hash {
+    pub fn get_block_hash(&self) -> &bitcoin::BlockHash {
         &self.block_hash
     }
 
     /// compute the merkle root implied by the SPV proof
-    pub fn merkle_root(&self) -> sha256d::Hash {
-        self.merkle_path
-            .iter()
-            .fold(self.transaction.txid(), |a, (left, h)| {
-                let mut engine = sha256d::Hash::engine();
+    pub fn merkle_root(&self) -> bitcoin::TxMerkleNode {
+        self.merkle_path.iter().fold(
+            bitcoin::TxMerkleNode::from_inner(self.transaction.txid().into_inner()),
+            |a, (left, h)| {
+                let mut encoder = bitcoin::TxMerkleNode::engine();
                 if *left {
-                    engine.input(&h[..]);
-                    engine.input(&a[..]);
+                    encoder.input(&h[..]);
+                    encoder.input(&a[..]);
                 } else {
-                    engine.input(&a[..]);
-                    engine.input(&h[..]);
+                    encoder.input(&a[..]);
+                    encoder.input(&h[..]);
                 }
-                sha256d::Hash::from_engine(engine)
-            })
+                bitcoin::TxMerkleNode::from_engine(encoder)
+            },
+        )
     }
 
     /// compute a proof for a transaction in a block
@@ -102,7 +103,11 @@ impl ProvedTransaction {
             (result, op)
         }
 
-        let mut ids = block.txdata.iter().map(|t| t.txid()).collect::<Vec<_>>();
+        let mut ids = block
+            .txdata
+            .iter()
+            .map(|t| t.txid().as_hash())
+            .collect::<Vec<_>>();
         let mut proof = Vec::new();
         while let (i, Some((t, left, hash))) = binhash(ids.as_slice(), track) {
             proof.push((left, hash));