Add test_bump_penalty_txn_on_revoked_txn

Author: Antoine Riard

src/ln/functional_test_utils.rs

@@ -47,13 +47,14 @@ pub fn confirm_transaction(chain: &chaininterface::ChainWatchInterfaceUtil, tx:
 	}
 }
 
-pub fn connect_blocks(chain: &chaininterface::ChainWatchInterfaceUtil, depth: u32, height: u32, parent: bool, prev_blockhash: Sha256d) {
+pub fn connect_blocks(chain: &chaininterface::ChainWatchInterfaceUtil, depth: u32, height: u32, parent: bool, prev_blockhash: Sha256d) -> BlockHeader {
 	let mut header = BlockHeader { version: 0x2000000, prev_blockhash: if parent { prev_blockhash } else { Default::default() }, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 	chain.block_connected_checked(&header, height + 1, &Vec::new(), &Vec::new());
 	for i in 2..depth + 1 {
 		header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 		chain.block_connected_checked(&header, height + i, &Vec::new(), &Vec::new());
 	}
+	return header;
 }
 
 pub fn disconnect_blocks(chain: &chaininterface::ChainWatchInterfaceUtil, depth: u32, height: u32, parent: bool, prev_blockhash: Sha256d) {

src/ln/functional_tests.rs

@@ -3,7 +3,7 @@
 //! claim outputs on-chain.
 
 use chain::transaction::OutPoint;
-use chain::chaininterface::{ChainListener, ChainWatchInterface};
+use chain::chaininterface::{ChainListener, ChainWatchInterface, ChainWatchInterfaceUtil};
 use chain::keysinterface::{KeysInterface, SpendableOutputDescriptor};
 use chain::keysinterface;
 use ln::channel::{COMMITMENT_TX_BASE_WEIGHT, COMMITMENT_TX_WEIGHT_PER_HTLC, BREAKDOWN_TIMEOUT};
@@ -19,6 +19,7 @@ use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsPro
 use util::errors::APIError;
 use util::ser::{Writeable, ReadableArgs};
 use util::config::UserConfig;
+use util::logger::Logger;
 use util::rng;
 
 use bitcoin::util::hash::BitcoinHash;
@@ -41,7 +42,7 @@ use secp256k1::key::{PublicKey,SecretKey};
 
 use std::collections::{BTreeSet, HashMap, HashSet};
 use std::default::Default;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use std::sync::atomic::Ordering;
 use std::time::Instant;
 use std::mem;
@@ -5709,3 +5710,252 @@ fn test_sweep_outbound_htlc_failure_update() {
 	do_test_sweep_outbound_htlc_failure_update(false, false);
 	do_test_sweep_outbound_htlc_failure_update(true, false);
 }
+
+
+// aggregation
+// multiple bumping rounds
+// 2 different bumping heuristic
+// min relay fee isn't enough
+
+#[test]
+fn test_bump_penalty_txn_on_revoked_commitment() {
+	// In case of penalty txn with too low feerates for getting into mempools, RBF-bump them to be sure 
+	// we're able to claim outputs on revoked commitment transaction before timelocks expiration
+
+	let mut nodes = create_network(2);
+
+	let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000);
+	let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
+	route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000).0;
+	let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().last_local_commitment_txn.clone();
+	assert_eq!(revoked_local_txn[0].output.len(), 4);
+	assert_eq!(revoked_local_txn[0].input.len(), 1);
+	assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
+	let revoked_txid = revoked_local_txn[0].txid();
+
+	let mut penalty_amount = 0;
+	for outp in revoked_local_txn[0].output.iter() {
+		if outp.script_pubkey.is_v0_p2wsh() {
+			penalty_amount += outp.value;
+		}
+	}
+
+	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
+	let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+	nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
+
+	let previous_penalty_txid;
+	let feerate_1;
+	{
+		let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		assert_eq!(node_txn.len(), 2);
+		assert_eq!(node_txn[0], node_txn[1]);
+		assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
+		assert_eq!(node_txn[0].output.len(), 1);
+		check_spends!(node_txn[0], revoked_local_txn[0].clone());
+		let fee_1 = penalty_amount - node_txn[0].output[0].value;
+		feerate_1 = fee_1 * 1000 / node_txn[0].get_weight();
+		previous_penalty_txid = node_txn[0].txid();
+		node_txn.clear();
+	};
+
+	let header = connect_blocks(&nodes[1].chain_monitor, 3, 1,  true, header.bitcoin_hash());
+	let mut penalties_2 = HashMap::new();
+	let mut feerate_2 = 0;
+	{
+		let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		assert_eq!(node_txn.len(), 3);
+		for tx in node_txn.drain(..) {
+			if tx.input[0].previous_output.txid == revoked_txid {
+				let txid = tx.txid();
+				// Verify new bumped tx is different from last claiming transaction, we don't want spurrious rebroadcast
+				assert_ne!(previous_penalty_txid, txid);
+				check_spends!(tx, revoked_local_txn[0].clone());
+				let fee_2 = revoked_local_txn[0].output[tx.input[0].previous_output.vout as usize].value - tx.output[0].value;
+				feerate_2 = fee_2 * 1000 / tx.get_weight();
+				// Verify 25% bump heuristic
+				assert!(feerate_2 * 100 >= feerate_1 * 125);
+				penalties_2.insert(tx.input[0].previous_output, (txid, fee_2));
+			}
+		}
+	}
+	assert_ne!(feerate_2, 0);
+
+	let header = connect_blocks(&nodes[1].chain_monitor, 3, 4, true, header.bitcoin_hash());
+	let mut penalties_3 = HashMap::new();
+	let mut feerate_3 = 0;
+	{
+		let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		assert_eq!(node_txn.len(), 5);
+		for tx in node_txn.drain(..) {
+			if let Some(previous_data) = penalties_2.get(&tx.input[0].previous_output) {
+				let txid = tx.txid();
+				// Verify new bumped tx is different from any last claiming treansaction, we don't want spurrious rebroadcast
+				assert_ne!(previous_data.0, txid);
+				check_spends!(tx, revoked_local_txn[0].clone());
+				let fee_3 = revoked_local_txn[0].output[tx.input[0].previous_output.vout as usize].value - tx.output[0].value;
+				feerate_3 = fee_3 * 1000 / tx.get_weight();
+				// Verify 25% bump heuristic;
+				assert!(feerate_3 * 100 >= feerate_2 * 125);
+				penalties_3.insert(tx.input[0].previous_output, (txid, fee_3));
+			}
+		}
+	}
+	assert_ne!(feerate_3, 0);
+
+	macro_rules! update_fee_estimator {
+		($node: expr, $sat_per_kw: expr, $min_relay_sat_per_kw: expr) => {
+			let funding_outpoint = OutPoint { txid: chan.3.txid(), index: 0 };
+			let current_monitor = nodes[1].chan_monitor.simple_monitor.monitors.lock().unwrap().remove(&funding_outpoint).unwrap();
+			let logger: Arc<Logger> = Arc::new(test_utils::TestLogger::with_id(format!("node {}", 1)));
+			let chain_monitor = Arc::new(ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&logger)));
+			let new_fee_estimator = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: $sat_per_kw, min_relay_sat_per_kw: $min_relay_sat_per_kw});
+			let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())});
+			let chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor.clone(), tx_broadcaster.clone(), logger.clone(), new_fee_estimator.clone()));
+			assert!(chan_monitor.add_update_monitor(funding_outpoint, current_monitor).is_ok());
+			$node.chain_monitor = chain_monitor;
+			$node.chan_monitor = chan_monitor;
+			$node.tx_broadcaster = tx_broadcaster;
+		}
+	}
+
+	update_fee_estimator!(nodes[1], 500, 0);
+	let header = connect_blocks(&nodes[1].chain_monitor, 3, 7, true, header.bitcoin_hash());
+	let mut penalties_4 = HashMap::new();
+	let mut feerate_4 = 0;
+	{
+		let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		assert_eq!(node_txn.len(), 3);
+		for tx in node_txn.drain(..) {
+			if let Some(previous_data) = penalties_3.get(&tx.input[0].previous_output) {
+				let txid = tx.txid();
+				// Verify new bumped tx is different from any last claiming treansaction, we don't want spurrious rebroadcast
+				assert_ne!(previous_data.0, txid);
+				check_spends!(tx, revoked_local_txn[0].clone());
+				let fee_4 = revoked_local_txn[0].output[tx.input[0].previous_output.vout as usize].value - tx.output[0].value;
+				feerate_4 = fee_4 * 1000 / tx.get_weight();
+				// Verify HighPriority spike bump heuristic;
+				assert!(feerate_4 > feerate_3);
+				penalties_4.insert(tx.input[0].previous_output, (txid, fee_4));
+			}
+		}
+	}
+	assert_ne!(feerate_4, 0);
+	update_fee_estimator!(nodes[1], 500, 100);
+	check_added_monitors!(nodes[1], 1);
+
+	connect_blocks(&nodes[1].chain_monitor, 3, 10, true, header.bitcoin_hash());
+	let mut feerate_5 = 0;
+	{
+		let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		assert_eq!(node_txn.len(), 3);
+		for tx in node_txn.drain(..) {
+			if let Some(previous_data) = penalties_4.get(&tx.input[0].previous_output) {
+				let txid = tx.txid();
+				// Verify new bumped tx is different from any last claiming treansaction, we don't want spurrious rebroadcast
+				assert_ne!(previous_data.0, txid);
+				check_spends!(tx, revoked_local_txn[0].clone());
+				let fee_5 = revoked_local_txn[0].output[tx.input[0].previous_output.vout as usize].value - tx.output[0].value;
+				feerate_5 = fee_5 * 1000 / tx.get_weight();
+				// Verify min_relay_fee threshold force bump
+				assert!(feerate_5 * 100 >= feerate_4 * 119);
+			}
+		}
+	}
+	assert_ne!(feerate_5, 0);
+	nodes[0].node.get_and_clear_pending_msg_events();
+	nodes[1].node.get_and_clear_pending_msg_events();
+	nodes[0].node.get_and_clear_pending_events();
+	nodes[1].node.get_and_clear_pending_events();
+}
+
+#[test]
+fn test_bump_penalty_txn_on_revoked_htlc() {
+	// In case of penalty txn with too low feerates for getting into mempools, RBF-bump them to be sure
+	// we're able to claim outputs on revoked HTLC-Success/Timeout txn before timelock expiration
+
+	let nodes = create_network(2);
+
+	let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000);
+	let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
+	route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000).0;
+	let revoked_local_txn;
+	{
+		revoked_local_txn = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().last_local_commitment_txn.clone();
+		assert_eq!(revoked_local_txn[0].output.len(), 4);
+		assert_eq!(revoked_local_txn[0].input.len(), 1);
+		assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
+	}
+
+	claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
+	let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+	nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
+	let mut htlc_timeout = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() };
+	let mut htlc_success = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() };
+	{
+		let mut revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		assert_eq!(revoked_htlc_txn.len(), 4);
+		if revoked_htlc_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
+			assert_eq!(revoked_htlc_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
+			htlc_success = revoked_htlc_txn[0].clone();
+			htlc_timeout = revoked_htlc_txn[1].clone();
+		} else if revoked_htlc_txn[0].input[0].witness.last().unwrap().len() == OFFERED_HTLC_SCRIPT_WEIGHT {
+			assert_eq!(revoked_htlc_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
+			htlc_timeout = revoked_htlc_txn[0].clone();
+			htlc_success = revoked_htlc_txn[1].clone();
+		}
+		assert_eq!(revoked_htlc_txn[0], revoked_htlc_txn[2]);
+		assert_eq!(revoked_htlc_txn[1], revoked_htlc_txn[3]);
+		revoked_htlc_txn.clear();
+	}
+	nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()]}, 1);
+	{
+		let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		node_txn.clear();
+	}
+	let header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+	nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![htlc_success.clone(), htlc_timeout.clone()] }, 2);
+	let mut penalties = HashMap::new();
+	{
+		let mut penalty_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		assert_eq!(penalty_txn.len(), 2);
+		if penalty_txn[0].input[0].previous_output.txid == htlc_timeout.txid() {
+			check_spends!(penalty_txn[0], htlc_timeout.clone());
+			penalties.insert(penalty_txn[0].input[0].previous_output, (penalty_txn[0].txid(), htlc_timeout.output[0].value - penalty_txn[0].output[0].value));
+			check_spends!(penalty_txn[1], htlc_success.clone());
+			penalties.insert(penalty_txn[1].input[0].previous_output, (penalty_txn[1].txid(), htlc_success.output[0].value - penalty_txn[1].output[0].value));
+		} else {
+			check_spends!(penalty_txn[1], htlc_timeout.clone());
+			penalties.insert(penalty_txn[1].input[0].previous_output, (penalty_txn[0].txid(), htlc_timeout.output[0].value - penalty_txn[1].output[0].value));
+			check_spends!(penalty_txn[0], htlc_success.clone());
+			penalties.insert(penalty_txn[0].input[0].previous_output, (penalty_txn[1].txid(), htlc_success.output[0].value - penalty_txn[0].output[0].value));
+		}
+		penalty_txn.clear();
+	}
+	let header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
+	let header = connect_blocks(&nodes[0].chain_monitor, 2, 2, true, header.bitcoin_hash());
+	{
+		let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		node_txn.clear();
+	}
+	connect_blocks(&nodes[0].chain_monitor, 1, 4, true, header.bitcoin_hash());
+	{
+		let penalty_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
+		for tx in penalty_txn.iter() {
+			if let Some(previous_data) = penalties.get(&tx.input[0].previous_output) {
+				let txid = tx.txid();
+				assert_ne!(previous_data.0, txid);
+				// Verify that fee has been increased
+				if tx.input[0].previous_output.txid == htlc_timeout.txid() {
+					check_spends!(tx, htlc_timeout.clone());
+					let fee = htlc_timeout.output[0].value - tx.output[0].value;
+					assert!(fee > previous_data.1);
+				} else {
+					check_spends!(tx, htlc_success.clone());
+					let fee = htlc_timeout.output[0].value - tx.output[0].value;
+					assert!(fee > previous_data.1);
+				}
+			}
+		}
+	}
+}