Struct UserConfig 

pub struct UserConfig {
    pub channel_handshake_config: ChannelHandshakeConfig,
    pub channel_handshake_limits: ChannelHandshakeLimits,
    pub channel_config: ChannelConfig,
    pub accept_forwards_to_priv_channels: bool,
    pub accept_inbound_channels: bool,
    pub manually_accept_inbound_channels: bool,
    pub accept_intercept_htlcs: bool,
    pub manually_handle_bolt12_invoices: bool,
    pub enable_htlc_hold: bool,
    pub hold_outbound_htlcs_at_next_hop: bool,
    pub reject_inbound_splices: bool,
}

Top-level config which holds ChannelHandshakeLimits and ChannelConfig.

Default::default() provides sane defaults for most configurations (but currently with zero relay fees!)

Fields

channel_handshake_config: ChannelHandshakeConfig

Channel handshake config that we propose to our counterparty.

channel_handshake_limits: ChannelHandshakeLimits

Limits applied to our counterparty’s proposed channel handshake config settings.

channel_config: ChannelConfig

Channel config which affects behavior during channel lifetime.

accept_forwards_to_priv_channels: bool

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::announce_for_forwarding 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.

Note that this setting does not apply for intercepted payments that are surfaced via Event::HTLCIntercepted and manually forwarded.

Default value: false

accept_inbound_channels: bool

If this is set to false, we do not accept inbound requests to open a new channel.

Default value: true

manually_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

accept_intercept_htlcs: bool

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

manually_handle_bolt12_invoices: bool

If this is set to true, the user needs to manually pay Bolt12Invoices when received.

When set to true, Event::InvoiceReceived will be generated for each received Bolt12Invoice instead of being automatically paid after verification. Use ChannelManager::send_payment_for_bolt12_invoice to pay the invoice or ChannelManager::abandon_payment to abandon the associated payment.

Default value: false

enable_htlc_hold: bool

LDK supports a feature for always-online nodes such that these nodes can hold onto an HTLC from an often-offline channel peer until the often-offline payment recipient sends an onion message telling the always-online node to release the HTLC. If this is set to true, our node will carry out this feature for channel peers that request it.

This should only be set to true for nodes which expect to be online reliably.

Setting this to true may break backwards compatibility with LDK versions < 0.2.

Default value: false

hold_outbound_htlcs_at_next_hop: bool

If this is set to true, then if we as an often-offline payer receive a StaticInvoice to pay, we will attempt to hold the corresponding outbound HTLCs with our next-hop channel counterparty(s) that support the htlc_hold feature. This allows our node to go offline once the HTLCs are locked in even though the recipient may not yet be online to receive them.

This option is intended for usage by private nodes, and should NOT be set if we are an announced node that is expected to be online at all times.

Setting this to true may lead to HTLC failures if downgrading to LDK versions < 0.2.

Default value: false

reject_inbound_splices: bool

If this is set to true, then inbound channel splice requests will be rejected. This ensures backwards compatibility is not broken with LDK versions < 0.2 while a splice is pending.

Outbound channel splice requests (via ChannelManager::splice_channel, an opt-in API) are still allowed as users should be aware of the backwards compatibility risk prior to using the functionality.

Default value: true

Implementations

impl UserConfig

pub fn apply(&mut self, config: &ChannelConfigOverrides)

Applies given channel config overrides to the user config.

Trait Implementations

impl Clone for UserConfig

fn clone(&self) -> UserConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UserConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for UserConfig

fn default() -> Self

Returns the “default value” for a type.