From d2b5999dc02fe164924dfc4e8297a0a53f58adc2 Mon Sep 17 00:00:00 2001 From: Antoine Riard Date: Fri, 6 Dec 2019 20:51:36 -0500 Subject: [PATCH] Add test_bump_penalty_txn_on_revoked_htlcs --- lightning/src/ln/functional_tests.rs | 129 +++++++++++++++++++++++++++ 1 file changed, 129 insertions(+) diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs index 65ae208ba..00677cbfd 100644 --- a/lightning/src/ln/functional_tests.rs +++ b/lightning/src/ln/functional_tests.rs @@ -6429,3 +6429,132 @@ fn test_bump_penalty_txn_on_revoked_commitment() { nodes[1].node.get_and_clear_pending_events(); nodes[1].node.get_and_clear_pending_msg_events(); } + +#[test] +fn test_bump_penalty_txn_on_revoked_htlcs() { + // In case of penalty txn with too low feerates for getting into mempools, RBF-bump them to sure + // we're able to claim outputs on revoked HTLC transactions before timelocks expiration + + let nodes = create_network(2, &[None, None]); + + let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, LocalFeatures::new(), LocalFeatures::new()); + // Lock HTLC in both directions + let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3_000_000).0; + route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0; + + let 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].input.len(), 1); + assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid()); + + // Revoke local commitment tx + claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000); + + let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + // B will generate both revoked HTLC-timeout/HTLC-preimage txn from revoked commitment tx + nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1); + check_closed_broadcast!(nodes[1]); + + let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); + assert_eq!(revoked_htlc_txn.len(), 6); + if revoked_htlc_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT { + assert_eq!(revoked_htlc_txn[0].input.len(), 1); + check_spends!(revoked_htlc_txn[0], revoked_local_txn[0].clone()); + assert_eq!(revoked_htlc_txn[1].input.len(), 1); + assert_eq!(revoked_htlc_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); + check_spends!(revoked_htlc_txn[1], revoked_local_txn[0].clone()); + } else { + assert_eq!(revoked_htlc_txn[1].input.len(), 1); + check_spends!(revoked_htlc_txn[1], revoked_local_txn[0].clone()); + assert_eq!(revoked_htlc_txn[0].input.len(), 1); + assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); + check_spends!(revoked_htlc_txn[0], revoked_local_txn[0].clone()); + } + + // Broadcast set of revoked txn on A + let header_129 = connect_blocks(&nodes[0].block_notifier, 128, 1, true, header.bitcoin_hash()); + let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[0].block_notifier.block_connected(&Block { header: header_130, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone(), revoked_htlc_txn[1].clone()] }, 130); + let first; + let second; + let feerate_1; + let feerate_2; + { + let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); + assert_eq!(node_txn.len(), 9); // 3 penalty txn on revoked commitment tx * 2 (block-rescan) + A commitment tx + 2 penalty tnx on revoked HTLC txn + // Verify claim tx are spending revoked HTLC txn + assert_eq!(node_txn[7].input.len(), 1); + assert_eq!(node_txn[7].output.len(), 1); + check_spends!(node_txn[7], revoked_htlc_txn[0].clone()); + first = node_txn[7].txid(); + assert_eq!(node_txn[8].input.len(), 1); + assert_eq!(node_txn[8].output.len(), 1); + check_spends!(node_txn[8], revoked_htlc_txn[1].clone()); + second = node_txn[8].txid(); + // Store both feerates for later comparison + let fee_1 = revoked_htlc_txn[0].output[0].value - node_txn[7].output[0].value; + feerate_1 = fee_1 * 1000 / node_txn[7].get_weight() as u64; + let fee_2 = revoked_htlc_txn[1].output[0].value - node_txn[8].output[0].value; + feerate_2 = fee_2 * 1000 / node_txn[8].get_weight() as u64; + node_txn.clear(); + } + + // Connect three more block to see if bumped penalty are issued for HTLC txn + let header_133 = connect_blocks(&nodes[0].block_notifier, 3, 130, true, header_130.bitcoin_hash()); + let node_txn = { + let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); + assert_eq!(node_txn.len(), 4); // 2 first tx : bumped claiming txn on Revoked Commitment Tx + 2 last tx : bumped claiming txn on Revoked HTLCs Txn + check_spends!(node_txn[0], revoked_local_txn[0].clone()); + check_spends!(node_txn[1], revoked_local_txn[0].clone()); + assert_eq!(node_txn[2].input.len(), 1); + assert_eq!(node_txn[2].output.len(), 1); + assert_eq!(node_txn[3].input.len(), 1); + assert_eq!(node_txn[3].output.len(), 1); + // Verify bumped tx is different and 25% bump heuristic + if node_txn[2].input[0].previous_output.txid == revoked_htlc_txn[0].txid() { + check_spends!(node_txn[2], revoked_htlc_txn[0].clone()); + assert_ne!(first, node_txn[2].txid()); + let fee = revoked_htlc_txn[0].output[0].value - node_txn[2].output[0].value; + let new_feerate = fee * 1000 / node_txn[2].get_weight() as u64; + assert!(new_feerate * 100 > feerate_1 * 125); + + check_spends!(node_txn[3], revoked_htlc_txn[1].clone()); + assert_ne!(second, node_txn[3].txid()); + let fee = revoked_htlc_txn[1].output[0].value - node_txn[3].output[0].value; + let new_feerate = fee * 1000 / node_txn[3].get_weight() as u64; + assert!(new_feerate * 100 > feerate_2 * 125); + } else if node_txn[2].input[0].previous_output.txid == revoked_htlc_txn[1].txid() { + check_spends!(node_txn[2], revoked_htlc_txn[1].clone()); + assert_ne!(second, node_txn[2].txid()); + let fee = revoked_htlc_txn[1].output[0].value - node_txn[2].output[0].value; + let new_feerate = fee * 1000 / node_txn[2].get_weight() as u64; + assert!(new_feerate * 100 > feerate_2 * 125); + + check_spends!(node_txn[3], revoked_htlc_txn[0].clone()); + assert_ne!(first, node_txn[3].txid()); + let fee = revoked_htlc_txn[0].output[0].value - node_txn[3].output[0].value; + let new_feerate = fee * 1000 / node_txn[3].get_weight() as u64; + assert!(new_feerate * 100 > feerate_1 * 125); + } else { assert!(false) } + let txn = vec![node_txn[0].clone(), node_txn[1].clone(), node_txn[2].clone(), node_txn[3].clone()]; + node_txn.clear(); + txn + }; + // Broadcast claim txn and confirm blocks to avoid further bumps on this outputs + let header_134 = BlockHeader { version: 0x20000000, prev_blockhash: header_133, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; + nodes[0].block_notifier.block_connected(&Block { header: header_134, txdata: node_txn }, 134); + connect_blocks(&nodes[0].block_notifier, 6, 134, true, header_134.bitcoin_hash()); + { + let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); + node_txn.clear(); + } + + // Connect few more blocks and check only penalty transaction for to_local output have been issued + connect_blocks(&nodes[0].block_notifier, 5, 140, true, header_134.bitcoin_hash()); + { + let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap(); + assert_eq!(node_txn.len(), 1); + check_spends!(node_txn[0], revoked_local_txn[0].clone()); + node_txn.clear(); + } + check_closed_broadcast!(nodes[0]); +} -- 2.39.5