_ 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 alloc::string::String;
  13 use core::ffi::c_void;
  14 use core::convert::Infallible;
  15 use bitcoin::hashes::Hash;
  16 use crate::c_types::*;
  17 #[cfg(feature="no-std")]
  18 use alloc::{vec::Vec, boxed::Box};
  19
  20 /// A handler for an [`OnionMessage`] containing a BOLT 12 Offers message as its payload.
  21 ///
  22 /// [`OnionMessage`]: crate::ln::msgs::OnionMessage
  23 #[repr(C)]
  24 pub struct OffersMessageHandler {
  25         /// An opaque pointer which is passed to your function implementations as an argument.
  26         /// This has no meaning in the LDK, and can be NULL or any other value.
  27         pub this_arg: *mut c_void,
  28         /// Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
  29         /// or replying with an error.
  30         ///
  31         /// The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
  32         ///
  33         /// [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
  34         pub handle_message: extern "C" fn (this_arg: *const c_void, message: crate::lightning::onion_message::offers::OffersMessage) -> crate::c_types::derived::COption_OffersMessageZ,
  35         /// Releases any [`OffersMessage`]s that need to be sent.
  36         ///
  37         /// Typically, this is used for messages initiating a payment flow rather than in response to
  38         /// another message. The latter should use the return value of [`Self::handle_message`].
  39         pub release_pending_messages: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ,
  40         /// Frees any resources associated with this object given its this_arg pointer.
  41         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
  42         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
  43 }
  44 unsafe impl Send for OffersMessageHandler {}
  45 unsafe impl Sync for OffersMessageHandler {}
  46 #[allow(unused)]
  47 pub(crate) fn OffersMessageHandler_clone_fields(orig: &OffersMessageHandler) -> OffersMessageHandler {
  48         OffersMessageHandler {
  49                 this_arg: orig.this_arg,
  50                 handle_message: Clone::clone(&orig.handle_message),
  51                 release_pending_messages: Clone::clone(&orig.release_pending_messages),
  52                 free: Clone::clone(&orig.free),
  53         }
  54 }
  55
  56 use lightning::onion_message::offers::OffersMessageHandler as rustOffersMessageHandler;
  57 impl rustOffersMessageHandler for OffersMessageHandler {
  58         fn handle_message(&self, mut message: lightning::onion_message::offers::OffersMessage) -> Option<lightning::onion_message::offers::OffersMessage> {
  59                 let mut ret = (self.handle_message)(self.this_arg, crate::lightning::onion_message::offers::OffersMessage::native_into(message));
  60                 let mut local_ret = { /*ret*/ let ret_opt = ret; if ret_opt.is_none() { None } else { Some({ { { ret_opt.take() }.into_native() }})} };
  61                 local_ret
  62         }
  63         fn release_pending_messages(&self) -> Vec<(lightning::onion_message::offers::OffersMessage, lightning::onion_message::messenger::Destination, Option<lightning::blinded_path::BlindedPath>)> {
  64                 let mut ret = (self.release_pending_messages)(self.this_arg);
  65                 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { let (mut orig_ret_0_0, mut orig_ret_0_1, mut orig_ret_0_2) = item.to_rust(); let mut local_orig_ret_0_2 = if orig_ret_0_2.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(orig_ret_0_2.take_inner()) } }) }; let mut local_ret_0 = (orig_ret_0_0.into_native(), orig_ret_0_1.into_native(), local_orig_ret_0_2); local_ret_0 }); };
  66                 local_ret
  67         }
  68 }
  69
  70 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
  71 // directly as a Deref trait in higher-level structs:
  72 impl core::ops::Deref for OffersMessageHandler {
  73         type Target = Self;
  74         fn deref(&self) -> &Self {
  75                 self
  76         }
  77 }
  78 impl core::ops::DerefMut for OffersMessageHandler {
  79         fn deref_mut(&mut self) -> &mut Self {
  80                 self
  81         }
  82 }
  83 /// Calls the free function if one is set
  84 #[no_mangle]
  85 pub extern "C" fn OffersMessageHandler_free(this_ptr: OffersMessageHandler) { }
  86 impl Drop for OffersMessageHandler {
  87         fn drop(&mut self) {
  88                 if let Some(f) = self.free {
  89                         f(self.this_arg);
  90                 }
  91         }
  92 }
  93 /// Possible BOLT 12 Offers messages sent and received via an [`OnionMessage`].
  94 ///
  95 /// [`OnionMessage`]: crate::ln::msgs::OnionMessage
  96 #[derive(Clone)]
  97 #[must_use]
  98 #[repr(C)]
  99 pub enum OffersMessage {
 100         /// A request for a [`Bolt12Invoice`] for a particular [`Offer`].
 101         ///
 102         /// [`Offer`]: crate::offers::offer::Offer
 103         InvoiceRequest(
 104                 crate::lightning::offers::invoice_request::InvoiceRequest),
 105         /// A [`Bolt12Invoice`] sent in response to an [`InvoiceRequest`] or a [`Refund`].
 106         ///
 107         /// [`Refund`]: crate::offers::refund::Refund
 108         Invoice(
 109                 crate::lightning::offers::invoice::Bolt12Invoice),
 110         /// An error from handling an [`OffersMessage`].
 111         InvoiceError(
 112                 crate::lightning::offers::invoice_error::InvoiceError),
 113 }
 114 use lightning::onion_message::offers::OffersMessage as OffersMessageImport;
 115 pub(crate) type nativeOffersMessage = OffersMessageImport;
 116
 117 impl OffersMessage {
 118         #[allow(unused)]
 119         pub(crate) fn to_native(&self) -> nativeOffersMessage {
 120                 match self {
 121                         OffersMessage::InvoiceRequest (ref a, ) => {
 122                                 let mut a_nonref = Clone::clone(a);
 123                                 nativeOffersMessage::InvoiceRequest (
 124                                         *unsafe { Box::from_raw(a_nonref.take_inner()) },
 125                                 )
 126                         },
 127                         OffersMessage::Invoice (ref a, ) => {
 128                                 let mut a_nonref = Clone::clone(a);
 129                                 nativeOffersMessage::Invoice (
 130                                         *unsafe { Box::from_raw(a_nonref.take_inner()) },
 131                                 )
 132                         },
 133                         OffersMessage::InvoiceError (ref a, ) => {
 134                                 let mut a_nonref = Clone::clone(a);
 135                                 nativeOffersMessage::InvoiceError (
 136                                         *unsafe { Box::from_raw(a_nonref.take_inner()) },
 137                                 )
 138                         },
 139                 }
 140         }
 141         #[allow(unused)]
 142         pub(crate) fn into_native(self) -> nativeOffersMessage {
 143                 match self {
 144                         OffersMessage::InvoiceRequest (mut a, ) => {
 145                                 nativeOffersMessage::InvoiceRequest (
 146                                         *unsafe { Box::from_raw(a.take_inner()) },
 147                                 )
 148                         },
 149                         OffersMessage::Invoice (mut a, ) => {
 150                                 nativeOffersMessage::Invoice (
 151                                         *unsafe { Box::from_raw(a.take_inner()) },
 152                                 )
 153                         },
 154                         OffersMessage::InvoiceError (mut a, ) => {
 155                                 nativeOffersMessage::InvoiceError (
 156                                         *unsafe { Box::from_raw(a.take_inner()) },
 157                                 )
 158                         },
 159                 }
 160         }
 161         #[allow(unused)]
 162         pub(crate) fn from_native(native: &OffersMessageImport) -> Self {
 163                 let native = unsafe { &*(native as *const _ as *const c_void as *const nativeOffersMessage) };
 164                 match native {
 165                         nativeOffersMessage::InvoiceRequest (ref a, ) => {
 166                                 let mut a_nonref = Clone::clone(a);
 167                                 OffersMessage::InvoiceRequest (
 168                                         crate::lightning::offers::invoice_request::InvoiceRequest { inner: ObjOps::heap_alloc(a_nonref), is_owned: true },
 169                                 )
 170                         },
 171                         nativeOffersMessage::Invoice (ref a, ) => {
 172                                 let mut a_nonref = Clone::clone(a);
 173                                 OffersMessage::Invoice (
 174                                         crate::lightning::offers::invoice::Bolt12Invoice { inner: ObjOps::heap_alloc(a_nonref), is_owned: true },
 175                                 )
 176                         },
 177                         nativeOffersMessage::InvoiceError (ref a, ) => {
 178                                 let mut a_nonref = Clone::clone(a);
 179                                 OffersMessage::InvoiceError (
 180                                         crate::lightning::offers::invoice_error::InvoiceError { inner: ObjOps::heap_alloc(a_nonref), is_owned: true },
 181                                 )
 182                         },
 183                 }
 184         }
 185         #[allow(unused)]
 186         pub(crate) fn native_into(native: nativeOffersMessage) -> Self {
 187                 match native {
 188                         nativeOffersMessage::InvoiceRequest (mut a, ) => {
 189                                 OffersMessage::InvoiceRequest (
 190                                         crate::lightning::offers::invoice_request::InvoiceRequest { inner: ObjOps::heap_alloc(a), is_owned: true },
 191                                 )
 192                         },
 193                         nativeOffersMessage::Invoice (mut a, ) => {
 194                                 OffersMessage::Invoice (
 195                                         crate::lightning::offers::invoice::Bolt12Invoice { inner: ObjOps::heap_alloc(a), is_owned: true },
 196                                 )
 197                         },
 198                         nativeOffersMessage::InvoiceError (mut a, ) => {
 199                                 OffersMessage::InvoiceError (
 200                                         crate::lightning::offers::invoice_error::InvoiceError { inner: ObjOps::heap_alloc(a), is_owned: true },
 201                                 )
 202                         },
 203                 }
 204         }
 205 }
 206 /// Frees any resources used by the OffersMessage
 207 #[no_mangle]
 208 pub extern "C" fn OffersMessage_free(this_ptr: OffersMessage) { }
 209 /// Creates a copy of the OffersMessage
 210 #[no_mangle]
 211 pub extern "C" fn OffersMessage_clone(orig: &OffersMessage) -> OffersMessage {
 212         orig.clone()
 213 }
 214 #[allow(unused)]
 215 /// Used only if an object of this type is returned as a trait impl by a method
 216 pub(crate) extern "C" fn OffersMessage_clone_void(this_ptr: *const c_void) -> *mut c_void {
 217         Box::into_raw(Box::new(unsafe { (*(this_ptr as *const OffersMessage)).clone() })) as *mut c_void
 218 }
 219 #[allow(unused)]
 220 /// Used only if an object of this type is returned as a trait impl by a method
 221 pub(crate) extern "C" fn OffersMessage_free_void(this_ptr: *mut c_void) {
 222         let _ = unsafe { Box::from_raw(this_ptr as *mut OffersMessage) };
 223 }
 224 #[no_mangle]
 225 /// Utility method to constructs a new InvoiceRequest-variant OffersMessage
 226 pub extern "C" fn OffersMessage_invoice_request(a: crate::lightning::offers::invoice_request::InvoiceRequest) -> OffersMessage {
 227         OffersMessage::InvoiceRequest(a, )
 228 }
 229 #[no_mangle]
 230 /// Utility method to constructs a new Invoice-variant OffersMessage
 231 pub extern "C" fn OffersMessage_invoice(a: crate::lightning::offers::invoice::Bolt12Invoice) -> OffersMessage {
 232         OffersMessage::Invoice(a, )
 233 }
 234 #[no_mangle]
 235 /// Utility method to constructs a new InvoiceError-variant OffersMessage
 236 pub extern "C" fn OffersMessage_invoice_error(a: crate::lightning::offers::invoice_error::InvoiceError) -> OffersMessage {
 237         OffersMessage::InvoiceError(a, )
 238 }
 239 /// Returns whether `tlv_type` corresponds to a TLV record for Offers.
 240 #[must_use]
 241 #[no_mangle]
 242 pub extern "C" fn OffersMessage_is_known_type(mut tlv_type: u64) -> bool {
 243         let mut ret = lightning::onion_message::offers::OffersMessage::is_known_type(tlv_type);
 244         ret
 245 }
 246
 247 /// Get a string which allows debug introspection of a OffersMessage object
 248 pub extern "C" fn OffersMessage_debug_str_void(o: *const c_void) -> Str {
 249         alloc::format!("{:?}", unsafe { o as *const crate::lightning::onion_message::offers::OffersMessage }).into()}
 250 impl From<nativeOffersMessage> for crate::lightning::onion_message::packet::OnionMessageContents {
 251         fn from(obj: nativeOffersMessage) -> Self {
 252                 let rust_obj = crate::lightning::onion_message::offers::OffersMessage::native_into(obj);
 253                 let mut ret = OffersMessage_as_OnionMessageContents(&rust_obj);
 254                 // We want to free rust_obj when ret gets drop()'d, not rust_obj, so forget it and set ret's free() fn
 255                 core::mem::forget(rust_obj);
 256                 ret.free = Some(OffersMessage_free_void);
 257                 ret
 258         }
 259 }
 260 /// Constructs a new OnionMessageContents which calls the relevant methods on this_arg.
 261 /// This copies the `inner` pointer in this_arg and thus the returned OnionMessageContents must be freed before this_arg is
 262 #[no_mangle]
 263 pub extern "C" fn OffersMessage_as_OnionMessageContents(this_arg: &OffersMessage) -> crate::lightning::onion_message::packet::OnionMessageContents {
 264         crate::lightning::onion_message::packet::OnionMessageContents {
 265                 this_arg: unsafe { ObjOps::untweak_ptr(this_arg as *const OffersMessage as *mut OffersMessage) as *mut c_void },
 266                 free: None,
 267                 tlv_type: OffersMessage_OnionMessageContents_tlv_type,
 268                 write: OffersMessage_write_void,
 269                 debug_str: OffersMessage_debug_str_void,
 270                 cloned: Some(OnionMessageContents_OffersMessage_cloned),
 271         }
 272 }
 273
 274 #[must_use]
 275 extern "C" fn OffersMessage_OnionMessageContents_tlv_type(this_arg: *const c_void) -> u64 {
 276         let mut ret = <nativeOffersMessage as lightning::onion_message::packet::OnionMessageContents<>>::tlv_type(unsafe { &mut *(this_arg as *mut nativeOffersMessage) }, );
 277         ret
 278 }
 279 extern "C" fn OnionMessageContents_OffersMessage_cloned(new_obj: &mut crate::lightning::onion_message::packet::OnionMessageContents) {
 280         new_obj.this_arg = OffersMessage_clone_void(new_obj.this_arg);
 281         new_obj.free = Some(OffersMessage_free_void);
 282 }
 283
 284 #[no_mangle]
 285 /// Serialize the OffersMessage object into a byte array which can be read by OffersMessage_read
 286 pub extern "C" fn OffersMessage_write(obj: &crate::lightning::onion_message::offers::OffersMessage) -> crate::c_types::derived::CVec_u8Z {
 287         crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
 288 }
 289 #[allow(unused)]
 290 pub(crate) extern "C" fn OffersMessage_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 291         OffersMessage_write(unsafe { &*(obj as *const OffersMessage) })
 292 }
 293 #[no_mangle]
 294 /// Read a OffersMessage from a byte array, created by OffersMessage_write
 295 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 {
 296         let arg_a_conv = arg_a;
 297         let arg_b_conv = arg_b;
 298         let arg_conv = (arg_a_conv, arg_b_conv);
 299         let res: Result<lightning::onion_message::offers::OffersMessage, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj_arg(ser, arg_conv);
 300         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() };
 301         local_res
 302 }