Add generation of SpendableOutputDescriptor in closing_signed

Aims to send back closing output descritpor to user wallet

Add get_vout_my_output in transaction_utils

Author: Antoine Riard

src/ln/channel.rs

@@ -1,6 +1,7 @@
 use bitcoin::blockdata::block::BlockHeader;
 use bitcoin::blockdata::script::{Script,Builder};
 use bitcoin::blockdata::transaction::{TxIn, TxOut, Transaction, SigHashType};
+use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint;
 use bitcoin::blockdata::opcodes;
 use bitcoin::util::hash::{BitcoinHash, Sha256dHash, Hash160};
 use bitcoin::util::bip143;
@@ -20,7 +21,7 @@ use ln::chan_utils::{TxCreationKeys,HTLCOutputInCommitment,HTLC_SUCCESS_TX_WEIGH
 use ln::chan_utils;
 use chain::chaininterface::{FeeEstimator,ConfirmationTarget};
 use chain::transaction::OutPoint;
-use chain::keysinterface::{ChannelKeys, KeysInterface};
+use chain::keysinterface::{ChannelKeys, KeysInterface, SpendableOutputDescriptor};
 use util::{transaction_utils,rng};
 use util::ser::{Readable, ReadableArgs, Writeable, Writer, WriterWriteAdaptor};
 use util::sha2::Sha256;
@@ -2496,7 +2497,7 @@ impl Channel {
 		Ok((our_shutdown, self.maybe_propose_first_closing_signed(fee_estimator), dropped_outbound_htlcs))
 	}
 
-	pub fn closing_signed(&mut self, fee_estimator: &FeeEstimator, msg: &msgs::ClosingSigned) -> Result<(Option<msgs::ClosingSigned>, Option<Transaction>), HandleError> {
+	pub fn closing_signed(&mut self, fee_estimator: &FeeEstimator, msg: &msgs::ClosingSigned) -> Result<(Option<msgs::ClosingSigned>, Option<SpendableOutputDescriptor>, Option<Transaction>), HandleError> {
 		if self.channel_state & BOTH_SIDES_SHUTDOWN_MASK != BOTH_SIDES_SHUTDOWN_MASK {
 			return Err(HandleError{err: "Remote end sent us a closing_signed before both sides provided a shutdown", action: None});
 		}
@@ -2517,6 +2518,8 @@ impl Channel {
 		}
 		let mut sighash = Message::from_slice(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap();
 
+		let our_output_idx = transaction_utils::get_vout_my_output(&closing_tx, self.get_closing_scriptpubkey());
+
 		match self.secp_ctx.verify(&sighash, &msg.signature, &self.their_funding_pubkey.unwrap()) {
 			Ok(_) => {},
 			Err(_e) => {
@@ -2533,7 +2536,10 @@ impl Channel {
 				self.sign_commitment_transaction(&mut closing_tx, &msg.signature);
 				self.channel_state = ChannelState::ShutdownComplete as u32;
 				self.channel_update_count += 1;
-				return Ok((None, Some(closing_tx)));
+				return Ok((None, if our_output_idx.is_some() { Some(SpendableOutputDescriptor::StaticOutput {
+					outpoint: BitcoinOutPoint { txid: closing_tx.txid(), vout: our_output_idx.unwrap() },
+					output: closing_tx.output[our_output_idx.unwrap() as usize].clone(),
+				})} else { None }, Some(closing_tx)));
 			}
 		}
 
@@ -2548,7 +2554,7 @@ impl Channel {
 					channel_id: self.channel_id,
 					fee_satoshis: used_total_fee,
 					signature: our_sig,
-				}), None))
+				}), None, None))
 			}
 		}
 
@@ -2583,7 +2589,10 @@ impl Channel {
 			channel_id: self.channel_id,
 			fee_satoshis: msg.fee_satoshis,
 			signature: our_sig,
-		}), Some(closing_tx)))
+		}), if our_output_idx.is_some() { Some(SpendableOutputDescriptor::StaticOutput {
+			outpoint: BitcoinOutPoint { txid: closing_tx.txid(), vout: our_output_idx.unwrap() },
+			output: closing_tx.output[our_output_idx.unwrap() as usize].clone(),
+		})} else { None }, Some(closing_tx)))
 	}
 
 	// Public utilities:

src/ln/channelmanager.rs

@@ -1873,6 +1873,7 @@ impl ChannelManager {
 	}
 
 	fn internal_closing_signed(&self, their_node_id: &PublicKey, msg: &msgs::ClosingSigned) -> Result<(), MsgHandleErrInternal> {
+		let mut spendable_output = Vec::with_capacity(1);
 		let (tx, chan_option) = {
 			let mut channel_state_lock = self.channel_state.lock().unwrap();
 			let channel_state = channel_state_lock.borrow_parts();
@@ -1882,13 +1883,16 @@ impl ChannelManager {
 						//TODO: here and below MsgHandleErrInternal, #153 case
 						return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!", msg.channel_id));
 					}
-					let (closing_signed, tx) = chan_entry.get_mut().closing_signed(&*self.fee_estimator, &msg).map_err(|e| MsgHandleErrInternal::from_maybe_close(e))?;
+					let (closing_signed, spendable_outp, tx) = chan_entry.get_mut().closing_signed(&*self.fee_estimator, &msg).map_err(|e| MsgHandleErrInternal::from_maybe_close(e))?;
 					if let Some(msg) = closing_signed {
 						channel_state.pending_msg_events.push(events::MessageSendEvent::SendClosingSigned {
 							node_id: their_node_id.clone(),
 							msg,
 						});
 					}
+					if let Some(spendable_outp) = spendable_outp {
+						spendable_output.push(spendable_outp);
+					}
 					if tx.is_some() {
 						// We're done with this channel, we've got a signed closing transaction and
 						// will send the closing_signed back to the remote peer upon return. This
@@ -1904,6 +1908,9 @@ impl ChannelManager {
 				hash_map::Entry::Vacant(_) => return Err(MsgHandleErrInternal::send_err_msg_no_close("Failed to find corresponding channel", msg.channel_id))
 			}
 		};
+		if spendable_output.len() > 0 {
+			self.pending_events.lock().unwrap().push(events::Event::SpendableOutputs { outputs: spendable_output });
+		}
 		if let Some(broadcast_tx) = tx {
 			self.tx_broadcaster.broadcast_transaction(&broadcast_tx);
 		}
@@ -3672,6 +3679,23 @@ mod tests {
 		}
 	}
 
+	macro_rules! check_closing_output {
+		($node: expr) => {
+			let events = $node.get_and_clear_pending_events();
+			if events.len() > 0 {
+				match events[0] {
+					Event::SpendableOutputs { ref outputs } => {
+						match outputs[0] {
+							SpendableOutputDescriptor::StaticOutput { .. } => {},
+							_ => panic!("Unexpected event"),
+						}
+					}
+					_ => panic!("Unexpected event"),
+				}
+			}
+		}
+	}
+
 	fn close_channel(outbound_node: &Node, inbound_node: &Node, channel_id: &[u8; 32], funding_tx: Transaction, close_inbound_first: bool) -> (msgs::ChannelUpdate, msgs::ChannelUpdate) {
 		let (node_a, broadcaster_a, struct_a) = if close_inbound_first { (&inbound_node.node, &inbound_node.tx_broadcaster, inbound_node) } else { (&outbound_node.node, &outbound_node.tx_broadcaster, outbound_node) };
 		let (node_b, broadcaster_b) = if close_inbound_first { (&outbound_node.node, &outbound_node.tx_broadcaster) } else { (&inbound_node.node, &inbound_node.tx_broadcaster) };
@@ -4571,6 +4595,9 @@ mod tests {
 		send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000);
 		send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000);
 		close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
+
+		check_closing_output!(nodes[0].node);
+		check_closing_output!(nodes[1].node);
 	}
 
 	#[test]
@@ -4679,6 +4706,9 @@ mod tests {
 		assert_eq!(get_feerate!(nodes[0]), feerate + 30);
 		assert_eq!(get_feerate!(nodes[1]), feerate + 30);
 		close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
+
+		check_closing_output!(nodes[0].node);
+		check_closing_output!(nodes[1].node);
 	}
 
 	#[test]
@@ -4705,6 +4735,9 @@ mod tests {
 
 		assert!(nodes[0].node.list_channels().is_empty());
 		assert!(nodes[1].node.list_channels().is_empty());
+
+		check_closing_output!(nodes[0].node);
+		check_closing_output!(nodes[1].node);
 	}
 
 	#[test]
@@ -4777,6 +4810,10 @@ mod tests {
 		close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 		assert!(nodes[1].node.list_channels().is_empty());
 		assert!(nodes[2].node.list_channels().is_empty());
+
+		check_closing_output!(nodes[0].node);
+		check_closing_output!(nodes[1].node);
+		check_closing_output!(nodes[2].node);
 	}
 
 	#[test]
@@ -4843,6 +4880,10 @@ mod tests {
 		close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 		assert!(nodes[1].node.list_channels().is_empty());
 		assert!(nodes[2].node.list_channels().is_empty());
+
+		check_closing_output!(nodes[0].node);
+		check_closing_output!(nodes[1].node);
+		check_closing_output!(nodes[2].node);
 	}
 
 	#[test]
@@ -4889,6 +4930,9 @@ mod tests {
 		nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()).unwrap();
 		let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 		assert!(node_0_none.is_none());
+
+		check_closing_output!(nodes[0].node);
+		check_closing_output!(nodes[1].node);
 	}
 
 	fn do_test_shutdown_rebroadcast(recv_count: u8) {
@@ -5041,6 +5085,10 @@ mod tests {
 		close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 		assert!(nodes[1].node.list_channels().is_empty());
 		assert!(nodes[2].node.list_channels().is_empty());
+
+		check_closing_output!(nodes[0].node);
+		check_closing_output!(nodes[1].node);
+		check_closing_output!(nodes[2].node);
 	}
 
 	#[test]
@@ -5160,6 +5208,11 @@ mod tests {
 		close_channel(&nodes[2], &nodes[3], &chan_3.2, chan_3.3, true);
 		close_channel(&nodes[1], &nodes[3], &chan_4.2, chan_4.3, false);
 		close_channel(&nodes[1], &nodes[3], &chan_5.2, chan_5.3, false);
+
+		check_closing_output!(nodes[0].node);
+		check_closing_output!(nodes[1].node);
+		check_closing_output!(nodes[2].node);
+		check_closing_output!(nodes[3].node);
 	}
 
 	#[test]

src/util/transaction_utils.rs

@@ -1,4 +1,5 @@
-use bitcoin::blockdata::transaction::{TxIn, TxOut};
+use bitcoin::blockdata::transaction::{Transaction, TxIn, TxOut};
+use bitcoin::blockdata::script::Script;
 
 use std::cmp::Ordering;
 
@@ -34,6 +35,15 @@ pub fn sort_inputs<T>(inputs: &mut Vec<(TxIn, T)>) {
 	});
 }
 
+pub fn get_vout_my_output(tx: &Transaction, match_script: Script) -> Option<u32> {
+	for (idx, out) in tx.output.iter().enumerate() {
+		if out.script_pubkey == match_script {
+			return Some(idx as u32);
+		}
+	}
+	None
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;