Add RBF-bumping of preimage/timeout txn on remote HTLC outputs

Given they are only signed by us we can RBF at wish

Fix tests broken by introduction of more txn broadcast
(channel_monitor_network_test)

Add locktime in RemoteHTLC as it's needed to generate
timeout txn.

Author: Antoine Riard

lightning/src/ln/channelmonitor.rs

@@ -387,6 +387,7 @@ enum InputMaterial {
 		key: SecretKey,
 		preimage: Option<PaymentPreimage>,
 		amount: u64,
+		locktime: u32,
 	},
 	LocalHTLC {
 		script: Script,
@@ -1175,12 +1176,13 @@ impl ChannelMonitor {
 						}
 						writer.write_all(&byte_utils::be64_to_array(*amount))?;
 					},
-					&InputMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref amount } => {
+					&InputMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref amount, ref locktime } => {
 						writer.write_all(&[1; 1])?;
 						script.write(writer)?;
 						key.write(writer)?;
 						preimage.write(writer)?;
 						writer.write_all(&byte_utils::be64_to_array(*amount))?;
+						writer.write_all(&byte_utils::be32_to_array(*locktime))?;
 					},
 					&InputMaterial::LocalHTLC { ref script, ref sigs, ref preimage, ref amount } => {
 						writer.write_all(&[2; 1])?;
@@ -1708,7 +1710,7 @@ impl ChannelMonitor {
 											});
 											log_trace!(self, "Outpoint {}:{} is being being claimed, if it doesn't succeed, a bumped claiming txn is going to be broadcast at height {}", single_htlc_tx.input[0].previous_output.txid, single_htlc_tx.input[0].previous_output.vout, height_timer);
 											let mut per_input_material = HashMap::with_capacity(1);
-											per_input_material.insert(single_htlc_tx.input[0].previous_output.vout, InputMaterial::RemoteHTLC { script: redeemscript, key: htlc_key, preimage: Some(*payment_preimage), amount: htlc.amount_msat / 1000 });
+											per_input_material.insert(single_htlc_tx.input[0].previous_output.vout, InputMaterial::RemoteHTLC { script: redeemscript, key: htlc_key, preimage: Some(*payment_preimage), amount: htlc.amount_msat / 1000, locktime: 0 });
 											match self.our_claim_txn_waiting_first_conf.entry(single_htlc_tx.input[0].previous_output.clone()) {
 												hash_map::Entry::Occupied(_) => {},
 												hash_map::Entry::Vacant(entry) => { entry.insert(ClaimTxBumpMaterial { height_timer, first_seen_height: height, feerate_previous: used_feerate, soonest_timelock: htlc.cltv_expiry, per_input_material}); }
@@ -1749,7 +1751,7 @@ impl ChannelMonitor {
 									//TODO: track SpendableOutputDescriptor
 									log_trace!(self, "Outpoint {}:{} is being being claimed, if it doesn't succeed, a bumped claiming txn is going to be broadcast at height {}", timeout_tx.input[0].previous_output.txid, timeout_tx.input[0].previous_output.vout, height_timer);
 									let mut per_input_material = HashMap::with_capacity(1);
-									per_input_material.insert(timeout_tx.input[0].previous_output.vout, InputMaterial::RemoteHTLC { script : redeemscript, key: htlc_key, preimage: None, amount: htlc.amount_msat / 1000 });
+									per_input_material.insert(timeout_tx.input[0].previous_output.vout, InputMaterial::RemoteHTLC { script : redeemscript, key: htlc_key, preimage: None, amount: htlc.amount_msat / 1000, locktime: htlc.cltv_expiry });
 									match self.our_claim_txn_waiting_first_conf.entry(timeout_tx.input[0].previous_output.clone()) {
 										hash_map::Entry::Occupied(_) => {},
 										hash_map::Entry::Vacant(entry) => { entry.insert(ClaimTxBumpMaterial { height_timer, first_seen_height: height, feerate_previous: used_feerate, soonest_timelock: htlc.cltv_expiry, per_input_material }); }
@@ -1793,7 +1795,7 @@ impl ChannelMonitor {
 					for (input, info) in spend_tx.input.iter_mut().zip(inputs_info.iter()) {
 						let (redeemscript, htlc_key) = sign_input!(sighash_parts, input, info.1, (info.0).0.to_vec());
 						log_trace!(self, "Outpoint {}:{} is being being claimed, if it doesn't succeed, a bumped claiming txn is going to be broadcast at height {}", input.previous_output.txid, input.previous_output.vout, height_timer);
-						per_input_material.insert(input.previous_output.vout, InputMaterial::RemoteHTLC { script: redeemscript, key: htlc_key, preimage: Some(*(info.0)), amount: info.1});
+						per_input_material.insert(input.previous_output.vout, InputMaterial::RemoteHTLC { script: redeemscript, key: htlc_key, preimage: Some(*(info.0)), amount: info.1, locktime: 0});
 					}
 					match self.our_claim_txn_waiting_first_conf.entry(spend_tx.input[0].previous_output.clone()) {
 						hash_map::Entry::Occupied(_) => {},
@@ -2600,7 +2602,10 @@ impl ChannelMonitor {
 					inputs_witnesses_weight += Self::get_witnesses_weight(if !is_htlc { &[InputDescriptors::RevokedOutput] } else if script.len() == OFFERED_HTLC_SCRIPT_WEIGHT { &[InputDescriptors::RevokedOfferedHTLC] } else if script.len() == ACCEPTED_HTLC_SCRIPT_WEIGHT { &[InputDescriptors::RevokedReceivedHTLC] } else { &[] });
 					amt += *amount;
 				},
-				&InputMaterial::RemoteHTLC { .. } => { return None; },
+				&InputMaterial::RemoteHTLC { ref preimage, ref amount, .. } => {
+					inputs_witnesses_weight += Self::get_witnesses_weight(if preimage.is_some() { &[InputDescriptors::OfferedHTLC] } else { &[InputDescriptors::ReceivedHTLC] });
+					amt += *amount;
+				},
 				&InputMaterial::LocalHTLC { .. } => { return None; }
 			}
 		}
@@ -2637,7 +2642,21 @@ impl ChannelMonitor {
 					bumped_tx.input[i].witness.push(script.clone().into_bytes());
 					log_trace!(self, "Going to broadcast bumped Penalty Transaction {} claiming revoked {} output {} from {} with new feerate {}", bumped_tx.txid(), if !is_htlc { "to_local" } else if script.len() == OFFERED_HTLC_SCRIPT_WEIGHT { "offered" } else if script.len() == ACCEPTED_HTLC_SCRIPT_WEIGHT { "received" } else { "" }, vout, outp.txid, new_feerate);
 				},
-				&InputMaterial::RemoteHTLC { .. } => {},
+				&InputMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref amount, ref locktime } => {
+					if !preimage.is_some() { bumped_tx.lock_time = *locktime };
+					let sighash_parts = bip143::SighashComponents::new(&bumped_tx);
+					let sighash = hash_to_message!(&sighash_parts.sighash_all(&bumped_tx.input[i], &script, *amount)[..]);
+					let sig = self.secp_ctx.sign(&sighash, &key);
+					bumped_tx.input[i].witness.push(sig.serialize_der().to_vec());
+					bumped_tx.input[i].witness[0].push(SigHashType::All as u8);
+					if let &Some(preimage) = preimage {
+						bumped_tx.input[i].witness.push(preimage.clone().0.to_vec());
+					} else {
+						bumped_tx.input[i].witness.push(vec![0]);
+					}
+					bumped_tx.input[i].witness.push(script.clone().into_bytes());
+					log_trace!(self, "Going to broadcast bumped Claim Transaction {} claiming remote {} htlc output {} from {} with new feerate {}", bumped_tx.txid(), if preimage.is_some() { "offered" } else { "received" }, vout, outp.txid, new_feerate);
+				},
 				&InputMaterial::LocalHTLC { .. } => {
 					//TODO : Given that Local Commitment Transaction and HTLC-Timeout/HTLC-Success are counter-signed by peer, we can't
 					// RBF them. Need a Lightning specs change and package relay modification :
@@ -2908,11 +2927,13 @@ impl<R: ::std::io::Read> ReadableArgs<R, Arc<Logger>> for (Sha256dHash, ChannelM
 						let key = Readable::read(reader)?;
 						let preimage = Readable::read(reader)?;
 						let amount = Readable::read(reader)?;
+						let locktime = Readable::read(reader)?;
 						InputMaterial::RemoteHTLC {
 							script,
 							key,
 							preimage,
-							amount
+							amount,
+							locktime
 						}
 					},
 					2 => {

lightning/src/ln/functional_tests.rs

@@ -1783,8 +1783,10 @@ fn channel_monitor_network_test() {
 	// nodes[3] gets the preimage, but nodes[2] already disconnected, resulting in a nodes[2]
 	// HTLC-Timeout and a nodes[3] claim against it (+ its own announces)
 	nodes[2].node.peer_disconnected(&nodes[3].node.get_our_node_id(), true);
+	let node2_commitment_txid;
 	{
 		let node_txn = test_txn_broadcast(&nodes[2], &chan_3, None, HTLCType::TIMEOUT);
+		node2_commitment_txid = node_txn[0].txid();
 
 		// Claim the payment on nodes[3], giving it knowledge of the preimage
 		claim_funds!(nodes[3], nodes[2], payment_preimage_1, 3_000_000);
@@ -1818,6 +1820,16 @@ fn channel_monitor_network_test() {
 			nodes[3].block_notifier.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
 		}
 
+		// Clear bumped claiming txn spending node 2 commitment tx. Bumped txn are generated after reaching some height timer.
+		{
+			let mut node_txn = nodes[3].tx_broadcaster.txn_broadcasted.lock().unwrap();
+			node_txn.retain(|tx| {
+				if tx.input[0].previous_output.txid == node2_commitment_txid {
+					false
+				} else { true }
+			});
+		}
+
 		let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT);
 
 		// Claim the payment on nodes[4], giving it knowledge of the preimage