_ Git - ldk-c-bindings/blob - lightning-c-bindings/src/lightning/onion_message/offers.rs

   1 // This file is Copyright its original authors, visible in version control
   2 // history and in the source files from which this was generated.
   3 //
   4 // This file is licensed under the license available in the LICENSE or LICENSE.md
   5 // file in the root of this repository or, if no such file exists, the same
   6 // license as that which applies to the original source files from which this
   7 // source was automatically generated.
   8
   9 //! Message handling for BOLT 12 Offers.
  10
  11 use alloc::str::FromStr;
  12 use core::ffi::c_void;
  13 use core::convert::Infallible;
  14 use bitcoin::hashes::Hash;
  15 use crate::c_types::*;
  16 #[cfg(feature="no-std")]
  17 use alloc::{vec::Vec, boxed::Box};
  18
  19 /// A handler for an [`OnionMessage`] containing a BOLT 12 Offers message as its payload.
  20 ///
  21 /// [`OnionMessage`]: crate::ln::msgs::OnionMessage
  22 #[repr(C)]
  23 pub struct OffersMessageHandler {
  24         /// An opaque pointer which is passed to your function implementations as an argument.
  25         /// This has no meaning in the LDK, and can be NULL or any other value.
  26         pub this_arg: *mut c_void,
  27         /// Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
  28         /// or replying with an error.
  29         pub handle_message: extern "C" fn (this_arg: *const c_void, message: crate::lightning::onion_message::offers::OffersMessage) -> crate::c_types::derived::COption_OffersMessageZ,
  30         /// Frees any resources associated with this object given its this_arg pointer.
  31         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
  32         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
  33 }
  34 unsafe impl Send for OffersMessageHandler {}
  35 unsafe impl Sync for OffersMessageHandler {}
  36 #[no_mangle]
  37 pub(crate) extern "C" fn OffersMessageHandler_clone_fields(orig: &OffersMessageHandler) -> OffersMessageHandler {
  38         OffersMessageHandler {
  39                 this_arg: orig.this_arg,
  40                 handle_message: Clone::clone(&orig.handle_message),
  41                 free: Clone::clone(&orig.free),
  42         }
  43 }
  44
  45 use lightning::onion_message::offers::OffersMessageHandler as rustOffersMessageHandler;
  46 impl rustOffersMessageHandler for OffersMessageHandler {
  47         fn handle_message(&self, mut message: lightning::onion_message::offers::OffersMessage) -> Option<lightning::onion_message::offers::OffersMessage> {
  48                 let mut ret = (self.handle_message)(self.this_arg, crate::lightning::onion_message::offers::OffersMessage::native_into(message));
  49                 let mut local_ret = { /*ret*/ let ret_opt = ret; if ret_opt.is_none() { None } else { Some({ { { ret_opt.take() }.into_native() }})} };
  50                 local_ret
  51         }
  52 }
  53
  54 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
  55 // directly as a Deref trait in higher-level structs:
  56 impl core::ops::Deref for OffersMessageHandler {
  57         type Target = Self;
  58         fn deref(&self) -> &Self {
  59                 self
  60         }
  61 }
  62 /// Calls the free function if one is set
  63 #[no_mangle]
  64 pub extern "C" fn OffersMessageHandler_free(this_ptr: OffersMessageHandler) { }
  65 impl Drop for OffersMessageHandler {
  66         fn drop(&mut self) {
  67                 if let Some(f) = self.free {
  68                         f(self.this_arg);
  69                 }
  70         }
  71 }
  72 /// Possible BOLT 12 Offers messages sent and received via an [`OnionMessage`].
  73 ///
  74 /// [`OnionMessage`]: crate::ln::msgs::OnionMessage
  75 #[derive(Clone)]
  76 #[must_use]
  77 #[repr(C)]
  78 pub enum OffersMessage {
  79         /// A request for a [`Bolt12Invoice`] for a particular [`Offer`].
  80         ///
  81         /// [`Offer`]: crate::offers::offer::Offer
  82         InvoiceRequest(
  83                 crate::lightning::offers::invoice_request::InvoiceRequest),
  84         /// A [`Bolt12Invoice`] sent in response to an [`InvoiceRequest`] or a [`Refund`].
  85         ///
  86         /// [`Refund`]: crate::offers::refund::Refund
  87         Invoice(
  88                 crate::lightning::offers::invoice::Bolt12Invoice),
  89         /// An error from handling an [`OffersMessage`].
  90         InvoiceError(
  91                 crate::lightning::offers::invoice_error::InvoiceError),
  92 }
  93 use lightning::onion_message::offers::OffersMessage as OffersMessageImport;
  94 pub(crate) type nativeOffersMessage = OffersMessageImport;
  95
  96 impl OffersMessage {
  97         #[allow(unused)]
  98         pub(crate) fn to_native(&self) -> nativeOffersMessage {
  99                 match self {
 100                         OffersMessage::InvoiceRequest (ref a, ) => {
 101                                 let mut a_nonref = Clone::clone(a);
 102                                 nativeOffersMessage::InvoiceRequest (
 103                                         *unsafe { Box::from_raw(a_nonref.take_inner()) },
 104                                 )
 105                         },
 106                         OffersMessage::Invoice (ref a, ) => {
 107                                 let mut a_nonref = Clone::clone(a);
 108                                 nativeOffersMessage::Invoice (
 109                                         *unsafe { Box::from_raw(a_nonref.take_inner()) },
 110                                 )
 111                         },
 112                         OffersMessage::InvoiceError (ref a, ) => {
 113                                 let mut a_nonref = Clone::clone(a);
 114                                 nativeOffersMessage::InvoiceError (
 115                                         *unsafe { Box::from_raw(a_nonref.take_inner()) },
 116                                 )
 117                         },
 118                 }
 119         }
 120         #[allow(unused)]
 121         pub(crate) fn into_native(self) -> nativeOffersMessage {
 122                 match self {
 123                         OffersMessage::InvoiceRequest (mut a, ) => {
 124                                 nativeOffersMessage::InvoiceRequest (
 125                                         *unsafe { Box::from_raw(a.take_inner()) },
 126                                 )
 127                         },
 128                         OffersMessage::Invoice (mut a, ) => {
 129                                 nativeOffersMessage::Invoice (
 130                                         *unsafe { Box::from_raw(a.take_inner()) },
 131                                 )
 132                         },
 133                         OffersMessage::InvoiceError (mut a, ) => {
 134                                 nativeOffersMessage::InvoiceError (
 135                                         *unsafe { Box::from_raw(a.take_inner()) },
 136                                 )
 137                         },
 138                 }
 139         }
 140         #[allow(unused)]
 141         pub(crate) fn from_native(native: &nativeOffersMessage) -> Self {
 142                 match native {
 143                         nativeOffersMessage::InvoiceRequest (ref a, ) => {
 144                                 let mut a_nonref = Clone::clone(a);
 145                                 OffersMessage::InvoiceRequest (
 146                                         crate::lightning::offers::invoice_request::InvoiceRequest { inner: ObjOps::heap_alloc(a_nonref), is_owned: true },
 147                                 )
 148                         },
 149                         nativeOffersMessage::Invoice (ref a, ) => {
 150                                 let mut a_nonref = Clone::clone(a);
 151                                 OffersMessage::Invoice (
 152                                         crate::lightning::offers::invoice::Bolt12Invoice { inner: ObjOps::heap_alloc(a_nonref), is_owned: true },
 153                                 )
 154                         },
 155                         nativeOffersMessage::InvoiceError (ref a, ) => {
 156                                 let mut a_nonref = Clone::clone(a);
 157                                 OffersMessage::InvoiceError (
 158                                         crate::lightning::offers::invoice_error::InvoiceError { inner: ObjOps::heap_alloc(a_nonref), is_owned: true },
 159                                 )
 160                         },
 161                 }
 162         }
 163         #[allow(unused)]
 164         pub(crate) fn native_into(native: nativeOffersMessage) -> Self {
 165                 match native {
 166                         nativeOffersMessage::InvoiceRequest (mut a, ) => {
 167                                 OffersMessage::InvoiceRequest (
 168                                         crate::lightning::offers::invoice_request::InvoiceRequest { inner: ObjOps::heap_alloc(a), is_owned: true },
 169                                 )
 170                         },
 171                         nativeOffersMessage::Invoice (mut a, ) => {
 172                                 OffersMessage::Invoice (
 173                                         crate::lightning::offers::invoice::Bolt12Invoice { inner: ObjOps::heap_alloc(a), is_owned: true },
 174                                 )
 175                         },
 176                         nativeOffersMessage::InvoiceError (mut a, ) => {
 177                                 OffersMessage::InvoiceError (
 178                                         crate::lightning::offers::invoice_error::InvoiceError { inner: ObjOps::heap_alloc(a), is_owned: true },
 179                                 )
 180                         },
 181                 }
 182         }
 183 }
 184 /// Frees any resources used by the OffersMessage
 185 #[no_mangle]
 186 pub extern "C" fn OffersMessage_free(this_ptr: OffersMessage) { }
 187 /// Creates a copy of the OffersMessage
 188 #[no_mangle]
 189 pub extern "C" fn OffersMessage_clone(orig: &OffersMessage) -> OffersMessage {
 190         orig.clone()
 191 }
 192 #[no_mangle]
 193 /// Utility method to constructs a new InvoiceRequest-variant OffersMessage
 194 pub extern "C" fn OffersMessage_invoice_request(a: crate::lightning::offers::invoice_request::InvoiceRequest) -> OffersMessage {
 195         OffersMessage::InvoiceRequest(a, )
 196 }
 197 #[no_mangle]
 198 /// Utility method to constructs a new Invoice-variant OffersMessage
 199 pub extern "C" fn OffersMessage_invoice(a: crate::lightning::offers::invoice::Bolt12Invoice) -> OffersMessage {
 200         OffersMessage::Invoice(a, )
 201 }
 202 #[no_mangle]
 203 /// Utility method to constructs a new InvoiceError-variant OffersMessage
 204 pub extern "C" fn OffersMessage_invoice_error(a: crate::lightning::offers::invoice_error::InvoiceError) -> OffersMessage {
 205         OffersMessage::InvoiceError(a, )
 206 }
 207 /// Returns whether `tlv_type` corresponds to a TLV record for Offers.
 208 #[must_use]
 209 #[no_mangle]
 210 pub extern "C" fn OffersMessage_is_known_type(mut tlv_type: u64) -> bool {
 211         let mut ret = lightning::onion_message::offers::OffersMessage::is_known_type(tlv_type);
 212         ret
 213 }
 214
 215 /// The TLV record type for the message as used in an `onionmsg_tlv` TLV stream.
 216 #[must_use]
 217 #[no_mangle]
 218 pub extern "C" fn OffersMessage_tlv_type(this_arg: &crate::lightning::onion_message::offers::OffersMessage) -> u64 {
 219         let mut ret = this_arg.to_native().tlv_type();
 220         ret
 221 }
 222
 223 #[no_mangle]
 224 /// Serialize the OffersMessage object into a byte array which can be read by OffersMessage_read
 225 pub extern "C" fn OffersMessage_write(obj: &crate::lightning::onion_message::offers::OffersMessage) -> crate::c_types::derived::CVec_u8Z {
 226         crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
 227 }
 228 #[no_mangle]
 229 /// Read a OffersMessage from a byte array, created by OffersMessage_write
 230 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 {
 231         let arg_a_conv = arg_a;
 232         let arg_b_conv = arg_b;
 233         let arg_conv = (arg_a_conv, arg_b_conv);
 234         let res: Result<lightning::onion_message::offers::OffersMessage, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj_arg(ser, arg_conv);
 235         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() };
 236         local_res
 237 }