Class UserConfig


  • public class UserConfig
    extends Object
    Top-level config which holds ChannelHandshakeLimits and ChannelConfig. Default::default() provides sane defaults for most configurations (but currently with 0 relay fees!)
    • Method Detail

      • get_channel_handshake_config

        public ChannelHandshakeConfig get_channel_handshake_config()
        Channel handshake config that we propose to our counterparty.
      • set_channel_handshake_config

        public void set_channel_handshake_config​(ChannelHandshakeConfig val)
        Channel handshake config that we propose to our counterparty.
      • get_channel_handshake_limits

        public ChannelHandshakeLimits get_channel_handshake_limits()
        Limits applied to our counterparty's proposed channel handshake config settings.
      • set_channel_handshake_limits

        public void set_channel_handshake_limits​(ChannelHandshakeLimits val)
        Limits applied to our counterparty's proposed channel handshake config settings.
      • get_channel_config

        public ChannelConfig get_channel_config()
        Channel config which affects behavior during channel lifetime.
      • set_channel_config

        public void set_channel_config​(ChannelConfig val)
        Channel config which affects behavior during channel lifetime.
      • get_accept_forwards_to_priv_channels

        public boolean get_accept_forwards_to_priv_channels()
        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 [`ChannelHandshakeConfig::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.
      • set_accept_forwards_to_priv_channels

        public void set_accept_forwards_to_priv_channels​(boolean val)
        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 [`ChannelHandshakeConfig::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.
      • get_accept_inbound_channels

        public boolean get_accept_inbound_channels()
        If this is set to false, we do not accept inbound requests to open a new channel. Default value: true.
      • set_accept_inbound_channels

        public void set_accept_inbound_channels​(boolean val)
        If this is set to false, we do not accept inbound requests to open a new channel. Default value: true.
      • get_manually_accept_inbound_channels

        public boolean get_manually_accept_inbound_channels()
        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::events::Event::OpenChannelRequest [`msgs::OpenChannel`]: crate::ln::msgs::OpenChannel [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
      • set_manually_accept_inbound_channels

        public void set_manually_accept_inbound_channels​(boolean val)
        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::events::Event::OpenChannelRequest [`msgs::OpenChannel`]: crate::ln::msgs::OpenChannel [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
      • get_accept_intercept_htlcs

        public boolean get_accept_intercept_htlcs()
        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
      • set_accept_intercept_htlcs

        public void set_accept_intercept_htlcs​(boolean val)
        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
      • of

        public static UserConfig of​(ChannelHandshakeConfig channel_handshake_config_arg,
                                    ChannelHandshakeLimits channel_handshake_limits_arg,
                                    ChannelConfig channel_config_arg,
                                    boolean accept_forwards_to_priv_channels_arg,
                                    boolean accept_inbound_channels_arg,
                                    boolean manually_accept_inbound_channels_arg,
                                    boolean accept_intercept_htlcs_arg)
        Constructs a new UserConfig given each field
      • with_default

        public static UserConfig with_default()
        Creates a "default" UserConfig. See struct and individual field documentaiton for details on which values are used.