X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Flightning%2Fevents%2Fmod.rs;h=1e53afb7cc367126e1e192c1413976557311ce68;hb=0ac4dbdb8352c898100b34f0ef8ed9cebfea7786;hp=cfef8ae249ca4628a3d7915868aa7ebe92d1d916;hpb=48e3445a78b643c837e7d489d90588eb877d0319;p=ldk-c-bindings diff --git a/lightning-c-bindings/src/lightning/events/mod.rs b/lightning-c-bindings/src/lightning/events/mod.rs index cfef8ae..1e53afb 100644 --- a/lightning-c-bindings/src/lightning/events/mod.rs +++ b/lightning-c-bindings/src/lightning/events/mod.rs @@ -14,6 +14,7 @@ //! few other things. use alloc::str::FromStr; +use alloc::string::String; use core::ffi::c_void; use core::convert::Infallible; use bitcoin::hashes::Hash; @@ -36,7 +37,7 @@ pub enum PaymentPurpose { /// /// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds - payment_preimage: crate::c_types::derived::COption_PaymentPreimageZ, + payment_preimage: crate::c_types::derived::COption_ThirtyTwoBytesZ, /// The \"payment secret\". This authenticates the sender to the recipient, preventing a /// number of deanonymization attacks during the routing process. /// It is provided here for your reference, however its accuracy is enforced directly by @@ -96,11 +97,12 @@ impl PaymentPurpose { } } #[allow(unused)] - pub(crate) fn from_native(native: &nativePaymentPurpose) -> Self { + pub(crate) fn from_native(native: &PaymentPurposeImport) -> Self { + let native = unsafe { &*(native as *const _ as *const c_void as *const nativePaymentPurpose) }; match native { nativePaymentPurpose::InvoicePayment {ref payment_preimage, ref payment_secret, } => { let mut payment_preimage_nonref = Clone::clone(payment_preimage); - let mut local_payment_preimage_nonref = if payment_preimage_nonref.is_none() { crate::c_types::derived::COption_PaymentPreimageZ::None } else { crate::c_types::derived::COption_PaymentPreimageZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_preimage_nonref.unwrap().0 } }) }; + let mut local_payment_preimage_nonref = if payment_preimage_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_preimage_nonref.unwrap().0 } }) }; let mut payment_secret_nonref = Clone::clone(payment_secret); PaymentPurpose::InvoicePayment { payment_preimage: local_payment_preimage_nonref, @@ -119,7 +121,7 @@ impl PaymentPurpose { pub(crate) fn native_into(native: nativePaymentPurpose) -> Self { match native { nativePaymentPurpose::InvoicePayment {mut payment_preimage, mut payment_secret, } => { - let mut local_payment_preimage = if payment_preimage.is_none() { crate::c_types::derived::COption_PaymentPreimageZ::None } else { crate::c_types::derived::COption_PaymentPreimageZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_preimage.unwrap().0 } }) }; + let mut local_payment_preimage = if payment_preimage.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_preimage.unwrap().0 } }) }; PaymentPurpose::InvoicePayment { payment_preimage: local_payment_preimage, payment_secret: crate::c_types::ThirtyTwoBytes { data: payment_secret.0 }, @@ -141,9 +143,19 @@ pub extern "C" fn PaymentPurpose_free(this_ptr: PaymentPurpose) { } pub extern "C" fn PaymentPurpose_clone(orig: &PaymentPurpose) -> PaymentPurpose { 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 PaymentPurpose_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const PaymentPurpose)).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 PaymentPurpose_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut PaymentPurpose) }; +} #[no_mangle] /// Utility method to constructs a new InvoicePayment-variant PaymentPurpose -pub extern "C" fn PaymentPurpose_invoice_payment(payment_preimage: crate::c_types::derived::COption_PaymentPreimageZ, payment_secret: crate::c_types::ThirtyTwoBytes) -> PaymentPurpose { +pub extern "C" fn PaymentPurpose_invoice_payment(payment_preimage: crate::c_types::derived::COption_ThirtyTwoBytesZ, payment_secret: crate::c_types::ThirtyTwoBytes) -> PaymentPurpose { PaymentPurpose::InvoicePayment { payment_preimage, payment_secret, @@ -154,17 +166,33 @@ pub extern "C" fn PaymentPurpose_invoice_payment(payment_preimage: crate::c_type pub extern "C" fn PaymentPurpose_spontaneous_payment(a: crate::c_types::ThirtyTwoBytes) -> PaymentPurpose { PaymentPurpose::SpontaneousPayment(a, ) } +/// Get a string which allows debug introspection of a PaymentPurpose object +pub extern "C" fn PaymentPurpose_debug_str_void(o: *const c_void) -> Str { + alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::PaymentPurpose }).into()} /// Checks if two PaymentPurposes contain equal inner contents. /// This ignores pointers and is_owned flags and looks at the values in fields. #[no_mangle] pub extern "C" fn PaymentPurpose_eq(a: &PaymentPurpose, b: &PaymentPurpose) -> bool { if &a.to_native() == &b.to_native() { true } else { false } } +/// Returns the preimage for this payment, if it is known. +#[must_use] +#[no_mangle] +pub extern "C" fn PaymentPurpose_preimage(this_arg: &crate::lightning::events::PaymentPurpose) -> crate::c_types::derived::COption_ThirtyTwoBytesZ { + let mut ret = this_arg.to_native().preimage(); + let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: ret.unwrap().0 } }) }; + local_ret +} + #[no_mangle] /// Serialize the PaymentPurpose object into a byte array which can be read by PaymentPurpose_read pub extern "C" fn PaymentPurpose_write(obj: &crate::lightning::events::PaymentPurpose) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(&unsafe { &*obj }.to_native()) } +#[allow(unused)] +pub(crate) extern "C" fn PaymentPurpose_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + PaymentPurpose_write(unsafe { &*(obj as *const PaymentPurpose) }) +} #[no_mangle] /// Read a PaymentPurpose from a byte array, created by PaymentPurpose_write pub extern "C" fn PaymentPurpose_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PaymentPurposeDecodeErrorZ { @@ -172,6 +200,201 @@ pub extern "C" fn PaymentPurpose_read(ser: crate::c_types::u8slice) -> crate::c_ let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::events::PaymentPurpose::native_into(o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() }; local_res } + +use lightning::events::ClaimedHTLC as nativeClaimedHTLCImport; +pub(crate) type nativeClaimedHTLC = nativeClaimedHTLCImport; + +/// Information about an HTLC that is part of a payment that can be claimed. +#[must_use] +#[repr(C)] +pub struct ClaimedHTLC { + /// A pointer to the opaque Rust object. + + /// Nearly everywhere, inner must be non-null, however in places where + /// the Rust equivalent takes an Option, it may be set to null to indicate None. + pub inner: *mut nativeClaimedHTLC, + /// Indicates that this is the only struct which contains the same pointer. + + /// Rust functions which take ownership of an object provided via an argument require + /// this to be true and invalidate the object pointed to by inner. + pub is_owned: bool, +} + +impl Drop for ClaimedHTLC { + fn drop(&mut self) { + if self.is_owned && !<*mut nativeClaimedHTLC>::is_null(self.inner) { + let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) }; + } + } +} +/// Frees any resources used by the ClaimedHTLC, if is_owned is set and inner is non-NULL. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_free(this_obj: ClaimedHTLC) { } +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ClaimedHTLC_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut nativeClaimedHTLC) }; +} +#[allow(unused)] +impl ClaimedHTLC { + pub(crate) fn get_native_ref(&self) -> &'static nativeClaimedHTLC { + unsafe { &*ObjOps::untweak_ptr(self.inner) } + } + pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeClaimedHTLC { + unsafe { &mut *ObjOps::untweak_ptr(self.inner) } + } + /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy + pub(crate) fn take_inner(mut self) -> *mut nativeClaimedHTLC { + assert!(self.is_owned); + let ret = ObjOps::untweak_ptr(self.inner); + self.inner = core::ptr::null_mut(); + ret + } +} +/// The `channel_id` of the channel over which the HTLC was received. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_get_channel_id(this_ptr: &ClaimedHTLC) -> *const [u8; 32] { + let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id; + &inner_val.0 +} +/// The `channel_id` of the channel over which the HTLC was received. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_set_channel_id(this_ptr: &mut ClaimedHTLC, mut val: crate::c_types::ThirtyTwoBytes) { + unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data); +} +/// The `user_channel_id` of the channel over which the HTLC was received. This is the value +/// passed in to [`ChannelManager::create_channel`] for outbound channels, or to +/// [`ChannelManager::accept_inbound_channel`] for inbound channels if +/// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise +/// `user_channel_id` will be randomized for an inbound channel. +/// +/// This field will be zero for a payment that was serialized prior to LDK version 0.0.117. (This +/// should only happen in the case that a payment was claimable prior to LDK version 0.0.117, but +/// was not actually claimed until after upgrading.) +/// +/// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel +/// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel +/// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels +#[no_mangle] +pub extern "C" fn ClaimedHTLC_get_user_channel_id(this_ptr: &ClaimedHTLC) -> crate::c_types::U128 { + let mut inner_val = &mut this_ptr.get_native_mut_ref().user_channel_id; + inner_val.into() +} +/// The `user_channel_id` of the channel over which the HTLC was received. This is the value +/// passed in to [`ChannelManager::create_channel`] for outbound channels, or to +/// [`ChannelManager::accept_inbound_channel`] for inbound channels if +/// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise +/// `user_channel_id` will be randomized for an inbound channel. +/// +/// This field will be zero for a payment that was serialized prior to LDK version 0.0.117. (This +/// should only happen in the case that a payment was claimable prior to LDK version 0.0.117, but +/// was not actually claimed until after upgrading.) +/// +/// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel +/// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel +/// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels +#[no_mangle] +pub extern "C" fn ClaimedHTLC_set_user_channel_id(this_ptr: &mut ClaimedHTLC, mut val: crate::c_types::U128) { + unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.user_channel_id = val.into(); +} +/// The block height at which this HTLC expires. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_get_cltv_expiry(this_ptr: &ClaimedHTLC) -> u32 { + let mut inner_val = &mut this_ptr.get_native_mut_ref().cltv_expiry; + *inner_val +} +/// The block height at which this HTLC expires. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_set_cltv_expiry(this_ptr: &mut ClaimedHTLC, mut val: u32) { + unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry = val; +} +/// The amount (in msats) of this part of an MPP. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_get_value_msat(this_ptr: &ClaimedHTLC) -> u64 { + let mut inner_val = &mut this_ptr.get_native_mut_ref().value_msat; + *inner_val +} +/// The amount (in msats) of this part of an MPP. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_set_value_msat(this_ptr: &mut ClaimedHTLC, mut val: u64) { + unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.value_msat = val; +} +/// The extra fee our counterparty skimmed off the top of this HTLC, if any. +/// +/// This value will always be 0 for [`ClaimedHTLC`]s serialized with LDK versions prior to +/// 0.0.119. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_get_counterparty_skimmed_fee_msat(this_ptr: &ClaimedHTLC) -> u64 { + let mut inner_val = &mut this_ptr.get_native_mut_ref().counterparty_skimmed_fee_msat; + *inner_val +} +/// The extra fee our counterparty skimmed off the top of this HTLC, if any. +/// +/// This value will always be 0 for [`ClaimedHTLC`]s serialized with LDK versions prior to +/// 0.0.119. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_set_counterparty_skimmed_fee_msat(this_ptr: &mut ClaimedHTLC, mut val: u64) { + unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.counterparty_skimmed_fee_msat = val; +} +/// Constructs a new ClaimedHTLC given each field +#[must_use] +#[no_mangle] +pub extern "C" fn ClaimedHTLC_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut user_channel_id_arg: crate::c_types::U128, mut cltv_expiry_arg: u32, mut value_msat_arg: u64, mut counterparty_skimmed_fee_msat_arg: u64) -> ClaimedHTLC { + ClaimedHTLC { inner: ObjOps::heap_alloc(nativeClaimedHTLC { + channel_id: ::lightning::ln::ChannelId(channel_id_arg.data), + user_channel_id: user_channel_id_arg.into(), + cltv_expiry: cltv_expiry_arg, + value_msat: value_msat_arg, + counterparty_skimmed_fee_msat: counterparty_skimmed_fee_msat_arg, + }), is_owned: true } +} +impl Clone for ClaimedHTLC { + fn clone(&self) -> Self { + Self { + inner: if <*mut nativeClaimedHTLC>::is_null(self.inner) { core::ptr::null_mut() } else { + ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) }, + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn ClaimedHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeClaimedHTLC)).clone() })) as *mut c_void +} +#[no_mangle] +/// Creates a copy of the ClaimedHTLC +pub extern "C" fn ClaimedHTLC_clone(orig: &ClaimedHTLC) -> ClaimedHTLC { + orig.clone() +} +/// Get a string which allows debug introspection of a ClaimedHTLC object +pub extern "C" fn ClaimedHTLC_debug_str_void(o: *const c_void) -> Str { + alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::ClaimedHTLC }).into()} +/// Checks if two ClaimedHTLCs 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. +#[no_mangle] +pub extern "C" fn ClaimedHTLC_eq(a: &ClaimedHTLC, b: &ClaimedHTLC) -> bool { + if a.inner == b.inner { return true; } + if a.inner.is_null() || b.inner.is_null() { return false; } + if a.get_native_ref() == b.get_native_ref() { true } else { false } +} +#[no_mangle] +/// Serialize the ClaimedHTLC object into a byte array which can be read by ClaimedHTLC_read +pub extern "C" fn ClaimedHTLC_write(obj: &crate::lightning::events::ClaimedHTLC) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref()) +} +#[allow(unused)] +pub(crate) extern "C" fn ClaimedHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeClaimedHTLC) }) +} +#[no_mangle] +/// Read a ClaimedHTLC from a byte array, created by ClaimedHTLC_write +pub extern "C" fn ClaimedHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ClaimedHTLCDecodeErrorZ { + let res: Result = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::events::ClaimedHTLC { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() }; + local_res +} /// When the payment path failure took place and extra details about it. [`PathFailure::OnPath`] may /// contain a [`NetworkUpdate`] that needs to be applied to the [`NetworkGraph`]. /// @@ -236,7 +459,8 @@ impl PathFailure { } } #[allow(unused)] - pub(crate) fn from_native(native: &nativePathFailure) -> Self { + pub(crate) fn from_native(native: &PathFailureImport) -> Self { + let native = unsafe { &*(native as *const _ as *const c_void as *const nativePathFailure) }; match native { nativePathFailure::InitialSend {ref err, } => { let mut err_nonref = Clone::clone(err); @@ -278,6 +502,16 @@ pub extern "C" fn PathFailure_free(this_ptr: PathFailure) { } pub extern "C" fn PathFailure_clone(orig: &PathFailure) -> PathFailure { 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 PathFailure_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const PathFailure)).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 PathFailure_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut PathFailure) }; +} #[no_mangle] /// Utility method to constructs a new InitialSend-variant PathFailure pub extern "C" fn PathFailure_initial_send(err: crate::lightning::util::errors::APIError) -> PathFailure { @@ -292,6 +526,9 @@ pub extern "C" fn PathFailure_on_path(network_update: crate::c_types::derived::C network_update, } } +/// Get a string which allows debug introspection of a PathFailure object +pub extern "C" fn PathFailure_debug_str_void(o: *const c_void) -> Str { + alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::PathFailure }).into()} /// Checks if two PathFailures contain equal inner contents. /// This ignores pointers and is_owned flags and looks at the values in fields. #[no_mangle] @@ -303,6 +540,10 @@ pub extern "C" fn PathFailure_eq(a: &PathFailure, b: &PathFailure) -> bool { pub extern "C" fn PathFailure_write(obj: &crate::lightning::events::PathFailure) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(&unsafe { &*obj }.to_native()) } +#[allow(unused)] +pub(crate) extern "C" fn PathFailure_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + PathFailure_write(unsafe { &*(obj as *const PathFailure) }) +} #[no_mangle] /// Read a PathFailure from a byte array, created by PathFailure_write pub extern "C" fn PathFailure_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_PathFailureZDecodeErrorZ { @@ -367,6 +608,9 @@ pub enum ClosureReason { /// The counterparty requested a cooperative close of a channel that had not been funded yet. /// The channel has been immediately closed. CounterpartyCoopClosedUnfundedChannel, + /// Another channel in the same funding batch closed before the funding transaction + /// was ready to be broadcast. + FundingBatchClosure, } use lightning::events::ClosureReason as ClosureReasonImport; pub(crate) type nativeClosureReason = ClosureReasonImport; @@ -394,6 +638,7 @@ impl ClosureReason { ClosureReason::DisconnectedPeer => nativeClosureReason::DisconnectedPeer, ClosureReason::OutdatedChannelManager => nativeClosureReason::OutdatedChannelManager, ClosureReason::CounterpartyCoopClosedUnfundedChannel => nativeClosureReason::CounterpartyCoopClosedUnfundedChannel, + ClosureReason::FundingBatchClosure => nativeClosureReason::FundingBatchClosure, } } #[allow(unused)] @@ -416,10 +661,12 @@ impl ClosureReason { ClosureReason::DisconnectedPeer => nativeClosureReason::DisconnectedPeer, ClosureReason::OutdatedChannelManager => nativeClosureReason::OutdatedChannelManager, ClosureReason::CounterpartyCoopClosedUnfundedChannel => nativeClosureReason::CounterpartyCoopClosedUnfundedChannel, + ClosureReason::FundingBatchClosure => nativeClosureReason::FundingBatchClosure, } } #[allow(unused)] - pub(crate) fn from_native(native: &nativeClosureReason) -> Self { + pub(crate) fn from_native(native: &ClosureReasonImport) -> Self { + let native = unsafe { &*(native as *const _ as *const c_void as *const nativeClosureReason) }; match native { nativeClosureReason::CounterpartyForceClosed {ref peer_msg, } => { let mut peer_msg_nonref = Clone::clone(peer_msg); @@ -440,6 +687,7 @@ impl ClosureReason { nativeClosureReason::DisconnectedPeer => ClosureReason::DisconnectedPeer, nativeClosureReason::OutdatedChannelManager => ClosureReason::OutdatedChannelManager, nativeClosureReason::CounterpartyCoopClosedUnfundedChannel => ClosureReason::CounterpartyCoopClosedUnfundedChannel, + nativeClosureReason::FundingBatchClosure => ClosureReason::FundingBatchClosure, } } #[allow(unused)] @@ -462,6 +710,7 @@ impl ClosureReason { nativeClosureReason::DisconnectedPeer => ClosureReason::DisconnectedPeer, nativeClosureReason::OutdatedChannelManager => ClosureReason::OutdatedChannelManager, nativeClosureReason::CounterpartyCoopClosedUnfundedChannel => ClosureReason::CounterpartyCoopClosedUnfundedChannel, + nativeClosureReason::FundingBatchClosure => ClosureReason::FundingBatchClosure, } } } @@ -473,6 +722,16 @@ pub extern "C" fn ClosureReason_free(this_ptr: ClosureReason) { } pub extern "C" fn ClosureReason_clone(orig: &ClosureReason) -> ClosureReason { 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 ClosureReason_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const ClosureReason)).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 ClosureReason_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut ClosureReason) }; +} #[no_mangle] /// Utility method to constructs a new CounterpartyForceClosed-variant ClosureReason pub extern "C" fn ClosureReason_counterparty_force_closed(peer_msg: crate::lightning::util::string::UntrustedString) -> ClosureReason { @@ -515,6 +774,13 @@ pub extern "C" fn ClosureReason_outdated_channel_manager() -> ClosureReason { /// Utility method to constructs a new CounterpartyCoopClosedUnfundedChannel-variant ClosureReason pub extern "C" fn ClosureReason_counterparty_coop_closed_unfunded_channel() -> ClosureReason { ClosureReason::CounterpartyCoopClosedUnfundedChannel} +#[no_mangle] +/// Utility method to constructs a new FundingBatchClosure-variant ClosureReason +pub extern "C" fn ClosureReason_funding_batch_closure() -> ClosureReason { + ClosureReason::FundingBatchClosure} +/// Get a string which allows debug introspection of a ClosureReason object +pub extern "C" fn ClosureReason_debug_str_void(o: *const c_void) -> Str { + alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::ClosureReason }).into()} /// Checks if two ClosureReasons contain equal inner contents. /// This ignores pointers and is_owned flags and looks at the values in fields. #[no_mangle] @@ -526,6 +792,10 @@ pub extern "C" fn ClosureReason_eq(a: &ClosureReason, b: &ClosureReason) -> bool pub extern "C" fn ClosureReason_write(obj: &crate::lightning::events::ClosureReason) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(&unsafe { &*obj }.to_native()) } +#[allow(unused)] +pub(crate) extern "C" fn ClosureReason_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + ClosureReason_write(unsafe { &*(obj as *const ClosureReason) }) +} #[no_mangle] /// Read a ClosureReason from a byte array, created by ClosureReason_write pub extern "C" fn ClosureReason_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_ClosureReasonZDecodeErrorZ { @@ -589,7 +859,7 @@ impl HTLCDestination { let mut channel_id_nonref = Clone::clone(channel_id); nativeHTLCDestination::NextHopChannel { node_id: local_node_id_nonref, - channel_id: channel_id_nonref.data, + channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data), } }, HTLCDestination::UnknownNextHop {ref requested_forward_scid, } => { @@ -619,7 +889,7 @@ impl HTLCDestination { let mut local_node_id = if node_id.is_null() { None } else { Some( { node_id.into_rust() }) }; nativeHTLCDestination::NextHopChannel { node_id: local_node_id, - channel_id: channel_id.data, + channel_id: ::lightning::ln::ChannelId(channel_id.data), } }, HTLCDestination::UnknownNextHop {mut requested_forward_scid, } => { @@ -640,7 +910,8 @@ impl HTLCDestination { } } #[allow(unused)] - pub(crate) fn from_native(native: &nativeHTLCDestination) -> Self { + pub(crate) fn from_native(native: &HTLCDestinationImport) -> Self { + let native = unsafe { &*(native as *const _ as *const c_void as *const nativeHTLCDestination) }; match native { nativeHTLCDestination::NextHopChannel {ref node_id, ref channel_id, } => { let mut node_id_nonref = Clone::clone(node_id); @@ -648,7 +919,7 @@ impl HTLCDestination { let mut channel_id_nonref = Clone::clone(channel_id); HTLCDestination::NextHopChannel { node_id: local_node_id_nonref, - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 }, } }, nativeHTLCDestination::UnknownNextHop {ref requested_forward_scid, } => { @@ -678,7 +949,7 @@ impl HTLCDestination { let mut local_node_id = if node_id.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(node_id.unwrap())) } }; HTLCDestination::NextHopChannel { node_id: local_node_id, - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 }, } }, nativeHTLCDestination::UnknownNextHop {mut requested_forward_scid, } => { @@ -707,6 +978,16 @@ pub extern "C" fn HTLCDestination_free(this_ptr: HTLCDestination) { } pub extern "C" fn HTLCDestination_clone(orig: &HTLCDestination) -> HTLCDestination { 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 HTLCDestination_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const HTLCDestination)).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 HTLCDestination_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut HTLCDestination) }; +} #[no_mangle] /// Utility method to constructs a new NextHopChannel-variant HTLCDestination pub extern "C" fn HTLCDestination_next_hop_channel(node_id: crate::c_types::PublicKey, channel_id: crate::c_types::ThirtyTwoBytes) -> HTLCDestination { @@ -736,6 +1017,9 @@ pub extern "C" fn HTLCDestination_failed_payment(payment_hash: crate::c_types::T payment_hash, } } +/// Get a string which allows debug introspection of a HTLCDestination object +pub extern "C" fn HTLCDestination_debug_str_void(o: *const c_void) -> Str { + alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::HTLCDestination }).into()} /// Checks if two HTLCDestinations contain equal inner contents. /// This ignores pointers and is_owned flags and looks at the values in fields. #[no_mangle] @@ -747,6 +1031,10 @@ pub extern "C" fn HTLCDestination_eq(a: &HTLCDestination, b: &HTLCDestination) - pub extern "C" fn HTLCDestination_write(obj: &crate::lightning::events::HTLCDestination) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(&unsafe { &*obj }.to_native()) } +#[allow(unused)] +pub(crate) extern "C" fn HTLCDestination_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + HTLCDestination_write(unsafe { &*(obj as *const HTLCDestination) }) +} #[no_mangle] /// Read a HTLCDestination from a byte array, created by HTLCDestination_write pub extern "C" fn HTLCDestination_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_HTLCDestinationZDecodeErrorZ { @@ -810,7 +1098,8 @@ impl PaymentFailureReason { } } #[allow(unused)] - pub(crate) fn from_native(native: &nativePaymentFailureReason) -> Self { + pub(crate) fn from_native(native: &PaymentFailureReasonImport) -> Self { + let native = unsafe { &*(native as *const _ as *const c_void as *const nativePaymentFailureReason) }; match native { nativePaymentFailureReason::RecipientRejected => PaymentFailureReason::RecipientRejected, nativePaymentFailureReason::UserAbandoned => PaymentFailureReason::UserAbandoned, @@ -837,6 +1126,16 @@ impl PaymentFailureReason { pub extern "C" fn PaymentFailureReason_clone(orig: &PaymentFailureReason) -> PaymentFailureReason { 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 PaymentFailureReason_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const PaymentFailureReason)).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 PaymentFailureReason_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut PaymentFailureReason) }; +} #[no_mangle] /// Utility method to constructs a new RecipientRejected-variant PaymentFailureReason pub extern "C" fn PaymentFailureReason_recipient_rejected() -> PaymentFailureReason { @@ -861,6 +1160,9 @@ pub extern "C" fn PaymentFailureReason_route_not_found() -> PaymentFailureReason /// Utility method to constructs a new UnexpectedError-variant PaymentFailureReason pub extern "C" fn PaymentFailureReason_unexpected_error() -> PaymentFailureReason { PaymentFailureReason::UnexpectedError} +/// Get a string which allows debug introspection of a PaymentFailureReason object +pub extern "C" fn PaymentFailureReason_debug_str_void(o: *const c_void) -> Str { + alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::PaymentFailureReason }).into()} /// Checks if two PaymentFailureReasons contain equal inner contents. /// This ignores pointers and is_owned flags and looks at the values in fields. #[no_mangle] @@ -872,6 +1174,10 @@ pub extern "C" fn PaymentFailureReason_eq(a: &PaymentFailureReason, b: &PaymentF pub extern "C" fn PaymentFailureReason_write(obj: &crate::lightning::events::PaymentFailureReason) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(&unsafe { &*obj }.to_native()) } +#[allow(unused)] +pub(crate) extern "C" fn PaymentFailureReason_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + PaymentFailureReason_write(unsafe { &*(obj as *const PaymentFailureReason) }) +} #[no_mangle] /// Read a PaymentFailureReason from a byte array, created by PaymentFailureReason_write pub extern "C" fn PaymentFailureReason_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PaymentFailureReasonDecodeErrorZ { @@ -911,11 +1217,15 @@ pub enum Event { channel_value_satoshis: u64, /// The script which should be used in the transaction output. output_script: crate::c_types::derived::CVec_u8Z, - /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`], or a - /// random value for an inbound channel. This may be zero for objects serialized with LDK - /// versions prior to 0.0.113. + /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound + /// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if + /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise + /// `user_channel_id` will be randomized for an inbound channel. This may be zero for objects + /// serialized with LDK versions prior to 0.0.113. /// /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel + /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel + /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels user_channel_id: crate::c_types::U128, }, /// Indicates that we've been offered a payment and it needs to be claimed via calling @@ -924,9 +1234,19 @@ pub enum Event { /// Note that if the preimage is not known, you should call /// [`ChannelManager::fail_htlc_backwards`] or [`ChannelManager::fail_htlc_backwards_with_reason`] /// to free up resources for this HTLC and avoid network congestion. - /// If you fail to call either [`ChannelManager::claim_funds`], [`ChannelManager::fail_htlc_backwards`], - /// or [`ChannelManager::fail_htlc_backwards_with_reason`] within the HTLC's timeout, the HTLC will be - /// automatically failed. + /// + /// If [`Event::PaymentClaimable::onion_fields`] is `Some`, and includes custom TLVs with even type + /// numbers, you should use [`ChannelManager::fail_htlc_backwards_with_reason`] with + /// [`FailureCode::InvalidOnionPayload`] if you fail to understand and handle the contents, or + /// [`ChannelManager::claim_funds_with_known_custom_tlvs`] upon successful handling. + /// If you don't intend to check for custom TLVs, you can simply use + /// [`ChannelManager::claim_funds`], which will automatically fail back even custom TLVs. + /// + /// If you fail to call [`ChannelManager::claim_funds`], + /// [`ChannelManager::claim_funds_with_known_custom_tlvs`], + /// [`ChannelManager::fail_htlc_backwards`], or + /// [`ChannelManager::fail_htlc_backwards_with_reason`] within the HTLC's timeout, the HTLC will + /// be automatically failed. /// /// # Note /// LDK will not stop an inbound payment from being paid multiple times, so multiple @@ -938,6 +1258,8 @@ pub enum Event { /// This event used to be called `PaymentReceived` in LDK versions 0.0.112 and earlier. /// /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds + /// [`ChannelManager::claim_funds_with_known_custom_tlvs`]: crate::ln::channelmanager::ChannelManager::claim_funds_with_known_custom_tlvs + /// [`FailureCode::InvalidOnionPayload`]: crate::ln::channelmanager::FailureCode::InvalidOnionPayload /// [`ChannelManager::fail_htlc_backwards`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards /// [`ChannelManager::fail_htlc_backwards_with_reason`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards_with_reason PaymentClaimable { @@ -983,11 +1305,9 @@ pub enum Event { /// payment is to pay an invoice or to send a spontaneous payment. purpose: crate::lightning::events::PaymentPurpose, /// The `channel_id` indicating over which channel we received the payment. - /// - /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None - via_channel_id: crate::c_types::ThirtyTwoBytes, + via_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, /// The `user_channel_id` indicating over which channel we received the payment. - via_user_channel_id: crate::c_types::derived::COption_u128Z, + via_user_channel_id: crate::c_types::derived::COption_U128Z, /// The block height at which this payment will be failed back and will no longer be /// eligible for claiming. /// @@ -1030,6 +1350,43 @@ pub enum Event { /// The purpose of the claimed payment, i.e. whether the payment was for an invoice or a /// spontaneous payment. purpose: crate::lightning::events::PaymentPurpose, + /// The HTLCs that comprise the claimed payment. This will be empty for events serialized prior + /// to LDK version 0.0.117. + htlcs: crate::c_types::derived::CVec_ClaimedHTLCZ, + /// The sender-intended sum total of all the MPP parts. This will be `None` for events + /// serialized prior to LDK version 0.0.117. + sender_intended_total_msat: crate::c_types::derived::COption_u64Z, + }, + /// Indicates that a peer connection with a node is needed in order to send an [`OnionMessage`]. + /// + /// Typically, this happens when a [`MessageRouter`] is unable to find a complete path to a + /// [`Destination`]. Once a connection is established, any messages buffered by an + /// [`OnionMessageHandler`] may be sent. + /// + /// This event will not be generated for onion message forwards; only for sends including + /// replies. Handlers should connect to the node otherwise any buffered messages may be lost. + /// + /// [`OnionMessage`]: msgs::OnionMessage + /// [`MessageRouter`]: crate::onion_message::messenger::MessageRouter + /// [`Destination`]: crate::onion_message::messenger::Destination + /// [`OnionMessageHandler`]: crate::ln::msgs::OnionMessageHandler + ConnectionNeeded { + /// The node id for the node needing a connection. + node_id: crate::c_types::PublicKey, + /// Sockets for connecting to the node. + addresses: crate::c_types::derived::CVec_SocketAddressZ, + }, + /// Indicates a request for an invoice failed to yield a response in a reasonable amount of time + /// or was explicitly abandoned by [`ChannelManager::abandon_payment`]. This may be for an + /// [`InvoiceRequest`] sent for an [`Offer`] or for a [`Refund`] that hasn't been redeemed. + /// + /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment + /// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest + /// [`Offer`]: crate::offers::offer::Offer + /// [`Refund`]: crate::offers::refund::Refund + InvoiceRequestFailed { + /// The `payment_id` to have been associated with payment for the requested invoice. + payment_id: crate::c_types::ThirtyTwoBytes, }, /// Indicates an outbound payment we made succeeded (i.e. it made it all the way to its target /// and we got back the payment preimage for it). @@ -1040,7 +1397,7 @@ pub enum Event { /// The `payment_id` passed to [`ChannelManager::send_payment`]. /// /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment - payment_id: crate::c_types::derived::COption_PaymentIdZ, + payment_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, /// The preimage to the hash given to ChannelManager::send_payment. /// Note that this serves as a payment receipt, if you wish to have such a thing, you must /// store it somehow! @@ -1067,6 +1424,11 @@ pub enum Event { /// payment is no longer retryable, due either to the [`Retry`] provided or /// [`ChannelManager::abandon_payment`] having been called for the corresponding payment. /// + /// In exceedingly rare cases, it is possible that an [`Event::PaymentFailed`] is generated for + /// a payment after an [`Event::PaymentSent`] event for this same payment has already been + /// received and processed. In this case, the [`Event::PaymentFailed`] event MUST be ignored, + /// and the payment MUST be treated as having succeeded. + /// /// [`Retry`]: crate::ln::channelmanager::Retry /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment PaymentFailed { @@ -1096,7 +1458,7 @@ pub enum Event { /// This will be `Some` for all payments which completed on LDK 0.0.104 or later. /// /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment - payment_hash: crate::c_types::derived::COption_PaymentHashZ, + payment_hash: crate::c_types::derived::COption_ThirtyTwoBytesZ, /// The payment path that was successful. /// /// May contain a closed channel if the HTLC sent along the path was fulfilled on chain. @@ -1119,7 +1481,7 @@ pub enum Event { /// /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment - payment_id: crate::c_types::derived::COption_PaymentIdZ, + payment_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, /// The hash that was given to [`ChannelManager::send_payment`]. /// /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment @@ -1229,20 +1591,20 @@ pub enum Event { SpendableOutputs { /// The outputs which you should store as spendable by you. outputs: crate::c_types::derived::CVec_SpendableOutputDescriptorZ, + /// The `channel_id` indicating which channel the spendable outputs belong to. + /// + /// This will always be `Some` for events generated by LDK versions 0.0.117 and above. + channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, }, /// This event is generated when a payment has been successfully forwarded through us and a /// forwarding fee earned. PaymentForwarded { /// The incoming channel between the previous node and us. This is only `None` for events /// generated or serialized by versions prior to 0.0.107. - /// - /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None - prev_channel_id: crate::c_types::ThirtyTwoBytes, + prev_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, /// The outgoing channel between the next node and us. This is only `None` for events /// generated or serialized by versions prior to 0.0.107. - /// - /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None - next_channel_id: crate::c_types::ThirtyTwoBytes, + next_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, /// The fee, in milli-satoshis, which was earned as a result of the payment. /// /// Note that if we force-closed the channel over which we forwarded an HTLC while the HTLC @@ -1286,9 +1648,7 @@ pub enum Event { /// The `temporary_channel_id` this channel used to be known by during channel establishment. /// /// Will be `None` for channels created prior to LDK version 0.0.115. - /// - /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None - former_temporary_channel_id: crate::c_types::ThirtyTwoBytes, + former_temporary_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, /// The `node_id` of the channel counterparty. counterparty_node_id: crate::c_types::PublicKey, /// The outpoint of the channel's funding transaction. @@ -1317,6 +1677,13 @@ pub enum Event { }, /// Used to indicate that a previously opened channel with the given `channel_id` is in the /// process of closure. + /// + /// Note that this event is only triggered for accepted channels: if the + /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true and the channel is + /// rejected, no `ChannelClosed` event will be sent. + /// + /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel + /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels ChannelClosed { /// The `channel_id` of the channel which has been closed. Note that on-chain transactions /// resolving the channel are likely still awaiting confirmation. @@ -1334,9 +1701,27 @@ pub enum Event { user_channel_id: crate::c_types::U128, /// The reason the channel was closed. reason: crate::lightning::events::ClosureReason, + /// Counterparty in the closed channel. + /// + /// This field will be `None` for objects serialized prior to LDK 0.0.117. + /// + /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None + counterparty_node_id: crate::c_types::PublicKey, + /// Channel capacity of the closing channel (sats). + /// + /// This field will be `None` for objects serialized prior to LDK 0.0.117. + channel_capacity_sats: crate::c_types::derived::COption_u64Z, + /// The original channel funding TXO; this helps checking for the existence and confirmation + /// status of the closing tx. + /// Note that for instances serialized in v0.0.119 or prior this will be missing (None). + /// + /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None + channel_funding_txo: crate::lightning::chain::transaction::OutPoint, }, /// Used to indicate to the user that they can abandon the funding transaction and recycle the /// inputs for another purpose. + /// + /// This event is not guaranteed to be generated for channels that are closed due to a restart. DiscardFunding { /// The channel_id of the channel which has been closed. channel_id: crate::c_types::ThirtyTwoBytes, @@ -1345,8 +1730,9 @@ pub enum Event { }, /// Indicates a request to open a new channel by a peer. /// - /// To accept the request, call [`ChannelManager::accept_inbound_channel`]. To reject the - /// request, call [`ChannelManager::force_close_without_broadcasting_txn`]. + /// To accept the request, call [`ChannelManager::accept_inbound_channel`]. To reject the request, + /// call [`ChannelManager::force_close_without_broadcasting_txn`]. Note that a ['ChannelClosed`] + /// event will _not_ be triggered if the channel is rejected. /// /// The event is only triggered when a new open channel request is received and the /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. @@ -1438,10 +1824,10 @@ impl Event { let mut output_script_nonref = Clone::clone(output_script); let mut user_channel_id_nonref = Clone::clone(user_channel_id); nativeEvent::FundingGenerationReady { - temporary_channel_id: temporary_channel_id_nonref.data, + temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_nonref.data), counterparty_node_id: counterparty_node_id_nonref.into_rust(), channel_value_satoshis: channel_value_satoshis_nonref, - output_script: ::bitcoin::blockdata::script::Script::from(output_script_nonref.into_rust()), + output_script: ::bitcoin::blockdata::script::ScriptBuf::from(output_script_nonref.into_rust()), user_channel_id: user_channel_id_nonref.into(), } }, @@ -1455,7 +1841,7 @@ impl Event { let mut counterparty_skimmed_fee_msat_nonref = Clone::clone(counterparty_skimmed_fee_msat); let mut purpose_nonref = Clone::clone(purpose); let mut via_channel_id_nonref = Clone::clone(via_channel_id); - let mut local_via_channel_id_nonref = if via_channel_id_nonref.data == [0; 32] { None } else { Some( { via_channel_id_nonref.data }) }; + let mut local_via_channel_id_nonref = { /*via_channel_id_nonref*/ let via_channel_id_nonref_opt = via_channel_id_nonref; if via_channel_id_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ via_channel_id_nonref_opt.take() }.data) }})} }; let mut via_user_channel_id_nonref = Clone::clone(via_user_channel_id); let mut local_via_user_channel_id_nonref = { /*via_user_channel_id_nonref*/ let via_user_channel_id_nonref_opt = via_user_channel_id_nonref; if via_user_channel_id_nonref_opt.is_none() { None } else { Some({ { { via_user_channel_id_nonref_opt.take() }.into() }})} }; let mut claim_deadline_nonref = Clone::clone(claim_deadline); @@ -1472,17 +1858,38 @@ impl Event { claim_deadline: local_claim_deadline_nonref, } }, - Event::PaymentClaimed {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, } => { + Event::PaymentClaimed {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, ref htlcs, ref sender_intended_total_msat, } => { let mut receiver_node_id_nonref = Clone::clone(receiver_node_id); let mut local_receiver_node_id_nonref = if receiver_node_id_nonref.is_null() { None } else { Some( { receiver_node_id_nonref.into_rust() }) }; let mut payment_hash_nonref = Clone::clone(payment_hash); let mut amount_msat_nonref = Clone::clone(amount_msat); let mut purpose_nonref = Clone::clone(purpose); + let mut htlcs_nonref = Clone::clone(htlcs); + let mut local_htlcs_nonref = Vec::new(); for mut item in htlcs_nonref.into_rust().drain(..) { local_htlcs_nonref.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; + let mut sender_intended_total_msat_nonref = Clone::clone(sender_intended_total_msat); + let mut local_sender_intended_total_msat_nonref = if sender_intended_total_msat_nonref.is_some() { Some( { sender_intended_total_msat_nonref.take() }) } else { None }; nativeEvent::PaymentClaimed { receiver_node_id: local_receiver_node_id_nonref, payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data), amount_msat: amount_msat_nonref, purpose: purpose_nonref.into_native(), + htlcs: local_htlcs_nonref, + sender_intended_total_msat: local_sender_intended_total_msat_nonref, + } + }, + Event::ConnectionNeeded {ref node_id, ref addresses, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut addresses_nonref = Clone::clone(addresses); + let mut local_addresses_nonref = Vec::new(); for mut item in addresses_nonref.into_rust().drain(..) { local_addresses_nonref.push( { item.into_native() }); }; + nativeEvent::ConnectionNeeded { + node_id: node_id_nonref.into_rust(), + addresses: local_addresses_nonref, + } + }, + Event::InvoiceRequestFailed {ref payment_id, } => { + let mut payment_id_nonref = Clone::clone(payment_id); + nativeEvent::InvoiceRequestFailed { + payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data), } }, Event::PaymentSent {ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat, } => { @@ -1582,18 +1989,21 @@ impl Event { expected_outbound_amount_msat: expected_outbound_amount_msat_nonref, } }, - Event::SpendableOutputs {ref outputs, } => { + Event::SpendableOutputs {ref outputs, ref channel_id, } => { let mut outputs_nonref = Clone::clone(outputs); let mut local_outputs_nonref = Vec::new(); for mut item in outputs_nonref.into_rust().drain(..) { local_outputs_nonref.push( { item.into_native() }); }; + let mut channel_id_nonref = Clone::clone(channel_id); + let mut local_channel_id_nonref = { /*channel_id_nonref*/ let channel_id_nonref_opt = channel_id_nonref; if channel_id_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ channel_id_nonref_opt.take() }.data) }})} }; nativeEvent::SpendableOutputs { outputs: local_outputs_nonref, + channel_id: local_channel_id_nonref, } }, Event::PaymentForwarded {ref prev_channel_id, ref next_channel_id, ref fee_earned_msat, ref claim_from_onchain_tx, ref outbound_amount_forwarded_msat, } => { let mut prev_channel_id_nonref = Clone::clone(prev_channel_id); - let mut local_prev_channel_id_nonref = if prev_channel_id_nonref.data == [0; 32] { None } else { Some( { prev_channel_id_nonref.data }) }; + let mut local_prev_channel_id_nonref = { /*prev_channel_id_nonref*/ let prev_channel_id_nonref_opt = prev_channel_id_nonref; if prev_channel_id_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ prev_channel_id_nonref_opt.take() }.data) }})} }; let mut next_channel_id_nonref = Clone::clone(next_channel_id); - let mut local_next_channel_id_nonref = if next_channel_id_nonref.data == [0; 32] { None } else { Some( { next_channel_id_nonref.data }) }; + let mut local_next_channel_id_nonref = { /*next_channel_id_nonref*/ let next_channel_id_nonref_opt = next_channel_id_nonref; if next_channel_id_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ next_channel_id_nonref_opt.take() }.data) }})} }; let mut fee_earned_msat_nonref = Clone::clone(fee_earned_msat); let mut local_fee_earned_msat_nonref = if fee_earned_msat_nonref.is_some() { Some( { fee_earned_msat_nonref.take() }) } else { None }; let mut claim_from_onchain_tx_nonref = Clone::clone(claim_from_onchain_tx); @@ -1611,11 +2021,11 @@ impl Event { let mut channel_id_nonref = Clone::clone(channel_id); let mut user_channel_id_nonref = Clone::clone(user_channel_id); let mut former_temporary_channel_id_nonref = Clone::clone(former_temporary_channel_id); - let mut local_former_temporary_channel_id_nonref = if former_temporary_channel_id_nonref.data == [0; 32] { None } else { Some( { former_temporary_channel_id_nonref.data }) }; + let mut local_former_temporary_channel_id_nonref = { /*former_temporary_channel_id_nonref*/ let former_temporary_channel_id_nonref_opt = former_temporary_channel_id_nonref; if former_temporary_channel_id_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ former_temporary_channel_id_nonref_opt.take() }.data) }})} }; let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); let mut funding_txo_nonref = Clone::clone(funding_txo); nativeEvent::ChannelPending { - channel_id: channel_id_nonref.data, + channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data), user_channel_id: user_channel_id_nonref.into(), former_temporary_channel_id: local_former_temporary_channel_id_nonref, counterparty_node_id: counterparty_node_id_nonref.into_rust(), @@ -1628,27 +2038,36 @@ impl Event { let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); let mut channel_type_nonref = Clone::clone(channel_type); nativeEvent::ChannelReady { - channel_id: channel_id_nonref.data, + channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data), user_channel_id: user_channel_id_nonref.into(), counterparty_node_id: counterparty_node_id_nonref.into_rust(), channel_type: *unsafe { Box::from_raw(channel_type_nonref.take_inner()) }, } }, - Event::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, } => { + Event::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, ref counterparty_node_id, ref channel_capacity_sats, ref channel_funding_txo, } => { let mut channel_id_nonref = Clone::clone(channel_id); let mut user_channel_id_nonref = Clone::clone(user_channel_id); let mut reason_nonref = Clone::clone(reason); + let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); + let mut local_counterparty_node_id_nonref = if counterparty_node_id_nonref.is_null() { None } else { Some( { counterparty_node_id_nonref.into_rust() }) }; + let mut channel_capacity_sats_nonref = Clone::clone(channel_capacity_sats); + let mut local_channel_capacity_sats_nonref = if channel_capacity_sats_nonref.is_some() { Some( { channel_capacity_sats_nonref.take() }) } else { None }; + let mut channel_funding_txo_nonref = Clone::clone(channel_funding_txo); + let mut local_channel_funding_txo_nonref = if channel_funding_txo_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(channel_funding_txo_nonref.take_inner()) } }) }; nativeEvent::ChannelClosed { - channel_id: channel_id_nonref.data, + channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data), user_channel_id: user_channel_id_nonref.into(), reason: reason_nonref.into_native(), + counterparty_node_id: local_counterparty_node_id_nonref, + channel_capacity_sats: local_channel_capacity_sats_nonref, + channel_funding_txo: local_channel_funding_txo_nonref, } }, Event::DiscardFunding {ref channel_id, ref transaction, } => { let mut channel_id_nonref = Clone::clone(channel_id); let mut transaction_nonref = Clone::clone(transaction); nativeEvent::DiscardFunding { - channel_id: channel_id_nonref.data, + channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data), transaction: transaction_nonref.into_bitcoin(), } }, @@ -1659,7 +2078,7 @@ impl Event { let mut push_msat_nonref = Clone::clone(push_msat); let mut channel_type_nonref = Clone::clone(channel_type); nativeEvent::OpenChannelRequest { - temporary_channel_id: temporary_channel_id_nonref.data, + temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_nonref.data), counterparty_node_id: counterparty_node_id_nonref.into_rust(), funding_satoshis: funding_satoshis_nonref, push_msat: push_msat_nonref, @@ -1670,7 +2089,7 @@ impl Event { let mut prev_channel_id_nonref = Clone::clone(prev_channel_id); let mut failed_next_destination_nonref = Clone::clone(failed_next_destination); nativeEvent::HTLCHandlingFailed { - prev_channel_id: prev_channel_id_nonref.data, + prev_channel_id: ::lightning::ln::ChannelId(prev_channel_id_nonref.data), failed_next_destination: failed_next_destination_nonref.into_native(), } }, @@ -1687,17 +2106,17 @@ impl Event { match self { Event::FundingGenerationReady {mut temporary_channel_id, mut counterparty_node_id, mut channel_value_satoshis, mut output_script, mut user_channel_id, } => { nativeEvent::FundingGenerationReady { - temporary_channel_id: temporary_channel_id.data, + temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id.data), counterparty_node_id: counterparty_node_id.into_rust(), channel_value_satoshis: channel_value_satoshis, - output_script: ::bitcoin::blockdata::script::Script::from(output_script.into_rust()), + output_script: ::bitcoin::blockdata::script::ScriptBuf::from(output_script.into_rust()), user_channel_id: user_channel_id.into(), } }, Event::PaymentClaimable {mut receiver_node_id, mut payment_hash, mut onion_fields, mut amount_msat, mut counterparty_skimmed_fee_msat, mut purpose, mut via_channel_id, mut via_user_channel_id, mut claim_deadline, } => { let mut local_receiver_node_id = if receiver_node_id.is_null() { None } else { Some( { receiver_node_id.into_rust() }) }; let mut local_onion_fields = if onion_fields.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(onion_fields.take_inner()) } }) }; - let mut local_via_channel_id = if via_channel_id.data == [0; 32] { None } else { Some( { via_channel_id.data }) }; + let mut local_via_channel_id = { /*via_channel_id*/ let via_channel_id_opt = via_channel_id; if via_channel_id_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ via_channel_id_opt.take() }.data) }})} }; let mut local_via_user_channel_id = { /*via_user_channel_id*/ let via_user_channel_id_opt = via_user_channel_id; if via_user_channel_id_opt.is_none() { None } else { Some({ { { via_user_channel_id_opt.take() }.into() }})} }; let mut local_claim_deadline = if claim_deadline.is_some() { Some( { claim_deadline.take() }) } else { None }; nativeEvent::PaymentClaimable { @@ -1712,13 +2131,29 @@ impl Event { claim_deadline: local_claim_deadline, } }, - Event::PaymentClaimed {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, } => { + Event::PaymentClaimed {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, mut htlcs, mut sender_intended_total_msat, } => { let mut local_receiver_node_id = if receiver_node_id.is_null() { None } else { Some( { receiver_node_id.into_rust() }) }; + let mut local_htlcs = Vec::new(); for mut item in htlcs.into_rust().drain(..) { local_htlcs.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; + let mut local_sender_intended_total_msat = if sender_intended_total_msat.is_some() { Some( { sender_intended_total_msat.take() }) } else { None }; nativeEvent::PaymentClaimed { receiver_node_id: local_receiver_node_id, payment_hash: ::lightning::ln::PaymentHash(payment_hash.data), amount_msat: amount_msat, purpose: purpose.into_native(), + htlcs: local_htlcs, + sender_intended_total_msat: local_sender_intended_total_msat, + } + }, + Event::ConnectionNeeded {mut node_id, mut addresses, } => { + let mut local_addresses = Vec::new(); for mut item in addresses.into_rust().drain(..) { local_addresses.push( { item.into_native() }); }; + nativeEvent::ConnectionNeeded { + node_id: node_id.into_rust(), + addresses: local_addresses, + } + }, + Event::InvoiceRequestFailed {mut payment_id, } => { + nativeEvent::InvoiceRequestFailed { + payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id.data), } }, Event::PaymentSent {mut payment_id, mut payment_preimage, mut payment_hash, mut fee_paid_msat, } => { @@ -1789,15 +2224,17 @@ impl Event { expected_outbound_amount_msat: expected_outbound_amount_msat, } }, - Event::SpendableOutputs {mut outputs, } => { + Event::SpendableOutputs {mut outputs, mut channel_id, } => { let mut local_outputs = Vec::new(); for mut item in outputs.into_rust().drain(..) { local_outputs.push( { item.into_native() }); }; + let mut local_channel_id = { /*channel_id*/ let channel_id_opt = channel_id; if channel_id_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ channel_id_opt.take() }.data) }})} }; nativeEvent::SpendableOutputs { outputs: local_outputs, + channel_id: local_channel_id, } }, Event::PaymentForwarded {mut prev_channel_id, mut next_channel_id, mut fee_earned_msat, mut claim_from_onchain_tx, mut outbound_amount_forwarded_msat, } => { - let mut local_prev_channel_id = if prev_channel_id.data == [0; 32] { None } else { Some( { prev_channel_id.data }) }; - let mut local_next_channel_id = if next_channel_id.data == [0; 32] { None } else { Some( { next_channel_id.data }) }; + let mut local_prev_channel_id = { /*prev_channel_id*/ let prev_channel_id_opt = prev_channel_id; if prev_channel_id_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ prev_channel_id_opt.take() }.data) }})} }; + let mut local_next_channel_id = { /*next_channel_id*/ let next_channel_id_opt = next_channel_id; if next_channel_id_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ next_channel_id_opt.take() }.data) }})} }; let mut local_fee_earned_msat = if fee_earned_msat.is_some() { Some( { fee_earned_msat.take() }) } else { None }; let mut local_outbound_amount_forwarded_msat = if outbound_amount_forwarded_msat.is_some() { Some( { outbound_amount_forwarded_msat.take() }) } else { None }; nativeEvent::PaymentForwarded { @@ -1809,9 +2246,9 @@ impl Event { } }, Event::ChannelPending {mut channel_id, mut user_channel_id, mut former_temporary_channel_id, mut counterparty_node_id, mut funding_txo, } => { - let mut local_former_temporary_channel_id = if former_temporary_channel_id.data == [0; 32] { None } else { Some( { former_temporary_channel_id.data }) }; + let mut local_former_temporary_channel_id = { /*former_temporary_channel_id*/ let former_temporary_channel_id_opt = former_temporary_channel_id; if former_temporary_channel_id_opt.is_none() { None } else { Some({ { ::lightning::ln::ChannelId({ former_temporary_channel_id_opt.take() }.data) }})} }; nativeEvent::ChannelPending { - channel_id: channel_id.data, + channel_id: ::lightning::ln::ChannelId(channel_id.data), user_channel_id: user_channel_id.into(), former_temporary_channel_id: local_former_temporary_channel_id, counterparty_node_id: counterparty_node_id.into_rust(), @@ -1820,28 +2257,34 @@ impl Event { }, Event::ChannelReady {mut channel_id, mut user_channel_id, mut counterparty_node_id, mut channel_type, } => { nativeEvent::ChannelReady { - channel_id: channel_id.data, + channel_id: ::lightning::ln::ChannelId(channel_id.data), user_channel_id: user_channel_id.into(), counterparty_node_id: counterparty_node_id.into_rust(), channel_type: *unsafe { Box::from_raw(channel_type.take_inner()) }, } }, - Event::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, } => { + Event::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, mut counterparty_node_id, mut channel_capacity_sats, mut channel_funding_txo, } => { + let mut local_counterparty_node_id = if counterparty_node_id.is_null() { None } else { Some( { counterparty_node_id.into_rust() }) }; + let mut local_channel_capacity_sats = if channel_capacity_sats.is_some() { Some( { channel_capacity_sats.take() }) } else { None }; + let mut local_channel_funding_txo = if channel_funding_txo.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(channel_funding_txo.take_inner()) } }) }; nativeEvent::ChannelClosed { - channel_id: channel_id.data, + channel_id: ::lightning::ln::ChannelId(channel_id.data), user_channel_id: user_channel_id.into(), reason: reason.into_native(), + counterparty_node_id: local_counterparty_node_id, + channel_capacity_sats: local_channel_capacity_sats, + channel_funding_txo: local_channel_funding_txo, } }, Event::DiscardFunding {mut channel_id, mut transaction, } => { nativeEvent::DiscardFunding { - channel_id: channel_id.data, + channel_id: ::lightning::ln::ChannelId(channel_id.data), transaction: transaction.into_bitcoin(), } }, Event::OpenChannelRequest {mut temporary_channel_id, mut counterparty_node_id, mut funding_satoshis, mut push_msat, mut channel_type, } => { nativeEvent::OpenChannelRequest { - temporary_channel_id: temporary_channel_id.data, + temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id.data), counterparty_node_id: counterparty_node_id.into_rust(), funding_satoshis: funding_satoshis, push_msat: push_msat, @@ -1850,7 +2293,7 @@ impl Event { }, Event::HTLCHandlingFailed {mut prev_channel_id, mut failed_next_destination, } => { nativeEvent::HTLCHandlingFailed { - prev_channel_id: prev_channel_id.data, + prev_channel_id: ::lightning::ln::ChannelId(prev_channel_id.data), failed_next_destination: failed_next_destination.into_native(), } }, @@ -1862,7 +2305,8 @@ impl Event { } } #[allow(unused)] - pub(crate) fn from_native(native: &nativeEvent) -> Self { + pub(crate) fn from_native(native: &EventImport) -> Self { + let native = unsafe { &*(native as *const _ as *const c_void as *const nativeEvent) }; match native { nativeEvent::FundingGenerationReady {ref temporary_channel_id, ref counterparty_node_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => { let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id); @@ -1871,10 +2315,10 @@ impl Event { let mut output_script_nonref = Clone::clone(output_script); let mut user_channel_id_nonref = Clone::clone(user_channel_id); Event::FundingGenerationReady { - temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref }, + temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref.0 }, counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref), channel_value_satoshis: channel_value_satoshis_nonref, - output_script: output_script_nonref.into_bytes().into(), + output_script: output_script_nonref.to_bytes().into(), user_channel_id: user_channel_id_nonref.into(), } }, @@ -1888,9 +2332,9 @@ impl Event { let mut counterparty_skimmed_fee_msat_nonref = Clone::clone(counterparty_skimmed_fee_msat); let mut purpose_nonref = Clone::clone(purpose); let mut via_channel_id_nonref = Clone::clone(via_channel_id); - let mut local_via_channel_id_nonref = if via_channel_id_nonref.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (via_channel_id_nonref.unwrap()) } } }; + let mut local_via_channel_id_nonref = if via_channel_id_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: via_channel_id_nonref.unwrap().0 } }) }; let mut via_user_channel_id_nonref = Clone::clone(via_user_channel_id); - let mut local_via_user_channel_id_nonref = if via_user_channel_id_nonref.is_none() { crate::c_types::derived::COption_u128Z::None } else { crate::c_types::derived::COption_u128Z::Some( { via_user_channel_id_nonref.unwrap().into() }) }; + let mut local_via_user_channel_id_nonref = if via_user_channel_id_nonref.is_none() { crate::c_types::derived::COption_U128Z::None } else { crate::c_types::derived::COption_U128Z::Some( { via_user_channel_id_nonref.unwrap().into() }) }; let mut claim_deadline_nonref = Clone::clone(claim_deadline); let mut local_claim_deadline_nonref = if claim_deadline_nonref.is_none() { crate::c_types::derived::COption_u32Z::None } else { crate::c_types::derived::COption_u32Z::Some( { claim_deadline_nonref.unwrap() }) }; Event::PaymentClaimable { @@ -1905,22 +2349,43 @@ impl Event { claim_deadline: local_claim_deadline_nonref, } }, - nativeEvent::PaymentClaimed {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, } => { + nativeEvent::PaymentClaimed {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, ref htlcs, ref sender_intended_total_msat, } => { let mut receiver_node_id_nonref = Clone::clone(receiver_node_id); let mut local_receiver_node_id_nonref = if receiver_node_id_nonref.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(receiver_node_id_nonref.unwrap())) } }; let mut payment_hash_nonref = Clone::clone(payment_hash); let mut amount_msat_nonref = Clone::clone(amount_msat); let mut purpose_nonref = Clone::clone(purpose); + let mut htlcs_nonref = Clone::clone(htlcs); + let mut local_htlcs_nonref = Vec::new(); for mut item in htlcs_nonref.drain(..) { local_htlcs_nonref.push( { crate::lightning::events::ClaimedHTLC { inner: ObjOps::heap_alloc(item), is_owned: true } }); }; + let mut sender_intended_total_msat_nonref = Clone::clone(sender_intended_total_msat); + let mut local_sender_intended_total_msat_nonref = if sender_intended_total_msat_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { sender_intended_total_msat_nonref.unwrap() }) }; Event::PaymentClaimed { receiver_node_id: local_receiver_node_id_nonref, payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 }, amount_msat: amount_msat_nonref, purpose: crate::lightning::events::PaymentPurpose::native_into(purpose_nonref), + htlcs: local_htlcs_nonref.into(), + sender_intended_total_msat: local_sender_intended_total_msat_nonref, + } + }, + nativeEvent::ConnectionNeeded {ref node_id, ref addresses, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut addresses_nonref = Clone::clone(addresses); + let mut local_addresses_nonref = Vec::new(); for mut item in addresses_nonref.drain(..) { local_addresses_nonref.push( { crate::lightning::ln::msgs::SocketAddress::native_into(item) }); }; + Event::ConnectionNeeded { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + addresses: local_addresses_nonref.into(), + } + }, + nativeEvent::InvoiceRequestFailed {ref payment_id, } => { + let mut payment_id_nonref = Clone::clone(payment_id); + Event::InvoiceRequestFailed { + payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 }, } }, nativeEvent::PaymentSent {ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat, } => { let mut payment_id_nonref = Clone::clone(payment_id); - let mut local_payment_id_nonref = if payment_id_nonref.is_none() { crate::c_types::derived::COption_PaymentIdZ::None } else { crate::c_types::derived::COption_PaymentIdZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.unwrap().0 } }) }; + let mut local_payment_id_nonref = if payment_id_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.unwrap().0 } }) }; let mut payment_preimage_nonref = Clone::clone(payment_preimage); let mut payment_hash_nonref = Clone::clone(payment_hash); let mut fee_paid_msat_nonref = Clone::clone(fee_paid_msat); @@ -1946,7 +2411,7 @@ impl Event { nativeEvent::PaymentPathSuccessful {ref payment_id, ref payment_hash, ref path, } => { let mut payment_id_nonref = Clone::clone(payment_id); let mut payment_hash_nonref = Clone::clone(payment_hash); - let mut local_payment_hash_nonref = if payment_hash_nonref.is_none() { crate::c_types::derived::COption_PaymentHashZ::None } else { crate::c_types::derived::COption_PaymentHashZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.unwrap().0 } }) }; + let mut local_payment_hash_nonref = if payment_hash_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.unwrap().0 } }) }; let mut path_nonref = Clone::clone(path); Event::PaymentPathSuccessful { payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 }, @@ -1956,7 +2421,7 @@ impl Event { }, nativeEvent::PaymentPathFailed {ref payment_id, ref payment_hash, ref payment_failed_permanently, ref failure, ref path, ref short_channel_id, } => { let mut payment_id_nonref = Clone::clone(payment_id); - let mut local_payment_id_nonref = if payment_id_nonref.is_none() { crate::c_types::derived::COption_PaymentIdZ::None } else { crate::c_types::derived::COption_PaymentIdZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.unwrap().0 } }) }; + let mut local_payment_id_nonref = if payment_id_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.unwrap().0 } }) }; let mut payment_hash_nonref = Clone::clone(payment_hash); let mut payment_failed_permanently_nonref = Clone::clone(payment_failed_permanently); let mut failure_nonref = Clone::clone(failure); @@ -2015,18 +2480,21 @@ impl Event { expected_outbound_amount_msat: expected_outbound_amount_msat_nonref, } }, - nativeEvent::SpendableOutputs {ref outputs, } => { + nativeEvent::SpendableOutputs {ref outputs, ref channel_id, } => { let mut outputs_nonref = Clone::clone(outputs); let mut local_outputs_nonref = Vec::new(); for mut item in outputs_nonref.drain(..) { local_outputs_nonref.push( { crate::lightning::sign::SpendableOutputDescriptor::native_into(item) }); }; + let mut channel_id_nonref = Clone::clone(channel_id); + let mut local_channel_id_nonref = if channel_id_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.unwrap().0 } }) }; Event::SpendableOutputs { outputs: local_outputs_nonref.into(), + channel_id: local_channel_id_nonref, } }, nativeEvent::PaymentForwarded {ref prev_channel_id, ref next_channel_id, ref fee_earned_msat, ref claim_from_onchain_tx, ref outbound_amount_forwarded_msat, } => { let mut prev_channel_id_nonref = Clone::clone(prev_channel_id); - let mut local_prev_channel_id_nonref = if prev_channel_id_nonref.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (prev_channel_id_nonref.unwrap()) } } }; + let mut local_prev_channel_id_nonref = if prev_channel_id_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: prev_channel_id_nonref.unwrap().0 } }) }; let mut next_channel_id_nonref = Clone::clone(next_channel_id); - let mut local_next_channel_id_nonref = if next_channel_id_nonref.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (next_channel_id_nonref.unwrap()) } } }; + let mut local_next_channel_id_nonref = if next_channel_id_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: next_channel_id_nonref.unwrap().0 } }) }; let mut fee_earned_msat_nonref = Clone::clone(fee_earned_msat); let mut local_fee_earned_msat_nonref = if fee_earned_msat_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { fee_earned_msat_nonref.unwrap() }) }; let mut claim_from_onchain_tx_nonref = Clone::clone(claim_from_onchain_tx); @@ -2044,11 +2512,11 @@ impl Event { let mut channel_id_nonref = Clone::clone(channel_id); let mut user_channel_id_nonref = Clone::clone(user_channel_id); let mut former_temporary_channel_id_nonref = Clone::clone(former_temporary_channel_id); - let mut local_former_temporary_channel_id_nonref = if former_temporary_channel_id_nonref.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (former_temporary_channel_id_nonref.unwrap()) } } }; + let mut local_former_temporary_channel_id_nonref = if former_temporary_channel_id_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: former_temporary_channel_id_nonref.unwrap().0 } }) }; let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); let mut funding_txo_nonref = Clone::clone(funding_txo); Event::ChannelPending { - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 }, user_channel_id: user_channel_id_nonref.into(), former_temporary_channel_id: local_former_temporary_channel_id_nonref, counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref), @@ -2061,27 +2529,36 @@ impl Event { let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); let mut channel_type_nonref = Clone::clone(channel_type); Event::ChannelReady { - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 }, user_channel_id: user_channel_id_nonref.into(), counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref), channel_type: crate::lightning::ln::features::ChannelTypeFeatures { inner: ObjOps::heap_alloc(channel_type_nonref), is_owned: true }, } }, - nativeEvent::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, } => { + nativeEvent::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, ref counterparty_node_id, ref channel_capacity_sats, ref channel_funding_txo, } => { let mut channel_id_nonref = Clone::clone(channel_id); let mut user_channel_id_nonref = Clone::clone(user_channel_id); let mut reason_nonref = Clone::clone(reason); + let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); + let mut local_counterparty_node_id_nonref = if counterparty_node_id_nonref.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(counterparty_node_id_nonref.unwrap())) } }; + let mut channel_capacity_sats_nonref = Clone::clone(channel_capacity_sats); + let mut local_channel_capacity_sats_nonref = if channel_capacity_sats_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { channel_capacity_sats_nonref.unwrap() }) }; + let mut channel_funding_txo_nonref = Clone::clone(channel_funding_txo); + let mut local_channel_funding_txo_nonref = crate::lightning::chain::transaction::OutPoint { inner: if channel_funding_txo_nonref.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((channel_funding_txo_nonref.unwrap())) } }, is_owned: true }; Event::ChannelClosed { - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 }, user_channel_id: user_channel_id_nonref.into(), reason: crate::lightning::events::ClosureReason::native_into(reason_nonref), + counterparty_node_id: local_counterparty_node_id_nonref, + channel_capacity_sats: local_channel_capacity_sats_nonref, + channel_funding_txo: local_channel_funding_txo_nonref, } }, nativeEvent::DiscardFunding {ref channel_id, ref transaction, } => { let mut channel_id_nonref = Clone::clone(channel_id); let mut transaction_nonref = Clone::clone(transaction); Event::DiscardFunding { - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 }, transaction: crate::c_types::Transaction::from_bitcoin(&transaction_nonref), } }, @@ -2092,7 +2569,7 @@ impl Event { let mut push_msat_nonref = Clone::clone(push_msat); let mut channel_type_nonref = Clone::clone(channel_type); Event::OpenChannelRequest { - temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref }, + temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref.0 }, counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref), funding_satoshis: funding_satoshis_nonref, push_msat: push_msat_nonref, @@ -2103,7 +2580,7 @@ impl Event { let mut prev_channel_id_nonref = Clone::clone(prev_channel_id); let mut failed_next_destination_nonref = Clone::clone(failed_next_destination); Event::HTLCHandlingFailed { - prev_channel_id: crate::c_types::ThirtyTwoBytes { data: prev_channel_id_nonref }, + prev_channel_id: crate::c_types::ThirtyTwoBytes { data: prev_channel_id_nonref.0 }, failed_next_destination: crate::lightning::events::HTLCDestination::native_into(failed_next_destination_nonref), } }, @@ -2120,18 +2597,18 @@ impl Event { match native { nativeEvent::FundingGenerationReady {mut temporary_channel_id, mut counterparty_node_id, mut channel_value_satoshis, mut output_script, mut user_channel_id, } => { Event::FundingGenerationReady { - temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id }, + temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id.0 }, counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id), channel_value_satoshis: channel_value_satoshis, - output_script: output_script.into_bytes().into(), + output_script: output_script.to_bytes().into(), user_channel_id: user_channel_id.into(), } }, nativeEvent::PaymentClaimable {mut receiver_node_id, mut payment_hash, mut onion_fields, mut amount_msat, mut counterparty_skimmed_fee_msat, mut purpose, mut via_channel_id, mut via_user_channel_id, mut claim_deadline, } => { let mut local_receiver_node_id = if receiver_node_id.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(receiver_node_id.unwrap())) } }; let mut local_onion_fields = crate::lightning::ln::outbound_payment::RecipientOnionFields { inner: if onion_fields.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((onion_fields.unwrap())) } }, is_owned: true }; - let mut local_via_channel_id = if via_channel_id.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (via_channel_id.unwrap()) } } }; - let mut local_via_user_channel_id = if via_user_channel_id.is_none() { crate::c_types::derived::COption_u128Z::None } else { crate::c_types::derived::COption_u128Z::Some( { via_user_channel_id.unwrap().into() }) }; + let mut local_via_channel_id = if via_channel_id.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: via_channel_id.unwrap().0 } }) }; + let mut local_via_user_channel_id = if via_user_channel_id.is_none() { crate::c_types::derived::COption_U128Z::None } else { crate::c_types::derived::COption_U128Z::Some( { via_user_channel_id.unwrap().into() }) }; let mut local_claim_deadline = if claim_deadline.is_none() { crate::c_types::derived::COption_u32Z::None } else { crate::c_types::derived::COption_u32Z::Some( { claim_deadline.unwrap() }) }; Event::PaymentClaimable { receiver_node_id: local_receiver_node_id, @@ -2145,17 +2622,33 @@ impl Event { claim_deadline: local_claim_deadline, } }, - nativeEvent::PaymentClaimed {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, } => { + nativeEvent::PaymentClaimed {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, mut htlcs, mut sender_intended_total_msat, } => { let mut local_receiver_node_id = if receiver_node_id.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(receiver_node_id.unwrap())) } }; + let mut local_htlcs = Vec::new(); for mut item in htlcs.drain(..) { local_htlcs.push( { crate::lightning::events::ClaimedHTLC { inner: ObjOps::heap_alloc(item), is_owned: true } }); }; + let mut local_sender_intended_total_msat = if sender_intended_total_msat.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { sender_intended_total_msat.unwrap() }) }; Event::PaymentClaimed { receiver_node_id: local_receiver_node_id, payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 }, amount_msat: amount_msat, purpose: crate::lightning::events::PaymentPurpose::native_into(purpose), + htlcs: local_htlcs.into(), + sender_intended_total_msat: local_sender_intended_total_msat, + } + }, + nativeEvent::ConnectionNeeded {mut node_id, mut addresses, } => { + let mut local_addresses = Vec::new(); for mut item in addresses.drain(..) { local_addresses.push( { crate::lightning::ln::msgs::SocketAddress::native_into(item) }); }; + Event::ConnectionNeeded { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + addresses: local_addresses.into(), + } + }, + nativeEvent::InvoiceRequestFailed {mut payment_id, } => { + Event::InvoiceRequestFailed { + payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id.0 }, } }, nativeEvent::PaymentSent {mut payment_id, mut payment_preimage, mut payment_hash, mut fee_paid_msat, } => { - let mut local_payment_id = if payment_id.is_none() { crate::c_types::derived::COption_PaymentIdZ::None } else { crate::c_types::derived::COption_PaymentIdZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id.unwrap().0 } }) }; + let mut local_payment_id = if payment_id.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id.unwrap().0 } }) }; let mut local_fee_paid_msat = if fee_paid_msat.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { fee_paid_msat.unwrap() }) }; Event::PaymentSent { payment_id: local_payment_id, @@ -2173,7 +2666,7 @@ impl Event { } }, nativeEvent::PaymentPathSuccessful {mut payment_id, mut payment_hash, mut path, } => { - let mut local_payment_hash = if payment_hash.is_none() { crate::c_types::derived::COption_PaymentHashZ::None } else { crate::c_types::derived::COption_PaymentHashZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_hash.unwrap().0 } }) }; + let mut local_payment_hash = if payment_hash.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_hash.unwrap().0 } }) }; Event::PaymentPathSuccessful { payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id.0 }, payment_hash: local_payment_hash, @@ -2181,7 +2674,7 @@ impl Event { } }, nativeEvent::PaymentPathFailed {mut payment_id, mut payment_hash, mut payment_failed_permanently, mut failure, mut path, mut short_channel_id, } => { - let mut local_payment_id = if payment_id.is_none() { crate::c_types::derived::COption_PaymentIdZ::None } else { crate::c_types::derived::COption_PaymentIdZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id.unwrap().0 } }) }; + let mut local_payment_id = if payment_id.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id.unwrap().0 } }) }; let mut local_short_channel_id = if short_channel_id.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { short_channel_id.unwrap() }) }; Event::PaymentPathFailed { payment_id: local_payment_id, @@ -2222,15 +2715,17 @@ impl Event { expected_outbound_amount_msat: expected_outbound_amount_msat, } }, - nativeEvent::SpendableOutputs {mut outputs, } => { + nativeEvent::SpendableOutputs {mut outputs, mut channel_id, } => { let mut local_outputs = Vec::new(); for mut item in outputs.drain(..) { local_outputs.push( { crate::lightning::sign::SpendableOutputDescriptor::native_into(item) }); }; + let mut local_channel_id = if channel_id.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: channel_id.unwrap().0 } }) }; Event::SpendableOutputs { outputs: local_outputs.into(), + channel_id: local_channel_id, } }, nativeEvent::PaymentForwarded {mut prev_channel_id, mut next_channel_id, mut fee_earned_msat, mut claim_from_onchain_tx, mut outbound_amount_forwarded_msat, } => { - let mut local_prev_channel_id = if prev_channel_id.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (prev_channel_id.unwrap()) } } }; - let mut local_next_channel_id = if next_channel_id.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (next_channel_id.unwrap()) } } }; + let mut local_prev_channel_id = if prev_channel_id.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: prev_channel_id.unwrap().0 } }) }; + let mut local_next_channel_id = if next_channel_id.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: next_channel_id.unwrap().0 } }) }; let mut local_fee_earned_msat = if fee_earned_msat.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { fee_earned_msat.unwrap() }) }; let mut local_outbound_amount_forwarded_msat = if outbound_amount_forwarded_msat.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { outbound_amount_forwarded_msat.unwrap() }) }; Event::PaymentForwarded { @@ -2242,9 +2737,9 @@ impl Event { } }, nativeEvent::ChannelPending {mut channel_id, mut user_channel_id, mut former_temporary_channel_id, mut counterparty_node_id, mut funding_txo, } => { - let mut local_former_temporary_channel_id = if former_temporary_channel_id.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (former_temporary_channel_id.unwrap()) } } }; + let mut local_former_temporary_channel_id = if former_temporary_channel_id.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: former_temporary_channel_id.unwrap().0 } }) }; Event::ChannelPending { - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 }, user_channel_id: user_channel_id.into(), former_temporary_channel_id: local_former_temporary_channel_id, counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id), @@ -2253,28 +2748,34 @@ impl Event { }, nativeEvent::ChannelReady {mut channel_id, mut user_channel_id, mut counterparty_node_id, mut channel_type, } => { Event::ChannelReady { - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 }, user_channel_id: user_channel_id.into(), counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id), channel_type: crate::lightning::ln::features::ChannelTypeFeatures { inner: ObjOps::heap_alloc(channel_type), is_owned: true }, } }, - nativeEvent::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, } => { + nativeEvent::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, mut counterparty_node_id, mut channel_capacity_sats, mut channel_funding_txo, } => { + let mut local_counterparty_node_id = if counterparty_node_id.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(counterparty_node_id.unwrap())) } }; + let mut local_channel_capacity_sats = if channel_capacity_sats.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { channel_capacity_sats.unwrap() }) }; + let mut local_channel_funding_txo = crate::lightning::chain::transaction::OutPoint { inner: if channel_funding_txo.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((channel_funding_txo.unwrap())) } }, is_owned: true }; Event::ChannelClosed { - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 }, user_channel_id: user_channel_id.into(), reason: crate::lightning::events::ClosureReason::native_into(reason), + counterparty_node_id: local_counterparty_node_id, + channel_capacity_sats: local_channel_capacity_sats, + channel_funding_txo: local_channel_funding_txo, } }, nativeEvent::DiscardFunding {mut channel_id, mut transaction, } => { Event::DiscardFunding { - channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id }, + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 }, transaction: crate::c_types::Transaction::from_bitcoin(&transaction), } }, nativeEvent::OpenChannelRequest {mut temporary_channel_id, mut counterparty_node_id, mut funding_satoshis, mut push_msat, mut channel_type, } => { Event::OpenChannelRequest { - temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id }, + temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id.0 }, counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id), funding_satoshis: funding_satoshis, push_msat: push_msat, @@ -2283,7 +2784,7 @@ impl Event { }, nativeEvent::HTLCHandlingFailed {mut prev_channel_id, mut failed_next_destination, } => { Event::HTLCHandlingFailed { - prev_channel_id: crate::c_types::ThirtyTwoBytes { data: prev_channel_id }, + prev_channel_id: crate::c_types::ThirtyTwoBytes { data: prev_channel_id.0 }, failed_next_destination: crate::lightning::events::HTLCDestination::native_into(failed_next_destination), } }, @@ -2303,6 +2804,16 @@ pub extern "C" fn Event_free(this_ptr: Event) { } pub extern "C" fn Event_clone(orig: &Event) -> Event { 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 Event_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const Event)).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 Event_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut Event) }; +} #[no_mangle] /// Utility method to constructs a new FundingGenerationReady-variant Event pub extern "C" fn Event_funding_generation_ready(temporary_channel_id: crate::c_types::ThirtyTwoBytes, counterparty_node_id: crate::c_types::PublicKey, channel_value_satoshis: u64, output_script: crate::c_types::derived::CVec_u8Z, user_channel_id: crate::c_types::U128) -> Event { @@ -2316,7 +2827,7 @@ pub extern "C" fn Event_funding_generation_ready(temporary_channel_id: crate::c_ } #[no_mangle] /// Utility method to constructs a new PaymentClaimable-variant Event -pub extern "C" fn Event_payment_claimable(receiver_node_id: crate::c_types::PublicKey, payment_hash: crate::c_types::ThirtyTwoBytes, onion_fields: crate::lightning::ln::outbound_payment::RecipientOnionFields, amount_msat: u64, counterparty_skimmed_fee_msat: u64, purpose: crate::lightning::events::PaymentPurpose, via_channel_id: crate::c_types::ThirtyTwoBytes, via_user_channel_id: crate::c_types::derived::COption_u128Z, claim_deadline: crate::c_types::derived::COption_u32Z) -> Event { +pub extern "C" fn Event_payment_claimable(receiver_node_id: crate::c_types::PublicKey, payment_hash: crate::c_types::ThirtyTwoBytes, onion_fields: crate::lightning::ln::outbound_payment::RecipientOnionFields, amount_msat: u64, counterparty_skimmed_fee_msat: u64, purpose: crate::lightning::events::PaymentPurpose, via_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, via_user_channel_id: crate::c_types::derived::COption_U128Z, claim_deadline: crate::c_types::derived::COption_u32Z) -> Event { Event::PaymentClaimable { receiver_node_id, payment_hash, @@ -2331,17 +2842,34 @@ pub extern "C" fn Event_payment_claimable(receiver_node_id: crate::c_types::Publ } #[no_mangle] /// Utility method to constructs a new PaymentClaimed-variant Event -pub extern "C" fn Event_payment_claimed(receiver_node_id: crate::c_types::PublicKey, payment_hash: crate::c_types::ThirtyTwoBytes, amount_msat: u64, purpose: crate::lightning::events::PaymentPurpose) -> Event { +pub extern "C" fn Event_payment_claimed(receiver_node_id: crate::c_types::PublicKey, payment_hash: crate::c_types::ThirtyTwoBytes, amount_msat: u64, purpose: crate::lightning::events::PaymentPurpose, htlcs: crate::c_types::derived::CVec_ClaimedHTLCZ, sender_intended_total_msat: crate::c_types::derived::COption_u64Z) -> Event { Event::PaymentClaimed { receiver_node_id, payment_hash, amount_msat, purpose, + htlcs, + sender_intended_total_msat, + } +} +#[no_mangle] +/// Utility method to constructs a new ConnectionNeeded-variant Event +pub extern "C" fn Event_connection_needed(node_id: crate::c_types::PublicKey, addresses: crate::c_types::derived::CVec_SocketAddressZ) -> Event { + Event::ConnectionNeeded { + node_id, + addresses, + } +} +#[no_mangle] +/// Utility method to constructs a new InvoiceRequestFailed-variant Event +pub extern "C" fn Event_invoice_request_failed(payment_id: crate::c_types::ThirtyTwoBytes) -> Event { + Event::InvoiceRequestFailed { + payment_id, } } #[no_mangle] /// Utility method to constructs a new PaymentSent-variant Event -pub extern "C" fn Event_payment_sent(payment_id: crate::c_types::derived::COption_PaymentIdZ, payment_preimage: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::ThirtyTwoBytes, fee_paid_msat: crate::c_types::derived::COption_u64Z) -> Event { +pub extern "C" fn Event_payment_sent(payment_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, payment_preimage: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::ThirtyTwoBytes, fee_paid_msat: crate::c_types::derived::COption_u64Z) -> Event { Event::PaymentSent { payment_id, payment_preimage, @@ -2360,7 +2888,7 @@ pub extern "C" fn Event_payment_failed(payment_id: crate::c_types::ThirtyTwoByte } #[no_mangle] /// Utility method to constructs a new PaymentPathSuccessful-variant Event -pub extern "C" fn Event_payment_path_successful(payment_id: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::derived::COption_PaymentHashZ, path: crate::lightning::routing::router::Path) -> Event { +pub extern "C" fn Event_payment_path_successful(payment_id: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::derived::COption_ThirtyTwoBytesZ, path: crate::lightning::routing::router::Path) -> Event { Event::PaymentPathSuccessful { payment_id, payment_hash, @@ -2369,7 +2897,7 @@ pub extern "C" fn Event_payment_path_successful(payment_id: crate::c_types::Thir } #[no_mangle] /// Utility method to constructs a new PaymentPathFailed-variant Event -pub extern "C" fn Event_payment_path_failed(payment_id: crate::c_types::derived::COption_PaymentIdZ, payment_hash: crate::c_types::ThirtyTwoBytes, payment_failed_permanently: bool, failure: crate::lightning::events::PathFailure, path: crate::lightning::routing::router::Path, short_channel_id: crate::c_types::derived::COption_u64Z) -> Event { +pub extern "C" fn Event_payment_path_failed(payment_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, payment_hash: crate::c_types::ThirtyTwoBytes, payment_failed_permanently: bool, failure: crate::lightning::events::PathFailure, path: crate::lightning::routing::router::Path, short_channel_id: crate::c_types::derived::COption_u64Z) -> Event { Event::PaymentPathFailed { payment_id, payment_hash, @@ -2418,14 +2946,15 @@ pub extern "C" fn Event_htlcintercepted(intercept_id: crate::c_types::ThirtyTwoB } #[no_mangle] /// Utility method to constructs a new SpendableOutputs-variant Event -pub extern "C" fn Event_spendable_outputs(outputs: crate::c_types::derived::CVec_SpendableOutputDescriptorZ) -> Event { +pub extern "C" fn Event_spendable_outputs(outputs: crate::c_types::derived::CVec_SpendableOutputDescriptorZ, channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ) -> Event { Event::SpendableOutputs { outputs, + channel_id, } } #[no_mangle] /// Utility method to constructs a new PaymentForwarded-variant Event -pub extern "C" fn Event_payment_forwarded(prev_channel_id: crate::c_types::ThirtyTwoBytes, next_channel_id: crate::c_types::ThirtyTwoBytes, fee_earned_msat: crate::c_types::derived::COption_u64Z, claim_from_onchain_tx: bool, outbound_amount_forwarded_msat: crate::c_types::derived::COption_u64Z) -> Event { +pub extern "C" fn Event_payment_forwarded(prev_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, next_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, fee_earned_msat: crate::c_types::derived::COption_u64Z, claim_from_onchain_tx: bool, outbound_amount_forwarded_msat: crate::c_types::derived::COption_u64Z) -> Event { Event::PaymentForwarded { prev_channel_id, next_channel_id, @@ -2436,7 +2965,7 @@ pub extern "C" fn Event_payment_forwarded(prev_channel_id: crate::c_types::Thirt } #[no_mangle] /// Utility method to constructs a new ChannelPending-variant Event -pub extern "C" fn Event_channel_pending(channel_id: crate::c_types::ThirtyTwoBytes, user_channel_id: crate::c_types::U128, former_temporary_channel_id: crate::c_types::ThirtyTwoBytes, counterparty_node_id: crate::c_types::PublicKey, funding_txo: crate::lightning::chain::transaction::OutPoint) -> Event { +pub extern "C" fn Event_channel_pending(channel_id: crate::c_types::ThirtyTwoBytes, user_channel_id: crate::c_types::U128, former_temporary_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, counterparty_node_id: crate::c_types::PublicKey, funding_txo: crate::lightning::chain::transaction::OutPoint) -> Event { Event::ChannelPending { channel_id, user_channel_id, @@ -2457,11 +2986,14 @@ pub extern "C" fn Event_channel_ready(channel_id: crate::c_types::ThirtyTwoBytes } #[no_mangle] /// Utility method to constructs a new ChannelClosed-variant Event -pub extern "C" fn Event_channel_closed(channel_id: crate::c_types::ThirtyTwoBytes, user_channel_id: crate::c_types::U128, reason: crate::lightning::events::ClosureReason) -> Event { +pub extern "C" fn Event_channel_closed(channel_id: crate::c_types::ThirtyTwoBytes, user_channel_id: crate::c_types::U128, reason: crate::lightning::events::ClosureReason, counterparty_node_id: crate::c_types::PublicKey, channel_capacity_sats: crate::c_types::derived::COption_u64Z, channel_funding_txo: crate::lightning::chain::transaction::OutPoint) -> Event { Event::ChannelClosed { channel_id, user_channel_id, reason, + counterparty_node_id, + channel_capacity_sats, + channel_funding_txo, } } #[no_mangle] @@ -2496,6 +3028,9 @@ pub extern "C" fn Event_htlchandling_failed(prev_channel_id: crate::c_types::Thi pub extern "C" fn Event_bump_transaction(a: crate::lightning::events::bump_transaction::BumpTransactionEvent) -> Event { Event::BumpTransaction(a, ) } +/// Get a string which allows debug introspection of a Event object +pub extern "C" fn Event_debug_str_void(o: *const c_void) -> Str { + alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::Event }).into()} /// Checks if two Events contain equal inner contents. /// This ignores pointers and is_owned flags and looks at the values in fields. #[no_mangle] @@ -2507,6 +3042,10 @@ pub extern "C" fn Event_eq(a: &Event, b: &Event) -> bool { pub extern "C" fn Event_write(obj: &crate::lightning::events::Event) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(&unsafe { &*obj }.to_native()) } +#[allow(unused)] +pub(crate) extern "C" fn Event_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + Event_write(unsafe { &*(obj as *const Event) }) +} #[no_mangle] /// Read a Event from a byte array, created by Event_write pub extern "C" fn Event_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_EventZDecodeErrorZ { @@ -2567,6 +3106,34 @@ pub enum MessageSendEvent { /// The message which should be sent. msg: crate::lightning::ln::msgs::FundingSigned, }, + /// Used to indicate that a stfu message should be sent to the peer with the given node id. + SendStfu { + /// The node_id of the node which should receive this message + node_id: crate::c_types::PublicKey, + /// The message which should be sent. + msg: crate::lightning::ln::msgs::Stfu, + }, + /// Used to indicate that a splice message should be sent to the peer with the given node id. + SendSplice { + /// The node_id of the node which should receive this message + node_id: crate::c_types::PublicKey, + /// The message which should be sent. + msg: crate::lightning::ln::msgs::Splice, + }, + /// Used to indicate that a splice_ack message should be sent to the peer with the given node id. + SendSpliceAck { + /// The node_id of the node which should receive this message + node_id: crate::c_types::PublicKey, + /// The message which should be sent. + msg: crate::lightning::ln::msgs::SpliceAck, + }, + /// Used to indicate that a splice_locked message should be sent to the peer with the given node id. + SendSpliceLocked { + /// The node_id of the node which should receive this message + node_id: crate::c_types::PublicKey, + /// The message which should be sent. + msg: crate::lightning::ln::msgs::SpliceLocked, + }, /// Used to indicate that a tx_add_input message should be sent to the peer with the given node_id. SendTxAddInput { /// The node_id of the node which should receive this message @@ -2628,7 +3195,7 @@ pub enum MessageSendEvent { /// The node_id of the node which should receive this message node_id: crate::c_types::PublicKey, /// The message which should be sent. - msg: crate::lightning::ln::msgs::TxAddInput, + msg: crate::lightning::ln::msgs::TxAbort, }, /// Used to indicate that a channel_ready message should be sent to the peer with the given node_id. SendChannelReady { @@ -2821,6 +3388,38 @@ impl MessageSendEvent { msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, + MessageSendEvent::SendStfu {ref node_id, ref msg, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + nativeMessageSendEvent::SendStfu { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, + } + }, + MessageSendEvent::SendSplice {ref node_id, ref msg, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + nativeMessageSendEvent::SendSplice { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, + } + }, + MessageSendEvent::SendSpliceAck {ref node_id, ref msg, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + nativeMessageSendEvent::SendSpliceAck { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, + } + }, + MessageSendEvent::SendSpliceLocked {ref node_id, ref msg, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + nativeMessageSendEvent::SendSpliceLocked { + node_id: node_id_nonref.into_rust(), + msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, + } + }, MessageSendEvent::SendTxAddInput {ref node_id, ref msg, } => { let mut node_id_nonref = Clone::clone(node_id); let mut msg_nonref = Clone::clone(msg); @@ -3069,6 +3668,30 @@ impl MessageSendEvent { msg: *unsafe { Box::from_raw(msg.take_inner()) }, } }, + MessageSendEvent::SendStfu {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendStfu { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_inner()) }, + } + }, + MessageSendEvent::SendSplice {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendSplice { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_inner()) }, + } + }, + MessageSendEvent::SendSpliceAck {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendSpliceAck { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_inner()) }, + } + }, + MessageSendEvent::SendSpliceLocked {mut node_id, mut msg, } => { + nativeMessageSendEvent::SendSpliceLocked { + node_id: node_id.into_rust(), + msg: *unsafe { Box::from_raw(msg.take_inner()) }, + } + }, MessageSendEvent::SendTxAddInput {mut node_id, mut msg, } => { nativeMessageSendEvent::SendTxAddInput { node_id: node_id.into_rust(), @@ -3228,7 +3851,8 @@ impl MessageSendEvent { } } #[allow(unused)] - pub(crate) fn from_native(native: &nativeMessageSendEvent) -> Self { + pub(crate) fn from_native(native: &MessageSendEventImport) -> Self { + let native = unsafe { &*(native as *const _ as *const c_void as *const nativeMessageSendEvent) }; match native { nativeMessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => { let mut node_id_nonref = Clone::clone(node_id); @@ -3278,6 +3902,38 @@ impl MessageSendEvent { msg: crate::lightning::ln::msgs::FundingSigned { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, + nativeMessageSendEvent::SendStfu {ref node_id, ref msg, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + MessageSendEvent::SendStfu { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::lightning::ln::msgs::Stfu { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, + } + }, + nativeMessageSendEvent::SendSplice {ref node_id, ref msg, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + MessageSendEvent::SendSplice { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::lightning::ln::msgs::Splice { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, + } + }, + nativeMessageSendEvent::SendSpliceAck {ref node_id, ref msg, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + MessageSendEvent::SendSpliceAck { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::lightning::ln::msgs::SpliceAck { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, + } + }, + nativeMessageSendEvent::SendSpliceLocked {ref node_id, ref msg, } => { + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + MessageSendEvent::SendSpliceLocked { + node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), + msg: crate::lightning::ln::msgs::SpliceLocked { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, + } + }, nativeMessageSendEvent::SendTxAddInput {ref node_id, ref msg, } => { let mut node_id_nonref = Clone::clone(node_id); let mut msg_nonref = Clone::clone(msg); @@ -3347,7 +4003,7 @@ impl MessageSendEvent { let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendTxAbort { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), - msg: crate::lightning::ln::msgs::TxAddInput { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, + msg: crate::lightning::ln::msgs::TxAbort { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendChannelReady {ref node_id, ref msg, } => { @@ -3526,6 +4182,30 @@ impl MessageSendEvent { msg: crate::lightning::ln::msgs::FundingSigned { inner: ObjOps::heap_alloc(msg), is_owned: true }, } }, + nativeMessageSendEvent::SendStfu {mut node_id, mut msg, } => { + MessageSendEvent::SendStfu { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::lightning::ln::msgs::Stfu { inner: ObjOps::heap_alloc(msg), is_owned: true }, + } + }, + nativeMessageSendEvent::SendSplice {mut node_id, mut msg, } => { + MessageSendEvent::SendSplice { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::lightning::ln::msgs::Splice { inner: ObjOps::heap_alloc(msg), is_owned: true }, + } + }, + nativeMessageSendEvent::SendSpliceAck {mut node_id, mut msg, } => { + MessageSendEvent::SendSpliceAck { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::lightning::ln::msgs::SpliceAck { inner: ObjOps::heap_alloc(msg), is_owned: true }, + } + }, + nativeMessageSendEvent::SendSpliceLocked {mut node_id, mut msg, } => { + MessageSendEvent::SendSpliceLocked { + node_id: crate::c_types::PublicKey::from_rust(&node_id), + msg: crate::lightning::ln::msgs::SpliceLocked { inner: ObjOps::heap_alloc(msg), is_owned: true }, + } + }, nativeMessageSendEvent::SendTxAddInput {mut node_id, mut msg, } => { MessageSendEvent::SendTxAddInput { node_id: crate::c_types::PublicKey::from_rust(&node_id), @@ -3577,7 +4257,7 @@ impl MessageSendEvent { nativeMessageSendEvent::SendTxAbort {mut node_id, mut msg, } => { MessageSendEvent::SendTxAbort { node_id: crate::c_types::PublicKey::from_rust(&node_id), - msg: crate::lightning::ln::msgs::TxAddInput { inner: ObjOps::heap_alloc(msg), is_owned: true }, + msg: crate::lightning::ln::msgs::TxAbort { inner: ObjOps::heap_alloc(msg), is_owned: true }, } }, nativeMessageSendEvent::SendChannelReady {mut node_id, mut msg, } => { @@ -3693,6 +4373,16 @@ pub extern "C" fn MessageSendEvent_free(this_ptr: MessageSendEvent) { } pub extern "C" fn MessageSendEvent_clone(orig: &MessageSendEvent) -> MessageSendEvent { 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 MessageSendEvent_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *const MessageSendEvent)).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 MessageSendEvent_free_void(this_ptr: *mut c_void) { + let _ = unsafe { Box::from_raw(this_ptr as *mut MessageSendEvent) }; +} #[no_mangle] /// Utility method to constructs a new SendAcceptChannel-variant MessageSendEvent pub extern "C" fn MessageSendEvent_send_accept_channel(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::AcceptChannel) -> MessageSendEvent { @@ -3742,6 +4432,38 @@ pub extern "C" fn MessageSendEvent_send_funding_signed(node_id: crate::c_types:: } } #[no_mangle] +/// Utility method to constructs a new SendStfu-variant MessageSendEvent +pub extern "C" fn MessageSendEvent_send_stfu(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::Stfu) -> MessageSendEvent { + MessageSendEvent::SendStfu { + node_id, + msg, + } +} +#[no_mangle] +/// Utility method to constructs a new SendSplice-variant MessageSendEvent +pub extern "C" fn MessageSendEvent_send_splice(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::Splice) -> MessageSendEvent { + MessageSendEvent::SendSplice { + node_id, + msg, + } +} +#[no_mangle] +/// Utility method to constructs a new SendSpliceAck-variant MessageSendEvent +pub extern "C" fn MessageSendEvent_send_splice_ack(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::SpliceAck) -> MessageSendEvent { + MessageSendEvent::SendSpliceAck { + node_id, + msg, + } +} +#[no_mangle] +/// Utility method to constructs a new SendSpliceLocked-variant MessageSendEvent +pub extern "C" fn MessageSendEvent_send_splice_locked(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::SpliceLocked) -> MessageSendEvent { + MessageSendEvent::SendSpliceLocked { + node_id, + msg, + } +} +#[no_mangle] /// Utility method to constructs a new SendTxAddInput-variant MessageSendEvent pub extern "C" fn MessageSendEvent_send_tx_add_input(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxAddInput) -> MessageSendEvent { MessageSendEvent::SendTxAddInput { @@ -3807,7 +4529,7 @@ pub extern "C" fn MessageSendEvent_send_tx_ack_rbf(node_id: crate::c_types::Publ } #[no_mangle] /// Utility method to constructs a new SendTxAbort-variant MessageSendEvent -pub extern "C" fn MessageSendEvent_send_tx_abort(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxAddInput) -> MessageSendEvent { +pub extern "C" fn MessageSendEvent_send_tx_abort(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxAbort) -> MessageSendEvent { MessageSendEvent::SendTxAbort { node_id, msg, @@ -3948,6 +4670,9 @@ pub extern "C" fn MessageSendEvent_send_gossip_timestamp_filter(node_id: crate:: msg, } } +/// Get a string which allows debug introspection of a MessageSendEvent object +pub extern "C" fn MessageSendEvent_debug_str_void(o: *const c_void) -> Str { + alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::MessageSendEvent }).into()} /// A trait indicating an object may generate message send events #[repr(C)] pub struct MessageSendEventsProvider { @@ -3963,8 +4688,8 @@ pub struct MessageSendEventsProvider { } unsafe impl Send for MessageSendEventsProvider {} unsafe impl Sync for MessageSendEventsProvider {} -#[no_mangle] -pub(crate) extern "C" fn MessageSendEventsProvider_clone_fields(orig: &MessageSendEventsProvider) -> MessageSendEventsProvider { +#[allow(unused)] +pub(crate) fn MessageSendEventsProvider_clone_fields(orig: &MessageSendEventsProvider) -> MessageSendEventsProvider { MessageSendEventsProvider { this_arg: orig.this_arg, get_and_clear_pending_msg_events: Clone::clone(&orig.get_and_clear_pending_msg_events), @@ -3989,62 +4714,15 @@ impl core::ops::Deref for MessageSendEventsProvider { self } } -/// Calls the free function if one is set -#[no_mangle] -pub extern "C" fn MessageSendEventsProvider_free(this_ptr: MessageSendEventsProvider) { } -impl Drop for MessageSendEventsProvider { - fn drop(&mut self) { - if let Some(f) = self.free { - f(self.this_arg); - } - } -} -/// A trait indicating an object may generate onion messages to send -#[repr(C)] -pub struct OnionMessageProvider { - /// An opaque pointer which is passed to your function implementations as an argument. - /// This has no meaning in the LDK, and can be NULL or any other value. - pub this_arg: *mut c_void, - /// Gets the next pending onion message for the peer with the given node id. - /// - /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None - pub next_onion_message_for_peer: extern "C" fn (this_arg: *const c_void, peer_node_id: crate::c_types::PublicKey) -> crate::lightning::ln::msgs::OnionMessage, - /// Frees any resources associated with this object given its this_arg pointer. - /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed. - pub free: Option, -} -unsafe impl Send for OnionMessageProvider {} -unsafe impl Sync for OnionMessageProvider {} -#[no_mangle] -pub(crate) extern "C" fn OnionMessageProvider_clone_fields(orig: &OnionMessageProvider) -> OnionMessageProvider { - OnionMessageProvider { - this_arg: orig.this_arg, - next_onion_message_for_peer: Clone::clone(&orig.next_onion_message_for_peer), - free: Clone::clone(&orig.free), - } -} - -use lightning::events::OnionMessageProvider as rustOnionMessageProvider; -impl rustOnionMessageProvider for OnionMessageProvider { - fn next_onion_message_for_peer(&self, mut peer_node_id: bitcoin::secp256k1::PublicKey) -> Option { - let mut ret = (self.next_onion_message_for_peer)(self.this_arg, crate::c_types::PublicKey::from_rust(&peer_node_id)); - let mut local_ret = if ret.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(ret.take_inner()) } }) }; - local_ret - } -} - -// We're essentially a pointer already, or at least a set of pointers, so allow us to be used -// directly as a Deref trait in higher-level structs: -impl core::ops::Deref for OnionMessageProvider { - type Target = Self; - fn deref(&self) -> &Self { +impl core::ops::DerefMut for MessageSendEventsProvider { + fn deref_mut(&mut self) -> &mut Self { self } } /// Calls the free function if one is set #[no_mangle] -pub extern "C" fn OnionMessageProvider_free(this_ptr: OnionMessageProvider) { } -impl Drop for OnionMessageProvider { +pub extern "C" fn MessageSendEventsProvider_free(this_ptr: MessageSendEventsProvider) { } +impl Drop for MessageSendEventsProvider { fn drop(&mut self) { if let Some(f) = self.free { f(self.this_arg); @@ -4102,8 +4780,8 @@ pub struct EventsProvider { } unsafe impl Send for EventsProvider {} unsafe impl Sync for EventsProvider {} -#[no_mangle] -pub(crate) extern "C" fn EventsProvider_clone_fields(orig: &EventsProvider) -> EventsProvider { +#[allow(unused)] +pub(crate) fn EventsProvider_clone_fields(orig: &EventsProvider) -> EventsProvider { EventsProvider { this_arg: orig.this_arg, process_pending_events: Clone::clone(&orig.process_pending_events), @@ -4142,8 +4820,8 @@ pub struct EventHandler { } unsafe impl Send for EventHandler {} unsafe impl Sync for EventHandler {} -#[no_mangle] -pub(crate) extern "C" fn EventHandler_clone_fields(orig: &EventHandler) -> EventHandler { +#[allow(unused)] +pub(crate) fn EventHandler_clone_fields(orig: &EventHandler) -> EventHandler { EventHandler { this_arg: orig.this_arg, handle_event: Clone::clone(&orig.handle_event), @@ -4166,6 +4844,11 @@ impl core::ops::Deref for EventHandler { self } } +impl core::ops::DerefMut for EventHandler { + fn deref_mut(&mut self) -> &mut Self { + self + } +} /// Calls the free function if one is set #[no_mangle] pub extern "C" fn EventHandler_free(this_ptr: EventHandler) { }