Implement timeout tx claiming on remote received HTLC outputs

Harden htlc_on_chain_timeout test in consequence

Author: Antoine Riard

src/ln/channelmanager.rs

@@ -3632,13 +3632,23 @@ mod tests {
 			Event::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { .. } } => {},
 			_ => panic!("Unexpected event"),
 		}
-		let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
+		let mut funding_tx_map = HashMap::new();
+		funding_tx_map.insert(chan_2.3.txid(), chan_2.3.clone());
+		commitment_tx[0].verify(&funding_tx_map).unwrap();
 
 		// Broadcast timeout transaction by B on received output fron C's commitment tx on B's chain
 		// Verify that B's ChannelManager is able to detect that HTLC is timeout by its own tx and react backward in consequence
-		nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: node_txn}, 200);
-		let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); //TODO: shouldn't be a HTLC-Timeout but actually that's one... => implement lacking parts  in check_spend_remote_transaction
-		nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: node_txn}, 1);
+		nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 200);
+		let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
+		assert_eq!(node_txn.len(), 8); // ChannelManager : 2 (commitment tx, HTLC-Timeout), ChannelMonitor : 6 (commitment tx, HTLC-Timeout, timeout tx) * 2 (block-rescan)
+		assert_eq!(node_txn[2].input[0].previous_output.txid, node_txn[1].txid());
+		assert_eq!(node_txn[2].clone().input[0].witness.last().unwrap().len(), 133);
+
+		let mut commitment_tx_map = HashMap::new();
+		commitment_tx_map.insert(commitment_tx[0].txid(), commitment_tx[0].clone());
+		node_txn[0].verify(&commitment_tx_map).unwrap();
+
+		nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[0].clone()]}, 1);
 		let events = nodes[1].node.get_and_clear_pending_events();
 		assert_eq!(events.len(), 2);
 		match events[0] {

src/ln/channelmonitor.rs

@@ -939,6 +939,29 @@ impl ChannelMonitor {
 						}
 					}
 
+					macro_rules! sign_input_timeout {
+						($sighash_parts: expr, $input: expr, $amount: expr) => {
+							{
+								let (sig, redeemscript) = match self.key_storage {
+									KeyStorage::PrivMode { ref htlc_base_key, .. } => {
+										let htlc = &per_commitment_option.unwrap()[$input.sequence as usize];
+										let redeemscript = chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &a_htlc_key, &b_htlc_key, &revocation_pubkey);
+										let sighash = ignore_error!(Message::from_slice(&$sighash_parts.sighash_all(&$input, &redeemscript, $amount)[..]));
+										let htlc_key = ignore_error!(chan_utils::derive_private_key(&self.secp_ctx, revocation_point, &htlc_base_key));
+										(self.secp_ctx.sign(&sighash, &htlc_key), redeemscript)
+									},
+									KeyStorage::SigsMode { .. } => {
+										unimplemented!();
+									}
+								};
+								$input.witness.push(sig.serialize_der(&self.secp_ctx).to_vec());
+								$input.witness[0].push(SigHashType::All as u8);
+								$input.witness.push(vec![0]);
+								$input.witness.push(redeemscript.into_bytes());
+							}
+						}
+					}
+
 					for (idx, htlc) in per_commitment_data.iter().enumerate() {
 						if let Some(payment_preimage) = self.payment_preimages.get(&htlc.payment_hash) {
 							let input = TxIn {
@@ -969,6 +992,29 @@ impl ChannelMonitor {
 								txn_to_broadcast.push(single_htlc_tx);
 							}
 						}
+						if !htlc.offered {
+							let input = TxIn {
+								previous_output: BitcoinOutPoint {
+									txid: commitment_txid,
+									vout: htlc.transaction_output_index,
+								},
+								script_sig: Script::new(),
+								sequence: idx as u32,
+								witness: Vec::new(),
+							};
+							let mut timeout_tx = Transaction {
+								version: 2,
+								lock_time: htlc.cltv_expiry,
+								input: vec![input],
+								output: vec!(TxOut {
+									script_pubkey: self.destination_script.clone(),
+									value: htlc.amount_msat / 1000,
+								}),
+							};
+							let sighash_parts = bip143::SighashComponents::new(&timeout_tx);
+							sign_input_timeout!(sighash_parts, timeout_tx.input[0], htlc.amount_msat / 1000);
+							txn_to_broadcast.push(timeout_tx);
+						}
 					}
 
 					if inputs.is_empty() { return (txn_to_broadcast, (commitment_txid, watch_outputs)); } // Nothing to be done...probably a false positive/local tx