X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Ffunctional_tests.rs;h=f491120835cba301de07e5aec78a57537a3d7e1f;hb=ee68ffa5fdfcfa8ee7fe70512d9e079d621083bc;hp=eef8199e8e43eaa3aa63c68e40b7a12966485780;hpb=36cc5814c1802dee2541c52497f8b4f034876daa;p=rust-lightning diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs index eef8199e..f4911208 100644 --- a/lightning/src/ln/functional_tests.rs +++ b/lightning/src/ln/functional_tests.rs @@ -15,7 +15,7 @@ use chain::Watch; use chain::channelmonitor; use chain::channelmonitor::{ChannelMonitor, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ANTI_REORG_DELAY}; use chain::transaction::OutPoint; -use chain::keysinterface::{ChannelKeys, KeysInterface, SpendableOutputDescriptor}; +use chain::keysinterface::{ChannelKeys, KeysInterface}; use ln::channel::{COMMITMENT_TX_BASE_WEIGHT, COMMITMENT_TX_WEIGHT_PER_HTLC}; use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSecret, PaymentSendFailure, BREAKDOWN_TIMEOUT}; use ln::channel::{Channel, ChannelError}; @@ -33,12 +33,8 @@ use util::config::UserConfig; use bitcoin::hashes::sha256d::Hash as Sha256dHash; use bitcoin::hash_types::{Txid, BlockHash}; -use bitcoin::util::bip143; -use bitcoin::util::address::Address; -use bitcoin::util::bip32::{ChildNumber, ExtendedPubKey, ExtendedPrivKey}; use bitcoin::blockdata::block::{Block, BlockHeader}; -use bitcoin::blockdata::transaction::{Transaction, TxOut, TxIn, SigHashType}; -use bitcoin::blockdata::script::{Builder, Script}; +use bitcoin::blockdata::script::Builder; use bitcoin::blockdata::opcodes; use bitcoin::blockdata::constants::genesis_block; use bitcoin::network::constants::Network; @@ -1583,7 +1579,7 @@ fn test_fee_spike_violation_fails_htlc() { let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap(); (route, payment_hash, payment_preimage) }} - }; + } let (route, payment_hash, _) = get_route_and_payment_hash!(3460001); // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc() @@ -1705,8 +1701,9 @@ fn test_fee_spike_violation_fails_htlc() { fn test_chan_reserve_violation_outbound_htlc_inbound_chan() { let mut chanmon_cfgs = create_chanmon_cfgs(2); // Set the fee rate for the channel very high, to the point where the fundee - // sending any amount would result in a channel reserve violation. In this test - // we check that we would be prevented from sending an HTLC in this situation. + // sending any above-dust amount would result in a channel reserve violation. + // In this test we check that we would be prevented from sending an HTLC in + // this situation. chanmon_cfgs[0].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 }; chanmon_cfgs[1].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 }; let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); @@ -1722,9 +1719,9 @@ fn test_chan_reserve_violation_outbound_htlc_inbound_chan() { let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.first().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap(); (route, payment_hash, payment_preimage) }} - }; + } - let (route, our_payment_hash, _) = get_route_and_payment_hash!(1000); + let (route, our_payment_hash, _) = get_route_and_payment_hash!(4843000); unwrap_send_err!(nodes[1].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err }, assert_eq!(err, "Cannot send value that would put counterparty balance under holder-announced channel reserve value")); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); @@ -1754,7 +1751,7 @@ fn test_chan_reserve_violation_inbound_htlc_outbound_channel() { let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.first().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap(); (route, payment_hash, payment_preimage) }} - }; + } let (route, payment_hash, _) = get_route_and_payment_hash!(1000); // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc() @@ -1782,6 +1779,57 @@ fn test_chan_reserve_violation_inbound_htlc_outbound_channel() { check_added_monitors!(nodes[0], 1); } +#[test] +fn test_chan_reserve_dust_inbound_htlcs_outbound_chan() { + // Test that if we receive many dust HTLCs over an outbound channel, they don't count when + // calculating our commitment transaction fee (this was previously broken). + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None, None]); + let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + + // Set nodes[0]'s balance such that they will consider any above-dust received HTLC to be a + // channel reserve violation (so their balance is channel reserve (1000 sats) + commitment + // transaction fee with 0 HTLCs (183 sats)). + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 98817000, InitFeatures::known(), InitFeatures::known()); + + let dust_amt = 546000; // Dust amount + // In the previous code, routing this dust payment would cause nodes[0] to perceive a channel + // reserve violation even though it's a dust HTLC and therefore shouldn't count towards the + // commitment transaction fee. + let (_, _) = route_payment(&nodes[1], &[&nodes[0]], dust_amt); +} + +#[test] +fn test_chan_reserve_dust_inbound_htlcs_inbound_chan() { + // Test that if we receive many dust HTLCs over an inbound channel, they don't count when + // calculating our counterparty's commitment transaction fee (this was previously broken). + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None, None]); + let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 98000000, InitFeatures::known(), InitFeatures::known()); + + let payment_amt = 46000; // Dust amount + // In the previous code, these first four payments would succeed. + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); + + // Then these next 5 would be interpreted by nodes[1] as violating the fee spike buffer. + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); + + // And this last payment previously resulted in nodes[1] closing on its inbound-channel + // counterparty, because it counted all the previous dust HTLCs against nodes[0]'s commitment + // transaction fee and therefore perceived this next payment as a channel reserve violation. + let (_, _) = route_payment(&nodes[0], &[&nodes[1]], payment_amt); +} + #[test] fn test_chan_reserve_violation_inbound_htlc_inbound_chan() { let chanmon_cfgs = create_chanmon_cfgs(3); @@ -1799,7 +1847,7 @@ fn test_chan_reserve_violation_inbound_htlc_inbound_chan() { let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap(); (route, payment_hash, payment_preimage) }} - }; + } let feemsat = 239; let total_routing_fee_msat = (nodes.len() - 2) as u64 * feemsat; @@ -1900,7 +1948,7 @@ fn test_channel_reserve_holding_cell_htlcs() { let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap(); (route, payment_hash, payment_preimage) }} - }; + } macro_rules! expect_forward { ($node: expr) => {{ @@ -2093,23 +2141,6 @@ fn test_channel_reserve_holding_cell_htlcs() { let commit_tx_fee_0_htlcs = 2*commit_tx_fee_msat(feerate, 1); let recv_value_3 = commit_tx_fee_2_htlcs - commit_tx_fee_0_htlcs - total_fee_msat; - { - let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_3 + 1); - let err = nodes[0].node.send_payment(&route, our_payment_hash, &None).err().unwrap(); - match err { - PaymentSendFailure::AllFailedRetrySafe(ref fails) => { - match &fails[0] { - &APIError::ChannelUnavailable{ref err} => - assert!(regex::Regex::new(r"Cannot send value that would put our balance under counterparty-announced channel reserve value \(\d+\)").unwrap().is_match(err)), - _ => panic!("Unexpected error variant"), - } - }, - _ => panic!("Unexpected error variant"), - } - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put our balance under counterparty-announced channel reserve value".to_string(), 3); - } - send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_3, recv_value_3); let commit_tx_fee_1_htlc = 2*commit_tx_fee_msat(feerate, 1 + 1); @@ -4655,122 +4686,26 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() { macro_rules! check_spendable_outputs { ($node: expr, $der_idx: expr, $keysinterface: expr, $chan_value: expr) => { { - let events = $node.chain_monitor.chain_monitor.get_and_clear_pending_events(); + let mut events = $node.chain_monitor.chain_monitor.get_and_clear_pending_events(); let mut txn = Vec::new(); - for event in events { + let mut all_outputs = Vec::new(); + let secp_ctx = Secp256k1::new(); + for event in events.drain(..) { match event { - Event::SpendableOutputs { ref outputs } => { - for outp in outputs { - match *outp { - SpendableOutputDescriptor::StaticOutputCounterpartyPayment { ref outpoint, ref output, ref channel_keys_id, channel_value_satoshis } => { - assert_eq!(channel_value_satoshis, $chan_value); - let input = TxIn { - previous_output: outpoint.into_bitcoin_outpoint(), - script_sig: Script::new(), - sequence: 0, - witness: Vec::new(), - }; - let outp = TxOut { - script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), - value: output.value, - }; - let mut spend_tx = Transaction { - version: 2, - lock_time: 0, - input: vec![input], - output: vec![outp], - }; - spend_tx.output[0].value -= (spend_tx.get_weight() + 2 + 1 + 73 + 35 + 3) as u64 / 4; // (Max weight + 3 (to round up)) / 4 - let secp_ctx = Secp256k1::new(); - let keys = $keysinterface.derive_channel_keys($chan_value, channel_keys_id); - let remotepubkey = keys.pubkeys().payment_point; - let witness_script = Address::p2pkh(&::bitcoin::PublicKey{compressed: true, key: remotepubkey}, Network::Testnet).script_pubkey(); - let sighash = Message::from_slice(&bip143::SigHashCache::new(&spend_tx).signature_hash(0, &witness_script, output.value, SigHashType::All)[..]).unwrap(); - let remotesig = secp_ctx.sign(&sighash, &keys.inner.payment_key); - spend_tx.input[0].witness.push(remotesig.serialize_der().to_vec()); - spend_tx.input[0].witness[0].push(SigHashType::All as u8); - spend_tx.input[0].witness.push(remotepubkey.serialize().to_vec()); - txn.push(spend_tx); - }, - SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref revocation_pubkey, ref channel_keys_id, channel_value_satoshis } => { - assert_eq!(channel_value_satoshis, $chan_value); - let input = TxIn { - previous_output: outpoint.into_bitcoin_outpoint(), - script_sig: Script::new(), - sequence: *to_self_delay as u32, - witness: Vec::new(), - }; - let outp = TxOut { - script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), - value: output.value, - }; - let mut spend_tx = Transaction { - version: 2, - lock_time: 0, - input: vec![input], - output: vec![outp], - }; - let secp_ctx = Secp256k1::new(); - let keys = $keysinterface.derive_channel_keys($chan_value, channel_keys_id); - if let Ok(delayed_payment_key) = chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &keys.inner.delayed_payment_base_key) { - - let delayed_payment_pubkey = PublicKey::from_secret_key(&secp_ctx, &delayed_payment_key); - let witness_script = chan_utils::get_revokeable_redeemscript(revocation_pubkey, *to_self_delay, &delayed_payment_pubkey); - spend_tx.output[0].value -= (spend_tx.get_weight() + 2 + 1 + 73 + 1 + witness_script.len() + 1 + 3) as u64 / 4; // (Max weight + 3 (to round up)) / 4 - let sighash = Message::from_slice(&bip143::SigHashCache::new(&spend_tx).signature_hash(0, &witness_script, output.value, SigHashType::All)[..]).unwrap(); - let local_delayedsig = secp_ctx.sign(&sighash, &delayed_payment_key); - spend_tx.input[0].witness.push(local_delayedsig.serialize_der().to_vec()); - spend_tx.input[0].witness[0].push(SigHashType::All as u8); - spend_tx.input[0].witness.push(vec!()); //MINIMALIF - spend_tx.input[0].witness.push(witness_script.clone().into_bytes()); - } else { panic!() } - txn.push(spend_tx); - }, - SpendableOutputDescriptor::StaticOutput { ref outpoint, ref output } => { - let secp_ctx = Secp256k1::new(); - let input = TxIn { - previous_output: outpoint.into_bitcoin_outpoint(), - script_sig: Script::new(), - sequence: 0, - witness: Vec::new(), - }; - let outp = TxOut { - script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), - value: output.value, - }; - let mut spend_tx = Transaction { - version: 2, - lock_time: 0, - input: vec![input], - output: vec![outp.clone()], - }; - spend_tx.output[0].value -= (spend_tx.get_weight() + 2 + 1 + 73 + 35 + 3) as u64 / 4; // (Max weight + 3 (to round up)) / 4 - let secret = { - match ExtendedPrivKey::new_master(Network::Testnet, &$node.node_seed) { - Ok(master_key) => { - match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx($der_idx).expect("key space exhausted")) { - Ok(key) => key, - Err(_) => panic!("Your RNG is busted"), - } - } - Err(_) => panic!("Your rng is busted"), - } - }; - let pubkey = ExtendedPubKey::from_private(&secp_ctx, &secret).public_key; - let witness_script = Address::p2pkh(&pubkey, Network::Testnet).script_pubkey(); - let sighash = Message::from_slice(&bip143::SigHashCache::new(&spend_tx).signature_hash(0, &witness_script, output.value, SigHashType::All)[..]).unwrap(); - let sig = secp_ctx.sign(&sighash, &secret.private_key.key); - spend_tx.input[0].witness.push(sig.serialize_der().to_vec()); - spend_tx.input[0].witness[0].push(SigHashType::All as u8); - spend_tx.input[0].witness.push(pubkey.key.serialize().to_vec()); - txn.push(spend_tx); - }, - } + Event::SpendableOutputs { mut outputs } => { + for outp in outputs.drain(..) { + txn.push($keysinterface.backing.spend_spendable_outputs(&[&outp], Vec::new(), Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), 253, &secp_ctx).unwrap()); + all_outputs.push(outp); } }, _ => panic!("Unexpected event"), }; } + if all_outputs.len() > 1 { + if let Ok(tx) = $keysinterface.backing.spend_spendable_outputs(&all_outputs.iter().map(|a| a).collect::>(), Vec::new(), Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(), 253, &secp_ctx) { + txn.push(tx); + } + } txn } } @@ -4860,9 +4795,10 @@ fn test_claim_on_remote_revoked_sizeable_push_msat() { connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1, 1, true, header.block_hash()); let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); - assert_eq!(spend_txn.len(), 2); + assert_eq!(spend_txn.len(), 3); check_spends!(spend_txn[0], revoked_local_txn[0]); // to_remote output on revoked remote commitment_tx check_spends!(spend_txn[1], node_txn[0]); + check_spends!(spend_txn[2], revoked_local_txn[0], node_txn[0]); // Both outputs } #[test] @@ -4957,8 +4893,10 @@ fn test_static_spendable_outputs_timeout_tx() { expect_payment_failed!(nodes[1], our_payment_hash, true); let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); - assert_eq!(spend_txn.len(), 2); // SpendableOutput: remote_commitment_tx.to_remote, timeout_tx.output + assert_eq!(spend_txn.len(), 3); // SpendableOutput: remote_commitment_tx.to_remote, timeout_tx.output + check_spends!(spend_txn[0], commitment_tx[0]); check_spends!(spend_txn[1], node_txn[0]); + check_spends!(spend_txn[2], node_txn[0], commitment_tx[0]); // All outputs } #[test] @@ -5135,11 +5073,12 @@ fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() { // Check A's ChannelMonitor was able to generate the right spendable output descriptor let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000); - assert_eq!(spend_txn.len(), 2); + assert_eq!(spend_txn.len(), 3); assert_eq!(spend_txn[0].input.len(), 1); check_spends!(spend_txn[0], revoked_local_txn[0]); // spending to_remote output from revoked local tx assert_ne!(spend_txn[0].input[0].previous_output, revoked_htlc_txn[0].input[0].previous_output); check_spends!(spend_txn[1], node_txn[1]); // spending justice tx output on the htlc success tx + check_spends!(spend_txn[2], revoked_local_txn[0], node_txn[1]); // Both outputs } #[test] @@ -5372,6 +5311,7 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() { let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000).0; let local_txn = get_local_commitment_txn!(nodes[1], chan_1.2); + assert_eq!(local_txn.len(), 1); assert_eq!(local_txn[0].input.len(), 1); check_spends!(local_txn[0], chan_1.3); @@ -5392,10 +5332,13 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() { } let node_txn = { let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); + assert_eq!(node_txn.len(), 3); + assert_eq!(node_txn[0], node_txn[2]); + assert_eq!(node_txn[1], local_txn[0]); assert_eq!(node_txn[0].input.len(), 1); assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT); check_spends!(node_txn[0], local_txn[0]); - vec![node_txn[0].clone(), node_txn[2].clone()] + vec![node_txn[0].clone()] }; let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.block_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 }; @@ -5404,9 +5347,8 @@ fn test_dynamic_spendable_outputs_local_htlc_success_tx() { // Verify that B is able to spend its own HTLC-Success tx thanks to spendable output event given back by its ChannelMonitor let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000); - assert_eq!(spend_txn.len(), 2); + assert_eq!(spend_txn.len(), 1); check_spends!(spend_txn[0], node_txn[0]); - check_spends!(spend_txn[1], node_txn[1]); } fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, announce_latest: bool) { @@ -5701,9 +5643,10 @@ fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() { // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000); - assert_eq!(spend_txn.len(), 2); + assert_eq!(spend_txn.len(), 3); check_spends!(spend_txn[0], local_txn[0]); check_spends!(spend_txn[1], htlc_timeout); + check_spends!(spend_txn[2], local_txn[0], htlc_timeout); } #[test] @@ -5771,9 +5714,10 @@ fn test_key_derivation_params() { // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor let new_keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet); let spend_txn = check_spendable_outputs!(nodes[0], 1, new_keys_manager, 100000); - assert_eq!(spend_txn.len(), 2); + assert_eq!(spend_txn.len(), 3); check_spends!(spend_txn[0], local_txn_1[0]); check_spends!(spend_txn[1], htlc_timeout); + check_spends!(spend_txn[2], local_txn_1[0], htlc_timeout); } #[test]