X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Flightning%2Fonion_message%2Foffers.rs;fp=lightning-c-bindings%2Fsrc%2Flightning%2Fonion_message%2Foffers.rs;h=55fd8e1fd7308b68f13fd77d562b0f60a102b36d;hp=0000000000000000000000000000000000000000;hb=7ebc93258c70a014e9129c0b464256d2ee670751;hpb=334f6732f8c2f09f4b169c6ca0ea792c0c1ae48d diff --git a/lightning-c-bindings/src/lightning/onion_message/offers.rs b/lightning-c-bindings/src/lightning/onion_message/offers.rs new file mode 100644 index 0000000..55fd8e1 --- /dev/null +++ b/lightning-c-bindings/src/lightning/onion_message/offers.rs @@ -0,0 +1,237 @@ +// This file is Copyright its original authors, visible in version control +// history and in the source files from which this was generated. +// +// This file is licensed under the license available in the LICENSE or LICENSE.md +// file in the root of this repository or, if no such file exists, the same +// license as that which applies to the original source files from which this +// source was automatically generated. + +//! Message handling for BOLT 12 Offers. + +use alloc::str::FromStr; +use core::ffi::c_void; +use core::convert::Infallible; +use bitcoin::hashes::Hash; +use crate::c_types::*; +#[cfg(feature="no-std")] +use alloc::{vec::Vec, boxed::Box}; + +/// A handler for an [`OnionMessage`] containing a BOLT 12 Offers message as its payload. +/// +/// [`OnionMessage`]: crate::ln::msgs::OnionMessage +#[repr(C)] +pub struct OffersMessageHandler { + /// 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, + /// Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment, + /// or replying with an error. + pub handle_message: extern "C" fn (this_arg: *const c_void, message: crate::lightning::onion_message::offers::OffersMessage) -> crate::c_types::derived::COption_OffersMessageZ, + /// Frees any resources associated with this object given its this_arg pointer. + /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed. + pub free: Option, +} +unsafe impl Send for OffersMessageHandler {} +unsafe impl Sync for OffersMessageHandler {} +#[no_mangle] +pub(crate) extern "C" fn OffersMessageHandler_clone_fields(orig: &OffersMessageHandler) -> OffersMessageHandler { + OffersMessageHandler { + this_arg: orig.this_arg, + handle_message: Clone::clone(&orig.handle_message), + free: Clone::clone(&orig.free), + } +} + +use lightning::onion_message::offers::OffersMessageHandler as rustOffersMessageHandler; +impl rustOffersMessageHandler for OffersMessageHandler { + fn handle_message(&self, mut message: lightning::onion_message::offers::OffersMessage) -> Option { + let mut ret = (self.handle_message)(self.this_arg, crate::lightning::onion_message::offers::OffersMessage::native_into(message)); + let mut local_ret = { /*ret*/ let ret_opt = ret; if ret_opt.is_none() { None } else { Some({ { { ret_opt.take() }.into_native() }})} }; + 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 OffersMessageHandler { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} +/// Calls the free function if one is set +#[no_mangle] +pub extern "C" fn OffersMessageHandler_free(this_ptr: OffersMessageHandler) { } +impl Drop for OffersMessageHandler { + fn drop(&mut self) { + if let Some(f) = self.free { + f(self.this_arg); + } + } +} +/// Possible BOLT 12 Offers messages sent and received via an [`OnionMessage`]. +/// +/// [`OnionMessage`]: crate::ln::msgs::OnionMessage +#[derive(Clone)] +#[must_use] +#[repr(C)] +pub enum OffersMessage { + /// A request for a [`Bolt12Invoice`] for a particular [`Offer`]. + /// + /// [`Offer`]: crate::offers::offer::Offer + InvoiceRequest( + crate::lightning::offers::invoice_request::InvoiceRequest), + /// A [`Bolt12Invoice`] sent in response to an [`InvoiceRequest`] or a [`Refund`]. + /// + /// [`Refund`]: crate::offers::refund::Refund + Invoice( + crate::lightning::offers::invoice::Bolt12Invoice), + /// An error from handling an [`OffersMessage`]. + InvoiceError( + crate::lightning::offers::invoice_error::InvoiceError), +} +use lightning::onion_message::offers::OffersMessage as OffersMessageImport; +pub(crate) type nativeOffersMessage = OffersMessageImport; + +impl OffersMessage { + #[allow(unused)] + pub(crate) fn to_native(&self) -> nativeOffersMessage { + match self { + OffersMessage::InvoiceRequest (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeOffersMessage::InvoiceRequest ( + *unsafe { Box::from_raw(a_nonref.take_inner()) }, + ) + }, + OffersMessage::Invoice (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeOffersMessage::Invoice ( + *unsafe { Box::from_raw(a_nonref.take_inner()) }, + ) + }, + OffersMessage::InvoiceError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + nativeOffersMessage::InvoiceError ( + *unsafe { Box::from_raw(a_nonref.take_inner()) }, + ) + }, + } + } + #[allow(unused)] + pub(crate) fn into_native(self) -> nativeOffersMessage { + match self { + OffersMessage::InvoiceRequest (mut a, ) => { + nativeOffersMessage::InvoiceRequest ( + *unsafe { Box::from_raw(a.take_inner()) }, + ) + }, + OffersMessage::Invoice (mut a, ) => { + nativeOffersMessage::Invoice ( + *unsafe { Box::from_raw(a.take_inner()) }, + ) + }, + OffersMessage::InvoiceError (mut a, ) => { + nativeOffersMessage::InvoiceError ( + *unsafe { Box::from_raw(a.take_inner()) }, + ) + }, + } + } + #[allow(unused)] + pub(crate) fn from_native(native: &nativeOffersMessage) -> Self { + match native { + nativeOffersMessage::InvoiceRequest (ref a, ) => { + let mut a_nonref = Clone::clone(a); + OffersMessage::InvoiceRequest ( + crate::lightning::offers::invoice_request::InvoiceRequest { inner: ObjOps::heap_alloc(a_nonref), is_owned: true }, + ) + }, + nativeOffersMessage::Invoice (ref a, ) => { + let mut a_nonref = Clone::clone(a); + OffersMessage::Invoice ( + crate::lightning::offers::invoice::Bolt12Invoice { inner: ObjOps::heap_alloc(a_nonref), is_owned: true }, + ) + }, + nativeOffersMessage::InvoiceError (ref a, ) => { + let mut a_nonref = Clone::clone(a); + OffersMessage::InvoiceError ( + crate::lightning::offers::invoice_error::InvoiceError { inner: ObjOps::heap_alloc(a_nonref), is_owned: true }, + ) + }, + } + } + #[allow(unused)] + pub(crate) fn native_into(native: nativeOffersMessage) -> Self { + match native { + nativeOffersMessage::InvoiceRequest (mut a, ) => { + OffersMessage::InvoiceRequest ( + crate::lightning::offers::invoice_request::InvoiceRequest { inner: ObjOps::heap_alloc(a), is_owned: true }, + ) + }, + nativeOffersMessage::Invoice (mut a, ) => { + OffersMessage::Invoice ( + crate::lightning::offers::invoice::Bolt12Invoice { inner: ObjOps::heap_alloc(a), is_owned: true }, + ) + }, + nativeOffersMessage::InvoiceError (mut a, ) => { + OffersMessage::InvoiceError ( + crate::lightning::offers::invoice_error::InvoiceError { inner: ObjOps::heap_alloc(a), is_owned: true }, + ) + }, + } + } +} +/// Frees any resources used by the OffersMessage +#[no_mangle] +pub extern "C" fn OffersMessage_free(this_ptr: OffersMessage) { } +/// Creates a copy of the OffersMessage +#[no_mangle] +pub extern "C" fn OffersMessage_clone(orig: &OffersMessage) -> OffersMessage { + orig.clone() +} +#[no_mangle] +/// Utility method to constructs a new InvoiceRequest-variant OffersMessage +pub extern "C" fn OffersMessage_invoice_request(a: crate::lightning::offers::invoice_request::InvoiceRequest) -> OffersMessage { + OffersMessage::InvoiceRequest(a, ) +} +#[no_mangle] +/// Utility method to constructs a new Invoice-variant OffersMessage +pub extern "C" fn OffersMessage_invoice(a: crate::lightning::offers::invoice::Bolt12Invoice) -> OffersMessage { + OffersMessage::Invoice(a, ) +} +#[no_mangle] +/// Utility method to constructs a new InvoiceError-variant OffersMessage +pub extern "C" fn OffersMessage_invoice_error(a: crate::lightning::offers::invoice_error::InvoiceError) -> OffersMessage { + OffersMessage::InvoiceError(a, ) +} +/// Returns whether `tlv_type` corresponds to a TLV record for Offers. +#[must_use] +#[no_mangle] +pub extern "C" fn OffersMessage_is_known_type(mut tlv_type: u64) -> bool { + let mut ret = lightning::onion_message::offers::OffersMessage::is_known_type(tlv_type); + ret +} + +/// The TLV record type for the message as used in an `onionmsg_tlv` TLV stream. +#[must_use] +#[no_mangle] +pub extern "C" fn OffersMessage_tlv_type(this_arg: &crate::lightning::onion_message::offers::OffersMessage) -> u64 { + let mut ret = this_arg.to_native().tlv_type(); + ret +} + +#[no_mangle] +/// Serialize the OffersMessage object into a byte array which can be read by OffersMessage_read +pub extern "C" fn OffersMessage_write(obj: &crate::lightning::onion_message::offers::OffersMessage) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(&unsafe { &*obj }.to_native()) +} +#[no_mangle] +/// Read a OffersMessage from a byte array, created by OffersMessage_write +pub extern "C" fn OffersMessage_read(ser: crate::c_types::u8slice, arg_a: u64, arg_b: &crate::lightning::util::logger::Logger) -> crate::c_types::derived::CResult_OffersMessageDecodeErrorZ { + let arg_a_conv = arg_a; + let arg_b_conv = arg_b; + let arg_conv = (arg_a_conv, arg_b_conv); + let res: Result = crate::c_types::deserialize_obj_arg(ser, arg_conv); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::onion_message::offers::OffersMessage::native_into(o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError::native_into(e) }).into() }; + local_res +}