X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fshutdown_tests.rs;h=a40ad23761e36853015a8284e42ed6cbbcbad36d;hb=f60da31e56cab7713119be1658d4204b054a30d2;hp=a4dd3a0781a98aff618d84dc3d9548e1ba3179ef;hpb=5712de2da0d4591b96b2e5b5d1e7bd68c30c6ad5;p=rust-lightning diff --git a/lightning/src/ln/shutdown_tests.rs b/lightning/src/ln/shutdown_tests.rs index a4dd3a07..a40ad237 100644 --- a/lightning/src/ln/shutdown_tests.rs +++ b/lightning/src/ln/shutdown_tests.rs @@ -726,3 +726,203 @@ fn test_invalid_shutdown_script() { } check_added_monitors!(nodes[0], 1); } + +#[derive(PartialEq)] +enum TimeoutStep { + AfterShutdown, + AfterClosingSigned, + NoTimeout, +} + +fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) { + // The range-based closing signed negotiation allows the funder to restart the process with a + // new range if the previous range did not overlap. This allows implementations to request user + // intervention allowing users to enter a new fee range. We do not implement the sending side + // of this, instead opting to allow users to enter an explicit "willing to pay up to X to avoid + // force-closing" value and relying on that instead. + // + // Here we run test the fundee side of that restart mechanism, implementing the funder side of + // it manually. + 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]); + let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2; + + send_payment(&nodes[0], &[&nodes[1]], 8_000_000); + + nodes[0].node.close_channel(&chan_id).unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); + nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown); + + { + // Now we set nodes[1] to require a relatively high feerate for closing. This should result + // in it rejecting nodes[0]'s initial closing_signed, giving nodes[0] a chance to try + // again. + let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap(); + *feerate_lock *= 10; + } + + let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); + // nodes[0] should use a "reasonable" feerate, well under the 10 sat/vByte that nodes[1] thinks + // is the current prevailing feerate. + assert!(node_0_closing_signed.fee_satoshis <= 500); + + if timeout_step != TimeoutStep::AfterShutdown { + nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed); + // At this point nodes[1] should send back a warning message indicating it disagrees with the + // given channel-closing fee. Currently we do not implement warning messages so instead we + // remain silent here. + assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + + // Now deliver a mutated closing_signed indicating a higher acceptable fee range, which + // nodes[1] should happily accept and respond to. + node_0_closing_signed.fee_range.as_mut().unwrap().max_fee_satoshis *= 10; + { + let mut lock; + get_channel_ref!(nodes[0], lock, chan_id).closing_fee_limits.as_mut().unwrap().1 *= 10; + } + nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed); + let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); + nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed); + let node_0_2nd_closing_signed = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); + if timeout_step == TimeoutStep::NoTimeout { + nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.1.unwrap()); + } + } + + if timeout_step != TimeoutStep::NoTimeout { + assert!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty()); + } else { + assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); + } + + nodes[1].node.timer_tick_occurred(); + nodes[1].node.timer_tick_occurred(); + + let txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); + assert_eq!(txn.len(), 1); + assert_eq!(txn[0].output.len(), 2); + + if timeout_step != TimeoutStep::NoTimeout { + assert!((txn[0].output[0].script_pubkey.is_v0_p2wpkh() && + txn[0].output[1].script_pubkey.is_v0_p2wsh()) || + (txn[0].output[1].script_pubkey.is_v0_p2wpkh() && + txn[0].output[0].script_pubkey.is_v0_p2wsh())); + check_closed_broadcast!(nodes[1], true); + check_added_monitors!(nodes[1], 1); + } else { + assert!(txn[0].output[0].script_pubkey.is_v0_p2wpkh()); + assert!(txn[0].output[1].script_pubkey.is_v0_p2wpkh()); + + let events = nodes[1].node.get_and_clear_pending_msg_events(); + assert_eq!(events.len(), 1); + match events[0] { + MessageSendEvent::BroadcastChannelUpdate { ref msg } => { + assert_eq!(msg.contents.flags & 2, 2); + }, + _ => panic!("Unexpected event"), + } + } +} + +#[test] +fn test_closing_signed_reinit_timeout() { + do_test_closing_signed_reinit_timeout(TimeoutStep::AfterShutdown); + do_test_closing_signed_reinit_timeout(TimeoutStep::AfterClosingSigned); + do_test_closing_signed_reinit_timeout(TimeoutStep::NoTimeout); +} + +fn do_simple_legacy_shutdown_test(high_initiator_fee: bool) { + // A simpe test of the legacy shutdown fee negotiation logic. + 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]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + + let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()); + + if high_initiator_fee { + // If high_initiator_fee is set, set nodes[0]'s feerate significantly higher. This + // shouldn't impact the flow at all given nodes[1] will happily accept the higher fee. + let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap(); + *feerate_lock *= 10; + } + + nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); + nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown); + + let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); + node_0_closing_signed.fee_range = None; + if high_initiator_fee { + assert!(node_0_closing_signed.fee_satoshis > 500); + } else { + assert!(node_0_closing_signed.fee_satoshis < 500); + } + + nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed); + let (_, mut node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + node_1_closing_signed.as_mut().unwrap().fee_range = None; + + nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()); + let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); + assert!(node_0_none.is_none()); +} + +#[test] +fn simple_legacy_shutdown_test() { + do_simple_legacy_shutdown_test(false); + do_simple_legacy_shutdown_test(true); +} + +#[test] +fn simple_target_feerate_shutdown() { + // Simple test of target in `close_channel_with_target_feerate`. + 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]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + + let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()); + let chan_id = OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(); + + nodes[0].node.close_channel_with_target_feerate(&chan_id, 253 * 10).unwrap(); + let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); + nodes[1].node.close_channel_with_target_feerate(&chan_id, 253 * 5).unwrap(); + let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + + nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown); + nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown); + + let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); + nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed); + let (_, node_1_closing_signed_opt) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); + let node_1_closing_signed = node_1_closing_signed_opt.unwrap(); + + // nodes[1] was passed a target which was larger than the current channel feerate, which it + // should ignore in favor of the channel fee, as there is no use demanding a minimum higher + // than what will be paid on a force-close transaction. Note that we have to consider rounding, + // so only check that we're within 10 sats. + assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis >= + node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 - 5); + assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis <= + node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 + 5); + + // Further, because nodes[0]'s target fee is larger than the `Normal` fee estimation plus our + // force-closure-avoidance buffer, min should equal max, and the nodes[1]-selected fee should + // be the nodes[0] only available fee. + assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, + node_0_closing_signed.fee_range.as_ref().unwrap().max_fee_satoshis); + assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, + node_0_closing_signed.fee_satoshis); + assert_eq!(node_0_closing_signed.fee_satoshis, node_1_closing_signed.fee_satoshis); + + nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed); + let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); + assert!(node_0_none.is_none()); +}