X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fconfig.rs;h=5c8d5b6c554fc11ad4f89500a69f8f600812ad66;hb=86fd9e7fbc549f1e556063301a22a5bb3bc1f333;hp=26c8da7543615777ec814a88adff9163b147ddd0;hpb=a257906743d528c32c862b053b652d4b728aa990;p=rust-lightning diff --git a/lightning/src/util/config.rs b/lightning/src/util/config.rs index 26c8da75..5c8d5b6c 100644 --- a/lightning/src/util/config.rs +++ b/lightning/src/util/config.rs @@ -120,13 +120,12 @@ pub struct ChannelHandshakeConfig { /// 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. /// @@ -149,7 +148,49 @@ pub struct ChannelHandshakeConfig { /// 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, + /// If set, we attempt to negotiate the `anchors_zero_fee_htlc_tx`option for all future + /// channels. This feature requires having a reserve of onchain funds readily available to bump + /// transactions in the event of a channel force close to avoid the possibility of losing funds. + /// + /// Note that if you wish accept inbound channels with anchor outputs, you must enable + /// [`UserConfig::manually_accept_inbound_channels`] and manually accept them with + /// [`ChannelManager::accept_inbound_channel`]. This is done to give you the chance to check + /// whether your reserve of onchain funds is enough to cover the fees for all existing and new + /// channels featuring anchor outputs in the event of a force close. + /// + /// If this option is set, channels may be created that will not be readable by LDK versions + /// prior to 0.0.116, 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 + /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel + /// [`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 { @@ -163,6 +204,8 @@ impl Default for ChannelHandshakeConfig { announced_channel: false, commit_upfront_shutdown_pubkey: true, their_channel_reserve_proportional_millionths: 10_000, + negotiate_anchors_zero_fee_htlc_tx: false, + our_max_accepted_htlcs: 50, } } } @@ -171,7 +214,7 @@ impl Default for ChannelHandshakeConfig { /// /// These limits are only applied to our counterparty's limits, not our own. /// -/// Use 0/::max_value() as appropriate to skip checking. +/// Use 0/`::max_value()` as appropriate to skip checking. /// /// Provides sane defaults for most configurations. /// @@ -361,6 +404,59 @@ pub struct ChannelConfig { /// [`Normal`]: crate::chain::chaininterface::ConfirmationTarget::Normal /// [`Background`]: crate::chain::chaininterface::ConfirmationTarget::Background pub force_close_avoidance_max_fee_satoshis: u64, + /// If set, allows this channel's counterparty to skim an additional fee off this node's inbound + /// HTLCs. Useful for liquidity providers to offload on-chain channel costs to end users. + /// + /// Usage: + /// - The payee will set this option and set its invoice route hints to use [intercept scids] + /// generated by this channel's counterparty. + /// - The counterparty will get an [`HTLCIntercepted`] event upon payment forward, and call + /// [`forward_intercepted_htlc`] with less than the amount provided in + /// [`HTLCIntercepted::expected_outbound_amount_msat`]. The difference between the expected and + /// actual forward amounts is their fee. + // TODO: link to LSP JIT channel invoice generation spec when it's merged + /// + /// # Note + /// It's important for payee wallet software to verify that [`PaymentClaimable::amount_msat`] is + /// as-expected if this feature is activated, otherwise they may lose money! + /// [`PaymentClaimable::counterparty_skimmed_fee_msat`] provides the fee taken by the + /// counterparty. + /// + /// # Note + /// Switching this config flag on may break compatibility with versions of LDK prior to 0.0.116. + /// Unsetting this flag between restarts may lead to payment receive failures. + /// + /// Default value: false. + /// + /// [intercept scids]: crate::ln::channelmanager::ChannelManager::get_intercept_scid + /// [`forward_intercepted_htlc`]: crate::ln::channelmanager::ChannelManager::forward_intercepted_htlc + /// [`HTLCIntercepted`]: crate::events::Event::HTLCIntercepted + /// [`HTLCIntercepted::expected_outbound_amount_msat`]: crate::events::Event::HTLCIntercepted::expected_outbound_amount_msat + /// [`PaymentClaimable::amount_msat`]: crate::events::Event::PaymentClaimable::amount_msat + /// [`PaymentClaimable::counterparty_skimmed_fee_msat`]: crate::events::Event::PaymentClaimable::counterparty_skimmed_fee_msat + // TODO: link to bLIP when it's merged + pub accept_underpaying_htlcs: bool, +} + +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 { @@ -372,12 +468,14 @@ impl Default for ChannelConfig { cltv_expiry_delta: 6 * 12, // 6 blocks/hour * 12 hours max_dust_htlc_exposure_msat: 5_000_000, force_close_avoidance_max_fee_satoshis: 1000, + accept_underpaying_htlcs: false, } } } impl_writeable_tlv_based!(ChannelConfig, { (0, forwarding_fee_proportional_millionths, required), + (1, accept_underpaying_htlcs, (default_value, false)), (2, forwarding_fee_base_msat, required), (4, cltv_expiry_delta, required), (6, max_dust_htlc_exposure_msat, required), @@ -387,6 +485,40 @@ impl_writeable_tlv_based!(ChannelConfig, { (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, + pub forwarding_fee_base_msat: Option, + pub cltv_expiry_delta: Option, + pub max_dust_htlc_exposure_msat: Option, + pub force_close_avoidance_max_fee_satoshis: Option, +} + +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 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. @@ -452,6 +584,7 @@ impl crate::util::ser::Readable for LegacyChannelConfig { cltv_expiry_delta, force_close_avoidance_max_fee_satoshis, forwarding_fee_base_msat, + accept_underpaying_htlcs: false, }, announced_channel, commit_upfront_shutdown_pubkey, @@ -501,10 +634,32 @@ pub struct UserConfig { /// /// 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, + /// If this is set to true, LDK will intercept HTLCs that are attempting to be forwarded over + /// fake short channel ids generated via [`ChannelManager::get_intercept_scid`]. Upon HTLC + /// intercept, LDK will generate an [`Event::HTLCIntercepted`] which MUST be handled by the user. + /// + /// Setting this to true may break backwards compatibility with LDK versions < 0.0.113. + /// + /// Default value: false. + /// + /// [`ChannelManager::get_intercept_scid`]: crate::ln::channelmanager::ChannelManager::get_intercept_scid + /// [`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 { @@ -516,6 +671,8 @@ impl Default for UserConfig { accept_forwards_to_priv_channels: false, accept_inbound_channels: true, manually_accept_inbound_channels: false, + accept_intercept_htlcs: false, + accept_mpp_keysend: false, } } }