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.
`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)`	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_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::util::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::util::events::Event::OpenChannelRequest [`msgs::OpenChannel`]: crate::ln::msgs::OpenChannel [`msgs::AcceptChannel`]: crate::ln::msgs::AcceptChannel
  - 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)
```
    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

of

clone

with_default