X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Flightning%2Futil%2Fevents.rs;h=2d280f14f41d7fba1f07f7efbcc8985517ae94f8;hp=bb4fa57732e0c913e94066ee8fcfd122beec4732;hb=11b997c3a0452ea1da5b7b352e7887798105db29;hpb=c96981baf087d5441d079508ae71d2e046167ebf diff --git a/lightning-c-bindings/src/lightning/util/events.rs b/lightning-c-bindings/src/lightning/util/events.rs index bb4fa57..2d280f1 100644 --- a/lightning-c-bindings/src/lightning/util/events.rs +++ b/lightning-c-bindings/src/lightning/util/events.rs @@ -63,16 +63,16 @@ impl PaymentPurpose { pub(crate) fn to_native(&self) -> nativePaymentPurpose { match self { PaymentPurpose::InvoicePayment {ref payment_preimage, ref payment_secret, } => { - let mut payment_preimage_nonref = (*payment_preimage).clone(); + let mut payment_preimage_nonref = Clone::clone(payment_preimage); let mut local_payment_preimage_nonref = if payment_preimage_nonref.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentPreimage(payment_preimage_nonref.data) }) }; - let mut payment_secret_nonref = (*payment_secret).clone(); + let mut payment_secret_nonref = Clone::clone(payment_secret); nativePaymentPurpose::InvoicePayment { payment_preimage: local_payment_preimage_nonref, payment_secret: ::lightning::ln::PaymentSecret(payment_secret_nonref.data), } }, PaymentPurpose::SpontaneousPayment (ref a, ) => { - let mut a_nonref = (*a).clone(); + let mut a_nonref = Clone::clone(a); nativePaymentPurpose::SpontaneousPayment ( ::lightning::ln::PaymentPreimage(a_nonref.data), ) @@ -100,16 +100,16 @@ impl PaymentPurpose { pub(crate) fn from_native(native: &nativePaymentPurpose) -> Self { match native { nativePaymentPurpose::InvoicePayment {ref payment_preimage, ref payment_secret, } => { - let mut payment_preimage_nonref = (*payment_preimage).clone(); + let mut payment_preimage_nonref = Clone::clone(payment_preimage); let mut local_payment_preimage_nonref = if payment_preimage_nonref.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_preimage_nonref.unwrap()).0 } } }; - let mut payment_secret_nonref = (*payment_secret).clone(); + let mut payment_secret_nonref = Clone::clone(payment_secret); PaymentPurpose::InvoicePayment { payment_preimage: local_payment_preimage_nonref, payment_secret: crate::c_types::ThirtyTwoBytes { data: payment_secret_nonref.0 }, } }, nativePaymentPurpose::SpontaneousPayment (ref a, ) => { - let mut a_nonref = (*a).clone(); + let mut a_nonref = Clone::clone(a); PaymentPurpose::SpontaneousPayment ( crate::c_types::ThirtyTwoBytes { data: a_nonref.0 }, ) @@ -155,6 +155,12 @@ pub extern "C" fn PaymentPurpose_invoice_payment(payment_preimage: crate::c_type pub extern "C" fn PaymentPurpose_spontaneous_payment(a: crate::c_types::ThirtyTwoBytes) -> PaymentPurpose { PaymentPurpose::SpontaneousPayment(a, ) } +/// Checks if two PaymentPurposes contain equal inner contents. +/// This ignores pointers and is_owned flags and looks at the values in fields. +#[no_mangle] +pub extern "C" fn PaymentPurpose_eq(a: &PaymentPurpose, b: &PaymentPurpose) -> bool { + if &a.to_native() == &b.to_native() { true } else { false } +} #[no_mangle] /// Serialize the PaymentPurpose object into a byte array which can be read by PaymentPurpose_read pub extern "C" fn PaymentPurpose_write(obj: &crate::lightning::util::events::PaymentPurpose) -> crate::c_types::derived::CVec_u8Z { @@ -164,7 +170,145 @@ pub extern "C" fn PaymentPurpose_write(obj: &crate::lightning::util::events::Pay /// Read a PaymentPurpose from a byte array, created by PaymentPurpose_write pub extern "C" fn PaymentPurpose_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PaymentPurposeDecodeErrorZ { let res: Result = crate::c_types::deserialize_obj(ser); - let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::util::events::PaymentPurpose::native_into(o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() }; + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::util::events::PaymentPurpose::native_into(o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() }; + local_res +} +/// When the payment path failure took place and extra details about it. [`PathFailure::OnPath`] may +/// contain a [`NetworkUpdate`] that needs to be applied to the [`NetworkGraph`]. +/// +/// [`NetworkUpdate`]: crate::routing::gossip::NetworkUpdate +/// [`NetworkGraph`]: crate::routing::gossip::NetworkGraph +#[derive(Clone)] +#[must_use] +#[repr(C)] +pub enum PathFailure { + /// We failed to initially send the payment and no HTLC was committed to. Contains the relevant + /// error. + InitialSend { + /// The error surfaced from initial send. + err: crate::lightning::util::errors::APIError, + }, + /// A hop on the path failed to forward our payment. + OnPath { + /// If present, this [`NetworkUpdate`] should be applied to the [`NetworkGraph`] so that routing + /// decisions can take into account the update. + /// + /// [`NetworkUpdate`]: crate::routing::gossip::NetworkUpdate + /// [`NetworkGraph`]: crate::routing::gossip::NetworkGraph + network_update: crate::c_types::derived::COption_NetworkUpdateZ, + }, +} +use lightning::util::events::PathFailure as PathFailureImport; +pub(crate) type nativePathFailure = PathFailureImport; + +impl PathFailure { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativePathFailure { + match self { + PathFailure::InitialSend {ref err, } => { + let mut err_nonref = Clone::clone(err); + nativePathFailure::InitialSend { + err: err_nonref.into_native(), + } + }, + PathFailure::OnPath {ref network_update, } => { + let mut network_update_nonref = Clone::clone(network_update); + 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() }) } }; + nativePathFailure::OnPath { + network_update: local_network_update_nonref, + } + }, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativePathFailure { + match self { + PathFailure::InitialSend {mut err, } => { + nativePathFailure::InitialSend { + err: err.into_native(), + } + }, + PathFailure::OnPath {mut network_update, } => { + 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() }) } }; + nativePathFailure::OnPath { + network_update: local_network_update, + } + }, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativePathFailure) -> Self { + match native { + nativePathFailure::InitialSend {ref err, } => { + let mut err_nonref = Clone::clone(err); + PathFailure::InitialSend { + err: crate::lightning::util::errors::APIError::native_into(err_nonref), + } + }, + nativePathFailure::OnPath {ref network_update, } => { + let mut network_update_nonref = Clone::clone(network_update); + 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()) }) }; + PathFailure::OnPath { + network_update: local_network_update_nonref, + } + }, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativePathFailure) -> Self { + match native { + nativePathFailure::InitialSend {mut err, } => { + PathFailure::InitialSend { + err: crate::lightning::util::errors::APIError::native_into(err), + } + }, + nativePathFailure::OnPath {mut network_update, } => { + 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()) }) }; + PathFailure::OnPath { + network_update: local_network_update, + } + }, + } + } +} +/// Frees any resources used by the PathFailure +#[no_mangle] +pub extern "C" fn PathFailure_free(this_ptr: PathFailure) { } +/// Creates a copy of the PathFailure +#[no_mangle] +pub extern "C" fn PathFailure_clone(orig: &PathFailure) -> PathFailure { + orig.clone() +} +#[no_mangle] +/// Utility method to constructs a new InitialSend-variant PathFailure +pub extern "C" fn PathFailure_initial_send(err: crate::lightning::util::errors::APIError) -> PathFailure { + PathFailure::InitialSend { + err, + } +} +#[no_mangle] +/// Utility method to constructs a new OnPath-variant PathFailure +pub extern "C" fn PathFailure_on_path(network_update: crate::c_types::derived::COption_NetworkUpdateZ) -> PathFailure { + PathFailure::OnPath { + network_update, + } +} +/// Checks if two PathFailures contain equal inner contents. +/// This ignores pointers and is_owned flags and looks at the values in fields. +#[no_mangle] +pub extern "C" fn PathFailure_eq(a: &PathFailure, b: &PathFailure) -> bool { + if &a.to_native() == &b.to_native() { true } else { false } +} +#[no_mangle] +/// Serialize the PathFailure object into a byte array which can be read by PathFailure_read +pub extern "C" fn PathFailure_write(obj: &crate::lightning::util::events::PathFailure) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(&unsafe { &*obj }.to_native()) +} +#[no_mangle] +/// Read a PathFailure from a byte array, created by PathFailure_write +pub extern "C" fn PathFailure_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_PathFailureZDecodeErrorZ { + let res: Result, lightning::ln::msgs::DecodeError> = crate::c_types::maybe_deserialize_obj(ser); + 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::util::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() }; local_res } /// The reason the channel was closed. See individual variants more details. @@ -205,11 +349,19 @@ pub enum ClosureReason { /// The peer disconnected prior to funding completing. In this case the spec mandates that we /// forget the channel entirely - we can attempt again if the peer reconnects. /// + /// This includes cases where we restarted prior to funding completion, including prior to the + /// initial [`ChannelMonitor`] persistence completing. + /// /// In LDK versions prior to 0.0.107 this could also occur if we were unable to connect to the /// peer because of mutual incompatibility between us and our channel counterparty. + /// + /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor DisconnectedPeer, - /// Closure generated from `ChannelManager::read` if the ChannelMonitor is newer than - /// the ChannelManager deserialized. + /// Closure generated from `ChannelManager::read` if the [`ChannelMonitor`] is newer than + /// the [`ChannelManager`] deserialized. + /// + /// [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor + /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager OutdatedChannelManager, } use lightning::util::events::ClosureReason as ClosureReasonImport; @@ -220,7 +372,7 @@ impl ClosureReason { pub(crate) fn to_native(&self) -> nativeClosureReason { match self { ClosureReason::CounterpartyForceClosed {ref peer_msg, } => { - let mut peer_msg_nonref = (*peer_msg).clone(); + let mut peer_msg_nonref = Clone::clone(peer_msg); nativeClosureReason::CounterpartyForceClosed { peer_msg: peer_msg_nonref.into_string(), } @@ -230,7 +382,7 @@ impl ClosureReason { ClosureReason::CommitmentTxConfirmed => nativeClosureReason::CommitmentTxConfirmed, ClosureReason::FundingTimedOut => nativeClosureReason::FundingTimedOut, ClosureReason::ProcessingError {ref err, } => { - let mut err_nonref = (*err).clone(); + let mut err_nonref = Clone::clone(err); nativeClosureReason::ProcessingError { err: err_nonref.into_string(), } @@ -264,7 +416,7 @@ impl ClosureReason { pub(crate) fn from_native(native: &nativeClosureReason) -> Self { match native { nativeClosureReason::CounterpartyForceClosed {ref peer_msg, } => { - let mut peer_msg_nonref = (*peer_msg).clone(); + let mut peer_msg_nonref = Clone::clone(peer_msg); ClosureReason::CounterpartyForceClosed { peer_msg: peer_msg_nonref.into(), } @@ -274,7 +426,7 @@ impl ClosureReason { nativeClosureReason::CommitmentTxConfirmed => ClosureReason::CommitmentTxConfirmed, nativeClosureReason::FundingTimedOut => ClosureReason::FundingTimedOut, nativeClosureReason::ProcessingError {ref err, } => { - let mut err_nonref = (*err).clone(); + let mut err_nonref = Clone::clone(err); ClosureReason::ProcessingError { err: err_nonref.into(), } @@ -351,6 +503,12 @@ pub extern "C" fn ClosureReason_disconnected_peer() -> ClosureReason { /// Utility method to constructs a new OutdatedChannelManager-variant ClosureReason pub extern "C" fn ClosureReason_outdated_channel_manager() -> ClosureReason { ClosureReason::OutdatedChannelManager} +/// Checks if two ClosureReasons contain equal inner contents. +/// This ignores pointers and is_owned flags and looks at the values in fields. +#[no_mangle] +pub extern "C" fn ClosureReason_eq(a: &ClosureReason, b: &ClosureReason) -> bool { + if &a.to_native() == &b.to_native() { true } else { false } +} #[no_mangle] /// Serialize the ClosureReason object into a byte array which can be read by ClosureReason_read pub extern "C" fn ClosureReason_write(obj: &crate::lightning::util::events::ClosureReason) -> crate::c_types::derived::CVec_u8Z { @@ -360,7 +518,7 @@ pub extern "C" fn ClosureReason_write(obj: &crate::lightning::util::events::Clos /// Read a ClosureReason from a byte array, created by ClosureReason_write pub extern "C" fn ClosureReason_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_ClosureReasonZDecodeErrorZ { let res: Result, lightning::ln::msgs::DecodeError> = crate::c_types::maybe_deserialize_obj(ser); - 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::util::events::ClosureReason::native_into(o.unwrap()) }) }; local_res_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() }; + 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::util::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() }; local_res } /// Intended destination of a failed HTLC as indicated in [`Event::HTLCHandlingFailed`]. @@ -385,6 +543,12 @@ pub enum HTLCDestination { /// Short channel id we are requesting to forward an HTLC to. requested_forward_scid: u64, }, + /// We couldn't forward to the outgoing scid. An example would be attempting to send a duplicate + /// intercept HTLC. + InvalidForward { + /// Short channel id we are requesting to forward an HTLC to. + requested_forward_scid: u64, + }, /// Failure scenario where an HTLC may have been forwarded to be intended for us, /// but is invalid for some reason, so we reject it. /// @@ -405,22 +569,28 @@ impl HTLCDestination { pub(crate) fn to_native(&self) -> nativeHTLCDestination { match self { HTLCDestination::NextHopChannel {ref node_id, ref channel_id, } => { - let mut node_id_nonref = (*node_id).clone(); + let mut node_id_nonref = Clone::clone(node_id); let mut local_node_id_nonref = if node_id_nonref.is_null() { None } else { Some( { node_id_nonref.into_rust() }) }; - let mut channel_id_nonref = (*channel_id).clone(); + let mut channel_id_nonref = Clone::clone(channel_id); nativeHTLCDestination::NextHopChannel { node_id: local_node_id_nonref, channel_id: channel_id_nonref.data, } }, HTLCDestination::UnknownNextHop {ref requested_forward_scid, } => { - let mut requested_forward_scid_nonref = (*requested_forward_scid).clone(); + let mut requested_forward_scid_nonref = Clone::clone(requested_forward_scid); nativeHTLCDestination::UnknownNextHop { requested_forward_scid: requested_forward_scid_nonref, } }, + HTLCDestination::InvalidForward {ref requested_forward_scid, } => { + let mut requested_forward_scid_nonref = Clone::clone(requested_forward_scid); + nativeHTLCDestination::InvalidForward { + requested_forward_scid: requested_forward_scid_nonref, + } + }, HTLCDestination::FailedPayment {ref payment_hash, } => { - let mut payment_hash_nonref = (*payment_hash).clone(); + let mut payment_hash_nonref = Clone::clone(payment_hash); nativeHTLCDestination::FailedPayment { payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data), } @@ -442,6 +612,11 @@ impl HTLCDestination { requested_forward_scid: requested_forward_scid, } }, + HTLCDestination::InvalidForward {mut requested_forward_scid, } => { + nativeHTLCDestination::InvalidForward { + requested_forward_scid: requested_forward_scid, + } + }, HTLCDestination::FailedPayment {mut payment_hash, } => { nativeHTLCDestination::FailedPayment { payment_hash: ::lightning::ln::PaymentHash(payment_hash.data), @@ -453,22 +628,28 @@ impl HTLCDestination { pub(crate) fn from_native(native: &nativeHTLCDestination) -> Self { match native { nativeHTLCDestination::NextHopChannel {ref node_id, ref channel_id, } => { - let mut node_id_nonref = (*node_id).clone(); + let mut node_id_nonref = Clone::clone(node_id); 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())) } }; - let mut channel_id_nonref = (*channel_id).clone(); + let mut channel_id_nonref = Clone::clone(channel_id); HTLCDestination::NextHopChannel { node_id: local_node_id_nonref, channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref }, } }, nativeHTLCDestination::UnknownNextHop {ref requested_forward_scid, } => { - let mut requested_forward_scid_nonref = (*requested_forward_scid).clone(); + let mut requested_forward_scid_nonref = Clone::clone(requested_forward_scid); HTLCDestination::UnknownNextHop { requested_forward_scid: requested_forward_scid_nonref, } }, + nativeHTLCDestination::InvalidForward {ref requested_forward_scid, } => { + let mut requested_forward_scid_nonref = Clone::clone(requested_forward_scid); + HTLCDestination::InvalidForward { + requested_forward_scid: requested_forward_scid_nonref, + } + }, nativeHTLCDestination::FailedPayment {ref payment_hash, } => { - let mut payment_hash_nonref = (*payment_hash).clone(); + let mut payment_hash_nonref = Clone::clone(payment_hash); HTLCDestination::FailedPayment { payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 }, } @@ -490,6 +671,11 @@ impl HTLCDestination { requested_forward_scid: requested_forward_scid, } }, + nativeHTLCDestination::InvalidForward {mut requested_forward_scid, } => { + HTLCDestination::InvalidForward { + requested_forward_scid: requested_forward_scid, + } + }, nativeHTLCDestination::FailedPayment {mut payment_hash, } => { HTLCDestination::FailedPayment { payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 }, @@ -522,12 +708,25 @@ pub extern "C" fn HTLCDestination_unknown_next_hop(requested_forward_scid: u64) } } #[no_mangle] +/// Utility method to constructs a new InvalidForward-variant HTLCDestination +pub extern "C" fn HTLCDestination_invalid_forward(requested_forward_scid: u64) -> HTLCDestination { + HTLCDestination::InvalidForward { + requested_forward_scid, + } +} +#[no_mangle] /// Utility method to constructs a new FailedPayment-variant HTLCDestination pub extern "C" fn HTLCDestination_failed_payment(payment_hash: crate::c_types::ThirtyTwoBytes) -> HTLCDestination { HTLCDestination::FailedPayment { payment_hash, } } +/// Checks if two HTLCDestinations contain equal inner contents. +/// This ignores pointers and is_owned flags and looks at the values in fields. +#[no_mangle] +pub extern "C" fn HTLCDestination_eq(a: &HTLCDestination, b: &HTLCDestination) -> bool { + if &a.to_native() == &b.to_native() { true } else { false } +} #[no_mangle] /// Serialize the HTLCDestination object into a byte array which can be read by HTLCDestination_read pub extern "C" fn HTLCDestination_write(obj: &crate::lightning::util::events::HTLCDestination) -> crate::c_types::derived::CVec_u8Z { @@ -537,7 +736,7 @@ pub extern "C" fn HTLCDestination_write(obj: &crate::lightning::util::events::HT /// Read a HTLCDestination from a byte array, created by HTLCDestination_write pub extern "C" fn HTLCDestination_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_HTLCDestinationZDecodeErrorZ { let res: Result, lightning::ln::msgs::DecodeError> = crate::c_types::maybe_deserialize_obj(ser); - 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::util::events::HTLCDestination::native_into(o.unwrap()) }) }; local_res_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() }; + 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::util::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() }; local_res } /// An Event which you should probably take some action in response to. @@ -572,29 +771,43 @@ pub enum Event { channel_value_satoshis: u64, /// The script which should be used in the transaction output. output_script: crate::c_types::derived::CVec_u8Z, - /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`], or 0 for - /// an inbound channel. + /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`], or a + /// random value for an inbound channel. This may be zero for objects serialized with LDK + /// versions prior to 0.0.113. /// /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel - user_channel_id: u64, + user_channel_id: crate::c_types::U128, }, - /// Indicates we've received (an offer of) money! Just gotta dig out that payment preimage and - /// feed it to [`ChannelManager::claim_funds`] to get it.... + /// Indicates that we've been offered a payment and it needs to be claimed via calling + /// [`ChannelManager::claim_funds`] with the preimage given in [`PaymentPurpose`]. /// /// Note that if the preimage is not known, you should call - /// [`ChannelManager::fail_htlc_backwards`] to free up resources for this HTLC and avoid - /// network congestion. - /// If you fail to call either [`ChannelManager::claim_funds`] or - /// [`ChannelManager::fail_htlc_backwards`] within the HTLC's timeout, the HTLC will be + /// [`ChannelManager::fail_htlc_backwards`] or [`ChannelManager::fail_htlc_backwards_with_reason`] + /// to free up resources for this HTLC and avoid network congestion. + /// If you fail to call either [`ChannelManager::claim_funds`], [`ChannelManager::fail_htlc_backwards`], + /// or [`ChannelManager::fail_htlc_backwards_with_reason`] within the HTLC's timeout, the HTLC will be /// automatically failed. /// /// # Note /// LDK will not stop an inbound payment from being paid multiple times, so multiple - /// `PaymentReceived` events may be generated for the same payment. + /// `PaymentClaimable` events may be generated for the same payment. + /// + /// # Note + /// This event used to be called `PaymentReceived` in LDK versions 0.0.112 and earlier. /// /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds /// [`ChannelManager::fail_htlc_backwards`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards - PaymentReceived { + /// [`ChannelManager::fail_htlc_backwards_with_reason`]: crate::ln::channelmanager::ChannelManager::fail_htlc_backwards_with_reason + PaymentClaimable { + /// The node that will receive the payment after it has been claimed. + /// This is useful to identify payments received via [phantom nodes]. + /// This field will always be filled in when the event was generated by LDK versions + /// 0.0.113 and above. + /// + /// [phantom nodes]: crate::chain::keysinterface::PhantomKeysManager + /// + /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None + receiver_node_id: crate::c_types::PublicKey, /// The hash for which the preimage should be handed to the ChannelManager. Note that LDK will /// not stop you from registering duplicate payment hashes for inbound payments. payment_hash: crate::c_types::ThirtyTwoBytes, @@ -603,28 +816,43 @@ pub enum Event { /// Information for claiming this received payment, based on whether the purpose of the /// payment is to pay an invoice or to send a spontaneous payment. purpose: crate::lightning::util::events::PaymentPurpose, + /// The `channel_id` indicating over which channel we received the payment. + /// + /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None + via_channel_id: crate::c_types::ThirtyTwoBytes, + /// The `user_channel_id` indicating over which channel we received the payment. + via_user_channel_id: crate::c_types::derived::COption_u128Z, }, /// Indicates a payment has been claimed and we've received money! /// /// This most likely occurs when [`ChannelManager::claim_funds`] has been called in response - /// to an [`Event::PaymentReceived`]. However, if we previously crashed during a + /// to an [`Event::PaymentClaimable`]. However, if we previously crashed during a /// [`ChannelManager::claim_funds`] call you may see this event without a corresponding - /// [`Event::PaymentReceived`] event. + /// [`Event::PaymentClaimable`] event. /// /// # Note /// LDK will not stop an inbound payment from being paid multiple times, so multiple - /// `PaymentReceived` events may be generated for the same payment. If you then call - /// [`ChannelManager::claim_funds`] twice for the same [`Event::PaymentReceived`] you may get + /// `PaymentClaimable` events may be generated for the same payment. If you then call + /// [`ChannelManager::claim_funds`] twice for the same [`Event::PaymentClaimable`] you may get /// multiple `PaymentClaimed` events. /// /// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds PaymentClaimed { + /// The node that received the payment. + /// This is useful to identify payments which were received via [phantom nodes]. + /// This field will always be filled in when the event was generated by LDK versions + /// 0.0.113 and above. + /// + /// [phantom nodes]: crate::chain::keysinterface::PhantomKeysManager + /// + /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None + receiver_node_id: crate::c_types::PublicKey, /// The payment hash of the claimed payment. Note that LDK will not stop you from /// registering duplicate payment hashes for inbound payments. payment_hash: crate::c_types::ThirtyTwoBytes, /// The value, in thousandths of a satoshi, that this payment is for. amount_msat: u64, - /// The purpose of this claimed payment, i.e. whether the payment was for an invoice or a + /// The purpose of the claimed payment, i.e. whether the payment was for an invoice or a /// spontaneous payment. purpose: crate::lightning::util::events::PaymentPurpose, }, @@ -634,11 +862,9 @@ pub enum Event { /// Note for MPP payments: in rare cases, this event may be preceded by a `PaymentPathFailed` /// event. In this situation, you SHOULD treat this payment as having succeeded. PaymentSent { - /// The id returned by [`ChannelManager::send_payment`] and used with - /// [`ChannelManager::retry_payment`]. + /// The id returned by [`ChannelManager::send_payment`]. /// /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment - /// [`ChannelManager::retry_payment`]: crate::ln::channelmanager::ChannelManager::retry_payment /// /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None payment_id: crate::c_types::ThirtyTwoBytes, @@ -662,19 +888,19 @@ pub enum Event { fee_paid_msat: crate::c_types::derived::COption_u64Z, }, /// Indicates an outbound payment failed. Individual [`Event::PaymentPathFailed`] events - /// provide failure information for each MPP part in the payment. + /// provide failure information for each path attempt in the payment, including retries. /// /// This event is provided once there are no further pending HTLCs for the payment and the - /// payment is no longer retryable, either due to a several-block timeout or because - /// [`ChannelManager::abandon_payment`] was previously called for the corresponding payment. + /// payment is no longer retryable, due either to the [`Retry`] provided or + /// [`ChannelManager::abandon_payment`] having been called for the corresponding payment. /// + /// [`Retry`]: crate::ln::channelmanager::Retry /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment PaymentFailed { /// The id returned by [`ChannelManager::send_payment`] and used with - /// [`ChannelManager::retry_payment`] and [`ChannelManager::abandon_payment`]. + /// [`ChannelManager::abandon_payment`]. /// /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment - /// [`ChannelManager::retry_payment`]: crate::ln::channelmanager::ChannelManager::retry_payment /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment payment_id: crate::c_types::ThirtyTwoBytes, /// The hash that was given to [`ChannelManager::send_payment`]. @@ -687,11 +913,9 @@ pub enum Event { /// Always generated after [`Event::PaymentSent`] and thus useful for scoring channels. See /// [`Event::PaymentSent`] for obtaining the payment preimage. PaymentPathSuccessful { - /// The id returned by [`ChannelManager::send_payment`] and used with - /// [`ChannelManager::retry_payment`]. + /// The id returned by [`ChannelManager::send_payment`]. /// /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment - /// [`ChannelManager::retry_payment`]: crate::ln::channelmanager::ChannelManager::retry_payment payment_id: crate::c_types::ThirtyTwoBytes, /// The hash that was given to [`ChannelManager::send_payment`]. /// @@ -704,19 +928,21 @@ pub enum Event { /// May contain a closed channel if the HTLC sent along the path was fulfilled on chain. path: crate::c_types::derived::CVec_RouteHopZ, }, - /// Indicates an outbound HTLC we sent failed. Probably some intermediary node dropped - /// something. You may wish to retry with a different route. + /// Indicates an outbound HTLC we sent failed, likely due to an intermediary node being unable to + /// handle the HTLC. /// /// Note that this does *not* indicate that all paths for an MPP payment have failed, see - /// [`Event::PaymentFailed`] and [`all_paths_failed`]. + /// [`Event::PaymentFailed`]. /// - /// [`all_paths_failed`]: Self::PaymentPathFailed::all_paths_failed + /// See [`ChannelManager::abandon_payment`] for giving up on this payment before its retries have + /// been exhausted. + /// + /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment PaymentPathFailed { /// The id returned by [`ChannelManager::send_payment`] and used with - /// [`ChannelManager::retry_payment`] and [`ChannelManager::abandon_payment`]. + /// [`ChannelManager::abandon_payment`]. /// /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment - /// [`ChannelManager::retry_payment`]: crate::ln::channelmanager::ChannelManager::retry_payment /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment /// /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None @@ -726,35 +952,14 @@ pub enum Event { /// [`ChannelManager::send_payment`]: crate::ln::channelmanager::ChannelManager::send_payment payment_hash: crate::c_types::ThirtyTwoBytes, /// Indicates the payment was rejected for some reason by the recipient. This implies that - /// the payment has failed, not just the route in question. If this is not set, you may - /// retry the payment via a different route. + /// the payment has failed, not just the route in question. If this is not set, the payment may + /// be retried via a different route. payment_failed_permanently: bool, - /// Any failure information conveyed via the Onion return packet by a node along the failed - /// payment route. - /// - /// Should be applied to the [`NetworkGraph`] so that routing decisions can take into - /// account the update. + /// Extra error details based on the failure type. May contain an update that needs to be + /// applied to the [`NetworkGraph`]. /// /// [`NetworkGraph`]: crate::routing::gossip::NetworkGraph - network_update: crate::c_types::derived::COption_NetworkUpdateZ, - /// For both single-path and multi-path payments, this is set if all paths of the payment have - /// failed. This will be set to false if (1) this is an MPP payment and (2) other parts of the - /// larger MPP payment were still in flight when this event was generated. - /// - /// Note that if you are retrying individual MPP parts, using this value to determine if a - /// payment has fully failed is race-y. Because multiple failures can happen prior to events - /// being processed, you may retry in response to a first failure, with a second failure - /// (with `all_paths_failed` set) still pending. Then, when the second failure is processed - /// you will see `all_paths_failed` set even though the retry of the first failure still - /// has an associated in-flight HTLC. See (1) for an example of such a failure. - /// - /// If you wish to retry individual MPP parts and learn when a payment has failed, you must - /// call [`ChannelManager::abandon_payment`] and wait for a [`Event::PaymentFailed`] event. - /// - /// (1) - /// - /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment - all_paths_failed: bool, + failure: crate::lightning::util::events::PathFailure, /// The payment path that failed. path: crate::c_types::derived::CVec_RouteHopZ, /// The channel responsible for the failed payment path. @@ -766,12 +971,9 @@ pub enum Event { /// If this is `Some`, then the corresponding channel should be avoided when the payment is /// retried. May be `None` for older [`Event`] serializations. short_channel_id: crate::c_types::derived::COption_u64Z, - /// Parameters needed to compute a new [`Route`] when retrying the failed payment path. - /// - /// See [`find_route`] for details. + /// Parameters used by LDK to compute a new [`Route`] when retrying the failed payment path. /// /// [`Route`]: crate::routing::router::Route - /// [`find_route`]: crate::routing::router::find_route /// /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None retry: crate::lightning::routing::router::RouteParameters, @@ -819,6 +1021,38 @@ pub enum Event { /// now + 5*time_forwardable). time_forwardable: u64, }, + /// Used to indicate that we've intercepted an HTLC forward. This event will only be generated if + /// you've encoded an intercept scid in the receiver's invoice route hints using + /// [`ChannelManager::get_intercept_scid`] and have set [`UserConfig::accept_intercept_htlcs`]. + /// + /// [`ChannelManager::forward_intercepted_htlc`] or + /// [`ChannelManager::fail_intercepted_htlc`] MUST be called in response to this event. See + /// their docs for more information. + /// + /// [`ChannelManager::get_intercept_scid`]: crate::ln::channelmanager::ChannelManager::get_intercept_scid + /// [`UserConfig::accept_intercept_htlcs`]: crate::util::config::UserConfig::accept_intercept_htlcs + /// [`ChannelManager::forward_intercepted_htlc`]: crate::ln::channelmanager::ChannelManager::forward_intercepted_htlc + /// [`ChannelManager::fail_intercepted_htlc`]: crate::ln::channelmanager::ChannelManager::fail_intercepted_htlc + HTLCIntercepted { + /// An id to help LDK identify which HTLC is being forwarded or failed. + intercept_id: crate::c_types::ThirtyTwoBytes, + /// The fake scid that was programmed as the next hop's scid, generated using + /// [`ChannelManager::get_intercept_scid`]. + /// + /// [`ChannelManager::get_intercept_scid`]: crate::ln::channelmanager::ChannelManager::get_intercept_scid + requested_next_hop_scid: u64, + /// The payment hash used for this HTLC. + payment_hash: crate::c_types::ThirtyTwoBytes, + /// How many msats were received on the inbound edge of this HTLC. + inbound_amount_msat: u64, + /// How many msats the payer intended to route to the next node. Depending on the reason you are + /// intercepting this payment, you might take a fee by forwarding less than this amount. + /// + /// Note that LDK will NOT check that expected fees were factored into this value. You MUST + /// check that whatever fee you want has been included here or subtract it as required. Further, + /// LDK will not stop you from forwarding more than you received. + expected_outbound_amount_msat: u64, + }, /// Used to indicate that an output which you should know how to spend was confirmed on chain /// and is now spendable. /// Such an output will *not* ever be spent by rust-lightning, and are not at risk of your @@ -859,6 +1093,27 @@ pub enum Event { /// transaction. claim_from_onchain_tx: bool, }, + /// Used to indicate that a channel with the given `channel_id` is ready to + /// be used. This event is emitted either when the funding transaction has been confirmed + /// on-chain, or, in case of a 0conf channel, when both parties have confirmed the channel + /// establishment. + ChannelReady { + /// The channel_id of the channel that is ready. + channel_id: crate::c_types::ThirtyTwoBytes, + /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound + /// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if + /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise + /// `user_channel_id` will be randomized for an inbound channel. + /// + /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel + /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel + /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels + user_channel_id: crate::c_types::U128, + /// The node_id of the channel counterparty. + counterparty_node_id: crate::c_types::PublicKey, + /// The features that this channel will operate with. + channel_type: crate::lightning::ln::features::ChannelTypeFeatures, + }, /// Used to indicate that a previously opened channel with the given `channel_id` is in the /// process of closure. ChannelClosed { @@ -868,13 +1123,14 @@ pub enum Event { /// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound /// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if /// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise - /// `user_channel_id` will be 0 for an inbound channel. - /// This will always be zero for objects serialized with LDK versions prior to 0.0.102. + /// `user_channel_id` will be randomized for inbound channels. + /// This may be zero for inbound channels serialized prior to 0.0.113 and will always be + /// zero for objects serialized with LDK versions prior to 0.0.102. /// /// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel /// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel /// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels - user_channel_id: u64, + user_channel_id: crate::c_types::U128, /// The reason the channel was closed. reason: crate::lightning::util::events::ClosureReason, }, @@ -965,45 +1221,57 @@ impl Event { pub(crate) fn to_native(&self) -> nativeEvent { match self { Event::FundingGenerationReady {ref temporary_channel_id, ref counterparty_node_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => { - let mut temporary_channel_id_nonref = (*temporary_channel_id).clone(); - let mut counterparty_node_id_nonref = (*counterparty_node_id).clone(); - let mut channel_value_satoshis_nonref = (*channel_value_satoshis).clone(); - let mut output_script_nonref = (*output_script).clone(); - let mut user_channel_id_nonref = (*user_channel_id).clone(); + let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id); + let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); + let mut channel_value_satoshis_nonref = Clone::clone(channel_value_satoshis); + let mut output_script_nonref = Clone::clone(output_script); + let mut user_channel_id_nonref = Clone::clone(user_channel_id); nativeEvent::FundingGenerationReady { temporary_channel_id: temporary_channel_id_nonref.data, counterparty_node_id: counterparty_node_id_nonref.into_rust(), channel_value_satoshis: channel_value_satoshis_nonref, output_script: ::bitcoin::blockdata::script::Script::from(output_script_nonref.into_rust()), - user_channel_id: user_channel_id_nonref, - } - }, - Event::PaymentReceived {ref payment_hash, ref amount_msat, ref purpose, } => { - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut amount_msat_nonref = (*amount_msat).clone(); - let mut purpose_nonref = (*purpose).clone(); - nativeEvent::PaymentReceived { + user_channel_id: user_channel_id_nonref.into(), + } + }, + Event::PaymentClaimable {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, ref via_channel_id, ref via_user_channel_id, } => { + let mut receiver_node_id_nonref = Clone::clone(receiver_node_id); + let mut local_receiver_node_id_nonref = if receiver_node_id_nonref.is_null() { None } else { Some( { receiver_node_id_nonref.into_rust() }) }; + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut amount_msat_nonref = Clone::clone(amount_msat); + let mut purpose_nonref = Clone::clone(purpose); + let mut via_channel_id_nonref = Clone::clone(via_channel_id); + let mut local_via_channel_id_nonref = if via_channel_id_nonref.data == [0; 32] { None } else { Some( { via_channel_id_nonref.data }) }; + let mut via_user_channel_id_nonref = Clone::clone(via_user_channel_id); + let mut local_via_user_channel_id_nonref = { /* via_user_channel_id_nonref*/ let via_user_channel_id_nonref_opt = via_user_channel_id_nonref; { } if via_user_channel_id_nonref_opt.is_none() { None } else { Some({ via_user_channel_id_nonref_opt.take().into() }) } }; + nativeEvent::PaymentClaimable { + receiver_node_id: local_receiver_node_id_nonref, payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data), amount_msat: amount_msat_nonref, purpose: purpose_nonref.into_native(), + via_channel_id: local_via_channel_id_nonref, + via_user_channel_id: local_via_user_channel_id_nonref, } }, - Event::PaymentClaimed {ref payment_hash, ref amount_msat, ref purpose, } => { - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut amount_msat_nonref = (*amount_msat).clone(); - let mut purpose_nonref = (*purpose).clone(); + Event::PaymentClaimed {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, } => { + let mut receiver_node_id_nonref = Clone::clone(receiver_node_id); + let mut local_receiver_node_id_nonref = if receiver_node_id_nonref.is_null() { None } else { Some( { receiver_node_id_nonref.into_rust() }) }; + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut amount_msat_nonref = Clone::clone(amount_msat); + let mut purpose_nonref = Clone::clone(purpose); nativeEvent::PaymentClaimed { + receiver_node_id: local_receiver_node_id_nonref, payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data), amount_msat: amount_msat_nonref, purpose: purpose_nonref.into_native(), } }, Event::PaymentSent {ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat, } => { - let mut payment_id_nonref = (*payment_id).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); let mut local_payment_id_nonref = if payment_id_nonref.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data) }) }; - let mut payment_preimage_nonref = (*payment_preimage).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut fee_paid_msat_nonref = (*fee_paid_msat).clone(); + let mut payment_preimage_nonref = Clone::clone(payment_preimage); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut fee_paid_msat_nonref = Clone::clone(fee_paid_msat); let mut local_fee_paid_msat_nonref = if fee_paid_msat_nonref.is_some() { Some( { fee_paid_msat_nonref.take() }) } else { None }; nativeEvent::PaymentSent { payment_id: local_payment_id_nonref, @@ -1013,18 +1281,18 @@ impl Event { } }, Event::PaymentFailed {ref payment_id, ref payment_hash, } => { - let mut payment_id_nonref = (*payment_id).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); + let mut payment_hash_nonref = Clone::clone(payment_hash); nativeEvent::PaymentFailed { payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data), payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data), } }, Event::PaymentPathSuccessful {ref payment_id, ref payment_hash, ref path, } => { - let mut payment_id_nonref = (*payment_id).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); + let mut payment_hash_nonref = Clone::clone(payment_hash); let mut local_payment_hash_nonref = if payment_hash_nonref.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentHash(payment_hash_nonref.data) }) }; - let mut path_nonref = (*path).clone(); + let mut path_nonref = Clone::clone(path); let mut local_path_nonref = Vec::new(); for mut item in path_nonref.into_rust().drain(..) { local_path_nonref.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; nativeEvent::PaymentPathSuccessful { payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data), @@ -1032,35 +1300,32 @@ impl Event { path: local_path_nonref, } }, - Event::PaymentPathFailed {ref payment_id, ref payment_hash, ref payment_failed_permanently, ref network_update, ref all_paths_failed, ref path, ref short_channel_id, ref retry, } => { - let mut payment_id_nonref = (*payment_id).clone(); + Event::PaymentPathFailed {ref payment_id, ref payment_hash, ref payment_failed_permanently, ref failure, ref path, ref short_channel_id, ref retry, } => { + let mut payment_id_nonref = Clone::clone(payment_id); let mut local_payment_id_nonref = if payment_id_nonref.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data) }) }; - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut payment_failed_permanently_nonref = (*payment_failed_permanently).clone(); - let mut network_update_nonref = (*network_update).clone(); - 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() }) } }; - let mut all_paths_failed_nonref = (*all_paths_failed).clone(); - let mut path_nonref = (*path).clone(); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut payment_failed_permanently_nonref = Clone::clone(payment_failed_permanently); + let mut failure_nonref = Clone::clone(failure); + let mut path_nonref = Clone::clone(path); let mut local_path_nonref = Vec::new(); for mut item in path_nonref.into_rust().drain(..) { local_path_nonref.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; - let mut short_channel_id_nonref = (*short_channel_id).clone(); + let mut short_channel_id_nonref = Clone::clone(short_channel_id); let mut local_short_channel_id_nonref = if short_channel_id_nonref.is_some() { Some( { short_channel_id_nonref.take() }) } else { None }; - let mut retry_nonref = (*retry).clone(); + let mut retry_nonref = Clone::clone(retry); let mut local_retry_nonref = if retry_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(retry_nonref.take_inner()) } }) }; nativeEvent::PaymentPathFailed { payment_id: local_payment_id_nonref, payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data), payment_failed_permanently: payment_failed_permanently_nonref, - network_update: local_network_update_nonref, - all_paths_failed: all_paths_failed_nonref, + failure: failure_nonref.into_native(), path: local_path_nonref, short_channel_id: local_short_channel_id_nonref, retry: local_retry_nonref, } }, Event::ProbeSuccessful {ref payment_id, ref payment_hash, ref path, } => { - let mut payment_id_nonref = (*payment_id).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut path_nonref = (*path).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut path_nonref = Clone::clone(path); let mut local_path_nonref = Vec::new(); for mut item in path_nonref.into_rust().drain(..) { local_path_nonref.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; nativeEvent::ProbeSuccessful { payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data), @@ -1069,11 +1334,11 @@ impl Event { } }, Event::ProbeFailed {ref payment_id, ref payment_hash, ref path, ref short_channel_id, } => { - let mut payment_id_nonref = (*payment_id).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut path_nonref = (*path).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut path_nonref = Clone::clone(path); let mut local_path_nonref = Vec::new(); for mut item in path_nonref.into_rust().drain(..) { local_path_nonref.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; - let mut short_channel_id_nonref = (*short_channel_id).clone(); + let mut short_channel_id_nonref = Clone::clone(short_channel_id); let mut local_short_channel_id_nonref = if short_channel_id_nonref.is_some() { Some( { short_channel_id_nonref.take() }) } else { None }; nativeEvent::ProbeFailed { payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data), @@ -1083,26 +1348,40 @@ impl Event { } }, Event::PendingHTLCsForwardable {ref time_forwardable, } => { - let mut time_forwardable_nonref = (*time_forwardable).clone(); + let mut time_forwardable_nonref = Clone::clone(time_forwardable); nativeEvent::PendingHTLCsForwardable { time_forwardable: core::time::Duration::from_secs(time_forwardable_nonref), } }, + Event::HTLCIntercepted {ref intercept_id, ref requested_next_hop_scid, ref payment_hash, ref inbound_amount_msat, ref expected_outbound_amount_msat, } => { + let mut intercept_id_nonref = Clone::clone(intercept_id); + let mut requested_next_hop_scid_nonref = Clone::clone(requested_next_hop_scid); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut inbound_amount_msat_nonref = Clone::clone(inbound_amount_msat); + let mut expected_outbound_amount_msat_nonref = Clone::clone(expected_outbound_amount_msat); + nativeEvent::HTLCIntercepted { + intercept_id: ::lightning::ln::channelmanager::InterceptId(intercept_id_nonref.data), + requested_next_hop_scid: requested_next_hop_scid_nonref, + payment_hash: ::lightning::ln::PaymentHash(payment_hash_nonref.data), + inbound_amount_msat: inbound_amount_msat_nonref, + expected_outbound_amount_msat: expected_outbound_amount_msat_nonref, + } + }, Event::SpendableOutputs {ref outputs, } => { - let mut outputs_nonref = (*outputs).clone(); + let mut outputs_nonref = Clone::clone(outputs); let mut local_outputs_nonref = Vec::new(); for mut item in outputs_nonref.into_rust().drain(..) { local_outputs_nonref.push( { item.into_native() }); }; nativeEvent::SpendableOutputs { outputs: local_outputs_nonref, } }, Event::PaymentForwarded {ref prev_channel_id, ref next_channel_id, ref fee_earned_msat, ref claim_from_onchain_tx, } => { - let mut prev_channel_id_nonref = (*prev_channel_id).clone(); + let mut prev_channel_id_nonref = Clone::clone(prev_channel_id); let mut local_prev_channel_id_nonref = if prev_channel_id_nonref.data == [0; 32] { None } else { Some( { prev_channel_id_nonref.data }) }; - let mut next_channel_id_nonref = (*next_channel_id).clone(); + let mut next_channel_id_nonref = Clone::clone(next_channel_id); let mut local_next_channel_id_nonref = if next_channel_id_nonref.data == [0; 32] { None } else { Some( { next_channel_id_nonref.data }) }; - let mut fee_earned_msat_nonref = (*fee_earned_msat).clone(); + let mut fee_earned_msat_nonref = Clone::clone(fee_earned_msat); let mut local_fee_earned_msat_nonref = if fee_earned_msat_nonref.is_some() { Some( { fee_earned_msat_nonref.take() }) } else { None }; - let mut claim_from_onchain_tx_nonref = (*claim_from_onchain_tx).clone(); + let mut claim_from_onchain_tx_nonref = Clone::clone(claim_from_onchain_tx); nativeEvent::PaymentForwarded { prev_channel_id: local_prev_channel_id_nonref, next_channel_id: local_next_channel_id_nonref, @@ -1110,30 +1389,42 @@ impl Event { claim_from_onchain_tx: claim_from_onchain_tx_nonref, } }, + Event::ChannelReady {ref channel_id, ref user_channel_id, ref counterparty_node_id, ref channel_type, } => { + let mut channel_id_nonref = Clone::clone(channel_id); + let mut user_channel_id_nonref = Clone::clone(user_channel_id); + let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); + let mut channel_type_nonref = Clone::clone(channel_type); + nativeEvent::ChannelReady { + channel_id: channel_id_nonref.data, + user_channel_id: user_channel_id_nonref.into(), + counterparty_node_id: counterparty_node_id_nonref.into_rust(), + channel_type: *unsafe { Box::from_raw(channel_type_nonref.take_inner()) }, + } + }, Event::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, } => { - let mut channel_id_nonref = (*channel_id).clone(); - let mut user_channel_id_nonref = (*user_channel_id).clone(); - let mut reason_nonref = (*reason).clone(); + let mut channel_id_nonref = Clone::clone(channel_id); + let mut user_channel_id_nonref = Clone::clone(user_channel_id); + let mut reason_nonref = Clone::clone(reason); nativeEvent::ChannelClosed { channel_id: channel_id_nonref.data, - user_channel_id: user_channel_id_nonref, + user_channel_id: user_channel_id_nonref.into(), reason: reason_nonref.into_native(), } }, Event::DiscardFunding {ref channel_id, ref transaction, } => { - let mut channel_id_nonref = (*channel_id).clone(); - let mut transaction_nonref = (*transaction).clone(); + let mut channel_id_nonref = Clone::clone(channel_id); + let mut transaction_nonref = Clone::clone(transaction); nativeEvent::DiscardFunding { channel_id: channel_id_nonref.data, transaction: transaction_nonref.into_bitcoin(), } }, Event::OpenChannelRequest {ref temporary_channel_id, ref counterparty_node_id, ref funding_satoshis, ref push_msat, ref channel_type, } => { - let mut temporary_channel_id_nonref = (*temporary_channel_id).clone(); - let mut counterparty_node_id_nonref = (*counterparty_node_id).clone(); - let mut funding_satoshis_nonref = (*funding_satoshis).clone(); - let mut push_msat_nonref = (*push_msat).clone(); - let mut channel_type_nonref = (*channel_type).clone(); + let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id); + let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); + let mut funding_satoshis_nonref = Clone::clone(funding_satoshis); + let mut push_msat_nonref = Clone::clone(push_msat); + let mut channel_type_nonref = Clone::clone(channel_type); nativeEvent::OpenChannelRequest { temporary_channel_id: temporary_channel_id_nonref.data, counterparty_node_id: counterparty_node_id_nonref.into_rust(), @@ -1143,8 +1434,8 @@ impl Event { } }, Event::HTLCHandlingFailed {ref prev_channel_id, ref failed_next_destination, } => { - let mut prev_channel_id_nonref = (*prev_channel_id).clone(); - let mut failed_next_destination_nonref = (*failed_next_destination).clone(); + let mut prev_channel_id_nonref = Clone::clone(prev_channel_id); + let mut failed_next_destination_nonref = Clone::clone(failed_next_destination); nativeEvent::HTLCHandlingFailed { prev_channel_id: prev_channel_id_nonref.data, failed_next_destination: failed_next_destination_nonref.into_native(), @@ -1161,18 +1452,26 @@ impl Event { counterparty_node_id: counterparty_node_id.into_rust(), channel_value_satoshis: channel_value_satoshis, output_script: ::bitcoin::blockdata::script::Script::from(output_script.into_rust()), - user_channel_id: user_channel_id, + user_channel_id: user_channel_id.into(), } }, - Event::PaymentReceived {mut payment_hash, mut amount_msat, mut purpose, } => { - nativeEvent::PaymentReceived { + Event::PaymentClaimable {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, mut via_channel_id, mut via_user_channel_id, } => { + let mut local_receiver_node_id = if receiver_node_id.is_null() { None } else { Some( { receiver_node_id.into_rust() }) }; + let mut local_via_channel_id = if via_channel_id.data == [0; 32] { None } else { Some( { via_channel_id.data }) }; + let mut local_via_user_channel_id = { /* via_user_channel_id*/ let via_user_channel_id_opt = via_user_channel_id; { } if via_user_channel_id_opt.is_none() { None } else { Some({ via_user_channel_id_opt.take().into() }) } }; + nativeEvent::PaymentClaimable { + receiver_node_id: local_receiver_node_id, payment_hash: ::lightning::ln::PaymentHash(payment_hash.data), amount_msat: amount_msat, purpose: purpose.into_native(), + via_channel_id: local_via_channel_id, + via_user_channel_id: local_via_user_channel_id, } }, - Event::PaymentClaimed {mut payment_hash, mut amount_msat, mut purpose, } => { + Event::PaymentClaimed {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, } => { + let mut local_receiver_node_id = if receiver_node_id.is_null() { None } else { Some( { receiver_node_id.into_rust() }) }; nativeEvent::PaymentClaimed { + receiver_node_id: local_receiver_node_id, payment_hash: ::lightning::ln::PaymentHash(payment_hash.data), amount_msat: amount_msat, purpose: purpose.into_native(), @@ -1203,9 +1502,8 @@ impl Event { path: local_path, } }, - Event::PaymentPathFailed {mut payment_id, mut payment_hash, mut payment_failed_permanently, mut network_update, mut all_paths_failed, mut path, mut short_channel_id, mut retry, } => { + Event::PaymentPathFailed {mut payment_id, mut payment_hash, mut payment_failed_permanently, mut failure, mut path, mut short_channel_id, mut retry, } => { let mut local_payment_id = if payment_id.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentId(payment_id.data) }) }; - 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() }) } }; let mut local_path = Vec::new(); for mut item in path.into_rust().drain(..) { local_path.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; let mut local_short_channel_id = if short_channel_id.is_some() { Some( { short_channel_id.take() }) } else { None }; let mut local_retry = if retry.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(retry.take_inner()) } }) }; @@ -1213,8 +1511,7 @@ impl Event { payment_id: local_payment_id, payment_hash: ::lightning::ln::PaymentHash(payment_hash.data), payment_failed_permanently: payment_failed_permanently, - network_update: local_network_update, - all_paths_failed: all_paths_failed, + failure: failure.into_native(), path: local_path, short_channel_id: local_short_channel_id, retry: local_retry, @@ -1243,6 +1540,15 @@ impl Event { time_forwardable: core::time::Duration::from_secs(time_forwardable), } }, + Event::HTLCIntercepted {mut intercept_id, mut requested_next_hop_scid, mut payment_hash, mut inbound_amount_msat, mut expected_outbound_amount_msat, } => { + nativeEvent::HTLCIntercepted { + intercept_id: ::lightning::ln::channelmanager::InterceptId(intercept_id.data), + requested_next_hop_scid: requested_next_hop_scid, + payment_hash: ::lightning::ln::PaymentHash(payment_hash.data), + inbound_amount_msat: inbound_amount_msat, + expected_outbound_amount_msat: expected_outbound_amount_msat, + } + }, Event::SpendableOutputs {mut outputs, } => { let mut local_outputs = Vec::new(); for mut item in outputs.into_rust().drain(..) { local_outputs.push( { item.into_native() }); }; nativeEvent::SpendableOutputs { @@ -1260,10 +1566,18 @@ impl Event { claim_from_onchain_tx: claim_from_onchain_tx, } }, + Event::ChannelReady {mut channel_id, mut user_channel_id, mut counterparty_node_id, mut channel_type, } => { + nativeEvent::ChannelReady { + channel_id: channel_id.data, + user_channel_id: user_channel_id.into(), + counterparty_node_id: counterparty_node_id.into_rust(), + channel_type: *unsafe { Box::from_raw(channel_type.take_inner()) }, + } + }, Event::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, } => { nativeEvent::ChannelClosed { channel_id: channel_id.data, - user_channel_id: user_channel_id, + user_channel_id: user_channel_id.into(), reason: reason.into_native(), } }, @@ -1294,45 +1608,57 @@ impl Event { pub(crate) fn from_native(native: &nativeEvent) -> Self { match native { nativeEvent::FundingGenerationReady {ref temporary_channel_id, ref counterparty_node_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => { - let mut temporary_channel_id_nonref = (*temporary_channel_id).clone(); - let mut counterparty_node_id_nonref = (*counterparty_node_id).clone(); - let mut channel_value_satoshis_nonref = (*channel_value_satoshis).clone(); - let mut output_script_nonref = (*output_script).clone(); - let mut user_channel_id_nonref = (*user_channel_id).clone(); + let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id); + let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); + let mut channel_value_satoshis_nonref = Clone::clone(channel_value_satoshis); + let mut output_script_nonref = Clone::clone(output_script); + let mut user_channel_id_nonref = Clone::clone(user_channel_id); Event::FundingGenerationReady { temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref }, counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref), channel_value_satoshis: channel_value_satoshis_nonref, output_script: output_script_nonref.into_bytes().into(), - user_channel_id: user_channel_id_nonref, - } - }, - nativeEvent::PaymentReceived {ref payment_hash, ref amount_msat, ref purpose, } => { - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut amount_msat_nonref = (*amount_msat).clone(); - let mut purpose_nonref = (*purpose).clone(); - Event::PaymentReceived { + user_channel_id: user_channel_id_nonref.into(), + } + }, + nativeEvent::PaymentClaimable {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, ref via_channel_id, ref via_user_channel_id, } => { + let mut receiver_node_id_nonref = Clone::clone(receiver_node_id); + let mut local_receiver_node_id_nonref = if receiver_node_id_nonref.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(receiver_node_id_nonref.unwrap())) } }; + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut amount_msat_nonref = Clone::clone(amount_msat); + let mut purpose_nonref = Clone::clone(purpose); + let mut via_channel_id_nonref = Clone::clone(via_channel_id); + let mut local_via_channel_id_nonref = if via_channel_id_nonref.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (via_channel_id_nonref.unwrap()) } } }; + let mut via_user_channel_id_nonref = Clone::clone(via_user_channel_id); + let mut local_via_user_channel_id_nonref = if via_user_channel_id_nonref.is_none() { crate::c_types::derived::COption_u128Z::None } else { crate::c_types::derived::COption_u128Z::Some( { via_user_channel_id_nonref.unwrap().into() }) }; + Event::PaymentClaimable { + receiver_node_id: local_receiver_node_id_nonref, payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 }, amount_msat: amount_msat_nonref, purpose: crate::lightning::util::events::PaymentPurpose::native_into(purpose_nonref), + via_channel_id: local_via_channel_id_nonref, + via_user_channel_id: local_via_user_channel_id_nonref, } }, - nativeEvent::PaymentClaimed {ref payment_hash, ref amount_msat, ref purpose, } => { - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut amount_msat_nonref = (*amount_msat).clone(); - let mut purpose_nonref = (*purpose).clone(); + nativeEvent::PaymentClaimed {ref receiver_node_id, ref payment_hash, ref amount_msat, ref purpose, } => { + let mut receiver_node_id_nonref = Clone::clone(receiver_node_id); + let mut local_receiver_node_id_nonref = if receiver_node_id_nonref.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(receiver_node_id_nonref.unwrap())) } }; + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut amount_msat_nonref = Clone::clone(amount_msat); + let mut purpose_nonref = Clone::clone(purpose); Event::PaymentClaimed { + receiver_node_id: local_receiver_node_id_nonref, payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 }, amount_msat: amount_msat_nonref, purpose: crate::lightning::util::events::PaymentPurpose::native_into(purpose_nonref), } }, nativeEvent::PaymentSent {ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat, } => { - let mut payment_id_nonref = (*payment_id).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); let mut local_payment_id_nonref = if payment_id_nonref.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_id_nonref.unwrap()).0 } } }; - let mut payment_preimage_nonref = (*payment_preimage).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut fee_paid_msat_nonref = (*fee_paid_msat).clone(); + let mut payment_preimage_nonref = Clone::clone(payment_preimage); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut fee_paid_msat_nonref = Clone::clone(fee_paid_msat); 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() }) }; Event::PaymentSent { payment_id: local_payment_id_nonref, @@ -1342,18 +1668,18 @@ impl Event { } }, nativeEvent::PaymentFailed {ref payment_id, ref payment_hash, } => { - let mut payment_id_nonref = (*payment_id).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); + let mut payment_hash_nonref = Clone::clone(payment_hash); Event::PaymentFailed { payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 }, payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 }, } }, nativeEvent::PaymentPathSuccessful {ref payment_id, ref payment_hash, ref path, } => { - let mut payment_id_nonref = (*payment_id).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); + let mut payment_hash_nonref = Clone::clone(payment_hash); let mut local_payment_hash_nonref = if payment_hash_nonref.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_hash_nonref.unwrap()).0 } } }; - let mut path_nonref = (*path).clone(); + let mut path_nonref = Clone::clone(path); let mut local_path_nonref = Vec::new(); for mut item in path_nonref.drain(..) { local_path_nonref.push( { crate::lightning::routing::router::RouteHop { inner: ObjOps::heap_alloc(item), is_owned: true } }); }; Event::PaymentPathSuccessful { payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 }, @@ -1361,35 +1687,32 @@ impl Event { path: local_path_nonref.into(), } }, - nativeEvent::PaymentPathFailed {ref payment_id, ref payment_hash, ref payment_failed_permanently, ref network_update, ref all_paths_failed, ref path, ref short_channel_id, ref retry, } => { - let mut payment_id_nonref = (*payment_id).clone(); + nativeEvent::PaymentPathFailed {ref payment_id, ref payment_hash, ref payment_failed_permanently, ref failure, ref path, ref short_channel_id, ref retry, } => { + let mut payment_id_nonref = Clone::clone(payment_id); let mut local_payment_id_nonref = if payment_id_nonref.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_id_nonref.unwrap()).0 } } }; - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut payment_failed_permanently_nonref = (*payment_failed_permanently).clone(); - let mut network_update_nonref = (*network_update).clone(); - 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()) }) }; - let mut all_paths_failed_nonref = (*all_paths_failed).clone(); - let mut path_nonref = (*path).clone(); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut payment_failed_permanently_nonref = Clone::clone(payment_failed_permanently); + let mut failure_nonref = Clone::clone(failure); + let mut path_nonref = Clone::clone(path); let mut local_path_nonref = Vec::new(); for mut item in path_nonref.drain(..) { local_path_nonref.push( { crate::lightning::routing::router::RouteHop { inner: ObjOps::heap_alloc(item), is_owned: true } }); }; - let mut short_channel_id_nonref = (*short_channel_id).clone(); + let mut short_channel_id_nonref = Clone::clone(short_channel_id); 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() }) }; - let mut retry_nonref = (*retry).clone(); + let mut retry_nonref = Clone::clone(retry); let mut local_retry_nonref = crate::lightning::routing::router::RouteParameters { inner: if retry_nonref.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((retry_nonref.unwrap())) } }, is_owned: true }; Event::PaymentPathFailed { payment_id: local_payment_id_nonref, payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 }, payment_failed_permanently: payment_failed_permanently_nonref, - network_update: local_network_update_nonref, - all_paths_failed: all_paths_failed_nonref, + failure: crate::lightning::util::events::PathFailure::native_into(failure_nonref), path: local_path_nonref.into(), short_channel_id: local_short_channel_id_nonref, retry: local_retry_nonref, } }, nativeEvent::ProbeSuccessful {ref payment_id, ref payment_hash, ref path, } => { - let mut payment_id_nonref = (*payment_id).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut path_nonref = (*path).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut path_nonref = Clone::clone(path); let mut local_path_nonref = Vec::new(); for mut item in path_nonref.drain(..) { local_path_nonref.push( { crate::lightning::routing::router::RouteHop { inner: ObjOps::heap_alloc(item), is_owned: true } }); }; Event::ProbeSuccessful { payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 }, @@ -1398,11 +1721,11 @@ impl Event { } }, nativeEvent::ProbeFailed {ref payment_id, ref payment_hash, ref path, ref short_channel_id, } => { - let mut payment_id_nonref = (*payment_id).clone(); - let mut payment_hash_nonref = (*payment_hash).clone(); - let mut path_nonref = (*path).clone(); + let mut payment_id_nonref = Clone::clone(payment_id); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut path_nonref = Clone::clone(path); let mut local_path_nonref = Vec::new(); for mut item in path_nonref.drain(..) { local_path_nonref.push( { crate::lightning::routing::router::RouteHop { inner: ObjOps::heap_alloc(item), is_owned: true } }); }; - let mut short_channel_id_nonref = (*short_channel_id).clone(); + let mut short_channel_id_nonref = Clone::clone(short_channel_id); 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() }) }; Event::ProbeFailed { payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 }, @@ -1412,26 +1735,40 @@ impl Event { } }, nativeEvent::PendingHTLCsForwardable {ref time_forwardable, } => { - let mut time_forwardable_nonref = (*time_forwardable).clone(); + let mut time_forwardable_nonref = Clone::clone(time_forwardable); Event::PendingHTLCsForwardable { time_forwardable: time_forwardable_nonref.as_secs(), } }, + nativeEvent::HTLCIntercepted {ref intercept_id, ref requested_next_hop_scid, ref payment_hash, ref inbound_amount_msat, ref expected_outbound_amount_msat, } => { + let mut intercept_id_nonref = Clone::clone(intercept_id); + let mut requested_next_hop_scid_nonref = Clone::clone(requested_next_hop_scid); + let mut payment_hash_nonref = Clone::clone(payment_hash); + let mut inbound_amount_msat_nonref = Clone::clone(inbound_amount_msat); + let mut expected_outbound_amount_msat_nonref = Clone::clone(expected_outbound_amount_msat); + Event::HTLCIntercepted { + intercept_id: crate::c_types::ThirtyTwoBytes { data: intercept_id_nonref.0 }, + requested_next_hop_scid: requested_next_hop_scid_nonref, + payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 }, + inbound_amount_msat: inbound_amount_msat_nonref, + expected_outbound_amount_msat: expected_outbound_amount_msat_nonref, + } + }, nativeEvent::SpendableOutputs {ref outputs, } => { - let mut outputs_nonref = (*outputs).clone(); + let mut outputs_nonref = Clone::clone(outputs); let mut local_outputs_nonref = Vec::new(); for mut item in outputs_nonref.drain(..) { local_outputs_nonref.push( { crate::lightning::chain::keysinterface::SpendableOutputDescriptor::native_into(item) }); }; Event::SpendableOutputs { outputs: local_outputs_nonref.into(), } }, nativeEvent::PaymentForwarded {ref prev_channel_id, ref next_channel_id, ref fee_earned_msat, ref claim_from_onchain_tx, } => { - let mut prev_channel_id_nonref = (*prev_channel_id).clone(); + let mut prev_channel_id_nonref = Clone::clone(prev_channel_id); let mut local_prev_channel_id_nonref = if prev_channel_id_nonref.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (prev_channel_id_nonref.unwrap()) } } }; - let mut next_channel_id_nonref = (*next_channel_id).clone(); + let mut next_channel_id_nonref = Clone::clone(next_channel_id); let mut local_next_channel_id_nonref = if next_channel_id_nonref.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (next_channel_id_nonref.unwrap()) } } }; - let mut fee_earned_msat_nonref = (*fee_earned_msat).clone(); + let mut fee_earned_msat_nonref = Clone::clone(fee_earned_msat); let mut local_fee_earned_msat_nonref = if fee_earned_msat_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { fee_earned_msat_nonref.unwrap() }) }; - let mut claim_from_onchain_tx_nonref = (*claim_from_onchain_tx).clone(); + let mut claim_from_onchain_tx_nonref = Clone::clone(claim_from_onchain_tx); Event::PaymentForwarded { prev_channel_id: local_prev_channel_id_nonref, next_channel_id: local_next_channel_id_nonref, @@ -1439,30 +1776,42 @@ impl Event { claim_from_onchain_tx: claim_from_onchain_tx_nonref, } }, + nativeEvent::ChannelReady {ref channel_id, ref user_channel_id, ref counterparty_node_id, ref channel_type, } => { + let mut channel_id_nonref = Clone::clone(channel_id); + let mut user_channel_id_nonref = Clone::clone(user_channel_id); + let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); + let mut channel_type_nonref = Clone::clone(channel_type); + Event::ChannelReady { + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref }, + user_channel_id: user_channel_id_nonref.into(), + counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref), + channel_type: crate::lightning::ln::features::ChannelTypeFeatures { inner: ObjOps::heap_alloc(channel_type_nonref), is_owned: true }, + } + }, nativeEvent::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, } => { - let mut channel_id_nonref = (*channel_id).clone(); - let mut user_channel_id_nonref = (*user_channel_id).clone(); - let mut reason_nonref = (*reason).clone(); + let mut channel_id_nonref = Clone::clone(channel_id); + let mut user_channel_id_nonref = Clone::clone(user_channel_id); + let mut reason_nonref = Clone::clone(reason); Event::ChannelClosed { channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref }, - user_channel_id: user_channel_id_nonref, + user_channel_id: user_channel_id_nonref.into(), reason: crate::lightning::util::events::ClosureReason::native_into(reason_nonref), } }, nativeEvent::DiscardFunding {ref channel_id, ref transaction, } => { - let mut channel_id_nonref = (*channel_id).clone(); - let mut transaction_nonref = (*transaction).clone(); + let mut channel_id_nonref = Clone::clone(channel_id); + let mut transaction_nonref = Clone::clone(transaction); Event::DiscardFunding { channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref }, transaction: crate::c_types::Transaction::from_bitcoin(&transaction_nonref), } }, nativeEvent::OpenChannelRequest {ref temporary_channel_id, ref counterparty_node_id, ref funding_satoshis, ref push_msat, ref channel_type, } => { - let mut temporary_channel_id_nonref = (*temporary_channel_id).clone(); - let mut counterparty_node_id_nonref = (*counterparty_node_id).clone(); - let mut funding_satoshis_nonref = (*funding_satoshis).clone(); - let mut push_msat_nonref = (*push_msat).clone(); - let mut channel_type_nonref = (*channel_type).clone(); + let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id); + let mut counterparty_node_id_nonref = Clone::clone(counterparty_node_id); + let mut funding_satoshis_nonref = Clone::clone(funding_satoshis); + let mut push_msat_nonref = Clone::clone(push_msat); + let mut channel_type_nonref = Clone::clone(channel_type); Event::OpenChannelRequest { temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref }, counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref), @@ -1472,8 +1821,8 @@ impl Event { } }, nativeEvent::HTLCHandlingFailed {ref prev_channel_id, ref failed_next_destination, } => { - let mut prev_channel_id_nonref = (*prev_channel_id).clone(); - let mut failed_next_destination_nonref = (*failed_next_destination).clone(); + let mut prev_channel_id_nonref = Clone::clone(prev_channel_id); + let mut failed_next_destination_nonref = Clone::clone(failed_next_destination); Event::HTLCHandlingFailed { prev_channel_id: crate::c_types::ThirtyTwoBytes { data: prev_channel_id_nonref }, failed_next_destination: crate::lightning::util::events::HTLCDestination::native_into(failed_next_destination_nonref), @@ -1490,18 +1839,26 @@ impl Event { counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id), channel_value_satoshis: channel_value_satoshis, output_script: output_script.into_bytes().into(), - user_channel_id: user_channel_id, + user_channel_id: user_channel_id.into(), } }, - nativeEvent::PaymentReceived {mut payment_hash, mut amount_msat, mut purpose, } => { - Event::PaymentReceived { + nativeEvent::PaymentClaimable {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, mut via_channel_id, mut via_user_channel_id, } => { + let mut local_receiver_node_id = if receiver_node_id.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(receiver_node_id.unwrap())) } }; + let mut local_via_channel_id = if via_channel_id.is_none() { crate::c_types::ThirtyTwoBytes { data: [0; 32] } } else { { crate::c_types::ThirtyTwoBytes { data: (via_channel_id.unwrap()) } } }; + let mut local_via_user_channel_id = if via_user_channel_id.is_none() { crate::c_types::derived::COption_u128Z::None } else { crate::c_types::derived::COption_u128Z::Some( { via_user_channel_id.unwrap().into() }) }; + Event::PaymentClaimable { + receiver_node_id: local_receiver_node_id, payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 }, amount_msat: amount_msat, purpose: crate::lightning::util::events::PaymentPurpose::native_into(purpose), + via_channel_id: local_via_channel_id, + via_user_channel_id: local_via_user_channel_id, } }, - nativeEvent::PaymentClaimed {mut payment_hash, mut amount_msat, mut purpose, } => { + nativeEvent::PaymentClaimed {mut receiver_node_id, mut payment_hash, mut amount_msat, mut purpose, } => { + 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())) } }; Event::PaymentClaimed { + receiver_node_id: local_receiver_node_id, payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 }, amount_msat: amount_msat, purpose: crate::lightning::util::events::PaymentPurpose::native_into(purpose), @@ -1532,9 +1889,8 @@ impl Event { path: local_path.into(), } }, - nativeEvent::PaymentPathFailed {mut payment_id, mut payment_hash, mut payment_failed_permanently, mut network_update, mut all_paths_failed, mut path, mut short_channel_id, mut retry, } => { + nativeEvent::PaymentPathFailed {mut payment_id, mut payment_hash, mut payment_failed_permanently, mut failure, mut path, mut short_channel_id, mut retry, } => { let mut local_payment_id = if payment_id.is_none() { crate::c_types::ThirtyTwoBytes::null() } else { { crate::c_types::ThirtyTwoBytes { data: (payment_id.unwrap()).0 } } }; - 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()) }) }; let mut local_path = Vec::new(); for mut item in path.drain(..) { local_path.push( { crate::lightning::routing::router::RouteHop { inner: ObjOps::heap_alloc(item), is_owned: true } }); }; 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() }) }; let mut local_retry = crate::lightning::routing::router::RouteParameters { inner: if retry.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((retry.unwrap())) } }, is_owned: true }; @@ -1542,8 +1898,7 @@ impl Event { payment_id: local_payment_id, payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 }, payment_failed_permanently: payment_failed_permanently, - network_update: local_network_update, - all_paths_failed: all_paths_failed, + failure: crate::lightning::util::events::PathFailure::native_into(failure), path: local_path.into(), short_channel_id: local_short_channel_id, retry: local_retry, @@ -1572,6 +1927,15 @@ impl Event { time_forwardable: time_forwardable.as_secs(), } }, + nativeEvent::HTLCIntercepted {mut intercept_id, mut requested_next_hop_scid, mut payment_hash, mut inbound_amount_msat, mut expected_outbound_amount_msat, } => { + Event::HTLCIntercepted { + intercept_id: crate::c_types::ThirtyTwoBytes { data: intercept_id.0 }, + requested_next_hop_scid: requested_next_hop_scid, + payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 }, + inbound_amount_msat: inbound_amount_msat, + expected_outbound_amount_msat: expected_outbound_amount_msat, + } + }, nativeEvent::SpendableOutputs {mut outputs, } => { let mut local_outputs = Vec::new(); for mut item in outputs.drain(..) { local_outputs.push( { crate::lightning::chain::keysinterface::SpendableOutputDescriptor::native_into(item) }); }; Event::SpendableOutputs { @@ -1589,10 +1953,18 @@ impl Event { claim_from_onchain_tx: claim_from_onchain_tx, } }, + nativeEvent::ChannelReady {mut channel_id, mut user_channel_id, mut counterparty_node_id, mut channel_type, } => { + Event::ChannelReady { + channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id }, + user_channel_id: user_channel_id.into(), + counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id), + channel_type: crate::lightning::ln::features::ChannelTypeFeatures { inner: ObjOps::heap_alloc(channel_type), is_owned: true }, + } + }, nativeEvent::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, } => { Event::ChannelClosed { channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id }, - user_channel_id: user_channel_id, + user_channel_id: user_channel_id.into(), reason: crate::lightning::util::events::ClosureReason::native_into(reason), } }, @@ -1630,7 +2002,7 @@ pub extern "C" fn Event_clone(orig: &Event) -> Event { } #[no_mangle] /// Utility method to constructs a new FundingGenerationReady-variant Event -pub extern "C" fn Event_funding_generation_ready(temporary_channel_id: crate::c_types::ThirtyTwoBytes, counterparty_node_id: crate::c_types::PublicKey, channel_value_satoshis: u64, output_script: crate::c_types::derived::CVec_u8Z, user_channel_id: u64) -> Event { +pub extern "C" fn Event_funding_generation_ready(temporary_channel_id: crate::c_types::ThirtyTwoBytes, counterparty_node_id: crate::c_types::PublicKey, channel_value_satoshis: u64, output_script: crate::c_types::derived::CVec_u8Z, user_channel_id: crate::c_types::U128) -> Event { Event::FundingGenerationReady { temporary_channel_id, counterparty_node_id, @@ -1640,18 +2012,22 @@ pub extern "C" fn Event_funding_generation_ready(temporary_channel_id: crate::c_ } } #[no_mangle] -/// Utility method to constructs a new PaymentReceived-variant Event -pub extern "C" fn Event_payment_received(payment_hash: crate::c_types::ThirtyTwoBytes, amount_msat: u64, purpose: crate::lightning::util::events::PaymentPurpose) -> Event { - Event::PaymentReceived { +/// Utility method to constructs a new PaymentClaimable-variant Event +pub extern "C" fn Event_payment_claimable(receiver_node_id: crate::c_types::PublicKey, payment_hash: crate::c_types::ThirtyTwoBytes, amount_msat: u64, purpose: crate::lightning::util::events::PaymentPurpose, via_channel_id: crate::c_types::ThirtyTwoBytes, via_user_channel_id: crate::c_types::derived::COption_u128Z) -> Event { + Event::PaymentClaimable { + receiver_node_id, payment_hash, amount_msat, purpose, + via_channel_id, + via_user_channel_id, } } #[no_mangle] /// Utility method to constructs a new PaymentClaimed-variant Event -pub extern "C" fn Event_payment_claimed(payment_hash: crate::c_types::ThirtyTwoBytes, amount_msat: u64, purpose: crate::lightning::util::events::PaymentPurpose) -> Event { +pub extern "C" fn Event_payment_claimed(receiver_node_id: crate::c_types::PublicKey, payment_hash: crate::c_types::ThirtyTwoBytes, amount_msat: u64, purpose: crate::lightning::util::events::PaymentPurpose) -> Event { Event::PaymentClaimed { + receiver_node_id, payment_hash, amount_msat, purpose, @@ -1686,13 +2062,12 @@ pub extern "C" fn Event_payment_path_successful(payment_id: crate::c_types::Thir } #[no_mangle] /// Utility method to constructs a new PaymentPathFailed-variant Event -pub extern "C" fn Event_payment_path_failed(payment_id: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::ThirtyTwoBytes, payment_failed_permanently: bool, network_update: crate::c_types::derived::COption_NetworkUpdateZ, all_paths_failed: bool, path: crate::c_types::derived::CVec_RouteHopZ, short_channel_id: crate::c_types::derived::COption_u64Z, retry: crate::lightning::routing::router::RouteParameters) -> Event { +pub extern "C" fn Event_payment_path_failed(payment_id: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::ThirtyTwoBytes, payment_failed_permanently: bool, failure: crate::lightning::util::events::PathFailure, path: crate::c_types::derived::CVec_RouteHopZ, short_channel_id: crate::c_types::derived::COption_u64Z, retry: crate::lightning::routing::router::RouteParameters) -> Event { Event::PaymentPathFailed { payment_id, payment_hash, payment_failed_permanently, - network_update, - all_paths_failed, + failure, path, short_channel_id, retry, @@ -1725,6 +2100,17 @@ pub extern "C" fn Event_pending_htlcs_forwardable(time_forwardable: u64) -> Even } } #[no_mangle] +/// Utility method to constructs a new HTLCIntercepted-variant Event +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 { + Event::HTLCIntercepted { + intercept_id, + requested_next_hop_scid, + payment_hash, + inbound_amount_msat, + expected_outbound_amount_msat, + } +} +#[no_mangle] /// Utility method to constructs a new SpendableOutputs-variant Event pub extern "C" fn Event_spendable_outputs(outputs: crate::c_types::derived::CVec_SpendableOutputDescriptorZ) -> Event { Event::SpendableOutputs { @@ -1742,8 +2128,18 @@ pub extern "C" fn Event_payment_forwarded(prev_channel_id: crate::c_types::Thirt } } #[no_mangle] +/// Utility method to constructs a new ChannelReady-variant Event +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 { + Event::ChannelReady { + channel_id, + user_channel_id, + counterparty_node_id, + channel_type, + } +} +#[no_mangle] /// Utility method to constructs a new ChannelClosed-variant Event -pub extern "C" fn Event_channel_closed(channel_id: crate::c_types::ThirtyTwoBytes, user_channel_id: u64, reason: crate::lightning::util::events::ClosureReason) -> Event { +pub extern "C" fn Event_channel_closed(channel_id: crate::c_types::ThirtyTwoBytes, user_channel_id: crate::c_types::U128, reason: crate::lightning::util::events::ClosureReason) -> Event { Event::ChannelClosed { channel_id, user_channel_id, @@ -1777,6 +2173,12 @@ pub extern "C" fn Event_htlchandling_failed(prev_channel_id: crate::c_types::Thi failed_next_destination, } } +/// Checks if two Events contain equal inner contents. +/// This ignores pointers and is_owned flags and looks at the values in fields. +#[no_mangle] +pub extern "C" fn Event_eq(a: &Event, b: &Event) -> bool { + if &a.to_native() == &b.to_native() { true } else { false } +} #[no_mangle] /// Serialize the Event object into a byte array which can be read by Event_read pub extern "C" fn Event_write(obj: &crate::lightning::util::events::Event) -> crate::c_types::derived::CVec_u8Z { @@ -1786,7 +2188,7 @@ pub extern "C" fn Event_write(obj: &crate::lightning::util::events::Event) -> cr /// Read a Event from a byte array, created by Event_write pub extern "C" fn Event_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_EventZDecodeErrorZ { let res: Result, lightning::ln::msgs::DecodeError> = crate::c_types::maybe_deserialize_obj(ser); - 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::util::events::Event::native_into(o.unwrap()) }) }; local_res_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() }; + 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::util::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() }; local_res } /// An event generated by ChannelManager which indicates a message should be sent to a peer (or @@ -1900,6 +2302,8 @@ pub enum MessageSendEvent { /// The channel_announcement which should be sent. msg: crate::lightning::ln::msgs::ChannelAnnouncement, /// The followup channel_update which should be sent. + /// + /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None update_msg: crate::lightning::ln::msgs::ChannelUpdate, }, /// Used to indicate that a channel_update should be broadcast to all peers. @@ -1907,6 +2311,11 @@ pub enum MessageSendEvent { /// The channel_update which should be sent. msg: crate::lightning::ln::msgs::ChannelUpdate, }, + /// Used to indicate that a node_announcement should be broadcast to all peers. + BroadcastNodeAnnouncement { + /// The node_announcement which should be sent. + msg: crate::lightning::ln::msgs::NodeAnnouncement, + }, /// Used to indicate that a channel_update should be sent to a single peer. /// In contrast to [`Self::BroadcastChannelUpdate`], this is used when the channel is a /// private channel and we shouldn't be informing all of our peers of channel parameters. @@ -1963,97 +2372,97 @@ impl MessageSendEvent { pub(crate) fn to_native(&self) -> nativeMessageSendEvent { match self { MessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendAcceptChannel { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendOpenChannel { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendFundingCreated { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendFundingSigned { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendChannelReady {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendChannelReady { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendAnnouncementSignatures { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut updates_nonref = (*updates).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut updates_nonref = Clone::clone(updates); nativeMessageSendEvent::UpdateHTLCs { node_id: node_id_nonref.into_rust(), updates: *unsafe { Box::from_raw(updates_nonref.take_inner()) }, } }, MessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendRevokeAndACK { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendClosingSigned { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendShutdown {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendShutdown { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendChannelReestablish { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendChannelAnnouncement {ref node_id, ref msg, ref update_msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); - let mut update_msg_nonref = (*update_msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + let mut update_msg_nonref = Clone::clone(update_msg); nativeMessageSendEvent::SendChannelAnnouncement { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, @@ -2061,62 +2470,69 @@ impl MessageSendEvent { } }, MessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => { - let mut msg_nonref = (*msg).clone(); - let mut update_msg_nonref = (*update_msg).clone(); + let mut msg_nonref = Clone::clone(msg); + let mut update_msg_nonref = Clone::clone(update_msg); + 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()) } }) }; nativeMessageSendEvent::BroadcastChannelAnnouncement { msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, - update_msg: *unsafe { Box::from_raw(update_msg_nonref.take_inner()) }, + update_msg: local_update_msg_nonref, } }, MessageSendEvent::BroadcastChannelUpdate {ref msg, } => { - let mut msg_nonref = (*msg).clone(); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::BroadcastChannelUpdate { msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, + MessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => { + let mut msg_nonref = Clone::clone(msg); + nativeMessageSendEvent::BroadcastNodeAnnouncement { + msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, + } + }, MessageSendEvent::SendChannelUpdate {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendChannelUpdate { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::HandleError {ref node_id, ref action, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut action_nonref = (*action).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut action_nonref = Clone::clone(action); nativeMessageSendEvent::HandleError { node_id: node_id_nonref.into_rust(), action: action_nonref.into_native(), } }, MessageSendEvent::SendChannelRangeQuery {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendChannelRangeQuery { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendShortIdsQuery {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendShortIdsQuery { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendReplyChannelRange {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendReplyChannelRange { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, MessageSendEvent::SendGossipTimestampFilter {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); nativeMessageSendEvent::SendGossipTimestampFilter { node_id: node_id_nonref.into_rust(), msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, @@ -2201,9 +2617,10 @@ impl MessageSendEvent { } }, MessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => { + let mut local_update_msg = if update_msg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(update_msg.take_inner()) } }) }; nativeMessageSendEvent::BroadcastChannelAnnouncement { msg: *unsafe { Box::from_raw(msg.take_inner()) }, - update_msg: *unsafe { Box::from_raw(update_msg.take_inner()) }, + update_msg: local_update_msg, } }, MessageSendEvent::BroadcastChannelUpdate {mut msg, } => { @@ -2211,6 +2628,11 @@ impl MessageSendEvent { msg: *unsafe { Box::from_raw(msg.take_inner()) }, } }, + MessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => { + nativeMessageSendEvent::BroadcastNodeAnnouncement { + msg: *unsafe { Box::from_raw(msg.take_inner()) }, + } + }, MessageSendEvent::SendChannelUpdate {mut node_id, mut msg, } => { nativeMessageSendEvent::SendChannelUpdate { node_id: node_id.into_rust(), @@ -2253,97 +2675,97 @@ impl MessageSendEvent { pub(crate) fn from_native(native: &nativeMessageSendEvent) -> Self { match native { nativeMessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendAcceptChannel { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::AcceptChannel { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendOpenChannel { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::OpenChannel { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendFundingCreated { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::FundingCreated { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendFundingSigned { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::FundingSigned { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendChannelReady {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendChannelReady { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::ChannelReady { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendAnnouncementSignatures { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::AnnouncementSignatures { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut updates_nonref = (*updates).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut updates_nonref = Clone::clone(updates); MessageSendEvent::UpdateHTLCs { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), updates: crate::lightning::ln::msgs::CommitmentUpdate { inner: ObjOps::heap_alloc(updates_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendRevokeAndACK { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::RevokeAndACK { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendClosingSigned { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::ClosingSigned { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendShutdown {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendShutdown { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::Shutdown { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendChannelReestablish { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::ChannelReestablish { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendChannelAnnouncement {ref node_id, ref msg, ref update_msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); - let mut update_msg_nonref = (*update_msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); + let mut update_msg_nonref = Clone::clone(update_msg); MessageSendEvent::SendChannelAnnouncement { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::ChannelAnnouncement { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, @@ -2351,62 +2773,69 @@ impl MessageSendEvent { } }, nativeMessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => { - let mut msg_nonref = (*msg).clone(); - let mut update_msg_nonref = (*update_msg).clone(); + let mut msg_nonref = Clone::clone(msg); + let mut update_msg_nonref = Clone::clone(update_msg); + 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 }; MessageSendEvent::BroadcastChannelAnnouncement { msg: crate::lightning::ln::msgs::ChannelAnnouncement { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, - update_msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(update_msg_nonref), is_owned: true }, + update_msg: local_update_msg_nonref, } }, nativeMessageSendEvent::BroadcastChannelUpdate {ref msg, } => { - let mut msg_nonref = (*msg).clone(); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::BroadcastChannelUpdate { msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, + nativeMessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => { + let mut msg_nonref = Clone::clone(msg); + MessageSendEvent::BroadcastNodeAnnouncement { + msg: crate::lightning::ln::msgs::NodeAnnouncement { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, + } + }, nativeMessageSendEvent::SendChannelUpdate {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendChannelUpdate { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::HandleError {ref node_id, ref action, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut action_nonref = (*action).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut action_nonref = Clone::clone(action); MessageSendEvent::HandleError { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), action: crate::lightning::ln::msgs::ErrorAction::native_into(action_nonref), } }, nativeMessageSendEvent::SendChannelRangeQuery {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendChannelRangeQuery { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::QueryChannelRange { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendShortIdsQuery {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendShortIdsQuery { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::QueryShortChannelIds { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendReplyChannelRange {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendReplyChannelRange { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::ReplyChannelRange { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, } }, nativeMessageSendEvent::SendGossipTimestampFilter {ref node_id, ref msg, } => { - let mut node_id_nonref = (*node_id).clone(); - let mut msg_nonref = (*msg).clone(); + let mut node_id_nonref = Clone::clone(node_id); + let mut msg_nonref = Clone::clone(msg); MessageSendEvent::SendGossipTimestampFilter { node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref), msg: crate::lightning::ln::msgs::GossipTimestampFilter { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true }, @@ -2491,9 +2920,10 @@ impl MessageSendEvent { } }, nativeMessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => { + 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 }; MessageSendEvent::BroadcastChannelAnnouncement { msg: crate::lightning::ln::msgs::ChannelAnnouncement { inner: ObjOps::heap_alloc(msg), is_owned: true }, - update_msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(update_msg), is_owned: true }, + update_msg: local_update_msg, } }, nativeMessageSendEvent::BroadcastChannelUpdate {mut msg, } => { @@ -2501,6 +2931,11 @@ impl MessageSendEvent { msg: crate::lightning::ln::msgs::ChannelUpdate { inner: ObjOps::heap_alloc(msg), is_owned: true }, } }, + nativeMessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => { + MessageSendEvent::BroadcastNodeAnnouncement { + msg: crate::lightning::ln::msgs::NodeAnnouncement { inner: ObjOps::heap_alloc(msg), is_owned: true }, + } + }, nativeMessageSendEvent::SendChannelUpdate {mut node_id, mut msg, } => { MessageSendEvent::SendChannelUpdate { node_id: crate::c_types::PublicKey::from_rust(&node_id), @@ -2661,6 +3096,13 @@ pub extern "C" fn MessageSendEvent_broadcast_channel_update(msg: crate::lightnin } } #[no_mangle] +/// Utility method to constructs a new BroadcastNodeAnnouncement-variant MessageSendEvent +pub extern "C" fn MessageSendEvent_broadcast_node_announcement(msg: crate::lightning::ln::msgs::NodeAnnouncement) -> MessageSendEvent { + MessageSendEvent::BroadcastNodeAnnouncement { + msg, + } +} +#[no_mangle] /// Utility method to constructs a new SendChannelUpdate-variant MessageSendEvent pub extern "C" fn MessageSendEvent_send_channel_update(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::ChannelUpdate) -> MessageSendEvent { MessageSendEvent::SendChannelUpdate { @@ -2817,6 +3259,10 @@ impl Drop for OnionMessageProvider { /// /// Events are processed by passing an [`EventHandler`] to [`process_pending_events`]. /// +/// Implementations of this trait may also feature an async version of event handling, as shown with +/// [`ChannelManager::process_pending_events_async`] and +/// [`ChainMonitor::process_pending_events_async`]. +/// /// # Requirements /// /// When using this trait, [`process_pending_events`] will call [`handle_event`] for each pending @@ -2843,6 +3289,8 @@ impl Drop for OnionMessageProvider { /// [`handle_event`]: EventHandler::handle_event /// [`ChannelManager::process_pending_events`]: crate::ln::channelmanager::ChannelManager#method.process_pending_events /// [`ChainMonitor::process_pending_events`]: crate::chain::chainmonitor::ChainMonitor#method.process_pending_events +/// [`ChannelManager::process_pending_events_async`]: crate::ln::channelmanager::ChannelManager::process_pending_events_async +/// [`ChainMonitor::process_pending_events_async`]: crate::chain::chainmonitor::ChainMonitor::process_pending_events_async #[repr(C)] pub struct EventsProvider { /// An opaque pointer which is passed to your function implementations as an argument. @@ -2879,6 +3327,10 @@ impl Drop for EventsProvider { } } /// A trait implemented for objects handling events from [`EventsProvider`]. +/// +/// An async variation also exists for implementations of [`EventsProvider`] that support async +/// event handling. The async event handler should satisfy the generic bounds: `F: +/// core::future::Future, H: Fn(Event) -> F`. #[repr(C)] pub struct EventHandler { /// An opaque pointer which is passed to your function implementations as an argument. @@ -2887,7 +3339,7 @@ pub struct EventHandler { /// Handles the given [`Event`]. /// /// See [`EventsProvider`] for details that must be considered when implementing this method. - pub handle_event: extern "C" fn (this_arg: *const c_void, event: &crate::lightning::util::events::Event), + pub handle_event: extern "C" fn (this_arg: *const c_void, event: crate::lightning::util::events::Event), /// Frees any resources associated with this object given its this_arg pointer. /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed. pub free: Option, @@ -2905,8 +3357,8 @@ pub(crate) extern "C" fn EventHandler_clone_fields(orig: &EventHandler) -> Event use lightning::util::events::EventHandler as rustEventHandler; impl rustEventHandler for EventHandler { - fn handle_event(&self, mut event: &lightning::util::events::Event) { - (self.handle_event)(self.this_arg, &crate::lightning::util::events::Event::from_native(event)) + fn handle_event(&self, mut event: lightning::util::events::Event) { + (self.handle_event)(self.this_arg, crate::lightning::util::events::Event::native_into(event)) } }