Refactor the Keychain to be based on a trait (#1146)

* First pass at restructuring the keychain crate and introducing a Keychain trait
* Parameterized everything that had to. Stuff compiles.
* More stuff compiles, fix most tests
* Big merge, pushing down opening the keychain forced adding factory methods on trait
* Test fixes for pool and servers crate

core/src/core/transaction.rs

@@ -14,8 +14,8 @@
 
 //! Transactions
 
-use std::cmp::max;
 use std::cmp::Ordering;
+use std::cmp::max;
 use std::collections::HashSet;
 use std::io::Cursor;
 use std::{error, fmt};
@@ -26,12 +26,12 @@ use util::{kernel_sig_msg, static_secp_instance};
 
 use consensus;
 use consensus::VerifySortOrder;
+use core::BlockHeader;
 use core::committed;
 use core::committed::Committed;
 use core::global;
 use core::hash::{Hash, Hashed, ZERO_HASH};
 use core::pmmr::MerkleProof;
-use core::BlockHeader;
 use keychain;
 use keychain::BlindingFactor;
 use ser::{self, read_and_verify_sorted, ser_vec, PMMRable, Readable, Reader, Writeable,
@@ -1074,12 +1074,12 @@ impl ProofMessageElements {
 mod test {
 	use super::*;
 	use core::id::{ShortId, ShortIdentifiable};
-	use keychain::Keychain;
+	use keychain::{ExtKeychain, Keychain};
 	use util::secp;
 
 	#[test]
 	fn test_kernel_ser_deser() {
-		let keychain = Keychain::from_random_seed().unwrap();
+		let keychain = ExtKeychain::from_random_seed().unwrap();
 		let key_id = keychain.derive_key_id(1).unwrap();
 		let commit = keychain.commit(5, &key_id).unwrap();
 
@@ -1124,7 +1124,7 @@ mod test {
 
 	#[test]
 	fn commit_consistency() {
-		let keychain = Keychain::from_seed(&[0; 32]).unwrap();
+		let keychain = ExtKeychain::from_seed(&[0; 32]).unwrap();
 		let key_id = keychain.derive_key_id(1).unwrap();
 
 		let commit = keychain.commit(1003, &key_id).unwrap();
@@ -1137,7 +1137,7 @@ mod test {
 
 	#[test]
 	fn input_short_id() {
-		let keychain = Keychain::from_seed(&[0; 32]).unwrap();
+		let keychain = ExtKeychain::from_seed(&[0; 32]).unwrap();
 		let key_id = keychain.derive_key_id(1).unwrap();
 		let commit = keychain.commit(5, &key_id).unwrap();
 

core/tests/block.rs

@@ -21,14 +21,14 @@ pub mod common;
 
 use common::{new_block, tx1i2o, tx2i1o, txspend1i1o};
 use grin_core::consensus::{BLOCK_OUTPUT_WEIGHT, MAX_BLOCK_WEIGHT};
+use grin_core::core::Committed;
 use grin_core::core::block::Error;
 use grin_core::core::hash::Hashed;
 use grin_core::core::id::{ShortId, ShortIdentifiable};
-use grin_core::core::Committed;
 use grin_core::core::{Block, BlockHeader, CompactBlock, KernelFeatures, OutputFeatures};
 use grin_core::global;
 use grin_core::ser;
-use keychain::Keychain;
+use keychain::{ExtKeychain, Keychain};
 use std::time::Instant;
 use wallet::libtx::build::{self, input, output, with_fee};
 
@@ -38,7 +38,7 @@ use util::{secp, secp_static};
 // TODO: make this fast enough or add similar but faster test?
 #[allow(dead_code)]
 fn too_large_block() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let max_out = MAX_BLOCK_WEIGHT / BLOCK_OUTPUT_WEIGHT;
 
 	let zero_commit = secp_static::commit_to_zero_value();
@@ -84,7 +84,7 @@ fn very_empty_block() {
 #[test]
 // builds a block with a tx spending another and check that cut_through occurred
 fn block_with_cut_through() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let key_id1 = keychain.derive_key_id(1).unwrap();
 	let key_id2 = keychain.derive_key_id(2).unwrap();
 	let key_id3 = keychain.derive_key_id(3).unwrap();
@@ -118,7 +118,7 @@ fn block_with_cut_through() {
 
 #[test]
 fn empty_block_with_coinbase_is_valid() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let zero_commit = secp_static::commit_to_zero_value();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
@@ -152,7 +152,7 @@ fn empty_block_with_coinbase_is_valid() {
 // invalidates the block and specifically it causes verify_coinbase to fail
 // additionally verifying the merkle_inputs_outputs also fails
 fn remove_coinbase_output_flag() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let zero_commit = secp_static::commit_to_zero_value();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
@@ -184,7 +184,7 @@ fn remove_coinbase_output_flag() {
 // test that flipping the COINBASE_KERNEL flag on the kernel features
 // invalidates the block and specifically it causes verify_coinbase to fail
 fn remove_coinbase_kernel_flag() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let zero_commit = secp_static::commit_to_zero_value();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
@@ -212,7 +212,7 @@ fn remove_coinbase_kernel_flag() {
 
 #[test]
 fn serialize_deserialize_block() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
 	let b = new_block(vec![], &keychain, &prev, &key_id);
@@ -229,7 +229,7 @@ fn serialize_deserialize_block() {
 
 #[test]
 fn empty_block_serialized_size() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
 	let b = new_block(vec![], &keychain, &prev, &key_id);
@@ -241,7 +241,7 @@ fn empty_block_serialized_size() {
 
 #[test]
 fn block_single_tx_serialized_size() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let tx1 = tx1i2o();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
@@ -254,7 +254,7 @@ fn block_single_tx_serialized_size() {
 
 #[test]
 fn empty_compact_block_serialized_size() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
 	let b = new_block(vec![], &keychain, &prev, &key_id);
@@ -266,7 +266,7 @@ fn empty_compact_block_serialized_size() {
 
 #[test]
 fn compact_block_single_tx_serialized_size() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let tx1 = tx1i2o();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
@@ -279,7 +279,7 @@ fn compact_block_single_tx_serialized_size() {
 
 #[test]
 fn block_10_tx_serialized_size() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	global::set_mining_mode(global::ChainTypes::Mainnet);
 
 	let mut txs = vec![];
@@ -298,7 +298,7 @@ fn block_10_tx_serialized_size() {
 
 #[test]
 fn compact_block_10_tx_serialized_size() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 
 	let mut txs = vec![];
 	for _ in 0..10 {
@@ -316,7 +316,7 @@ fn compact_block_10_tx_serialized_size() {
 
 #[test]
 fn compact_block_hash_with_nonce() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let tx = tx1i2o();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
@@ -346,7 +346,7 @@ fn compact_block_hash_with_nonce() {
 
 #[test]
 fn convert_block_to_compact_block() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let tx1 = tx1i2o();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
@@ -369,7 +369,7 @@ fn convert_block_to_compact_block() {
 
 #[test]
 fn hydrate_empty_compact_block() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let prev = BlockHeader::default();
 	let key_id = keychain.derive_key_id(1).unwrap();
 	let b = new_block(vec![], &keychain, &prev, &key_id);

core/tests/common/mod.rs

@@ -19,16 +19,16 @@ extern crate grin_keychain as keychain;
 extern crate grin_util as util;
 extern crate grin_wallet as wallet;
 
+use grin_core::core::Transaction;
 use grin_core::core::block::{Block, BlockHeader};
 use grin_core::core::target::Difficulty;
-use grin_core::core::Transaction;
 use keychain::{Identifier, Keychain};
 use wallet::libtx::build::{self, input, output, with_fee};
 use wallet::libtx::reward;
 
 // utility producing a transaction with 2 inputs and a single outputs
 pub fn tx2i1o() -> Transaction {
-	let keychain = keychain::Keychain::from_random_seed().unwrap();
+	let keychain = keychain::ExtKeychain::from_random_seed().unwrap();
 	let key_id1 = keychain.derive_key_id(1).unwrap();
 	let key_id2 = keychain.derive_key_id(2).unwrap();
 	let key_id3 = keychain.derive_key_id(3).unwrap();
@@ -46,7 +46,7 @@ pub fn tx2i1o() -> Transaction {
 
 // utility producing a transaction with a single input and output
 pub fn tx1i1o() -> Transaction {
-	let keychain = keychain::Keychain::from_random_seed().unwrap();
+	let keychain = keychain::ExtKeychain::from_random_seed().unwrap();
 	let key_id1 = keychain.derive_key_id(1).unwrap();
 	let key_id2 = keychain.derive_key_id(2).unwrap();
 
@@ -60,7 +60,7 @@ pub fn tx1i1o() -> Transaction {
 // and two outputs (one change output)
 // Note: this tx has an "offset" kernel
 pub fn tx1i2o() -> Transaction {
-	let keychain = keychain::Keychain::from_random_seed().unwrap();
+	let keychain = keychain::ExtKeychain::from_random_seed().unwrap();
 	let key_id1 = keychain.derive_key_id(1).unwrap();
 	let key_id2 = keychain.derive_key_id(2).unwrap();
 	let key_id3 = keychain.derive_key_id(3).unwrap();
@@ -78,12 +78,15 @@ pub fn tx1i2o() -> Transaction {
 
 // utility to create a block without worrying about the key or previous
 // header
-pub fn new_block(
+pub fn new_block<K>(
 	txs: Vec<&Transaction>,
-	keychain: &Keychain,
+	keychain: &K,
 	previous_header: &BlockHeader,
 	key_id: &Identifier,
-) -> Block {
+) -> Block
+where
+	K: Keychain,
+{
 	let fees = txs.iter().map(|tx| tx.fee()).sum();
 	let reward_output = reward::output(keychain, &key_id, fees, previous_header.height).unwrap();
 	Block::new(
@@ -96,14 +99,12 @@ pub fn new_block(
 
 // utility producing a transaction that spends an output with the provided
 // value and blinding key
-pub fn txspend1i1o(
-	v: u64,
-	keychain: &Keychain,
-	key_id1: Identifier,
-	key_id2: Identifier,
-) -> Transaction {
+pub fn txspend1i1o<K>(v: u64, keychain: &K, key_id1: Identifier, key_id2: Identifier) -> Transaction
+where
+	K: Keychain,
+{
 	build::transaction(
 		vec![input(v, key_id1), output(3, key_id2), with_fee(2)],
-		&keychain,
+		keychain,
 	).unwrap()
 }

core/tests/core.rs

@@ -26,7 +26,7 @@ use grin_core::core::block::Error::KernelLockHeight;
 use grin_core::core::hash::{Hashed, ZERO_HASH};
 use grin_core::core::{aggregate, deaggregate, KernelFeatures, Output, Transaction};
 use grin_core::ser;
-use keychain::Keychain;
+use keychain::{ExtKeychain, Keychain};
 use util::{secp_static, static_secp_instance};
 use wallet::libtx::build::{self, initial_tx, input, output, with_excess, with_fee,
                            with_lock_height};
@@ -72,7 +72,7 @@ fn tx_double_ser_deser() {
 #[test]
 #[should_panic(expected = "InvalidSecretKey")]
 fn test_zero_commit_fails() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let key_id1 = keychain.derive_key_id(1).unwrap();
 
 	// blinding should fail as signing with a zero r*G shouldn't work
@@ -88,7 +88,7 @@ fn test_zero_commit_fails() {
 
 #[test]
 fn build_tx_kernel() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let key_id1 = keychain.derive_key_id(1).unwrap();
 	let key_id2 = keychain.derive_key_id(2).unwrap();
 	let key_id3 = keychain.derive_key_id(3).unwrap();
@@ -295,7 +295,7 @@ fn basic_transaction_deaggregation() {
 
 #[test]
 fn hash_output() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let key_id1 = keychain.derive_key_id(1).unwrap();
 	let key_id2 = keychain.derive_key_id(2).unwrap();
 	let key_id3 = keychain.derive_key_id(3).unwrap();
@@ -349,7 +349,7 @@ fn tx_hash_diff() {
 /// 2 inputs, 2 outputs transaction.
 #[test]
 fn tx_build_exchange() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let key_id1 = keychain.derive_key_id(1).unwrap();
 	let key_id2 = keychain.derive_key_id(2).unwrap();
 	let key_id3 = keychain.derive_key_id(3).unwrap();
@@ -386,7 +386,7 @@ fn tx_build_exchange() {
 
 #[test]
 fn reward_empty_block() {
-	let keychain = keychain::Keychain::from_random_seed().unwrap();
+	let keychain = keychain::ExtKeychain::from_random_seed().unwrap();
 	let key_id = keychain.derive_key_id(1).unwrap();
 
 	let zero_commit = secp_static::commit_to_zero_value();
@@ -402,7 +402,7 @@ fn reward_empty_block() {
 
 #[test]
 fn reward_with_tx_block() {
-	let keychain = keychain::Keychain::from_random_seed().unwrap();
+	let keychain = keychain::ExtKeychain::from_random_seed().unwrap();
 	let key_id = keychain.derive_key_id(1).unwrap();
 
 	let zero_commit = secp_static::commit_to_zero_value();
@@ -421,7 +421,7 @@ fn reward_with_tx_block() {
 
 #[test]
 fn simple_block() {
-	let keychain = keychain::Keychain::from_random_seed().unwrap();
+	let keychain = keychain::ExtKeychain::from_random_seed().unwrap();
 	let key_id = keychain.derive_key_id(1).unwrap();
 
 	let zero_commit = secp_static::commit_to_zero_value();
@@ -442,7 +442,7 @@ fn simple_block() {
 
 #[test]
 fn test_block_with_timelocked_tx() {
-	let keychain = keychain::Keychain::from_random_seed().unwrap();
+	let keychain = keychain::ExtKeychain::from_random_seed().unwrap();
 
 	let key_id1 = keychain.derive_key_id(1).unwrap();
 	let key_id2 = keychain.derive_key_id(2).unwrap();

core/tests/transaction.rs

@@ -22,13 +22,13 @@ pub mod common;
 
 use grin_core::core::{Output, OutputFeatures};
 use grin_core::ser;
-use keychain::Keychain;
+use keychain::{ExtKeychain, Keychain};
 use util::secp;
 use wallet::libtx::proof;
 
 #[test]
 fn test_output_ser_deser() {
-	let keychain = Keychain::from_random_seed().unwrap();
+	let keychain = ExtKeychain::from_random_seed().unwrap();
 	let key_id = keychain.derive_key_id(1).unwrap();
 	let commit = keychain.commit(5, &key_id).unwrap();
 	let msg = secp::pedersen::ProofMessage::empty();