/// any attacker who is able to take control of a channel can just as easily send the funds via
/// lightning payments, so we never require that our counterparties support this option.
///
- /// The upfront key committed is provided from [`KeysInterface::get_shutdown_scriptpubkey`].
+ /// The upfront key committed is provided from [`SignerProvider::get_shutdown_scriptpubkey`].
///
/// Default value: true.
///
- /// [`KeysInterface::get_shutdown_scriptpubkey`]: crate::chain::keysinterface::KeysInterface::get_shutdown_scriptpubkey
+ /// [`SignerProvider::get_shutdown_scriptpubkey`]: crate::sign::SignerProvider::get_shutdown_scriptpubkey
pub commit_upfront_shutdown_pubkey: bool,
-
/// The Proportion of the channel value to configure as counterparty's channel reserve,
/// i.e., `their_channel_reserve_satoshis` for both outbound and inbound channels.
///
/// as 1000 sats instead, which is a safe implementation-specific lower bound.
/// Maximum value: 1,000,000, any values larger than 1 Million will be treated as 1 Million (or 100%)
/// instead, although channel negotiations will fail in that case.
- pub their_channel_reserve_proportional_millionths: u32
+ pub their_channel_reserve_proportional_millionths: u32,
+ #[cfg(anchors)]
+ /// If set, we attempt to negotiate the `anchors_zero_fee_htlc_tx`option for outbound channels.
+ ///
+ /// If this option is set, channels may be created that will not be readable by LDK versions
+ /// prior to 0.0.114, 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 `anchors_zero_fee_htlc_tx` option; we will simply
+ /// fall back to a `static_remote_key` channel.
+ ///
+ /// LDK will not support the legacy `option_anchors` commitment version due to a discovered
+ /// vulnerability after its deployment. For more context, see the [`SIGHASH_SINGLE + update_fee
+ /// Considered Harmful`] mailing list post.
+ ///
+ /// 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
+ /// [`SIGHASH_SINGLE + update_fee Considered Harmful`]: https://lists.linuxfoundation.org/pipermail/lightning-dev/2020-September/002796.html
+ pub negotiate_anchors_zero_fee_htlc_tx: bool,
+
+ /// The maximum number of HTLCs in-flight from our counterparty towards us at the same time.
+ ///
+ /// Increasing the value can help improve liquidity and stability in
+ /// routing at the cost of higher long term disk / DB usage.
+ ///
+ /// Note: Versions of LDK earlier than v0.0.115 will fail to read channels with a configuration
+ /// other than the default value.
+ ///
+ /// Default value: 50
+ /// Maximum value: 483, any values larger will be treated as 483.
+ /// This is the BOLT #2 spec limit on `max_accepted_htlcs`.
+ pub our_max_accepted_htlcs: u16,
}
impl Default for ChannelHandshakeConfig {
announced_channel: false,
commit_upfront_shutdown_pubkey: true,
their_channel_reserve_proportional_millionths: 10_000,
+ #[cfg(anchors)]
+ negotiate_anchors_zero_fee_htlc_tx: false,
+ our_max_accepted_htlcs: 50,
}
}
}
///
/// These limits are only applied to our counterparty's limits, not our own.
///
-/// Use 0/<type>::max_value() as appropriate to skip checking.
+/// Use 0/`<type>::max_value()` as appropriate to skip checking.
///
/// Provides sane defaults for most configurations.
///
pub force_close_avoidance_max_fee_satoshis: u64,
}
+impl ChannelConfig {
+ /// Applies the given [`ChannelConfigUpdate`] as a partial update to the [`ChannelConfig`].
+ pub fn apply(&mut self, update: &ChannelConfigUpdate) {
+ if let Some(forwarding_fee_proportional_millionths) = update.forwarding_fee_proportional_millionths {
+ self.forwarding_fee_proportional_millionths = forwarding_fee_proportional_millionths;
+ }
+ if let Some(forwarding_fee_base_msat) = update.forwarding_fee_base_msat {
+ self.forwarding_fee_base_msat = forwarding_fee_base_msat;
+ }
+ if let Some(cltv_expiry_delta) = update.cltv_expiry_delta {
+ self.cltv_expiry_delta = cltv_expiry_delta;
+ }
+ if let Some(max_dust_htlc_exposure_msat) = update.max_dust_htlc_exposure_msat {
+ self.max_dust_htlc_exposure_msat = max_dust_htlc_exposure_msat;
+ }
+ if let Some(force_close_avoidance_max_fee_satoshis) = update.force_close_avoidance_max_fee_satoshis {
+ self.force_close_avoidance_max_fee_satoshis = force_close_avoidance_max_fee_satoshis;
+ }
+ }
+}
+
impl Default for ChannelConfig {
/// Provides sane defaults for most configurations (but with zero relay fees!).
fn default() -> Self {
(10, force_close_avoidance_max_fee_satoshis, required),
});
+/// A parallel struct to [`ChannelConfig`] to define partial updates.
+#[allow(missing_docs)]
+pub struct ChannelConfigUpdate {
+ pub forwarding_fee_proportional_millionths: Option<u32>,
+ pub forwarding_fee_base_msat: Option<u32>,
+ pub cltv_expiry_delta: Option<u16>,
+ pub max_dust_htlc_exposure_msat: Option<u64>,
+ pub force_close_avoidance_max_fee_satoshis: Option<u64>,
+}
+
+impl Default for ChannelConfigUpdate {
+ fn default() -> ChannelConfigUpdate {
+ ChannelConfigUpdate {
+ forwarding_fee_proportional_millionths: None,
+ forwarding_fee_base_msat: None,
+ cltv_expiry_delta: None,
+ max_dust_htlc_exposure_msat: None,
+ force_close_avoidance_max_fee_satoshis: None,
+ }
+ }
+}
+
+impl From<ChannelConfig> for ChannelConfigUpdate {
+ fn from(config: ChannelConfig) -> ChannelConfigUpdate {
+ ChannelConfigUpdate {
+ forwarding_fee_proportional_millionths: Some(config.forwarding_fee_proportional_millionths),
+ forwarding_fee_base_msat: Some(config.forwarding_fee_base_msat),
+ cltv_expiry_delta: Some(config.cltv_expiry_delta),
+ max_dust_htlc_exposure_msat: Some(config.max_dust_htlc_exposure_msat),
+ force_close_avoidance_max_fee_satoshis: Some(config.force_close_avoidance_max_fee_satoshis),
+ }
+ }
+}
+
/// Legacy version of [`ChannelConfig`] that stored the static
/// [`ChannelHandshakeConfig::announced_channel`] and
/// [`ChannelHandshakeConfig::commit_upfront_shutdown_pubkey`] fields.
///
/// Default value: false.
///
- /// [`Event::OpenChannelRequest`]: crate::util::events::Event::OpenChannelRequest
+ /// [`Event::OpenChannelRequest`]: crate::events::Event::OpenChannelRequest
/// [`msgs::OpenChannel`]: crate::ln::msgs::OpenChannel
/// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
pub manually_accept_inbound_channels: bool,
/// Default value: false.
///
/// [`ChannelManager::get_intercept_scid`]: crate::ln::channelmanager::ChannelManager::get_intercept_scid
- /// [`Event::HTLCIntercepted`]: crate::util::events::Event::HTLCIntercepted
+ /// [`Event::HTLCIntercepted`]: crate::events::Event::HTLCIntercepted
pub accept_intercept_htlcs: bool,
+ /// If this is set to false, when receiving a keysend payment we'll fail it if it has multiple
+ /// parts. If this is set to true, we'll accept the payment.
+ ///
+ /// Setting this to true will break backwards compatibility upon downgrading to an LDK
+ /// version < 0.0.116 while receiving an MPP keysend. If we have already received an MPP
+ /// keysend, downgrading will cause us to fail to deserialize [`ChannelManager`].
+ ///
+ /// Default value: false.
+ ///
+ /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ pub accept_mpp_keysend: bool,
}
impl Default for UserConfig {
accept_inbound_channels: true,
manually_accept_inbound_channels: false,
accept_intercept_htlcs: false,
+ accept_mpp_keysend: false,
}
}
}