1 // This file is Copyright its original authors, visible in version control
2 // history and in the source files from which this was generated.
4 // This file is licensed under the license available in the LICENSE or LICENSE.md
5 // file in the root of this repository or, if no such file exists, the same
6 // license as that which applies to the original source files from which this
7 // source was automatically generated.
9 //! Events are returned from various bits in the library which indicate some action must be taken
12 //! Because we don't have a built-in runtime, it's up to the client to call events at a time in the
13 //! future, as well as generate and broadcast funding transactions handle payment preimages and a
16 use alloc::str::FromStr;
17 use alloc::string::String;
18 use core::ffi::c_void;
19 use core::convert::Infallible;
20 use bitcoin::hashes::Hash;
21 use crate::c_types::*;
22 #[cfg(feature="no-std")]
23 use alloc::{vec::Vec, boxed::Box};
25 pub mod bump_transaction;
26 /// Some information provided on receipt of payment depends on whether the payment received is a
27 /// spontaneous payment or a \"conventional\" lightning payment that's paying an invoice.
31 pub enum PaymentPurpose {
32 /// Information for receiving a payment that we generated an invoice for.
34 /// The preimage to the payment_hash, if the payment hash (and secret) were fetched via
35 /// [`ChannelManager::create_inbound_payment`]. If provided, this can be handed directly to
36 /// [`ChannelManager::claim_funds`].
38 /// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
39 /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
40 payment_preimage: crate::c_types::derived::COption_ThirtyTwoBytesZ,
41 /// The \"payment secret\". This authenticates the sender to the recipient, preventing a
42 /// number of deanonymization attacks during the routing process.
43 /// It is provided here for your reference, however its accuracy is enforced directly by
44 /// [`ChannelManager`] using the values you previously provided to
45 /// [`ChannelManager::create_inbound_payment`] or
46 /// [`ChannelManager::create_inbound_payment_for_hash`].
48 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
49 /// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
50 /// [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
51 payment_secret: crate::c_types::ThirtyTwoBytes,
53 /// Because this is a spontaneous payment, the payer generated their own preimage rather than us
54 /// (the payee) providing a preimage.
56 crate::c_types::ThirtyTwoBytes),
58 use lightning::events::PaymentPurpose as PaymentPurposeImport;
59 pub(crate) type nativePaymentPurpose = PaymentPurposeImport;
63 pub(crate) fn to_native(&self) -> nativePaymentPurpose {
65 PaymentPurpose::InvoicePayment {ref payment_preimage, ref payment_secret, } => {
66 let mut payment_preimage_nonref = Clone::clone(payment_preimage);
67 let mut local_payment_preimage_nonref = { /*payment_preimage_nonref*/ let payment_preimage_nonref_opt = payment_preimage_nonref; if payment_preimage_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::PaymentPreimage({ payment_preimage_nonref_opt.take() }.data) }})} };
68 let mut payment_secret_nonref = Clone::clone(payment_secret);
69 nativePaymentPurpose::InvoicePayment {
70 payment_preimage: local_payment_preimage_nonref,
71 payment_secret: ::lightning::ln::PaymentSecret(payment_secret_nonref.data),
74 PaymentPurpose::SpontaneousPayment (ref a, ) => {
75 let mut a_nonref = Clone::clone(a);
76 nativePaymentPurpose::SpontaneousPayment (
77 ::lightning::ln::PaymentPreimage(a_nonref.data),
83 pub(crate) fn into_native(self) -> nativePaymentPurpose {
85 PaymentPurpose::InvoicePayment {mut payment_preimage, mut payment_secret, } => {
86 let mut local_payment_preimage = { /*payment_preimage*/ let payment_preimage_opt = payment_preimage; if payment_preimage_opt.is_none() { None } else { Some({ { ::lightning::ln::PaymentPreimage({ payment_preimage_opt.take() }.data) }})} };
87 nativePaymentPurpose::InvoicePayment {
88 payment_preimage: local_payment_preimage,
89 payment_secret: ::lightning::ln::PaymentSecret(payment_secret.data),
92 PaymentPurpose::SpontaneousPayment (mut a, ) => {
93 nativePaymentPurpose::SpontaneousPayment (
94 ::lightning::ln::PaymentPreimage(a.data),
100 pub(crate) fn from_native(native: &nativePaymentPurpose) -> Self {
102 nativePaymentPurpose::InvoicePayment {ref payment_preimage, ref payment_secret, } => {
103 let mut payment_preimage_nonref = Clone::clone(payment_preimage);
104 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 } }) };
105 let mut payment_secret_nonref = Clone::clone(payment_secret);
106 PaymentPurpose::InvoicePayment {
107 payment_preimage: local_payment_preimage_nonref,
108 payment_secret: crate::c_types::ThirtyTwoBytes { data: payment_secret_nonref.0 },
111 nativePaymentPurpose::SpontaneousPayment (ref a, ) => {
112 let mut a_nonref = Clone::clone(a);
113 PaymentPurpose::SpontaneousPayment (
114 crate::c_types::ThirtyTwoBytes { data: a_nonref.0 },
120 pub(crate) fn native_into(native: nativePaymentPurpose) -> Self {
122 nativePaymentPurpose::InvoicePayment {mut payment_preimage, mut payment_secret, } => {
123 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 } }) };
124 PaymentPurpose::InvoicePayment {
125 payment_preimage: local_payment_preimage,
126 payment_secret: crate::c_types::ThirtyTwoBytes { data: payment_secret.0 },
129 nativePaymentPurpose::SpontaneousPayment (mut a, ) => {
130 PaymentPurpose::SpontaneousPayment (
131 crate::c_types::ThirtyTwoBytes { data: a.0 },
137 /// Frees any resources used by the PaymentPurpose
139 pub extern "C" fn PaymentPurpose_free(this_ptr: PaymentPurpose) { }
140 /// Creates a copy of the PaymentPurpose
142 pub extern "C" fn PaymentPurpose_clone(orig: &PaymentPurpose) -> PaymentPurpose {
146 /// Utility method to constructs a new InvoicePayment-variant PaymentPurpose
147 pub extern "C" fn PaymentPurpose_invoice_payment(payment_preimage: crate::c_types::derived::COption_ThirtyTwoBytesZ, payment_secret: crate::c_types::ThirtyTwoBytes) -> PaymentPurpose {
148 PaymentPurpose::InvoicePayment {
154 /// Utility method to constructs a new SpontaneousPayment-variant PaymentPurpose
155 pub extern "C" fn PaymentPurpose_spontaneous_payment(a: crate::c_types::ThirtyTwoBytes) -> PaymentPurpose {
156 PaymentPurpose::SpontaneousPayment(a, )
158 /// Checks if two PaymentPurposes contain equal inner contents.
159 /// This ignores pointers and is_owned flags and looks at the values in fields.
161 pub extern "C" fn PaymentPurpose_eq(a: &PaymentPurpose, b: &PaymentPurpose) -> bool {
162 if &a.to_native() == &b.to_native() { true } else { false }
165 /// Serialize the PaymentPurpose object into a byte array which can be read by PaymentPurpose_read
166 pub extern "C" fn PaymentPurpose_write(obj: &crate::lightning::events::PaymentPurpose) -> crate::c_types::derived::CVec_u8Z {
167 crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
170 /// Read a PaymentPurpose from a byte array, created by PaymentPurpose_write
171 pub extern "C" fn PaymentPurpose_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PaymentPurposeDecodeErrorZ {
172 let res: Result<lightning::events::PaymentPurpose, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
173 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() };
177 use lightning::events::ClaimedHTLC as nativeClaimedHTLCImport;
178 pub(crate) type nativeClaimedHTLC = nativeClaimedHTLCImport;
180 /// Information about an HTLC that is part of a payment that can be claimed.
183 pub struct ClaimedHTLC {
184 /// A pointer to the opaque Rust object.
186 /// Nearly everywhere, inner must be non-null, however in places where
187 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
188 pub inner: *mut nativeClaimedHTLC,
189 /// Indicates that this is the only struct which contains the same pointer.
191 /// Rust functions which take ownership of an object provided via an argument require
192 /// this to be true and invalidate the object pointed to by inner.
196 impl Drop for ClaimedHTLC {
198 if self.is_owned && !<*mut nativeClaimedHTLC>::is_null(self.inner) {
199 let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
203 /// Frees any resources used by the ClaimedHTLC, if is_owned is set and inner is non-NULL.
205 pub extern "C" fn ClaimedHTLC_free(this_obj: ClaimedHTLC) { }
207 /// Used only if an object of this type is returned as a trait impl by a method
208 pub(crate) extern "C" fn ClaimedHTLC_free_void(this_ptr: *mut c_void) {
209 let _ = unsafe { Box::from_raw(this_ptr as *mut nativeClaimedHTLC) };
213 pub(crate) fn get_native_ref(&self) -> &'static nativeClaimedHTLC {
214 unsafe { &*ObjOps::untweak_ptr(self.inner) }
216 pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeClaimedHTLC {
217 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
219 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
220 pub(crate) fn take_inner(mut self) -> *mut nativeClaimedHTLC {
221 assert!(self.is_owned);
222 let ret = ObjOps::untweak_ptr(self.inner);
223 self.inner = core::ptr::null_mut();
227 /// The `channel_id` of the channel over which the HTLC was received.
229 pub extern "C" fn ClaimedHTLC_get_channel_id(this_ptr: &ClaimedHTLC) -> *const [u8; 32] {
230 let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
233 /// The `channel_id` of the channel over which the HTLC was received.
235 pub extern "C" fn ClaimedHTLC_set_channel_id(this_ptr: &mut ClaimedHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
236 unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = ::lightning::ln::ChannelId(val.data);
238 /// The `user_channel_id` of the channel over which the HTLC was received. This is the value
239 /// passed in to [`ChannelManager::create_channel`] for outbound channels, or to
240 /// [`ChannelManager::accept_inbound_channel`] for inbound channels if
241 /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
242 /// `user_channel_id` will be randomized for an inbound channel.
244 /// This field will be zero for a payment that was serialized prior to LDK version 0.0.117. (This
245 /// should only happen in the case that a payment was claimable prior to LDK version 0.0.117, but
246 /// was not actually claimed until after upgrading.)
248 /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel
249 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
250 /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
252 pub extern "C" fn ClaimedHTLC_get_user_channel_id(this_ptr: &ClaimedHTLC) -> crate::c_types::U128 {
253 let mut inner_val = &mut this_ptr.get_native_mut_ref().user_channel_id;
256 /// The `user_channel_id` of the channel over which the HTLC was received. This is the value
257 /// passed in to [`ChannelManager::create_channel`] for outbound channels, or to
258 /// [`ChannelManager::accept_inbound_channel`] for inbound channels if
259 /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
260 /// `user_channel_id` will be randomized for an inbound channel.
262 /// This field will be zero for a payment that was serialized prior to LDK version 0.0.117. (This
263 /// should only happen in the case that a payment was claimable prior to LDK version 0.0.117, but
264 /// was not actually claimed until after upgrading.)
266 /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel
267 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
268 /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
270 pub extern "C" fn ClaimedHTLC_set_user_channel_id(this_ptr: &mut ClaimedHTLC, mut val: crate::c_types::U128) {
271 unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.user_channel_id = val.into();
273 /// The block height at which this HTLC expires.
275 pub extern "C" fn ClaimedHTLC_get_cltv_expiry(this_ptr: &ClaimedHTLC) -> u32 {
276 let mut inner_val = &mut this_ptr.get_native_mut_ref().cltv_expiry;
279 /// The block height at which this HTLC expires.
281 pub extern "C" fn ClaimedHTLC_set_cltv_expiry(this_ptr: &mut ClaimedHTLC, mut val: u32) {
282 unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry = val;
284 /// The amount (in msats) of this part of an MPP.
286 pub extern "C" fn ClaimedHTLC_get_value_msat(this_ptr: &ClaimedHTLC) -> u64 {
287 let mut inner_val = &mut this_ptr.get_native_mut_ref().value_msat;
290 /// The amount (in msats) of this part of an MPP.
292 pub extern "C" fn ClaimedHTLC_set_value_msat(this_ptr: &mut ClaimedHTLC, mut val: u64) {
293 unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.value_msat = val;
295 /// Constructs a new ClaimedHTLC given each field
298 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) -> ClaimedHTLC {
299 ClaimedHTLC { inner: ObjOps::heap_alloc(nativeClaimedHTLC {
300 channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
301 user_channel_id: user_channel_id_arg.into(),
302 cltv_expiry: cltv_expiry_arg,
303 value_msat: value_msat_arg,
306 impl Clone for ClaimedHTLC {
307 fn clone(&self) -> Self {
309 inner: if <*mut nativeClaimedHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
310 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
316 /// Used only if an object of this type is returned as a trait impl by a method
317 pub(crate) extern "C" fn ClaimedHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
318 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeClaimedHTLC)).clone() })) as *mut c_void
321 /// Creates a copy of the ClaimedHTLC
322 pub extern "C" fn ClaimedHTLC_clone(orig: &ClaimedHTLC) -> ClaimedHTLC {
325 /// Checks if two ClaimedHTLCs contain equal inner contents.
326 /// This ignores pointers and is_owned flags and looks at the values in fields.
327 /// Two objects with NULL inner values will be considered "equal" here.
329 pub extern "C" fn ClaimedHTLC_eq(a: &ClaimedHTLC, b: &ClaimedHTLC) -> bool {
330 if a.inner == b.inner { return true; }
331 if a.inner.is_null() || b.inner.is_null() { return false; }
332 if a.get_native_ref() == b.get_native_ref() { true } else { false }
335 /// Serialize the ClaimedHTLC object into a byte array which can be read by ClaimedHTLC_read
336 pub extern "C" fn ClaimedHTLC_write(obj: &crate::lightning::events::ClaimedHTLC) -> crate::c_types::derived::CVec_u8Z {
337 crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
340 pub(crate) extern "C" fn ClaimedHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
341 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeClaimedHTLC) })
344 /// Read a ClaimedHTLC from a byte array, created by ClaimedHTLC_write
345 pub extern "C" fn ClaimedHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ClaimedHTLCDecodeErrorZ {
346 let res: Result<lightning::events::ClaimedHTLC, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
347 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() };
350 /// When the payment path failure took place and extra details about it. [`PathFailure::OnPath`] may
351 /// contain a [`NetworkUpdate`] that needs to be applied to the [`NetworkGraph`].
353 /// [`NetworkUpdate`]: crate::routing::gossip::NetworkUpdate
354 /// [`NetworkGraph`]: crate::routing::gossip::NetworkGraph
358 pub enum PathFailure {
359 /// We failed to initially send the payment and no HTLC was committed to. Contains the relevant
362 /// The error surfaced from initial send.
363 err: crate::lightning::util::errors::APIError,
365 /// A hop on the path failed to forward our payment.
367 /// If present, this [`NetworkUpdate`] should be applied to the [`NetworkGraph`] so that routing
368 /// decisions can take into account the update.
370 /// [`NetworkUpdate`]: crate::routing::gossip::NetworkUpdate
371 /// [`NetworkGraph`]: crate::routing::gossip::NetworkGraph
372 network_update: crate::c_types::derived::COption_NetworkUpdateZ,
375 use lightning::events::PathFailure as PathFailureImport;
376 pub(crate) type nativePathFailure = PathFailureImport;
380 pub(crate) fn to_native(&self) -> nativePathFailure {
382 PathFailure::InitialSend {ref err, } => {
383 let mut err_nonref = Clone::clone(err);
384 nativePathFailure::InitialSend {
385 err: err_nonref.into_native(),
388 PathFailure::OnPath {ref network_update, } => {
389 let mut network_update_nonref = Clone::clone(network_update);
390 let mut local_network_update_nonref = { /*network_update_nonref*/ let network_update_nonref_opt = network_update_nonref; if network_update_nonref_opt.is_none() { None } else { Some({ { { network_update_nonref_opt.take() }.into_native() }})} };
391 nativePathFailure::OnPath {
392 network_update: local_network_update_nonref,
398 pub(crate) fn into_native(self) -> nativePathFailure {
400 PathFailure::InitialSend {mut err, } => {
401 nativePathFailure::InitialSend {
402 err: err.into_native(),
405 PathFailure::OnPath {mut network_update, } => {
406 let mut local_network_update = { /*network_update*/ let network_update_opt = network_update; if network_update_opt.is_none() { None } else { Some({ { { network_update_opt.take() }.into_native() }})} };
407 nativePathFailure::OnPath {
408 network_update: local_network_update,
414 pub(crate) fn from_native(native: &nativePathFailure) -> Self {
416 nativePathFailure::InitialSend {ref err, } => {
417 let mut err_nonref = Clone::clone(err);
418 PathFailure::InitialSend {
419 err: crate::lightning::util::errors::APIError::native_into(err_nonref),
422 nativePathFailure::OnPath {ref network_update, } => {
423 let mut network_update_nonref = Clone::clone(network_update);
424 let mut local_network_update_nonref = if network_update_nonref.is_none() { crate::c_types::derived::COption_NetworkUpdateZ::None } else { crate::c_types::derived::COption_NetworkUpdateZ::Some( { crate::lightning::routing::gossip::NetworkUpdate::native_into(network_update_nonref.unwrap()) }) };
425 PathFailure::OnPath {
426 network_update: local_network_update_nonref,
432 pub(crate) fn native_into(native: nativePathFailure) -> Self {
434 nativePathFailure::InitialSend {mut err, } => {
435 PathFailure::InitialSend {
436 err: crate::lightning::util::errors::APIError::native_into(err),
439 nativePathFailure::OnPath {mut network_update, } => {
440 let mut local_network_update = if network_update.is_none() { crate::c_types::derived::COption_NetworkUpdateZ::None } else { crate::c_types::derived::COption_NetworkUpdateZ::Some( { crate::lightning::routing::gossip::NetworkUpdate::native_into(network_update.unwrap()) }) };
441 PathFailure::OnPath {
442 network_update: local_network_update,
448 /// Frees any resources used by the PathFailure
450 pub extern "C" fn PathFailure_free(this_ptr: PathFailure) { }
451 /// Creates a copy of the PathFailure
453 pub extern "C" fn PathFailure_clone(orig: &PathFailure) -> PathFailure {
457 /// Utility method to constructs a new InitialSend-variant PathFailure
458 pub extern "C" fn PathFailure_initial_send(err: crate::lightning::util::errors::APIError) -> PathFailure {
459 PathFailure::InitialSend {
464 /// Utility method to constructs a new OnPath-variant PathFailure
465 pub extern "C" fn PathFailure_on_path(network_update: crate::c_types::derived::COption_NetworkUpdateZ) -> PathFailure {
466 PathFailure::OnPath {
470 /// Checks if two PathFailures contain equal inner contents.
471 /// This ignores pointers and is_owned flags and looks at the values in fields.
473 pub extern "C" fn PathFailure_eq(a: &PathFailure, b: &PathFailure) -> bool {
474 if &a.to_native() == &b.to_native() { true } else { false }
477 /// Serialize the PathFailure object into a byte array which can be read by PathFailure_read
478 pub extern "C" fn PathFailure_write(obj: &crate::lightning::events::PathFailure) -> crate::c_types::derived::CVec_u8Z {
479 crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
482 /// Read a PathFailure from a byte array, created by PathFailure_write
483 pub extern "C" fn PathFailure_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_PathFailureZDecodeErrorZ {
484 let res: Result<Option<lightning::events::PathFailure>, lightning::ln::msgs::DecodeError> = crate::c_types::maybe_deserialize_obj(ser);
485 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_res_0 = if o.is_none() { crate::c_types::derived::COption_PathFailureZ::None } else { crate::c_types::derived::COption_PathFailureZ::Some( { crate::lightning::events::PathFailure::native_into(o.unwrap()) }) }; local_res_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
488 /// The reason the channel was closed. See individual variants for more details.
492 pub enum ClosureReason {
493 /// Closure generated from receiving a peer error message.
495 /// Our counterparty may have broadcasted their latest commitment state, and we have
497 CounterpartyForceClosed {
498 /// The error which the peer sent us.
500 /// Be careful about printing the peer_msg, a well-crafted message could exploit
501 /// a security vulnerability in the terminal emulator or the logging subsystem.
502 /// To be safe, use `Display` on `UntrustedString`
504 /// [`UntrustedString`]: crate::util::string::UntrustedString
505 peer_msg: crate::lightning::util::string::UntrustedString,
507 /// Closure generated from [`ChannelManager::force_close_channel`], called by the user.
509 /// [`ChannelManager::force_close_channel`]: crate::ln::channelmanager::ChannelManager::force_close_channel.
511 /// The channel was closed after negotiating a cooperative close and we've now broadcasted
512 /// the cooperative close transaction. Note the shutdown may have been initiated by us.
514 /// A commitment transaction was confirmed on chain, closing the channel. Most likely this
515 /// commitment transaction came from our counterparty, but it may also have come from
516 /// a copy of our own `ChannelMonitor`.
517 CommitmentTxConfirmed,
518 /// The funding transaction failed to confirm in a timely manner on an inbound channel.
520 /// Closure generated from processing an event, likely a HTLC forward/relay/reception.
522 /// A developer-readable error message which we generated.
523 err: crate::c_types::Str,
525 /// The peer disconnected prior to funding completing. In this case the spec mandates that we
526 /// forget the channel entirely - we can attempt again if the peer reconnects.
528 /// This includes cases where we restarted prior to funding completion, including prior to the
529 /// initial [`ChannelMonitor`] persistence completing.
531 /// In LDK versions prior to 0.0.107 this could also occur if we were unable to connect to the
532 /// peer because of mutual incompatibility between us and our channel counterparty.
534 /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
536 /// Closure generated from `ChannelManager::read` if the [`ChannelMonitor`] is newer than
537 /// the [`ChannelManager`] deserialized.
539 /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
540 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
541 OutdatedChannelManager,
542 /// The counterparty requested a cooperative close of a channel that had not been funded yet.
543 /// The channel has been immediately closed.
544 CounterpartyCoopClosedUnfundedChannel,
545 /// Another channel in the same funding batch closed before the funding transaction
546 /// was ready to be broadcast.
549 use lightning::events::ClosureReason as ClosureReasonImport;
550 pub(crate) type nativeClosureReason = ClosureReasonImport;
554 pub(crate) fn to_native(&self) -> nativeClosureReason {
556 ClosureReason::CounterpartyForceClosed {ref peer_msg, } => {
557 let mut peer_msg_nonref = Clone::clone(peer_msg);
558 nativeClosureReason::CounterpartyForceClosed {
559 peer_msg: *unsafe { Box::from_raw(peer_msg_nonref.take_inner()) },
562 ClosureReason::HolderForceClosed => nativeClosureReason::HolderForceClosed,
563 ClosureReason::CooperativeClosure => nativeClosureReason::CooperativeClosure,
564 ClosureReason::CommitmentTxConfirmed => nativeClosureReason::CommitmentTxConfirmed,
565 ClosureReason::FundingTimedOut => nativeClosureReason::FundingTimedOut,
566 ClosureReason::ProcessingError {ref err, } => {
567 let mut err_nonref = Clone::clone(err);
568 nativeClosureReason::ProcessingError {
569 err: err_nonref.into_string(),
572 ClosureReason::DisconnectedPeer => nativeClosureReason::DisconnectedPeer,
573 ClosureReason::OutdatedChannelManager => nativeClosureReason::OutdatedChannelManager,
574 ClosureReason::CounterpartyCoopClosedUnfundedChannel => nativeClosureReason::CounterpartyCoopClosedUnfundedChannel,
575 ClosureReason::FundingBatchClosure => nativeClosureReason::FundingBatchClosure,
579 pub(crate) fn into_native(self) -> nativeClosureReason {
581 ClosureReason::CounterpartyForceClosed {mut peer_msg, } => {
582 nativeClosureReason::CounterpartyForceClosed {
583 peer_msg: *unsafe { Box::from_raw(peer_msg.take_inner()) },
586 ClosureReason::HolderForceClosed => nativeClosureReason::HolderForceClosed,
587 ClosureReason::CooperativeClosure => nativeClosureReason::CooperativeClosure,
588 ClosureReason::CommitmentTxConfirmed => nativeClosureReason::CommitmentTxConfirmed,
589 ClosureReason::FundingTimedOut => nativeClosureReason::FundingTimedOut,
590 ClosureReason::ProcessingError {mut err, } => {
591 nativeClosureReason::ProcessingError {
592 err: err.into_string(),
595 ClosureReason::DisconnectedPeer => nativeClosureReason::DisconnectedPeer,
596 ClosureReason::OutdatedChannelManager => nativeClosureReason::OutdatedChannelManager,
597 ClosureReason::CounterpartyCoopClosedUnfundedChannel => nativeClosureReason::CounterpartyCoopClosedUnfundedChannel,
598 ClosureReason::FundingBatchClosure => nativeClosureReason::FundingBatchClosure,
602 pub(crate) fn from_native(native: &nativeClosureReason) -> Self {
604 nativeClosureReason::CounterpartyForceClosed {ref peer_msg, } => {
605 let mut peer_msg_nonref = Clone::clone(peer_msg);
606 ClosureReason::CounterpartyForceClosed {
607 peer_msg: crate::lightning::util::string::UntrustedString { inner: ObjOps::heap_alloc(peer_msg_nonref), is_owned: true },
610 nativeClosureReason::HolderForceClosed => ClosureReason::HolderForceClosed,
611 nativeClosureReason::CooperativeClosure => ClosureReason::CooperativeClosure,
612 nativeClosureReason::CommitmentTxConfirmed => ClosureReason::CommitmentTxConfirmed,
613 nativeClosureReason::FundingTimedOut => ClosureReason::FundingTimedOut,
614 nativeClosureReason::ProcessingError {ref err, } => {
615 let mut err_nonref = Clone::clone(err);
616 ClosureReason::ProcessingError {
617 err: err_nonref.into(),
620 nativeClosureReason::DisconnectedPeer => ClosureReason::DisconnectedPeer,
621 nativeClosureReason::OutdatedChannelManager => ClosureReason::OutdatedChannelManager,
622 nativeClosureReason::CounterpartyCoopClosedUnfundedChannel => ClosureReason::CounterpartyCoopClosedUnfundedChannel,
623 nativeClosureReason::FundingBatchClosure => ClosureReason::FundingBatchClosure,
627 pub(crate) fn native_into(native: nativeClosureReason) -> Self {
629 nativeClosureReason::CounterpartyForceClosed {mut peer_msg, } => {
630 ClosureReason::CounterpartyForceClosed {
631 peer_msg: crate::lightning::util::string::UntrustedString { inner: ObjOps::heap_alloc(peer_msg), is_owned: true },
634 nativeClosureReason::HolderForceClosed => ClosureReason::HolderForceClosed,
635 nativeClosureReason::CooperativeClosure => ClosureReason::CooperativeClosure,
636 nativeClosureReason::CommitmentTxConfirmed => ClosureReason::CommitmentTxConfirmed,
637 nativeClosureReason::FundingTimedOut => ClosureReason::FundingTimedOut,
638 nativeClosureReason::ProcessingError {mut err, } => {
639 ClosureReason::ProcessingError {
643 nativeClosureReason::DisconnectedPeer => ClosureReason::DisconnectedPeer,
644 nativeClosureReason::OutdatedChannelManager => ClosureReason::OutdatedChannelManager,
645 nativeClosureReason::CounterpartyCoopClosedUnfundedChannel => ClosureReason::CounterpartyCoopClosedUnfundedChannel,
646 nativeClosureReason::FundingBatchClosure => ClosureReason::FundingBatchClosure,
650 /// Frees any resources used by the ClosureReason
652 pub extern "C" fn ClosureReason_free(this_ptr: ClosureReason) { }
653 /// Creates a copy of the ClosureReason
655 pub extern "C" fn ClosureReason_clone(orig: &ClosureReason) -> ClosureReason {
659 /// Utility method to constructs a new CounterpartyForceClosed-variant ClosureReason
660 pub extern "C" fn ClosureReason_counterparty_force_closed(peer_msg: crate::lightning::util::string::UntrustedString) -> ClosureReason {
661 ClosureReason::CounterpartyForceClosed {
666 /// Utility method to constructs a new HolderForceClosed-variant ClosureReason
667 pub extern "C" fn ClosureReason_holder_force_closed() -> ClosureReason {
668 ClosureReason::HolderForceClosed}
670 /// Utility method to constructs a new CooperativeClosure-variant ClosureReason
671 pub extern "C" fn ClosureReason_cooperative_closure() -> ClosureReason {
672 ClosureReason::CooperativeClosure}
674 /// Utility method to constructs a new CommitmentTxConfirmed-variant ClosureReason
675 pub extern "C" fn ClosureReason_commitment_tx_confirmed() -> ClosureReason {
676 ClosureReason::CommitmentTxConfirmed}
678 /// Utility method to constructs a new FundingTimedOut-variant ClosureReason
679 pub extern "C" fn ClosureReason_funding_timed_out() -> ClosureReason {
680 ClosureReason::FundingTimedOut}
682 /// Utility method to constructs a new ProcessingError-variant ClosureReason
683 pub extern "C" fn ClosureReason_processing_error(err: crate::c_types::Str) -> ClosureReason {
684 ClosureReason::ProcessingError {
689 /// Utility method to constructs a new DisconnectedPeer-variant ClosureReason
690 pub extern "C" fn ClosureReason_disconnected_peer() -> ClosureReason {
691 ClosureReason::DisconnectedPeer}
693 /// Utility method to constructs a new OutdatedChannelManager-variant ClosureReason
694 pub extern "C" fn ClosureReason_outdated_channel_manager() -> ClosureReason {
695 ClosureReason::OutdatedChannelManager}
697 /// Utility method to constructs a new CounterpartyCoopClosedUnfundedChannel-variant ClosureReason
698 pub extern "C" fn ClosureReason_counterparty_coop_closed_unfunded_channel() -> ClosureReason {
699 ClosureReason::CounterpartyCoopClosedUnfundedChannel}
701 /// Utility method to constructs a new FundingBatchClosure-variant ClosureReason
702 pub extern "C" fn ClosureReason_funding_batch_closure() -> ClosureReason {
703 ClosureReason::FundingBatchClosure}
704 /// Checks if two ClosureReasons contain equal inner contents.
705 /// This ignores pointers and is_owned flags and looks at the values in fields.
707 pub extern "C" fn ClosureReason_eq(a: &ClosureReason, b: &ClosureReason) -> bool {
708 if &a.to_native() == &b.to_native() { true } else { false }
711 /// Serialize the ClosureReason object into a byte array which can be read by ClosureReason_read
712 pub extern "C" fn ClosureReason_write(obj: &crate::lightning::events::ClosureReason) -> crate::c_types::derived::CVec_u8Z {
713 crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
716 /// Read a ClosureReason from a byte array, created by ClosureReason_write
717 pub extern "C" fn ClosureReason_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_ClosureReasonZDecodeErrorZ {
718 let res: Result<Option<lightning::events::ClosureReason>, lightning::ln::msgs::DecodeError> = crate::c_types::maybe_deserialize_obj(ser);
719 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_res_0 = if o.is_none() { crate::c_types::derived::COption_ClosureReasonZ::None } else { crate::c_types::derived::COption_ClosureReasonZ::Some( { crate::lightning::events::ClosureReason::native_into(o.unwrap()) }) }; local_res_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
722 /// Intended destination of a failed HTLC as indicated in [`Event::HTLCHandlingFailed`].
726 pub enum HTLCDestination {
727 /// We tried forwarding to a channel but failed to do so. An example of such an instance is when
728 /// there is insufficient capacity in our outbound channel.
730 /// The `node_id` of the next node. For backwards compatibility, this field is
731 /// marked as optional, versions prior to 0.0.110 may not always be able to provide
732 /// counterparty node information.
734 /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
735 node_id: crate::c_types::PublicKey,
736 /// The outgoing `channel_id` between us and the next node.
737 channel_id: crate::c_types::ThirtyTwoBytes,
739 /// Scenario where we are unsure of the next node to forward the HTLC to.
741 /// Short channel id we are requesting to forward an HTLC to.
742 requested_forward_scid: u64,
744 /// We couldn't forward to the outgoing scid. An example would be attempting to send a duplicate
747 /// Short channel id we are requesting to forward an HTLC to.
748 requested_forward_scid: u64,
750 /// Failure scenario where an HTLC may have been forwarded to be intended for us,
751 /// but is invalid for some reason, so we reject it.
753 /// Some of the reasons may include:
755 /// * Excess HTLCs for a payment that we have already fully received, over-paying for the
757 /// * The counterparty node modified the HTLC in transit,
758 /// * A probing attack where an intermediary node is trying to detect if we are the ultimate
759 /// recipient for a payment.
761 /// The payment hash of the payment we attempted to process.
762 payment_hash: crate::c_types::ThirtyTwoBytes,
765 use lightning::events::HTLCDestination as HTLCDestinationImport;
766 pub(crate) type nativeHTLCDestination = HTLCDestinationImport;
768 impl HTLCDestination {
770 pub(crate) fn to_native(&self) -> nativeHTLCDestination {
772 HTLCDestination::NextHopChannel {ref node_id, ref channel_id, } => {
773 let mut node_id_nonref = Clone::clone(node_id);
774 let mut local_node_id_nonref = if node_id_nonref.is_null() { None } else { Some( { node_id_nonref.into_rust() }) };
775 let mut channel_id_nonref = Clone::clone(channel_id);
776 nativeHTLCDestination::NextHopChannel {
777 node_id: local_node_id_nonref,
778 channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data),
781 HTLCDestination::UnknownNextHop {ref requested_forward_scid, } => {
782 let mut requested_forward_scid_nonref = Clone::clone(requested_forward_scid);
783 nativeHTLCDestination::UnknownNextHop {
784 requested_forward_scid: requested_forward_scid_nonref,
787 HTLCDestination::InvalidForward {ref requested_forward_scid, } => {
788 let mut requested_forward_scid_nonref = Clone::clone(requested_forward_scid);
789 nativeHTLCDestination::InvalidForward {
790 requested_forward_scid: requested_forward_scid_nonref,
793 HTLCDestination::FailedPayment {ref payment_hash, } => {
794 let mut payment_hash_nonref = Clone::clone(payment_hash);
795 nativeHTLCDestination::FailedPayment {
796 payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
802 pub(crate) fn into_native(self) -> nativeHTLCDestination {
804 HTLCDestination::NextHopChannel {mut node_id, mut channel_id, } => {
805 let mut local_node_id = if node_id.is_null() { None } else { Some( { node_id.into_rust() }) };
806 nativeHTLCDestination::NextHopChannel {
807 node_id: local_node_id,
808 channel_id: ::lightning::ln::ChannelId(channel_id.data),
811 HTLCDestination::UnknownNextHop {mut requested_forward_scid, } => {
812 nativeHTLCDestination::UnknownNextHop {
813 requested_forward_scid: requested_forward_scid,
816 HTLCDestination::InvalidForward {mut requested_forward_scid, } => {
817 nativeHTLCDestination::InvalidForward {
818 requested_forward_scid: requested_forward_scid,
821 HTLCDestination::FailedPayment {mut payment_hash, } => {
822 nativeHTLCDestination::FailedPayment {
823 payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
829 pub(crate) fn from_native(native: &nativeHTLCDestination) -> Self {
831 nativeHTLCDestination::NextHopChannel {ref node_id, ref channel_id, } => {
832 let mut node_id_nonref = Clone::clone(node_id);
833 let mut local_node_id_nonref = if node_id_nonref.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(node_id_nonref.unwrap())) } };
834 let mut channel_id_nonref = Clone::clone(channel_id);
835 HTLCDestination::NextHopChannel {
836 node_id: local_node_id_nonref,
837 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 },
840 nativeHTLCDestination::UnknownNextHop {ref requested_forward_scid, } => {
841 let mut requested_forward_scid_nonref = Clone::clone(requested_forward_scid);
842 HTLCDestination::UnknownNextHop {
843 requested_forward_scid: requested_forward_scid_nonref,
846 nativeHTLCDestination::InvalidForward {ref requested_forward_scid, } => {
847 let mut requested_forward_scid_nonref = Clone::clone(requested_forward_scid);
848 HTLCDestination::InvalidForward {
849 requested_forward_scid: requested_forward_scid_nonref,
852 nativeHTLCDestination::FailedPayment {ref payment_hash, } => {
853 let mut payment_hash_nonref = Clone::clone(payment_hash);
854 HTLCDestination::FailedPayment {
855 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
861 pub(crate) fn native_into(native: nativeHTLCDestination) -> Self {
863 nativeHTLCDestination::NextHopChannel {mut node_id, mut channel_id, } => {
864 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())) } };
865 HTLCDestination::NextHopChannel {
866 node_id: local_node_id,
867 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 },
870 nativeHTLCDestination::UnknownNextHop {mut requested_forward_scid, } => {
871 HTLCDestination::UnknownNextHop {
872 requested_forward_scid: requested_forward_scid,
875 nativeHTLCDestination::InvalidForward {mut requested_forward_scid, } => {
876 HTLCDestination::InvalidForward {
877 requested_forward_scid: requested_forward_scid,
880 nativeHTLCDestination::FailedPayment {mut payment_hash, } => {
881 HTLCDestination::FailedPayment {
882 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
888 /// Frees any resources used by the HTLCDestination
890 pub extern "C" fn HTLCDestination_free(this_ptr: HTLCDestination) { }
891 /// Creates a copy of the HTLCDestination
893 pub extern "C" fn HTLCDestination_clone(orig: &HTLCDestination) -> HTLCDestination {
897 /// Utility method to constructs a new NextHopChannel-variant HTLCDestination
898 pub extern "C" fn HTLCDestination_next_hop_channel(node_id: crate::c_types::PublicKey, channel_id: crate::c_types::ThirtyTwoBytes) -> HTLCDestination {
899 HTLCDestination::NextHopChannel {
905 /// Utility method to constructs a new UnknownNextHop-variant HTLCDestination
906 pub extern "C" fn HTLCDestination_unknown_next_hop(requested_forward_scid: u64) -> HTLCDestination {
907 HTLCDestination::UnknownNextHop {
908 requested_forward_scid,
912 /// Utility method to constructs a new InvalidForward-variant HTLCDestination
913 pub extern "C" fn HTLCDestination_invalid_forward(requested_forward_scid: u64) -> HTLCDestination {
914 HTLCDestination::InvalidForward {
915 requested_forward_scid,
919 /// Utility method to constructs a new FailedPayment-variant HTLCDestination
920 pub extern "C" fn HTLCDestination_failed_payment(payment_hash: crate::c_types::ThirtyTwoBytes) -> HTLCDestination {
921 HTLCDestination::FailedPayment {
925 /// Checks if two HTLCDestinations contain equal inner contents.
926 /// This ignores pointers and is_owned flags and looks at the values in fields.
928 pub extern "C" fn HTLCDestination_eq(a: &HTLCDestination, b: &HTLCDestination) -> bool {
929 if &a.to_native() == &b.to_native() { true } else { false }
932 /// Serialize the HTLCDestination object into a byte array which can be read by HTLCDestination_read
933 pub extern "C" fn HTLCDestination_write(obj: &crate::lightning::events::HTLCDestination) -> crate::c_types::derived::CVec_u8Z {
934 crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
937 /// Read a HTLCDestination from a byte array, created by HTLCDestination_write
938 pub extern "C" fn HTLCDestination_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_HTLCDestinationZDecodeErrorZ {
939 let res: Result<Option<lightning::events::HTLCDestination>, lightning::ln::msgs::DecodeError> = crate::c_types::maybe_deserialize_obj(ser);
940 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_res_0 = if o.is_none() { crate::c_types::derived::COption_HTLCDestinationZ::None } else { crate::c_types::derived::COption_HTLCDestinationZ::Some( { crate::lightning::events::HTLCDestination::native_into(o.unwrap()) }) }; local_res_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
943 /// The reason the payment failed. Used in [`Event::PaymentFailed`].
947 pub enum PaymentFailureReason {
948 /// The intended recipient rejected our payment.
950 /// The user chose to abandon this payment by calling [`ChannelManager::abandon_payment`].
952 /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
954 /// We exhausted all of our retry attempts while trying to send the payment, or we
955 /// exhausted the [`Retry::Timeout`] if the user set one. If at any point a retry
956 /// attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
957 /// have come before this.
959 /// [`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout
961 /// The payment expired while retrying, based on the provided
962 /// [`PaymentParameters::expiry_time`].
964 /// [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
966 /// We failed to find a route while retrying the payment.
968 /// This error should generally never happen. This likely means that there is a problem with
972 use lightning::events::PaymentFailureReason as PaymentFailureReasonImport;
973 pub(crate) type nativePaymentFailureReason = PaymentFailureReasonImport;
975 impl PaymentFailureReason {
977 pub(crate) fn to_native(&self) -> nativePaymentFailureReason {
979 PaymentFailureReason::RecipientRejected => nativePaymentFailureReason::RecipientRejected,
980 PaymentFailureReason::UserAbandoned => nativePaymentFailureReason::UserAbandoned,
981 PaymentFailureReason::RetriesExhausted => nativePaymentFailureReason::RetriesExhausted,
982 PaymentFailureReason::PaymentExpired => nativePaymentFailureReason::PaymentExpired,
983 PaymentFailureReason::RouteNotFound => nativePaymentFailureReason::RouteNotFound,
984 PaymentFailureReason::UnexpectedError => nativePaymentFailureReason::UnexpectedError,
988 pub(crate) fn into_native(self) -> nativePaymentFailureReason {
990 PaymentFailureReason::RecipientRejected => nativePaymentFailureReason::RecipientRejected,
991 PaymentFailureReason::UserAbandoned => nativePaymentFailureReason::UserAbandoned,
992 PaymentFailureReason::RetriesExhausted => nativePaymentFailureReason::RetriesExhausted,
993 PaymentFailureReason::PaymentExpired => nativePaymentFailureReason::PaymentExpired,
994 PaymentFailureReason::RouteNotFound => nativePaymentFailureReason::RouteNotFound,
995 PaymentFailureReason::UnexpectedError => nativePaymentFailureReason::UnexpectedError,
999 pub(crate) fn from_native(native: &nativePaymentFailureReason) -> Self {
1001 nativePaymentFailureReason::RecipientRejected => PaymentFailureReason::RecipientRejected,
1002 nativePaymentFailureReason::UserAbandoned => PaymentFailureReason::UserAbandoned,
1003 nativePaymentFailureReason::RetriesExhausted => PaymentFailureReason::RetriesExhausted,
1004 nativePaymentFailureReason::PaymentExpired => PaymentFailureReason::PaymentExpired,
1005 nativePaymentFailureReason::RouteNotFound => PaymentFailureReason::RouteNotFound,
1006 nativePaymentFailureReason::UnexpectedError => PaymentFailureReason::UnexpectedError,
1010 pub(crate) fn native_into(native: nativePaymentFailureReason) -> Self {
1012 nativePaymentFailureReason::RecipientRejected => PaymentFailureReason::RecipientRejected,
1013 nativePaymentFailureReason::UserAbandoned => PaymentFailureReason::UserAbandoned,
1014 nativePaymentFailureReason::RetriesExhausted => PaymentFailureReason::RetriesExhausted,
1015 nativePaymentFailureReason::PaymentExpired => PaymentFailureReason::PaymentExpired,
1016 nativePaymentFailureReason::RouteNotFound => PaymentFailureReason::RouteNotFound,
1017 nativePaymentFailureReason::UnexpectedError => PaymentFailureReason::UnexpectedError,
1021 /// Creates a copy of the PaymentFailureReason
1023 pub extern "C" fn PaymentFailureReason_clone(orig: &PaymentFailureReason) -> PaymentFailureReason {
1027 /// Utility method to constructs a new RecipientRejected-variant PaymentFailureReason
1028 pub extern "C" fn PaymentFailureReason_recipient_rejected() -> PaymentFailureReason {
1029 PaymentFailureReason::RecipientRejected}
1031 /// Utility method to constructs a new UserAbandoned-variant PaymentFailureReason
1032 pub extern "C" fn PaymentFailureReason_user_abandoned() -> PaymentFailureReason {
1033 PaymentFailureReason::UserAbandoned}
1035 /// Utility method to constructs a new RetriesExhausted-variant PaymentFailureReason
1036 pub extern "C" fn PaymentFailureReason_retries_exhausted() -> PaymentFailureReason {
1037 PaymentFailureReason::RetriesExhausted}
1039 /// Utility method to constructs a new PaymentExpired-variant PaymentFailureReason
1040 pub extern "C" fn PaymentFailureReason_payment_expired() -> PaymentFailureReason {
1041 PaymentFailureReason::PaymentExpired}
1043 /// Utility method to constructs a new RouteNotFound-variant PaymentFailureReason
1044 pub extern "C" fn PaymentFailureReason_route_not_found() -> PaymentFailureReason {
1045 PaymentFailureReason::RouteNotFound}
1047 /// Utility method to constructs a new UnexpectedError-variant PaymentFailureReason
1048 pub extern "C" fn PaymentFailureReason_unexpected_error() -> PaymentFailureReason {
1049 PaymentFailureReason::UnexpectedError}
1050 /// Checks if two PaymentFailureReasons contain equal inner contents.
1051 /// This ignores pointers and is_owned flags and looks at the values in fields.
1053 pub extern "C" fn PaymentFailureReason_eq(a: &PaymentFailureReason, b: &PaymentFailureReason) -> bool {
1054 if &a.to_native() == &b.to_native() { true } else { false }
1057 /// Serialize the PaymentFailureReason object into a byte array which can be read by PaymentFailureReason_read
1058 pub extern "C" fn PaymentFailureReason_write(obj: &crate::lightning::events::PaymentFailureReason) -> crate::c_types::derived::CVec_u8Z {
1059 crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
1062 /// Read a PaymentFailureReason from a byte array, created by PaymentFailureReason_write
1063 pub extern "C" fn PaymentFailureReason_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PaymentFailureReasonDecodeErrorZ {
1064 let res: Result<lightning::events::PaymentFailureReason, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
1065 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::events::PaymentFailureReason::native_into(o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
1068 /// An Event which you should probably take some action in response to.
1070 /// Note that while Writeable and Readable are implemented for Event, you probably shouldn't use
1071 /// them directly as they don't round-trip exactly (for example FundingGenerationReady is never
1072 /// written as it makes no sense to respond to it after reconnecting to peers).
1077 /// Used to indicate that the client should generate a funding transaction with the given
1078 /// parameters and then call [`ChannelManager::funding_transaction_generated`].
1079 /// Generated in [`ChannelManager`] message handling.
1080 /// Note that *all inputs* in the funding transaction must spend SegWit outputs or your
1081 /// counterparty can steal your funds!
1083 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1084 /// [`ChannelManager::funding_transaction_generated`]: crate::ln::channelmanager::ChannelManager::funding_transaction_generated
1085 FundingGenerationReady {
1086 /// The random channel_id we picked which you'll need to pass into
1087 /// [`ChannelManager::funding_transaction_generated`].
1089 /// [`ChannelManager::funding_transaction_generated`]: crate::ln::channelmanager::ChannelManager::funding_transaction_generated
1090 temporary_channel_id: crate::c_types::ThirtyTwoBytes,
1091 /// The counterparty's node_id, which you'll need to pass back into
1092 /// [`ChannelManager::funding_transaction_generated`].
1094 /// [`ChannelManager::funding_transaction_generated`]: crate::ln::channelmanager::ChannelManager::funding_transaction_generated
1095 counterparty_node_id: crate::c_types::PublicKey,
1096 /// The value, in satoshis, that the output should have.
1097 channel_value_satoshis: u64,
1098 /// The script which should be used in the transaction output.
1099 output_script: crate::c_types::derived::CVec_u8Z,
1100 /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound
1101 /// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if
1102 /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
1103 /// `user_channel_id` will be randomized for an inbound channel. This may be zero for objects
1104 /// serialized with LDK versions prior to 0.0.113.
1106 /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel
1107 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
1108 /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
1109 user_channel_id: crate::c_types::U128,
1111 /// Indicates that we've been offered a payment and it needs to be claimed via calling
1112 /// [`ChannelManager::claim_funds`] with the preimage given in [`PaymentPurpose`].
1114 /// Note that if the preimage is not known, you should call
1115 /// [`ChannelManager::fail_htlc_backwards`] or [`ChannelManager::fail_htlc_backwards_with_reason`]
1116 /// to free up resources for this HTLC and avoid network congestion.
1118 /// If [`Event::PaymentClaimable::onion_fields`] is `Some`, and includes custom TLVs with even type
1119 /// numbers, you should use [`ChannelManager::fail_htlc_backwards_with_reason`] with
1120 /// [`FailureCode::InvalidOnionPayload`] if you fail to understand and handle the contents, or
1121 /// [`ChannelManager::claim_funds_with_known_custom_tlvs`] upon successful handling.
1122 /// If you don't intend to check for custom TLVs, you can simply use
1123 /// [`ChannelManager::claim_funds`], which will automatically fail back even custom TLVs.
1125 /// If you fail to call [`ChannelManager::claim_funds`],
1126 /// [`ChannelManager::claim_funds_with_known_custom_tlvs`],
1127 /// [`ChannelManager::fail_htlc_backwards`], or
1128 /// [`ChannelManager::fail_htlc_backwards_with_reason`] within the HTLC's timeout, the HTLC will
1129 /// be automatically failed.
1132 /// LDK will not stop an inbound payment from being paid multiple times, so multiple
1133 /// `PaymentClaimable` events may be generated for the same payment. In such a case it is
1134 /// polite (and required in the lightning specification) to fail the payment the second time
1135 /// and give the sender their money back rather than accepting double payment.
1138 /// This event used to be called `PaymentReceived` in LDK versions 0.0.112 and earlier.
1140 /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
1141 /// [`ChannelManager::claim_funds_with_known_custom_tlvs`]: crate::ln::channelmanager::ChannelManager::claim_funds_with_known_custom_tlvs
1142 /// [`FailureCode::InvalidOnionPayload`]: crate::ln::channelmanager::FailureCode::InvalidOnionPayload
1143 /// [`ChannelManager::fail_htlc_backwards`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards
1144 /// [`ChannelManager::fail_htlc_backwards_with_reason`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards_with_reason
1146 /// The node that will receive the payment after it has been claimed.
1147 /// This is useful to identify payments received via [phantom nodes].
1148 /// This field will always be filled in when the event was generated by LDK versions
1149 /// 0.0.113 and above.
1151 /// [phantom nodes]: crate::sign::PhantomKeysManager
1153 /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
1154 receiver_node_id: crate::c_types::PublicKey,
1155 /// The hash for which the preimage should be handed to the ChannelManager. Note that LDK will
1156 /// not stop you from registering duplicate payment hashes for inbound payments.
1157 payment_hash: crate::c_types::ThirtyTwoBytes,
1158 /// The fields in the onion which were received with each HTLC. Only fields which were
1159 /// identical in each HTLC involved in the payment will be included here.
1161 /// Payments received on LDK versions prior to 0.0.115 will have this field unset.
1163 /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
1164 onion_fields: crate::lightning::ln::outbound_payment::RecipientOnionFields,
1165 /// The value, in thousandths of a satoshi, that this payment is claimable for. May be greater
1166 /// than the invoice amount.
1168 /// May be less than the invoice amount if [`ChannelConfig::accept_underpaying_htlcs`] is set
1169 /// and the previous hop took an extra fee.
1172 /// If [`ChannelConfig::accept_underpaying_htlcs`] is set and you claim without verifying this
1173 /// field, you may lose money!
1175 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
1177 /// The value, in thousands of a satoshi, that was skimmed off of this payment as an extra fee
1178 /// taken by our channel counterparty.
1180 /// Will always be 0 unless [`ChannelConfig::accept_underpaying_htlcs`] is set.
1182 /// [`ChannelConfig::accept_underpaying_htlcs`]: crate::util::config::ChannelConfig::accept_underpaying_htlcs
1183 counterparty_skimmed_fee_msat: u64,
1184 /// Information for claiming this received payment, based on whether the purpose of the
1185 /// payment is to pay an invoice or to send a spontaneous payment.
1186 purpose: crate::lightning::events::PaymentPurpose,
1187 /// The `channel_id` indicating over which channel we received the payment.
1188 via_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ,
1189 /// The `user_channel_id` indicating over which channel we received the payment.
1190 via_user_channel_id: crate::c_types::derived::COption_U128Z,
1191 /// The block height at which this payment will be failed back and will no longer be
1192 /// eligible for claiming.
1194 /// Prior to this height, a call to [`ChannelManager::claim_funds`] is guaranteed to
1195 /// succeed, however you should wait for [`Event::PaymentClaimed`] to be sure.
1197 /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
1198 claim_deadline: crate::c_types::derived::COption_u32Z,
1200 /// Indicates a payment has been claimed and we've received money!
1202 /// This most likely occurs when [`ChannelManager::claim_funds`] has been called in response
1203 /// to an [`Event::PaymentClaimable`]. However, if we previously crashed during a
1204 /// [`ChannelManager::claim_funds`] call you may see this event without a corresponding
1205 /// [`Event::PaymentClaimable`] event.
1208 /// LDK will not stop an inbound payment from being paid multiple times, so multiple
1209 /// `PaymentClaimable` events may be generated for the same payment. If you then call
1210 /// [`ChannelManager::claim_funds`] twice for the same [`Event::PaymentClaimable`] you may get
1211 /// multiple `PaymentClaimed` events.
1213 /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
1215 /// The node that received the payment.
1216 /// This is useful to identify payments which were received via [phantom nodes].
1217 /// This field will always be filled in when the event was generated by LDK versions
1218 /// 0.0.113 and above.
1220 /// [phantom nodes]: crate::sign::PhantomKeysManager
1222 /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
1223 receiver_node_id: crate::c_types::PublicKey,
1224 /// The payment hash of the claimed payment. Note that LDK will not stop you from
1225 /// registering duplicate payment hashes for inbound payments.
1226 payment_hash: crate::c_types::ThirtyTwoBytes,
1227 /// The value, in thousandths of a satoshi, that this payment is for. May be greater than the
1230 /// The purpose of the claimed payment, i.e. whether the payment was for an invoice or a
1231 /// spontaneous payment.
1232 purpose: crate::lightning::events::PaymentPurpose,
1233 /// The HTLCs that comprise the claimed payment. This will be empty for events serialized prior
1234 /// to LDK version 0.0.117.
1235 htlcs: crate::c_types::derived::CVec_ClaimedHTLCZ,
1236 /// The sender-intended sum total of all the MPP parts. This will be `None` for events
1237 /// serialized prior to LDK version 0.0.117.
1238 sender_intended_total_msat: crate::c_types::derived::COption_u64Z,
1240 /// Indicates an outbound payment we made succeeded (i.e. it made it all the way to its target
1241 /// and we got back the payment preimage for it).
1243 /// Note for MPP payments: in rare cases, this event may be preceded by a `PaymentPathFailed`
1244 /// event. In this situation, you SHOULD treat this payment as having succeeded.
1246 /// The `payment_id` passed to [`ChannelManager::send_payment`].
1248 /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
1249 payment_id: crate::c_types::derived::COption_ThirtyTwoBytesZ,
1250 /// The preimage to the hash given to ChannelManager::send_payment.
1251 /// Note that this serves as a payment receipt, if you wish to have such a thing, you must
1252 /// store it somehow!
1253 payment_preimage: crate::c_types::ThirtyTwoBytes,
1254 /// The hash that was given to [`ChannelManager::send_payment`].
1256 /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
1257 payment_hash: crate::c_types::ThirtyTwoBytes,
1258 /// The total fee which was spent at intermediate hops in this payment, across all paths.
1260 /// Note that, like [`Route::get_total_fees`] this does *not* include any potential
1261 /// overpayment to the recipient node.
1263 /// If the recipient or an intermediate node misbehaves and gives us free money, this may
1264 /// overstate the amount paid, though this is unlikely.
1266 /// [`Route::get_total_fees`]: crate::routing::router::Route::get_total_fees
1267 fee_paid_msat: crate::c_types::derived::COption_u64Z,
1269 /// Indicates an outbound payment failed. Individual [`Event::PaymentPathFailed`] events
1270 /// provide failure information for each path attempt in the payment, including retries.
1272 /// This event is provided once there are no further pending HTLCs for the payment and the
1273 /// payment is no longer retryable, due either to the [`Retry`] provided or
1274 /// [`ChannelManager::abandon_payment`] having been called for the corresponding payment.
1276 /// In exceedingly rare cases, it is possible that an [`Event::PaymentFailed`] is generated for
1277 /// a payment after an [`Event::PaymentSent`] event for this same payment has already been
1278 /// received and processed. In this case, the [`Event::PaymentFailed`] event MUST be ignored,
1279 /// and the payment MUST be treated as having succeeded.
1281 /// [`Retry`]: crate::ln::channelmanager::Retry
1282 /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
1284 /// The `payment_id` passed to [`ChannelManager::send_payment`].
1286 /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
1287 payment_id: crate::c_types::ThirtyTwoBytes,
1288 /// The hash that was given to [`ChannelManager::send_payment`].
1290 /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
1291 payment_hash: crate::c_types::ThirtyTwoBytes,
1292 /// The reason the payment failed. This is only `None` for events generated or serialized
1293 /// by versions prior to 0.0.115.
1294 reason: crate::c_types::derived::COption_PaymentFailureReasonZ,
1296 /// Indicates that a path for an outbound payment was successful.
1298 /// Always generated after [`Event::PaymentSent`] and thus useful for scoring channels. See
1299 /// [`Event::PaymentSent`] for obtaining the payment preimage.
1300 PaymentPathSuccessful {
1301 /// The `payment_id` passed to [`ChannelManager::send_payment`].
1303 /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
1304 payment_id: crate::c_types::ThirtyTwoBytes,
1305 /// The hash that was given to [`ChannelManager::send_payment`].
1307 /// This will be `Some` for all payments which completed on LDK 0.0.104 or later.
1309 /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
1310 payment_hash: crate::c_types::derived::COption_ThirtyTwoBytesZ,
1311 /// The payment path that was successful.
1313 /// May contain a closed channel if the HTLC sent along the path was fulfilled on chain.
1314 path: crate::lightning::routing::router::Path,
1316 /// Indicates an outbound HTLC we sent failed, likely due to an intermediary node being unable to
1317 /// handle the HTLC.
1319 /// Note that this does *not* indicate that all paths for an MPP payment have failed, see
1320 /// [`Event::PaymentFailed`].
1322 /// See [`ChannelManager::abandon_payment`] for giving up on this payment before its retries have
1325 /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
1327 /// The `payment_id` passed to [`ChannelManager::send_payment`].
1329 /// This will be `Some` for all payment paths which failed on LDK 0.0.103 or later.
1331 /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
1332 /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
1333 payment_id: crate::c_types::derived::COption_ThirtyTwoBytesZ,
1334 /// The hash that was given to [`ChannelManager::send_payment`].
1336 /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment
1337 payment_hash: crate::c_types::ThirtyTwoBytes,
1338 /// Indicates the payment was rejected for some reason by the recipient. This implies that
1339 /// the payment has failed, not just the route in question. If this is not set, the payment may
1340 /// be retried via a different route.
1341 payment_failed_permanently: bool,
1342 /// Extra error details based on the failure type. May contain an update that needs to be
1343 /// applied to the [`NetworkGraph`].
1345 /// [`NetworkGraph`]: crate::routing::gossip::NetworkGraph
1346 failure: crate::lightning::events::PathFailure,
1347 /// The payment path that failed.
1348 path: crate::lightning::routing::router::Path,
1349 /// The channel responsible for the failed payment path.
1351 /// Note that for route hints or for the first hop in a path this may be an SCID alias and
1352 /// may not refer to a channel in the public network graph. These aliases may also collide
1353 /// with channels in the public network graph.
1355 /// If this is `Some`, then the corresponding channel should be avoided when the payment is
1356 /// retried. May be `None` for older [`Event`] serializations.
1357 short_channel_id: crate::c_types::derived::COption_u64Z,
1359 /// Indicates that a probe payment we sent returned successful, i.e., only failed at the destination.
1361 /// The id returned by [`ChannelManager::send_probe`].
1363 /// [`ChannelManager::send_probe`]: crate::ln::channelmanager::ChannelManager::send_probe
1364 payment_id: crate::c_types::ThirtyTwoBytes,
1365 /// The hash generated by [`ChannelManager::send_probe`].
1367 /// [`ChannelManager::send_probe`]: crate::ln::channelmanager::ChannelManager::send_probe
1368 payment_hash: crate::c_types::ThirtyTwoBytes,
1369 /// The payment path that was successful.
1370 path: crate::lightning::routing::router::Path,
1372 /// Indicates that a probe payment we sent failed at an intermediary node on the path.
1374 /// The id returned by [`ChannelManager::send_probe`].
1376 /// [`ChannelManager::send_probe`]: crate::ln::channelmanager::ChannelManager::send_probe
1377 payment_id: crate::c_types::ThirtyTwoBytes,
1378 /// The hash generated by [`ChannelManager::send_probe`].
1380 /// [`ChannelManager::send_probe`]: crate::ln::channelmanager::ChannelManager::send_probe
1381 payment_hash: crate::c_types::ThirtyTwoBytes,
1382 /// The payment path that failed.
1383 path: crate::lightning::routing::router::Path,
1384 /// The channel responsible for the failed probe.
1386 /// Note that for route hints or for the first hop in a path this may be an SCID alias and
1387 /// may not refer to a channel in the public network graph. These aliases may also collide
1388 /// with channels in the public network graph.
1389 short_channel_id: crate::c_types::derived::COption_u64Z,
1391 /// Used to indicate that [`ChannelManager::process_pending_htlc_forwards`] should be called at
1392 /// a time in the future.
1394 /// [`ChannelManager::process_pending_htlc_forwards`]: crate::ln::channelmanager::ChannelManager::process_pending_htlc_forwards
1395 PendingHTLCsForwardable {
1396 /// The minimum amount of time that should be waited prior to calling
1397 /// process_pending_htlc_forwards. To increase the effort required to correlate payments,
1398 /// you should wait a random amount of time in roughly the range (now + time_forwardable,
1399 /// now + 5*time_forwardable).
1400 time_forwardable: u64,
1402 /// Used to indicate that we've intercepted an HTLC forward. This event will only be generated if
1403 /// you've encoded an intercept scid in the receiver's invoice route hints using
1404 /// [`ChannelManager::get_intercept_scid`] and have set [`UserConfig::accept_intercept_htlcs`].
1406 /// [`ChannelManager::forward_intercepted_htlc`] or
1407 /// [`ChannelManager::fail_intercepted_htlc`] MUST be called in response to this event. See
1408 /// their docs for more information.
1410 /// [`ChannelManager::get_intercept_scid`]: crate::ln::channelmanager::ChannelManager::get_intercept_scid
1411 /// [`UserConfig::accept_intercept_htlcs`]: crate::util::config::UserConfig::accept_intercept_htlcs
1412 /// [`ChannelManager::forward_intercepted_htlc`]: crate::ln::channelmanager::ChannelManager::forward_intercepted_htlc
1413 /// [`ChannelManager::fail_intercepted_htlc`]: crate::ln::channelmanager::ChannelManager::fail_intercepted_htlc
1415 /// An id to help LDK identify which HTLC is being forwarded or failed.
1416 intercept_id: crate::c_types::ThirtyTwoBytes,
1417 /// The fake scid that was programmed as the next hop's scid, generated using
1418 /// [`ChannelManager::get_intercept_scid`].
1420 /// [`ChannelManager::get_intercept_scid`]: crate::ln::channelmanager::ChannelManager::get_intercept_scid
1421 requested_next_hop_scid: u64,
1422 /// The payment hash used for this HTLC.
1423 payment_hash: crate::c_types::ThirtyTwoBytes,
1424 /// How many msats were received on the inbound edge of this HTLC.
1425 inbound_amount_msat: u64,
1426 /// How many msats the payer intended to route to the next node. Depending on the reason you are
1427 /// intercepting this payment, you might take a fee by forwarding less than this amount.
1428 /// Forwarding less than this amount may break compatibility with LDK versions prior to 0.0.116.
1430 /// Note that LDK will NOT check that expected fees were factored into this value. You MUST
1431 /// check that whatever fee you want has been included here or subtract it as required. Further,
1432 /// LDK will not stop you from forwarding more than you received.
1433 expected_outbound_amount_msat: u64,
1435 /// Used to indicate that an output which you should know how to spend was confirmed on chain
1436 /// and is now spendable.
1437 /// Such an output will *not* ever be spent by rust-lightning, and are not at risk of your
1438 /// counterparty spending them due to some kind of timeout. Thus, you need to store them
1439 /// somewhere and spend them when you create on-chain transactions.
1441 /// The outputs which you should store as spendable by you.
1442 outputs: crate::c_types::derived::CVec_SpendableOutputDescriptorZ,
1443 /// The `channel_id` indicating which channel the spendable outputs belong to.
1445 /// This will always be `Some` for events generated by LDK versions 0.0.117 and above.
1446 channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ,
1448 /// This event is generated when a payment has been successfully forwarded through us and a
1449 /// forwarding fee earned.
1451 /// The incoming channel between the previous node and us. This is only `None` for events
1452 /// generated or serialized by versions prior to 0.0.107.
1453 prev_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ,
1454 /// The outgoing channel between the next node and us. This is only `None` for events
1455 /// generated or serialized by versions prior to 0.0.107.
1456 next_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ,
1457 /// The fee, in milli-satoshis, which was earned as a result of the payment.
1459 /// Note that if we force-closed the channel over which we forwarded an HTLC while the HTLC
1460 /// was pending, the amount the next hop claimed will have been rounded down to the nearest
1461 /// whole satoshi. Thus, the fee calculated here may be higher than expected as we still
1462 /// claimed the full value in millisatoshis from the source. In this case,
1463 /// `claim_from_onchain_tx` will be set.
1465 /// If the channel which sent us the payment has been force-closed, we will claim the funds
1466 /// via an on-chain transaction. In that case we do not yet know the on-chain transaction
1467 /// fees which we will spend and will instead set this to `None`. It is possible duplicate
1468 /// `PaymentForwarded` events are generated for the same payment iff `fee_earned_msat` is
1470 fee_earned_msat: crate::c_types::derived::COption_u64Z,
1471 /// If this is `true`, the forwarded HTLC was claimed by our counterparty via an on-chain
1473 claim_from_onchain_tx: bool,
1474 /// The final amount forwarded, in milli-satoshis, after the fee is deducted.
1476 /// The caveat described above the `fee_earned_msat` field applies here as well.
1477 outbound_amount_forwarded_msat: crate::c_types::derived::COption_u64Z,
1479 /// Used to indicate that a channel with the given `channel_id` is being opened and pending
1480 /// confirmation on-chain.
1482 /// This event is emitted when the funding transaction has been signed and is broadcast to the
1483 /// network. For 0conf channels it will be immediately followed by the corresponding
1484 /// [`Event::ChannelReady`] event.
1486 /// The `channel_id` of the channel that is pending confirmation.
1487 channel_id: crate::c_types::ThirtyTwoBytes,
1488 /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound
1489 /// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if
1490 /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
1491 /// `user_channel_id` will be randomized for an inbound channel.
1493 /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel
1494 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
1495 /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
1496 user_channel_id: crate::c_types::U128,
1497 /// The `temporary_channel_id` this channel used to be known by during channel establishment.
1499 /// Will be `None` for channels created prior to LDK version 0.0.115.
1500 former_temporary_channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ,
1501 /// The `node_id` of the channel counterparty.
1502 counterparty_node_id: crate::c_types::PublicKey,
1503 /// The outpoint of the channel's funding transaction.
1504 funding_txo: crate::lightning::chain::transaction::OutPoint,
1506 /// Used to indicate that a channel with the given `channel_id` is ready to
1507 /// be used. This event is emitted either when the funding transaction has been confirmed
1508 /// on-chain, or, in case of a 0conf channel, when both parties have confirmed the channel
1511 /// The `channel_id` of the channel that is ready.
1512 channel_id: crate::c_types::ThirtyTwoBytes,
1513 /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound
1514 /// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if
1515 /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
1516 /// `user_channel_id` will be randomized for an inbound channel.
1518 /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel
1519 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
1520 /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
1521 user_channel_id: crate::c_types::U128,
1522 /// The `node_id` of the channel counterparty.
1523 counterparty_node_id: crate::c_types::PublicKey,
1524 /// The features that this channel will operate with.
1525 channel_type: crate::lightning::ln::features::ChannelTypeFeatures,
1527 /// Used to indicate that a previously opened channel with the given `channel_id` is in the
1528 /// process of closure.
1530 /// Note that this event is only triggered for accepted channels: if the
1531 /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true and the channel is
1532 /// rejected, no `ChannelClosed` event will be sent.
1534 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
1535 /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
1537 /// The `channel_id` of the channel which has been closed. Note that on-chain transactions
1538 /// resolving the channel are likely still awaiting confirmation.
1539 channel_id: crate::c_types::ThirtyTwoBytes,
1540 /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound
1541 /// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if
1542 /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
1543 /// `user_channel_id` will be randomized for inbound channels.
1544 /// This may be zero for inbound channels serialized prior to 0.0.113 and will always be
1545 /// zero for objects serialized with LDK versions prior to 0.0.102.
1547 /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel
1548 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
1549 /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
1550 user_channel_id: crate::c_types::U128,
1551 /// The reason the channel was closed.
1552 reason: crate::lightning::events::ClosureReason,
1553 /// Counterparty in the closed channel.
1555 /// This field will be `None` for objects serialized prior to LDK 0.0.117.
1557 /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
1558 counterparty_node_id: crate::c_types::PublicKey,
1559 /// Channel capacity of the closing channel (sats).
1561 /// This field will be `None` for objects serialized prior to LDK 0.0.117.
1562 channel_capacity_sats: crate::c_types::derived::COption_u64Z,
1564 /// Used to indicate to the user that they can abandon the funding transaction and recycle the
1565 /// inputs for another purpose.
1567 /// This event is not guaranteed to be generated for channels that are closed due to a restart.
1569 /// The channel_id of the channel which has been closed.
1570 channel_id: crate::c_types::ThirtyTwoBytes,
1571 /// The full transaction received from the user
1572 transaction: crate::c_types::Transaction,
1574 /// Indicates a request to open a new channel by a peer.
1576 /// To accept the request, call [`ChannelManager::accept_inbound_channel`]. To reject the request,
1577 /// call [`ChannelManager::force_close_without_broadcasting_txn`]. Note that a ['ChannelClosed`]
1578 /// event will _not_ be triggered if the channel is rejected.
1580 /// The event is only triggered when a new open channel request is received and the
1581 /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true.
1583 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
1584 /// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
1585 /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
1586 OpenChannelRequest {
1587 /// The temporary channel ID of the channel requested to be opened.
1589 /// When responding to the request, the `temporary_channel_id` should be passed
1590 /// back to the ChannelManager through [`ChannelManager::accept_inbound_channel`] to accept,
1591 /// or through [`ChannelManager::force_close_without_broadcasting_txn`] to reject.
1593 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
1594 /// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
1595 temporary_channel_id: crate::c_types::ThirtyTwoBytes,
1596 /// The node_id of the counterparty requesting to open the channel.
1598 /// When responding to the request, the `counterparty_node_id` should be passed
1599 /// back to the `ChannelManager` through [`ChannelManager::accept_inbound_channel`] to
1600 /// accept the request, or through [`ChannelManager::force_close_without_broadcasting_txn`] to reject the
1603 /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
1604 /// [`ChannelManager::force_close_without_broadcasting_txn`]: crate::ln::channelmanager::ChannelManager::force_close_without_broadcasting_txn
1605 counterparty_node_id: crate::c_types::PublicKey,
1606 /// The channel value of the requested channel.
1607 funding_satoshis: u64,
1608 /// Our starting balance in the channel if the request is accepted, in milli-satoshi.
1610 /// The features that this channel will operate with. If you reject the channel, a
1611 /// well-behaved counterparty may automatically re-attempt the channel with a new set of
1614 /// Note that if [`ChannelTypeFeatures::supports_scid_privacy`] returns true on this type,
1615 /// the resulting [`ChannelManager`] will not be readable by versions of LDK prior to
1618 /// Furthermore, note that if [`ChannelTypeFeatures::supports_zero_conf`] returns true on this type,
1619 /// the resulting [`ChannelManager`] will not be readable by versions of LDK prior to
1620 /// 0.0.107. Channels setting this type also need to get manually accepted via
1621 /// [`crate::ln::channelmanager::ChannelManager::accept_inbound_channel_from_trusted_peer_0conf`],
1622 /// or will be rejected otherwise.
1624 /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1625 channel_type: crate::lightning::ln::features::ChannelTypeFeatures,
1627 /// Indicates that the HTLC was accepted, but could not be processed when or after attempting to
1630 /// Some scenarios where this event may be sent include:
1631 /// * Insufficient capacity in the outbound channel
1632 /// * While waiting to forward the HTLC, the channel it is meant to be forwarded through closes
1633 /// * When an unknown SCID is requested for forwarding a payment.
1634 /// * Expected MPP amount has already been reached
1635 /// * The HTLC has timed out
1637 /// This event, however, does not get generated if an HTLC fails to meet the forwarding
1638 /// requirements (i.e. insufficient fees paid, or a CLTV that is too soon).
1639 HTLCHandlingFailed {
1640 /// The channel over which the HTLC was received.
1641 prev_channel_id: crate::c_types::ThirtyTwoBytes,
1642 /// Destination of the HTLC that failed to be processed.
1643 failed_next_destination: crate::lightning::events::HTLCDestination,
1645 /// Indicates that a transaction originating from LDK needs to have its fee bumped. This event
1646 /// requires confirmed external funds to be readily available to spend.
1648 /// LDK does not currently generate this event unless the
1649 /// [`ChannelHandshakeConfig::negotiate_anchors_zero_fee_htlc_tx`] config flag is set to true.
1650 /// It is limited to the scope of channels with anchor outputs.
1652 /// [`ChannelHandshakeConfig::negotiate_anchors_zero_fee_htlc_tx`]: crate::util::config::ChannelHandshakeConfig::negotiate_anchors_zero_fee_htlc_tx
1654 crate::lightning::events::bump_transaction::BumpTransactionEvent),
1656 use lightning::events::Event as EventImport;
1657 pub(crate) type nativeEvent = EventImport;
1661 pub(crate) fn to_native(&self) -> nativeEvent {
1663 Event::FundingGenerationReady {ref temporary_channel_id, ref counterparty_node_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => {
1664 let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id);
1665 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
1666 let mut channel_value_satoshis_nonref = Clone::clone(channel_value_satoshis);
1667 let mut output_script_nonref = Clone::clone(output_script);
1668 let mut user_channel_id_nonref = Clone::clone(user_channel_id);
1669 nativeEvent::FundingGenerationReady {
1670 temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_nonref.data),
1671 counterparty_node_id: counterparty_node_id_nonref.into_rust(),
1672 channel_value_satoshis: channel_value_satoshis_nonref,
1673 output_script: ::bitcoin::blockdata::script::Script::from(output_script_nonref.into_rust()),
1674 user_channel_id: user_channel_id_nonref.into(),
1677 Event::PaymentClaimable {ref receiver_node_id, ref payment_hash, ref onion_fields, ref amount_msat, ref counterparty_skimmed_fee_msat, ref purpose, ref via_channel_id, ref via_user_channel_id, ref claim_deadline, } => {
1678 let mut receiver_node_id_nonref = Clone::clone(receiver_node_id);
1679 let mut local_receiver_node_id_nonref = if receiver_node_id_nonref.is_null() { None } else { Some( { receiver_node_id_nonref.into_rust() }) };
1680 let mut payment_hash_nonref = Clone::clone(payment_hash);
1681 let mut onion_fields_nonref = Clone::clone(onion_fields);
1682 let mut local_onion_fields_nonref = if onion_fields_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(onion_fields_nonref.take_inner()) } }) };
1683 let mut amount_msat_nonref = Clone::clone(amount_msat);
1684 let mut counterparty_skimmed_fee_msat_nonref = Clone::clone(counterparty_skimmed_fee_msat);
1685 let mut purpose_nonref = Clone::clone(purpose);
1686 let mut via_channel_id_nonref = Clone::clone(via_channel_id);
1687 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) }})} };
1688 let mut via_user_channel_id_nonref = Clone::clone(via_user_channel_id);
1689 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() }})} };
1690 let mut claim_deadline_nonref = Clone::clone(claim_deadline);
1691 let mut local_claim_deadline_nonref = if claim_deadline_nonref.is_some() { Some( { claim_deadline_nonref.take() }) } else { None };
1692 nativeEvent::PaymentClaimable {
1693 receiver_node_id: local_receiver_node_id_nonref,
1694 payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
1695 onion_fields: local_onion_fields_nonref,
1696 amount_msat: amount_msat_nonref,
1697 counterparty_skimmed_fee_msat: counterparty_skimmed_fee_msat_nonref,
1698 purpose: purpose_nonref.into_native(),
1699 via_channel_id: local_via_channel_id_nonref,
1700 via_user_channel_id: local_via_user_channel_id_nonref,
1701 claim_deadline: local_claim_deadline_nonref,
1704 Event::PaymentClaimed {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, ref htlcs, ref sender_intended_total_msat, } => {
1705 let mut receiver_node_id_nonref = Clone::clone(receiver_node_id);
1706 let mut local_receiver_node_id_nonref = if receiver_node_id_nonref.is_null() { None } else { Some( { receiver_node_id_nonref.into_rust() }) };
1707 let mut payment_hash_nonref = Clone::clone(payment_hash);
1708 let mut amount_msat_nonref = Clone::clone(amount_msat);
1709 let mut purpose_nonref = Clone::clone(purpose);
1710 let mut htlcs_nonref = Clone::clone(htlcs);
1711 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()) } }); };
1712 let mut sender_intended_total_msat_nonref = Clone::clone(sender_intended_total_msat);
1713 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 };
1714 nativeEvent::PaymentClaimed {
1715 receiver_node_id: local_receiver_node_id_nonref,
1716 payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
1717 amount_msat: amount_msat_nonref,
1718 purpose: purpose_nonref.into_native(),
1719 htlcs: local_htlcs_nonref,
1720 sender_intended_total_msat: local_sender_intended_total_msat_nonref,
1723 Event::PaymentSent {ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat, } => {
1724 let mut payment_id_nonref = Clone::clone(payment_id);
1725 let mut local_payment_id_nonref = { /*payment_id_nonref*/ let payment_id_nonref_opt = payment_id_nonref; if payment_id_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::channelmanager::PaymentId({ payment_id_nonref_opt.take() }.data) }})} };
1726 let mut payment_preimage_nonref = Clone::clone(payment_preimage);
1727 let mut payment_hash_nonref = Clone::clone(payment_hash);
1728 let mut fee_paid_msat_nonref = Clone::clone(fee_paid_msat);
1729 let mut local_fee_paid_msat_nonref = if fee_paid_msat_nonref.is_some() { Some( { fee_paid_msat_nonref.take() }) } else { None };
1730 nativeEvent::PaymentSent {
1731 payment_id: local_payment_id_nonref,
1732 payment_preimage: ::lightning::ln::PaymentPreimage(payment_preimage_nonref.data),
1733 payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
1734 fee_paid_msat: local_fee_paid_msat_nonref,
1737 Event::PaymentFailed {ref payment_id, ref payment_hash, ref reason, } => {
1738 let mut payment_id_nonref = Clone::clone(payment_id);
1739 let mut payment_hash_nonref = Clone::clone(payment_hash);
1740 let mut reason_nonref = Clone::clone(reason);
1741 let mut local_reason_nonref = { /*reason_nonref*/ let reason_nonref_opt = reason_nonref; if reason_nonref_opt.is_none() { None } else { Some({ { { reason_nonref_opt.take() }.into_native() }})} };
1742 nativeEvent::PaymentFailed {
1743 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data),
1744 payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
1745 reason: local_reason_nonref,
1748 Event::PaymentPathSuccessful {ref payment_id, ref payment_hash, ref path, } => {
1749 let mut payment_id_nonref = Clone::clone(payment_id);
1750 let mut payment_hash_nonref = Clone::clone(payment_hash);
1751 let mut local_payment_hash_nonref = { /*payment_hash_nonref*/ let payment_hash_nonref_opt = payment_hash_nonref; if payment_hash_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::PaymentHash({ payment_hash_nonref_opt.take() }.data) }})} };
1752 let mut path_nonref = Clone::clone(path);
1753 nativeEvent::PaymentPathSuccessful {
1754 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data),
1755 payment_hash: local_payment_hash_nonref,
1756 path: *unsafe { Box::from_raw(path_nonref.take_inner()) },
1759 Event::PaymentPathFailed {ref payment_id, ref payment_hash, ref payment_failed_permanently, ref failure, ref path, ref short_channel_id, } => {
1760 let mut payment_id_nonref = Clone::clone(payment_id);
1761 let mut local_payment_id_nonref = { /*payment_id_nonref*/ let payment_id_nonref_opt = payment_id_nonref; if payment_id_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::channelmanager::PaymentId({ payment_id_nonref_opt.take() }.data) }})} };
1762 let mut payment_hash_nonref = Clone::clone(payment_hash);
1763 let mut payment_failed_permanently_nonref = Clone::clone(payment_failed_permanently);
1764 let mut failure_nonref = Clone::clone(failure);
1765 let mut path_nonref = Clone::clone(path);
1766 let mut short_channel_id_nonref = Clone::clone(short_channel_id);
1767 let mut local_short_channel_id_nonref = if short_channel_id_nonref.is_some() { Some( { short_channel_id_nonref.take() }) } else { None };
1768 nativeEvent::PaymentPathFailed {
1769 payment_id: local_payment_id_nonref,
1770 payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
1771 payment_failed_permanently: payment_failed_permanently_nonref,
1772 failure: failure_nonref.into_native(),
1773 path: *unsafe { Box::from_raw(path_nonref.take_inner()) },
1774 short_channel_id: local_short_channel_id_nonref,
1777 Event::ProbeSuccessful {ref payment_id, ref payment_hash, ref path, } => {
1778 let mut payment_id_nonref = Clone::clone(payment_id);
1779 let mut payment_hash_nonref = Clone::clone(payment_hash);
1780 let mut path_nonref = Clone::clone(path);
1781 nativeEvent::ProbeSuccessful {
1782 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data),
1783 payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
1784 path: *unsafe { Box::from_raw(path_nonref.take_inner()) },
1787 Event::ProbeFailed {ref payment_id, ref payment_hash, ref path, ref short_channel_id, } => {
1788 let mut payment_id_nonref = Clone::clone(payment_id);
1789 let mut payment_hash_nonref = Clone::clone(payment_hash);
1790 let mut path_nonref = Clone::clone(path);
1791 let mut short_channel_id_nonref = Clone::clone(short_channel_id);
1792 let mut local_short_channel_id_nonref = if short_channel_id_nonref.is_some() { Some( { short_channel_id_nonref.take() }) } else { None };
1793 nativeEvent::ProbeFailed {
1794 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data),
1795 payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
1796 path: *unsafe { Box::from_raw(path_nonref.take_inner()) },
1797 short_channel_id: local_short_channel_id_nonref,
1800 Event::PendingHTLCsForwardable {ref time_forwardable, } => {
1801 let mut time_forwardable_nonref = Clone::clone(time_forwardable);
1802 nativeEvent::PendingHTLCsForwardable {
1803 time_forwardable: core::time::Duration::from_secs(time_forwardable_nonref),
1806 Event::HTLCIntercepted {ref intercept_id, ref requested_next_hop_scid, ref payment_hash, ref inbound_amount_msat, ref expected_outbound_amount_msat, } => {
1807 let mut intercept_id_nonref = Clone::clone(intercept_id);
1808 let mut requested_next_hop_scid_nonref = Clone::clone(requested_next_hop_scid);
1809 let mut payment_hash_nonref = Clone::clone(payment_hash);
1810 let mut inbound_amount_msat_nonref = Clone::clone(inbound_amount_msat);
1811 let mut expected_outbound_amount_msat_nonref = Clone::clone(expected_outbound_amount_msat);
1812 nativeEvent::HTLCIntercepted {
1813 intercept_id: ::lightning::ln::channelmanager::InterceptId(intercept_id_nonref.data),
1814 requested_next_hop_scid: requested_next_hop_scid_nonref,
1815 payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data),
1816 inbound_amount_msat: inbound_amount_msat_nonref,
1817 expected_outbound_amount_msat: expected_outbound_amount_msat_nonref,
1820 Event::SpendableOutputs {ref outputs, ref channel_id, } => {
1821 let mut outputs_nonref = Clone::clone(outputs);
1822 let mut local_outputs_nonref = Vec::new(); for mut item in outputs_nonref.into_rust().drain(..) { local_outputs_nonref.push( { item.into_native() }); };
1823 let mut channel_id_nonref = Clone::clone(channel_id);
1824 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) }})} };
1825 nativeEvent::SpendableOutputs {
1826 outputs: local_outputs_nonref,
1827 channel_id: local_channel_id_nonref,
1830 Event::PaymentForwarded {ref prev_channel_id, ref next_channel_id, ref fee_earned_msat, ref claim_from_onchain_tx, ref outbound_amount_forwarded_msat, } => {
1831 let mut prev_channel_id_nonref = Clone::clone(prev_channel_id);
1832 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) }})} };
1833 let mut next_channel_id_nonref = Clone::clone(next_channel_id);
1834 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) }})} };
1835 let mut fee_earned_msat_nonref = Clone::clone(fee_earned_msat);
1836 let mut local_fee_earned_msat_nonref = if fee_earned_msat_nonref.is_some() { Some( { fee_earned_msat_nonref.take() }) } else { None };
1837 let mut claim_from_onchain_tx_nonref = Clone::clone(claim_from_onchain_tx);
1838 let mut outbound_amount_forwarded_msat_nonref = Clone::clone(outbound_amount_forwarded_msat);
1839 let mut local_outbound_amount_forwarded_msat_nonref = if outbound_amount_forwarded_msat_nonref.is_some() { Some( { outbound_amount_forwarded_msat_nonref.take() }) } else { None };
1840 nativeEvent::PaymentForwarded {
1841 prev_channel_id: local_prev_channel_id_nonref,
1842 next_channel_id: local_next_channel_id_nonref,
1843 fee_earned_msat: local_fee_earned_msat_nonref,
1844 claim_from_onchain_tx: claim_from_onchain_tx_nonref,
1845 outbound_amount_forwarded_msat: local_outbound_amount_forwarded_msat_nonref,
1848 Event::ChannelPending {ref channel_id, ref user_channel_id, ref former_temporary_channel_id, ref counterparty_node_id, ref funding_txo, } => {
1849 let mut channel_id_nonref = Clone::clone(channel_id);
1850 let mut user_channel_id_nonref = Clone::clone(user_channel_id);
1851 let mut former_temporary_channel_id_nonref = Clone::clone(former_temporary_channel_id);
1852 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) }})} };
1853 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
1854 let mut funding_txo_nonref = Clone::clone(funding_txo);
1855 nativeEvent::ChannelPending {
1856 channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data),
1857 user_channel_id: user_channel_id_nonref.into(),
1858 former_temporary_channel_id: local_former_temporary_channel_id_nonref,
1859 counterparty_node_id: counterparty_node_id_nonref.into_rust(),
1860 funding_txo: crate::c_types::C_to_bitcoin_outpoint(funding_txo_nonref),
1863 Event::ChannelReady {ref channel_id, ref user_channel_id, ref counterparty_node_id, ref channel_type, } => {
1864 let mut channel_id_nonref = Clone::clone(channel_id);
1865 let mut user_channel_id_nonref = Clone::clone(user_channel_id);
1866 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
1867 let mut channel_type_nonref = Clone::clone(channel_type);
1868 nativeEvent::ChannelReady {
1869 channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data),
1870 user_channel_id: user_channel_id_nonref.into(),
1871 counterparty_node_id: counterparty_node_id_nonref.into_rust(),
1872 channel_type: *unsafe { Box::from_raw(channel_type_nonref.take_inner()) },
1875 Event::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, ref counterparty_node_id, ref channel_capacity_sats, } => {
1876 let mut channel_id_nonref = Clone::clone(channel_id);
1877 let mut user_channel_id_nonref = Clone::clone(user_channel_id);
1878 let mut reason_nonref = Clone::clone(reason);
1879 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
1880 let mut local_counterparty_node_id_nonref = if counterparty_node_id_nonref.is_null() { None } else { Some( { counterparty_node_id_nonref.into_rust() }) };
1881 let mut channel_capacity_sats_nonref = Clone::clone(channel_capacity_sats);
1882 let mut local_channel_capacity_sats_nonref = if channel_capacity_sats_nonref.is_some() { Some( { channel_capacity_sats_nonref.take() }) } else { None };
1883 nativeEvent::ChannelClosed {
1884 channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data),
1885 user_channel_id: user_channel_id_nonref.into(),
1886 reason: reason_nonref.into_native(),
1887 counterparty_node_id: local_counterparty_node_id_nonref,
1888 channel_capacity_sats: local_channel_capacity_sats_nonref,
1891 Event::DiscardFunding {ref channel_id, ref transaction, } => {
1892 let mut channel_id_nonref = Clone::clone(channel_id);
1893 let mut transaction_nonref = Clone::clone(transaction);
1894 nativeEvent::DiscardFunding {
1895 channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data),
1896 transaction: transaction_nonref.into_bitcoin(),
1899 Event::OpenChannelRequest {ref temporary_channel_id, ref counterparty_node_id, ref funding_satoshis, ref push_msat, ref channel_type, } => {
1900 let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id);
1901 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
1902 let mut funding_satoshis_nonref = Clone::clone(funding_satoshis);
1903 let mut push_msat_nonref = Clone::clone(push_msat);
1904 let mut channel_type_nonref = Clone::clone(channel_type);
1905 nativeEvent::OpenChannelRequest {
1906 temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_nonref.data),
1907 counterparty_node_id: counterparty_node_id_nonref.into_rust(),
1908 funding_satoshis: funding_satoshis_nonref,
1909 push_msat: push_msat_nonref,
1910 channel_type: *unsafe { Box::from_raw(channel_type_nonref.take_inner()) },
1913 Event::HTLCHandlingFailed {ref prev_channel_id, ref failed_next_destination, } => {
1914 let mut prev_channel_id_nonref = Clone::clone(prev_channel_id);
1915 let mut failed_next_destination_nonref = Clone::clone(failed_next_destination);
1916 nativeEvent::HTLCHandlingFailed {
1917 prev_channel_id: ::lightning::ln::ChannelId(prev_channel_id_nonref.data),
1918 failed_next_destination: failed_next_destination_nonref.into_native(),
1921 Event::BumpTransaction (ref a, ) => {
1922 let mut a_nonref = Clone::clone(a);
1923 nativeEvent::BumpTransaction (
1924 a_nonref.into_native(),
1930 pub(crate) fn into_native(self) -> nativeEvent {
1932 Event::FundingGenerationReady {mut temporary_channel_id, mut counterparty_node_id, mut channel_value_satoshis, mut output_script, mut user_channel_id, } => {
1933 nativeEvent::FundingGenerationReady {
1934 temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id.data),
1935 counterparty_node_id: counterparty_node_id.into_rust(),
1936 channel_value_satoshis: channel_value_satoshis,
1937 output_script: ::bitcoin::blockdata::script::Script::from(output_script.into_rust()),
1938 user_channel_id: user_channel_id.into(),
1941 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, } => {
1942 let mut local_receiver_node_id = if receiver_node_id.is_null() { None } else { Some( { receiver_node_id.into_rust() }) };
1943 let mut local_onion_fields = if onion_fields.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(onion_fields.take_inner()) } }) };
1944 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) }})} };
1945 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() }})} };
1946 let mut local_claim_deadline = if claim_deadline.is_some() { Some( { claim_deadline.take() }) } else { None };
1947 nativeEvent::PaymentClaimable {
1948 receiver_node_id: local_receiver_node_id,
1949 payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
1950 onion_fields: local_onion_fields,
1951 amount_msat: amount_msat,
1952 counterparty_skimmed_fee_msat: counterparty_skimmed_fee_msat,
1953 purpose: purpose.into_native(),
1954 via_channel_id: local_via_channel_id,
1955 via_user_channel_id: local_via_user_channel_id,
1956 claim_deadline: local_claim_deadline,
1959 Event::PaymentClaimed {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, mut htlcs, mut sender_intended_total_msat, } => {
1960 let mut local_receiver_node_id = if receiver_node_id.is_null() { None } else { Some( { receiver_node_id.into_rust() }) };
1961 let mut local_htlcs = Vec::new(); for mut item in htlcs.into_rust().drain(..) { local_htlcs.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
1962 let mut local_sender_intended_total_msat = if sender_intended_total_msat.is_some() { Some( { sender_intended_total_msat.take() }) } else { None };
1963 nativeEvent::PaymentClaimed {
1964 receiver_node_id: local_receiver_node_id,
1965 payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
1966 amount_msat: amount_msat,
1967 purpose: purpose.into_native(),
1969 sender_intended_total_msat: local_sender_intended_total_msat,
1972 Event::PaymentSent {mut payment_id, mut payment_preimage, mut payment_hash, mut fee_paid_msat, } => {
1973 let mut local_payment_id = { /*payment_id*/ let payment_id_opt = payment_id; if payment_id_opt.is_none() { None } else { Some({ { ::lightning::ln::channelmanager::PaymentId({ payment_id_opt.take() }.data) }})} };
1974 let mut local_fee_paid_msat = if fee_paid_msat.is_some() { Some( { fee_paid_msat.take() }) } else { None };
1975 nativeEvent::PaymentSent {
1976 payment_id: local_payment_id,
1977 payment_preimage: ::lightning::ln::PaymentPreimage(payment_preimage.data),
1978 payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
1979 fee_paid_msat: local_fee_paid_msat,
1982 Event::PaymentFailed {mut payment_id, mut payment_hash, mut reason, } => {
1983 let mut local_reason = { /*reason*/ let reason_opt = reason; if reason_opt.is_none() { None } else { Some({ { { reason_opt.take() }.into_native() }})} };
1984 nativeEvent::PaymentFailed {
1985 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id.data),
1986 payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
1987 reason: local_reason,
1990 Event::PaymentPathSuccessful {mut payment_id, mut payment_hash, mut path, } => {
1991 let mut local_payment_hash = { /*payment_hash*/ let payment_hash_opt = payment_hash; if payment_hash_opt.is_none() { None } else { Some({ { ::lightning::ln::PaymentHash({ payment_hash_opt.take() }.data) }})} };
1992 nativeEvent::PaymentPathSuccessful {
1993 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id.data),
1994 payment_hash: local_payment_hash,
1995 path: *unsafe { Box::from_raw(path.take_inner()) },
1998 Event::PaymentPathFailed {mut payment_id, mut payment_hash, mut payment_failed_permanently, mut failure, mut path, mut short_channel_id, } => {
1999 let mut local_payment_id = { /*payment_id*/ let payment_id_opt = payment_id; if payment_id_opt.is_none() { None } else { Some({ { ::lightning::ln::channelmanager::PaymentId({ payment_id_opt.take() }.data) }})} };
2000 let mut local_short_channel_id = if short_channel_id.is_some() { Some( { short_channel_id.take() }) } else { None };
2001 nativeEvent::PaymentPathFailed {
2002 payment_id: local_payment_id,
2003 payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
2004 payment_failed_permanently: payment_failed_permanently,
2005 failure: failure.into_native(),
2006 path: *unsafe { Box::from_raw(path.take_inner()) },
2007 short_channel_id: local_short_channel_id,
2010 Event::ProbeSuccessful {mut payment_id, mut payment_hash, mut path, } => {
2011 nativeEvent::ProbeSuccessful {
2012 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id.data),
2013 payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
2014 path: *unsafe { Box::from_raw(path.take_inner()) },
2017 Event::ProbeFailed {mut payment_id, mut payment_hash, mut path, mut short_channel_id, } => {
2018 let mut local_short_channel_id = if short_channel_id.is_some() { Some( { short_channel_id.take() }) } else { None };
2019 nativeEvent::ProbeFailed {
2020 payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id.data),
2021 payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
2022 path: *unsafe { Box::from_raw(path.take_inner()) },
2023 short_channel_id: local_short_channel_id,
2026 Event::PendingHTLCsForwardable {mut time_forwardable, } => {
2027 nativeEvent::PendingHTLCsForwardable {
2028 time_forwardable: core::time::Duration::from_secs(time_forwardable),
2031 Event::HTLCIntercepted {mut intercept_id, mut requested_next_hop_scid, mut payment_hash, mut inbound_amount_msat, mut expected_outbound_amount_msat, } => {
2032 nativeEvent::HTLCIntercepted {
2033 intercept_id: ::lightning::ln::channelmanager::InterceptId(intercept_id.data),
2034 requested_next_hop_scid: requested_next_hop_scid,
2035 payment_hash: ::lightning::ln::PaymentHash(payment_hash.data),
2036 inbound_amount_msat: inbound_amount_msat,
2037 expected_outbound_amount_msat: expected_outbound_amount_msat,
2040 Event::SpendableOutputs {mut outputs, mut channel_id, } => {
2041 let mut local_outputs = Vec::new(); for mut item in outputs.into_rust().drain(..) { local_outputs.push( { item.into_native() }); };
2042 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) }})} };
2043 nativeEvent::SpendableOutputs {
2044 outputs: local_outputs,
2045 channel_id: local_channel_id,
2048 Event::PaymentForwarded {mut prev_channel_id, mut next_channel_id, mut fee_earned_msat, mut claim_from_onchain_tx, mut outbound_amount_forwarded_msat, } => {
2049 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) }})} };
2050 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) }})} };
2051 let mut local_fee_earned_msat = if fee_earned_msat.is_some() { Some( { fee_earned_msat.take() }) } else { None };
2052 let mut local_outbound_amount_forwarded_msat = if outbound_amount_forwarded_msat.is_some() { Some( { outbound_amount_forwarded_msat.take() }) } else { None };
2053 nativeEvent::PaymentForwarded {
2054 prev_channel_id: local_prev_channel_id,
2055 next_channel_id: local_next_channel_id,
2056 fee_earned_msat: local_fee_earned_msat,
2057 claim_from_onchain_tx: claim_from_onchain_tx,
2058 outbound_amount_forwarded_msat: local_outbound_amount_forwarded_msat,
2061 Event::ChannelPending {mut channel_id, mut user_channel_id, mut former_temporary_channel_id, mut counterparty_node_id, mut funding_txo, } => {
2062 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) }})} };
2063 nativeEvent::ChannelPending {
2064 channel_id: ::lightning::ln::ChannelId(channel_id.data),
2065 user_channel_id: user_channel_id.into(),
2066 former_temporary_channel_id: local_former_temporary_channel_id,
2067 counterparty_node_id: counterparty_node_id.into_rust(),
2068 funding_txo: crate::c_types::C_to_bitcoin_outpoint(funding_txo),
2071 Event::ChannelReady {mut channel_id, mut user_channel_id, mut counterparty_node_id, mut channel_type, } => {
2072 nativeEvent::ChannelReady {
2073 channel_id: ::lightning::ln::ChannelId(channel_id.data),
2074 user_channel_id: user_channel_id.into(),
2075 counterparty_node_id: counterparty_node_id.into_rust(),
2076 channel_type: *unsafe { Box::from_raw(channel_type.take_inner()) },
2079 Event::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, mut counterparty_node_id, mut channel_capacity_sats, } => {
2080 let mut local_counterparty_node_id = if counterparty_node_id.is_null() { None } else { Some( { counterparty_node_id.into_rust() }) };
2081 let mut local_channel_capacity_sats = if channel_capacity_sats.is_some() { Some( { channel_capacity_sats.take() }) } else { None };
2082 nativeEvent::ChannelClosed {
2083 channel_id: ::lightning::ln::ChannelId(channel_id.data),
2084 user_channel_id: user_channel_id.into(),
2085 reason: reason.into_native(),
2086 counterparty_node_id: local_counterparty_node_id,
2087 channel_capacity_sats: local_channel_capacity_sats,
2090 Event::DiscardFunding {mut channel_id, mut transaction, } => {
2091 nativeEvent::DiscardFunding {
2092 channel_id: ::lightning::ln::ChannelId(channel_id.data),
2093 transaction: transaction.into_bitcoin(),
2096 Event::OpenChannelRequest {mut temporary_channel_id, mut counterparty_node_id, mut funding_satoshis, mut push_msat, mut channel_type, } => {
2097 nativeEvent::OpenChannelRequest {
2098 temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id.data),
2099 counterparty_node_id: counterparty_node_id.into_rust(),
2100 funding_satoshis: funding_satoshis,
2101 push_msat: push_msat,
2102 channel_type: *unsafe { Box::from_raw(channel_type.take_inner()) },
2105 Event::HTLCHandlingFailed {mut prev_channel_id, mut failed_next_destination, } => {
2106 nativeEvent::HTLCHandlingFailed {
2107 prev_channel_id: ::lightning::ln::ChannelId(prev_channel_id.data),
2108 failed_next_destination: failed_next_destination.into_native(),
2111 Event::BumpTransaction (mut a, ) => {
2112 nativeEvent::BumpTransaction (
2119 pub(crate) fn from_native(native: &nativeEvent) -> Self {
2121 nativeEvent::FundingGenerationReady {ref temporary_channel_id, ref counterparty_node_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => {
2122 let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id);
2123 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
2124 let mut channel_value_satoshis_nonref = Clone::clone(channel_value_satoshis);
2125 let mut output_script_nonref = Clone::clone(output_script);
2126 let mut user_channel_id_nonref = Clone::clone(user_channel_id);
2127 Event::FundingGenerationReady {
2128 temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref.0 },
2129 counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref),
2130 channel_value_satoshis: channel_value_satoshis_nonref,
2131 output_script: output_script_nonref.into_bytes().into(),
2132 user_channel_id: user_channel_id_nonref.into(),
2135 nativeEvent::PaymentClaimable {ref receiver_node_id, ref payment_hash, ref onion_fields, ref amount_msat, ref counterparty_skimmed_fee_msat, ref purpose, ref via_channel_id, ref via_user_channel_id, ref claim_deadline, } => {
2136 let mut receiver_node_id_nonref = Clone::clone(receiver_node_id);
2137 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())) } };
2138 let mut payment_hash_nonref = Clone::clone(payment_hash);
2139 let mut onion_fields_nonref = Clone::clone(onion_fields);
2140 let mut local_onion_fields_nonref = crate::lightning::ln::outbound_payment::RecipientOnionFields { inner: if onion_fields_nonref.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((onion_fields_nonref.unwrap())) } }, is_owned: true };
2141 let mut amount_msat_nonref = Clone::clone(amount_msat);
2142 let mut counterparty_skimmed_fee_msat_nonref = Clone::clone(counterparty_skimmed_fee_msat);
2143 let mut purpose_nonref = Clone::clone(purpose);
2144 let mut via_channel_id_nonref = Clone::clone(via_channel_id);
2145 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 } }) };
2146 let mut via_user_channel_id_nonref = Clone::clone(via_user_channel_id);
2147 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() }) };
2148 let mut claim_deadline_nonref = Clone::clone(claim_deadline);
2149 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() }) };
2150 Event::PaymentClaimable {
2151 receiver_node_id: local_receiver_node_id_nonref,
2152 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
2153 onion_fields: local_onion_fields_nonref,
2154 amount_msat: amount_msat_nonref,
2155 counterparty_skimmed_fee_msat: counterparty_skimmed_fee_msat_nonref,
2156 purpose: crate::lightning::events::PaymentPurpose::native_into(purpose_nonref),
2157 via_channel_id: local_via_channel_id_nonref,
2158 via_user_channel_id: local_via_user_channel_id_nonref,
2159 claim_deadline: local_claim_deadline_nonref,
2162 nativeEvent::PaymentClaimed {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, ref htlcs, ref sender_intended_total_msat, } => {
2163 let mut receiver_node_id_nonref = Clone::clone(receiver_node_id);
2164 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())) } };
2165 let mut payment_hash_nonref = Clone::clone(payment_hash);
2166 let mut amount_msat_nonref = Clone::clone(amount_msat);
2167 let mut purpose_nonref = Clone::clone(purpose);
2168 let mut htlcs_nonref = Clone::clone(htlcs);
2169 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 } }); };
2170 let mut sender_intended_total_msat_nonref = Clone::clone(sender_intended_total_msat);
2171 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() }) };
2172 Event::PaymentClaimed {
2173 receiver_node_id: local_receiver_node_id_nonref,
2174 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
2175 amount_msat: amount_msat_nonref,
2176 purpose: crate::lightning::events::PaymentPurpose::native_into(purpose_nonref),
2177 htlcs: local_htlcs_nonref.into(),
2178 sender_intended_total_msat: local_sender_intended_total_msat_nonref,
2181 nativeEvent::PaymentSent {ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat, } => {
2182 let mut payment_id_nonref = Clone::clone(payment_id);
2183 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 } }) };
2184 let mut payment_preimage_nonref = Clone::clone(payment_preimage);
2185 let mut payment_hash_nonref = Clone::clone(payment_hash);
2186 let mut fee_paid_msat_nonref = Clone::clone(fee_paid_msat);
2187 let mut local_fee_paid_msat_nonref = if fee_paid_msat_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { fee_paid_msat_nonref.unwrap() }) };
2188 Event::PaymentSent {
2189 payment_id: local_payment_id_nonref,
2190 payment_preimage: crate::c_types::ThirtyTwoBytes { data: payment_preimage_nonref.0 },
2191 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
2192 fee_paid_msat: local_fee_paid_msat_nonref,
2195 nativeEvent::PaymentFailed {ref payment_id, ref payment_hash, ref reason, } => {
2196 let mut payment_id_nonref = Clone::clone(payment_id);
2197 let mut payment_hash_nonref = Clone::clone(payment_hash);
2198 let mut reason_nonref = Clone::clone(reason);
2199 let mut local_reason_nonref = if reason_nonref.is_none() { crate::c_types::derived::COption_PaymentFailureReasonZ::None } else { crate::c_types::derived::COption_PaymentFailureReasonZ::Some( { crate::lightning::events::PaymentFailureReason::native_into(reason_nonref.unwrap()) }) };
2200 Event::PaymentFailed {
2201 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 },
2202 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
2203 reason: local_reason_nonref,
2206 nativeEvent::PaymentPathSuccessful {ref payment_id, ref payment_hash, ref path, } => {
2207 let mut payment_id_nonref = Clone::clone(payment_id);
2208 let mut payment_hash_nonref = Clone::clone(payment_hash);
2209 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 } }) };
2210 let mut path_nonref = Clone::clone(path);
2211 Event::PaymentPathSuccessful {
2212 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 },
2213 payment_hash: local_payment_hash_nonref,
2214 path: crate::lightning::routing::router::Path { inner: ObjOps::heap_alloc(path_nonref), is_owned: true },
2217 nativeEvent::PaymentPathFailed {ref payment_id, ref payment_hash, ref payment_failed_permanently, ref failure, ref path, ref short_channel_id, } => {
2218 let mut payment_id_nonref = Clone::clone(payment_id);
2219 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 } }) };
2220 let mut payment_hash_nonref = Clone::clone(payment_hash);
2221 let mut payment_failed_permanently_nonref = Clone::clone(payment_failed_permanently);
2222 let mut failure_nonref = Clone::clone(failure);
2223 let mut path_nonref = Clone::clone(path);
2224 let mut short_channel_id_nonref = Clone::clone(short_channel_id);
2225 let mut local_short_channel_id_nonref = if short_channel_id_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { short_channel_id_nonref.unwrap() }) };
2226 Event::PaymentPathFailed {
2227 payment_id: local_payment_id_nonref,
2228 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
2229 payment_failed_permanently: payment_failed_permanently_nonref,
2230 failure: crate::lightning::events::PathFailure::native_into(failure_nonref),
2231 path: crate::lightning::routing::router::Path { inner: ObjOps::heap_alloc(path_nonref), is_owned: true },
2232 short_channel_id: local_short_channel_id_nonref,
2235 nativeEvent::ProbeSuccessful {ref payment_id, ref payment_hash, ref path, } => {
2236 let mut payment_id_nonref = Clone::clone(payment_id);
2237 let mut payment_hash_nonref = Clone::clone(payment_hash);
2238 let mut path_nonref = Clone::clone(path);
2239 Event::ProbeSuccessful {
2240 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 },
2241 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
2242 path: crate::lightning::routing::router::Path { inner: ObjOps::heap_alloc(path_nonref), is_owned: true },
2245 nativeEvent::ProbeFailed {ref payment_id, ref payment_hash, ref path, ref short_channel_id, } => {
2246 let mut payment_id_nonref = Clone::clone(payment_id);
2247 let mut payment_hash_nonref = Clone::clone(payment_hash);
2248 let mut path_nonref = Clone::clone(path);
2249 let mut short_channel_id_nonref = Clone::clone(short_channel_id);
2250 let mut local_short_channel_id_nonref = if short_channel_id_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { short_channel_id_nonref.unwrap() }) };
2251 Event::ProbeFailed {
2252 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 },
2253 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
2254 path: crate::lightning::routing::router::Path { inner: ObjOps::heap_alloc(path_nonref), is_owned: true },
2255 short_channel_id: local_short_channel_id_nonref,
2258 nativeEvent::PendingHTLCsForwardable {ref time_forwardable, } => {
2259 let mut time_forwardable_nonref = Clone::clone(time_forwardable);
2260 Event::PendingHTLCsForwardable {
2261 time_forwardable: time_forwardable_nonref.as_secs(),
2264 nativeEvent::HTLCIntercepted {ref intercept_id, ref requested_next_hop_scid, ref payment_hash, ref inbound_amount_msat, ref expected_outbound_amount_msat, } => {
2265 let mut intercept_id_nonref = Clone::clone(intercept_id);
2266 let mut requested_next_hop_scid_nonref = Clone::clone(requested_next_hop_scid);
2267 let mut payment_hash_nonref = Clone::clone(payment_hash);
2268 let mut inbound_amount_msat_nonref = Clone::clone(inbound_amount_msat);
2269 let mut expected_outbound_amount_msat_nonref = Clone::clone(expected_outbound_amount_msat);
2270 Event::HTLCIntercepted {
2271 intercept_id: crate::c_types::ThirtyTwoBytes { data: intercept_id_nonref.0 },
2272 requested_next_hop_scid: requested_next_hop_scid_nonref,
2273 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
2274 inbound_amount_msat: inbound_amount_msat_nonref,
2275 expected_outbound_amount_msat: expected_outbound_amount_msat_nonref,
2278 nativeEvent::SpendableOutputs {ref outputs, ref channel_id, } => {
2279 let mut outputs_nonref = Clone::clone(outputs);
2280 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) }); };
2281 let mut channel_id_nonref = Clone::clone(channel_id);
2282 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 } }) };
2283 Event::SpendableOutputs {
2284 outputs: local_outputs_nonref.into(),
2285 channel_id: local_channel_id_nonref,
2288 nativeEvent::PaymentForwarded {ref prev_channel_id, ref next_channel_id, ref fee_earned_msat, ref claim_from_onchain_tx, ref outbound_amount_forwarded_msat, } => {
2289 let mut prev_channel_id_nonref = Clone::clone(prev_channel_id);
2290 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 } }) };
2291 let mut next_channel_id_nonref = Clone::clone(next_channel_id);
2292 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 } }) };
2293 let mut fee_earned_msat_nonref = Clone::clone(fee_earned_msat);
2294 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() }) };
2295 let mut claim_from_onchain_tx_nonref = Clone::clone(claim_from_onchain_tx);
2296 let mut outbound_amount_forwarded_msat_nonref = Clone::clone(outbound_amount_forwarded_msat);
2297 let mut local_outbound_amount_forwarded_msat_nonref = if outbound_amount_forwarded_msat_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { outbound_amount_forwarded_msat_nonref.unwrap() }) };
2298 Event::PaymentForwarded {
2299 prev_channel_id: local_prev_channel_id_nonref,
2300 next_channel_id: local_next_channel_id_nonref,
2301 fee_earned_msat: local_fee_earned_msat_nonref,
2302 claim_from_onchain_tx: claim_from_onchain_tx_nonref,
2303 outbound_amount_forwarded_msat: local_outbound_amount_forwarded_msat_nonref,
2306 nativeEvent::ChannelPending {ref channel_id, ref user_channel_id, ref former_temporary_channel_id, ref counterparty_node_id, ref funding_txo, } => {
2307 let mut channel_id_nonref = Clone::clone(channel_id);
2308 let mut user_channel_id_nonref = Clone::clone(user_channel_id);
2309 let mut former_temporary_channel_id_nonref = Clone::clone(former_temporary_channel_id);
2310 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 } }) };
2311 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
2312 let mut funding_txo_nonref = Clone::clone(funding_txo);
2313 Event::ChannelPending {
2314 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 },
2315 user_channel_id: user_channel_id_nonref.into(),
2316 former_temporary_channel_id: local_former_temporary_channel_id_nonref,
2317 counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref),
2318 funding_txo: crate::c_types::bitcoin_to_C_outpoint(&funding_txo_nonref),
2321 nativeEvent::ChannelReady {ref channel_id, ref user_channel_id, ref counterparty_node_id, ref channel_type, } => {
2322 let mut channel_id_nonref = Clone::clone(channel_id);
2323 let mut user_channel_id_nonref = Clone::clone(user_channel_id);
2324 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
2325 let mut channel_type_nonref = Clone::clone(channel_type);
2326 Event::ChannelReady {
2327 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 },
2328 user_channel_id: user_channel_id_nonref.into(),
2329 counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref),
2330 channel_type: crate::lightning::ln::features::ChannelTypeFeatures { inner: ObjOps::heap_alloc(channel_type_nonref), is_owned: true },
2333 nativeEvent::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, ref counterparty_node_id, ref channel_capacity_sats, } => {
2334 let mut channel_id_nonref = Clone::clone(channel_id);
2335 let mut user_channel_id_nonref = Clone::clone(user_channel_id);
2336 let mut reason_nonref = Clone::clone(reason);
2337 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
2338 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())) } };
2339 let mut channel_capacity_sats_nonref = Clone::clone(channel_capacity_sats);
2340 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() }) };
2341 Event::ChannelClosed {
2342 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 },
2343 user_channel_id: user_channel_id_nonref.into(),
2344 reason: crate::lightning::events::ClosureReason::native_into(reason_nonref),
2345 counterparty_node_id: local_counterparty_node_id_nonref,
2346 channel_capacity_sats: local_channel_capacity_sats_nonref,
2349 nativeEvent::DiscardFunding {ref channel_id, ref transaction, } => {
2350 let mut channel_id_nonref = Clone::clone(channel_id);
2351 let mut transaction_nonref = Clone::clone(transaction);
2352 Event::DiscardFunding {
2353 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 },
2354 transaction: crate::c_types::Transaction::from_bitcoin(&transaction_nonref),
2357 nativeEvent::OpenChannelRequest {ref temporary_channel_id, ref counterparty_node_id, ref funding_satoshis, ref push_msat, ref channel_type, } => {
2358 let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id);
2359 let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id);
2360 let mut funding_satoshis_nonref = Clone::clone(funding_satoshis);
2361 let mut push_msat_nonref = Clone::clone(push_msat);
2362 let mut channel_type_nonref = Clone::clone(channel_type);
2363 Event::OpenChannelRequest {
2364 temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref.0 },
2365 counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref),
2366 funding_satoshis: funding_satoshis_nonref,
2367 push_msat: push_msat_nonref,
2368 channel_type: crate::lightning::ln::features::ChannelTypeFeatures { inner: ObjOps::heap_alloc(channel_type_nonref), is_owned: true },
2371 nativeEvent::HTLCHandlingFailed {ref prev_channel_id, ref failed_next_destination, } => {
2372 let mut prev_channel_id_nonref = Clone::clone(prev_channel_id);
2373 let mut failed_next_destination_nonref = Clone::clone(failed_next_destination);
2374 Event::HTLCHandlingFailed {
2375 prev_channel_id: crate::c_types::ThirtyTwoBytes { data: prev_channel_id_nonref.0 },
2376 failed_next_destination: crate::lightning::events::HTLCDestination::native_into(failed_next_destination_nonref),
2379 nativeEvent::BumpTransaction (ref a, ) => {
2380 let mut a_nonref = Clone::clone(a);
2381 Event::BumpTransaction (
2382 crate::lightning::events::bump_transaction::BumpTransactionEvent::native_into(a_nonref),
2388 pub(crate) fn native_into(native: nativeEvent) -> Self {
2390 nativeEvent::FundingGenerationReady {mut temporary_channel_id, mut counterparty_node_id, mut channel_value_satoshis, mut output_script, mut user_channel_id, } => {
2391 Event::FundingGenerationReady {
2392 temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id.0 },
2393 counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id),
2394 channel_value_satoshis: channel_value_satoshis,
2395 output_script: output_script.into_bytes().into(),
2396 user_channel_id: user_channel_id.into(),
2399 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, } => {
2400 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())) } };
2401 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 };
2402 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 } }) };
2403 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() }) };
2404 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() }) };
2405 Event::PaymentClaimable {
2406 receiver_node_id: local_receiver_node_id,
2407 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
2408 onion_fields: local_onion_fields,
2409 amount_msat: amount_msat,
2410 counterparty_skimmed_fee_msat: counterparty_skimmed_fee_msat,
2411 purpose: crate::lightning::events::PaymentPurpose::native_into(purpose),
2412 via_channel_id: local_via_channel_id,
2413 via_user_channel_id: local_via_user_channel_id,
2414 claim_deadline: local_claim_deadline,
2417 nativeEvent::PaymentClaimed {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, mut htlcs, mut sender_intended_total_msat, } => {
2418 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())) } };
2419 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 } }); };
2420 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() }) };
2421 Event::PaymentClaimed {
2422 receiver_node_id: local_receiver_node_id,
2423 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
2424 amount_msat: amount_msat,
2425 purpose: crate::lightning::events::PaymentPurpose::native_into(purpose),
2426 htlcs: local_htlcs.into(),
2427 sender_intended_total_msat: local_sender_intended_total_msat,
2430 nativeEvent::PaymentSent {mut payment_id, mut payment_preimage, mut payment_hash, mut fee_paid_msat, } => {
2431 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 } }) };
2432 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() }) };
2433 Event::PaymentSent {
2434 payment_id: local_payment_id,
2435 payment_preimage: crate::c_types::ThirtyTwoBytes { data: payment_preimage.0 },
2436 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
2437 fee_paid_msat: local_fee_paid_msat,
2440 nativeEvent::PaymentFailed {mut payment_id, mut payment_hash, mut reason, } => {
2441 let mut local_reason = if reason.is_none() { crate::c_types::derived::COption_PaymentFailureReasonZ::None } else { crate::c_types::derived::COption_PaymentFailureReasonZ::Some( { crate::lightning::events::PaymentFailureReason::native_into(reason.unwrap()) }) };
2442 Event::PaymentFailed {
2443 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id.0 },
2444 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
2445 reason: local_reason,
2448 nativeEvent::PaymentPathSuccessful {mut payment_id, mut payment_hash, mut path, } => {
2449 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 } }) };
2450 Event::PaymentPathSuccessful {
2451 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id.0 },
2452 payment_hash: local_payment_hash,
2453 path: crate::lightning::routing::router::Path { inner: ObjOps::heap_alloc(path), is_owned: true },
2456 nativeEvent::PaymentPathFailed {mut payment_id, mut payment_hash, mut payment_failed_permanently, mut failure, mut path, mut short_channel_id, } => {
2457 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 } }) };
2458 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() }) };
2459 Event::PaymentPathFailed {
2460 payment_id: local_payment_id,
2461 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
2462 payment_failed_permanently: payment_failed_permanently,
2463 failure: crate::lightning::events::PathFailure::native_into(failure),
2464 path: crate::lightning::routing::router::Path { inner: ObjOps::heap_alloc(path), is_owned: true },
2465 short_channel_id: local_short_channel_id,
2468 nativeEvent::ProbeSuccessful {mut payment_id, mut payment_hash, mut path, } => {
2469 Event::ProbeSuccessful {
2470 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id.0 },
2471 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
2472 path: crate::lightning::routing::router::Path { inner: ObjOps::heap_alloc(path), is_owned: true },
2475 nativeEvent::ProbeFailed {mut payment_id, mut payment_hash, mut path, mut short_channel_id, } => {
2476 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() }) };
2477 Event::ProbeFailed {
2478 payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id.0 },
2479 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
2480 path: crate::lightning::routing::router::Path { inner: ObjOps::heap_alloc(path), is_owned: true },
2481 short_channel_id: local_short_channel_id,
2484 nativeEvent::PendingHTLCsForwardable {mut time_forwardable, } => {
2485 Event::PendingHTLCsForwardable {
2486 time_forwardable: time_forwardable.as_secs(),
2489 nativeEvent::HTLCIntercepted {mut intercept_id, mut requested_next_hop_scid, mut payment_hash, mut inbound_amount_msat, mut expected_outbound_amount_msat, } => {
2490 Event::HTLCIntercepted {
2491 intercept_id: crate::c_types::ThirtyTwoBytes { data: intercept_id.0 },
2492 requested_next_hop_scid: requested_next_hop_scid,
2493 payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
2494 inbound_amount_msat: inbound_amount_msat,
2495 expected_outbound_amount_msat: expected_outbound_amount_msat,
2498 nativeEvent::SpendableOutputs {mut outputs, mut channel_id, } => {
2499 let mut local_outputs = Vec::new(); for mut item in outputs.drain(..) { local_outputs.push( { crate::lightning::sign::SpendableOutputDescriptor::native_into(item) }); };
2500 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 } }) };
2501 Event::SpendableOutputs {
2502 outputs: local_outputs.into(),
2503 channel_id: local_channel_id,
2506 nativeEvent::PaymentForwarded {mut prev_channel_id, mut next_channel_id, mut fee_earned_msat, mut claim_from_onchain_tx, mut outbound_amount_forwarded_msat, } => {
2507 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 } }) };
2508 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 } }) };
2509 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() }) };
2510 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() }) };
2511 Event::PaymentForwarded {
2512 prev_channel_id: local_prev_channel_id,
2513 next_channel_id: local_next_channel_id,
2514 fee_earned_msat: local_fee_earned_msat,
2515 claim_from_onchain_tx: claim_from_onchain_tx,
2516 outbound_amount_forwarded_msat: local_outbound_amount_forwarded_msat,
2519 nativeEvent::ChannelPending {mut channel_id, mut user_channel_id, mut former_temporary_channel_id, mut counterparty_node_id, mut funding_txo, } => {
2520 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 } }) };
2521 Event::ChannelPending {
2522 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 },
2523 user_channel_id: user_channel_id.into(),
2524 former_temporary_channel_id: local_former_temporary_channel_id,
2525 counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id),
2526 funding_txo: crate::c_types::bitcoin_to_C_outpoint(&funding_txo),
2529 nativeEvent::ChannelReady {mut channel_id, mut user_channel_id, mut counterparty_node_id, mut channel_type, } => {
2530 Event::ChannelReady {
2531 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 },
2532 user_channel_id: user_channel_id.into(),
2533 counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id),
2534 channel_type: crate::lightning::ln::features::ChannelTypeFeatures { inner: ObjOps::heap_alloc(channel_type), is_owned: true },
2537 nativeEvent::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, mut counterparty_node_id, mut channel_capacity_sats, } => {
2538 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())) } };
2539 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() }) };
2540 Event::ChannelClosed {
2541 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 },
2542 user_channel_id: user_channel_id.into(),
2543 reason: crate::lightning::events::ClosureReason::native_into(reason),
2544 counterparty_node_id: local_counterparty_node_id,
2545 channel_capacity_sats: local_channel_capacity_sats,
2548 nativeEvent::DiscardFunding {mut channel_id, mut transaction, } => {
2549 Event::DiscardFunding {
2550 channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 },
2551 transaction: crate::c_types::Transaction::from_bitcoin(&transaction),
2554 nativeEvent::OpenChannelRequest {mut temporary_channel_id, mut counterparty_node_id, mut funding_satoshis, mut push_msat, mut channel_type, } => {
2555 Event::OpenChannelRequest {
2556 temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id.0 },
2557 counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id),
2558 funding_satoshis: funding_satoshis,
2559 push_msat: push_msat,
2560 channel_type: crate::lightning::ln::features::ChannelTypeFeatures { inner: ObjOps::heap_alloc(channel_type), is_owned: true },
2563 nativeEvent::HTLCHandlingFailed {mut prev_channel_id, mut failed_next_destination, } => {
2564 Event::HTLCHandlingFailed {
2565 prev_channel_id: crate::c_types::ThirtyTwoBytes { data: prev_channel_id.0 },
2566 failed_next_destination: crate::lightning::events::HTLCDestination::native_into(failed_next_destination),
2569 nativeEvent::BumpTransaction (mut a, ) => {
2570 Event::BumpTransaction (
2571 crate::lightning::events::bump_transaction::BumpTransactionEvent::native_into(a),
2577 /// Frees any resources used by the Event
2579 pub extern "C" fn Event_free(this_ptr: Event) { }
2580 /// Creates a copy of the Event
2582 pub extern "C" fn Event_clone(orig: &Event) -> Event {
2586 /// Utility method to constructs a new FundingGenerationReady-variant Event
2587 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 {
2588 Event::FundingGenerationReady {
2589 temporary_channel_id,
2590 counterparty_node_id,
2591 channel_value_satoshis,
2597 /// Utility method to constructs a new PaymentClaimable-variant Event
2598 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 {
2599 Event::PaymentClaimable {
2604 counterparty_skimmed_fee_msat,
2607 via_user_channel_id,
2612 /// Utility method to constructs a new PaymentClaimed-variant Event
2613 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 {
2614 Event::PaymentClaimed {
2620 sender_intended_total_msat,
2624 /// Utility method to constructs a new PaymentSent-variant Event
2625 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 {
2626 Event::PaymentSent {
2634 /// Utility method to constructs a new PaymentFailed-variant Event
2635 pub extern "C" fn Event_payment_failed(payment_id: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::ThirtyTwoBytes, reason: crate::c_types::derived::COption_PaymentFailureReasonZ) -> Event {
2636 Event::PaymentFailed {
2643 /// Utility method to constructs a new PaymentPathSuccessful-variant Event
2644 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 {
2645 Event::PaymentPathSuccessful {
2652 /// Utility method to constructs a new PaymentPathFailed-variant Event
2653 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 {
2654 Event::PaymentPathFailed {
2657 payment_failed_permanently,
2664 /// Utility method to constructs a new ProbeSuccessful-variant Event
2665 pub extern "C" fn Event_probe_successful(payment_id: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::ThirtyTwoBytes, path: crate::lightning::routing::router::Path) -> Event {
2666 Event::ProbeSuccessful {
2673 /// Utility method to constructs a new ProbeFailed-variant Event
2674 pub extern "C" fn Event_probe_failed(payment_id: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::ThirtyTwoBytes, path: crate::lightning::routing::router::Path, short_channel_id: crate::c_types::derived::COption_u64Z) -> Event {
2675 Event::ProbeFailed {
2683 /// Utility method to constructs a new PendingHTLCsForwardable-variant Event
2684 pub extern "C" fn Event_pending_htlcs_forwardable(time_forwardable: u64) -> Event {
2685 Event::PendingHTLCsForwardable {
2690 /// Utility method to constructs a new HTLCIntercepted-variant Event
2691 pub extern "C" fn Event_htlcintercepted(intercept_id: crate::c_types::ThirtyTwoBytes, requested_next_hop_scid: u64, payment_hash: crate::c_types::ThirtyTwoBytes, inbound_amount_msat: u64, expected_outbound_amount_msat: u64) -> Event {
2692 Event::HTLCIntercepted {
2694 requested_next_hop_scid,
2696 inbound_amount_msat,
2697 expected_outbound_amount_msat,
2701 /// Utility method to constructs a new SpendableOutputs-variant Event
2702 pub extern "C" fn Event_spendable_outputs(outputs: crate::c_types::derived::CVec_SpendableOutputDescriptorZ, channel_id: crate::c_types::derived::COption_ThirtyTwoBytesZ) -> Event {
2703 Event::SpendableOutputs {
2709 /// Utility method to constructs a new PaymentForwarded-variant Event
2710 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 {
2711 Event::PaymentForwarded {
2715 claim_from_onchain_tx,
2716 outbound_amount_forwarded_msat,
2720 /// Utility method to constructs a new ChannelPending-variant Event
2721 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 {
2722 Event::ChannelPending {
2725 former_temporary_channel_id,
2726 counterparty_node_id,
2731 /// Utility method to constructs a new ChannelReady-variant Event
2732 pub extern "C" fn Event_channel_ready(channel_id: crate::c_types::ThirtyTwoBytes, user_channel_id: crate::c_types::U128, counterparty_node_id: crate::c_types::PublicKey, channel_type: crate::lightning::ln::features::ChannelTypeFeatures) -> Event {
2733 Event::ChannelReady {
2736 counterparty_node_id,
2741 /// Utility method to constructs a new ChannelClosed-variant Event
2742 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) -> Event {
2743 Event::ChannelClosed {
2747 counterparty_node_id,
2748 channel_capacity_sats,
2752 /// Utility method to constructs a new DiscardFunding-variant Event
2753 pub extern "C" fn Event_discard_funding(channel_id: crate::c_types::ThirtyTwoBytes, transaction: crate::c_types::Transaction) -> Event {
2754 Event::DiscardFunding {
2760 /// Utility method to constructs a new OpenChannelRequest-variant Event
2761 pub extern "C" fn Event_open_channel_request(temporary_channel_id: crate::c_types::ThirtyTwoBytes, counterparty_node_id: crate::c_types::PublicKey, funding_satoshis: u64, push_msat: u64, channel_type: crate::lightning::ln::features::ChannelTypeFeatures) -> Event {
2762 Event::OpenChannelRequest {
2763 temporary_channel_id,
2764 counterparty_node_id,
2771 /// Utility method to constructs a new HTLCHandlingFailed-variant Event
2772 pub extern "C" fn Event_htlchandling_failed(prev_channel_id: crate::c_types::ThirtyTwoBytes, failed_next_destination: crate::lightning::events::HTLCDestination) -> Event {
2773 Event::HTLCHandlingFailed {
2775 failed_next_destination,
2779 /// Utility method to constructs a new BumpTransaction-variant Event
2780 pub extern "C" fn Event_bump_transaction(a: crate::lightning::events::bump_transaction::BumpTransactionEvent) -> Event {
2781 Event::BumpTransaction(a, )
2783 /// Checks if two Events contain equal inner contents.
2784 /// This ignores pointers and is_owned flags and looks at the values in fields.
2786 pub extern "C" fn Event_eq(a: &Event, b: &Event) -> bool {
2787 if &a.to_native() == &b.to_native() { true } else { false }
2790 /// Serialize the Event object into a byte array which can be read by Event_read
2791 pub extern "C" fn Event_write(obj: &crate::lightning::events::Event) -> crate::c_types::derived::CVec_u8Z {
2792 crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
2795 /// Read a Event from a byte array, created by Event_write
2796 pub extern "C" fn Event_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_EventZDecodeErrorZ {
2797 let res: Result<Option<lightning::events::Event>, lightning::ln::msgs::DecodeError> = crate::c_types::maybe_deserialize_obj(ser);
2798 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_res_0 = if o.is_none() { crate::c_types::derived::COption_EventZ::None } else { crate::c_types::derived::COption_EventZ::Some( { crate::lightning::events::Event::native_into(o.unwrap()) }) }; local_res_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() };
2801 /// An event generated by ChannelManager which indicates a message should be sent to a peer (or
2802 /// broadcast to most peers).
2803 /// These events are handled by PeerManager::process_events if you are using a PeerManager.
2807 pub enum MessageSendEvent {
2808 /// Used to indicate that we've accepted a channel open and should send the accept_channel
2809 /// message provided to the given peer.
2811 /// The node_id of the node which should receive this message
2812 node_id: crate::c_types::PublicKey,
2813 /// The message which should be sent.
2814 msg: crate::lightning::ln::msgs::AcceptChannel,
2816 /// Used to indicate that we've accepted a V2 channel open and should send the accept_channel2
2817 /// message provided to the given peer.
2818 SendAcceptChannelV2 {
2819 /// The node_id of the node which should receive this message
2820 node_id: crate::c_types::PublicKey,
2821 /// The message which should be sent.
2822 msg: crate::lightning::ln::msgs::AcceptChannelV2,
2824 /// Used to indicate that we've initiated a channel open and should send the open_channel
2825 /// message provided to the given peer.
2827 /// The node_id of the node which should receive this message
2828 node_id: crate::c_types::PublicKey,
2829 /// The message which should be sent.
2830 msg: crate::lightning::ln::msgs::OpenChannel,
2832 /// Used to indicate that we've initiated a V2 channel open and should send the open_channel2
2833 /// message provided to the given peer.
2835 /// The node_id of the node which should receive this message
2836 node_id: crate::c_types::PublicKey,
2837 /// The message which should be sent.
2838 msg: crate::lightning::ln::msgs::OpenChannelV2,
2840 /// Used to indicate that a funding_created message should be sent to the peer with the given node_id.
2841 SendFundingCreated {
2842 /// The node_id of the node which should receive this message
2843 node_id: crate::c_types::PublicKey,
2844 /// The message which should be sent.
2845 msg: crate::lightning::ln::msgs::FundingCreated,
2847 /// Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
2849 /// The node_id of the node which should receive this message
2850 node_id: crate::c_types::PublicKey,
2851 /// The message which should be sent.
2852 msg: crate::lightning::ln::msgs::FundingSigned,
2854 /// Used to indicate that a tx_add_input message should be sent to the peer with the given node_id.
2856 /// The node_id of the node which should receive this message
2857 node_id: crate::c_types::PublicKey,
2858 /// The message which should be sent.
2859 msg: crate::lightning::ln::msgs::TxAddInput,
2861 /// Used to indicate that a tx_add_output message should be sent to the peer with the given node_id.
2863 /// The node_id of the node which should receive this message
2864 node_id: crate::c_types::PublicKey,
2865 /// The message which should be sent.
2866 msg: crate::lightning::ln::msgs::TxAddOutput,
2868 /// Used to indicate that a tx_remove_input message should be sent to the peer with the given node_id.
2870 /// The node_id of the node which should receive this message
2871 node_id: crate::c_types::PublicKey,
2872 /// The message which should be sent.
2873 msg: crate::lightning::ln::msgs::TxRemoveInput,
2875 /// Used to indicate that a tx_remove_output message should be sent to the peer with the given node_id.
2876 SendTxRemoveOutput {
2877 /// The node_id of the node which should receive this message
2878 node_id: crate::c_types::PublicKey,
2879 /// The message which should be sent.
2880 msg: crate::lightning::ln::msgs::TxRemoveOutput,
2882 /// Used to indicate that a tx_complete message should be sent to the peer with the given node_id.
2884 /// The node_id of the node which should receive this message
2885 node_id: crate::c_types::PublicKey,
2886 /// The message which should be sent.
2887 msg: crate::lightning::ln::msgs::TxComplete,
2889 /// Used to indicate that a tx_signatures message should be sent to the peer with the given node_id.
2891 /// The node_id of the node which should receive this message
2892 node_id: crate::c_types::PublicKey,
2893 /// The message which should be sent.
2894 msg: crate::lightning::ln::msgs::TxSignatures,
2896 /// Used to indicate that a tx_init_rbf message should be sent to the peer with the given node_id.
2898 /// The node_id of the node which should receive this message
2899 node_id: crate::c_types::PublicKey,
2900 /// The message which should be sent.
2901 msg: crate::lightning::ln::msgs::TxInitRbf,
2903 /// Used to indicate that a tx_ack_rbf message should be sent to the peer with the given node_id.
2905 /// The node_id of the node which should receive this message
2906 node_id: crate::c_types::PublicKey,
2907 /// The message which should be sent.
2908 msg: crate::lightning::ln::msgs::TxAckRbf,
2910 /// Used to indicate that a tx_abort message should be sent to the peer with the given node_id.
2912 /// The node_id of the node which should receive this message
2913 node_id: crate::c_types::PublicKey,
2914 /// The message which should be sent.
2915 msg: crate::lightning::ln::msgs::TxAbort,
2917 /// Used to indicate that a channel_ready message should be sent to the peer with the given node_id.
2919 /// The node_id of the node which should receive these message(s)
2920 node_id: crate::c_types::PublicKey,
2921 /// The channel_ready message which should be sent.
2922 msg: crate::lightning::ln::msgs::ChannelReady,
2924 /// Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
2925 SendAnnouncementSignatures {
2926 /// The node_id of the node which should receive these message(s)
2927 node_id: crate::c_types::PublicKey,
2928 /// The announcement_signatures message which should be sent.
2929 msg: crate::lightning::ln::msgs::AnnouncementSignatures,
2931 /// Used to indicate that a series of HTLC update messages, as well as a commitment_signed
2932 /// message should be sent to the peer with the given node_id.
2934 /// The node_id of the node which should receive these message(s)
2935 node_id: crate::c_types::PublicKey,
2936 /// The update messages which should be sent. ALL messages in the struct should be sent!
2937 updates: crate::lightning::ln::msgs::CommitmentUpdate,
2939 /// Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
2941 /// The node_id of the node which should receive this message
2942 node_id: crate::c_types::PublicKey,
2943 /// The message which should be sent.
2944 msg: crate::lightning::ln::msgs::RevokeAndACK,
2946 /// Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
2948 /// The node_id of the node which should receive this message
2949 node_id: crate::c_types::PublicKey,
2950 /// The message which should be sent.
2951 msg: crate::lightning::ln::msgs::ClosingSigned,
2953 /// Used to indicate that a shutdown message should be sent to the peer with the given node_id.
2955 /// The node_id of the node which should receive this message
2956 node_id: crate::c_types::PublicKey,
2957 /// The message which should be sent.
2958 msg: crate::lightning::ln::msgs::Shutdown,
2960 /// Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
2961 SendChannelReestablish {
2962 /// The node_id of the node which should receive this message
2963 node_id: crate::c_types::PublicKey,
2964 /// The message which should be sent.
2965 msg: crate::lightning::ln::msgs::ChannelReestablish,
2967 /// Used to send a channel_announcement and channel_update to a specific peer, likely on
2968 /// initial connection to ensure our peers know about our channels.
2969 SendChannelAnnouncement {
2970 /// The node_id of the node which should receive this message
2971 node_id: crate::c_types::PublicKey,
2972 /// The channel_announcement which should be sent.
2973 msg: crate::lightning::ln::msgs::ChannelAnnouncement,
2974 /// The followup channel_update which should be sent.
2975 update_msg: crate::lightning::ln::msgs::ChannelUpdate,
2977 /// Used to indicate that a channel_announcement and channel_update should be broadcast to all
2978 /// peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
2980 /// Note that after doing so, you very likely (unless you did so very recently) want to
2981 /// broadcast a node_announcement (e.g. via [`PeerManager::broadcast_node_announcement`]). This
2982 /// ensures that any nodes which see our channel_announcement also have a relevant
2983 /// node_announcement, including relevant feature flags which may be important for routing
2984 /// through or to us.
2986 /// [`PeerManager::broadcast_node_announcement`]: crate::ln::peer_handler::PeerManager::broadcast_node_announcement
2987 BroadcastChannelAnnouncement {
2988 /// The channel_announcement which should be sent.
2989 msg: crate::lightning::ln::msgs::ChannelAnnouncement,
2990 /// The followup channel_update which should be sent.
2992 /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
2993 update_msg: crate::lightning::ln::msgs::ChannelUpdate,
2995 /// Used to indicate that a channel_update should be broadcast to all peers.
2996 BroadcastChannelUpdate {
2997 /// The channel_update which should be sent.
2998 msg: crate::lightning::ln::msgs::ChannelUpdate,
3000 /// Used to indicate that a node_announcement should be broadcast to all peers.
3001 BroadcastNodeAnnouncement {
3002 /// The node_announcement which should be sent.
3003 msg: crate::lightning::ln::msgs::NodeAnnouncement,
3005 /// Used to indicate that a channel_update should be sent to a single peer.
3006 /// In contrast to [`Self::BroadcastChannelUpdate`], this is used when the channel is a
3007 /// private channel and we shouldn't be informing all of our peers of channel parameters.
3009 /// The node_id of the node which should receive this message
3010 node_id: crate::c_types::PublicKey,
3011 /// The channel_update which should be sent.
3012 msg: crate::lightning::ln::msgs::ChannelUpdate,
3014 /// Broadcast an error downstream to be handled
3016 /// The node_id of the node which should receive this message
3017 node_id: crate::c_types::PublicKey,
3018 /// The action which should be taken.
3019 action: crate::lightning::ln::msgs::ErrorAction,
3021 /// Query a peer for channels with funding transaction UTXOs in a block range.
3022 SendChannelRangeQuery {
3023 /// The node_id of this message recipient
3024 node_id: crate::c_types::PublicKey,
3025 /// The query_channel_range which should be sent.
3026 msg: crate::lightning::ln::msgs::QueryChannelRange,
3028 /// Request routing gossip messages from a peer for a list of channels identified by
3029 /// their short_channel_ids.
3031 /// The node_id of this message recipient
3032 node_id: crate::c_types::PublicKey,
3033 /// The query_short_channel_ids which should be sent.
3034 msg: crate::lightning::ln::msgs::QueryShortChannelIds,
3036 /// Sends a reply to a channel range query. This may be one of several SendReplyChannelRange events
3037 /// emitted during processing of the query.
3038 SendReplyChannelRange {
3039 /// The node_id of this message recipient
3040 node_id: crate::c_types::PublicKey,
3041 /// The reply_channel_range which should be sent.
3042 msg: crate::lightning::ln::msgs::ReplyChannelRange,
3044 /// Sends a timestamp filter for inbound gossip. This should be sent on each new connection to
3045 /// enable receiving gossip messages from the peer.
3046 SendGossipTimestampFilter {
3047 /// The node_id of this message recipient
3048 node_id: crate::c_types::PublicKey,
3049 /// The gossip_timestamp_filter which should be sent.
3050 msg: crate::lightning::ln::msgs::GossipTimestampFilter,
3053 use lightning::events::MessageSendEvent as MessageSendEventImport;
3054 pub(crate) type nativeMessageSendEvent = MessageSendEventImport;
3056 impl MessageSendEvent {
3058 pub(crate) fn to_native(&self) -> nativeMessageSendEvent {
3060 MessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => {
3061 let mut node_id_nonref = Clone::clone(node_id);
3062 let mut msg_nonref = Clone::clone(msg);
3063 nativeMessageSendEvent::SendAcceptChannel {
3064 node_id: node_id_nonref.into_rust(),
3065 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3068 MessageSendEvent::SendAcceptChannelV2 {ref node_id, ref msg, } => {
3069 let mut node_id_nonref = Clone::clone(node_id);
3070 let mut msg_nonref = Clone::clone(msg);
3071 nativeMessageSendEvent::SendAcceptChannelV2 {
3072 node_id: node_id_nonref.into_rust(),
3073 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3076 MessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => {
3077 let mut node_id_nonref = Clone::clone(node_id);
3078 let mut msg_nonref = Clone::clone(msg);
3079 nativeMessageSendEvent::SendOpenChannel {
3080 node_id: node_id_nonref.into_rust(),
3081 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3084 MessageSendEvent::SendOpenChannelV2 {ref node_id, ref msg, } => {
3085 let mut node_id_nonref = Clone::clone(node_id);
3086 let mut msg_nonref = Clone::clone(msg);
3087 nativeMessageSendEvent::SendOpenChannelV2 {
3088 node_id: node_id_nonref.into_rust(),
3089 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3092 MessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => {
3093 let mut node_id_nonref = Clone::clone(node_id);
3094 let mut msg_nonref = Clone::clone(msg);
3095 nativeMessageSendEvent::SendFundingCreated {
3096 node_id: node_id_nonref.into_rust(),
3097 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3100 MessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => {
3101 let mut node_id_nonref = Clone::clone(node_id);
3102 let mut msg_nonref = Clone::clone(msg);
3103 nativeMessageSendEvent::SendFundingSigned {
3104 node_id: node_id_nonref.into_rust(),
3105 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3108 MessageSendEvent::SendTxAddInput {ref node_id, ref msg, } => {
3109 let mut node_id_nonref = Clone::clone(node_id);
3110 let mut msg_nonref = Clone::clone(msg);
3111 nativeMessageSendEvent::SendTxAddInput {
3112 node_id: node_id_nonref.into_rust(),
3113 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3116 MessageSendEvent::SendTxAddOutput {ref node_id, ref msg, } => {
3117 let mut node_id_nonref = Clone::clone(node_id);
3118 let mut msg_nonref = Clone::clone(msg);
3119 nativeMessageSendEvent::SendTxAddOutput {
3120 node_id: node_id_nonref.into_rust(),
3121 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3124 MessageSendEvent::SendTxRemoveInput {ref node_id, ref msg, } => {
3125 let mut node_id_nonref = Clone::clone(node_id);
3126 let mut msg_nonref = Clone::clone(msg);
3127 nativeMessageSendEvent::SendTxRemoveInput {
3128 node_id: node_id_nonref.into_rust(),
3129 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3132 MessageSendEvent::SendTxRemoveOutput {ref node_id, ref msg, } => {
3133 let mut node_id_nonref = Clone::clone(node_id);
3134 let mut msg_nonref = Clone::clone(msg);
3135 nativeMessageSendEvent::SendTxRemoveOutput {
3136 node_id: node_id_nonref.into_rust(),
3137 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3140 MessageSendEvent::SendTxComplete {ref node_id, ref msg, } => {
3141 let mut node_id_nonref = Clone::clone(node_id);
3142 let mut msg_nonref = Clone::clone(msg);
3143 nativeMessageSendEvent::SendTxComplete {
3144 node_id: node_id_nonref.into_rust(),
3145 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3148 MessageSendEvent::SendTxSignatures {ref node_id, ref msg, } => {
3149 let mut node_id_nonref = Clone::clone(node_id);
3150 let mut msg_nonref = Clone::clone(msg);
3151 nativeMessageSendEvent::SendTxSignatures {
3152 node_id: node_id_nonref.into_rust(),
3153 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3156 MessageSendEvent::SendTxInitRbf {ref node_id, ref msg, } => {
3157 let mut node_id_nonref = Clone::clone(node_id);
3158 let mut msg_nonref = Clone::clone(msg);
3159 nativeMessageSendEvent::SendTxInitRbf {
3160 node_id: node_id_nonref.into_rust(),
3161 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3164 MessageSendEvent::SendTxAckRbf {ref node_id, ref msg, } => {
3165 let mut node_id_nonref = Clone::clone(node_id);
3166 let mut msg_nonref = Clone::clone(msg);
3167 nativeMessageSendEvent::SendTxAckRbf {
3168 node_id: node_id_nonref.into_rust(),
3169 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3172 MessageSendEvent::SendTxAbort {ref node_id, ref msg, } => {
3173 let mut node_id_nonref = Clone::clone(node_id);
3174 let mut msg_nonref = Clone::clone(msg);
3175 nativeMessageSendEvent::SendTxAbort {
3176 node_id: node_id_nonref.into_rust(),
3177 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3180 MessageSendEvent::SendChannelReady {ref node_id, ref msg, } => {
3181 let mut node_id_nonref = Clone::clone(node_id);
3182 let mut msg_nonref = Clone::clone(msg);
3183 nativeMessageSendEvent::SendChannelReady {
3184 node_id: node_id_nonref.into_rust(),
3185 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3188 MessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => {
3189 let mut node_id_nonref = Clone::clone(node_id);
3190 let mut msg_nonref = Clone::clone(msg);
3191 nativeMessageSendEvent::SendAnnouncementSignatures {
3192 node_id: node_id_nonref.into_rust(),
3193 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3196 MessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => {
3197 let mut node_id_nonref = Clone::clone(node_id);
3198 let mut updates_nonref = Clone::clone(updates);
3199 nativeMessageSendEvent::UpdateHTLCs {
3200 node_id: node_id_nonref.into_rust(),
3201 updates: *unsafe { Box::from_raw(updates_nonref.take_inner()) },
3204 MessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => {
3205 let mut node_id_nonref = Clone::clone(node_id);
3206 let mut msg_nonref = Clone::clone(msg);
3207 nativeMessageSendEvent::SendRevokeAndACK {
3208 node_id: node_id_nonref.into_rust(),
3209 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3212 MessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => {
3213 let mut node_id_nonref = Clone::clone(node_id);
3214 let mut msg_nonref = Clone::clone(msg);
3215 nativeMessageSendEvent::SendClosingSigned {
3216 node_id: node_id_nonref.into_rust(),
3217 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3220 MessageSendEvent::SendShutdown {ref node_id, ref msg, } => {
3221 let mut node_id_nonref = Clone::clone(node_id);
3222 let mut msg_nonref = Clone::clone(msg);
3223 nativeMessageSendEvent::SendShutdown {
3224 node_id: node_id_nonref.into_rust(),
3225 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3228 MessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => {
3229 let mut node_id_nonref = Clone::clone(node_id);
3230 let mut msg_nonref = Clone::clone(msg);
3231 nativeMessageSendEvent::SendChannelReestablish {
3232 node_id: node_id_nonref.into_rust(),
3233 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3236 MessageSendEvent::SendChannelAnnouncement {ref node_id, ref msg, ref update_msg, } => {
3237 let mut node_id_nonref = Clone::clone(node_id);
3238 let mut msg_nonref = Clone::clone(msg);
3239 let mut update_msg_nonref = Clone::clone(update_msg);
3240 nativeMessageSendEvent::SendChannelAnnouncement {
3241 node_id: node_id_nonref.into_rust(),
3242 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3243 update_msg: *unsafe { Box::from_raw(update_msg_nonref.take_inner()) },
3246 MessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => {
3247 let mut msg_nonref = Clone::clone(msg);
3248 let mut update_msg_nonref = Clone::clone(update_msg);
3249 let mut local_update_msg_nonref = if update_msg_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(update_msg_nonref.take_inner()) } }) };
3250 nativeMessageSendEvent::BroadcastChannelAnnouncement {
3251 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3252 update_msg: local_update_msg_nonref,
3255 MessageSendEvent::BroadcastChannelUpdate {ref msg, } => {
3256 let mut msg_nonref = Clone::clone(msg);
3257 nativeMessageSendEvent::BroadcastChannelUpdate {
3258 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3261 MessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => {
3262 let mut msg_nonref = Clone::clone(msg);
3263 nativeMessageSendEvent::BroadcastNodeAnnouncement {
3264 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3267 MessageSendEvent::SendChannelUpdate {ref node_id, ref msg, } => {
3268 let mut node_id_nonref = Clone::clone(node_id);
3269 let mut msg_nonref = Clone::clone(msg);
3270 nativeMessageSendEvent::SendChannelUpdate {
3271 node_id: node_id_nonref.into_rust(),
3272 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3275 MessageSendEvent::HandleError {ref node_id, ref action, } => {
3276 let mut node_id_nonref = Clone::clone(node_id);
3277 let mut action_nonref = Clone::clone(action);
3278 nativeMessageSendEvent::HandleError {
3279 node_id: node_id_nonref.into_rust(),
3280 action: action_nonref.into_native(),
3283 MessageSendEvent::SendChannelRangeQuery {ref node_id, ref msg, } => {
3284 let mut node_id_nonref = Clone::clone(node_id);
3285 let mut msg_nonref = Clone::clone(msg);
3286 nativeMessageSendEvent::SendChannelRangeQuery {
3287 node_id: node_id_nonref.into_rust(),
3288 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3291 MessageSendEvent::SendShortIdsQuery {ref node_id, ref msg, } => {
3292 let mut node_id_nonref = Clone::clone(node_id);
3293 let mut msg_nonref = Clone::clone(msg);
3294 nativeMessageSendEvent::SendShortIdsQuery {
3295 node_id: node_id_nonref.into_rust(),
3296 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3299 MessageSendEvent::SendReplyChannelRange {ref node_id, ref msg, } => {
3300 let mut node_id_nonref = Clone::clone(node_id);
3301 let mut msg_nonref = Clone::clone(msg);
3302 nativeMessageSendEvent::SendReplyChannelRange {
3303 node_id: node_id_nonref.into_rust(),
3304 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3307 MessageSendEvent::SendGossipTimestampFilter {ref node_id, ref msg, } => {
3308 let mut node_id_nonref = Clone::clone(node_id);
3309 let mut msg_nonref = Clone::clone(msg);
3310 nativeMessageSendEvent::SendGossipTimestampFilter {
3311 node_id: node_id_nonref.into_rust(),
3312 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
3318 pub(crate) fn into_native(self) -> nativeMessageSendEvent {
3320 MessageSendEvent::SendAcceptChannel {mut node_id, mut msg, } => {
3321 nativeMessageSendEvent::SendAcceptChannel {
3322 node_id: node_id.into_rust(),
3323 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3326 MessageSendEvent::SendAcceptChannelV2 {mut node_id, mut msg, } => {
3327 nativeMessageSendEvent::SendAcceptChannelV2 {
3328 node_id: node_id.into_rust(),
3329 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3332 MessageSendEvent::SendOpenChannel {mut node_id, mut msg, } => {
3333 nativeMessageSendEvent::SendOpenChannel {
3334 node_id: node_id.into_rust(),
3335 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3338 MessageSendEvent::SendOpenChannelV2 {mut node_id, mut msg, } => {
3339 nativeMessageSendEvent::SendOpenChannelV2 {
3340 node_id: node_id.into_rust(),
3341 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3344 MessageSendEvent::SendFundingCreated {mut node_id, mut msg, } => {
3345 nativeMessageSendEvent::SendFundingCreated {
3346 node_id: node_id.into_rust(),
3347 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3350 MessageSendEvent::SendFundingSigned {mut node_id, mut msg, } => {
3351 nativeMessageSendEvent::SendFundingSigned {
3352 node_id: node_id.into_rust(),
3353 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3356 MessageSendEvent::SendTxAddInput {mut node_id, mut msg, } => {
3357 nativeMessageSendEvent::SendTxAddInput {
3358 node_id: node_id.into_rust(),
3359 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3362 MessageSendEvent::SendTxAddOutput {mut node_id, mut msg, } => {
3363 nativeMessageSendEvent::SendTxAddOutput {
3364 node_id: node_id.into_rust(),
3365 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3368 MessageSendEvent::SendTxRemoveInput {mut node_id, mut msg, } => {
3369 nativeMessageSendEvent::SendTxRemoveInput {
3370 node_id: node_id.into_rust(),
3371 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3374 MessageSendEvent::SendTxRemoveOutput {mut node_id, mut msg, } => {
3375 nativeMessageSendEvent::SendTxRemoveOutput {
3376 node_id: node_id.into_rust(),
3377 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3380 MessageSendEvent::SendTxComplete {mut node_id, mut msg, } => {
3381 nativeMessageSendEvent::SendTxComplete {
3382 node_id: node_id.into_rust(),
3383 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3386 MessageSendEvent::SendTxSignatures {mut node_id, mut msg, } => {
3387 nativeMessageSendEvent::SendTxSignatures {
3388 node_id: node_id.into_rust(),
3389 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3392 MessageSendEvent::SendTxInitRbf {mut node_id, mut msg, } => {
3393 nativeMessageSendEvent::SendTxInitRbf {
3394 node_id: node_id.into_rust(),
3395 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3398 MessageSendEvent::SendTxAckRbf {mut node_id, mut msg, } => {
3399 nativeMessageSendEvent::SendTxAckRbf {
3400 node_id: node_id.into_rust(),
3401 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3404 MessageSendEvent::SendTxAbort {mut node_id, mut msg, } => {
3405 nativeMessageSendEvent::SendTxAbort {
3406 node_id: node_id.into_rust(),
3407 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3410 MessageSendEvent::SendChannelReady {mut node_id, mut msg, } => {
3411 nativeMessageSendEvent::SendChannelReady {
3412 node_id: node_id.into_rust(),
3413 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3416 MessageSendEvent::SendAnnouncementSignatures {mut node_id, mut msg, } => {
3417 nativeMessageSendEvent::SendAnnouncementSignatures {
3418 node_id: node_id.into_rust(),
3419 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3422 MessageSendEvent::UpdateHTLCs {mut node_id, mut updates, } => {
3423 nativeMessageSendEvent::UpdateHTLCs {
3424 node_id: node_id.into_rust(),
3425 updates: *unsafe { Box::from_raw(updates.take_inner()) },
3428 MessageSendEvent::SendRevokeAndACK {mut node_id, mut msg, } => {
3429 nativeMessageSendEvent::SendRevokeAndACK {
3430 node_id: node_id.into_rust(),
3431 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3434 MessageSendEvent::SendClosingSigned {mut node_id, mut msg, } => {
3435 nativeMessageSendEvent::SendClosingSigned {
3436 node_id: node_id.into_rust(),
3437 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3440 MessageSendEvent::SendShutdown {mut node_id, mut msg, } => {
3441 nativeMessageSendEvent::SendShutdown {
3442 node_id: node_id.into_rust(),
3443 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3446 MessageSendEvent::SendChannelReestablish {mut node_id, mut msg, } => {
3447 nativeMessageSendEvent::SendChannelReestablish {
3448 node_id: node_id.into_rust(),
3449 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3452 MessageSendEvent::SendChannelAnnouncement {mut node_id, mut msg, mut update_msg, } => {
3453 nativeMessageSendEvent::SendChannelAnnouncement {
3454 node_id: node_id.into_rust(),
3455 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3456 update_msg: *unsafe { Box::from_raw(update_msg.take_inner()) },
3459 MessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => {
3460 let mut local_update_msg = if update_msg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(update_msg.take_inner()) } }) };
3461 nativeMessageSendEvent::BroadcastChannelAnnouncement {
3462 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3463 update_msg: local_update_msg,
3466 MessageSendEvent::BroadcastChannelUpdate {mut msg, } => {
3467 nativeMessageSendEvent::BroadcastChannelUpdate {
3468 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3471 MessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => {
3472 nativeMessageSendEvent::BroadcastNodeAnnouncement {
3473 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3476 MessageSendEvent::SendChannelUpdate {mut node_id, mut msg, } => {
3477 nativeMessageSendEvent::SendChannelUpdate {
3478 node_id: node_id.into_rust(),
3479 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3482 MessageSendEvent::HandleError {mut node_id, mut action, } => {
3483 nativeMessageSendEvent::HandleError {
3484 node_id: node_id.into_rust(),
3485 action: action.into_native(),
3488 MessageSendEvent::SendChannelRangeQuery {mut node_id, mut msg, } => {
3489 nativeMessageSendEvent::SendChannelRangeQuery {
3490 node_id: node_id.into_rust(),
3491 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3494 MessageSendEvent::SendShortIdsQuery {mut node_id, mut msg, } => {
3495 nativeMessageSendEvent::SendShortIdsQuery {
3496 node_id: node_id.into_rust(),
3497 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3500 MessageSendEvent::SendReplyChannelRange {mut node_id, mut msg, } => {
3501 nativeMessageSendEvent::SendReplyChannelRange {
3502 node_id: node_id.into_rust(),
3503 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3506 MessageSendEvent::SendGossipTimestampFilter {mut node_id, mut msg, } => {
3507 nativeMessageSendEvent::SendGossipTimestampFilter {
3508 node_id: node_id.into_rust(),
3509 msg: *unsafe { Box::from_raw(msg.take_inner()) },
3515 pub(crate) fn from_native(native: &nativeMessageSendEvent) -> Self {
3517 nativeMessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => {
3518 let mut node_id_nonref = Clone::clone(node_id);
3519 let mut msg_nonref = Clone::clone(msg);
3520 MessageSendEvent::SendAcceptChannel {
3521 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3522 msg: crate::lightning::ln::msgs::AcceptChannel { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3525 nativeMessageSendEvent::SendAcceptChannelV2 {ref node_id, ref msg, } => {
3526 let mut node_id_nonref = Clone::clone(node_id);
3527 let mut msg_nonref = Clone::clone(msg);
3528 MessageSendEvent::SendAcceptChannelV2 {
3529 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3530 msg: crate::lightning::ln::msgs::AcceptChannelV2 { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3533 nativeMessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => {
3534 let mut node_id_nonref = Clone::clone(node_id);
3535 let mut msg_nonref = Clone::clone(msg);
3536 MessageSendEvent::SendOpenChannel {
3537 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3538 msg: crate::lightning::ln::msgs::OpenChannel { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3541 nativeMessageSendEvent::SendOpenChannelV2 {ref node_id, ref msg, } => {
3542 let mut node_id_nonref = Clone::clone(node_id);
3543 let mut msg_nonref = Clone::clone(msg);
3544 MessageSendEvent::SendOpenChannelV2 {
3545 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3546 msg: crate::lightning::ln::msgs::OpenChannelV2 { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3549 nativeMessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => {
3550 let mut node_id_nonref = Clone::clone(node_id);
3551 let mut msg_nonref = Clone::clone(msg);
3552 MessageSendEvent::SendFundingCreated {
3553 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3554 msg: crate::lightning::ln::msgs::FundingCreated { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3557 nativeMessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => {
3558 let mut node_id_nonref = Clone::clone(node_id);
3559 let mut msg_nonref = Clone::clone(msg);
3560 MessageSendEvent::SendFundingSigned {
3561 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3562 msg: crate::lightning::ln::msgs::FundingSigned { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3565 nativeMessageSendEvent::SendTxAddInput {ref node_id, ref msg, } => {
3566 let mut node_id_nonref = Clone::clone(node_id);
3567 let mut msg_nonref = Clone::clone(msg);
3568 MessageSendEvent::SendTxAddInput {
3569 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3570 msg: crate::lightning::ln::msgs::TxAddInput { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3573 nativeMessageSendEvent::SendTxAddOutput {ref node_id, ref msg, } => {
3574 let mut node_id_nonref = Clone::clone(node_id);
3575 let mut msg_nonref = Clone::clone(msg);
3576 MessageSendEvent::SendTxAddOutput {
3577 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3578 msg: crate::lightning::ln::msgs::TxAddOutput { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3581 nativeMessageSendEvent::SendTxRemoveInput {ref node_id, ref msg, } => {
3582 let mut node_id_nonref = Clone::clone(node_id);
3583 let mut msg_nonref = Clone::clone(msg);
3584 MessageSendEvent::SendTxRemoveInput {
3585 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3586 msg: crate::lightning::ln::msgs::TxRemoveInput { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3589 nativeMessageSendEvent::SendTxRemoveOutput {ref node_id, ref msg, } => {
3590 let mut node_id_nonref = Clone::clone(node_id);
3591 let mut msg_nonref = Clone::clone(msg);
3592 MessageSendEvent::SendTxRemoveOutput {
3593 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3594 msg: crate::lightning::ln::msgs::TxRemoveOutput { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3597 nativeMessageSendEvent::SendTxComplete {ref node_id, ref msg, } => {
3598 let mut node_id_nonref = Clone::clone(node_id);
3599 let mut msg_nonref = Clone::clone(msg);
3600 MessageSendEvent::SendTxComplete {
3601 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3602 msg: crate::lightning::ln::msgs::TxComplete { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3605 nativeMessageSendEvent::SendTxSignatures {ref node_id, ref msg, } => {
3606 let mut node_id_nonref = Clone::clone(node_id);
3607 let mut msg_nonref = Clone::clone(msg);
3608 MessageSendEvent::SendTxSignatures {
3609 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3610 msg: crate::lightning::ln::msgs::TxSignatures { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3613 nativeMessageSendEvent::SendTxInitRbf {ref node_id, ref msg, } => {
3614 let mut node_id_nonref = Clone::clone(node_id);
3615 let mut msg_nonref = Clone::clone(msg);
3616 MessageSendEvent::SendTxInitRbf {
3617 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3618 msg: crate::lightning::ln::msgs::TxInitRbf { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3621 nativeMessageSendEvent::SendTxAckRbf {ref node_id, ref msg, } => {
3622 let mut node_id_nonref = Clone::clone(node_id);
3623 let mut msg_nonref = Clone::clone(msg);
3624 MessageSendEvent::SendTxAckRbf {
3625 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3626 msg: crate::lightning::ln::msgs::TxAckRbf { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3629 nativeMessageSendEvent::SendTxAbort {ref node_id, ref msg, } => {
3630 let mut node_id_nonref = Clone::clone(node_id);
3631 let mut msg_nonref = Clone::clone(msg);
3632 MessageSendEvent::SendTxAbort {
3633 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3634 msg: crate::lightning::ln::msgs::TxAbort { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3637 nativeMessageSendEvent::SendChannelReady {ref node_id, ref msg, } => {
3638 let mut node_id_nonref = Clone::clone(node_id);
3639 let mut msg_nonref = Clone::clone(msg);
3640 MessageSendEvent::SendChannelReady {
3641 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3642 msg: crate::lightning::ln::msgs::ChannelReady { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3645 nativeMessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => {
3646 let mut node_id_nonref = Clone::clone(node_id);
3647 let mut msg_nonref = Clone::clone(msg);
3648 MessageSendEvent::SendAnnouncementSignatures {
3649 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3650 msg: crate::lightning::ln::msgs::AnnouncementSignatures { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3653 nativeMessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => {
3654 let mut node_id_nonref = Clone::clone(node_id);
3655 let mut updates_nonref = Clone::clone(updates);
3656 MessageSendEvent::UpdateHTLCs {
3657 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3658 updates: crate::lightning::ln::msgs::CommitmentUpdate { inner: ObjOps::heap_alloc(updates_nonref), is_owned: true },
3661 nativeMessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => {
3662 let mut node_id_nonref = Clone::clone(node_id);
3663 let mut msg_nonref = Clone::clone(msg);
3664 MessageSendEvent::SendRevokeAndACK {
3665 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3666 msg: crate::lightning::ln::msgs::RevokeAndACK { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3669 nativeMessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => {
3670 let mut node_id_nonref = Clone::clone(node_id);
3671 let mut msg_nonref = Clone::clone(msg);
3672 MessageSendEvent::SendClosingSigned {
3673 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3674 msg: crate::lightning::ln::msgs::ClosingSigned { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3677 nativeMessageSendEvent::SendShutdown {ref node_id, ref msg, } => {
3678 let mut node_id_nonref = Clone::clone(node_id);
3679 let mut msg_nonref = Clone::clone(msg);
3680 MessageSendEvent::SendShutdown {
3681 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3682 msg: crate::lightning::ln::msgs::Shutdown { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3685 nativeMessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => {
3686 let mut node_id_nonref = Clone::clone(node_id);
3687 let mut msg_nonref = Clone::clone(msg);
3688 MessageSendEvent::SendChannelReestablish {
3689 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3690 msg: crate::lightning::ln::msgs::ChannelReestablish { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3693 nativeMessageSendEvent::SendChannelAnnouncement {ref node_id, ref msg, ref update_msg, } => {
3694 let mut node_id_nonref = Clone::clone(node_id);
3695 let mut msg_nonref = Clone::clone(msg);
3696 let mut update_msg_nonref = Clone::clone(update_msg);
3697 MessageSendEvent::SendChannelAnnouncement {
3698 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3699 msg: crate::lightning::ln::msgs::ChannelAnnouncement { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3700 update_msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(update_msg_nonref), is_owned: true },
3703 nativeMessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => {
3704 let mut msg_nonref = Clone::clone(msg);
3705 let mut update_msg_nonref = Clone::clone(update_msg);
3706 let mut local_update_msg_nonref = crate::lightning::ln::msgs::ChannelUpdate { inner: if update_msg_nonref.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((update_msg_nonref.unwrap())) } }, is_owned: true };
3707 MessageSendEvent::BroadcastChannelAnnouncement {
3708 msg: crate::lightning::ln::msgs::ChannelAnnouncement { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3709 update_msg: local_update_msg_nonref,
3712 nativeMessageSendEvent::BroadcastChannelUpdate {ref msg, } => {
3713 let mut msg_nonref = Clone::clone(msg);
3714 MessageSendEvent::BroadcastChannelUpdate {
3715 msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3718 nativeMessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => {
3719 let mut msg_nonref = Clone::clone(msg);
3720 MessageSendEvent::BroadcastNodeAnnouncement {
3721 msg: crate::lightning::ln::msgs::NodeAnnouncement { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3724 nativeMessageSendEvent::SendChannelUpdate {ref node_id, ref msg, } => {
3725 let mut node_id_nonref = Clone::clone(node_id);
3726 let mut msg_nonref = Clone::clone(msg);
3727 MessageSendEvent::SendChannelUpdate {
3728 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3729 msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3732 nativeMessageSendEvent::HandleError {ref node_id, ref action, } => {
3733 let mut node_id_nonref = Clone::clone(node_id);
3734 let mut action_nonref = Clone::clone(action);
3735 MessageSendEvent::HandleError {
3736 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3737 action: crate::lightning::ln::msgs::ErrorAction::native_into(action_nonref),
3740 nativeMessageSendEvent::SendChannelRangeQuery {ref node_id, ref msg, } => {
3741 let mut node_id_nonref = Clone::clone(node_id);
3742 let mut msg_nonref = Clone::clone(msg);
3743 MessageSendEvent::SendChannelRangeQuery {
3744 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3745 msg: crate::lightning::ln::msgs::QueryChannelRange { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3748 nativeMessageSendEvent::SendShortIdsQuery {ref node_id, ref msg, } => {
3749 let mut node_id_nonref = Clone::clone(node_id);
3750 let mut msg_nonref = Clone::clone(msg);
3751 MessageSendEvent::SendShortIdsQuery {
3752 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3753 msg: crate::lightning::ln::msgs::QueryShortChannelIds { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3756 nativeMessageSendEvent::SendReplyChannelRange {ref node_id, ref msg, } => {
3757 let mut node_id_nonref = Clone::clone(node_id);
3758 let mut msg_nonref = Clone::clone(msg);
3759 MessageSendEvent::SendReplyChannelRange {
3760 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3761 msg: crate::lightning::ln::msgs::ReplyChannelRange { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3764 nativeMessageSendEvent::SendGossipTimestampFilter {ref node_id, ref msg, } => {
3765 let mut node_id_nonref = Clone::clone(node_id);
3766 let mut msg_nonref = Clone::clone(msg);
3767 MessageSendEvent::SendGossipTimestampFilter {
3768 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
3769 msg: crate::lightning::ln::msgs::GossipTimestampFilter { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
3775 pub(crate) fn native_into(native: nativeMessageSendEvent) -> Self {
3777 nativeMessageSendEvent::SendAcceptChannel {mut node_id, mut msg, } => {
3778 MessageSendEvent::SendAcceptChannel {
3779 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3780 msg: crate::lightning::ln::msgs::AcceptChannel { inner: ObjOps::heap_alloc(msg), is_owned: true },
3783 nativeMessageSendEvent::SendAcceptChannelV2 {mut node_id, mut msg, } => {
3784 MessageSendEvent::SendAcceptChannelV2 {
3785 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3786 msg: crate::lightning::ln::msgs::AcceptChannelV2 { inner: ObjOps::heap_alloc(msg), is_owned: true },
3789 nativeMessageSendEvent::SendOpenChannel {mut node_id, mut msg, } => {
3790 MessageSendEvent::SendOpenChannel {
3791 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3792 msg: crate::lightning::ln::msgs::OpenChannel { inner: ObjOps::heap_alloc(msg), is_owned: true },
3795 nativeMessageSendEvent::SendOpenChannelV2 {mut node_id, mut msg, } => {
3796 MessageSendEvent::SendOpenChannelV2 {
3797 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3798 msg: crate::lightning::ln::msgs::OpenChannelV2 { inner: ObjOps::heap_alloc(msg), is_owned: true },
3801 nativeMessageSendEvent::SendFundingCreated {mut node_id, mut msg, } => {
3802 MessageSendEvent::SendFundingCreated {
3803 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3804 msg: crate::lightning::ln::msgs::FundingCreated { inner: ObjOps::heap_alloc(msg), is_owned: true },
3807 nativeMessageSendEvent::SendFundingSigned {mut node_id, mut msg, } => {
3808 MessageSendEvent::SendFundingSigned {
3809 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3810 msg: crate::lightning::ln::msgs::FundingSigned { inner: ObjOps::heap_alloc(msg), is_owned: true },
3813 nativeMessageSendEvent::SendTxAddInput {mut node_id, mut msg, } => {
3814 MessageSendEvent::SendTxAddInput {
3815 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3816 msg: crate::lightning::ln::msgs::TxAddInput { inner: ObjOps::heap_alloc(msg), is_owned: true },
3819 nativeMessageSendEvent::SendTxAddOutput {mut node_id, mut msg, } => {
3820 MessageSendEvent::SendTxAddOutput {
3821 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3822 msg: crate::lightning::ln::msgs::TxAddOutput { inner: ObjOps::heap_alloc(msg), is_owned: true },
3825 nativeMessageSendEvent::SendTxRemoveInput {mut node_id, mut msg, } => {
3826 MessageSendEvent::SendTxRemoveInput {
3827 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3828 msg: crate::lightning::ln::msgs::TxRemoveInput { inner: ObjOps::heap_alloc(msg), is_owned: true },
3831 nativeMessageSendEvent::SendTxRemoveOutput {mut node_id, mut msg, } => {
3832 MessageSendEvent::SendTxRemoveOutput {
3833 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3834 msg: crate::lightning::ln::msgs::TxRemoveOutput { inner: ObjOps::heap_alloc(msg), is_owned: true },
3837 nativeMessageSendEvent::SendTxComplete {mut node_id, mut msg, } => {
3838 MessageSendEvent::SendTxComplete {
3839 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3840 msg: crate::lightning::ln::msgs::TxComplete { inner: ObjOps::heap_alloc(msg), is_owned: true },
3843 nativeMessageSendEvent::SendTxSignatures {mut node_id, mut msg, } => {
3844 MessageSendEvent::SendTxSignatures {
3845 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3846 msg: crate::lightning::ln::msgs::TxSignatures { inner: ObjOps::heap_alloc(msg), is_owned: true },
3849 nativeMessageSendEvent::SendTxInitRbf {mut node_id, mut msg, } => {
3850 MessageSendEvent::SendTxInitRbf {
3851 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3852 msg: crate::lightning::ln::msgs::TxInitRbf { inner: ObjOps::heap_alloc(msg), is_owned: true },
3855 nativeMessageSendEvent::SendTxAckRbf {mut node_id, mut msg, } => {
3856 MessageSendEvent::SendTxAckRbf {
3857 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3858 msg: crate::lightning::ln::msgs::TxAckRbf { inner: ObjOps::heap_alloc(msg), is_owned: true },
3861 nativeMessageSendEvent::SendTxAbort {mut node_id, mut msg, } => {
3862 MessageSendEvent::SendTxAbort {
3863 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3864 msg: crate::lightning::ln::msgs::TxAbort { inner: ObjOps::heap_alloc(msg), is_owned: true },
3867 nativeMessageSendEvent::SendChannelReady {mut node_id, mut msg, } => {
3868 MessageSendEvent::SendChannelReady {
3869 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3870 msg: crate::lightning::ln::msgs::ChannelReady { inner: ObjOps::heap_alloc(msg), is_owned: true },
3873 nativeMessageSendEvent::SendAnnouncementSignatures {mut node_id, mut msg, } => {
3874 MessageSendEvent::SendAnnouncementSignatures {
3875 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3876 msg: crate::lightning::ln::msgs::AnnouncementSignatures { inner: ObjOps::heap_alloc(msg), is_owned: true },
3879 nativeMessageSendEvent::UpdateHTLCs {mut node_id, mut updates, } => {
3880 MessageSendEvent::UpdateHTLCs {
3881 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3882 updates: crate::lightning::ln::msgs::CommitmentUpdate { inner: ObjOps::heap_alloc(updates), is_owned: true },
3885 nativeMessageSendEvent::SendRevokeAndACK {mut node_id, mut msg, } => {
3886 MessageSendEvent::SendRevokeAndACK {
3887 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3888 msg: crate::lightning::ln::msgs::RevokeAndACK { inner: ObjOps::heap_alloc(msg), is_owned: true },
3891 nativeMessageSendEvent::SendClosingSigned {mut node_id, mut msg, } => {
3892 MessageSendEvent::SendClosingSigned {
3893 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3894 msg: crate::lightning::ln::msgs::ClosingSigned { inner: ObjOps::heap_alloc(msg), is_owned: true },
3897 nativeMessageSendEvent::SendShutdown {mut node_id, mut msg, } => {
3898 MessageSendEvent::SendShutdown {
3899 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3900 msg: crate::lightning::ln::msgs::Shutdown { inner: ObjOps::heap_alloc(msg), is_owned: true },
3903 nativeMessageSendEvent::SendChannelReestablish {mut node_id, mut msg, } => {
3904 MessageSendEvent::SendChannelReestablish {
3905 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3906 msg: crate::lightning::ln::msgs::ChannelReestablish { inner: ObjOps::heap_alloc(msg), is_owned: true },
3909 nativeMessageSendEvent::SendChannelAnnouncement {mut node_id, mut msg, mut update_msg, } => {
3910 MessageSendEvent::SendChannelAnnouncement {
3911 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3912 msg: crate::lightning::ln::msgs::ChannelAnnouncement { inner: ObjOps::heap_alloc(msg), is_owned: true },
3913 update_msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(update_msg), is_owned: true },
3916 nativeMessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => {
3917 let mut local_update_msg = crate::lightning::ln::msgs::ChannelUpdate { inner: if update_msg.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((update_msg.unwrap())) } }, is_owned: true };
3918 MessageSendEvent::BroadcastChannelAnnouncement {
3919 msg: crate::lightning::ln::msgs::ChannelAnnouncement { inner: ObjOps::heap_alloc(msg), is_owned: true },
3920 update_msg: local_update_msg,
3923 nativeMessageSendEvent::BroadcastChannelUpdate {mut msg, } => {
3924 MessageSendEvent::BroadcastChannelUpdate {
3925 msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(msg), is_owned: true },
3928 nativeMessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => {
3929 MessageSendEvent::BroadcastNodeAnnouncement {
3930 msg: crate::lightning::ln::msgs::NodeAnnouncement { inner: ObjOps::heap_alloc(msg), is_owned: true },
3933 nativeMessageSendEvent::SendChannelUpdate {mut node_id, mut msg, } => {
3934 MessageSendEvent::SendChannelUpdate {
3935 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3936 msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(msg), is_owned: true },
3939 nativeMessageSendEvent::HandleError {mut node_id, mut action, } => {
3940 MessageSendEvent::HandleError {
3941 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3942 action: crate::lightning::ln::msgs::ErrorAction::native_into(action),
3945 nativeMessageSendEvent::SendChannelRangeQuery {mut node_id, mut msg, } => {
3946 MessageSendEvent::SendChannelRangeQuery {
3947 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3948 msg: crate::lightning::ln::msgs::QueryChannelRange { inner: ObjOps::heap_alloc(msg), is_owned: true },
3951 nativeMessageSendEvent::SendShortIdsQuery {mut node_id, mut msg, } => {
3952 MessageSendEvent::SendShortIdsQuery {
3953 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3954 msg: crate::lightning::ln::msgs::QueryShortChannelIds { inner: ObjOps::heap_alloc(msg), is_owned: true },
3957 nativeMessageSendEvent::SendReplyChannelRange {mut node_id, mut msg, } => {
3958 MessageSendEvent::SendReplyChannelRange {
3959 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3960 msg: crate::lightning::ln::msgs::ReplyChannelRange { inner: ObjOps::heap_alloc(msg), is_owned: true },
3963 nativeMessageSendEvent::SendGossipTimestampFilter {mut node_id, mut msg, } => {
3964 MessageSendEvent::SendGossipTimestampFilter {
3965 node_id: crate::c_types::PublicKey::from_rust(&node_id),
3966 msg: crate::lightning::ln::msgs::GossipTimestampFilter { inner: ObjOps::heap_alloc(msg), is_owned: true },
3972 /// Frees any resources used by the MessageSendEvent
3974 pub extern "C" fn MessageSendEvent_free(this_ptr: MessageSendEvent) { }
3975 /// Creates a copy of the MessageSendEvent
3977 pub extern "C" fn MessageSendEvent_clone(orig: &MessageSendEvent) -> MessageSendEvent {
3981 /// Utility method to constructs a new SendAcceptChannel-variant MessageSendEvent
3982 pub extern "C" fn MessageSendEvent_send_accept_channel(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::AcceptChannel) -> MessageSendEvent {
3983 MessageSendEvent::SendAcceptChannel {
3989 /// Utility method to constructs a new SendAcceptChannelV2-variant MessageSendEvent
3990 pub extern "C" fn MessageSendEvent_send_accept_channel_v2(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::AcceptChannelV2) -> MessageSendEvent {
3991 MessageSendEvent::SendAcceptChannelV2 {
3997 /// Utility method to constructs a new SendOpenChannel-variant MessageSendEvent
3998 pub extern "C" fn MessageSendEvent_send_open_channel(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::OpenChannel) -> MessageSendEvent {
3999 MessageSendEvent::SendOpenChannel {
4005 /// Utility method to constructs a new SendOpenChannelV2-variant MessageSendEvent
4006 pub extern "C" fn MessageSendEvent_send_open_channel_v2(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::OpenChannelV2) -> MessageSendEvent {
4007 MessageSendEvent::SendOpenChannelV2 {
4013 /// Utility method to constructs a new SendFundingCreated-variant MessageSendEvent
4014 pub extern "C" fn MessageSendEvent_send_funding_created(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::FundingCreated) -> MessageSendEvent {
4015 MessageSendEvent::SendFundingCreated {
4021 /// Utility method to constructs a new SendFundingSigned-variant MessageSendEvent
4022 pub extern "C" fn MessageSendEvent_send_funding_signed(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::FundingSigned) -> MessageSendEvent {
4023 MessageSendEvent::SendFundingSigned {
4029 /// Utility method to constructs a new SendTxAddInput-variant MessageSendEvent
4030 pub extern "C" fn MessageSendEvent_send_tx_add_input(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxAddInput) -> MessageSendEvent {
4031 MessageSendEvent::SendTxAddInput {
4037 /// Utility method to constructs a new SendTxAddOutput-variant MessageSendEvent
4038 pub extern "C" fn MessageSendEvent_send_tx_add_output(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxAddOutput) -> MessageSendEvent {
4039 MessageSendEvent::SendTxAddOutput {
4045 /// Utility method to constructs a new SendTxRemoveInput-variant MessageSendEvent
4046 pub extern "C" fn MessageSendEvent_send_tx_remove_input(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxRemoveInput) -> MessageSendEvent {
4047 MessageSendEvent::SendTxRemoveInput {
4053 /// Utility method to constructs a new SendTxRemoveOutput-variant MessageSendEvent
4054 pub extern "C" fn MessageSendEvent_send_tx_remove_output(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxRemoveOutput) -> MessageSendEvent {
4055 MessageSendEvent::SendTxRemoveOutput {
4061 /// Utility method to constructs a new SendTxComplete-variant MessageSendEvent
4062 pub extern "C" fn MessageSendEvent_send_tx_complete(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxComplete) -> MessageSendEvent {
4063 MessageSendEvent::SendTxComplete {
4069 /// Utility method to constructs a new SendTxSignatures-variant MessageSendEvent
4070 pub extern "C" fn MessageSendEvent_send_tx_signatures(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxSignatures) -> MessageSendEvent {
4071 MessageSendEvent::SendTxSignatures {
4077 /// Utility method to constructs a new SendTxInitRbf-variant MessageSendEvent
4078 pub extern "C" fn MessageSendEvent_send_tx_init_rbf(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxInitRbf) -> MessageSendEvent {
4079 MessageSendEvent::SendTxInitRbf {
4085 /// Utility method to constructs a new SendTxAckRbf-variant MessageSendEvent
4086 pub extern "C" fn MessageSendEvent_send_tx_ack_rbf(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxAckRbf) -> MessageSendEvent {
4087 MessageSendEvent::SendTxAckRbf {
4093 /// Utility method to constructs a new SendTxAbort-variant MessageSendEvent
4094 pub extern "C" fn MessageSendEvent_send_tx_abort(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxAbort) -> MessageSendEvent {
4095 MessageSendEvent::SendTxAbort {
4101 /// Utility method to constructs a new SendChannelReady-variant MessageSendEvent
4102 pub extern "C" fn MessageSendEvent_send_channel_ready(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::ChannelReady) -> MessageSendEvent {
4103 MessageSendEvent::SendChannelReady {
4109 /// Utility method to constructs a new SendAnnouncementSignatures-variant MessageSendEvent
4110 pub extern "C" fn MessageSendEvent_send_announcement_signatures(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::AnnouncementSignatures) -> MessageSendEvent {
4111 MessageSendEvent::SendAnnouncementSignatures {
4117 /// Utility method to constructs a new UpdateHTLCs-variant MessageSendEvent
4118 pub extern "C" fn MessageSendEvent_update_htlcs(node_id: crate::c_types::PublicKey, updates: crate::lightning::ln::msgs::CommitmentUpdate) -> MessageSendEvent {
4119 MessageSendEvent::UpdateHTLCs {
4125 /// Utility method to constructs a new SendRevokeAndACK-variant MessageSendEvent
4126 pub extern "C" fn MessageSendEvent_send_revoke_and_ack(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::RevokeAndACK) -> MessageSendEvent {
4127 MessageSendEvent::SendRevokeAndACK {
4133 /// Utility method to constructs a new SendClosingSigned-variant MessageSendEvent
4134 pub extern "C" fn MessageSendEvent_send_closing_signed(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::ClosingSigned) -> MessageSendEvent {
4135 MessageSendEvent::SendClosingSigned {
4141 /// Utility method to constructs a new SendShutdown-variant MessageSendEvent
4142 pub extern "C" fn MessageSendEvent_send_shutdown(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::Shutdown) -> MessageSendEvent {
4143 MessageSendEvent::SendShutdown {
4149 /// Utility method to constructs a new SendChannelReestablish-variant MessageSendEvent
4150 pub extern "C" fn MessageSendEvent_send_channel_reestablish(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::ChannelReestablish) -> MessageSendEvent {
4151 MessageSendEvent::SendChannelReestablish {
4157 /// Utility method to constructs a new SendChannelAnnouncement-variant MessageSendEvent
4158 pub extern "C" fn MessageSendEvent_send_channel_announcement(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::ChannelAnnouncement, update_msg: crate::lightning::ln::msgs::ChannelUpdate) -> MessageSendEvent {
4159 MessageSendEvent::SendChannelAnnouncement {
4166 /// Utility method to constructs a new BroadcastChannelAnnouncement-variant MessageSendEvent
4167 pub extern "C" fn MessageSendEvent_broadcast_channel_announcement(msg: crate::lightning::ln::msgs::ChannelAnnouncement, update_msg: crate::lightning::ln::msgs::ChannelUpdate) -> MessageSendEvent {
4168 MessageSendEvent::BroadcastChannelAnnouncement {
4174 /// Utility method to constructs a new BroadcastChannelUpdate-variant MessageSendEvent
4175 pub extern "C" fn MessageSendEvent_broadcast_channel_update(msg: crate::lightning::ln::msgs::ChannelUpdate) -> MessageSendEvent {
4176 MessageSendEvent::BroadcastChannelUpdate {
4181 /// Utility method to constructs a new BroadcastNodeAnnouncement-variant MessageSendEvent
4182 pub extern "C" fn MessageSendEvent_broadcast_node_announcement(msg: crate::lightning::ln::msgs::NodeAnnouncement) -> MessageSendEvent {
4183 MessageSendEvent::BroadcastNodeAnnouncement {
4188 /// Utility method to constructs a new SendChannelUpdate-variant MessageSendEvent
4189 pub extern "C" fn MessageSendEvent_send_channel_update(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::ChannelUpdate) -> MessageSendEvent {
4190 MessageSendEvent::SendChannelUpdate {
4196 /// Utility method to constructs a new HandleError-variant MessageSendEvent
4197 pub extern "C" fn MessageSendEvent_handle_error(node_id: crate::c_types::PublicKey, action: crate::lightning::ln::msgs::ErrorAction) -> MessageSendEvent {
4198 MessageSendEvent::HandleError {
4204 /// Utility method to constructs a new SendChannelRangeQuery-variant MessageSendEvent
4205 pub extern "C" fn MessageSendEvent_send_channel_range_query(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::QueryChannelRange) -> MessageSendEvent {
4206 MessageSendEvent::SendChannelRangeQuery {
4212 /// Utility method to constructs a new SendShortIdsQuery-variant MessageSendEvent
4213 pub extern "C" fn MessageSendEvent_send_short_ids_query(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::QueryShortChannelIds) -> MessageSendEvent {
4214 MessageSendEvent::SendShortIdsQuery {
4220 /// Utility method to constructs a new SendReplyChannelRange-variant MessageSendEvent
4221 pub extern "C" fn MessageSendEvent_send_reply_channel_range(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::ReplyChannelRange) -> MessageSendEvent {
4222 MessageSendEvent::SendReplyChannelRange {
4228 /// Utility method to constructs a new SendGossipTimestampFilter-variant MessageSendEvent
4229 pub extern "C" fn MessageSendEvent_send_gossip_timestamp_filter(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::GossipTimestampFilter) -> MessageSendEvent {
4230 MessageSendEvent::SendGossipTimestampFilter {
4235 /// A trait indicating an object may generate message send events
4237 pub struct MessageSendEventsProvider {
4238 /// An opaque pointer which is passed to your function implementations as an argument.
4239 /// This has no meaning in the LDK, and can be NULL or any other value.
4240 pub this_arg: *mut c_void,
4241 /// Gets the list of pending events which were generated by previous actions, clearing the list
4243 pub get_and_clear_pending_msg_events: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_MessageSendEventZ,
4244 /// Frees any resources associated with this object given its this_arg pointer.
4245 /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4246 pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
4248 unsafe impl Send for MessageSendEventsProvider {}
4249 unsafe impl Sync for MessageSendEventsProvider {}
4250 pub(crate) fn MessageSendEventsProvider_clone_fields(orig: &MessageSendEventsProvider) -> MessageSendEventsProvider {
4251 MessageSendEventsProvider {
4252 this_arg: orig.this_arg,
4253 get_and_clear_pending_msg_events: Clone::clone(&orig.get_and_clear_pending_msg_events),
4254 free: Clone::clone(&orig.free),
4258 use lightning::events::MessageSendEventsProvider as rustMessageSendEventsProvider;
4259 impl rustMessageSendEventsProvider for MessageSendEventsProvider {
4260 fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::events::MessageSendEvent> {
4261 let mut ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
4262 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
4267 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
4268 // directly as a Deref trait in higher-level structs:
4269 impl core::ops::Deref for MessageSendEventsProvider {
4271 fn deref(&self) -> &Self {
4275 impl core::ops::DerefMut for MessageSendEventsProvider {
4276 fn deref_mut(&mut self) -> &mut Self {
4280 /// Calls the free function if one is set
4282 pub extern "C" fn MessageSendEventsProvider_free(this_ptr: MessageSendEventsProvider) { }
4283 impl Drop for MessageSendEventsProvider {
4284 fn drop(&mut self) {
4285 if let Some(f) = self.free {
4290 /// A trait indicating an object may generate onion messages to send
4292 pub struct OnionMessageProvider {
4293 /// An opaque pointer which is passed to your function implementations as an argument.
4294 /// This has no meaning in the LDK, and can be NULL or any other value.
4295 pub this_arg: *mut c_void,
4296 /// Gets the next pending onion message for the peer with the given node id.
4298 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4299 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,
4300 /// Frees any resources associated with this object given its this_arg pointer.
4301 /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4302 pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
4304 unsafe impl Send for OnionMessageProvider {}
4305 unsafe impl Sync for OnionMessageProvider {}
4306 pub(crate) fn OnionMessageProvider_clone_fields(orig: &OnionMessageProvider) -> OnionMessageProvider {
4307 OnionMessageProvider {
4308 this_arg: orig.this_arg,
4309 next_onion_message_for_peer: Clone::clone(&orig.next_onion_message_for_peer),
4310 free: Clone::clone(&orig.free),
4314 use lightning::events::OnionMessageProvider as rustOnionMessageProvider;
4315 impl rustOnionMessageProvider for OnionMessageProvider {
4316 fn next_onion_message_for_peer(&self, mut peer_node_id: bitcoin::secp256k1::PublicKey) -> Option<lightning::ln::msgs::OnionMessage> {
4317 let mut ret = (self.next_onion_message_for_peer)(self.this_arg, crate::c_types::PublicKey::from_rust(&peer_node_id));
4318 let mut local_ret = if ret.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(ret.take_inner()) } }) };
4323 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
4324 // directly as a Deref trait in higher-level structs:
4325 impl core::ops::Deref for OnionMessageProvider {
4327 fn deref(&self) -> &Self {
4331 impl core::ops::DerefMut for OnionMessageProvider {
4332 fn deref_mut(&mut self) -> &mut Self {
4336 /// Calls the free function if one is set
4338 pub extern "C" fn OnionMessageProvider_free(this_ptr: OnionMessageProvider) { }
4339 impl Drop for OnionMessageProvider {
4340 fn drop(&mut self) {
4341 if let Some(f) = self.free {
4346 /// A trait indicating an object may generate events.
4348 /// Events are processed by passing an [`EventHandler`] to [`process_pending_events`].
4350 /// Implementations of this trait may also feature an async version of event handling, as shown with
4351 /// [`ChannelManager::process_pending_events_async`] and
4352 /// [`ChainMonitor::process_pending_events_async`].
4356 /// When using this trait, [`process_pending_events`] will call [`handle_event`] for each pending
4357 /// event since the last invocation.
4359 /// In order to ensure no [`Event`]s are lost, implementors of this trait will persist [`Event`]s
4360 /// and replay any unhandled events on startup. An [`Event`] is considered handled when
4361 /// [`process_pending_events`] returns, thus handlers MUST fully handle [`Event`]s and persist any
4362 /// relevant changes to disk *before* returning.
4364 /// Further, because an application may crash between an [`Event`] being handled and the
4365 /// implementor of this trait being re-serialized, [`Event`] handling must be idempotent - in
4366 /// effect, [`Event`]s may be replayed.
4368 /// Note, handlers may call back into the provider and thus deadlocking must be avoided. Be sure to
4369 /// consult the provider's documentation on the implication of processing events and how a handler
4370 /// may safely use the provider (e.g., see [`ChannelManager::process_pending_events`] and
4371 /// [`ChainMonitor::process_pending_events`]).
4373 /// (C-not implementable) As there is likely no reason for a user to implement this trait on their
4376 /// [`process_pending_events`]: Self::process_pending_events
4377 /// [`handle_event`]: EventHandler::handle_event
4378 /// [`ChannelManager::process_pending_events`]: crate::ln::channelmanager::ChannelManager#method.process_pending_events
4379 /// [`ChainMonitor::process_pending_events`]: crate::chain::chainmonitor::ChainMonitor#method.process_pending_events
4380 /// [`ChannelManager::process_pending_events_async`]: crate::ln::channelmanager::ChannelManager::process_pending_events_async
4381 /// [`ChainMonitor::process_pending_events_async`]: crate::chain::chainmonitor::ChainMonitor::process_pending_events_async
4383 pub struct EventsProvider {
4384 /// An opaque pointer which is passed to your function implementations as an argument.
4385 /// This has no meaning in the LDK, and can be NULL or any other value.
4386 pub this_arg: *mut c_void,
4387 /// Processes any events generated since the last call using the given event handler.
4389 /// See the trait-level documentation for requirements.
4390 pub process_pending_events: extern "C" fn (this_arg: *const c_void, handler: crate::lightning::events::EventHandler),
4391 /// Frees any resources associated with this object given its this_arg pointer.
4392 /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4393 pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
4395 unsafe impl Send for EventsProvider {}
4396 unsafe impl Sync for EventsProvider {}
4397 pub(crate) fn EventsProvider_clone_fields(orig: &EventsProvider) -> EventsProvider {
4399 this_arg: orig.this_arg,
4400 process_pending_events: Clone::clone(&orig.process_pending_events),
4401 free: Clone::clone(&orig.free),
4405 use lightning::events::EventsProvider as rustEventsProvider;
4406 /// Calls the free function if one is set
4408 pub extern "C" fn EventsProvider_free(this_ptr: EventsProvider) { }
4409 impl Drop for EventsProvider {
4410 fn drop(&mut self) {
4411 if let Some(f) = self.free {
4416 /// A trait implemented for objects handling events from [`EventsProvider`].
4418 /// An async variation also exists for implementations of [`EventsProvider`] that support async
4419 /// event handling. The async event handler should satisfy the generic bounds: `F:
4420 /// core::future::Future, H: Fn(Event) -> F`.
4422 pub struct EventHandler {
4423 /// An opaque pointer which is passed to your function implementations as an argument.
4424 /// This has no meaning in the LDK, and can be NULL or any other value.
4425 pub this_arg: *mut c_void,
4426 /// Handles the given [`Event`].
4428 /// See [`EventsProvider`] for details that must be considered when implementing this method.
4429 pub handle_event: extern "C" fn (this_arg: *const c_void, event: crate::lightning::events::Event),
4430 /// Frees any resources associated with this object given its this_arg pointer.
4431 /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4432 pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
4434 unsafe impl Send for EventHandler {}
4435 unsafe impl Sync for EventHandler {}
4436 pub(crate) fn EventHandler_clone_fields(orig: &EventHandler) -> EventHandler {
4438 this_arg: orig.this_arg,
4439 handle_event: Clone::clone(&orig.handle_event),
4440 free: Clone::clone(&orig.free),
4444 use lightning::events::EventHandler as rustEventHandler;
4445 impl rustEventHandler for EventHandler {
4446 fn handle_event(&self, mut event: lightning::events::Event) {
4447 (self.handle_event)(self.this_arg, crate::lightning::events::Event::native_into(event))
4451 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
4452 // directly as a Deref trait in higher-level structs:
4453 impl core::ops::Deref for EventHandler {
4455 fn deref(&self) -> &Self {
4459 impl core::ops::DerefMut for EventHandler {
4460 fn deref_mut(&mut self) -> &mut Self {
4464 /// Calls the free function if one is set
4466 pub extern "C" fn EventHandler_free(this_ptr: EventHandler) { }
4467 impl Drop for EventHandler {
4468 fn drop(&mut self) {
4469 if let Some(f) = self.free {