+
+/// 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 config which affects behavior during channel lifetime.
+ pub channel_options: 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.
+ ///
+ /// For nodes which are not online reliably, you should set all channels to *not* be announced
+ /// (using [`ChannelConfig::announced_channel`] and
+ /// [`ChannelHandshakeLimits::force_announced_channel_preference`]) and set this to false to
+ /// ensure you are not exposed to any forwarding risk.
+ ///
+ /// Note that because you cannot change a channel's announced state after creation, there is no
+ /// way to disable forwarding on public channels retroactively. Thus, in order to change a node
+ /// from a publicly-announced forwarding node to a private non-forwarding node you must close
+ /// all your channels and open new ones. For privacy, you should also change your node_id
+ /// (swapping all private and public key material for new ones) at that time.
+ ///
+ /// Default value: false.
+ pub accept_forwards_to_priv_channels: bool,
+ /// If this is set to false, we do not accept inbound requests to open a new channel.
+ /// Default value: true.
+ pub accept_inbound_channels: bool,
+ /// If this is set to true, the user needs to manually accept inbound requests to open a new
+ /// channel.
+ ///
+ /// When set to true, [`Event::OpenChannelRequest`] will be triggered once a request to open a
+ /// new inbound channel is received through a [`msgs::OpenChannel`] message. In that case, a
+ /// [`msgs::AcceptChannel`] message will not be sent back to the counterparty node unless the
+ /// user explicitly chooses to accept the request.
+ ///
+ /// Default value: false.
+ ///
+ /// [`Event::OpenChannelRequest`]: crate::util::events::Event::OpenChannelRequest
+ /// [`msgs::OpenChannel`]: crate::ln::msgs::OpenChannel
+ /// [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
+ pub manually_accept_inbound_channels: bool,
+}
+
+impl Default for UserConfig {
+ fn default() -> Self {
+ UserConfig {
+ own_channel_config: ChannelHandshakeConfig::default(),
+ peer_channel_config_limits: ChannelHandshakeLimits::default(),
+ channel_options: ChannelConfig::default(),
+ accept_forwards_to_priv_channels: false,
+ accept_inbound_channels: true,
+ manually_accept_inbound_channels: false,
+ }
+ }
+}