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

Author: Antoine Riard

src/ln/channelmonitor.rs

@@ -2439,8 +2439,25 @@ impl ChannelMonitor {
 					return Some((new_timer, bumped_tx, new_feerate));
 				}
 			},
-			TxMaterial::RemoteHTLC { .. } => {
-				return None;
+			TxMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref amount } => {
+				let predicted_weight = bumped_tx.get_weight() + Self::get_witnesses_weight(if preimage.is_some() { &[InputDescriptors::OfferedHTLC] } else { &[InputDescriptors::ReceivedHTLC] });
+				if let Some((new_fee, new_feerate)) = RBF_bump!(*amount, old_feerate, fee_estimator, predicted_weight, claimed_outpoint, "remote htlc") {
+					bumped_tx.output[0].value = amount - new_fee; 
+					let sighash_parts = bip143::SighashComponents::new(&bumped_tx);	
+					let sighash = hash_to_message!(&sighash_parts.sighash_all(&bumped_tx.input[0], &script, *amount)[..]);
+					let sig = self.secp_ctx.sign(&sighash, &key);
+					bumped_tx.input[0].witness.push(sig.serialize_der().to_vec());
+					bumped_tx.input[0].witness[0].push(SigHashType::All as u8);
+					if let &Some(preimage) = preimage {
+						bumped_tx.input[0].witness.push(preimage.clone().0.to_vec());
+					} else {
+						bumped_tx.input[0].witness.push(vec![0]);
+					}
+					bumped_tx.input[0].witness.push(script.clone().into_bytes());
+					assert!(predicted_weight >= bumped_tx.get_weight());
+					log_info!(self, "Going to broadcast bumped Claim Transaction {} claiming remote htlc output {} from {} with new feerate {}", bumped_tx.txid(), claimed_outpoint.vout, claimed_outpoint.txid, new_feerate);
+					return Some((new_timer, bumped_tx, new_feerate));
+				}
 			},
 			TxMaterial::LocalHTLC { .. } => {
 				//TODO : Given that Local Commitment Transaction and HTLC-Timeout/HTLC-Success are counter-signed by peer, we can't

src/ln/functional_tests.rs

@@ -1695,14 +1695,19 @@ fn channel_monitor_network_test() {
 	let payment_preimage_2 = route_payment(&nodes[3], &vec!(&nodes[4])[..], 3000000).0;
 	// CLTV expires at TEST_FINAL_CLTV + 1 (current height) + 1 (added in send_payment for
 	// buffer space).
-
 	{
 		let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 		nodes[3].chain_monitor.block_connected_checked(&header, 7, &Vec::new()[..], &[0; 0]);
 		for i in 8..TEST_FINAL_CLTV + 2 + HTLC_FAIL_TIMEOUT_BLOCKS + 6 {
 			header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 			nodes[3].chain_monitor.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
 		}
+		{
+			let mut node_txn = nodes[3].tx_broadcaster.txn_broadcasted.lock().unwrap();
+			node_txn.swap_remove(0);
+			node_txn.swap_remove(1);
+			node_txn.truncate(2);
+		}
 
 		let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT);
 
@@ -2151,16 +2156,16 @@ fn test_htlc_on_chain_success() {
 	connect_blocks(&nodes[1].chain_monitor, HTLC_FAIL_ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
 	check_closed_broadcast!(nodes[1]);
 	let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 1 (commitment tx), ChannelMonitor : 1 (HTLC-Success) * 2 (block-rescan)
-	assert_eq!(node_txn.len(), 3);
+	assert_eq!(node_txn.len(), 5);
 	assert_eq!(node_txn[0], node_txn[1]);
 	check_spends!(node_txn[0], commitment_tx[0].clone());
 	assert_eq!(node_txn[0].input.len(), 2);
 	assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
 	assert_eq!(node_txn[0].input[1].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
 	assert_eq!(node_txn[0].lock_time, 0);
 	assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
-	check_spends!(node_txn[2], chan_1.3.clone());
-	assert_eq!(node_txn[2].input[0].witness.clone().last().unwrap().len(), 71);
+	check_spends!(node_txn[4], chan_1.3.clone());
+	assert_eq!(node_txn[4].input[0].witness.clone().last().unwrap().len(), 71);
 	// We don't bother to check that B can claim the HTLC output on its commitment tx here as
 	// we already checked the same situation with A.
 
@@ -3643,7 +3648,7 @@ fn test_static_spendable_outputs_preimage_tx() {
 	check_spends!(node_txn[0], commitment_tx[0].clone());
 	assert_eq!(node_txn[0], node_txn[1]);
 	assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
-	check_spends!(node_txn[2], chan_1.3.clone());
+	check_spends!(node_txn[3], chan_1.3.clone());
 
 	let spend_txn = check_spendable_outputs!(nodes[1], 1); // , 0, 0, 1, 1);
 	assert_eq!(spend_txn.len(), 2);
@@ -3861,8 +3866,8 @@ fn test_onchain_to_onchain_claim() {
 	nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
 	connect_blocks(&nodes[1].chain_monitor, HTLC_FAIL_ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
 	let b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
-	assert_eq!(b_txn.len(), 3);
-	check_spends!(b_txn[2], chan_1.3); // Local commitment tx, issued by ChannelManager
+	assert_eq!(b_txn.len(), 4);
+	check_spends!(b_txn[3], chan_1.3); // Local commitment tx, issued by ChannelManager
 	assert_eq!(b_txn[0], b_txn[1]); // HTLC-Success tx, issued by ChannelMonitor, * 2 due to block rescan
 	check_spends!(b_txn[0], commitment_tx[0].clone());
 	assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);