config override struct

Author: joostjager

fuzz/src/chanmon_consistency.rs

@@ -46,6 +46,7 @@ use lightning::events;
 use lightning::events::MessageSendEventsProvider;
 use lightning::ln::channel::FEE_SPIKE_BUFFER_FEE_INCREASE_MULTIPLE;
 use lightning::ln::channel_state::ChannelDetails;
+use lightning::ln::channelmanager::InboundChannelConfigOverrides;
 use lightning::ln::channelmanager::{
 	ChainParameters, ChannelManager, ChannelManagerReadArgs, PaymentId, RecentPaymentDetails,
 	RecipientOnionFields,
@@ -809,6 +810,7 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 								temporary_channel_id,
 								counterparty_node_id,
 								user_channel_id,
+								InboundChannelConfigOverrides::default(),
 							)
 							.unwrap();
 					} else {

lightning/src/ln/async_signer_tests.rs

@@ -23,7 +23,7 @@ use crate::events::bump_transaction::WalletSource;
 use crate::events::{ClosureReason, Event, MessageSendEvent, MessageSendEventsProvider};
 use crate::ln::chan_utils::ClosingTransaction;
 use crate::ln::channel_state::{ChannelDetails, ChannelShutdownState};
-use crate::ln::channelmanager::{PaymentId, RAACommitmentOrder, RecipientOnionFields};
+use crate::ln::channelmanager::{InboundChannelConfigOverrides, PaymentId, RAACommitmentOrder, RecipientOnionFields};
 use crate::ln::msgs::ChannelMessageHandler;
 use crate::ln::{functional_test_utils::*, msgs};
 use crate::sign::ecdsa::EcdsaChannelSigner;
@@ -74,7 +74,7 @@ fn do_test_open_channel(zero_conf: bool) {
 		match &events[0] {
 			Event::OpenChannelRequest { temporary_channel_id, .. } => {
 				nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(
-					temporary_channel_id, &nodes[0].node.get_our_node_id(), 0)
+					temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, InboundChannelConfigOverrides::default())
 					.expect("Unable to accept inbound zero-conf channel");
 			},
 			ev => panic!("Expected OpenChannelRequest, not {:?}", ev)
@@ -319,7 +319,7 @@ fn do_test_funding_signed_0conf(signer_ops: Vec<SignerOp>) {
 		match &events[0] {
 			Event::OpenChannelRequest { temporary_channel_id, .. } => {
 				nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(
-					temporary_channel_id, &nodes[0].node.get_our_node_id(), 0)
+					temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, InboundChannelConfigOverrides::default())
 					.expect("Unable to accept inbound zero-conf channel");
 			},
 			ev => panic!("Expected OpenChannelRequest, not {:?}", ev)

lightning/src/ln/chanmon_update_fail_tests.rs

@@ -18,7 +18,7 @@ use bitcoin::network::Network;
 use crate::chain::channelmonitor::{ANTI_REORG_DELAY, ChannelMonitor};
 use crate::chain::{ChannelMonitorUpdateStatus, Listen, Watch};
 use crate::events::{Event, MessageSendEvent, MessageSendEventsProvider, PaymentPurpose, ClosureReason, HTLCDestination};
-use crate::ln::channelmanager::{PaymentId, RAACommitmentOrder, RecipientOnionFields};
+use crate::ln::channelmanager::{InboundChannelConfigOverrides, PaymentId, RAACommitmentOrder, RecipientOnionFields};
 use crate::ln::channel::AnnouncementSigsState;
 use crate::ln::msgs;
 use crate::ln::types::ChannelId;
@@ -2775,9 +2775,9 @@ fn do_test_outbound_reload_without_init_mon(use_0conf: bool) {
 	match events[0] {
 		Event::OpenChannelRequest { temporary_channel_id, .. } => {
 			if use_0conf {
-				nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0).unwrap();
+				nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, InboundChannelConfigOverrides::default()).unwrap();
 			} else {
-				nodes[1].node.accept_inbound_channel(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0).unwrap();
+				nodes[1].node.accept_inbound_channel(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, InboundChannelConfigOverrides::default()).unwrap();
 			}
 		},
 		_ => panic!("Unexpected event"),
@@ -2866,9 +2866,9 @@ fn do_test_inbound_reload_without_init_mon(use_0conf: bool, lock_commitment: boo
 	match events[0] {
 		Event::OpenChannelRequest { temporary_channel_id, .. } => {
 			if use_0conf {
-				nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0).unwrap();
+				nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, InboundChannelConfigOverrides::default()).unwrap();
 			} else {
-				nodes[1].node.accept_inbound_channel(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0).unwrap();
+				nodes[1].node.accept_inbound_channel(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, InboundChannelConfigOverrides::default()).unwrap();
 			}
 		},
 		_ => panic!("Unexpected event"),

lightning/src/ln/channelmanager.rs

@@ -132,6 +132,18 @@ pub use crate::ln::outbound_payment::{Bolt12PaymentError, ProbeSendFailure, Retr
 pub(crate) use crate::ln::outbound_payment::PaymentSendFailure;
 use crate::ln::script::ShutdownScript;
 
+
+/// Config structure for overriding incoming channel configuration parameters.
+#[derive(Default)]
+pub struct InboundChannelConfigOverrides {
+	max_inbound_htlc_value_in_flight_percent_of_channel: Option<u8>,
+	htlc_minimum_msat: Option<u64>,
+	minimum_depth: Option<u32>,
+	to_self_delay: Option<u16>,
+	max_accepted_htlcs: Option<u16>,
+	channel_reserve_proportional_millionths: Option<u32>
+}
+
 // We hold various information about HTLC relay in the HTLC objects in Channel itself:
 //
 // Upon receipt of an HTLC from a peer, we'll give it a PendingHTLCStatus indicating if it should
@@ -1851,7 +1863,7 @@ where
 ///
 /// ```
 /// # use bitcoin::secp256k1::PublicKey;
-/// # use lightning::ln::channelmanager::AChannelManager;
+/// # use lightning::ln::channelmanager::{AChannelManager, InboundChannelConfigOverride};
 /// # use lightning::events::{Event, EventsProvider};
 /// #
 /// # fn is_trusted(counterparty_node_id: PublicKey) -> bool {
@@ -1877,7 +1889,7 @@ where
 ///
 ///             let user_channel_id = 43;
 ///             match channel_manager.accept_inbound_channel(
-///                 &temporary_channel_id, &counterparty_node_id, user_channel_id
+///                 &temporary_channel_id, &counterparty_node_id, user_channel_id, InboundChannelConfigOverride::default()
 ///             ) {
 ///                 Ok(()) => println!("Accepting channel {}", temporary_channel_id),
 ///                 Err(e) => println!("Error accepting channel {}: {:?}", temporary_channel_id, e),
@@ -7699,8 +7711,8 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 	///
 	/// [`Event::OpenChannelRequest`]: events::Event::OpenChannelRequest
 	/// [`Event::ChannelClosed::user_channel_id`]: events::Event::ChannelClosed::user_channel_id
-	pub fn accept_inbound_channel(&self, temporary_channel_id: &ChannelId, counterparty_node_id: &PublicKey, user_channel_id: u128) -> Result<(), APIError> {
-		self.do_accept_inbound_channel(temporary_channel_id, counterparty_node_id, false, user_channel_id, vec![], Weight::from_wu(0))
+	pub fn accept_inbound_channel(&self, temporary_channel_id: &ChannelId, counterparty_node_id: &PublicKey, user_channel_id: u128, config_overrides: InboundChannelConfigOverrides) -> Result<(), APIError> {
+		self.do_accept_inbound_channel(temporary_channel_id, counterparty_node_id, false, user_channel_id, vec![], Weight::from_wu(0), config_overrides)
 	}
 
 	/// Accepts a request to open a channel after a [`events::Event::OpenChannelRequest`], treating
@@ -7721,15 +7733,42 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 	///
 	/// [`Event::OpenChannelRequest`]: events::Event::OpenChannelRequest
 	/// [`Event::ChannelClosed::user_channel_id`]: events::Event::ChannelClosed::user_channel_id
-	pub fn accept_inbound_channel_from_trusted_peer_0conf(&self, temporary_channel_id: &ChannelId, counterparty_node_id: &PublicKey, user_channel_id: u128) -> Result<(), APIError> {
-		self.do_accept_inbound_channel(temporary_channel_id, counterparty_node_id, true, user_channel_id, vec![], Weight::from_wu(0))
+	pub fn accept_inbound_channel_from_trusted_peer_0conf(&self, temporary_channel_id: &ChannelId, counterparty_node_id: &PublicKey, user_channel_id: u128, config_overrides: InboundChannelConfigOverrides) -> Result<(), APIError> {
+		self.do_accept_inbound_channel(temporary_channel_id, counterparty_node_id, true, user_channel_id, vec![], Weight::from_wu(0), config_overrides)
 	}
 
 	fn do_accept_inbound_channel(
 		&self, temporary_channel_id: &ChannelId, counterparty_node_id: &PublicKey, accept_0conf: bool,
 		user_channel_id: u128, _funding_inputs: Vec<(TxIn, TransactionU16LenLimited)>,
-		_total_witness_weight: Weight,
+		_total_witness_weight: Weight, config_overrides: InboundChannelConfigOverrides
 	) -> Result<(), APIError> {
+
+		// Apply configuration overrides.
+		let mut config = self.default_configuration.clone();
+		if let Some(max_in_flight_percent) = config_overrides.max_inbound_htlc_value_in_flight_percent_of_channel {
+			config.channel_handshake_config.max_inbound_htlc_value_in_flight_percent_of_channel = max_in_flight_percent;
+		}
+
+		if let Some(htlc_minimum_msat) = config_overrides.htlc_minimum_msat {
+			config.channel_handshake_config.our_htlc_minimum_msat = htlc_minimum_msat;
+		}
+
+		if let Some(minimum_depth) = config_overrides.minimum_depth {
+			config.channel_handshake_config.minimum_depth = minimum_depth;
+		}
+
+		if let Some(to_self_delay) = config_overrides.to_self_delay {
+			config.channel_handshake_config.our_to_self_delay = to_self_delay;
+		}
+
+		if let Some(max_accepted_htlcs) = config_overrides.max_accepted_htlcs {
+			config.channel_handshake_config.our_max_accepted_htlcs = max_accepted_htlcs;
+		}
+
+		if let Some(channel_reserve) = config_overrides.channel_reserve_proportional_millionths {
+			config.channel_handshake_config.their_channel_reserve_proportional_millionths = channel_reserve;
+		}
+
 		let logger = WithContext::from(&self.logger, Some(*counterparty_node_id), Some(*temporary_channel_id), None);
 		let _persistence_guard = PersistenceNotifierGuard::notify_on_drop(self);
 
@@ -7759,7 +7798,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 						InboundV1Channel::new(
 							&self.fee_estimator, &self.entropy_source, &self.signer_provider, *counterparty_node_id,
 							&self.channel_type_features(), &peer_state.latest_features, &open_channel_msg,
-							user_channel_id, &self.default_configuration, best_block_height, &self.logger, accept_0conf
+							user_channel_id, &config, best_block_height, &self.logger, accept_0conf
 						).map_err(|err| MsgHandleErrInternal::from_chan_no_close(err, *temporary_channel_id)
 						).map(|mut channel| {
 							let logger = WithChannelContext::from(&self.logger, &channel.context, None);
@@ -14478,9 +14517,9 @@ mod tests {
 	use crate::events::{Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider, ClosureReason};
 	use crate::ln::types::ChannelId;
 	use crate::types::payment::{PaymentPreimage, PaymentHash, PaymentSecret};
-	use crate::ln::channelmanager::{create_recv_pending_htlc_info, HTLCForwardInfo, inbound_payment, PaymentId, RecipientOnionFields, InterceptId};
+	use crate::ln::channelmanager::{create_recv_pending_htlc_info, inbound_payment, InboundChannelConfigOverrides, HTLCForwardInfo, InterceptId, PaymentId, RecipientOnionFields};
 	use crate::ln::functional_test_utils::*;
-	use crate::ln::msgs::{self, ErrorAction};
+	use crate::ln::msgs::{self, AcceptChannel, ErrorAction};
 	use crate::ln::msgs::ChannelMessageHandler;
 	use crate::ln::outbound_payment::Retry;
 	use crate::prelude::*;
@@ -15237,7 +15276,7 @@ mod tests {
 		// Test the API functions.
 		check_not_connected_to_peer_error(nodes[0].node.create_channel(unkown_public_key, 1_000_000, 500_000_000, 42, None, None), unkown_public_key);
 
-		check_unkown_peer_error(nodes[0].node.accept_inbound_channel(&channel_id, &unkown_public_key, 42), unkown_public_key);
+		check_unkown_peer_error(nodes[0].node.accept_inbound_channel(&channel_id, &unkown_public_key, 42, InboundChannelConfigOverrides::default()), unkown_public_key);
 
 		check_unkown_peer_error(nodes[0].node.close_channel(&channel_id, &unkown_public_key), unkown_public_key);
 
@@ -15268,7 +15307,7 @@ mod tests {
 		let error_message = "Channel force-closed";
 
 		// Test the API functions.
-		check_api_misuse_error(nodes[0].node.accept_inbound_channel(&channel_id, &counterparty_node_id, 42));
+		check_api_misuse_error(nodes[0].node.accept_inbound_channel(&channel_id, &counterparty_node_id, 42, InboundChannelConfigOverrides::default()));
 
 		check_channel_unavailable_error(nodes[0].node.close_channel(&channel_id, &counterparty_node_id), channel_id, counterparty_node_id);
 
@@ -15459,7 +15498,7 @@ mod tests {
 			let events = nodes[1].node.get_and_clear_pending_events();
 			match events[0] {
 				Event::OpenChannelRequest { temporary_channel_id, .. } => {
-					nodes[1].node.accept_inbound_channel(&temporary_channel_id, &random_pk, 23).unwrap();
+					nodes[1].node.accept_inbound_channel(&temporary_channel_id, &random_pk, 23, InboundChannelConfigOverrides::default()).unwrap();
 				}
 				_ => panic!("Unexpected event"),
 			}
@@ -15477,7 +15516,7 @@ mod tests {
 		let events = nodes[1].node.get_and_clear_pending_events();
 		match events[0] {
 			Event::OpenChannelRequest { temporary_channel_id, .. } => {
-				match nodes[1].node.accept_inbound_channel(&temporary_channel_id, &last_random_pk, 23) {
+				match nodes[1].node.accept_inbound_channel(&temporary_channel_id, &last_random_pk, 23, InboundChannelConfigOverrides::default()) {
 					Err(APIError::APIMisuseError { err }) =>
 						assert_eq!(err, "Too many peers with unfunded channels, refusing to accept new ones"),
 					_ => panic!(),
@@ -15493,7 +15532,7 @@ mod tests {
 		let events = nodes[1].node.get_and_clear_pending_events();
 		match events[0] {
 			Event::OpenChannelRequest { temporary_channel_id, .. } => {
-				nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &last_random_pk, 23).unwrap();
+				nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &last_random_pk, 23, InboundChannelConfigOverrides::default()).unwrap();
 			}
 			_ => panic!("Unexpected event"),
 		}
@@ -15573,6 +15612,30 @@ mod tests {
 
 	#[test]
 	fn test_inbound_anchors_manual_acceptance() {
+		test_inbound_anchors_manual_acceptance_with_override(InboundChannelConfigOverrides::default());
+	}
+
+	#[test]
+	fn test_inbound_anchors_manual_acceptance_overridden() {
+		let overrides = InboundChannelConfigOverrides {
+			max_inbound_htlc_value_in_flight_percent_of_channel: Some(5),
+			htlc_minimum_msat: Some(1000),
+			minimum_depth: Some(2),
+			to_self_delay: Some(200),
+			max_accepted_htlcs: Some(5),
+			channel_reserve_proportional_millionths: Some(20000),
+		};
+
+		let accept_message = test_inbound_anchors_manual_acceptance_with_override(overrides);
+		assert_eq!(accept_message.common_fields.max_htlc_value_in_flight_msat, 5_000_000);
+		assert_eq!(accept_message.common_fields.htlc_minimum_msat, 1_000);
+		assert_eq!(accept_message.common_fields.minimum_depth, 2);
+		assert_eq!(accept_message.common_fields.to_self_delay, 200);
+		assert_eq!(accept_message.common_fields.max_accepted_htlcs, 5);
+		assert_eq!(accept_message.channel_reserve_satoshis, 2_000);
+	}
+
+	fn test_inbound_anchors_manual_acceptance_with_override(config_overrides: InboundChannelConfigOverrides) -> AcceptChannel {
 		// Tests that we properly limit inbound channels when we have the manual-channel-acceptance
 		// flag set and (sometimes) accept channels as 0conf.
 		let mut anchors_cfg = test_default_channel_config();
@@ -15609,10 +15672,10 @@ mod tests {
 		let events = nodes[2].node.get_and_clear_pending_events();
 		match events[0] {
 			Event::OpenChannelRequest { temporary_channel_id, .. } =>
-				nodes[2].node.accept_inbound_channel(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 23).unwrap(),
+				nodes[2].node.accept_inbound_channel(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 23, config_overrides).unwrap(),
 			_ => panic!("Unexpected event"),
 		}
-		get_event_msg!(nodes[2], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
+		get_event_msg!(nodes[2], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())
 	}
 
 	#[test]

lightning/src/ln/functional_test_utils.rs

@@ -37,6 +37,7 @@ use crate::util::test_channel_signer::SignerOp;
 use crate::util::test_utils;
 use crate::util::test_utils::{TestChainMonitor, TestScorer, TestKeysInterface};
 use crate::util::ser::{ReadableArgs, Writeable};
+use crate::ln::channelmanager::InboundChannelConfigOverrides;
 
 use bitcoin::WPubkeyHash;
 use bitcoin::amount::Amount;
@@ -1321,7 +1322,7 @@ pub fn open_zero_conf_channel<'a, 'b, 'c, 'd>(initiator: &'a Node<'b, 'c, 'd>, r
 	assert_eq!(events.len(), 1);
 	match events[0] {
 		Event::OpenChannelRequest { temporary_channel_id, .. } => {
-			receiver.node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &initiator.node.get_our_node_id(), 0).unwrap();
+			receiver.node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &initiator.node.get_our_node_id(), 0, InboundChannelConfigOverrides::default()).unwrap();
 		},
 		_ => panic!("Unexpected event"),
 	};
@@ -1389,7 +1390,7 @@ pub fn exchange_open_accept_chan<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b:
 		assert_eq!(events.len(), 1);
 		match &events[0] {
 			Event::OpenChannelRequest { temporary_channel_id, counterparty_node_id, .. } =>
-				node_b.node.accept_inbound_channel(temporary_channel_id, counterparty_node_id, 42).unwrap(),
+				node_b.node.accept_inbound_channel(temporary_channel_id, counterparty_node_id, 42, InboundChannelConfigOverrides::default()).unwrap(),
 			_ => panic!("Unexpected event"),
 		};
 	}