java.lang.Object
- org.ldk.structs.ChannelConfig

```
public class ChannelConfig
extends Object
```
Options which apply on a per-channel basis and may change at runtime or based on negotiation with our counterparty.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`apply(ChannelConfigUpdate update)`	Applies the given [`ChannelConfigUpdate`] as a partial update to the [`ChannelConfig`].
`ChannelConfig`	`clone()`	Creates a copy of the ChannelConfig
`boolean`	`eq(ChannelConfig b)`	Checks if two ChannelConfigs contain equal inner contents.
`boolean`	`equals(Object o)`
`protected void`	`finalize()`
`boolean`	`get_accept_underpaying_htlcs()`	If set, allows this channel's counterparty to skim an additional fee off this node's inbound HTLCs.
`short`	`get_cltv_expiry_delta()`	The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over the channel this config applies to.
`long`	`get_force_close_avoidance_max_fee_satoshis()`	The additional fee we're willing to pay to avoid waiting for the counterparty's `to_self_delay` to reclaim funds.
`int`	`get_forwarding_fee_base_msat()`	Amount (in milli-satoshi) charged for payments forwarded outbound over the channel, in excess of [`forwarding_fee_proportional_millionths`].
`int`	`get_forwarding_fee_proportional_millionths()`	Amount (in millionths of a satoshi) charged per satoshi for payments forwarded outbound over the channel.
`MaxDustHTLCExposure`	`get_max_dust_htlc_exposure()`	Limit our total exposure to in-flight HTLCs which are burned to fees as they are too small to claim on-chain.
`static ChannelConfig`	`of(int forwarding_fee_proportional_millionths_arg, int forwarding_fee_base_msat_arg, short cltv_expiry_delta_arg, MaxDustHTLCExposure max_dust_htlc_exposure_arg, long force_close_avoidance_max_fee_satoshis_arg, boolean accept_underpaying_htlcs_arg)`	Constructs a new ChannelConfig given each field
`static Result_ChannelConfigDecodeErrorZ`	`read(byte[] ser)`	Read a ChannelConfig from a byte array, created by ChannelConfig_write
`void`	`set_accept_underpaying_htlcs(boolean val)`	If set, allows this channel's counterparty to skim an additional fee off this node's inbound HTLCs.
`void`	`set_cltv_expiry_delta(short val)`	The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over the channel this config applies to.
`void`	`set_force_close_avoidance_max_fee_satoshis(long val)`	The additional fee we're willing to pay to avoid waiting for the counterparty's `to_self_delay` to reclaim funds.
`void`	`set_forwarding_fee_base_msat(int val)`	Amount (in milli-satoshi) charged for payments forwarded outbound over the channel, in excess of [`forwarding_fee_proportional_millionths`].
`void`	`set_forwarding_fee_proportional_millionths(int val)`	Amount (in millionths of a satoshi) charged per satoshi for payments forwarded outbound over the channel.
`void`	`set_max_dust_htlc_exposure(MaxDustHTLCExposure val)`	Limit our total exposure to in-flight HTLCs which are burned to fees as they are too small to claim on-chain.
`static ChannelConfig`	`with_default()`	Creates a "default" ChannelConfig.
`byte[]`	`write()`	Serialize the ChannelConfig object into a byte array which can be read by ChannelConfig_read

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

- Method Detail
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - get_forwarding_fee_proportional_millionths
```
public int get_forwarding_fee_proportional_millionths()
```
    Amount (in millionths of a satoshi) charged per satoshi for payments forwarded outbound over the channel. This may be allowed to change at runtime in a later update, however doing so must result in update messages sent to notify all nodes of our updated relay fee. Default value: 0.
  - set_forwarding_fee_proportional_millionths
```
public void set_forwarding_fee_proportional_millionths(int val)
```
    Amount (in millionths of a satoshi) charged per satoshi for payments forwarded outbound over the channel. This may be allowed to change at runtime in a later update, however doing so must result in update messages sent to notify all nodes of our updated relay fee. Default value: 0.
  - get_forwarding_fee_base_msat
```
public int get_forwarding_fee_base_msat()
```
    Amount (in milli-satoshi) charged for payments forwarded outbound over the channel, in excess of [`forwarding_fee_proportional_millionths`]. This may be allowed to change at runtime in a later update, however doing so must result in update messages sent to notify all nodes of our updated relay fee. The default value of a single satoshi roughly matches the market rate on many routing nodes as of July 2021. Adjusting it upwards or downwards may change whether nodes route through this node. Default value: 1000. [`forwarding_fee_proportional_millionths`]: ChannelConfig::forwarding_fee_proportional_millionths
  - set_forwarding_fee_base_msat
```
public void set_forwarding_fee_base_msat(int val)
```
    Amount (in milli-satoshi) charged for payments forwarded outbound over the channel, in excess of [`forwarding_fee_proportional_millionths`]. This may be allowed to change at runtime in a later update, however doing so must result in update messages sent to notify all nodes of our updated relay fee. The default value of a single satoshi roughly matches the market rate on many routing nodes as of July 2021. Adjusting it upwards or downwards may change whether nodes route through this node. Default value: 1000. [`forwarding_fee_proportional_millionths`]: ChannelConfig::forwarding_fee_proportional_millionths
  - get_cltv_expiry_delta
```
public short get_cltv_expiry_delta()
```
    The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over the channel this config applies to. This is analogous to [`ChannelHandshakeConfig::our_to_self_delay`] but applies to in-flight HTLC balance when a channel appears on-chain whereas [`ChannelHandshakeConfig::our_to_self_delay`] applies to the remaining (non-HTLC-encumbered) balance. Thus, for HTLC-encumbered balances to be enforced on-chain when a channel is force-closed, we (or one of our watchtowers) MUST be online to check for broadcast of the current commitment transaction at least once per this many blocks (minus some margin to allow us enough time to broadcast and confirm a transaction, possibly with time in between to RBF the spending transaction). Default value: 72 (12 hours at an average of 6 blocks/hour). Minimum value: [`MIN_CLTV_EXPIRY_DELTA`], any values less than this will be treated as [`MIN_CLTV_EXPIRY_DELTA`] instead. [`MIN_CLTV_EXPIRY_DELTA`]: crate::ln::channelmanager::MIN_CLTV_EXPIRY_DELTA
  - set_cltv_expiry_delta
```
public void set_cltv_expiry_delta(short val)
```
    The difference in the CLTV value between incoming HTLCs and an outbound HTLC forwarded over the channel this config applies to. This is analogous to [`ChannelHandshakeConfig::our_to_self_delay`] but applies to in-flight HTLC balance when a channel appears on-chain whereas [`ChannelHandshakeConfig::our_to_self_delay`] applies to the remaining (non-HTLC-encumbered) balance. Thus, for HTLC-encumbered balances to be enforced on-chain when a channel is force-closed, we (or one of our watchtowers) MUST be online to check for broadcast of the current commitment transaction at least once per this many blocks (minus some margin to allow us enough time to broadcast and confirm a transaction, possibly with time in between to RBF the spending transaction). Default value: 72 (12 hours at an average of 6 blocks/hour). Minimum value: [`MIN_CLTV_EXPIRY_DELTA`], any values less than this will be treated as [`MIN_CLTV_EXPIRY_DELTA`] instead. [`MIN_CLTV_EXPIRY_DELTA`]: crate::ln::channelmanager::MIN_CLTV_EXPIRY_DELTA
  - get_max_dust_htlc_exposure
```
public MaxDustHTLCExposure get_max_dust_htlc_exposure()
```
    Limit our total exposure to in-flight HTLCs which are burned to fees as they are too small to claim on-chain. When an HTLC present in one of our channels is below a \"dust\" threshold, the HTLC will not be claimable on-chain, instead being turned into additional miner fees if either party force-closes the channel. Because the threshold is per-HTLC, our total exposure to such payments may be sustantial if there are many dust HTLCs present when the channel is force-closed. The dust threshold for each HTLC is based on the `dust_limit_satoshis` for each party in a channel negotiated throughout the channel open process, along with the fees required to have a broadcastable HTLC spending transaction. When a channel supports anchor outputs (specifically the zero fee HTLC transaction variant), this threshold no longer takes into account the HTLC transaction fee as it is zero. Because of this, you may want to set this value to a fixed limit for channels using anchor outputs, while the fee rate multiplier variant is primarily intended for use with pre-anchor channels. The selected limit is applied for sent, forwarded, and received HTLCs and limits the total exposure across all three types per-channel. Default value: [`MaxDustHTLCExposure::FeeRateMultiplier`] with a multiplier of 5000.
  - set_max_dust_htlc_exposure
```
public void set_max_dust_htlc_exposure(MaxDustHTLCExposure val)
```
    Limit our total exposure to in-flight HTLCs which are burned to fees as they are too small to claim on-chain. When an HTLC present in one of our channels is below a \"dust\" threshold, the HTLC will not be claimable on-chain, instead being turned into additional miner fees if either party force-closes the channel. Because the threshold is per-HTLC, our total exposure to such payments may be sustantial if there are many dust HTLCs present when the channel is force-closed. The dust threshold for each HTLC is based on the `dust_limit_satoshis` for each party in a channel negotiated throughout the channel open process, along with the fees required to have a broadcastable HTLC spending transaction. When a channel supports anchor outputs (specifically the zero fee HTLC transaction variant), this threshold no longer takes into account the HTLC transaction fee as it is zero. Because of this, you may want to set this value to a fixed limit for channels using anchor outputs, while the fee rate multiplier variant is primarily intended for use with pre-anchor channels. The selected limit is applied for sent, forwarded, and received HTLCs and limits the total exposure across all three types per-channel. Default value: [`MaxDustHTLCExposure::FeeRateMultiplier`] with a multiplier of 5000.
  - get_force_close_avoidance_max_fee_satoshis
```
public long get_force_close_avoidance_max_fee_satoshis()
```
    The additional fee we're willing to pay to avoid waiting for the counterparty's `to_self_delay` to reclaim funds. When we close a channel cooperatively with our counterparty, we negotiate a fee for the closing transaction which both sides find acceptable, ultimately paid by the channel funder/initiator. When we are the funder, because we have to pay the channel closing fee, we bound the acceptable fee by our [`Background`] and [`Normal`] fees, with the upper bound increased by this value. Because the on-chain fee we'd pay to force-close the channel is kept near our [`Normal`] feerate during normal operation, this value represents the additional fee we're willing to pay in order to avoid waiting for our counterparty's to_self_delay to reclaim our funds. When we are not the funder, we require the closing transaction fee pay at least our [`Background`] fee estimate, but allow our counterparty to pay as much fee as they like. Thus, this value is ignored when we are not the funder. Default value: 1000 satoshis. [`Normal`]: crate::chain::chaininterface::ConfirmationTarget::Normal [`Background`]: crate::chain::chaininterface::ConfirmationTarget::Background
  - set_force_close_avoidance_max_fee_satoshis
```
public void set_force_close_avoidance_max_fee_satoshis(long val)
```
    The additional fee we're willing to pay to avoid waiting for the counterparty's `to_self_delay` to reclaim funds. When we close a channel cooperatively with our counterparty, we negotiate a fee for the closing transaction which both sides find acceptable, ultimately paid by the channel funder/initiator. When we are the funder, because we have to pay the channel closing fee, we bound the acceptable fee by our [`Background`] and [`Normal`] fees, with the upper bound increased by this value. Because the on-chain fee we'd pay to force-close the channel is kept near our [`Normal`] feerate during normal operation, this value represents the additional fee we're willing to pay in order to avoid waiting for our counterparty's to_self_delay to reclaim our funds. When we are not the funder, we require the closing transaction fee pay at least our [`Background`] fee estimate, but allow our counterparty to pay as much fee as they like. Thus, this value is ignored when we are not the funder. Default value: 1000 satoshis. [`Normal`]: crate::chain::chaininterface::ConfirmationTarget::Normal [`Background`]: crate::chain::chaininterface::ConfirmationTarget::Background
  - get_accept_underpaying_htlcs
```
public boolean get_accept_underpaying_htlcs()
```
    If set, allows this channel's counterparty to skim an additional fee off this node's inbound HTLCs. Useful for liquidity providers to offload on-chain channel costs to end users. Usage: - The payee will set this option and set its invoice route hints to use [intercept scids] generated by this channel's counterparty. - The counterparty will get an [`HTLCIntercepted`] event upon payment forward, and call [`forward_intercepted_htlc`] with less than the amount provided in [`HTLCIntercepted::expected_outbound_amount_msat`]. The difference between the expected and actual forward amounts is their fee. # Note It's important for payee wallet software to verify that [`PaymentClaimable::amount_msat`] is as-expected if this feature is activated, otherwise they may lose money! [`PaymentClaimable::counterparty_skimmed_fee_msat`] provides the fee taken by the counterparty. # Note Switching this config flag on may break compatibility with versions of LDK prior to 0.0.116. Unsetting this flag between restarts may lead to payment receive failures. Default value: false. [intercept scids]: crate::ln::channelmanager::ChannelManager::get_intercept_scid [`forward_intercepted_htlc`]: crate::ln::channelmanager::ChannelManager::forward_intercepted_htlc [`HTLCIntercepted`]: crate::events::Event::HTLCIntercepted [`HTLCIntercepted::expected_outbound_amount_msat`]: crate::events::Event::HTLCIntercepted::expected_outbound_amount_msat [`PaymentClaimable::amount_msat`]: crate::events::Event::PaymentClaimable::amount_msat [`PaymentClaimable::counterparty_skimmed_fee_msat`]: crate::events::Event::PaymentClaimable::counterparty_skimmed_fee_msat
  - set_accept_underpaying_htlcs
```
public void set_accept_underpaying_htlcs(boolean val)
```
    If set, allows this channel's counterparty to skim an additional fee off this node's inbound HTLCs. Useful for liquidity providers to offload on-chain channel costs to end users. Usage: - The payee will set this option and set its invoice route hints to use [intercept scids] generated by this channel's counterparty. - The counterparty will get an [`HTLCIntercepted`] event upon payment forward, and call [`forward_intercepted_htlc`] with less than the amount provided in [`HTLCIntercepted::expected_outbound_amount_msat`]. The difference between the expected and actual forward amounts is their fee. # Note It's important for payee wallet software to verify that [`PaymentClaimable::amount_msat`] is as-expected if this feature is activated, otherwise they may lose money! [`PaymentClaimable::counterparty_skimmed_fee_msat`] provides the fee taken by the counterparty. # Note Switching this config flag on may break compatibility with versions of LDK prior to 0.0.116. Unsetting this flag between restarts may lead to payment receive failures. Default value: false. [intercept scids]: crate::ln::channelmanager::ChannelManager::get_intercept_scid [`forward_intercepted_htlc`]: crate::ln::channelmanager::ChannelManager::forward_intercepted_htlc [`HTLCIntercepted`]: crate::events::Event::HTLCIntercepted [`HTLCIntercepted::expected_outbound_amount_msat`]: crate::events::Event::HTLCIntercepted::expected_outbound_amount_msat [`PaymentClaimable::amount_msat`]: crate::events::Event::PaymentClaimable::amount_msat [`PaymentClaimable::counterparty_skimmed_fee_msat`]: crate::events::Event::PaymentClaimable::counterparty_skimmed_fee_msat
  - of
```
public static ChannelConfig of(int forwarding_fee_proportional_millionths_arg,
                               int forwarding_fee_base_msat_arg,
                               short cltv_expiry_delta_arg,
                               MaxDustHTLCExposure max_dust_htlc_exposure_arg,
                               long force_close_avoidance_max_fee_satoshis_arg,
                               boolean accept_underpaying_htlcs_arg)
```
    Constructs a new ChannelConfig given each field
  - clone
```
public ChannelConfig clone()
```
    Creates a copy of the ChannelConfig
    
    Overrides:
    
    clone in class Object
  - eq
```
public boolean eq(ChannelConfig b)
```
    Checks if two ChannelConfigs contain equal inner contents. This ignores pointers and is_owned flags and looks at the values in fields. Two objects with NULL inner values will be considered "equal" here.
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - apply
```
public void apply(ChannelConfigUpdate update)
```
    Applies the given [`ChannelConfigUpdate`] as a partial update to the [`ChannelConfig`].
  - with_default
```
public static ChannelConfig with_default()
```
    Creates a "default" ChannelConfig. See struct and individual field documentaiton for details on which values are used.
  - write
```
public byte[] write()
```
    Serialize the ChannelConfig object into a byte array which can be read by ChannelConfig_read
  - read
```
public static Result_ChannelConfigDecodeErrorZ read(byte[] ser)
```
    Read a ChannelConfig from a byte array, created by ChannelConfig_write

Class ChannelConfig

Method Summary

Methods inherited from class java.lang.Object

Method Detail

finalize

get_forwarding_fee_proportional_millionths

set_forwarding_fee_proportional_millionths

get_forwarding_fee_base_msat

set_forwarding_fee_base_msat

get_cltv_expiry_delta

set_cltv_expiry_delta

get_max_dust_htlc_exposure

set_max_dust_htlc_exposure

get_force_close_avoidance_max_fee_satoshis

set_force_close_avoidance_max_fee_satoshis

get_accept_underpaying_htlcs

set_accept_underpaying_htlcs

of

clone

eq

equals

apply

with_default

write

read