/// 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.
///
/// [`MIN_CLTV_EXPIRY_DELTA`]: crate::ln::channelmanager::MIN_CLTV_EXPIRY_DELTA
pub cltv_expiry_delta: u16,
- /// Set to announce the channel publicly and notify all nodes that they can route via this
- /// channel.
- ///
- /// This should only be set to true for nodes which expect to be online reliably.
- ///
- /// As the node which funds a channel picks this value this will only apply for new outbound
- /// channels unless [`ChannelHandshakeLimits::force_announced_channel_preference`] is set.
- ///
- /// This cannot be changed after the initial channel handshake.
- ///
- /// Default value: false.
- pub announced_channel: bool,
- /// When set, we commit to an upfront shutdown_pubkey at channel open. If our counterparty
- /// supports it, they will then enforce the mutual-close output to us matches what we provided
- /// at intialization, preventing us from closing to an alternate pubkey.
- ///
- /// This is set to true by default to provide a slight increase in security, though ultimately
- /// 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.
- ///
- /// This cannot be changed after a channel has been initialized.
- ///
- /// Default value: true.
- pub commit_upfront_shutdown_pubkey: bool,
/// Limit our total exposure to in-flight HTLCs which are burned to fees as they are too
/// small to claim on-chain.
///
forwarding_fee_proportional_millionths: 0,
forwarding_fee_base_msat: 1000,
cltv_expiry_delta: 6 * 12, // 6 blocks/hour * 12 hours
- announced_channel: false,
- commit_upfront_shutdown_pubkey: true,
max_dust_htlc_exposure_msat: 5_000_000,
force_close_avoidance_max_fee_satoshis: 1000,
}
impl_writeable_tlv_based!(ChannelConfig, {
(0, forwarding_fee_proportional_millionths, required),
- (1, max_dust_htlc_exposure_msat, (default_value, 5_000_000)),
- (2, cltv_expiry_delta, required),
- (3, force_close_avoidance_max_fee_satoshis, (default_value, 1000)),
- (4, announced_channel, required),
- (6, commit_upfront_shutdown_pubkey, required),
- (8, forwarding_fee_base_msat, 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) 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,
+ /// Deprecated but may still be read from. See
+ /// [`ChannelHandshakeConfig::commit_upfront_shutdown_pubkey`] to set this when
+ /// opening/accepting a channel.
+ pub(crate) commit_upfront_shutdown_pubkey: bool,
+}
+
+impl Default for LegacyChannelConfig {
+ fn default() -> Self {
+ Self {
+ options: ChannelConfig::default(),
+ announced_channel: false,
+ commit_upfront_shutdown_pubkey: true,
+ }
+ }
+}
+
+impl ::util::ser::Writeable for LegacyChannelConfig {
+ fn write<W: ::util::ser::Writer>(&self, writer: &mut W) -> Result<(), ::io::Error> {
+ write_tlv_fields!(writer, {
+ (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.options.forwarding_fee_base_msat, required),
+ });
+ Ok(())
+ }
+}
+
+impl ::util::ser::Readable for LegacyChannelConfig {
+ fn read<R: ::io::Read>(reader: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
+ let mut forwarding_fee_proportional_millionths = 0;
+ let mut max_dust_htlc_exposure_msat = 5_000_000;
+ let mut cltv_expiry_delta = 0;
+ let mut force_close_avoidance_max_fee_satoshis = 1000;
+ let mut announced_channel = false;
+ let mut commit_upfront_shutdown_pubkey = false;
+ 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_000u64)),
+ (2, cltv_expiry_delta, required),
+ (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 {
+ options: ChannelConfig {
+ forwarding_fee_proportional_millionths,
+ max_dust_htlc_exposure_msat,
+ cltv_expiry_delta,
+ force_close_avoidance_max_fee_satoshis,
+ forwarding_fee_base_msat,
+ },
+ announced_channel,
+ commit_upfront_shutdown_pubkey,
+ })
+ }
+}
+
/// Top-level config which holds ChannelHandshakeLimits and ChannelConfig.
///
/// Default::default() provides sane defaults for most configurations
/// (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.
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,
projects / rust-lightning / blobdiff