}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativePaymentPurpose) -> Self {
+ pub(crate) fn from_native(native: &PaymentPurposeImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativePaymentPurpose) };
match native {
nativePaymentPurpose::InvoicePayment {ref payment_preimage, ref payment_secret, } => {
let mut payment_preimage_nonref = Clone::clone(payment_preimage);
pub extern "C" fn PaymentPurpose_clone(orig: &PaymentPurpose) -> PaymentPurpose {
orig.clone()
}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn PaymentPurpose_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const PaymentPurpose)).clone() })) as *mut c_void
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn PaymentPurpose_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut PaymentPurpose) };
+}
#[no_mangle]
/// Utility method to constructs a new InvoicePayment-variant PaymentPurpose
pub extern "C" fn PaymentPurpose_invoice_payment(payment_preimage: crate::c_types::derived::COption_ThirtyTwoBytesZ, payment_secret: crate::c_types::ThirtyTwoBytes) -> PaymentPurpose {
pub extern "C" fn PaymentPurpose_spontaneous_payment(a: crate::c_types::ThirtyTwoBytes) -> PaymentPurpose {
PaymentPurpose::SpontaneousPayment(a, )
}
+/// Get a string which allows debug introspection of a PaymentPurpose object
+pub extern "C" fn PaymentPurpose_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::PaymentPurpose }).into()}
/// Checks if two PaymentPurposes contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
pub extern "C" fn PaymentPurpose_eq(a: &PaymentPurpose, b: &PaymentPurpose) -> bool {
if &a.to_native() == &b.to_native() { true } else { false }
}
+/// Returns the preimage for this payment, if it is known.
+#[must_use]
+#[no_mangle]
+pub extern "C" fn PaymentPurpose_preimage(this_arg: &crate::lightning::events::PaymentPurpose) -> crate::c_types::derived::COption_ThirtyTwoBytesZ {
+ let mut ret = this_arg.to_native().preimage();
+ let mut local_ret = if ret.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: ret.unwrap().0 } }) };
+ local_ret
+}
+
#[no_mangle]
/// Serialize the PaymentPurpose object into a byte array which can be read by PaymentPurpose_read
pub extern "C" fn PaymentPurpose_write(obj: &crate::lightning::events::PaymentPurpose) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
}
+#[allow(unused)]
+pub(crate) extern "C" fn PaymentPurpose_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ PaymentPurpose_write(unsafe { &*(obj as *const PaymentPurpose) })
+}
#[no_mangle]
/// Read a PaymentPurpose from a byte array, created by PaymentPurpose_write
pub extern "C" fn PaymentPurpose_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PaymentPurposeDecodeErrorZ {
pub extern "C" fn ClaimedHTLC_set_value_msat(this_ptr: &mut ClaimedHTLC, mut val: u64) {
unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.value_msat = val;
}
+/// The extra fee our counterparty skimmed off the top of this HTLC, if any.
+///
+/// This value will always be 0 for [`ClaimedHTLC`]s serialized with LDK versions prior to
+/// 0.0.119.
+#[no_mangle]
+pub extern "C" fn ClaimedHTLC_get_counterparty_skimmed_fee_msat(this_ptr: &ClaimedHTLC) -> u64 {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().counterparty_skimmed_fee_msat;
+ *inner_val
+}
+/// The extra fee our counterparty skimmed off the top of this HTLC, if any.
+///
+/// This value will always be 0 for [`ClaimedHTLC`]s serialized with LDK versions prior to
+/// 0.0.119.
+#[no_mangle]
+pub extern "C" fn ClaimedHTLC_set_counterparty_skimmed_fee_msat(this_ptr: &mut ClaimedHTLC, mut val: u64) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.counterparty_skimmed_fee_msat = val;
+}
/// Constructs a new ClaimedHTLC given each field
#[must_use]
#[no_mangle]
-pub extern "C" fn ClaimedHTLC_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut user_channel_id_arg: crate::c_types::U128, mut cltv_expiry_arg: u32, mut value_msat_arg: u64) -> ClaimedHTLC {
+pub extern "C" fn ClaimedHTLC_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut user_channel_id_arg: crate::c_types::U128, mut cltv_expiry_arg: u32, mut value_msat_arg: u64, mut counterparty_skimmed_fee_msat_arg: u64) -> ClaimedHTLC {
ClaimedHTLC { inner: ObjOps::heap_alloc(nativeClaimedHTLC {
channel_id: ::lightning::ln::ChannelId(channel_id_arg.data),
user_channel_id: user_channel_id_arg.into(),
cltv_expiry: cltv_expiry_arg,
value_msat: value_msat_arg,
+ counterparty_skimmed_fee_msat: counterparty_skimmed_fee_msat_arg,
}), is_owned: true }
}
impl Clone for ClaimedHTLC {
#[allow(unused)]
/// Used only if an object of this type is returned as a trait impl by a method
pub(crate) extern "C" fn ClaimedHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
- Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeClaimedHTLC)).clone() })) as *mut c_void
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const nativeClaimedHTLC)).clone() })) as *mut c_void
}
#[no_mangle]
/// Creates a copy of the ClaimedHTLC
pub extern "C" fn ClaimedHTLC_clone(orig: &ClaimedHTLC) -> ClaimedHTLC {
orig.clone()
}
+/// Get a string which allows debug introspection of a ClaimedHTLC object
+pub extern "C" fn ClaimedHTLC_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::ClaimedHTLC }).into()}
/// Checks if two ClaimedHTLCs contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
/// Two objects with NULL inner values will be considered "equal" here.
pub extern "C" fn ClaimedHTLC_write(obj: &crate::lightning::events::ClaimedHTLC) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
}
-#[no_mangle]
+#[allow(unused)]
pub(crate) extern "C" fn ClaimedHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeClaimedHTLC) })
}
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativePathFailure) -> Self {
+ pub(crate) fn from_native(native: &PathFailureImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativePathFailure) };
match native {
nativePathFailure::InitialSend {ref err, } => {
let mut err_nonref = Clone::clone(err);
pub extern "C" fn PathFailure_clone(orig: &PathFailure) -> PathFailure {
orig.clone()
}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn PathFailure_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const PathFailure)).clone() })) as *mut c_void
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn PathFailure_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut PathFailure) };
+}
#[no_mangle]
/// Utility method to constructs a new InitialSend-variant PathFailure
pub extern "C" fn PathFailure_initial_send(err: crate::lightning::util::errors::APIError) -> PathFailure {
network_update,
}
}
+/// Get a string which allows debug introspection of a PathFailure object
+pub extern "C" fn PathFailure_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::PathFailure }).into()}
/// Checks if two PathFailures contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
pub extern "C" fn PathFailure_write(obj: &crate::lightning::events::PathFailure) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
}
+#[allow(unused)]
+pub(crate) extern "C" fn PathFailure_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ PathFailure_write(unsafe { &*(obj as *const PathFailure) })
+}
#[no_mangle]
/// Read a PathFailure from a byte array, created by PathFailure_write
pub extern "C" fn PathFailure_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_PathFailureZDecodeErrorZ {
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeClosureReason) -> Self {
+ pub(crate) fn from_native(native: &ClosureReasonImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeClosureReason) };
match native {
nativeClosureReason::CounterpartyForceClosed {ref peer_msg, } => {
let mut peer_msg_nonref = Clone::clone(peer_msg);
pub extern "C" fn ClosureReason_clone(orig: &ClosureReason) -> ClosureReason {
orig.clone()
}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn ClosureReason_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const ClosureReason)).clone() })) as *mut c_void
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn ClosureReason_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut ClosureReason) };
+}
#[no_mangle]
/// Utility method to constructs a new CounterpartyForceClosed-variant ClosureReason
pub extern "C" fn ClosureReason_counterparty_force_closed(peer_msg: crate::lightning::util::string::UntrustedString) -> ClosureReason {
/// Utility method to constructs a new FundingBatchClosure-variant ClosureReason
pub extern "C" fn ClosureReason_funding_batch_closure() -> ClosureReason {
ClosureReason::FundingBatchClosure}
+/// Get a string which allows debug introspection of a ClosureReason object
+pub extern "C" fn ClosureReason_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::ClosureReason }).into()}
/// Checks if two ClosureReasons contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
pub extern "C" fn ClosureReason_write(obj: &crate::lightning::events::ClosureReason) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
}
+#[allow(unused)]
+pub(crate) extern "C" fn ClosureReason_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ ClosureReason_write(unsafe { &*(obj as *const ClosureReason) })
+}
#[no_mangle]
/// Read a ClosureReason from a byte array, created by ClosureReason_write
pub extern "C" fn ClosureReason_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_ClosureReasonZDecodeErrorZ {
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeHTLCDestination) -> Self {
+ pub(crate) fn from_native(native: &HTLCDestinationImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeHTLCDestination) };
match native {
nativeHTLCDestination::NextHopChannel {ref node_id, ref channel_id, } => {
let mut node_id_nonref = Clone::clone(node_id);
pub extern "C" fn HTLCDestination_clone(orig: &HTLCDestination) -> HTLCDestination {
orig.clone()
}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn HTLCDestination_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const HTLCDestination)).clone() })) as *mut c_void
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn HTLCDestination_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut HTLCDestination) };
+}
#[no_mangle]
/// Utility method to constructs a new NextHopChannel-variant HTLCDestination
pub extern "C" fn HTLCDestination_next_hop_channel(node_id: crate::c_types::PublicKey, channel_id: crate::c_types::ThirtyTwoBytes) -> HTLCDestination {
payment_hash,
}
}
+/// Get a string which allows debug introspection of a HTLCDestination object
+pub extern "C" fn HTLCDestination_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::HTLCDestination }).into()}
/// Checks if two HTLCDestinations contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
pub extern "C" fn HTLCDestination_write(obj: &crate::lightning::events::HTLCDestination) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
}
+#[allow(unused)]
+pub(crate) extern "C" fn HTLCDestination_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ HTLCDestination_write(unsafe { &*(obj as *const HTLCDestination) })
+}
#[no_mangle]
/// Read a HTLCDestination from a byte array, created by HTLCDestination_write
pub extern "C" fn HTLCDestination_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_HTLCDestinationZDecodeErrorZ {
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativePaymentFailureReason) -> Self {
+ pub(crate) fn from_native(native: &PaymentFailureReasonImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativePaymentFailureReason) };
match native {
nativePaymentFailureReason::RecipientRejected => PaymentFailureReason::RecipientRejected,
nativePaymentFailureReason::UserAbandoned => PaymentFailureReason::UserAbandoned,
pub extern "C" fn PaymentFailureReason_clone(orig: &PaymentFailureReason) -> PaymentFailureReason {
orig.clone()
}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn PaymentFailureReason_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const PaymentFailureReason)).clone() })) as *mut c_void
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn PaymentFailureReason_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut PaymentFailureReason) };
+}
#[no_mangle]
/// Utility method to constructs a new RecipientRejected-variant PaymentFailureReason
pub extern "C" fn PaymentFailureReason_recipient_rejected() -> PaymentFailureReason {
/// Utility method to constructs a new UnexpectedError-variant PaymentFailureReason
pub extern "C" fn PaymentFailureReason_unexpected_error() -> PaymentFailureReason {
PaymentFailureReason::UnexpectedError}
+/// Get a string which allows debug introspection of a PaymentFailureReason object
+pub extern "C" fn PaymentFailureReason_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::PaymentFailureReason }).into()}
/// Checks if two PaymentFailureReasons contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
pub extern "C" fn PaymentFailureReason_write(obj: &crate::lightning::events::PaymentFailureReason) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
}
+#[allow(unused)]
+pub(crate) extern "C" fn PaymentFailureReason_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ PaymentFailureReason_write(unsafe { &*(obj as *const PaymentFailureReason) })
+}
#[no_mangle]
/// Read a PaymentFailureReason from a byte array, created by PaymentFailureReason_write
pub extern "C" fn PaymentFailureReason_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PaymentFailureReasonDecodeErrorZ {
/// serialized prior to LDK version 0.0.117.
sender_intended_total_msat: crate::c_types::derived::COption_u64Z,
},
+ /// Indicates that a peer connection with a node is needed in order to send an [`OnionMessage`].
+ ///
+ /// Typically, this happens when a [`MessageRouter`] is unable to find a complete path to a
+ /// [`Destination`]. Once a connection is established, any messages buffered by an
+ /// [`OnionMessageHandler`] may be sent.
+ ///
+ /// This event will not be generated for onion message forwards; only for sends including
+ /// replies. Handlers should connect to the node otherwise any buffered messages may be lost.
+ ///
+ /// [`OnionMessage`]: msgs::OnionMessage
+ /// [`MessageRouter`]: crate::onion_message::messenger::MessageRouter
+ /// [`Destination`]: crate::onion_message::messenger::Destination
+ /// [`OnionMessageHandler`]: crate::ln::msgs::OnionMessageHandler
+ ConnectionNeeded {
+ /// The node id for the node needing a connection.
+ node_id: crate::c_types::PublicKey,
+ /// Sockets for connecting to the node.
+ addresses: crate::c_types::derived::CVec_SocketAddressZ,
+ },
+ /// Indicates a request for an invoice failed to yield a response in a reasonable amount of time
+ /// or was explicitly abandoned by [`ChannelManager::abandon_payment`]. This may be for an
+ /// [`InvoiceRequest`] sent for an [`Offer`] or for a [`Refund`] that hasn't been redeemed.
+ ///
+ /// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
+ /// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
+ /// [`Offer`]: crate::offers::offer::Offer
+ /// [`Refund`]: crate::offers::refund::Refund
+ InvoiceRequestFailed {
+ /// The `payment_id` to have been associated with payment for the requested invoice.
+ payment_id: crate::c_types::ThirtyTwoBytes,
+ },
/// Indicates an outbound payment we made succeeded (i.e. it made it all the way to its target
/// and we got back the payment preimage for it).
///
///
/// This field will be `None` for objects serialized prior to LDK 0.0.117.
channel_capacity_sats: crate::c_types::derived::COption_u64Z,
+ /// The original channel funding TXO; this helps checking for the existence and confirmation
+ /// status of the closing tx.
+ /// Note that for instances serialized in v0.0.119 or prior this will be missing (None).
+ ///
+ /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
+ channel_funding_txo: crate::lightning::chain::transaction::OutPoint,
},
/// Used to indicate to the user that they can abandon the funding transaction and recycle the
/// inputs for another purpose.
temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id_nonref.data),
counterparty_node_id: counterparty_node_id_nonref.into_rust(),
channel_value_satoshis: channel_value_satoshis_nonref,
- output_script: ::bitcoin::blockdata::script::Script::from(output_script_nonref.into_rust()),
+ output_script: ::bitcoin::blockdata::script::ScriptBuf::from(output_script_nonref.into_rust()),
user_channel_id: user_channel_id_nonref.into(),
}
},
sender_intended_total_msat: local_sender_intended_total_msat_nonref,
}
},
+ Event::ConnectionNeeded {ref node_id, ref addresses, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut addresses_nonref = Clone::clone(addresses);
+ let mut local_addresses_nonref = Vec::new(); for mut item in addresses_nonref.into_rust().drain(..) { local_addresses_nonref.push( { item.into_native() }); };
+ nativeEvent::ConnectionNeeded {
+ node_id: node_id_nonref.into_rust(),
+ addresses: local_addresses_nonref,
+ }
+ },
+ Event::InvoiceRequestFailed {ref payment_id, } => {
+ let mut payment_id_nonref = Clone::clone(payment_id);
+ nativeEvent::InvoiceRequestFailed {
+ payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id_nonref.data),
+ }
+ },
Event::PaymentSent {ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat, } => {
let mut payment_id_nonref = Clone::clone(payment_id);
let mut local_payment_id_nonref = { /*payment_id_nonref*/ let payment_id_nonref_opt = payment_id_nonref; if payment_id_nonref_opt.is_none() { None } else { Some({ { ::lightning::ln::channelmanager::PaymentId({ payment_id_nonref_opt.take() }.data) }})} };
channel_type: *unsafe { Box::from_raw(channel_type_nonref.take_inner()) },
}
},
- Event::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, ref counterparty_node_id, ref channel_capacity_sats, } => {
+ Event::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, ref counterparty_node_id, ref channel_capacity_sats, ref channel_funding_txo, } => {
let mut channel_id_nonref = Clone::clone(channel_id);
let mut user_channel_id_nonref = Clone::clone(user_channel_id);
let mut reason_nonref = Clone::clone(reason);
let mut local_counterparty_node_id_nonref = if counterparty_node_id_nonref.is_null() { None } else { Some( { counterparty_node_id_nonref.into_rust() }) };
let mut channel_capacity_sats_nonref = Clone::clone(channel_capacity_sats);
let mut local_channel_capacity_sats_nonref = if channel_capacity_sats_nonref.is_some() { Some( { channel_capacity_sats_nonref.take() }) } else { None };
+ let mut channel_funding_txo_nonref = Clone::clone(channel_funding_txo);
+ let mut local_channel_funding_txo_nonref = if channel_funding_txo_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(channel_funding_txo_nonref.take_inner()) } }) };
nativeEvent::ChannelClosed {
channel_id: ::lightning::ln::ChannelId(channel_id_nonref.data),
user_channel_id: user_channel_id_nonref.into(),
reason: reason_nonref.into_native(),
counterparty_node_id: local_counterparty_node_id_nonref,
channel_capacity_sats: local_channel_capacity_sats_nonref,
+ channel_funding_txo: local_channel_funding_txo_nonref,
}
},
Event::DiscardFunding {ref channel_id, ref transaction, } => {
temporary_channel_id: ::lightning::ln::ChannelId(temporary_channel_id.data),
counterparty_node_id: counterparty_node_id.into_rust(),
channel_value_satoshis: channel_value_satoshis,
- output_script: ::bitcoin::blockdata::script::Script::from(output_script.into_rust()),
+ output_script: ::bitcoin::blockdata::script::ScriptBuf::from(output_script.into_rust()),
user_channel_id: user_channel_id.into(),
}
},
sender_intended_total_msat: local_sender_intended_total_msat,
}
},
+ Event::ConnectionNeeded {mut node_id, mut addresses, } => {
+ let mut local_addresses = Vec::new(); for mut item in addresses.into_rust().drain(..) { local_addresses.push( { item.into_native() }); };
+ nativeEvent::ConnectionNeeded {
+ node_id: node_id.into_rust(),
+ addresses: local_addresses,
+ }
+ },
+ Event::InvoiceRequestFailed {mut payment_id, } => {
+ nativeEvent::InvoiceRequestFailed {
+ payment_id: ::lightning::ln::channelmanager::PaymentId(payment_id.data),
+ }
+ },
Event::PaymentSent {mut payment_id, mut payment_preimage, mut payment_hash, mut fee_paid_msat, } => {
let mut local_payment_id = { /*payment_id*/ let payment_id_opt = payment_id; if payment_id_opt.is_none() { None } else { Some({ { ::lightning::ln::channelmanager::PaymentId({ payment_id_opt.take() }.data) }})} };
let mut local_fee_paid_msat = if fee_paid_msat.is_some() { Some( { fee_paid_msat.take() }) } else { None };
channel_type: *unsafe { Box::from_raw(channel_type.take_inner()) },
}
},
- Event::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, mut counterparty_node_id, mut channel_capacity_sats, } => {
+ Event::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, mut counterparty_node_id, mut channel_capacity_sats, mut channel_funding_txo, } => {
let mut local_counterparty_node_id = if counterparty_node_id.is_null() { None } else { Some( { counterparty_node_id.into_rust() }) };
let mut local_channel_capacity_sats = if channel_capacity_sats.is_some() { Some( { channel_capacity_sats.take() }) } else { None };
+ let mut local_channel_funding_txo = if channel_funding_txo.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(channel_funding_txo.take_inner()) } }) };
nativeEvent::ChannelClosed {
channel_id: ::lightning::ln::ChannelId(channel_id.data),
user_channel_id: user_channel_id.into(),
reason: reason.into_native(),
counterparty_node_id: local_counterparty_node_id,
channel_capacity_sats: local_channel_capacity_sats,
+ channel_funding_txo: local_channel_funding_txo,
}
},
Event::DiscardFunding {mut channel_id, mut transaction, } => {
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeEvent) -> Self {
+ pub(crate) fn from_native(native: &EventImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeEvent) };
match native {
nativeEvent::FundingGenerationReady {ref temporary_channel_id, ref counterparty_node_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => {
let mut temporary_channel_id_nonref = Clone::clone(temporary_channel_id);
temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref.0 },
counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id_nonref),
channel_value_satoshis: channel_value_satoshis_nonref,
- output_script: output_script_nonref.into_bytes().into(),
+ output_script: output_script_nonref.to_bytes().into(),
user_channel_id: user_channel_id_nonref.into(),
}
},
sender_intended_total_msat: local_sender_intended_total_msat_nonref,
}
},
+ nativeEvent::ConnectionNeeded {ref node_id, ref addresses, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut addresses_nonref = Clone::clone(addresses);
+ let mut local_addresses_nonref = Vec::new(); for mut item in addresses_nonref.drain(..) { local_addresses_nonref.push( { crate::lightning::ln::msgs::SocketAddress::native_into(item) }); };
+ Event::ConnectionNeeded {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
+ addresses: local_addresses_nonref.into(),
+ }
+ },
+ nativeEvent::InvoiceRequestFailed {ref payment_id, } => {
+ let mut payment_id_nonref = Clone::clone(payment_id);
+ Event::InvoiceRequestFailed {
+ payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.0 },
+ }
+ },
nativeEvent::PaymentSent {ref payment_id, ref payment_preimage, ref payment_hash, ref fee_paid_msat, } => {
let mut payment_id_nonref = Clone::clone(payment_id);
let mut local_payment_id_nonref = if payment_id_nonref.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id_nonref.unwrap().0 } }) };
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, ref counterparty_node_id, ref channel_capacity_sats, } => {
+ nativeEvent::ChannelClosed {ref channel_id, ref user_channel_id, ref reason, ref counterparty_node_id, ref channel_capacity_sats, ref channel_funding_txo, } => {
let mut channel_id_nonref = Clone::clone(channel_id);
let mut user_channel_id_nonref = Clone::clone(user_channel_id);
let mut reason_nonref = Clone::clone(reason);
let mut local_counterparty_node_id_nonref = if counterparty_node_id_nonref.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(counterparty_node_id_nonref.unwrap())) } };
let mut channel_capacity_sats_nonref = Clone::clone(channel_capacity_sats);
let mut local_channel_capacity_sats_nonref = if channel_capacity_sats_nonref.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { channel_capacity_sats_nonref.unwrap() }) };
+ let mut channel_funding_txo_nonref = Clone::clone(channel_funding_txo);
+ let mut local_channel_funding_txo_nonref = crate::lightning::chain::transaction::OutPoint { inner: if channel_funding_txo_nonref.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((channel_funding_txo_nonref.unwrap())) } }, is_owned: true };
Event::ChannelClosed {
channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id_nonref.0 },
user_channel_id: user_channel_id_nonref.into(),
reason: crate::lightning::events::ClosureReason::native_into(reason_nonref),
counterparty_node_id: local_counterparty_node_id_nonref,
channel_capacity_sats: local_channel_capacity_sats_nonref,
+ channel_funding_txo: local_channel_funding_txo_nonref,
}
},
nativeEvent::DiscardFunding {ref channel_id, ref transaction, } => {
temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id.0 },
counterparty_node_id: crate::c_types::PublicKey::from_rust(&counterparty_node_id),
channel_value_satoshis: channel_value_satoshis,
- output_script: output_script.into_bytes().into(),
+ output_script: output_script.to_bytes().into(),
user_channel_id: user_channel_id.into(),
}
},
sender_intended_total_msat: local_sender_intended_total_msat,
}
},
+ nativeEvent::ConnectionNeeded {mut node_id, mut addresses, } => {
+ let mut local_addresses = Vec::new(); for mut item in addresses.drain(..) { local_addresses.push( { crate::lightning::ln::msgs::SocketAddress::native_into(item) }); };
+ Event::ConnectionNeeded {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id),
+ addresses: local_addresses.into(),
+ }
+ },
+ nativeEvent::InvoiceRequestFailed {mut payment_id, } => {
+ Event::InvoiceRequestFailed {
+ payment_id: crate::c_types::ThirtyTwoBytes { data: payment_id.0 },
+ }
+ },
nativeEvent::PaymentSent {mut payment_id, mut payment_preimage, mut payment_hash, mut fee_paid_msat, } => {
let mut local_payment_id = if payment_id.is_none() { crate::c_types::derived::COption_ThirtyTwoBytesZ::None } else { crate::c_types::derived::COption_ThirtyTwoBytesZ::Some( { crate::c_types::ThirtyTwoBytes { data: payment_id.unwrap().0 } }) };
let mut local_fee_paid_msat = if fee_paid_msat.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { fee_paid_msat.unwrap() }) };
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, mut counterparty_node_id, mut channel_capacity_sats, } => {
+ nativeEvent::ChannelClosed {mut channel_id, mut user_channel_id, mut reason, mut counterparty_node_id, mut channel_capacity_sats, mut channel_funding_txo, } => {
let mut local_counterparty_node_id = if counterparty_node_id.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(counterparty_node_id.unwrap())) } };
let mut local_channel_capacity_sats = if channel_capacity_sats.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { channel_capacity_sats.unwrap() }) };
+ let mut local_channel_funding_txo = crate::lightning::chain::transaction::OutPoint { inner: if channel_funding_txo.is_none() { core::ptr::null_mut() } else { { ObjOps::heap_alloc((channel_funding_txo.unwrap())) } }, is_owned: true };
Event::ChannelClosed {
channel_id: crate::c_types::ThirtyTwoBytes { data: channel_id.0 },
user_channel_id: user_channel_id.into(),
reason: crate::lightning::events::ClosureReason::native_into(reason),
counterparty_node_id: local_counterparty_node_id,
channel_capacity_sats: local_channel_capacity_sats,
+ channel_funding_txo: local_channel_funding_txo,
}
},
nativeEvent::DiscardFunding {mut channel_id, mut transaction, } => {
pub extern "C" fn Event_clone(orig: &Event) -> Event {
orig.clone()
}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn Event_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const Event)).clone() })) as *mut c_void
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn Event_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut Event) };
+}
#[no_mangle]
/// Utility method to constructs a new FundingGenerationReady-variant Event
pub extern "C" fn Event_funding_generation_ready(temporary_channel_id: crate::c_types::ThirtyTwoBytes, counterparty_node_id: crate::c_types::PublicKey, channel_value_satoshis: u64, output_script: crate::c_types::derived::CVec_u8Z, user_channel_id: crate::c_types::U128) -> Event {
}
}
#[no_mangle]
+/// Utility method to constructs a new ConnectionNeeded-variant Event
+pub extern "C" fn Event_connection_needed(node_id: crate::c_types::PublicKey, addresses: crate::c_types::derived::CVec_SocketAddressZ) -> Event {
+ Event::ConnectionNeeded {
+ node_id,
+ addresses,
+ }
+}
+#[no_mangle]
+/// Utility method to constructs a new InvoiceRequestFailed-variant Event
+pub extern "C" fn Event_invoice_request_failed(payment_id: crate::c_types::ThirtyTwoBytes) -> Event {
+ Event::InvoiceRequestFailed {
+ payment_id,
+ }
+}
+#[no_mangle]
/// Utility method to constructs a new PaymentSent-variant Event
pub extern "C" fn Event_payment_sent(payment_id: crate::c_types::derived::COption_ThirtyTwoBytesZ, payment_preimage: crate::c_types::ThirtyTwoBytes, payment_hash: crate::c_types::ThirtyTwoBytes, fee_paid_msat: crate::c_types::derived::COption_u64Z) -> Event {
Event::PaymentSent {
}
#[no_mangle]
/// Utility method to constructs a new ChannelClosed-variant Event
-pub extern "C" fn Event_channel_closed(channel_id: crate::c_types::ThirtyTwoBytes, user_channel_id: crate::c_types::U128, reason: crate::lightning::events::ClosureReason, counterparty_node_id: crate::c_types::PublicKey, channel_capacity_sats: crate::c_types::derived::COption_u64Z) -> Event {
+pub extern "C" fn Event_channel_closed(channel_id: crate::c_types::ThirtyTwoBytes, user_channel_id: crate::c_types::U128, reason: crate::lightning::events::ClosureReason, counterparty_node_id: crate::c_types::PublicKey, channel_capacity_sats: crate::c_types::derived::COption_u64Z, channel_funding_txo: crate::lightning::chain::transaction::OutPoint) -> Event {
Event::ChannelClosed {
channel_id,
user_channel_id,
reason,
counterparty_node_id,
channel_capacity_sats,
+ channel_funding_txo,
}
}
#[no_mangle]
pub extern "C" fn Event_bump_transaction(a: crate::lightning::events::bump_transaction::BumpTransactionEvent) -> Event {
Event::BumpTransaction(a, )
}
+/// Get a string which allows debug introspection of a Event object
+pub extern "C" fn Event_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::Event }).into()}
/// Checks if two Events contain equal inner contents.
/// This ignores pointers and is_owned flags and looks at the values in fields.
#[no_mangle]
pub extern "C" fn Event_write(obj: &crate::lightning::events::Event) -> crate::c_types::derived::CVec_u8Z {
crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
}
+#[allow(unused)]
+pub(crate) extern "C" fn Event_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ Event_write(unsafe { &*(obj as *const Event) })
+}
#[no_mangle]
/// Read a Event from a byte array, created by Event_write
pub extern "C" fn Event_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_COption_EventZDecodeErrorZ {
/// The message which should be sent.
msg: crate::lightning::ln::msgs::FundingSigned,
},
+ /// Used to indicate that a stfu message should be sent to the peer with the given node id.
+ SendStfu {
+ /// The node_id of the node which should receive this message
+ node_id: crate::c_types::PublicKey,
+ /// The message which should be sent.
+ msg: crate::lightning::ln::msgs::Stfu,
+ },
+ /// Used to indicate that a splice message should be sent to the peer with the given node id.
+ SendSplice {
+ /// The node_id of the node which should receive this message
+ node_id: crate::c_types::PublicKey,
+ /// The message which should be sent.
+ msg: crate::lightning::ln::msgs::Splice,
+ },
+ /// Used to indicate that a splice_ack message should be sent to the peer with the given node id.
+ SendSpliceAck {
+ /// The node_id of the node which should receive this message
+ node_id: crate::c_types::PublicKey,
+ /// The message which should be sent.
+ msg: crate::lightning::ln::msgs::SpliceAck,
+ },
+ /// Used to indicate that a splice_locked message should be sent to the peer with the given node id.
+ SendSpliceLocked {
+ /// The node_id of the node which should receive this message
+ node_id: crate::c_types::PublicKey,
+ /// The message which should be sent.
+ msg: crate::lightning::ln::msgs::SpliceLocked,
+ },
/// Used to indicate that a tx_add_input message should be sent to the peer with the given node_id.
SendTxAddInput {
/// The node_id of the node which should receive this message
msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
}
},
+ MessageSendEvent::SendStfu {ref node_id, ref msg, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut msg_nonref = Clone::clone(msg);
+ nativeMessageSendEvent::SendStfu {
+ node_id: node_id_nonref.into_rust(),
+ msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
+ }
+ },
+ MessageSendEvent::SendSplice {ref node_id, ref msg, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut msg_nonref = Clone::clone(msg);
+ nativeMessageSendEvent::SendSplice {
+ node_id: node_id_nonref.into_rust(),
+ msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
+ }
+ },
+ MessageSendEvent::SendSpliceAck {ref node_id, ref msg, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut msg_nonref = Clone::clone(msg);
+ nativeMessageSendEvent::SendSpliceAck {
+ node_id: node_id_nonref.into_rust(),
+ msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
+ }
+ },
+ MessageSendEvent::SendSpliceLocked {ref node_id, ref msg, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut msg_nonref = Clone::clone(msg);
+ nativeMessageSendEvent::SendSpliceLocked {
+ node_id: node_id_nonref.into_rust(),
+ msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
+ }
+ },
MessageSendEvent::SendTxAddInput {ref node_id, ref msg, } => {
let mut node_id_nonref = Clone::clone(node_id);
let mut msg_nonref = Clone::clone(msg);
msg: *unsafe { Box::from_raw(msg.take_inner()) },
}
},
+ MessageSendEvent::SendStfu {mut node_id, mut msg, } => {
+ nativeMessageSendEvent::SendStfu {
+ node_id: node_id.into_rust(),
+ msg: *unsafe { Box::from_raw(msg.take_inner()) },
+ }
+ },
+ MessageSendEvent::SendSplice {mut node_id, mut msg, } => {
+ nativeMessageSendEvent::SendSplice {
+ node_id: node_id.into_rust(),
+ msg: *unsafe { Box::from_raw(msg.take_inner()) },
+ }
+ },
+ MessageSendEvent::SendSpliceAck {mut node_id, mut msg, } => {
+ nativeMessageSendEvent::SendSpliceAck {
+ node_id: node_id.into_rust(),
+ msg: *unsafe { Box::from_raw(msg.take_inner()) },
+ }
+ },
+ MessageSendEvent::SendSpliceLocked {mut node_id, mut msg, } => {
+ nativeMessageSendEvent::SendSpliceLocked {
+ node_id: node_id.into_rust(),
+ msg: *unsafe { Box::from_raw(msg.take_inner()) },
+ }
+ },
MessageSendEvent::SendTxAddInput {mut node_id, mut msg, } => {
nativeMessageSendEvent::SendTxAddInput {
node_id: node_id.into_rust(),
}
}
#[allow(unused)]
- pub(crate) fn from_native(native: &nativeMessageSendEvent) -> Self {
+ pub(crate) fn from_native(native: &MessageSendEventImport) -> Self {
+ let native = unsafe { &*(native as *const _ as *const c_void as *const nativeMessageSendEvent) };
match native {
nativeMessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => {
let mut node_id_nonref = Clone::clone(node_id);
msg: crate::lightning::ln::msgs::FundingSigned { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
}
},
+ nativeMessageSendEvent::SendStfu {ref node_id, ref msg, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut msg_nonref = Clone::clone(msg);
+ MessageSendEvent::SendStfu {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
+ msg: crate::lightning::ln::msgs::Stfu { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
+ }
+ },
+ nativeMessageSendEvent::SendSplice {ref node_id, ref msg, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut msg_nonref = Clone::clone(msg);
+ MessageSendEvent::SendSplice {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
+ msg: crate::lightning::ln::msgs::Splice { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
+ }
+ },
+ nativeMessageSendEvent::SendSpliceAck {ref node_id, ref msg, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut msg_nonref = Clone::clone(msg);
+ MessageSendEvent::SendSpliceAck {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
+ msg: crate::lightning::ln::msgs::SpliceAck { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
+ }
+ },
+ nativeMessageSendEvent::SendSpliceLocked {ref node_id, ref msg, } => {
+ let mut node_id_nonref = Clone::clone(node_id);
+ let mut msg_nonref = Clone::clone(msg);
+ MessageSendEvent::SendSpliceLocked {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
+ msg: crate::lightning::ln::msgs::SpliceLocked { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
+ }
+ },
nativeMessageSendEvent::SendTxAddInput {ref node_id, ref msg, } => {
let mut node_id_nonref = Clone::clone(node_id);
let mut msg_nonref = Clone::clone(msg);
msg: crate::lightning::ln::msgs::FundingSigned { inner: ObjOps::heap_alloc(msg), is_owned: true },
}
},
+ nativeMessageSendEvent::SendStfu {mut node_id, mut msg, } => {
+ MessageSendEvent::SendStfu {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id),
+ msg: crate::lightning::ln::msgs::Stfu { inner: ObjOps::heap_alloc(msg), is_owned: true },
+ }
+ },
+ nativeMessageSendEvent::SendSplice {mut node_id, mut msg, } => {
+ MessageSendEvent::SendSplice {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id),
+ msg: crate::lightning::ln::msgs::Splice { inner: ObjOps::heap_alloc(msg), is_owned: true },
+ }
+ },
+ nativeMessageSendEvent::SendSpliceAck {mut node_id, mut msg, } => {
+ MessageSendEvent::SendSpliceAck {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id),
+ msg: crate::lightning::ln::msgs::SpliceAck { inner: ObjOps::heap_alloc(msg), is_owned: true },
+ }
+ },
+ nativeMessageSendEvent::SendSpliceLocked {mut node_id, mut msg, } => {
+ MessageSendEvent::SendSpliceLocked {
+ node_id: crate::c_types::PublicKey::from_rust(&node_id),
+ msg: crate::lightning::ln::msgs::SpliceLocked { inner: ObjOps::heap_alloc(msg), is_owned: true },
+ }
+ },
nativeMessageSendEvent::SendTxAddInput {mut node_id, mut msg, } => {
MessageSendEvent::SendTxAddInput {
node_id: crate::c_types::PublicKey::from_rust(&node_id),
pub extern "C" fn MessageSendEvent_clone(orig: &MessageSendEvent) -> MessageSendEvent {
orig.clone()
}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn MessageSendEvent_clone_void(this_ptr: *const c_void) -> *mut c_void {
+ Box::into_raw(Box::new(unsafe { (*(this_ptr as *const MessageSendEvent)).clone() })) as *mut c_void
+}
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn MessageSendEvent_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut MessageSendEvent) };
+}
#[no_mangle]
/// Utility method to constructs a new SendAcceptChannel-variant MessageSendEvent
pub extern "C" fn MessageSendEvent_send_accept_channel(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::AcceptChannel) -> MessageSendEvent {
}
}
#[no_mangle]
+/// Utility method to constructs a new SendStfu-variant MessageSendEvent
+pub extern "C" fn MessageSendEvent_send_stfu(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::Stfu) -> MessageSendEvent {
+ MessageSendEvent::SendStfu {
+ node_id,
+ msg,
+ }
+}
+#[no_mangle]
+/// Utility method to constructs a new SendSplice-variant MessageSendEvent
+pub extern "C" fn MessageSendEvent_send_splice(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::Splice) -> MessageSendEvent {
+ MessageSendEvent::SendSplice {
+ node_id,
+ msg,
+ }
+}
+#[no_mangle]
+/// Utility method to constructs a new SendSpliceAck-variant MessageSendEvent
+pub extern "C" fn MessageSendEvent_send_splice_ack(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::SpliceAck) -> MessageSendEvent {
+ MessageSendEvent::SendSpliceAck {
+ node_id,
+ msg,
+ }
+}
+#[no_mangle]
+/// Utility method to constructs a new SendSpliceLocked-variant MessageSendEvent
+pub extern "C" fn MessageSendEvent_send_splice_locked(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::SpliceLocked) -> MessageSendEvent {
+ MessageSendEvent::SendSpliceLocked {
+ node_id,
+ msg,
+ }
+}
+#[no_mangle]
/// Utility method to constructs a new SendTxAddInput-variant MessageSendEvent
pub extern "C" fn MessageSendEvent_send_tx_add_input(node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::TxAddInput) -> MessageSendEvent {
MessageSendEvent::SendTxAddInput {
msg,
}
}
+/// Get a string which allows debug introspection of a MessageSendEvent object
+pub extern "C" fn MessageSendEvent_debug_str_void(o: *const c_void) -> Str {
+ alloc::format!("{:?}", unsafe { o as *const crate::lightning::events::MessageSendEvent }).into()}
/// A trait indicating an object may generate message send events
#[repr(C)]
pub struct MessageSendEventsProvider {
}
unsafe impl Send for MessageSendEventsProvider {}
unsafe impl Sync for MessageSendEventsProvider {}
+#[allow(unused)]
pub(crate) fn MessageSendEventsProvider_clone_fields(orig: &MessageSendEventsProvider) -> MessageSendEventsProvider {
MessageSendEventsProvider {
this_arg: orig.this_arg,
}
}
}
-/// A trait indicating an object may generate onion messages to send
-#[repr(C)]
-pub struct OnionMessageProvider {
- /// An opaque pointer which is passed to your function implementations as an argument.
- /// This has no meaning in the LDK, and can be NULL or any other value.
- pub this_arg: *mut c_void,
- /// Gets the next pending onion message for the peer with the given node id.
- ///
- /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
- pub next_onion_message_for_peer: extern "C" fn (this_arg: *const c_void, peer_node_id: crate::c_types::PublicKey) -> crate::lightning::ln::msgs::OnionMessage,
- /// Frees any resources associated with this object given its this_arg pointer.
- /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
- pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
-}
-unsafe impl Send for OnionMessageProvider {}
-unsafe impl Sync for OnionMessageProvider {}
-pub(crate) fn OnionMessageProvider_clone_fields(orig: &OnionMessageProvider) -> OnionMessageProvider {
- OnionMessageProvider {
- this_arg: orig.this_arg,
- next_onion_message_for_peer: Clone::clone(&orig.next_onion_message_for_peer),
- free: Clone::clone(&orig.free),
- }
-}
-
-use lightning::events::OnionMessageProvider as rustOnionMessageProvider;
-impl rustOnionMessageProvider for OnionMessageProvider {
- fn next_onion_message_for_peer(&self, mut peer_node_id: bitcoin::secp256k1::PublicKey) -> Option<lightning::ln::msgs::OnionMessage> {
- let mut ret = (self.next_onion_message_for_peer)(self.this_arg, crate::c_types::PublicKey::from_rust(&peer_node_id));
- let mut local_ret = if ret.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(ret.take_inner()) } }) };
- local_ret
- }
-}
-
-// We're essentially a pointer already, or at least a set of pointers, so allow us to be used
-// directly as a Deref trait in higher-level structs:
-impl core::ops::Deref for OnionMessageProvider {
- type Target = Self;
- fn deref(&self) -> &Self {
- self
- }
-}
-impl core::ops::DerefMut for OnionMessageProvider {
- fn deref_mut(&mut self) -> &mut Self {
- self
- }
-}
-/// Calls the free function if one is set
-#[no_mangle]
-pub extern "C" fn OnionMessageProvider_free(this_ptr: OnionMessageProvider) { }
-impl Drop for OnionMessageProvider {
- fn drop(&mut self) {
- if let Some(f) = self.free {
- f(self.this_arg);
- }
- }
-}
/// A trait indicating an object may generate events.
///
/// Events are processed by passing an [`EventHandler`] to [`process_pending_events`].
}
unsafe impl Send for EventsProvider {}
unsafe impl Sync for EventsProvider {}
+#[allow(unused)]
pub(crate) fn EventsProvider_clone_fields(orig: &EventsProvider) -> EventsProvider {
EventsProvider {
this_arg: orig.this_arg,
}
unsafe impl Send for EventHandler {}
unsafe impl Sync for EventHandler {}
+#[allow(unused)]
pub(crate) fn EventHandler_clone_fields(orig: &EventHandler) -> EventHandler {
EventHandler {
this_arg: orig.this_arg,
projects / ldk-c-bindings / blobdiff