Implement KeysInterface for KeysManager util

Author: Antoine Riard

src/ln/keysinterface.rs

@@ -7,12 +7,20 @@
 //!
 
 use bitcoin::blockdata::transaction::OutPoint;
-use bitcoin::blockdata::script::Script;
+use bitcoin::blockdata::script::{Script, Builder};
+use bitcoin::blockdata::opcodes;
+use bitcoin::network::constants::Network;
+use bitcoin::util::bip32::{ExtendedPrivKey, ExtendedPubKey, ChildNumber};
 
-use secp256k1::key::SecretKey;
+use secp256k1::key::{SecretKey, PublicKey};
+use secp256k1::Secp256k1;
+use secp256k1;
 
 use ln::channel::ChannelKeys;
 use util::events;
+use util::logger::Logger;
+
+use std::sync::Arc;
 
 /// A trait to describe a wallet which sould receive data to be able to spend onchain outputs
 /// fron a lightning channel
@@ -87,3 +95,92 @@ pub trait KeysInterface: Send + Sync {
 	/// For Channel N, keys correspond to ChannelKeys::new_from_seed(/3/N')
 	fn get_channel_keys(&mut self) -> Option<ChannelKeys>;
 }
+
+/// Utility for storing/deriving lightning keys materials
+pub struct KeysManager {
+	network: Network,
+	secp_ctx: Secp256k1<secp256k1::All>,
+	master_key: Option<SecretKey>,
+	node_secret: Option<SecretKey>,
+	destination_script: Option<Script>,
+	shutdown_pubkey: Option<PublicKey>,
+	channel_master_seed: Option<ExtendedPrivKey>,
+	current_channel_index: u32,
+
+	logger: Arc<Logger>,
+}
+
+impl KeysManager {
+	/// Constructs and empty KeysManager
+	pub fn new(network: Network, logger: Arc<Logger>) -> KeysManager {
+		KeysManager {
+			network,
+			secp_ctx: Secp256k1::new(),
+			master_key: None,
+			node_secret: None,
+			destination_script: None,
+			shutdown_pubkey: None,
+			channel_master_seed: None,
+			current_channel_index: 0,
+
+			logger,
+		}
+	}
+}
+
+impl KeysInterface for KeysManager {
+	fn provide_master_seed(&mut self, seed: &[u8; 32]) {
+		self.master_key = match ExtendedPrivKey::new_master(&self.secp_ctx, self.network.clone(), seed) {
+			Ok(master_key) => {
+				self.node_secret = match master_key.ckd_priv(&self.secp_ctx, ChildNumber::from_hardened_idx(0)) {
+					Ok(node_secret) => Some(node_secret.secret_key),
+					Err(_) => None,
+				};
+				self.destination_script = match master_key.ckd_priv(&self.secp_ctx, ChildNumber::from_hardened_idx(1)) {
+					Ok(destination_key) => Some(Builder::new().push_slice(&ExtendedPubKey::from_private(&self.secp_ctx, &destination_key).public_key.serialize()[..])
+									             .push_opcode(opcodes::All::OP_CHECKSIG)
+									             .into_script()),
+					Err(_) => None,
+				};
+				self.shutdown_pubkey = match master_key.ckd_priv(&self.secp_ctx, ChildNumber::from_hardened_idx(2)) {
+					Ok(shutdown_key) => Some(ExtendedPubKey::from_private(&self.secp_ctx, &shutdown_key).public_key),
+					Err(_) => None,
+				};
+				self.channel_master_seed = match master_key.ckd_priv(&self.secp_ctx, ChildNumber::from_hardened_idx(3)) {
+					Ok(channel_master_key) => Some(channel_master_key),
+					Err(_) => None,
+				};
+				Some(master_key.secret_key)
+			},
+			Err(_) => None,
+		};
+	}
+
+	fn get_node_secret(&self) -> Option<SecretKey> {
+		self.node_secret.clone()
+	}
+
+	fn get_destination_script(&self) -> Option<Script> {
+		self.destination_script.clone()
+	}
+
+	fn get_shutdown_pubkey(&self) -> Option<PublicKey> {
+		self.shutdown_pubkey.clone()
+	}
+
+	fn get_channel_keys(&mut self) -> Option<ChannelKeys> {
+		if let &Some(channel_master_key) = &self.channel_master_seed {
+			if let Ok(channel_key) = channel_master_key.ckd_priv(&self.secp_ctx, ChildNumber::Hardened { index: self.current_channel_index }) {
+				let channel_pubkey = ExtendedPubKey::from_private(&self.secp_ctx, &channel_key);
+				let mut seed = [0; 32];
+				for (arr, slice) in seed.iter_mut().zip((&channel_pubkey.public_key.serialize()[0..32]).iter()) {
+					*arr = *slice;
+				}
+				if let Ok(channel_keys) = ChannelKeys::new_from_seed(&seed) {
+					return Some(channel_keys);
+				}
+			}
+		}
+		None
+	}
+}