Shakedown zero reserve channels

Author: tankyleo

lightning/src/ln/functional_test_utils.rs

@@ -1602,6 +1602,109 @@ pub fn exchange_open_accept_zero_conf_chan<'a, 'b, 'c, 'd>(
 	accept_channel.common_fields.temporary_channel_id
 }
 
+pub fn exchange_open_accept_zero_reserve_chan<'a, 'b, 'c, 'd>(
+	initiator: &'a Node<'b, 'c, 'd>, receiver: &'a Node<'b, 'c, 'd>, channel_value_sat: u64,
+	push_msat: u64,
+) -> ChannelId {
+	let receiver_node_id = receiver.node.get_our_node_id();
+	let initiator_node_id = initiator.node.get_our_node_id();
+
+	initiator
+		.node
+		.create_channel(receiver_node_id, channel_value_sat, push_msat, 42, None, None)
+		.unwrap();
+	let open_channel =
+		get_event_msg!(initiator, MessageSendEvent::SendOpenChannel, receiver_node_id);
+
+	receiver.node.handle_open_channel(initiator_node_id, &open_channel);
+	let events = receiver.node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	match events[0] {
+		Event::OpenChannelRequest { temporary_channel_id, .. } => {
+			receiver
+				.node
+				.accept_inbound_channel_from_trusted_peer(
+					&temporary_channel_id,
+					&initiator_node_id,
+					0,
+					false,
+					true,
+					None,
+				)
+				.unwrap();
+		},
+		_ => panic!("Unexpected event"),
+	};
+
+	let accept_channel =
+		get_event_msg!(receiver, MessageSendEvent::SendAcceptChannel, initiator_node_id);
+	assert_eq!(accept_channel.channel_reserve_satoshis, 0);
+	initiator.node.handle_accept_channel(receiver_node_id, &accept_channel);
+
+	accept_channel.common_fields.temporary_channel_id
+}
+
+pub fn create_zero_reserve_chan_between_nodes_with_value_init<'a, 'b, 'c>(
+	node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, channel_value: u64, push_msat: u64,
+) -> Transaction {
+	let create_chan_id =
+		exchange_open_accept_zero_reserve_chan(node_a, node_b, channel_value, push_msat);
+	sign_funding_transaction(node_a, node_b, channel_value, create_chan_id)
+}
+
+pub fn create_zero_reserve_chan_between_nodes_with_value_a<'a, 'b, 'c: 'd, 'd>(
+	node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, channel_value: u64, push_msat: u64,
+) -> ((msgs::ChannelReady, msgs::AnnouncementSignatures), ChannelId, Transaction) {
+	let tx = create_zero_reserve_chan_between_nodes_with_value_init(
+		node_a,
+		node_b,
+		channel_value,
+		push_msat,
+	);
+	let (msgs, chan_id) = create_chan_between_nodes_with_value_confirm(node_a, node_b, &tx);
+	(msgs, chan_id, tx)
+}
+
+pub fn create_zero_reserve_chan_between_nodes_with_value<'a, 'b, 'c: 'd, 'd>(
+	node_a: &'a Node<'b, 'c, 'd>, node_b: &'a Node<'b, 'c, 'd>, channel_value: u64, push_msat: u64,
+) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) {
+	let (channel_ready, channel_id, tx) = create_zero_reserve_chan_between_nodes_with_value_a(
+		node_a,
+		node_b,
+		channel_value,
+		push_msat,
+	);
+	let (announcement, as_update, bs_update) =
+		create_chan_between_nodes_with_value_b(node_a, node_b, &channel_ready);
+	(announcement, as_update, bs_update, channel_id, tx)
+}
+
+pub fn create_announced_zero_reserve_chan_between_nodes_with_value<'a, 'b, 'c: 'd, 'd>(
+	nodes: &'a Vec<Node<'b, 'c, 'd>>, a: usize, b: usize, channel_value: u64, push_msat: u64,
+) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) {
+	let chan_announcement = create_zero_reserve_chan_between_nodes_with_value(
+		&nodes[a],
+		&nodes[b],
+		channel_value,
+		push_msat,
+	);
+	update_nodes_with_chan_announce(
+		nodes,
+		a,
+		b,
+		&chan_announcement.0,
+		&chan_announcement.1,
+		&chan_announcement.2,
+	);
+	(chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4)
+}
+
+pub fn create_announced_zero_reserve_chan_between_nodes<'a, 'b, 'c: 'd, 'd>(
+	nodes: &'a Vec<Node<'b, 'c, 'd>>, a: usize, b: usize,
+) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, ChannelId, Transaction) {
+	create_announced_zero_reserve_chan_between_nodes_with_value(nodes, a, b, 100000, 10001)
+}
+
 // Receiver must have been initialized with manually_accept_inbound_channels set to true.
 pub fn open_zero_conf_channel_with_value<'a, 'b, 'c, 'd>(
 	initiator: &'a Node<'b, 'c, 'd>, receiver: &'a Node<'b, 'c, 'd>,

lightning/src/ln/htlc_reserve_unit_tests.rs

@@ -14,7 +14,7 @@ use crate::ln::functional_test_utils::*;
 use crate::ln::msgs::{self, BaseMessageHandler, ChannelMessageHandler, MessageSendEvent};
 use crate::ln::onion_utils::{self, AttributionData};
 use crate::ln::outbound_payment::RecipientOnionFields;
-use crate::routing::router::PaymentParameters;
+use crate::routing::router::{PaymentParameters, RouteParameters};
 use crate::sign::ecdsa::EcdsaChannelSigner;
 use crate::sign::tx_builder::{SpecTxBuilder, TxBuilder};
 use crate::types::features::ChannelTypeFeatures;
@@ -2431,3 +2431,170 @@ pub fn do_test_dust_limit_fee_accounting(can_afford: bool) {
 		check_added_monitors(&nodes[1], 3);
 	}
 }
+
+#[test]
+fn test_create_channel_to_trusted_peer() {
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let mut config = test_default_channel_config();
+	config.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 100;
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(config), None]);
+	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+	let node_a_id = nodes[0].node.get_our_node_id();
+	let node_b_id = nodes[1].node.get_our_node_id();
+
+	let feerate_per_kw = 253;
+	let channel_type_features = ChannelTypeFeatures::only_static_remote_key();
+
+	let default_config = UserConfig::default();
+
+	let mut push_amt = 100_000_000;
+	push_amt -= chan_utils::commit_tx_fee_sat(
+		feerate_per_kw,
+		MIN_AFFORDABLE_HTLC_COUNT,
+		&channel_type_features,
+	) * 1000;
+	push_amt -= get_holder_selected_channel_reserve_satoshis(100_000, &default_config) * 1000;
+
+	let temp_channel_id = nodes[0]
+		.node
+		.create_channel_to_trusted_peer(node_b_id, 100_000, push_amt, 42, None, None)
+		.unwrap();
+	let mut open_channel_message =
+		get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id);
+
+	nodes[1].node.handle_open_channel(node_a_id, &open_channel_message);
+
+	let mut accept_channel_message =
+		get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id);
+
+	nodes[0].node.handle_accept_channel(node_b_id, &accept_channel_message);
+
+	let funding_tx = sign_funding_transaction(&nodes[0], &nodes[1], 100_000, temp_channel_id);
+	let funding_msgs =
+		create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &funding_tx);
+	create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_msgs.0);
+
+	send_payment(&nodes[1], &[&nodes[0]], push_amt);
+}
+
+#[test]
+fn test_accept_inbound_channel_from_trusted_peer_0reserve() {
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let mut config = test_default_channel_config();
+	config.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 100;
+	config.manually_accept_inbound_channels = true;
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(config)]);
+	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+	let initial_channel_value_sat = 100_000;
+	let (_, _, chan_id, _) = create_announced_zero_reserve_chan_between_nodes_with_value(
+		&nodes,
+		0,
+		1,
+		initial_channel_value_sat,
+		0,
+	);
+
+	let channel_type = ChannelTypeFeatures::only_static_remote_key();
+
+	let delta = chan_utils::commit_tx_fee_sat(
+		253 * FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE as u32,
+		2,
+		&channel_type,
+	);
+
+	let _ = send_payment(&nodes[0], &[&nodes[1]], (100_000 - delta) * 1000);
+
+	{
+		let per_peer_state_lock;
+		let mut peer_state_lock;
+		let chan =
+			get_channel_ref!(nodes[1], nodes[0], per_peer_state_lock, peer_state_lock, chan_id);
+		assert_eq!(chan.funding().holder_selected_channel_reserve_satoshis, 0);
+	}
+}
+
+#[test]
+fn test_zero_reserve_no_outputs() {
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let mut config = test_default_channel_config();
+	config.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = 100;
+	config.manually_accept_inbound_channels = true;
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(config)]);
+	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+	let channel_type = ChannelTypeFeatures::only_static_remote_key();
+
+	let node_a_id = nodes[0].node.get_our_node_id();
+	let node_b_id = nodes[1].node.get_our_node_id();
+
+	nodes[0].node.create_channel(node_b_id, 1000 + 2, 0, 42, None, None).unwrap();
+	let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id);
+	open_channel.common_fields.max_htlc_value_in_flight_msat = 1_000_000;
+	open_channel.common_fields.dust_limit_satoshis = 546;
+	nodes[1].node.handle_open_channel(node_a_id, &open_channel);
+	let events = nodes[1].node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	match events[0] {
+		Event::OpenChannelRequest { temporary_channel_id: chan_id, .. } => {
+			nodes[1]
+				.node
+				.accept_inbound_channel_from_trusted_peer(
+					&chan_id, &node_a_id, 0, false, true, None,
+				)
+				.unwrap();
+		},
+		_ => panic!("Unexpected event"),
+	};
+
+	nodes[0].node.handle_accept_channel(
+		node_b_id,
+		&get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id),
+	);
+
+	let (chan_id, tx, _) = create_funding_transaction(&nodes[0], &node_b_id, 1000 + 2, 42);
+
+	{
+		let mut per_peer_lock;
+		let mut peer_state_lock;
+		let channel = get_channel_ref!(nodes[0], nodes[1], per_peer_lock, peer_state_lock, chan_id);
+		if let Some(mut chan) = channel.as_unfunded_outbound_v1_mut() {
+			chan.context.holder_dust_limit_satoshis = 546;
+		} else {
+			panic!("Unexpected Channel phase");
+		}
+	}
+
+	nodes[0].node.funding_transaction_generated(chan_id, node_b_id, tx.clone()).unwrap();
+	nodes[1].node.handle_funding_created(
+		node_a_id,
+		&get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id),
+	);
+	check_added_monitors(&nodes[1], 1);
+	expect_channel_pending_event(&nodes[1], &node_a_id);
+
+	nodes[0].node.handle_funding_signed(
+		node_b_id,
+		&get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, node_a_id),
+	);
+	check_added_monitors(&nodes[0], 1);
+	expect_channel_pending_event(&nodes[0], &node_b_id);
+
+	let (channel_ready, _channel_id) =
+		create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
+	let (announcement, as_update, bs_update) =
+		create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready);
+	update_nodes_with_chan_announce(&nodes, 0, 1, &announcement, &as_update, &bs_update);
+
+	let delta = chan_utils::commit_tx_fee_sat(253 * 2, 2, &channel_type);
+	//let _ = send_payment(&nodes[0], &[&nodes[1]], delta * 1000);
+
+	let payment_params =
+		PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(), TEST_FINAL_CLTV);
+
+	let route_params = RouteParameters::from_payment_params_and_value(payment_params, delta * 1000);
+	assert!(get_route(&nodes[0], &route_params).is_err());
+}