Merge pull request #19 from stevenroose/no-hex

Clean up dependencies a bit

Author: stevenroose

Cargo.toml

@@ -10,14 +10,17 @@ description = "Wallet library for Bitcoin"
 keywords = [ "crypto", "bitcoin" ]
 readme = "README.md"
 
+[features]
+use-serde = ["serde", "bitcoin/use-serde"]
+
 [dependencies]
-bitcoin = { version= "0.23", features=["use-serde"]}
-rand="0.7"
+bitcoin = "0.26"
+rand = "0.7"
 rust-crypto = "0.2"
-serde = "1"
-serde_derive = "1"
+
+serde = { version = "1", optional = true, features = ["derive"] }
 
 [dev-dependencies]
-bitcoin = { version= "0.23", features=["use-serde", "bitcoinconsensus"]}
-serde_json="1"
-hex = "0.3"
+bitcoin = { version = "0.26", features = ["use-serde", "bitcoinconsensus"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"

src/account.rs

@@ -307,6 +307,7 @@ impl Unlocker {
             Network::Bitcoin => 0,
             Network::Testnet => 1,
             Network::Regtest => 1,
+            Network::Signet => 1,
         };
         let by_coin_type = by_purpose.1.entry(coin_type).or_insert((
             self.context
@@ -641,8 +642,9 @@ impl Account {
         R: Fn(&OutPoint) -> Option<TxOut>,
     {
         let mut signed = 0;
+        //TODO(stevenroose) try to prevent this clone here
         let txclone = transaction.clone();
-        let mut bip143hasher: Option<bip143::SighashComponents> = None;
+        let mut bip143hasher = bip143::SigHashCache::new(&txclone);
         for (ix, input) in transaction.input.iter_mut().enumerate() {
             if let Some(spend) = resolver(&input.previous_output) {
                 if let Some((kix, instantiated)) = self
@@ -680,14 +682,12 @@ impl Account {
                                 return Err(Error::Unsupported("can only sign all inputs for now"));
                             }
                             input.script_sig = Script::new();
-                            let hasher =
-                                bip143hasher.unwrap_or(bip143::SighashComponents::new(&txclone));
-                            let sighash = hasher.sighash_all(
-                                &txclone.input[ix],
+                            let sighash = bip143hasher.signature_hash(
+                                ix,
                                 &instantiated.script_code,
                                 spend.value,
+                                hash_type,
                             );
-                            bip143hasher = Some(hasher);
                             let signature = self.context.sign(&sighash[..], &pk)?.serialize_der();
                             let mut with_hashtype = signature.to_vec();
                             with_hashtype.push(hash_type.as_u32() as u8);
@@ -712,14 +712,12 @@ impl Account {
                                         .into_script()[..],
                                 )
                                 .into_script();
-                            let hasher =
-                                bip143hasher.unwrap_or(bip143::SighashComponents::new(&txclone));
-                            let sighash = hasher.sighash_all(
-                                &txclone.input[ix],
+                            let sighash = bip143hasher.signature_hash(
+                                ix,
                                 &instantiated.script_code,
                                 spend.value,
+                                hash_type,
                             );
-                            bip143hasher = Some(hasher);
                             let signature = self.context.sign(&sighash[..], &pk)?.serialize_der();
                             let mut with_hashtype = signature.to_vec();
                             with_hashtype.push(hash_type.as_u32() as u8);
@@ -733,14 +731,12 @@ impl Account {
                                 return Err(Error::Unsupported("can only sign all inputs for now"));
                             }
                             input.script_sig = Script::new();
-                            let hasher =
-                                bip143hasher.unwrap_or(bip143::SighashComponents::new(&txclone));
-                            let sighash = hasher.sighash_all(
-                                &txclone.input[ix],
+                            let sighash = bip143hasher.signature_hash(
+                                ix,
                                 &instantiated.script_code,
                                 spend.value,
+                                hash_type,
                             );
-                            bip143hasher = Some(hasher);
                             let signature = self.context.sign(&sighash[..], &pk)?.serialize_der();
                             let mut with_hashtype = signature.to_vec();
                             with_hashtype.push(hash_type.as_u32() as u8);
@@ -758,7 +754,8 @@ impl Account {
 }
 
 /// instantiated key of an account
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct InstantiatedKey {
     pub public: PublicKey,
     pub script_code: Script,
@@ -788,10 +785,15 @@ impl InstantiatedKey {
             context.tweak_exp_add(&mut public, tweak)?;
         }
         let script_code = scripter(&public, csv);
+        assert!(public.compressed);
         let address = match address_type {
             AccountAddressType::P2PKH => Address::p2pkh(&public, network),
-            AccountAddressType::P2SHWPKH => Address::p2shwpkh(&public, network),
-            AccountAddressType::P2WPKH => Address::p2wpkh(&public, network),
+            AccountAddressType::P2SHWPKH => {
+                Address::p2shwpkh(&public, network).expect("compressed pubkey")
+            }
+            AccountAddressType::P2WPKH => {
+                Address::p2wpkh(&public, network).expect("compressed pubkey")
+            }
             AccountAddressType::P2WSH(_) => Address::p2wsh(&script_code, network),
         };
         Ok(InstantiatedKey {
@@ -880,12 +882,12 @@ mod test {
     use std::io::Read;
     use std::path::PathBuf;
 
+    use bitcoin::hashes::hex::FromHex;
     use bitcoin::blockdata::opcodes::all;
     use bitcoin::blockdata::script::Builder;
     use bitcoin::blockdata::transaction::{OutPoint, TxIn, TxOut};
     use bitcoin::network::constants::Network;
     use bitcoin::util::bip32::ChildNumber;
-    use hex::decode;
     use rand::Rng;
     use serde_json::Value;
 
@@ -1352,7 +1354,7 @@ mod test {
         let json: Value = serde_json::from_str(&data).unwrap();
         let tests = json.as_array().unwrap();
         for test in tests {
-            let seed = Seed(decode(test["seed"].as_str().unwrap()).unwrap());
+            let seed = Seed(Vec::<u8>::from_hex(test["seed"].as_str().unwrap()).unwrap());
             let master_private = context.master_private_key(Network::Bitcoin, &seed).unwrap();
             assert_eq!(
                 test["private"].as_str().unwrap(),

src/coins.rs

@@ -20,8 +20,7 @@
 
 use std::collections::HashMap;
 
-use bitcoin::Block;
-use bitcoin::{OutPoint, Script, Transaction, TxOut};
+use bitcoin::{Block, OutPoint, Script, Transaction, TxOut};
 use rand::thread_rng;
 
 use account::{KeyDerivation, MasterAccount};
@@ -321,11 +320,12 @@ mod test {
         time::{SystemTime, UNIX_EPOCH},
     };
 
+use bitcoin::hashes::hex::FromHex;
     use bitcoin::blockdata::constants::genesis_block;
     use bitcoin::blockdata::script::Builder;
     use bitcoin::util::bip32::ExtendedPubKey;
     use bitcoin::{
-        network::constants::Network, Address, BitcoinHash, Block, BlockHeader, OutPoint,
+        network::constants::Network, Address, Block, BlockHeader, OutPoint,
         Transaction, TxIn, TxOut,
     };
 
@@ -378,7 +378,7 @@ mod test {
 
     fn new_master() -> MasterAccount {
         let mut master = MasterAccount::from_encrypted(
-            hex::decode("e541bc73d9990b290cc4a8d8ff4592183171d1808a32695b1835aa3c12f50f34849a0dc5b730c507f19f22af393b5e5453e0974977922dbba513dadf81d364d8e204209ea02af35693b49b3b09191f01").unwrap().as_slice(),
+            Vec::<u8>::from_hex("e541bc73d9990b290cc4a8d8ff4592183171d1808a32695b1835aa3c12f50f34849a0dc5b730c507f19f22af393b5e5453e0974977922dbba513dadf81d364d8e204209ea02af35693b49b3b09191f01").unwrap().as_slice(),
             ExtendedPubKey::from_str("tpubD6NzVbkrYhZ4YUqaTmpewwbvSoA4dkwzGzvwGcUbwbRyu8i6dCSroCsvFmC6qzQgJxddMfA6Mg8r6XmkJVhQ8ihAWzfRBYTG5o28AC5HWX2").unwrap(),
             1567260002);
         let mut unlocker = Unlocker::new_for_master(&master, "whatever").unwrap();
@@ -406,10 +406,10 @@ mod test {
             .address
             .clone();
         let genesis = genesis_block(Network::Testnet);
-        let next = mine(&genesis.bitcoin_hash(), 1, miner);
+        let next = mine(&genesis.block_hash(), 1, miner);
         coins.process(&mut master, &next);
         assert_eq!(coins.confirmed_balance(), NEW_COINS);
-        coins.unwind_tip(&next.bitcoin_hash());
+        coins.unwind_tip(&next.block_hash());
         assert_eq!(coins.confirmed_balance(), 0);
     }
 }

src/lib.rs

@@ -21,14 +21,14 @@
 #![deny(unused_must_use)]
 #![forbid(unsafe_code)]
 
-extern crate bitcoin;
-extern crate crypto;
-#[cfg(test)]
-extern crate hex;
+pub extern crate bitcoin;
+pub extern crate crypto;
 extern crate rand;
-extern crate serde;
+
+#[cfg(feature = "serde")]
 #[macro_use]
-extern crate serde_derive;
+extern crate serde;
+
 #[cfg(test)]
 extern crate serde_json;
 

src/mnemonic.rs

@@ -167,8 +167,8 @@ mod test {
     use std::io::Read;
     use std::path::PathBuf;
 
+    use bitcoin::hashes::hex::FromHex;
     use bitcoin::network::constants::Network;
-    use hex::decode;
     use serde_json::Value;
 
     use context::SecpContext;
@@ -191,15 +191,15 @@ mod test {
 
         for t in 0..tests.len() {
             let values = tests[t].as_array().unwrap();
-            let data = decode(values[0].as_str().unwrap()).unwrap();
+            let data = Vec::<u8>::from_hex(values[0].as_str().unwrap()).unwrap();
             let m = values[1].as_str().unwrap();
             let mnemonic = Mnemonic::from_str(m).unwrap();
             let seed = mnemonic.to_seed(Some("TREZOR"));
             assert_eq!(
                 mnemonic.to_string(),
                 Mnemonic::new(data.as_slice()).unwrap().to_string()
             );
-            assert_eq!(seed.0, decode(values[2].as_str().unwrap()).unwrap());
+            assert_eq!(seed.0, Vec::<u8>::from_hex(values[2].as_str().unwrap()).unwrap());
 
             if values.len() == 4 {
                 let pk = values[3].as_str().unwrap();

src/proved.rs

@@ -678,6 +678,7 @@ mod test {
     use std::collections::HashSet;
     use std::str::FromStr;
 
+    use bitcoin::hashes::hex::ToHex;
     use bitcoin::network::constants::Network;
     use bitcoin::Address;
     use rand::{thread_rng, Rng};
@@ -822,13 +823,8 @@ mod test {
                     .iter()
                     .map(|v| Share::from_mnemonic(v.as_str().unwrap()).unwrap())
                     .collect::<Vec<_>>();
-                assert_eq!(
-                    result,
-                    hex::encode(
-                        ShamirSecretSharing::combine(&shares, Some("TREZOR"))
-                            .unwrap()
-                            .0
-                    )
+                assert_eq!(result,
+                    ShamirSecretSharing::combine(&shares, Some("TREZOR")).unwrap().0.to_hex(),
                 );
             }
         }