use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, MIN_CLTV_EXPIRY_DELTA};
use routing::gossip::RoutingFees;
use routing::router::{PaymentParameters, RouteHint, RouteHintHop};
-use ln::features::{InitFeatures, InvoiceFeatures};
+use ln::features::{InitFeatures, InvoiceFeatures, ChannelTypeFeatures};
use ln::msgs;
-use ln::msgs::{ChannelMessageHandler, RoutingMessageHandler, OptionalField, ChannelUpdate};
+use ln::msgs::{ChannelMessageHandler, RoutingMessageHandler, OptionalField, ChannelUpdate, ErrorAction};
use ln::wire::Encode;
use util::enforcing_trait_impls::EnforcingSigner;
use util::events::{ClosureReason, Event, MessageSendEvent, MessageSendEventsProvider};
// Previously, if the minium_depth config was set to 1, we'd never send a channel_ready. This
// tests that we properly send one in that case.
let mut alice_config = UserConfig::default();
- alice_config.own_channel_config.minimum_depth = 1;
- alice_config.channel_options.announced_channel = true;
- alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
+ alice_config.channel_handshake_config.minimum_depth = 1;
+ alice_config.channel_handshake_config.announced_channel = true;
+ alice_config.channel_handshake_limits.force_announced_channel_preference = false;
let mut bob_config = UserConfig::default();
- bob_config.own_channel_config.minimum_depth = 1;
- bob_config.channel_options.announced_channel = true;
- bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
+ bob_config.channel_handshake_config.minimum_depth = 1;
+ bob_config.channel_handshake_config.announced_channel = true;
+ bob_config.channel_handshake_limits.force_announced_channel_preference = false;
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, &[Some(alice_config), Some(bob_config)]);
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
let mut scid_privacy_cfg = test_default_channel_config();
- scid_privacy_cfg.channel_options.announced_channel = true;
- scid_privacy_cfg.own_channel_config.negotiate_scid_privacy = true;
+ scid_privacy_cfg.channel_handshake_config.announced_channel = true;
+ scid_privacy_cfg.channel_handshake_config.negotiate_scid_privacy = true;
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, Some(scid_privacy_cfg)).unwrap();
let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
let mut scid_privacy_cfg = test_default_channel_config();
- scid_privacy_cfg.channel_options.announced_channel = false;
- scid_privacy_cfg.own_channel_config.negotiate_scid_privacy = true;
+ scid_privacy_cfg.channel_handshake_config.announced_channel = false;
+ scid_privacy_cfg.channel_handshake_config.negotiate_scid_privacy = true;
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, Some(scid_privacy_cfg)).unwrap();
let init_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
let mut no_announce_cfg = test_default_channel_config();
- no_announce_cfg.channel_options.announced_channel = false;
- no_announce_cfg.own_channel_config.negotiate_scid_privacy = true;
+ no_announce_cfg.channel_handshake_config.announced_channel = false;
+ no_announce_cfg.channel_handshake_config.negotiate_scid_privacy = true;
nodes[1].node.create_channel(nodes[2].node.get_our_node_id(), 100_000, 10_000, 42, Some(no_announce_cfg)).unwrap();
let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[2].node.get_our_node_id());
nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false);
- expect_payment_failed_conditions!(nodes[0], payment_hash_2, false,
+ expect_payment_failed_conditions(&nodes[0], payment_hash_2, false,
PaymentFailedConditions::new().blamed_scid(last_hop[0].short_channel_id.unwrap())
.blamed_chan_closed(true).expected_htlc_error_data(0x4000|10, &[0; 0]));
}
short_channel_id: last_hop[0].inbound_scid_alias.unwrap(),
timestamp: 21,
flags: 1,
- cltv_expiry_delta: accept_forward_cfg.channel_options.cltv_expiry_delta,
+ cltv_expiry_delta: accept_forward_cfg.channel_config.cltv_expiry_delta,
htlc_minimum_msat: 1_000,
htlc_maximum_msat: OptionalField::Present(1_000_000), // Defaults to 10% of the channel value
fee_base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat,
err_data.extend_from_slice(&ChannelUpdate::TYPE.to_be_bytes());
err_data.extend_from_slice(&msg.encode());
- expect_payment_failed_conditions!(nodes[0], payment_hash, false,
+ expect_payment_failed_conditions(&nodes[0], payment_hash, false,
PaymentFailedConditions::new().blamed_scid(last_hop[0].inbound_scid_alias.unwrap())
.blamed_chan_closed(false).expected_htlc_error_data(0x1000|7, &err_data));
err_data.extend_from_slice(&(msg.serialized_length() as u16 + 2).to_be_bytes());
err_data.extend_from_slice(&ChannelUpdate::TYPE.to_be_bytes());
err_data.extend_from_slice(&msg.encode());
- expect_payment_failed_conditions!(nodes[0], payment_hash, false,
+ expect_payment_failed_conditions(&nodes[0], payment_hash, false,
PaymentFailedConditions::new().blamed_scid(last_hop[0].inbound_scid_alias.unwrap())
.blamed_chan_closed(false).expected_htlc_error_data(0x1000|12, &err_data));
}
create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0, InitFeatures::known(), InitFeatures::known());
- chan_config.channel_options.announced_channel = false;
+ chan_config.channel_handshake_config.announced_channel = false;
nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, Some(chan_config)).unwrap();
let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
// This is the default but we force it on anyway
- chan_config.channel_options.announced_channel = true;
+ chan_config.channel_handshake_config.announced_channel = true;
open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config));
// We can use the channel immediately, but won't generate a channel_update until we get confs
send_payment(&nodes[0], &[&nodes[1]], 100_000);
- nodes[0].node.force_close_all_channels();
+ nodes[0].node.force_close_all_channels_broadcasting_latest_txn();
check_added_monitors!(nodes[0], 1);
check_closed_event!(&nodes[0], 1, ClosureReason::HolderForceClosed);
let _ = get_err_msg!(nodes[0], nodes[1].node.get_our_node_id());
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
// This is the default but we force it on anyway
- chan_config.channel_options.announced_channel = true;
+ chan_config.channel_handshake_config.announced_channel = true;
let tx = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config));
// We can use the channel immediately, but we can't announce it until we get 6+ confirmations
let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
// This is the default but we force it on anyway
- chan_config.channel_options.announced_channel = true;
+ chan_config.channel_handshake_config.announced_channel = true;
let tx = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config));
// We can use the channel immediately, but we can't announce it until we get 6+ confirmations
});
check_closed_broadcast!(nodes[1], true);
}
+
+#[test]
+fn test_zero_conf_accept_reject() {
+ let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key();
+ channel_type_features.set_zero_conf_required();
+
+ // 1. Check we reject zero conf channels by default
+ 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);
+
+ nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
+ let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
+
+ open_channel_msg.channel_type = Some(channel_type_features.clone());
+
+ nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &open_channel_msg);
+
+ let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
+ match msg_events[0] {
+ MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg, .. }, .. } => {
+ assert_eq!(msg.data, "No zero confirmation channels accepted".to_owned());
+ },
+ _ => panic!(),
+ }
+
+ // 2. Check we can manually accept zero conf channels via the right method
+ let mut manually_accept_conf = UserConfig::default();
+ manually_accept_conf.manually_accept_inbound_channels = true;
+
+ 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, Some(manually_accept_conf.clone())]);
+ let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+ // 2.1 First try the non-0conf method to manually accept
+ nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42,
+ Some(manually_accept_conf)).unwrap();
+ let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel,
+ nodes[1].node.get_our_node_id());
+
+ open_channel_msg.channel_type = Some(channel_type_features.clone());
+
+ nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(),
+ &open_channel_msg);
+
+ // Assert that `nodes[1]` has no `MessageSendEvent::SendAcceptChannel` in the `msg_events`.
+ assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
+
+ let events = nodes[1].node.get_and_clear_pending_events();
+
+ match events[0] {
+ Event::OpenChannelRequest { temporary_channel_id, .. } => {
+ // Assert we fail to accept via the non-0conf method
+ assert!(nodes[1].node.accept_inbound_channel(&temporary_channel_id,
+ &nodes[0].node.get_our_node_id(), 0).is_err());
+ },
+ _ => panic!(),
+ }
+
+ let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
+ match msg_events[0] {
+ MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg, .. }, .. } => {
+ assert_eq!(msg.data, "No zero confirmation channels accepted".to_owned());
+ },
+ _ => panic!(),
+ }
+
+ // 2.2 Try again with the 0conf method to manually accept
+ nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42,
+ Some(manually_accept_conf)).unwrap();
+ let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel,
+ nodes[1].node.get_our_node_id());
+
+ open_channel_msg.channel_type = Some(channel_type_features);
+
+ nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(),
+ &open_channel_msg);
+
+ let events = nodes[1].node.get_and_clear_pending_events();
+
+ match events[0] {
+ Event::OpenChannelRequest { temporary_channel_id, .. } => {
+ // Assert we can accept via the 0conf method
+ assert!(nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(
+ &temporary_channel_id, &nodes[0].node.get_our_node_id(), 0).is_ok());
+ },
+ _ => panic!(),
+ }
+
+ // Check we would send accept
+ let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
+ match msg_events[0] {
+ MessageSendEvent::SendAcceptChannel { .. } => {},
+ _ => panic!(),
+ }
+}