#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
pub(crate) extern "C" fn ChannelHandshakeConfig_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelHandshakeConfig)).clone() })) as *mut c_void
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeChannelHandshakeConfig)).clone() })) as *mut c_void
}
#[no_mangle]
/// Creates a copy of the ChannelHandshakeConfig
pub extern "C" fn ChannelHandshakeConfig_clone(orig: &ChannelHandshakeConfig) -> ChannelHandshakeConfig {
orig.clone()
}
+/// Get a string which allows debug introspection of a ChannelHandshakeConfig object
+pub extern "C" fn ChannelHandshakeConfig_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::util::config::ChannelHandshakeConfig }).into()}
/// Creates a "default" ChannelHandshakeConfig. See struct and individual field documentaiton for details on which values are used.
#[must_use]
#[no_mangle]
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
pub(crate) extern "C" fn ChannelHandshakeLimits_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelHandshakeLimits)).clone() })) as *mut c_void
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeChannelHandshakeLimits)).clone() })) as *mut c_void
}
#[no_mangle]
/// Creates a copy of the ChannelHandshakeLimits
pub extern "C" fn ChannelHandshakeLimits_clone(orig: &ChannelHandshakeLimits) -> ChannelHandshakeLimits {
orig.clone()
}
+/// Get a string which allows debug introspection of a ChannelHandshakeLimits object
+pub extern "C" fn ChannelHandshakeLimits_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::util::config::ChannelHandshakeLimits }).into()}
/// Creates a "default" ChannelHandshakeLimits. See struct and individual field documentaiton for details on which values are used.
#[must_use]
#[no_mangle]
pub extern "C" fn ChannelHandshakeLimits_default() -> ChannelHandshakeLimits {
ChannelHandshakeLimits { inner: ObjOps::heap_alloc(Default::default()), is_owned: true }
}
-/// Options for how to set the max dust HTLC exposure allowed on a channel. See
+/// Options for how to set the max dust exposure allowed on a channel. See
/// [`ChannelConfig::max_dust_htlc_exposure`] for details.
#[derive(Clone)]
#[must_use]
/// exposure and the new minimum value for HTLCs to be economically viable to claim.
FixedLimitMsat(
u64),
- /// This sets a multiplier on the estimated high priority feerate (sats/KW, as obtained from
- /// [`FeeEstimator`]) to determine the maximum allowed dust exposure. If this variant is used
- /// then the maximum dust exposure in millisatoshis is calculated as:
- /// `high_priority_feerate_per_kw * value`. For example, with our default value
- /// `FeeRateMultiplier(5000)`:
+ /// This sets a multiplier on the [`ConfirmationTarget::OnChainSweep`] feerate (in sats/KW) to
+ /// determine the maximum allowed dust exposure. If this variant is used then the maximum dust
+ /// exposure in millisatoshis is calculated as:
+ /// `feerate_per_kw * value`. For example, with our default value
+ /// `FeeRateMultiplier(10_000)`:
///
/// - For the minimum fee rate of 1 sat/vByte (250 sat/KW, although the minimum
/// defaults to 253 sats/KW for rounding, see [`FeeEstimator`]), the max dust exposure would
- /// be 253 * 5000 = 1,265,000 msats.
+ /// be 253 * 10_000 = 2,530,000 msats.
/// - For a fee rate of 30 sat/vByte (7500 sat/KW), the max dust exposure would be
- /// 7500 * 5000 = 37,500,000 msats.
- ///
- /// This allows the maximum dust exposure to automatically scale with fee rate changes.
+ /// 7500 * 50_000 = 75,000,000 msats (0.00075 BTC).
///
/// Note, if you're using a third-party fee estimator, this may leave you more exposed to a
/// fee griefing attack, where your fee estimator may purposely overestimate the fee rate,
/// by default this will be set to a [`Self::FixedLimitMsat`] of 5,000,000 msat.
///
/// [`FeeEstimator`]: crate::chain::chaininterface::FeeEstimator
+ /// [`ConfirmationTarget::OnChainSweep`]: crate::chain::chaininterface::ConfirmationTarget::OnChainSweep
FeeRateMultiplier(
u64),
}
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeMaxDustHTLCExposure) -> Self {
+ pub(crate) fn from_native(native: &MaxDustHTLCExposureImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeMaxDustHTLCExposure) };
match native {
nativeMaxDustHTLCExposure::FixedLimitMsat (ref a, ) => {
let mut a_nonref = Clone::clone(a);
pub extern "C" fn MaxDustHTLCExposure_clone(orig: &MaxDustHTLCExposure) -> MaxDustHTLCExposure {
orig.clone()
}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn MaxDustHTLCExposure_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const MaxDustHTLCExposure)).clone() })) as *mut c_void
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn MaxDustHTLCExposure_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut MaxDustHTLCExposure) };
+}
#[no_mangle]
/// Utility method to constructs a new FixedLimitMsat-variant MaxDustHTLCExposure
pub extern "C" fn MaxDustHTLCExposure_fixed_limit_msat(a: u64) -> MaxDustHTLCExposure {
pub extern "C" fn MaxDustHTLCExposure_fee_rate_multiplier(a: u64) -> MaxDustHTLCExposure {
MaxDustHTLCExposure::FeeRateMultiplier(a, )
}
+/// Get a string which allows debug introspection of a MaxDustHTLCExposure object
+pub extern "C" fn MaxDustHTLCExposure_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::util::config::MaxDustHTLCExposure }).into()}
/// Checks if two MaxDustHTLCExposures contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
pub extern "C" fn MaxDustHTLCExposure_write(obj: &crate::lightning::util::config::MaxDustHTLCExposure) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
}
+#[allow(unused)]
+pub(crate) extern "C" fn MaxDustHTLCExposure_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ MaxDustHTLCExposure_write(unsafe { &*(obj as *const MaxDustHTLCExposure) })
+}
#[no_mangle]
/// Read a MaxDustHTLCExposure from a byte array, created by MaxDustHTLCExposure_write
pub extern "C" fn MaxDustHTLCExposure_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_MaxDustHTLCExposureDecodeErrorZ {
pub extern "C" fn ChannelConfig_set_cltv_expiry_delta(this_ptr: &mut ChannelConfig, mut val: u16) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry_delta = val;
}
-/// Limit our total exposure to in-flight HTLCs which are burned to fees as they are too
-/// small to claim on-chain.
+/// Limit our total exposure to potential loss to on-chain fees on close, including in-flight
+/// HTLCs which are burned to fees as they are too small to claim on-chain and fees on
+/// commitment transaction(s) broadcasted by our counterparty in excess of our own fee estimate.
+///
+/// # HTLC-based Dust Exposure
///
/// 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
+/// to such payments may be substantial 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
/// 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.
+/// # Transaction Fee Dust Exposure
+///
+/// Further, counterparties broadcasting a commitment transaction in a force-close may result
+/// in other balance being burned to fees, and thus all fees on commitment and HTLC
+/// transactions in excess of our local fee estimates are included in the dust calculation.
+///
+/// Because of this, another way to look at this limit is to divide it by 43,000 (or 218,750
+/// for non-anchor channels) and see it as the maximum feerate disagreement (in sats/vB) per
+/// non-dust HTLC we're allowed to have with our peers before risking a force-closure for
+/// inbound channels.
+///
+/// Thus, for the default value of 10_000 * a current feerate estimate of 10 sat/vB (or 2,500
+/// sat/KW), we risk force-closure if we disagree with our peer by:
+/// * `10_000 * 2_500 / 43_000 / (483*2)` = 0.6 sat/vB for anchor channels with 483 HTLCs in
+/// both directions (the maximum),
+/// * `10_000 * 2_500 / 43_000 / (50*2)` = 5.8 sat/vB for anchor channels with 50 HTLCs in both
+/// directions (the LDK default max from [`ChannelHandshakeConfig::our_max_accepted_htlcs`])
+/// * `10_000 * 2_500 / 218_750 / (483*2)` = 0.1 sat/vB for non-anchor channels with 483 HTLCs
+/// in both directions (the maximum),
+/// * `10_000 * 2_500 / 218_750 / (50*2)` = 1.1 sat/vB for non-anchor channels with 50 HTLCs
+/// in both (the LDK default maximum from [`ChannelHandshakeConfig::our_max_accepted_htlcs`])
+///
+/// Note that when using [`MaxDustHTLCExposure::FeeRateMultiplier`] this maximum disagreement
+/// will scale linearly with increases (or decreases) in the our feerate estimates. Further,
+/// for anchor channels we expect our counterparty to use a relatively low feerate estimate
+/// while we use [`ConfirmationTarget::OnChainSweep`] (which should be relatively high) and
+/// feerate disagreement force-closures should only occur when theirs is higher than ours.
+///
+/// Default value: [`MaxDustHTLCExposure::FeeRateMultiplier`] with a multiplier of 10_000.
+///
+/// [`ConfirmationTarget::OnChainSweep`]: crate::chain::chaininterface::ConfirmationTarget::OnChainSweep
#[no_mangle]
pub extern "C" fn ChannelConfig_get_max_dust_htlc_exposure(this_ptr: &ChannelConfig) -> crate::lightning::util::config::MaxDustHTLCExposure {
let mut inner_val = &mut this_ptr.get_native_mut_ref().max_dust_htlc_exposure;
crate::lightning::util::config::MaxDustHTLCExposure::from_native(inner_val)
}
-/// Limit our total exposure to in-flight HTLCs which are burned to fees as they are too
-/// small to claim on-chain.
+/// Limit our total exposure to potential loss to on-chain fees on close, including in-flight
+/// HTLCs which are burned to fees as they are too small to claim on-chain and fees on
+/// commitment transaction(s) broadcasted by our counterparty in excess of our own fee estimate.
+///
+/// # HTLC-based Dust Exposure
///
/// 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
+/// to such payments may be substantial 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
/// 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.
+/// # Transaction Fee Dust Exposure
+///
+/// Further, counterparties broadcasting a commitment transaction in a force-close may result
+/// in other balance being burned to fees, and thus all fees on commitment and HTLC
+/// transactions in excess of our local fee estimates are included in the dust calculation.
+///
+/// Because of this, another way to look at this limit is to divide it by 43,000 (or 218,750
+/// for non-anchor channels) and see it as the maximum feerate disagreement (in sats/vB) per
+/// non-dust HTLC we're allowed to have with our peers before risking a force-closure for
+/// inbound channels.
+///
+/// Thus, for the default value of 10_000 * a current feerate estimate of 10 sat/vB (or 2,500
+/// sat/KW), we risk force-closure if we disagree with our peer by:
+/// * `10_000 * 2_500 / 43_000 / (483*2)` = 0.6 sat/vB for anchor channels with 483 HTLCs in
+/// both directions (the maximum),
+/// * `10_000 * 2_500 / 43_000 / (50*2)` = 5.8 sat/vB for anchor channels with 50 HTLCs in both
+/// directions (the LDK default max from [`ChannelHandshakeConfig::our_max_accepted_htlcs`])
+/// * `10_000 * 2_500 / 218_750 / (483*2)` = 0.1 sat/vB for non-anchor channels with 483 HTLCs
+/// in both directions (the maximum),
+/// * `10_000 * 2_500 / 218_750 / (50*2)` = 1.1 sat/vB for non-anchor channels with 50 HTLCs
+/// in both (the LDK default maximum from [`ChannelHandshakeConfig::our_max_accepted_htlcs`])
+///
+/// Note that when using [`MaxDustHTLCExposure::FeeRateMultiplier`] this maximum disagreement
+/// will scale linearly with increases (or decreases) in the our feerate estimates. Further,
+/// for anchor channels we expect our counterparty to use a relatively low feerate estimate
+/// while we use [`ConfirmationTarget::OnChainSweep`] (which should be relatively high) and
+/// feerate disagreement force-closures should only occur when theirs is higher than ours.
+///
+/// Default value: [`MaxDustHTLCExposure::FeeRateMultiplier`] with a multiplier of 10_000.
+///
+/// [`ConfirmationTarget::OnChainSweep`]: crate::chain::chaininterface::ConfirmationTarget::OnChainSweep
#[no_mangle]
pub extern "C" fn ChannelConfig_set_max_dust_htlc_exposure(this_ptr: &mut ChannelConfig, mut val: crate::lightning::util::config::MaxDustHTLCExposure) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_dust_htlc_exposure = val.into_native();
/// 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
+/// acceptable fee by our [`ChannelCloseMinimum`] and [`NonAnchorChannelFee`] 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
+/// [`NonAnchorChannelFee`] 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.
+/// [`ChannelCloseMinimum`] 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
+/// [`NonAnchorChannelFee`]: crate::chain::chaininterface::ConfirmationTarget::NonAnchorChannelFee
+/// [`ChannelCloseMinimum`]: crate::chain::chaininterface::ConfirmationTarget::ChannelCloseMinimum
#[no_mangle]
pub extern "C" fn ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: &ChannelConfig) -> u64 {
let mut inner_val = &mut this_ptr.get_native_mut_ref().force_close_avoidance_max_fee_satoshis;
/// 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
+/// acceptable fee by our [`ChannelCloseMinimum`] and [`NonAnchorChannelFee`] 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
+/// [`NonAnchorChannelFee`] 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.
+/// [`ChannelCloseMinimum`] 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
+/// [`NonAnchorChannelFee`]: crate::chain::chaininterface::ConfirmationTarget::NonAnchorChannelFee
+/// [`ChannelCloseMinimum`]: crate::chain::chaininterface::ConfirmationTarget::ChannelCloseMinimum
#[no_mangle]
pub extern "C" fn ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: &mut ChannelConfig, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.force_close_avoidance_max_fee_satoshis = val;
/// - 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.
+/// actual forward amounts is their fee. See
+/// <https://github.com/BitcoinAndLightningLayerSpecs/lsp/tree/main/LSPS2#flow-lsp-trusts-client-model>
+/// for how this feature may be used in the LSP use case.
///
/// # Note
/// It's important for payee wallet software to verify that [`PaymentClaimable::amount_msat`] is
/// - 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.
+/// actual forward amounts is their fee. See
+/// <https://github.com/BitcoinAndLightningLayerSpecs/lsp/tree/main/LSPS2#flow-lsp-trusts-client-model>
+/// for how this feature may be used in the LSP use case.
///
/// # Note
/// It's important for payee wallet software to verify that [`PaymentClaimable::amount_msat`] is
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
pub(crate) extern "C" fn ChannelConfig_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelConfig)).clone() })) as *mut c_void
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeChannelConfig)).clone() })) as *mut c_void
}
#[no_mangle]
/// Creates a copy of the ChannelConfig
pub extern "C" fn ChannelConfig_clone(orig: &ChannelConfig) -> ChannelConfig {
orig.clone()
}
+/// Get a string which allows debug introspection of a ChannelConfig object
+pub extern "C" fn ChannelConfig_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::util::config::ChannelConfig }).into()}
/// 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.
pub extern "C" fn ChannelConfig_write(obj: &crate::lightning::util::config::ChannelConfig) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
}
-#[no_mangle]
+#[allow(unused)]
pub(crate) extern "C" fn ChannelConfig_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelConfig) })
}
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
pub(crate) extern "C" fn UserConfig_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUserConfig)).clone() })) as *mut c_void
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeUserConfig)).clone() })) as *mut c_void
}
#[no_mangle]
/// Creates a copy of the UserConfig
pub extern "C" fn UserConfig_clone(orig: &UserConfig) -> UserConfig {
orig.clone()
}
+/// Get a string which allows debug introspection of a UserConfig object
+pub extern "C" fn UserConfig_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::util::config::UserConfig }).into()}
/// Creates a "default" UserConfig. See struct and individual field documentaiton for details on which values are used.
#[must_use]
#[no_mangle]
projects / ldk-c-bindings / blobdiff