X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fconfig.rs;h=54ea6178798d25a3e6103c39419b886632024ca9;hb=b4a40f6b409a54f586ba560ecb1d5ab002c3e8f3;hp=570e570a893e9583e4bb57ca18d4cb7c515a581c;hpb=5421e1a6e712ae3d04569562fd036e29908188d7;p=rust-lightning diff --git a/lightning/src/util/config.rs b/lightning/src/util/config.rs index 570e570a..54ea6178 100644 --- a/lightning/src/util/config.rs +++ b/lightning/src/util/config.rs @@ -126,6 +126,30 @@ pub struct ChannelHandshakeConfig { /// /// [`KeysInterface::get_shutdown_scriptpubkey`]: crate::chain::keysinterface::KeysInterface::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. + /// + /// `their_channel_reserve_satoshis` is the minimum balance that the other node has to maintain + /// on their side, at all times. + /// This ensures that if our counterparty broadcasts a revoked state, we can punish them by + /// claiming at least this value on chain. + /// + /// Channel reserve values greater than 30% could be considered highly unreasonable, since that + /// amount can never be used for payments. + /// Also, if our selected channel reserve for counterparty and counterparty's selected + /// channel reserve for us sum up to equal or greater than channel value, channel negotiations + /// will fail. + /// + /// Note: Versions of LDK earlier than v0.0.104 will fail to read channels with any channel reserve + /// other than the default value. + /// + /// Default value: 1% of channel value, i.e., configured as 10,000 millionths. + /// Minimum value: If the calculated proportional value is less than 1000 sats, it will be treated + /// 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 } impl Default for ChannelHandshakeConfig { @@ -138,6 +162,7 @@ impl Default for ChannelHandshakeConfig { negotiate_scid_privacy: false, announced_channel: false, commit_upfront_shutdown_pubkey: true, + their_channel_reserve_proportional_millionths: 10_000, } } } @@ -249,7 +274,7 @@ impl Default for ChannelHandshakeLimits { /// Options which apply on a per-channel basis and may change at runtime or based on negotiation /// with our counterparty. -#[derive(Copy, Clone, Debug)] +#[derive(Copy, Clone, Debug, PartialEq)] pub struct ChannelConfig { /// Amount (in millionths of a satoshi) charged per satoshi for payments forwarded outbound /// over the channel. @@ -345,12 +370,23 @@ impl Default for ChannelConfig { } } +impl_writeable_tlv_based!(ChannelConfig, { + (0, forwarding_fee_proportional_millionths, required), + (2, forwarding_fee_base_msat, required), + (4, cltv_expiry_delta, required), + (6, max_dust_htlc_exposure_msat, required), + // ChannelConfig serialized this field with a required type of 8 prior to the introduction of + // LegacyChannelConfig. To make sure that serialization is not compatible with this one, we use + // the next required type of 10, which if seen by the old serialization will always fail. + (10, force_close_avoidance_max_fee_satoshis, required), +}); + /// Legacy version of [`ChannelConfig`] that stored the static /// [`ChannelHandshakeConfig::announced_channel`] and /// [`ChannelHandshakeConfig::commit_upfront_shutdown_pubkey`] fields. #[derive(Copy, Clone, Debug)] pub(crate) struct LegacyChannelConfig { - pub(crate) mutable: ChannelConfig, + pub(crate) options: ChannelConfig, /// Deprecated but may still be read from. See [`ChannelHandshakeConfig::announced_channel`] to /// set this when opening/accepting a channel. pub(crate) announced_channel: bool, @@ -363,7 +399,7 @@ pub(crate) struct LegacyChannelConfig { impl Default for LegacyChannelConfig { fn default() -> Self { Self { - mutable: ChannelConfig::default(), + options: ChannelConfig::default(), announced_channel: false, commit_upfront_shutdown_pubkey: true, } @@ -373,13 +409,13 @@ impl Default for LegacyChannelConfig { impl ::util::ser::Writeable for LegacyChannelConfig { fn write(&self, writer: &mut W) -> Result<(), ::io::Error> { write_tlv_fields!(writer, { - (0, self.mutable.forwarding_fee_proportional_millionths, required), - (1, self.mutable.max_dust_htlc_exposure_msat, (default_value, 5_000_000)), - (2, self.mutable.cltv_expiry_delta, required), - (3, self.mutable.force_close_avoidance_max_fee_satoshis, (default_value, 1000)), + (0, self.options.forwarding_fee_proportional_millionths, required), + (1, self.options.max_dust_htlc_exposure_msat, (default_value, 5_000_000)), + (2, self.options.cltv_expiry_delta, required), + (3, self.options.force_close_avoidance_max_fee_satoshis, (default_value, 1000)), (4, self.announced_channel, required), (6, self.commit_upfront_shutdown_pubkey, required), - (8, self.mutable.forwarding_fee_base_msat, required), + (8, self.options.forwarding_fee_base_msat, required), }); Ok(()) } @@ -396,15 +432,15 @@ impl ::util::ser::Readable for LegacyChannelConfig { let mut forwarding_fee_base_msat = 0; read_tlv_fields!(reader, { (0, forwarding_fee_proportional_millionths, required), - (1, max_dust_htlc_exposure_msat, (default_value, 5_000_000)), + (1, max_dust_htlc_exposure_msat, (default_value, 5_000_000u64)), (2, cltv_expiry_delta, required), - (3, force_close_avoidance_max_fee_satoshis, (default_value, 1000)), + (3, force_close_avoidance_max_fee_satoshis, (default_value, 1000u64)), (4, announced_channel, required), (6, commit_upfront_shutdown_pubkey, required), (8, forwarding_fee_base_msat, required), }); Ok(Self { - mutable: ChannelConfig { + options: ChannelConfig { forwarding_fee_proportional_millionths, max_dust_htlc_exposure_msat, cltv_expiry_delta, @@ -423,12 +459,12 @@ impl ::util::ser::Readable for LegacyChannelConfig { /// (but currently with 0 relay fees!) #[derive(Copy, Clone, Debug)] pub struct UserConfig { - /// Channel config that we propose to our counterparty. - pub own_channel_config: ChannelHandshakeConfig, - /// Limits applied to our counterparty's proposed channel config settings. - pub peer_channel_config_limits: ChannelHandshakeLimits, + /// Channel handshake config that we propose to our counterparty. + pub channel_handshake_config: ChannelHandshakeConfig, + /// Limits applied to our counterparty's proposed channel handshake config settings. + pub channel_handshake_limits: ChannelHandshakeLimits, /// Channel config which affects behavior during channel lifetime. - pub channel_options: ChannelConfig, + pub channel_config: ChannelConfig, /// If this is set to false, we will reject any HTLCs which were to be forwarded over private /// channels. This prevents us from taking on HTLC-forwarding risk when we intend to run as a /// node which is not online reliably. @@ -468,9 +504,9 @@ pub struct UserConfig { impl Default for UserConfig { fn default() -> Self { UserConfig { - own_channel_config: ChannelHandshakeConfig::default(), - peer_channel_config_limits: ChannelHandshakeLimits::default(), - channel_options: ChannelConfig::default(), + channel_handshake_config: ChannelHandshakeConfig::default(), + channel_handshake_limits: ChannelHandshakeLimits::default(), + channel_config: ChannelConfig::default(), accept_forwards_to_priv_channels: false, accept_inbound_channels: true, manually_accept_inbound_channels: false,