_ Git - ldk-c-bindings/blob - lightning-c-bindings/src/lightning_invoice/utils.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 //! Convenient utilities to create an invoice.
  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 /// Utility to create an invoice that can be paid to one of multiple nodes, or a \"phantom invoice.\"
  20 /// See [`PhantomKeysManager`] for more information on phantom node payments.
  21 ///
  22 /// `phantom_route_hints` parameter:
  23 /// * Contains channel info for all nodes participating in the phantom invoice
  24 /// * Entries are retrieved from a call to [`ChannelManager::get_phantom_route_hints`] on each
  25 ///   participating node
  26 /// * It is fine to cache `phantom_route_hints` and reuse it across invoices, as long as the data is
  27 ///   updated when a channel becomes disabled or closes
  28 /// * Note that if too many channels are included in [`PhantomRouteHints::channels`], the invoice
  29 ///   may be too long for QR code scanning. To fix this, `PhantomRouteHints::channels` may be pared
  30 ///   down
  31 ///
  32 /// `payment_hash` can be specified if you have a specific need for a custom payment hash (see the difference
  33 /// between [`ChannelManager::create_inbound_payment`] and [`ChannelManager::create_inbound_payment_for_hash`]).
  34 /// If `None` is provided for `payment_hash`, then one will be created.
  35 ///
  36 /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for
  37 /// in excess of the current time.
  38 ///
  39 /// Note that the provided `keys_manager`'s `KeysInterface` implementation must support phantom
  40 /// invoices in its `sign_invoice` implementation ([`PhantomKeysManager`] satisfies this
  41 /// requirement).
  42 ///
  43 /// [`PhantomKeysManager`]: lightning::chain::keysinterface::PhantomKeysManager
  44 /// [`ChannelManager::get_phantom_route_hints`]: lightning::ln::channelmanager::ChannelManager::get_phantom_route_hints
  45 /// [`ChannelManager::create_inbound_payment`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment
  46 /// [`ChannelManager::create_inbound_payment_for_hash`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
  47 /// [`PhantomRouteHints::channels`]: lightning::ln::channelmanager::PhantomRouteHints::channels
  48 ///
  49 /// Note that payment_hash (or a relevant inner pointer) may be NULL or all-0s to represent None
  50 #[no_mangle]
  51 pub extern "C" fn create_phantom_invoice(mut amt_msat: crate::c_types::derived::COption_u64Z, mut payment_hash: crate::c_types::ThirtyTwoBytes, mut description: crate::c_types::Str, mut invoice_expiry_delta_secs: u32, mut phantom_route_hints: crate::c_types::derived::CVec_PhantomRouteHintsZ, mut keys_manager: crate::lightning::chain::keysinterface::KeysInterface, mut logger: crate::lightning::util::logger::Logger, mut network: crate::lightning_invoice::Currency) -> crate::c_types::derived::CResult_InvoiceSignOrCreationErrorZ {
  52         let mut local_amt_msat = if amt_msat.is_some() { Some( { amt_msat.take() }) } else { None };
  53         let mut local_payment_hash = if payment_hash.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentHash(payment_hash.data) }) };
  54         let mut local_phantom_route_hints = Vec::new(); for mut item in phantom_route_hints.into_rust().drain(..) { local_phantom_route_hints.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
  55         let mut ret = lightning_invoice::utils::create_phantom_invoice::<crate::lightning::chain::keysinterface::Sign, crate::lightning::chain::keysinterface::KeysInterface, crate::lightning::util::logger::Logger>(local_amt_msat, local_payment_hash, description.into_string(), invoice_expiry_delta_secs, local_phantom_route_hints, keys_manager, logger, network.into_native());
  56         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::Invoice { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::SignOrCreationError::native_into(e) }).into() };
  57         local_ret
  58 }
  59
  60 /// Utility to create an invoice that can be paid to one of multiple nodes, or a \"phantom invoice.\"
  61 /// See [`PhantomKeysManager`] for more information on phantom node payments.
  62 ///
  63 /// `phantom_route_hints` parameter:
  64 /// * Contains channel info for all nodes participating in the phantom invoice
  65 /// * Entries are retrieved from a call to [`ChannelManager::get_phantom_route_hints`] on each
  66 ///   participating node
  67 /// * It is fine to cache `phantom_route_hints` and reuse it across invoices, as long as the data is
  68 ///   updated when a channel becomes disabled or closes
  69 /// * Note that if too many channels are included in [`PhantomRouteHints::channels`], the invoice
  70 ///   may be too long for QR code scanning. To fix this, `PhantomRouteHints::channels` may be pared
  71 ///   down
  72 ///
  73 /// `description_hash` is a SHA-256 hash of the description text
  74 ///
  75 /// `payment_hash` can be specified if you have a specific need for a custom payment hash (see the difference
  76 /// between [`ChannelManager::create_inbound_payment`] and [`ChannelManager::create_inbound_payment_for_hash`]).
  77 /// If `None` is provided for `payment_hash`, then one will be created.
  78 ///
  79 /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for
  80 /// in excess of the current time.
  81 ///
  82 /// Note that the provided `keys_manager`'s `KeysInterface` implementation must support phantom
  83 /// invoices in its `sign_invoice` implementation ([`PhantomKeysManager`] satisfies this
  84 /// requirement).
  85 ///
  86 /// [`PhantomKeysManager`]: lightning::chain::keysinterface::PhantomKeysManager
  87 /// [`ChannelManager::get_phantom_route_hints`]: lightning::ln::channelmanager::ChannelManager::get_phantom_route_hints
  88 /// [`ChannelManager::create_inbound_payment`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment
  89 /// [`ChannelManager::create_inbound_payment_for_hash`]: lightning::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
  90 /// [`PhantomRouteHints::channels`]: lightning::ln::channelmanager::PhantomRouteHints::channels
  91 ///
  92 /// Note that payment_hash (or a relevant inner pointer) may be NULL or all-0s to represent None
  93 #[no_mangle]
  94 pub extern "C" fn create_phantom_invoice_with_description_hash(mut amt_msat: crate::c_types::derived::COption_u64Z, mut payment_hash: crate::c_types::ThirtyTwoBytes, mut invoice_expiry_delta_secs: u32, mut description_hash: crate::lightning_invoice::Sha256, mut phantom_route_hints: crate::c_types::derived::CVec_PhantomRouteHintsZ, mut keys_manager: crate::lightning::chain::keysinterface::KeysInterface, mut logger: crate::lightning::util::logger::Logger, mut network: crate::lightning_invoice::Currency) -> crate::c_types::derived::CResult_InvoiceSignOrCreationErrorZ {
  95         let mut local_amt_msat = if amt_msat.is_some() { Some( { amt_msat.take() }) } else { None };
  96         let mut local_payment_hash = if payment_hash.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentHash(payment_hash.data) }) };
  97         let mut local_phantom_route_hints = Vec::new(); for mut item in phantom_route_hints.into_rust().drain(..) { local_phantom_route_hints.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
  98         let mut ret = lightning_invoice::utils::create_phantom_invoice_with_description_hash::<crate::lightning::chain::keysinterface::Sign, crate::lightning::chain::keysinterface::KeysInterface, crate::lightning::util::logger::Logger>(local_amt_msat, local_payment_hash, invoice_expiry_delta_secs, *unsafe { Box::from_raw(description_hash.take_inner()) }, local_phantom_route_hints, keys_manager, logger, network.into_native());
  99         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::Invoice { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::SignOrCreationError::native_into(e) }).into() };
 100         local_ret
 101 }
 102
 103 /// Utility to construct an invoice. Generally, unless you want to do something like a custom
 104 /// cltv_expiry, this is what you should be using to create an invoice. The reason being, this
 105 /// method stores the invoice's payment secret and preimage in `ChannelManager`, so (a) the user
 106 /// doesn't have to store preimage/payment secret information and (b) `ChannelManager` can verify
 107 /// that the payment secret is valid when the invoice is paid.
 108 ///
 109 /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for
 110 /// in excess of the current time.
 111 #[no_mangle]
 112 pub extern "C" fn create_invoice_from_channelmanager(channelmanager: &crate::lightning::ln::channelmanager::ChannelManager, mut keys_manager: crate::lightning::chain::keysinterface::KeysInterface, mut logger: crate::lightning::util::logger::Logger, mut network: crate::lightning_invoice::Currency, mut amt_msat: crate::c_types::derived::COption_u64Z, mut description: crate::c_types::Str, mut invoice_expiry_delta_secs: u32) -> crate::c_types::derived::CResult_InvoiceSignOrCreationErrorZ {
 113         let mut local_amt_msat = if amt_msat.is_some() { Some( { amt_msat.take() }) } else { None };
 114         let mut ret = lightning_invoice::utils::create_invoice_from_channelmanager::<crate::lightning::chain::keysinterface::Sign, crate::lightning::chain::Watch, crate::lightning::chain::chaininterface::BroadcasterInterface, crate::lightning::chain::keysinterface::KeysInterface, crate::lightning::chain::chaininterface::FeeEstimator, crate::lightning::util::logger::Logger>(channelmanager.get_native_ref(), keys_manager, logger, network.into_native(), local_amt_msat, description.into_string(), invoice_expiry_delta_secs);
 115         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::Invoice { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::SignOrCreationError::native_into(e) }).into() };
 116         local_ret
 117 }
 118
 119 /// Utility to construct an invoice. Generally, unless you want to do something like a custom
 120 /// cltv_expiry, this is what you should be using to create an invoice. The reason being, this
 121 /// method stores the invoice's payment secret and preimage in `ChannelManager`, so (a) the user
 122 /// doesn't have to store preimage/payment secret information and (b) `ChannelManager` can verify
 123 /// that the payment secret is valid when the invoice is paid.
 124 /// Use this variant if you want to pass the `description_hash` to the invoice.
 125 ///
 126 /// `invoice_expiry_delta_secs` describes the number of seconds that the invoice is valid for
 127 /// in excess of the current time.
 128 #[no_mangle]
 129 pub extern "C" fn create_invoice_from_channelmanager_with_description_hash(channelmanager: &crate::lightning::ln::channelmanager::ChannelManager, mut keys_manager: crate::lightning::chain::keysinterface::KeysInterface, mut logger: crate::lightning::util::logger::Logger, mut network: crate::lightning_invoice::Currency, mut amt_msat: crate::c_types::derived::COption_u64Z, mut description_hash: crate::lightning_invoice::Sha256, mut invoice_expiry_delta_secs: u32) -> crate::c_types::derived::CResult_InvoiceSignOrCreationErrorZ {
 130         let mut local_amt_msat = if amt_msat.is_some() { Some( { amt_msat.take() }) } else { None };
 131         let mut ret = lightning_invoice::utils::create_invoice_from_channelmanager_with_description_hash::<crate::lightning::chain::keysinterface::Sign, crate::lightning::chain::Watch, crate::lightning::chain::chaininterface::BroadcasterInterface, crate::lightning::chain::keysinterface::KeysInterface, crate::lightning::chain::chaininterface::FeeEstimator, crate::lightning::util::logger::Logger>(channelmanager.get_native_ref(), keys_manager, logger, network.into_native(), local_amt_msat, *unsafe { Box::from_raw(description_hash.take_inner()) }, invoice_expiry_delta_secs);
 132         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::Invoice { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::SignOrCreationError::native_into(e) }).into() };
 133         local_ret
 134 }
 135
 136 /// See [`create_invoice_from_channelmanager_with_description_hash`]
 137 /// This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not
 138 /// available and the current time is supplied by the caller.
 139 #[no_mangle]
 140 pub extern "C" fn create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: &crate::lightning::ln::channelmanager::ChannelManager, mut keys_manager: crate::lightning::chain::keysinterface::KeysInterface, mut logger: crate::lightning::util::logger::Logger, mut network: crate::lightning_invoice::Currency, mut amt_msat: crate::c_types::derived::COption_u64Z, mut description_hash: crate::lightning_invoice::Sha256, mut duration_since_epoch: u64, mut invoice_expiry_delta_secs: u32) -> crate::c_types::derived::CResult_InvoiceSignOrCreationErrorZ {
 141         let mut local_amt_msat = if amt_msat.is_some() { Some( { amt_msat.take() }) } else { None };
 142         let mut ret = lightning_invoice::utils::create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch::<crate::lightning::chain::keysinterface::Sign, crate::lightning::chain::Watch, crate::lightning::chain::chaininterface::BroadcasterInterface, crate::lightning::chain::keysinterface::KeysInterface, crate::lightning::chain::chaininterface::FeeEstimator, crate::lightning::util::logger::Logger>(channelmanager.get_native_ref(), keys_manager, logger, network.into_native(), local_amt_msat, *unsafe { Box::from_raw(description_hash.take_inner()) }, core::time::Duration::from_secs(duration_since_epoch), invoice_expiry_delta_secs);
 143         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::Invoice { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::SignOrCreationError::native_into(e) }).into() };
 144         local_ret
 145 }
 146
 147 /// See [`create_invoice_from_channelmanager`]
 148 /// This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not
 149 /// available and the current time is supplied by the caller.
 150 #[no_mangle]
 151 pub extern "C" fn create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: &crate::lightning::ln::channelmanager::ChannelManager, mut keys_manager: crate::lightning::chain::keysinterface::KeysInterface, mut logger: crate::lightning::util::logger::Logger, mut network: crate::lightning_invoice::Currency, mut amt_msat: crate::c_types::derived::COption_u64Z, mut description: crate::c_types::Str, mut duration_since_epoch: u64, mut invoice_expiry_delta_secs: u32) -> crate::c_types::derived::CResult_InvoiceSignOrCreationErrorZ {
 152         let mut local_amt_msat = if amt_msat.is_some() { Some( { amt_msat.take() }) } else { None };
 153         let mut ret = lightning_invoice::utils::create_invoice_from_channelmanager_and_duration_since_epoch::<crate::lightning::chain::keysinterface::Sign, crate::lightning::chain::Watch, crate::lightning::chain::chaininterface::BroadcasterInterface, crate::lightning::chain::keysinterface::KeysInterface, crate::lightning::chain::chaininterface::FeeEstimator, crate::lightning::util::logger::Logger>(channelmanager.get_native_ref(), keys_manager, logger, network.into_native(), local_amt_msat, description.into_string(), core::time::Duration::from_secs(duration_since_epoch), invoice_expiry_delta_secs);
 154         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning_invoice::Invoice { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_invoice::SignOrCreationError::native_into(e) }).into() };
 155         local_ret
 156 }
 157
 158
 159 use lightning_invoice::utils::DefaultRouter as nativeDefaultRouterImport;
 160 pub(crate) type nativeDefaultRouter = nativeDefaultRouterImport<&'static lightning::routing::gossip::NetworkGraph<crate::lightning::util::logger::Logger>, crate::lightning::util::logger::Logger, crate::lightning::routing::scoring::LockableScore>;
 161
 162 /// A [`Router`] implemented using [`find_route`].
 163 #[must_use]
 164 #[repr(C)]
 165 pub struct DefaultRouter {
 166         /// A pointer to the opaque Rust object.
 167
 168         /// Nearly everywhere, inner must be non-null, however in places where
 169         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 170         pub inner: *mut nativeDefaultRouter,
 171         /// Indicates that this is the only struct which contains the same pointer.
 172
 173         /// Rust functions which take ownership of an object provided via an argument require
 174         /// this to be true and invalidate the object pointed to by inner.
 175         pub is_owned: bool,
 176 }
 177
 178 impl Drop for DefaultRouter {
 179         fn drop(&mut self) {
 180                 if self.is_owned && !<*mut nativeDefaultRouter>::is_null(self.inner) {
 181                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 182                 }
 183         }
 184 }
 185 /// Frees any resources used by the DefaultRouter, if is_owned is set and inner is non-NULL.
 186 #[no_mangle]
 187 pub extern "C" fn DefaultRouter_free(this_obj: DefaultRouter) { }
 188 #[allow(unused)]
 189 /// Used only if an object of this type is returned as a trait impl by a method
 190 pub(crate) extern "C" fn DefaultRouter_free_void(this_ptr: *mut c_void) {
 191         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDefaultRouter); }
 192 }
 193 #[allow(unused)]
 194 impl DefaultRouter {
 195         pub(crate) fn get_native_ref(&self) -> &'static nativeDefaultRouter {
 196                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 197         }
 198         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeDefaultRouter {
 199                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 200         }
 201         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 202         pub(crate) fn take_inner(mut self) -> *mut nativeDefaultRouter {
 203                 assert!(self.is_owned);
 204                 let ret = ObjOps::untweak_ptr(self.inner);
 205                 self.inner = core::ptr::null_mut();
 206                 ret
 207         }
 208 }
 209 /// Creates a new router using the given [`NetworkGraph`], a [`Logger`], and a randomness source
 210 /// `random_seed_bytes`.
 211 #[must_use]
 212 #[no_mangle]
 213 pub extern "C" fn DefaultRouter_new(network_graph: &crate::lightning::routing::gossip::NetworkGraph, mut logger: crate::lightning::util::logger::Logger, mut random_seed_bytes: crate::c_types::ThirtyTwoBytes, mut scorer: crate::lightning::routing::scoring::LockableScore) -> crate::lightning_invoice::utils::DefaultRouter {
 214         let mut ret = lightning_invoice::utils::DefaultRouter::new(network_graph.get_native_ref(), logger, random_seed_bytes.data, scorer);
 215         crate::lightning_invoice::utils::DefaultRouter { inner: ObjOps::heap_alloc(ret), is_owned: true }
 216 }
 217
 218 impl From<nativeDefaultRouter> for crate::lightning_invoice::payment::Router {
 219         fn from(obj: nativeDefaultRouter) -> Self {
 220                 let mut rust_obj = DefaultRouter { inner: ObjOps::heap_alloc(obj), is_owned: true };
 221                 let mut ret = DefaultRouter_as_Router(&rust_obj);
 222                 // We want to free rust_obj when ret gets drop()'d, not rust_obj, so wipe rust_obj's pointer and set ret's free() fn
 223                 rust_obj.inner = core::ptr::null_mut();
 224                 ret.free = Some(DefaultRouter_free_void);
 225                 ret
 226         }
 227 }
 228 /// Constructs a new Router which calls the relevant methods on this_arg.
 229 /// This copies the `inner` pointer in this_arg and thus the returned Router must be freed before this_arg is
 230 #[no_mangle]
 231 pub extern "C" fn DefaultRouter_as_Router(this_arg: &DefaultRouter) -> crate::lightning_invoice::payment::Router {
 232         crate::lightning_invoice::payment::Router {
 233                 this_arg: unsafe { ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void },
 234                 free: None,
 235                 find_route: DefaultRouter_Router_find_route,
 236                 notify_payment_path_failed: DefaultRouter_Router_notify_payment_path_failed,
 237                 notify_payment_path_successful: DefaultRouter_Router_notify_payment_path_successful,
 238                 notify_payment_probe_successful: DefaultRouter_Router_notify_payment_probe_successful,
 239                 notify_payment_probe_failed: DefaultRouter_Router_notify_payment_probe_failed,
 240         }
 241 }
 242
 243 #[must_use]
 244 extern "C" fn DefaultRouter_Router_find_route(this_arg: *const c_void, mut payer: crate::c_types::PublicKey, route_params: &crate::lightning::routing::router::RouteParameters, payment_hash: *const [u8; 32], first_hops: *mut crate::c_types::derived::CVec_ChannelDetailsZ, mut inflight_htlcs: crate::lightning_invoice::payment::InFlightHtlcs) -> crate::c_types::derived::CResult_RouteLightningErrorZ {
 245         let mut local_first_hops_base = if first_hops == core::ptr::null_mut() { None } else { Some( { let mut local_first_hops_0 = Vec::new(); for mut item in unsafe { &mut *first_hops }.as_slice().iter() { local_first_hops_0.push( { item.get_native_ref() }); }; local_first_hops_0 }) }; let mut local_first_hops = local_first_hops_base.as_ref().map(|a| &a[..]);
 246         let mut ret = <nativeDefaultRouter as lightning_invoice::payment::Router<>>::find_route(unsafe { &mut *(this_arg as *mut nativeDefaultRouter) }, &payer.into_rust(), route_params.get_native_ref(), &::lightning::ln::PaymentHash(unsafe { *payment_hash }), local_first_hops, *unsafe { Box::from_raw(inflight_htlcs.take_inner()) });
 247         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::routing::router::Route { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::LightningError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() };
 248         local_ret
 249 }
 250 extern "C" fn DefaultRouter_Router_notify_payment_path_failed(this_arg: *const c_void, mut path: crate::c_types::derived::CVec_RouteHopZ, mut short_channel_id: u64) {
 251         let mut local_path = Vec::new(); for mut item in path.as_slice().iter() { local_path.push( { item.get_native_ref() }); };
 252         <nativeDefaultRouter as lightning_invoice::payment::Router<>>::notify_payment_path_failed(unsafe { &mut *(this_arg as *mut nativeDefaultRouter) }, &local_path[..], short_channel_id)
 253 }
 254 extern "C" fn DefaultRouter_Router_notify_payment_path_successful(this_arg: *const c_void, mut path: crate::c_types::derived::CVec_RouteHopZ) {
 255         let mut local_path = Vec::new(); for mut item in path.as_slice().iter() { local_path.push( { item.get_native_ref() }); };
 256         <nativeDefaultRouter as lightning_invoice::payment::Router<>>::notify_payment_path_successful(unsafe { &mut *(this_arg as *mut nativeDefaultRouter) }, &local_path[..])
 257 }
 258 extern "C" fn DefaultRouter_Router_notify_payment_probe_successful(this_arg: *const c_void, mut path: crate::c_types::derived::CVec_RouteHopZ) {
 259         let mut local_path = Vec::new(); for mut item in path.as_slice().iter() { local_path.push( { item.get_native_ref() }); };
 260         <nativeDefaultRouter as lightning_invoice::payment::Router<>>::notify_payment_probe_successful(unsafe { &mut *(this_arg as *mut nativeDefaultRouter) }, &local_path[..])
 261 }
 262 extern "C" fn DefaultRouter_Router_notify_payment_probe_failed(this_arg: *const c_void, mut path: crate::c_types::derived::CVec_RouteHopZ, mut short_channel_id: u64) {
 263         let mut local_path = Vec::new(); for mut item in path.as_slice().iter() { local_path.push( { item.get_native_ref() }); };
 264         <nativeDefaultRouter as lightning_invoice::payment::Router<>>::notify_payment_probe_failed(unsafe { &mut *(this_arg as *mut nativeDefaultRouter) }, &local_path[..], short_channel_id)
 265 }
 266
 267 impl From<nativeChannelManager> for crate::lightning_invoice::payment::Payer {
 268         fn from(obj: nativeChannelManager) -> Self {
 269                 let mut rust_obj = ChannelManager { inner: ObjOps::heap_alloc(obj), is_owned: true };
 270                 let mut ret = ChannelManager_as_Payer(&rust_obj);
 271                 // We want to free rust_obj when ret gets drop()'d, not rust_obj, so wipe rust_obj's pointer and set ret's free() fn
 272                 rust_obj.inner = core::ptr::null_mut();
 273                 ret.free = Some(ChannelManager_free_void);
 274                 ret
 275         }
 276 }
 277 /// Constructs a new Payer which calls the relevant methods on this_arg.
 278 /// This copies the `inner` pointer in this_arg and thus the returned Payer must be freed before this_arg is
 279 #[no_mangle]
 280 pub extern "C" fn ChannelManager_as_Payer(this_arg: &ChannelManager) -> crate::lightning_invoice::payment::Payer {
 281         crate::lightning_invoice::payment::Payer {
 282                 this_arg: unsafe { ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void },
 283                 free: None,
 284                 node_id: ChannelManager_Payer_node_id,
 285                 first_hops: ChannelManager_Payer_first_hops,
 286                 send_payment: ChannelManager_Payer_send_payment,
 287                 send_spontaneous_payment: ChannelManager_Payer_send_spontaneous_payment,
 288                 retry_payment: ChannelManager_Payer_retry_payment,
 289                 abandon_payment: ChannelManager_Payer_abandon_payment,
 290         }
 291 }
 292
 293 #[must_use]
 294 extern "C" fn ChannelManager_Payer_node_id(this_arg: *const c_void) -> crate::c_types::PublicKey {
 295         let mut ret = <nativeChannelManager as lightning_invoice::payment::Payer<>>::node_id(unsafe { &mut *(this_arg as *mut nativeChannelManager) }, );
 296         crate::c_types::PublicKey::from_rust(&ret)
 297 }
 298 #[must_use]
 299 extern "C" fn ChannelManager_Payer_first_hops(this_arg: *const c_void) -> crate::c_types::derived::CVec_ChannelDetailsZ {
 300         let mut ret = <nativeChannelManager as lightning_invoice::payment::Payer<>>::first_hops(unsafe { &mut *(this_arg as *mut nativeChannelManager) }, );
 301         let mut local_ret = Vec::new(); for mut item in ret.drain(..) { local_ret.push( { crate::lightning::ln::channelmanager::ChannelDetails { inner: ObjOps::heap_alloc(item), is_owned: true } }); };
 302         local_ret.into()
 303 }
 304 #[must_use]
 305 extern "C" fn ChannelManager_Payer_send_payment(this_arg: *const c_void, route: &crate::lightning::routing::router::Route, mut payment_hash: crate::c_types::ThirtyTwoBytes, mut payment_secret: crate::c_types::ThirtyTwoBytes) -> crate::c_types::derived::CResult_PaymentIdPaymentSendFailureZ {
 306         let mut local_payment_secret = if payment_secret.data == [0; 32] { None } else { Some( { ::lightning::ln::PaymentSecret(payment_secret.data) }) };
 307         let mut ret = <nativeChannelManager as lightning_invoice::payment::Payer<>>::send_payment(unsafe { &mut *(this_arg as *mut nativeChannelManager) }, route.get_native_ref(), ::lightning::ln::PaymentHash(payment_hash.data), &local_payment_secret);
 308         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::ThirtyTwoBytes { data: o.0 } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::channelmanager::PaymentSendFailure::native_into(e) }).into() };
 309         local_ret
 310 }
 311 #[must_use]
 312 extern "C" fn ChannelManager_Payer_send_spontaneous_payment(this_arg: *const c_void, route: &crate::lightning::routing::router::Route, mut payment_preimage: crate::c_types::ThirtyTwoBytes) -> crate::c_types::derived::CResult_PaymentIdPaymentSendFailureZ {
 313         let mut ret = <nativeChannelManager as lightning_invoice::payment::Payer<>>::send_spontaneous_payment(unsafe { &mut *(this_arg as *mut nativeChannelManager) }, route.get_native_ref(), ::lightning::ln::PaymentPreimage(payment_preimage.data));
 314         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::c_types::ThirtyTwoBytes { data: o.0 } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::channelmanager::PaymentSendFailure::native_into(e) }).into() };
 315         local_ret
 316 }
 317 #[must_use]
 318 extern "C" fn ChannelManager_Payer_retry_payment(this_arg: *const c_void, route: &crate::lightning::routing::router::Route, mut payment_id: crate::c_types::ThirtyTwoBytes) -> crate::c_types::derived::CResult_NonePaymentSendFailureZ {
 319         let mut ret = <nativeChannelManager as lightning_invoice::payment::Payer<>>::retry_payment(unsafe { &mut *(this_arg as *mut nativeChannelManager) }, route.get_native_ref(), ::lightning::ln::channelmanager::PaymentId(payment_id.data));
 320         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { () /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::channelmanager::PaymentSendFailure::native_into(e) }).into() };
 321         local_ret
 322 }
 323 extern "C" fn ChannelManager_Payer_abandon_payment(this_arg: *const c_void, mut payment_id: crate::c_types::ThirtyTwoBytes) {
 324         <nativeChannelManager as lightning_invoice::payment::Payer<>>::abandon_payment(unsafe { &mut *(this_arg as *mut nativeChannelManager) }, ::lightning::ln::channelmanager::PaymentId(payment_id.data))
 325 }
 326
 327 use crate::lightning::ln::channelmanager::nativeChannelManager as nativeChannelManager;
 328 use crate::lightning::ln::channelmanager::ChannelManager;
 329 use crate::lightning::ln::channelmanager::ChannelManager_free_void;