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

```
public class ProbabilisticScoringFeeParameters
extends Object
```
Parameters for configuring [`ProbabilisticScorer`]. Used to configure base, liquidity, and amount penalties, the sum of which comprises the channel penalty (i.e., the amount in msats willing to be paid to avoid routing through the channel). The penalty applied to any channel by the [`ProbabilisticScorer`] is the sum of each of the parameters here.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`add_banned(NodeId node_id)`	Marks the node with the given `node_id` as banned, i.e it will be avoided during path finding.
`void`	`add_banned_from_list(NodeId[] node_ids)`	Marks all nodes in the given list as banned, i.e., they will be avoided during path finding.
`void`	`clear_manual_penalties()`	Clears the list of manual penalties that are applied during path finding.
`ProbabilisticScoringFeeParameters`	`clone()`	Creates a copy of the ProbabilisticScoringFeeParameters
`protected void`	`finalize()`
`long`	`get_anti_probing_penalty_msat()`	This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the channel's capacity, (ie.
`long`	`get_base_penalty_amount_multiplier_msat()`	A multiplier used with the total amount flowing over a channel to calculate a fixed penalty applied to each channel, in excess of the [`base_penalty_msat`].
`long`	`get_base_penalty_msat()`	A fixed penalty in msats to apply to each channel.
`long`	`get_considered_impossible_penalty_msat()`	This penalty is applied when the total amount flowing over a channel exceeds our current estimate of the channel's available liquidity.
`long`	`get_historical_liquidity_penalty_amount_multiplier_msat()`	A multiplier used in conjunction with the total amount flowing over a channel and the negative `log10` of the channel's success probability for the payment, as determined based on the history of our estimates of the channel's available liquidity, to determine a penalty.
`long`	`get_historical_liquidity_penalty_multiplier_msat()`	A multiplier used in conjunction with the negative `log10` of the channel's success probability for the payment, as determined based on the history of our estimates of the channel's available liquidity, to determine a penalty.
`boolean`	`get_linear_success_probability()`	In order to calculate most of the scores above, we must first convert a lower and upper bound on the available liquidity in a channel into the probability that we think a payment will succeed.
`long`	`get_liquidity_penalty_amount_multiplier_msat()`	A multiplier used in conjunction with the total amount flowing over a channel and the negative `log10` of the channel's success probability for the payment, as determined by our latest estimates of the channel's liquidity, to determine the amount penalty.
`long`	`get_liquidity_penalty_multiplier_msat()`	A multiplier used in conjunction with the negative `log10` of the channel's success probability for a payment, as determined by our latest estimates of the channel's liquidity, to determine the liquidity penalty.
`void`	`remove_banned(NodeId node_id)`	Removes the node with the given `node_id` from the list of nodes to avoid.
`void`	`remove_manual_penalty(NodeId node_id)`	Removes the node with the given `node_id` from the list of manual penalties.
`void`	`set_anti_probing_penalty_msat(long val)`	This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the channel's capacity, (ie.
`void`	`set_base_penalty_amount_multiplier_msat(long val)`	A multiplier used with the total amount flowing over a channel to calculate a fixed penalty applied to each channel, in excess of the [`base_penalty_msat`].
`void`	`set_base_penalty_msat(long val)`	A fixed penalty in msats to apply to each channel.
`void`	`set_considered_impossible_penalty_msat(long val)`	This penalty is applied when the total amount flowing over a channel exceeds our current estimate of the channel's available liquidity.
`void`	`set_historical_liquidity_penalty_amount_multiplier_msat(long val)`	A multiplier used in conjunction with the total amount flowing over a channel and the negative `log10` of the channel's success probability for the payment, as determined based on the history of our estimates of the channel's available liquidity, to determine a penalty.
`void`	`set_historical_liquidity_penalty_multiplier_msat(long val)`	A multiplier used in conjunction with the negative `log10` of the channel's success probability for the payment, as determined based on the history of our estimates of the channel's available liquidity, to determine a penalty.
`void`	`set_linear_success_probability(boolean val)`	In order to calculate most of the scores above, we must first convert a lower and upper bound on the available liquidity in a channel into the probability that we think a payment will succeed.
`void`	`set_liquidity_penalty_amount_multiplier_msat(long val)`	A multiplier used in conjunction with the total amount flowing over a channel and the negative `log10` of the channel's success probability for the payment, as determined by our latest estimates of the channel's liquidity, to determine the amount penalty.
`void`	`set_liquidity_penalty_multiplier_msat(long val)`	A multiplier used in conjunction with the negative `log10` of the channel's success probability for a payment, as determined by our latest estimates of the channel's liquidity, to determine the liquidity penalty.
`void`	`set_manual_penalty(NodeId node_id, long penalty)`	Sets a manual penalty for the given node.
`static ProbabilisticScoringFeeParameters`	`with_default()`	Creates a "default" ProbabilisticScoringFeeParameters.

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_base_penalty_msat
```
public long get_base_penalty_msat()
```
    A fixed penalty in msats to apply to each channel. Default value: 500 msat
  - set_base_penalty_msat
```
public void set_base_penalty_msat(long val)
```
    A fixed penalty in msats to apply to each channel. Default value: 500 msat
  - get_base_penalty_amount_multiplier_msat
```
public long get_base_penalty_amount_multiplier_msat()
```
    A multiplier used with the total amount flowing over a channel to calculate a fixed penalty applied to each channel, in excess of the [`base_penalty_msat`]. The purpose of the amount penalty is to avoid having fees dominate the channel cost (i.e., fees plus penalty) for large payments. The penalty is computed as the product of this multiplier and `2^30`ths of the total amount flowing over a channel (i.e. the payment amount plus the amount of any other HTLCs flowing we sent over the same channel). ie `base_penalty_amount_multiplier_msat * amount_msat / 2^30` Default value: 8,192 msat [`base_penalty_msat`]: Self::base_penalty_msat
  - set_base_penalty_amount_multiplier_msat
```
public void set_base_penalty_amount_multiplier_msat(long val)
```
    A multiplier used with the total amount flowing over a channel to calculate a fixed penalty applied to each channel, in excess of the [`base_penalty_msat`]. The purpose of the amount penalty is to avoid having fees dominate the channel cost (i.e., fees plus penalty) for large payments. The penalty is computed as the product of this multiplier and `2^30`ths of the total amount flowing over a channel (i.e. the payment amount plus the amount of any other HTLCs flowing we sent over the same channel). ie `base_penalty_amount_multiplier_msat * amount_msat / 2^30` Default value: 8,192 msat [`base_penalty_msat`]: Self::base_penalty_msat
  - get_liquidity_penalty_multiplier_msat
```
public long get_liquidity_penalty_multiplier_msat()
```
    A multiplier used in conjunction with the negative `log10` of the channel's success probability for a payment, as determined by our latest estimates of the channel's liquidity, to determine the liquidity penalty. The penalty is based in part on the knowledge learned from prior successful and unsuccessful payments. This knowledge is decayed over time based on [`liquidity_offset_half_life`]. The penalty is effectively limited to `2 * liquidity_penalty_multiplier_msat` (corresponding to lower bounding the success probability to `0.01`) when the amount falls within the uncertainty bounds of the channel liquidity balance. Amounts above the upper bound will result in a `u64::max_value` penalty, however. `-log10(success_probability) * liquidity_penalty_multiplier_msat` Default value: 30,000 msat [`liquidity_offset_half_life`]: ProbabilisticScoringDecayParameters::liquidity_offset_half_life
  - set_liquidity_penalty_multiplier_msat
```
public void set_liquidity_penalty_multiplier_msat(long val)
```
    A multiplier used in conjunction with the negative `log10` of the channel's success probability for a payment, as determined by our latest estimates of the channel's liquidity, to determine the liquidity penalty. The penalty is based in part on the knowledge learned from prior successful and unsuccessful payments. This knowledge is decayed over time based on [`liquidity_offset_half_life`]. The penalty is effectively limited to `2 * liquidity_penalty_multiplier_msat` (corresponding to lower bounding the success probability to `0.01`) when the amount falls within the uncertainty bounds of the channel liquidity balance. Amounts above the upper bound will result in a `u64::max_value` penalty, however. `-log10(success_probability) * liquidity_penalty_multiplier_msat` Default value: 30,000 msat [`liquidity_offset_half_life`]: ProbabilisticScoringDecayParameters::liquidity_offset_half_life
  - get_liquidity_penalty_amount_multiplier_msat
```
public long get_liquidity_penalty_amount_multiplier_msat()
```
    A multiplier used in conjunction with the total amount flowing over a channel and the negative `log10` of the channel's success probability for the payment, as determined by our latest estimates of the channel's liquidity, to determine the amount penalty. The purpose of the amount penalty is to avoid having fees dominate the channel cost (i.e., fees plus penalty) for large payments. The penalty is computed as the product of this multiplier and `2^20`ths of the amount flowing over this channel, weighted by the negative `log10` of the success probability. `-log10(success_probability) * liquidity_penalty_amount_multiplier_msat * amount_msat / 2^20` In practice, this means for 0.1 success probability (`-log10(0.1) == 1`) each `2^20`th of the amount will result in a penalty of the multiplier. And, as the success probability decreases, the negative `log10` weighting will increase dramatically. For higher success probabilities, the multiplier will have a decreasing effect as the negative `log10` will fall below `1`. Default value: 192 msat
  - set_liquidity_penalty_amount_multiplier_msat
```
public void set_liquidity_penalty_amount_multiplier_msat(long val)
```
    A multiplier used in conjunction with the total amount flowing over a channel and the negative `log10` of the channel's success probability for the payment, as determined by our latest estimates of the channel's liquidity, to determine the amount penalty. The purpose of the amount penalty is to avoid having fees dominate the channel cost (i.e., fees plus penalty) for large payments. The penalty is computed as the product of this multiplier and `2^20`ths of the amount flowing over this channel, weighted by the negative `log10` of the success probability. `-log10(success_probability) * liquidity_penalty_amount_multiplier_msat * amount_msat / 2^20` In practice, this means for 0.1 success probability (`-log10(0.1) == 1`) each `2^20`th of the amount will result in a penalty of the multiplier. And, as the success probability decreases, the negative `log10` weighting will increase dramatically. For higher success probabilities, the multiplier will have a decreasing effect as the negative `log10` will fall below `1`. Default value: 192 msat
  - get_historical_liquidity_penalty_multiplier_msat
```
public long get_historical_liquidity_penalty_multiplier_msat()
```
    A multiplier used in conjunction with the negative `log10` of the channel's success probability for the payment, as determined based on the history of our estimates of the channel's available liquidity, to determine a penalty. This penalty is similar to [`liquidity_penalty_multiplier_msat`], however, instead of using only our latest estimate for the current liquidity available in the channel, it estimates success probability based on the estimated liquidity available in the channel through history. Specifically, every time we update our liquidity bounds on a given channel, we track which of several buckets those bounds fall into, exponentially decaying the probability of each bucket as new samples are added. Default value: 10,000 msat [`liquidity_penalty_multiplier_msat`]: Self::liquidity_penalty_multiplier_msat
  - set_historical_liquidity_penalty_multiplier_msat
```
public void set_historical_liquidity_penalty_multiplier_msat(long val)
```
    A multiplier used in conjunction with the negative `log10` of the channel's success probability for the payment, as determined based on the history of our estimates of the channel's available liquidity, to determine a penalty. This penalty is similar to [`liquidity_penalty_multiplier_msat`], however, instead of using only our latest estimate for the current liquidity available in the channel, it estimates success probability based on the estimated liquidity available in the channel through history. Specifically, every time we update our liquidity bounds on a given channel, we track which of several buckets those bounds fall into, exponentially decaying the probability of each bucket as new samples are added. Default value: 10,000 msat [`liquidity_penalty_multiplier_msat`]: Self::liquidity_penalty_multiplier_msat
  - get_historical_liquidity_penalty_amount_multiplier_msat
```
public long get_historical_liquidity_penalty_amount_multiplier_msat()
```
    A multiplier used in conjunction with the total amount flowing over a channel and the negative `log10` of the channel's success probability for the payment, as determined based on the history of our estimates of the channel's available liquidity, to determine a penalty. The purpose of the amount penalty is to avoid having fees dominate the channel cost for large payments. The penalty is computed as the product of this multiplier and `2^20`ths of the amount flowing over this channel, weighted by the negative `log10` of the success probability. This penalty is similar to [`liquidity_penalty_amount_multiplier_msat`], however, instead of using only our latest estimate for the current liquidity available in the channel, it estimates success probability based on the estimated liquidity available in the channel through history. Specifically, every time we update our liquidity bounds on a given channel, we track which of several buckets those bounds fall into, exponentially decaying the probability of each bucket as new samples are added. Default value: 64 msat [`liquidity_penalty_amount_multiplier_msat`]: Self::liquidity_penalty_amount_multiplier_msat
  - set_historical_liquidity_penalty_amount_multiplier_msat
```
public void set_historical_liquidity_penalty_amount_multiplier_msat(long val)
```
    A multiplier used in conjunction with the total amount flowing over a channel and the negative `log10` of the channel's success probability for the payment, as determined based on the history of our estimates of the channel's available liquidity, to determine a penalty. The purpose of the amount penalty is to avoid having fees dominate the channel cost for large payments. The penalty is computed as the product of this multiplier and `2^20`ths of the amount flowing over this channel, weighted by the negative `log10` of the success probability. This penalty is similar to [`liquidity_penalty_amount_multiplier_msat`], however, instead of using only our latest estimate for the current liquidity available in the channel, it estimates success probability based on the estimated liquidity available in the channel through history. Specifically, every time we update our liquidity bounds on a given channel, we track which of several buckets those bounds fall into, exponentially decaying the probability of each bucket as new samples are added. Default value: 64 msat [`liquidity_penalty_amount_multiplier_msat`]: Self::liquidity_penalty_amount_multiplier_msat
  - get_anti_probing_penalty_msat
```
public long get_anti_probing_penalty_msat()
```
    This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the channel's capacity, (ie. htlc_maximum_msat >= 0.5 * channel_capacity) which makes us prefer nodes with a smaller `htlc_maximum_msat`. We treat such nodes preferentially as this makes balance discovery attacks harder to execute, thereby creating an incentive to restrict `htlc_maximum_msat` and improve privacy. Default value: 250 msat
  - set_anti_probing_penalty_msat
```
public void set_anti_probing_penalty_msat(long val)
```
    This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the channel's capacity, (ie. htlc_maximum_msat >= 0.5 * channel_capacity) which makes us prefer nodes with a smaller `htlc_maximum_msat`. We treat such nodes preferentially as this makes balance discovery attacks harder to execute, thereby creating an incentive to restrict `htlc_maximum_msat` and improve privacy. Default value: 250 msat
  - get_considered_impossible_penalty_msat
```
public long get_considered_impossible_penalty_msat()
```
    This penalty is applied when the total amount flowing over a channel exceeds our current estimate of the channel's available liquidity. The total amount is the amount of the current HTLC plus any HTLCs which we've sent over the same channel. Note that in this case all other penalties, including the [`liquidity_penalty_multiplier_msat`] and [`liquidity_penalty_amount_multiplier_msat`]-based penalties, as well as the [`base_penalty_msat`] and the [`anti_probing_penalty_msat`], if applicable, are still included in the overall penalty. If you wish to avoid creating paths with such channels entirely, setting this to a value of `u64::max_value()` will guarantee that. Default value: 1_0000_0000_000 msat (1 Bitcoin) [`liquidity_penalty_multiplier_msat`]: Self::liquidity_penalty_multiplier_msat [`liquidity_penalty_amount_multiplier_msat`]: Self::liquidity_penalty_amount_multiplier_msat [`base_penalty_msat`]: Self::base_penalty_msat [`anti_probing_penalty_msat`]: Self::anti_probing_penalty_msat
  - set_considered_impossible_penalty_msat
```
public void set_considered_impossible_penalty_msat(long val)
```
    This penalty is applied when the total amount flowing over a channel exceeds our current estimate of the channel's available liquidity. The total amount is the amount of the current HTLC plus any HTLCs which we've sent over the same channel. Note that in this case all other penalties, including the [`liquidity_penalty_multiplier_msat`] and [`liquidity_penalty_amount_multiplier_msat`]-based penalties, as well as the [`base_penalty_msat`] and the [`anti_probing_penalty_msat`], if applicable, are still included in the overall penalty. If you wish to avoid creating paths with such channels entirely, setting this to a value of `u64::max_value()` will guarantee that. Default value: 1_0000_0000_000 msat (1 Bitcoin) [`liquidity_penalty_multiplier_msat`]: Self::liquidity_penalty_multiplier_msat [`liquidity_penalty_amount_multiplier_msat`]: Self::liquidity_penalty_amount_multiplier_msat [`base_penalty_msat`]: Self::base_penalty_msat [`anti_probing_penalty_msat`]: Self::anti_probing_penalty_msat
  - get_linear_success_probability
```
public boolean get_linear_success_probability()
```
    In order to calculate most of the scores above, we must first convert a lower and upper bound on the available liquidity in a channel into the probability that we think a payment will succeed. That probability is derived from a Probability Density Function for where we think the liquidity in a channel likely lies, given such bounds. If this flag is set, that PDF is simply a constant - we assume that the actual available liquidity in a channel is just as likely to be at any point between our lower and upper bounds. If this flag is *not* set, that PDF is `(x - 0.5*capacity) ^ 2`. That is, we use an exponential curve which expects the liquidity of a channel to lie \"at the edges\". This matches experimental results - most routing nodes do not aggressively rebalance their channels and flows in the network are often unbalanced, leaving liquidity usually unavailable. Thus, for the \"best\" routes, leave this flag `false`. However, the flag does imply a number of floating-point multiplications in the hottest routing code, which may lead to routing performance degradation on some machines. Default value: false
  - set_linear_success_probability
```
public void set_linear_success_probability(boolean val)
```
    In order to calculate most of the scores above, we must first convert a lower and upper bound on the available liquidity in a channel into the probability that we think a payment will succeed. That probability is derived from a Probability Density Function for where we think the liquidity in a channel likely lies, given such bounds. If this flag is set, that PDF is simply a constant - we assume that the actual available liquidity in a channel is just as likely to be at any point between our lower and upper bounds. If this flag is *not* set, that PDF is `(x - 0.5*capacity) ^ 2`. That is, we use an exponential curve which expects the liquidity of a channel to lie \"at the edges\". This matches experimental results - most routing nodes do not aggressively rebalance their channels and flows in the network are often unbalanced, leaving liquidity usually unavailable. Thus, for the \"best\" routes, leave this flag `false`. However, the flag does imply a number of floating-point multiplications in the hottest routing code, which may lead to routing performance degradation on some machines. Default value: false
  - clone
```
public ProbabilisticScoringFeeParameters clone()
```
    Creates a copy of the ProbabilisticScoringFeeParameters
    
    Overrides:
    
    clone in class Object
  - with_default
```
public static ProbabilisticScoringFeeParameters with_default()
```
    Creates a "default" ProbabilisticScoringFeeParameters. See struct and individual field documentaiton for details on which values are used.
  - add_banned
```
public void add_banned(NodeId node_id)
```
    Marks the node with the given `node_id` as banned, i.e it will be avoided during path finding.
  - add_banned_from_list
```
public void add_banned_from_list(NodeId[] node_ids)
```
    Marks all nodes in the given list as banned, i.e., they will be avoided during path finding.
  - remove_banned
```
public void remove_banned(NodeId node_id)
```
    Removes the node with the given `node_id` from the list of nodes to avoid.
  - set_manual_penalty
```
public void set_manual_penalty(NodeId node_id,
                               long penalty)
```
    Sets a manual penalty for the given node.
  - remove_manual_penalty
```
public void remove_manual_penalty(NodeId node_id)
```
    Removes the node with the given `node_id` from the list of manual penalties.
  - clear_manual_penalties
```
public void clear_manual_penalties()
```
    Clears the list of manual penalties that are applied during path finding.

Class ProbabilisticScoringFeeParameters

Method Summary

Methods inherited from class java.lang.Object

Method Detail

finalize

get_base_penalty_msat

set_base_penalty_msat

get_base_penalty_amount_multiplier_msat

set_base_penalty_amount_multiplier_msat

get_liquidity_penalty_multiplier_msat

set_liquidity_penalty_multiplier_msat

get_liquidity_penalty_amount_multiplier_msat

set_liquidity_penalty_amount_multiplier_msat

get_historical_liquidity_penalty_multiplier_msat

set_historical_liquidity_penalty_multiplier_msat

get_historical_liquidity_penalty_amount_multiplier_msat

set_historical_liquidity_penalty_amount_multiplier_msat

get_anti_probing_penalty_msat

set_anti_probing_penalty_msat

get_considered_impossible_penalty_msat

set_considered_impossible_penalty_msat

get_linear_success_probability

set_linear_success_probability

clone

with_default

add_banned

add_banned_from_list

remove_banned

set_manual_penalty

remove_manual_penalty

clear_manual_penalties