Make our in-flight limit percentage configurable

[rust-lightning] / lightning / src / util / config.rs

diff --git a/lightning/src/util/config.rs b/lightning/src/util/config.rs
index 55d506e79f145a386919ecce11f54ea7adbb432f..3868d29aab49f66789c49c970a662cba19000e2e 100644 (file)
--- a/lightning/src/util/config.rs
+++ b/lightning/src/util/config.rs
@@ -10,6 +10,7 @@
 //! Various user-configurable channel limits and settings which ChannelManager
 //! applies for you.
 
+use ln::channel::MAX_FUNDING_SATOSHIS_NO_WUMBO;
 use ln::channelmanager::{BREAKDOWN_TIMEOUT, MAX_LOCAL_BREAKDOWN_TIMEOUT};
 
 /// Configuration we set when applicable.
@@ -47,6 +48,52 @@ pub struct ChannelHandshakeConfig {
        /// Default value: 1. If the value is less than 1, it is ignored and set to 1, as is required
        /// by the protocol.
        pub our_htlc_minimum_msat: u64,
+       /// Sets the percentage of the channel value we will cap the total value of outstanding inbound
+       /// HTLCs to.
+       ///
+       /// This can be set to a value between 1-100, where the value corresponds to the percent of the
+       /// channel value in whole percentages.
+       ///
+       /// Note that:
+       /// * If configured to another value than the default value 10, any new channels created with
+       /// the non default value will cause versions of LDK prior to 0.0.104 to refuse to read the
+       /// `ChannelManager`.
+       ///
+       /// * This caps the total value for inbound HTLCs in-flight only, and there's currently
+       /// no way to configure the cap for the total value of outbound HTLCs in-flight.
+       ///
+       /// * The requirements for your node being online to ensure the safety of HTLC-encumbered funds
+       /// are different from the non-HTLC-encumbered funds. This makes this an important knob to
+       /// restrict exposure to loss due to being offline for too long.
+       /// See [`ChannelHandshakeConfig::our_to_self_delay`] and [`ChannelConfig::cltv_expiry_delta`]
+       /// for more information.
+       ///
+       /// Default value: 10.
+       /// Minimum value: 1, any values less than 1 will be treated as 1 instead.
+       /// Maximum value: 100, any values larger than 100 will be treated as 100 instead.
+       pub max_inbound_htlc_value_in_flight_percent_of_channel: u8,
+       /// If set, we attempt to negotiate the `scid_privacy` (referred to as `scid_alias` in the
+       /// BOLTs) option for outbound private channels. This provides better privacy by not including
+       /// our real on-chain channel UTXO in each invoice and requiring that our counterparty only
+       /// relay HTLCs to us using the channel's SCID alias.
+       ///
+       /// If this option is set, channels may be created that will not be readable by LDK versions
+       /// prior to 0.0.106, causing [`ChannelManager`]'s read method to return a
+       /// [`DecodeError:InvalidValue`].
+       ///
+       /// Note that setting this to true does *not* prevent us from opening channels with
+       /// counterparties that do not support the `scid_alias` option; we will simply fall back to a
+       /// private channel without that option.
+       ///
+       /// Ignored if the channel is negotiated to be announced, see
+       /// [`ChannelConfig::announced_channel`] and
+       /// [`ChannelHandshakeLimits::force_announced_channel_preference`] for more.
+       ///
+       /// Default value: false. This value is likely to change to true in the future.
+       ///
+       /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+       /// [`DecodeError:InvalidValue`]: crate::ln::msgs::DecodeError::InvalidValue
+       pub negotiate_scid_privacy: bool,
 }
 
 impl Default for ChannelHandshakeConfig {
@@ -55,6 +102,8 @@ impl Default for ChannelHandshakeConfig {
                        minimum_depth: 6,
                        our_to_self_delay: BREAKDOWN_TIMEOUT,
                        our_htlc_minimum_msat: 1,
+                       max_inbound_htlc_value_in_flight_percent_of_channel: 10,
+                       negotiate_scid_privacy: false,
                }
        }
 }
@@ -72,11 +121,16 @@ impl Default for ChannelHandshakeConfig {
 /// are applied mostly only to incoming channels that's not much of a problem.
 #[derive(Copy, Clone, Debug)]
 pub struct ChannelHandshakeLimits {
-       /// Minimum allowed satoshis when a channel is funded, this is supplied by the sender and so
+       /// Minimum allowed satoshis when a channel is funded. This is supplied by the sender and so
        /// only applies to inbound channels.
        ///
        /// Default value: 0.
        pub min_funding_satoshis: u64,
+       /// Maximum allowed satoshis when a channel is funded. This is supplied by the sender and so
+       /// only applies to inbound channels.
+       ///
+       /// Default value: 2^24 - 1.
+       pub max_funding_satoshis: u64,
        /// The remote node sets a limit on the minimum size of HTLCs we can send to them. This allows
        /// you to limit the maximum minimum-size they can require.
        ///
@@ -128,6 +182,7 @@ impl Default for ChannelHandshakeLimits {
        fn default() -> Self {
                ChannelHandshakeLimits {
                        min_funding_satoshis: 0,
+                       max_funding_satoshis: MAX_FUNDING_SATOSHIS_NO_WUMBO,
                        max_htlc_minimum_msat: <u64>::max_value(),
                        min_max_htlc_value_in_flight_msat: 0,
                        max_channel_reserve_satoshis: <u64>::max_value(),