java.lang.Object
- org.ldk.structs.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 Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`UserConfig`	`clone()`	Creates a copy of the UserConfig
`protected void`	`finalize()`
`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.
`boolean`	`get_accept_inbound_channels()`	If this is set to false, we do not accept inbound requests to open a new channel.
`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`].
`boolean`	`get_accept_mpp_keysend()`	If this is set to false, when receiving a keysend payment we'll fail it if it has multiple parts.
`ChannelConfig`	`get_channel_config()`	Channel config which affects behavior during channel lifetime.
`ChannelHandshakeConfig`	`get_channel_handshake_config()`	Channel handshake config that we propose to our counterparty.
`ChannelHandshakeLimits`	`get_channel_handshake_limits()`	Limits applied to our counterparty's proposed channel handshake config settings.
`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.
`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, boolean accept_mpp_keysend_arg)`	Constructs a new UserConfig given each field
`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.
`void`	`set_accept_inbound_channels(boolean val)`	If this is set to false, we do not accept inbound requests to open a new channel.
`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`].
`void`	`set_accept_mpp_keysend(boolean val)`	If this is set to false, when receiving a keysend payment we'll fail it if it has multiple parts.
`void`	`set_channel_config(ChannelConfig val)`	Channel config which affects behavior during channel lifetime.
`void`	`set_channel_handshake_config(ChannelHandshakeConfig val)`	Channel handshake config that we propose to our counterparty.
`void`	`set_channel_handshake_limits(ChannelHandshakeLimits val)`	Limits applied to our counterparty's proposed channel handshake config settings.
`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.
`static UserConfig`	`with_default()`	Creates a "default" UserConfig.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - 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
  - get_accept_mpp_keysend
```
public boolean get_accept_mpp_keysend()
```
    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
  - set_accept_mpp_keysend
```
public void set_accept_mpp_keysend(boolean val)
```
    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
  - 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,
                            boolean accept_mpp_keysend_arg)
```
    Constructs a new UserConfig given each field
  - clone
```
public UserConfig clone()
```
    Creates a copy of the UserConfig
    
    Overrides:
    
    clone in class Object
  - with_default
```
public static UserConfig with_default()
```
    Creates a "default" UserConfig. See struct and individual field documentaiton for details on which values are used.

Class UserConfig

Method Summary

Methods inherited from class java.lang.Object

Method Detail

finalize

get_channel_handshake_config

set_channel_handshake_config

get_channel_handshake_limits

set_channel_handshake_limits

get_channel_config

set_channel_config

get_accept_forwards_to_priv_channels

set_accept_forwards_to_priv_channels

get_accept_inbound_channels

set_accept_inbound_channels

get_manually_accept_inbound_channels

set_manually_accept_inbound_channels

get_accept_intercept_htlcs

set_accept_intercept_htlcs

get_accept_mpp_keysend

set_accept_mpp_keysend

of

clone

with_default