+pub extern "C" fn ProbabilisticScoringParameters_get_historical_liquidity_penalty_multiplier_msat(this_ptr: &ProbabilisticScoringParameters) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().historical_liquidity_penalty_multiplier_msat;
+ *inner_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
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_set_historical_liquidity_penalty_multiplier_msat(this_ptr: &mut ProbabilisticScoringParameters, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.historical_liquidity_penalty_multiplier_msat = val;
+}
+/// A multiplier used in conjunction with the payment amount 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 the `2^20`ths
+/// of the payment amount, 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
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_get_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: &ProbabilisticScoringParameters) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().historical_liquidity_penalty_amount_multiplier_msat;
+ *inner_val
+}
+/// A multiplier used in conjunction with the payment amount 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 the `2^20`ths
+/// of the payment amount, 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
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_set_historical_liquidity_penalty_amount_multiplier_msat(this_ptr: &mut ProbabilisticScoringParameters, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.historical_liquidity_penalty_amount_multiplier_msat = val;
+}
+/// If we aren't learning any new datapoints for a channel, the historical liquidity bounds
+/// tracking can simply live on with increasingly stale data. Instead, when a channel has not
+/// seen a liquidity estimate update for this amount of time, the historical datapoints are
+/// decayed by half.
+///
+/// Note that after 16 or more half lives all historical data will be completely gone.
+///
+/// Default value: 14 days
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_get_historical_no_updates_half_life(this_ptr: &ProbabilisticScoringParameters) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().historical_no_updates_half_life;
+ inner_val.as_secs()
+}
+/// If we aren't learning any new datapoints for a channel, the historical liquidity bounds
+/// tracking can simply live on with increasingly stale data. Instead, when a channel has not
+/// seen a liquidity estimate update for this amount of time, the historical datapoints are
+/// decayed by half.
+///
+/// Note that after 16 or more half lives all historical data will be completely gone.
+///
+/// Default value: 14 days
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_set_historical_no_updates_half_life(this_ptr: &mut ProbabilisticScoringParameters, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.historical_no_updates_half_life = core::time::Duration::from_secs(val);
+}
+/// This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the
+/// channel's 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
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: &ProbabilisticScoringParameters) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().anti_probing_penalty_msat;
+ *inner_val
+}
+/// This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the
+/// channel's 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
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: &mut ProbabilisticScoringParameters, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.anti_probing_penalty_msat = val;
+}
+/// This penalty is applied when the amount we're attempting to send over a channel exceeds our
+/// current estimate of the channel's available liquidity.
+///
+/// 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
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: &ProbabilisticScoringParameters) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().considered_impossible_penalty_msat;
+ *inner_val
+}
+/// This penalty is applied when the amount we're attempting to send over a channel exceeds our
+/// current estimate of the channel's available liquidity.
+///
+/// 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
+#[no_mangle]
+pub extern "C" fn ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: &mut ProbabilisticScoringParameters, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.considered_impossible_penalty_msat = val;