_ Git - ldk-c-bindings/blob - lightning-c-bindings/src/lightning/routing/router.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 //! The top-level routing/network map tracking logic lives here.
  10 //!
  11 //! You probably want to create a NetGraphMsgHandler and use that as your RoutingMessageHandler and then
  12 //! interrogate it to get routes for your own payments.
  13
  14 use alloc::str::FromStr;
  15 use core::ffi::c_void;
  16 use core::convert::Infallible;
  17 use bitcoin::hashes::Hash;
  18 use crate::c_types::*;
  19 #[cfg(feature="no-std")]
  20 use alloc::{vec::Vec, boxed::Box};
  21
  22
  23 use lightning::routing::router::RouteHop as nativeRouteHopImport;
  24 pub(crate) type nativeRouteHop = nativeRouteHopImport;
  25
  26 /// A hop in a route
  27 #[must_use]
  28 #[repr(C)]
  29 pub struct RouteHop {
  30         /// A pointer to the opaque Rust object.
  31
  32         /// Nearly everywhere, inner must be non-null, however in places where
  33         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
  34         pub inner: *mut nativeRouteHop,
  35         /// Indicates that this is the only struct which contains the same pointer.
  36
  37         /// Rust functions which take ownership of an object provided via an argument require
  38         /// this to be true and invalidate the object pointed to by inner.
  39         pub is_owned: bool,
  40 }
  41
  42 impl Drop for RouteHop {
  43         fn drop(&mut self) {
  44                 if self.is_owned && !<*mut nativeRouteHop>::is_null(self.inner) {
  45                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
  46                 }
  47         }
  48 }
  49 /// Frees any resources used by the RouteHop, if is_owned is set and inner is non-NULL.
  50 #[no_mangle]
  51 pub extern "C" fn RouteHop_free(this_obj: RouteHop) { }
  52 #[allow(unused)]
  53 /// Used only if an object of this type is returned as a trait impl by a method
  54 pub(crate) extern "C" fn RouteHop_free_void(this_ptr: *mut c_void) {
  55         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRouteHop); }
  56 }
  57 #[allow(unused)]
  58 impl RouteHop {
  59         pub(crate) fn get_native_ref(&self) -> &'static nativeRouteHop {
  60                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
  61         }
  62         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRouteHop {
  63                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
  64         }
  65         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
  66         pub(crate) fn take_inner(mut self) -> *mut nativeRouteHop {
  67                 assert!(self.is_owned);
  68                 let ret = ObjOps::untweak_ptr(self.inner);
  69                 self.inner = core::ptr::null_mut();
  70                 ret
  71         }
  72 }
  73 /// The node_id of the node at this hop.
  74 #[no_mangle]
  75 pub extern "C" fn RouteHop_get_pubkey(this_ptr: &RouteHop) -> crate::c_types::PublicKey {
  76         let mut inner_val = &mut this_ptr.get_native_mut_ref().pubkey;
  77         crate::c_types::PublicKey::from_rust(&inner_val)
  78 }
  79 /// The node_id of the node at this hop.
  80 #[no_mangle]
  81 pub extern "C" fn RouteHop_set_pubkey(this_ptr: &mut RouteHop, mut val: crate::c_types::PublicKey) {
  82         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.pubkey = val.into_rust();
  83 }
  84 /// The node_announcement features of the node at this hop. For the last hop, these may be
  85 /// amended to match the features present in the invoice this node generated.
  86 #[no_mangle]
  87 pub extern "C" fn RouteHop_get_node_features(this_ptr: &RouteHop) -> crate::lightning::ln::features::NodeFeatures {
  88         let mut inner_val = &mut this_ptr.get_native_mut_ref().node_features;
  89         crate::lightning::ln::features::NodeFeatures { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::features::NodeFeatures<>) as *mut _) }, is_owned: false }
  90 }
  91 /// The node_announcement features of the node at this hop. For the last hop, these may be
  92 /// amended to match the features present in the invoice this node generated.
  93 #[no_mangle]
  94 pub extern "C" fn RouteHop_set_node_features(this_ptr: &mut RouteHop, mut val: crate::lightning::ln::features::NodeFeatures) {
  95         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.node_features = *unsafe { Box::from_raw(val.take_inner()) };
  96 }
  97 /// The channel that should be used from the previous hop to reach this node.
  98 #[no_mangle]
  99 pub extern "C" fn RouteHop_get_short_channel_id(this_ptr: &RouteHop) -> u64 {
 100         let mut inner_val = &mut this_ptr.get_native_mut_ref().short_channel_id;
 101         *inner_val
 102 }
 103 /// The channel that should be used from the previous hop to reach this node.
 104 #[no_mangle]
 105 pub extern "C" fn RouteHop_set_short_channel_id(this_ptr: &mut RouteHop, mut val: u64) {
 106         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_id = val;
 107 }
 108 /// The channel_announcement features of the channel that should be used from the previous hop
 109 /// to reach this node.
 110 #[no_mangle]
 111 pub extern "C" fn RouteHop_get_channel_features(this_ptr: &RouteHop) -> crate::lightning::ln::features::ChannelFeatures {
 112         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_features;
 113         crate::lightning::ln::features::ChannelFeatures { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::features::ChannelFeatures<>) as *mut _) }, is_owned: false }
 114 }
 115 /// The channel_announcement features of the channel that should be used from the previous hop
 116 /// to reach this node.
 117 #[no_mangle]
 118 pub extern "C" fn RouteHop_set_channel_features(this_ptr: &mut RouteHop, mut val: crate::lightning::ln::features::ChannelFeatures) {
 119         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_features = *unsafe { Box::from_raw(val.take_inner()) };
 120 }
 121 /// The fee taken on this hop (for paying for the use of the *next* channel in the path).
 122 /// For the last hop, this should be the full value of the payment (might be more than
 123 /// requested if we had to match htlc_minimum_msat).
 124 #[no_mangle]
 125 pub extern "C" fn RouteHop_get_fee_msat(this_ptr: &RouteHop) -> u64 {
 126         let mut inner_val = &mut this_ptr.get_native_mut_ref().fee_msat;
 127         *inner_val
 128 }
 129 /// The fee taken on this hop (for paying for the use of the *next* channel in the path).
 130 /// For the last hop, this should be the full value of the payment (might be more than
 131 /// requested if we had to match htlc_minimum_msat).
 132 #[no_mangle]
 133 pub extern "C" fn RouteHop_set_fee_msat(this_ptr: &mut RouteHop, mut val: u64) {
 134         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fee_msat = val;
 135 }
 136 /// The CLTV delta added for this hop. For the last hop, this should be the full CLTV value
 137 /// expected at the destination, in excess of the current block height.
 138 #[no_mangle]
 139 pub extern "C" fn RouteHop_get_cltv_expiry_delta(this_ptr: &RouteHop) -> u32 {
 140         let mut inner_val = &mut this_ptr.get_native_mut_ref().cltv_expiry_delta;
 141         *inner_val
 142 }
 143 /// The CLTV delta added for this hop. For the last hop, this should be the full CLTV value
 144 /// expected at the destination, in excess of the current block height.
 145 #[no_mangle]
 146 pub extern "C" fn RouteHop_set_cltv_expiry_delta(this_ptr: &mut RouteHop, mut val: u32) {
 147         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry_delta = val;
 148 }
 149 /// Constructs a new RouteHop given each field
 150 #[must_use]
 151 #[no_mangle]
 152 pub extern "C" fn RouteHop_new(mut pubkey_arg: crate::c_types::PublicKey, mut node_features_arg: crate::lightning::ln::features::NodeFeatures, mut short_channel_id_arg: u64, mut channel_features_arg: crate::lightning::ln::features::ChannelFeatures, mut fee_msat_arg: u64, mut cltv_expiry_delta_arg: u32) -> RouteHop {
 153         RouteHop { inner: ObjOps::heap_alloc(nativeRouteHop {
 154                 pubkey: pubkey_arg.into_rust(),
 155                 node_features: *unsafe { Box::from_raw(node_features_arg.take_inner()) },
 156                 short_channel_id: short_channel_id_arg,
 157                 channel_features: *unsafe { Box::from_raw(channel_features_arg.take_inner()) },
 158                 fee_msat: fee_msat_arg,
 159                 cltv_expiry_delta: cltv_expiry_delta_arg,
 160         }), is_owned: true }
 161 }
 162 impl Clone for RouteHop {
 163         fn clone(&self) -> Self {
 164                 Self {
 165                         inner: if <*mut nativeRouteHop>::is_null(self.inner) { core::ptr::null_mut() } else {
 166                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 167                         is_owned: true,
 168                 }
 169         }
 170 }
 171 #[allow(unused)]
 172 /// Used only if an object of this type is returned as a trait impl by a method
 173 pub(crate) extern "C" fn RouteHop_clone_void(this_ptr: *const c_void) -> *mut c_void {
 174         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRouteHop)).clone() })) as *mut c_void
 175 }
 176 #[no_mangle]
 177 /// Creates a copy of the RouteHop
 178 pub extern "C" fn RouteHop_clone(orig: &RouteHop) -> RouteHop {
 179         orig.clone()
 180 }
 181 /// Checks if two RouteHops contain equal inner contents.
 182 #[no_mangle]
 183 pub extern "C" fn RouteHop_hash(o: &RouteHop) -> u64 {
 184         if o.inner.is_null() { return 0; }
 185         // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
 186         #[allow(deprecated)]
 187         let mut hasher = core::hash::SipHasher::new();
 188         core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
 189         core::hash::Hasher::finish(&hasher)
 190 }
 191 /// Checks if two RouteHops contain equal inner contents.
 192 /// This ignores pointers and is_owned flags and looks at the values in fields.
 193 /// Two objects with NULL inner values will be considered "equal" here.
 194 #[no_mangle]
 195 pub extern "C" fn RouteHop_eq(a: &RouteHop, b: &RouteHop) -> bool {
 196         if a.inner == b.inner { return true; }
 197         if a.inner.is_null() || b.inner.is_null() { return false; }
 198         if a.get_native_ref() == b.get_native_ref() { true } else { false }
 199 }
 200 #[no_mangle]
 201 /// Serialize the RouteHop object into a byte array which can be read by RouteHop_read
 202 pub extern "C" fn RouteHop_write(obj: &RouteHop) -> crate::c_types::derived::CVec_u8Z {
 203         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
 204 }
 205 #[no_mangle]
 206 pub(crate) extern "C" fn RouteHop_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 207         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeRouteHop) })
 208 }
 209 #[no_mangle]
 210 /// Read a RouteHop from a byte array, created by RouteHop_write
 211 pub extern "C" fn RouteHop_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_RouteHopDecodeErrorZ {
 212         let res: Result<lightning::routing::router::RouteHop, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
 213         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::routing::router::RouteHop { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() };
 214         local_res
 215 }
 216
 217 use lightning::routing::router::Route as nativeRouteImport;
 218 pub(crate) type nativeRoute = nativeRouteImport;
 219
 220 /// A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP,
 221 /// it can take multiple paths. Each path is composed of one or more hops through the network.
 222 #[must_use]
 223 #[repr(C)]
 224 pub struct Route {
 225         /// A pointer to the opaque Rust object.
 226
 227         /// Nearly everywhere, inner must be non-null, however in places where
 228         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 229         pub inner: *mut nativeRoute,
 230         /// Indicates that this is the only struct which contains the same pointer.
 231
 232         /// Rust functions which take ownership of an object provided via an argument require
 233         /// this to be true and invalidate the object pointed to by inner.
 234         pub is_owned: bool,
 235 }
 236
 237 impl Drop for Route {
 238         fn drop(&mut self) {
 239                 if self.is_owned && !<*mut nativeRoute>::is_null(self.inner) {
 240                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 241                 }
 242         }
 243 }
 244 /// Frees any resources used by the Route, if is_owned is set and inner is non-NULL.
 245 #[no_mangle]
 246 pub extern "C" fn Route_free(this_obj: Route) { }
 247 #[allow(unused)]
 248 /// Used only if an object of this type is returned as a trait impl by a method
 249 pub(crate) extern "C" fn Route_free_void(this_ptr: *mut c_void) {
 250         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRoute); }
 251 }
 252 #[allow(unused)]
 253 impl Route {
 254         pub(crate) fn get_native_ref(&self) -> &'static nativeRoute {
 255                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 256         }
 257         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRoute {
 258                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 259         }
 260         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 261         pub(crate) fn take_inner(mut self) -> *mut nativeRoute {
 262                 assert!(self.is_owned);
 263                 let ret = ObjOps::untweak_ptr(self.inner);
 264                 self.inner = core::ptr::null_mut();
 265                 ret
 266         }
 267 }
 268 /// The list of routes taken for a single (potentially-)multi-part payment. The pubkey of the
 269 /// last RouteHop in each path must be the same.
 270 /// Each entry represents a list of hops, NOT INCLUDING our own, where the last hop is the
 271 /// destination. Thus, this must always be at least length one. While the maximum length of any
 272 /// given path is variable, keeping the length of any path to less than 20 should currently
 273 /// ensure it is viable.
 274 #[no_mangle]
 275 pub extern "C" fn Route_get_paths(this_ptr: &Route) -> crate::c_types::derived::CVec_CVec_RouteHopZZ {
 276         let mut inner_val = &mut this_ptr.get_native_mut_ref().paths;
 277         let mut local_inner_val = Vec::new(); for item in inner_val.iter() { local_inner_val.push( { let mut local_inner_val_0 = Vec::new(); for item in item.iter() { local_inner_val_0.push( { crate::lightning::routing::router::RouteHop { inner: unsafe { ObjOps::nonnull_ptr_to_inner((item as *const lightning::routing::router::RouteHop<>) as *mut _) }, is_owned: false } }); }; local_inner_val_0.into() }); };
 278         local_inner_val.into()
 279 }
 280 /// The list of routes taken for a single (potentially-)multi-part payment. The pubkey of the
 281 /// last RouteHop in each path must be the same.
 282 /// Each entry represents a list of hops, NOT INCLUDING our own, where the last hop is the
 283 /// destination. Thus, this must always be at least length one. While the maximum length of any
 284 /// given path is variable, keeping the length of any path to less than 20 should currently
 285 /// ensure it is viable.
 286 #[no_mangle]
 287 pub extern "C" fn Route_set_paths(this_ptr: &mut Route, mut val: crate::c_types::derived::CVec_CVec_RouteHopZZ) {
 288         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { let mut local_val_0 = Vec::new(); for mut item in item.into_rust().drain(..) { local_val_0.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; local_val_0 }); };
 289         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.paths = local_val;
 290 }
 291 /// The `payment_params` parameter passed to [`find_route`].
 292 /// This is used by `ChannelManager` to track information which may be required for retries,
 293 /// provided back to you via [`Event::PaymentPathFailed`].
 294 ///
 295 /// [`Event::PaymentPathFailed`]: crate::util::events::Event::PaymentPathFailed
 296 ///
 297 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
 298 #[no_mangle]
 299 pub extern "C" fn Route_get_payment_params(this_ptr: &Route) -> crate::lightning::routing::router::PaymentParameters {
 300         let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_params;
 301         let mut local_inner_val = crate::lightning::routing::router::PaymentParameters { inner: unsafe { (if inner_val.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (inner_val.as_ref().unwrap()) }) } as *const lightning::routing::router::PaymentParameters<>) as *mut _ }, is_owned: false };
 302         local_inner_val
 303 }
 304 /// The `payment_params` parameter passed to [`find_route`].
 305 /// This is used by `ChannelManager` to track information which may be required for retries,
 306 /// provided back to you via [`Event::PaymentPathFailed`].
 307 ///
 308 /// [`Event::PaymentPathFailed`]: crate::util::events::Event::PaymentPathFailed
 309 ///
 310 /// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
 311 #[no_mangle]
 312 pub extern "C" fn Route_set_payment_params(this_ptr: &mut Route, mut val: crate::lightning::routing::router::PaymentParameters) {
 313         let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
 314         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_params = local_val;
 315 }
 316 /// Constructs a new Route given each field
 317 #[must_use]
 318 #[no_mangle]
 319 pub extern "C" fn Route_new(mut paths_arg: crate::c_types::derived::CVec_CVec_RouteHopZZ, mut payment_params_arg: crate::lightning::routing::router::PaymentParameters) -> Route {
 320         let mut local_paths_arg = Vec::new(); for mut item in paths_arg.into_rust().drain(..) { local_paths_arg.push( { let mut local_paths_arg_0 = Vec::new(); for mut item in item.into_rust().drain(..) { local_paths_arg_0.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; local_paths_arg_0 }); };
 321         let mut local_payment_params_arg = if payment_params_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(payment_params_arg.take_inner()) } }) };
 322         Route { inner: ObjOps::heap_alloc(nativeRoute {
 323                 paths: local_paths_arg,
 324                 payment_params: local_payment_params_arg,
 325         }), is_owned: true }
 326 }
 327 impl Clone for Route {
 328         fn clone(&self) -> Self {
 329                 Self {
 330                         inner: if <*mut nativeRoute>::is_null(self.inner) { core::ptr::null_mut() } else {
 331                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 332                         is_owned: true,
 333                 }
 334         }
 335 }
 336 #[allow(unused)]
 337 /// Used only if an object of this type is returned as a trait impl by a method
 338 pub(crate) extern "C" fn Route_clone_void(this_ptr: *const c_void) -> *mut c_void {
 339         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRoute)).clone() })) as *mut c_void
 340 }
 341 #[no_mangle]
 342 /// Creates a copy of the Route
 343 pub extern "C" fn Route_clone(orig: &Route) -> Route {
 344         orig.clone()
 345 }
 346 /// Checks if two Routes contain equal inner contents.
 347 #[no_mangle]
 348 pub extern "C" fn Route_hash(o: &Route) -> u64 {
 349         if o.inner.is_null() { return 0; }
 350         // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
 351         #[allow(deprecated)]
 352         let mut hasher = core::hash::SipHasher::new();
 353         core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
 354         core::hash::Hasher::finish(&hasher)
 355 }
 356 /// Checks if two Routes contain equal inner contents.
 357 /// This ignores pointers and is_owned flags and looks at the values in fields.
 358 /// Two objects with NULL inner values will be considered "equal" here.
 359 #[no_mangle]
 360 pub extern "C" fn Route_eq(a: &Route, b: &Route) -> bool {
 361         if a.inner == b.inner { return true; }
 362         if a.inner.is_null() || b.inner.is_null() { return false; }
 363         if a.get_native_ref() == b.get_native_ref() { true } else { false }
 364 }
 365 /// Returns the total amount of fees paid on this [`Route`].
 366 ///
 367 /// This doesn't include any extra payment made to the recipient, which can happen in excess of
 368 /// the amount passed to [`find_route`]'s `params.final_value_msat`.
 369 #[must_use]
 370 #[no_mangle]
 371 pub extern "C" fn Route_get_total_fees(this_arg: &Route) -> u64 {
 372         let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.get_total_fees();
 373         ret
 374 }
 375
 376 /// Returns the total amount paid on this [`Route`], excluding the fees.
 377 #[must_use]
 378 #[no_mangle]
 379 pub extern "C" fn Route_get_total_amount(this_arg: &Route) -> u64 {
 380         let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.get_total_amount();
 381         ret
 382 }
 383
 384 #[no_mangle]
 385 /// Serialize the Route object into a byte array which can be read by Route_read
 386 pub extern "C" fn Route_write(obj: &Route) -> crate::c_types::derived::CVec_u8Z {
 387         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
 388 }
 389 #[no_mangle]
 390 pub(crate) extern "C" fn Route_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 391         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeRoute) })
 392 }
 393 #[no_mangle]
 394 /// Read a Route from a byte array, created by Route_write
 395 pub extern "C" fn Route_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_RouteDecodeErrorZ {
 396         let res: Result<lightning::routing::router::Route, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
 397         let mut local_res = match res { 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::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() };
 398         local_res
 399 }
 400
 401 use lightning::routing::router::RouteParameters as nativeRouteParametersImport;
 402 pub(crate) type nativeRouteParameters = nativeRouteParametersImport;
 403
 404 /// Parameters needed to find a [`Route`].
 405 ///
 406 /// Passed to [`find_route`] and also provided in [`Event::PaymentPathFailed`] for retrying a failed
 407 /// payment path.
 408 ///
 409 /// [`Event::PaymentPathFailed`]: crate::util::events::Event::PaymentPathFailed
 410 #[must_use]
 411 #[repr(C)]
 412 pub struct RouteParameters {
 413         /// A pointer to the opaque Rust object.
 414
 415         /// Nearly everywhere, inner must be non-null, however in places where
 416         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 417         pub inner: *mut nativeRouteParameters,
 418         /// Indicates that this is the only struct which contains the same pointer.
 419
 420         /// Rust functions which take ownership of an object provided via an argument require
 421         /// this to be true and invalidate the object pointed to by inner.
 422         pub is_owned: bool,
 423 }
 424
 425 impl Drop for RouteParameters {
 426         fn drop(&mut self) {
 427                 if self.is_owned && !<*mut nativeRouteParameters>::is_null(self.inner) {
 428                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 429                 }
 430         }
 431 }
 432 /// Frees any resources used by the RouteParameters, if is_owned is set and inner is non-NULL.
 433 #[no_mangle]
 434 pub extern "C" fn RouteParameters_free(this_obj: RouteParameters) { }
 435 #[allow(unused)]
 436 /// Used only if an object of this type is returned as a trait impl by a method
 437 pub(crate) extern "C" fn RouteParameters_free_void(this_ptr: *mut c_void) {
 438         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRouteParameters); }
 439 }
 440 #[allow(unused)]
 441 impl RouteParameters {
 442         pub(crate) fn get_native_ref(&self) -> &'static nativeRouteParameters {
 443                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 444         }
 445         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRouteParameters {
 446                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 447         }
 448         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 449         pub(crate) fn take_inner(mut self) -> *mut nativeRouteParameters {
 450                 assert!(self.is_owned);
 451                 let ret = ObjOps::untweak_ptr(self.inner);
 452                 self.inner = core::ptr::null_mut();
 453                 ret
 454         }
 455 }
 456 /// The parameters of the failed payment path.
 457 #[no_mangle]
 458 pub extern "C" fn RouteParameters_get_payment_params(this_ptr: &RouteParameters) -> crate::lightning::routing::router::PaymentParameters {
 459         let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_params;
 460         crate::lightning::routing::router::PaymentParameters { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::routing::router::PaymentParameters<>) as *mut _) }, is_owned: false }
 461 }
 462 /// The parameters of the failed payment path.
 463 #[no_mangle]
 464 pub extern "C" fn RouteParameters_set_payment_params(this_ptr: &mut RouteParameters, mut val: crate::lightning::routing::router::PaymentParameters) {
 465         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_params = *unsafe { Box::from_raw(val.take_inner()) };
 466 }
 467 /// The amount in msats sent on the failed payment path.
 468 #[no_mangle]
 469 pub extern "C" fn RouteParameters_get_final_value_msat(this_ptr: &RouteParameters) -> u64 {
 470         let mut inner_val = &mut this_ptr.get_native_mut_ref().final_value_msat;
 471         *inner_val
 472 }
 473 /// The amount in msats sent on the failed payment path.
 474 #[no_mangle]
 475 pub extern "C" fn RouteParameters_set_final_value_msat(this_ptr: &mut RouteParameters, mut val: u64) {
 476         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.final_value_msat = val;
 477 }
 478 /// The CLTV on the final hop of the failed payment path.
 479 #[no_mangle]
 480 pub extern "C" fn RouteParameters_get_final_cltv_expiry_delta(this_ptr: &RouteParameters) -> u32 {
 481         let mut inner_val = &mut this_ptr.get_native_mut_ref().final_cltv_expiry_delta;
 482         *inner_val
 483 }
 484 /// The CLTV on the final hop of the failed payment path.
 485 #[no_mangle]
 486 pub extern "C" fn RouteParameters_set_final_cltv_expiry_delta(this_ptr: &mut RouteParameters, mut val: u32) {
 487         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.final_cltv_expiry_delta = val;
 488 }
 489 /// Constructs a new RouteParameters given each field
 490 #[must_use]
 491 #[no_mangle]
 492 pub extern "C" fn RouteParameters_new(mut payment_params_arg: crate::lightning::routing::router::PaymentParameters, mut final_value_msat_arg: u64, mut final_cltv_expiry_delta_arg: u32) -> RouteParameters {
 493         RouteParameters { inner: ObjOps::heap_alloc(nativeRouteParameters {
 494                 payment_params: *unsafe { Box::from_raw(payment_params_arg.take_inner()) },
 495                 final_value_msat: final_value_msat_arg,
 496                 final_cltv_expiry_delta: final_cltv_expiry_delta_arg,
 497         }), is_owned: true }
 498 }
 499 impl Clone for RouteParameters {
 500         fn clone(&self) -> Self {
 501                 Self {
 502                         inner: if <*mut nativeRouteParameters>::is_null(self.inner) { core::ptr::null_mut() } else {
 503                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 504                         is_owned: true,
 505                 }
 506         }
 507 }
 508 #[allow(unused)]
 509 /// Used only if an object of this type is returned as a trait impl by a method
 510 pub(crate) extern "C" fn RouteParameters_clone_void(this_ptr: *const c_void) -> *mut c_void {
 511         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRouteParameters)).clone() })) as *mut c_void
 512 }
 513 #[no_mangle]
 514 /// Creates a copy of the RouteParameters
 515 pub extern "C" fn RouteParameters_clone(orig: &RouteParameters) -> RouteParameters {
 516         orig.clone()
 517 }
 518 #[no_mangle]
 519 /// Serialize the RouteParameters object into a byte array which can be read by RouteParameters_read
 520 pub extern "C" fn RouteParameters_write(obj: &RouteParameters) -> crate::c_types::derived::CVec_u8Z {
 521         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
 522 }
 523 #[no_mangle]
 524 pub(crate) extern "C" fn RouteParameters_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 525         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeRouteParameters) })
 526 }
 527 #[no_mangle]
 528 /// Read a RouteParameters from a byte array, created by RouteParameters_write
 529 pub extern "C" fn RouteParameters_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_RouteParametersDecodeErrorZ {
 530         let res: Result<lightning::routing::router::RouteParameters, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
 531         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::routing::router::RouteParameters { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() };
 532         local_res
 533 }
 534 /// Maximum total CTLV difference we allow for a full payment path.
 535
 536 #[no_mangle]
 537 pub static DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA: u32 = lightning::routing::router::DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA;
 538
 539 use lightning::routing::router::PaymentParameters as nativePaymentParametersImport;
 540 pub(crate) type nativePaymentParameters = nativePaymentParametersImport;
 541
 542 /// The recipient of a payment.
 543 #[must_use]
 544 #[repr(C)]
 545 pub struct PaymentParameters {
 546         /// A pointer to the opaque Rust object.
 547
 548         /// Nearly everywhere, inner must be non-null, however in places where
 549         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 550         pub inner: *mut nativePaymentParameters,
 551         /// Indicates that this is the only struct which contains the same pointer.
 552
 553         /// Rust functions which take ownership of an object provided via an argument require
 554         /// this to be true and invalidate the object pointed to by inner.
 555         pub is_owned: bool,
 556 }
 557
 558 impl Drop for PaymentParameters {
 559         fn drop(&mut self) {
 560                 if self.is_owned && !<*mut nativePaymentParameters>::is_null(self.inner) {
 561                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 562                 }
 563         }
 564 }
 565 /// Frees any resources used by the PaymentParameters, if is_owned is set and inner is non-NULL.
 566 #[no_mangle]
 567 pub extern "C" fn PaymentParameters_free(this_obj: PaymentParameters) { }
 568 #[allow(unused)]
 569 /// Used only if an object of this type is returned as a trait impl by a method
 570 pub(crate) extern "C" fn PaymentParameters_free_void(this_ptr: *mut c_void) {
 571         unsafe { let _ = Box::from_raw(this_ptr as *mut nativePaymentParameters); }
 572 }
 573 #[allow(unused)]
 574 impl PaymentParameters {
 575         pub(crate) fn get_native_ref(&self) -> &'static nativePaymentParameters {
 576                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 577         }
 578         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativePaymentParameters {
 579                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 580         }
 581         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 582         pub(crate) fn take_inner(mut self) -> *mut nativePaymentParameters {
 583                 assert!(self.is_owned);
 584                 let ret = ObjOps::untweak_ptr(self.inner);
 585                 self.inner = core::ptr::null_mut();
 586                 ret
 587         }
 588 }
 589 /// The node id of the payee.
 590 #[no_mangle]
 591 pub extern "C" fn PaymentParameters_get_payee_pubkey(this_ptr: &PaymentParameters) -> crate::c_types::PublicKey {
 592         let mut inner_val = &mut this_ptr.get_native_mut_ref().payee_pubkey;
 593         crate::c_types::PublicKey::from_rust(&inner_val)
 594 }
 595 /// The node id of the payee.
 596 #[no_mangle]
 597 pub extern "C" fn PaymentParameters_set_payee_pubkey(this_ptr: &mut PaymentParameters, mut val: crate::c_types::PublicKey) {
 598         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payee_pubkey = val.into_rust();
 599 }
 600 /// Features supported by the payee.
 601 ///
 602 /// May be set from the payee's invoice or via [`for_keysend`]. May be `None` if the invoice
 603 /// does not contain any features.
 604 ///
 605 /// [`for_keysend`]: Self::for_keysend
 606 ///
 607 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
 608 #[no_mangle]
 609 pub extern "C" fn PaymentParameters_get_features(this_ptr: &PaymentParameters) -> crate::lightning::ln::features::InvoiceFeatures {
 610         let mut inner_val = &mut this_ptr.get_native_mut_ref().features;
 611         let mut local_inner_val = crate::lightning::ln::features::InvoiceFeatures { inner: unsafe { (if inner_val.is_none() { core::ptr::null() } else { ObjOps::nonnull_ptr_to_inner( { (inner_val.as_ref().unwrap()) }) } as *const lightning::ln::features::InvoiceFeatures<>) as *mut _ }, is_owned: false };
 612         local_inner_val
 613 }
 614 /// Features supported by the payee.
 615 ///
 616 /// May be set from the payee's invoice or via [`for_keysend`]. May be `None` if the invoice
 617 /// does not contain any features.
 618 ///
 619 /// [`for_keysend`]: Self::for_keysend
 620 ///
 621 /// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
 622 #[no_mangle]
 623 pub extern "C" fn PaymentParameters_set_features(this_ptr: &mut PaymentParameters, mut val: crate::lightning::ln::features::InvoiceFeatures) {
 624         let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
 625         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.features = local_val;
 626 }
 627 /// Hints for routing to the payee, containing channels connecting the payee to public nodes.
 628 #[no_mangle]
 629 pub extern "C" fn PaymentParameters_get_route_hints(this_ptr: &PaymentParameters) -> crate::c_types::derived::CVec_RouteHintZ {
 630         let mut inner_val = &mut this_ptr.get_native_mut_ref().route_hints;
 631         let mut local_inner_val = Vec::new(); for item in inner_val.iter() { local_inner_val.push( { crate::lightning::routing::router::RouteHint { inner: unsafe { ObjOps::nonnull_ptr_to_inner((item as *const lightning::routing::router::RouteHint<>) as *mut _) }, is_owned: false } }); };
 632         local_inner_val.into()
 633 }
 634 /// Hints for routing to the payee, containing channels connecting the payee to public nodes.
 635 #[no_mangle]
 636 pub extern "C" fn PaymentParameters_set_route_hints(this_ptr: &mut PaymentParameters, mut val: crate::c_types::derived::CVec_RouteHintZ) {
 637         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
 638         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.route_hints = local_val;
 639 }
 640 /// Expiration of a payment to the payee, in seconds relative to the UNIX epoch.
 641 #[no_mangle]
 642 pub extern "C" fn PaymentParameters_get_expiry_time(this_ptr: &PaymentParameters) -> crate::c_types::derived::COption_u64Z {
 643         let mut inner_val = &mut this_ptr.get_native_mut_ref().expiry_time;
 644         let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { inner_val.unwrap() }) };
 645         local_inner_val
 646 }
 647 /// Expiration of a payment to the payee, in seconds relative to the UNIX epoch.
 648 #[no_mangle]
 649 pub extern "C" fn PaymentParameters_set_expiry_time(this_ptr: &mut PaymentParameters, mut val: crate::c_types::derived::COption_u64Z) {
 650         let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
 651         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.expiry_time = local_val;
 652 }
 653 /// The maximum total CLTV delta we accept for the route.
 654 #[no_mangle]
 655 pub extern "C" fn PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: &PaymentParameters) -> u32 {
 656         let mut inner_val = &mut this_ptr.get_native_mut_ref().max_total_cltv_expiry_delta;
 657         *inner_val
 658 }
 659 /// The maximum total CLTV delta we accept for the route.
 660 #[no_mangle]
 661 pub extern "C" fn PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: &mut PaymentParameters, mut val: u32) {
 662         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_total_cltv_expiry_delta = val;
 663 }
 664 /// Constructs a new PaymentParameters given each field
 665 #[must_use]
 666 #[no_mangle]
 667 pub extern "C" fn PaymentParameters_new(mut payee_pubkey_arg: crate::c_types::PublicKey, mut features_arg: crate::lightning::ln::features::InvoiceFeatures, mut route_hints_arg: crate::c_types::derived::CVec_RouteHintZ, mut expiry_time_arg: crate::c_types::derived::COption_u64Z, mut max_total_cltv_expiry_delta_arg: u32) -> PaymentParameters {
 668         let mut local_features_arg = if features_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(features_arg.take_inner()) } }) };
 669         let mut local_route_hints_arg = Vec::new(); for mut item in route_hints_arg.into_rust().drain(..) { local_route_hints_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
 670         let mut local_expiry_time_arg = if expiry_time_arg.is_some() { Some( { expiry_time_arg.take() }) } else { None };
 671         PaymentParameters { inner: ObjOps::heap_alloc(nativePaymentParameters {
 672                 payee_pubkey: payee_pubkey_arg.into_rust(),
 673                 features: local_features_arg,
 674                 route_hints: local_route_hints_arg,
 675                 expiry_time: local_expiry_time_arg,
 676                 max_total_cltv_expiry_delta: max_total_cltv_expiry_delta_arg,
 677         }), is_owned: true }
 678 }
 679 impl Clone for PaymentParameters {
 680         fn clone(&self) -> Self {
 681                 Self {
 682                         inner: if <*mut nativePaymentParameters>::is_null(self.inner) { core::ptr::null_mut() } else {
 683                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 684                         is_owned: true,
 685                 }
 686         }
 687 }
 688 #[allow(unused)]
 689 /// Used only if an object of this type is returned as a trait impl by a method
 690 pub(crate) extern "C" fn PaymentParameters_clone_void(this_ptr: *const c_void) -> *mut c_void {
 691         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePaymentParameters)).clone() })) as *mut c_void
 692 }
 693 #[no_mangle]
 694 /// Creates a copy of the PaymentParameters
 695 pub extern "C" fn PaymentParameters_clone(orig: &PaymentParameters) -> PaymentParameters {
 696         orig.clone()
 697 }
 698 /// Checks if two PaymentParameterss contain equal inner contents.
 699 #[no_mangle]
 700 pub extern "C" fn PaymentParameters_hash(o: &PaymentParameters) -> u64 {
 701         if o.inner.is_null() { return 0; }
 702         // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
 703         #[allow(deprecated)]
 704         let mut hasher = core::hash::SipHasher::new();
 705         core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
 706         core::hash::Hasher::finish(&hasher)
 707 }
 708 /// Checks if two PaymentParameterss contain equal inner contents.
 709 /// This ignores pointers and is_owned flags and looks at the values in fields.
 710 /// Two objects with NULL inner values will be considered "equal" here.
 711 #[no_mangle]
 712 pub extern "C" fn PaymentParameters_eq(a: &PaymentParameters, b: &PaymentParameters) -> bool {
 713         if a.inner == b.inner { return true; }
 714         if a.inner.is_null() || b.inner.is_null() { return false; }
 715         if a.get_native_ref() == b.get_native_ref() { true } else { false }
 716 }
 717 #[no_mangle]
 718 /// Serialize the PaymentParameters object into a byte array which can be read by PaymentParameters_read
 719 pub extern "C" fn PaymentParameters_write(obj: &PaymentParameters) -> crate::c_types::derived::CVec_u8Z {
 720         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
 721 }
 722 #[no_mangle]
 723 pub(crate) extern "C" fn PaymentParameters_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 724         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativePaymentParameters) })
 725 }
 726 #[no_mangle]
 727 /// Read a PaymentParameters from a byte array, created by PaymentParameters_write
 728 pub extern "C" fn PaymentParameters_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PaymentParametersDecodeErrorZ {
 729         let res: Result<lightning::routing::router::PaymentParameters, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
 730         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::routing::router::PaymentParameters { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() };
 731         local_res
 732 }
 733 /// Creates a payee with the node id of the given `pubkey`.
 734 #[must_use]
 735 #[no_mangle]
 736 pub extern "C" fn PaymentParameters_from_node_id(mut payee_pubkey: crate::c_types::PublicKey) -> PaymentParameters {
 737         let mut ret = lightning::routing::router::PaymentParameters::from_node_id(payee_pubkey.into_rust());
 738         PaymentParameters { inner: ObjOps::heap_alloc(ret), is_owned: true }
 739 }
 740
 741 /// Creates a payee with the node id of the given `pubkey` to use for keysend payments.
 742 #[must_use]
 743 #[no_mangle]
 744 pub extern "C" fn PaymentParameters_for_keysend(mut payee_pubkey: crate::c_types::PublicKey) -> PaymentParameters {
 745         let mut ret = lightning::routing::router::PaymentParameters::for_keysend(payee_pubkey.into_rust());
 746         PaymentParameters { inner: ObjOps::heap_alloc(ret), is_owned: true }
 747 }
 748
 749
 750 use lightning::routing::router::RouteHint as nativeRouteHintImport;
 751 pub(crate) type nativeRouteHint = nativeRouteHintImport;
 752
 753 /// A list of hops along a payment path terminating with a channel to the recipient.
 754 #[must_use]
 755 #[repr(C)]
 756 pub struct RouteHint {
 757         /// A pointer to the opaque Rust object.
 758
 759         /// Nearly everywhere, inner must be non-null, however in places where
 760         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 761         pub inner: *mut nativeRouteHint,
 762         /// Indicates that this is the only struct which contains the same pointer.
 763
 764         /// Rust functions which take ownership of an object provided via an argument require
 765         /// this to be true and invalidate the object pointed to by inner.
 766         pub is_owned: bool,
 767 }
 768
 769 impl Drop for RouteHint {
 770         fn drop(&mut self) {
 771                 if self.is_owned && !<*mut nativeRouteHint>::is_null(self.inner) {
 772                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 773                 }
 774         }
 775 }
 776 /// Frees any resources used by the RouteHint, if is_owned is set and inner is non-NULL.
 777 #[no_mangle]
 778 pub extern "C" fn RouteHint_free(this_obj: RouteHint) { }
 779 #[allow(unused)]
 780 /// Used only if an object of this type is returned as a trait impl by a method
 781 pub(crate) extern "C" fn RouteHint_free_void(this_ptr: *mut c_void) {
 782         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRouteHint); }
 783 }
 784 #[allow(unused)]
 785 impl RouteHint {
 786         pub(crate) fn get_native_ref(&self) -> &'static nativeRouteHint {
 787                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 788         }
 789         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRouteHint {
 790                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 791         }
 792         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 793         pub(crate) fn take_inner(mut self) -> *mut nativeRouteHint {
 794                 assert!(self.is_owned);
 795                 let ret = ObjOps::untweak_ptr(self.inner);
 796                 self.inner = core::ptr::null_mut();
 797                 ret
 798         }
 799 }
 800 #[no_mangle]
 801 pub extern "C" fn RouteHint_get_a(this_ptr: &RouteHint) -> crate::c_types::derived::CVec_RouteHintHopZ {
 802         let mut inner_val = &mut this_ptr.get_native_mut_ref().0;
 803         let mut local_inner_val = Vec::new(); for item in inner_val.iter() { local_inner_val.push( { crate::lightning::routing::router::RouteHintHop { inner: unsafe { ObjOps::nonnull_ptr_to_inner((item as *const lightning::routing::router::RouteHintHop<>) as *mut _) }, is_owned: false } }); };
 804         local_inner_val.into()
 805 }
 806 #[no_mangle]
 807 pub extern "C" fn RouteHint_set_a(this_ptr: &mut RouteHint, mut val: crate::c_types::derived::CVec_RouteHintHopZ) {
 808         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
 809         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.0 = local_val;
 810 }
 811 /// Constructs a new RouteHint given each field
 812 #[must_use]
 813 #[no_mangle]
 814 pub extern "C" fn RouteHint_new(mut a_arg: crate::c_types::derived::CVec_RouteHintHopZ) -> RouteHint {
 815         let mut local_a_arg = Vec::new(); for mut item in a_arg.into_rust().drain(..) { local_a_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
 816         RouteHint { inner: ObjOps::heap_alloc(lightning::routing::router::RouteHint (
 817                 local_a_arg,
 818         )), is_owned: true }
 819 }
 820 impl Clone for RouteHint {
 821         fn clone(&self) -> Self {
 822                 Self {
 823                         inner: if <*mut nativeRouteHint>::is_null(self.inner) { core::ptr::null_mut() } else {
 824                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 825                         is_owned: true,
 826                 }
 827         }
 828 }
 829 #[allow(unused)]
 830 /// Used only if an object of this type is returned as a trait impl by a method
 831 pub(crate) extern "C" fn RouteHint_clone_void(this_ptr: *const c_void) -> *mut c_void {
 832         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRouteHint)).clone() })) as *mut c_void
 833 }
 834 #[no_mangle]
 835 /// Creates a copy of the RouteHint
 836 pub extern "C" fn RouteHint_clone(orig: &RouteHint) -> RouteHint {
 837         orig.clone()
 838 }
 839 /// Checks if two RouteHints contain equal inner contents.
 840 #[no_mangle]
 841 pub extern "C" fn RouteHint_hash(o: &RouteHint) -> u64 {
 842         if o.inner.is_null() { return 0; }
 843         // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
 844         #[allow(deprecated)]
 845         let mut hasher = core::hash::SipHasher::new();
 846         core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
 847         core::hash::Hasher::finish(&hasher)
 848 }
 849 /// Checks if two RouteHints contain equal inner contents.
 850 /// This ignores pointers and is_owned flags and looks at the values in fields.
 851 /// Two objects with NULL inner values will be considered "equal" here.
 852 #[no_mangle]
 853 pub extern "C" fn RouteHint_eq(a: &RouteHint, b: &RouteHint) -> bool {
 854         if a.inner == b.inner { return true; }
 855         if a.inner.is_null() || b.inner.is_null() { return false; }
 856         if a.get_native_ref() == b.get_native_ref() { true } else { false }
 857 }
 858 #[no_mangle]
 859 /// Serialize the RouteHint object into a byte array which can be read by RouteHint_read
 860 pub extern "C" fn RouteHint_write(obj: &RouteHint) -> crate::c_types::derived::CVec_u8Z {
 861         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
 862 }
 863 #[no_mangle]
 864 pub(crate) extern "C" fn RouteHint_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 865         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeRouteHint) })
 866 }
 867 #[no_mangle]
 868 /// Read a RouteHint from a byte array, created by RouteHint_write
 869 pub extern "C" fn RouteHint_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_RouteHintDecodeErrorZ {
 870         let res: Result<lightning::routing::router::RouteHint, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
 871         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::routing::router::RouteHint { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() };
 872         local_res
 873 }
 874
 875 use lightning::routing::router::RouteHintHop as nativeRouteHintHopImport;
 876 pub(crate) type nativeRouteHintHop = nativeRouteHintHopImport;
 877
 878 /// A channel descriptor for a hop along a payment path.
 879 #[must_use]
 880 #[repr(C)]
 881 pub struct RouteHintHop {
 882         /// A pointer to the opaque Rust object.
 883
 884         /// Nearly everywhere, inner must be non-null, however in places where
 885         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 886         pub inner: *mut nativeRouteHintHop,
 887         /// Indicates that this is the only struct which contains the same pointer.
 888
 889         /// Rust functions which take ownership of an object provided via an argument require
 890         /// this to be true and invalidate the object pointed to by inner.
 891         pub is_owned: bool,
 892 }
 893
 894 impl Drop for RouteHintHop {
 895         fn drop(&mut self) {
 896                 if self.is_owned && !<*mut nativeRouteHintHop>::is_null(self.inner) {
 897                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 898                 }
 899         }
 900 }
 901 /// Frees any resources used by the RouteHintHop, if is_owned is set and inner is non-NULL.
 902 #[no_mangle]
 903 pub extern "C" fn RouteHintHop_free(this_obj: RouteHintHop) { }
 904 #[allow(unused)]
 905 /// Used only if an object of this type is returned as a trait impl by a method
 906 pub(crate) extern "C" fn RouteHintHop_free_void(this_ptr: *mut c_void) {
 907         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRouteHintHop); }
 908 }
 909 #[allow(unused)]
 910 impl RouteHintHop {
 911         pub(crate) fn get_native_ref(&self) -> &'static nativeRouteHintHop {
 912                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 913         }
 914         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRouteHintHop {
 915                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 916         }
 917         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 918         pub(crate) fn take_inner(mut self) -> *mut nativeRouteHintHop {
 919                 assert!(self.is_owned);
 920                 let ret = ObjOps::untweak_ptr(self.inner);
 921                 self.inner = core::ptr::null_mut();
 922                 ret
 923         }
 924 }
 925 /// The node_id of the non-target end of the route
 926 #[no_mangle]
 927 pub extern "C" fn RouteHintHop_get_src_node_id(this_ptr: &RouteHintHop) -> crate::c_types::PublicKey {
 928         let mut inner_val = &mut this_ptr.get_native_mut_ref().src_node_id;
 929         crate::c_types::PublicKey::from_rust(&inner_val)
 930 }
 931 /// The node_id of the non-target end of the route
 932 #[no_mangle]
 933 pub extern "C" fn RouteHintHop_set_src_node_id(this_ptr: &mut RouteHintHop, mut val: crate::c_types::PublicKey) {
 934         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.src_node_id = val.into_rust();
 935 }
 936 /// The short_channel_id of this channel
 937 #[no_mangle]
 938 pub extern "C" fn RouteHintHop_get_short_channel_id(this_ptr: &RouteHintHop) -> u64 {
 939         let mut inner_val = &mut this_ptr.get_native_mut_ref().short_channel_id;
 940         *inner_val
 941 }
 942 /// The short_channel_id of this channel
 943 #[no_mangle]
 944 pub extern "C" fn RouteHintHop_set_short_channel_id(this_ptr: &mut RouteHintHop, mut val: u64) {
 945         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_id = val;
 946 }
 947 /// The fees which must be paid to use this channel
 948 #[no_mangle]
 949 pub extern "C" fn RouteHintHop_get_fees(this_ptr: &RouteHintHop) -> crate::lightning::routing::network_graph::RoutingFees {
 950         let mut inner_val = &mut this_ptr.get_native_mut_ref().fees;
 951         crate::lightning::routing::network_graph::RoutingFees { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::routing::network_graph::RoutingFees<>) as *mut _) }, is_owned: false }
 952 }
 953 /// The fees which must be paid to use this channel
 954 #[no_mangle]
 955 pub extern "C" fn RouteHintHop_set_fees(this_ptr: &mut RouteHintHop, mut val: crate::lightning::routing::network_graph::RoutingFees) {
 956         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fees = *unsafe { Box::from_raw(val.take_inner()) };
 957 }
 958 /// The difference in CLTV values between this node and the next node.
 959 #[no_mangle]
 960 pub extern "C" fn RouteHintHop_get_cltv_expiry_delta(this_ptr: &RouteHintHop) -> u16 {
 961         let mut inner_val = &mut this_ptr.get_native_mut_ref().cltv_expiry_delta;
 962         *inner_val
 963 }
 964 /// The difference in CLTV values between this node and the next node.
 965 #[no_mangle]
 966 pub extern "C" fn RouteHintHop_set_cltv_expiry_delta(this_ptr: &mut RouteHintHop, mut val: u16) {
 967         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry_delta = val;
 968 }
 969 /// The minimum value, in msat, which must be relayed to the next hop.
 970 #[no_mangle]
 971 pub extern "C" fn RouteHintHop_get_htlc_minimum_msat(this_ptr: &RouteHintHop) -> crate::c_types::derived::COption_u64Z {
 972         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_minimum_msat;
 973         let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { inner_val.unwrap() }) };
 974         local_inner_val
 975 }
 976 /// The minimum value, in msat, which must be relayed to the next hop.
 977 #[no_mangle]
 978 pub extern "C" fn RouteHintHop_set_htlc_minimum_msat(this_ptr: &mut RouteHintHop, mut val: crate::c_types::derived::COption_u64Z) {
 979         let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
 980         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_minimum_msat = local_val;
 981 }
 982 /// The maximum value in msat available for routing with a single HTLC.
 983 #[no_mangle]
 984 pub extern "C" fn RouteHintHop_get_htlc_maximum_msat(this_ptr: &RouteHintHop) -> crate::c_types::derived::COption_u64Z {
 985         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_maximum_msat;
 986         let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_u64Z::None } else { crate::c_types::derived::COption_u64Z::Some( { inner_val.unwrap() }) };
 987         local_inner_val
 988 }
 989 /// The maximum value in msat available for routing with a single HTLC.
 990 #[no_mangle]
 991 pub extern "C" fn RouteHintHop_set_htlc_maximum_msat(this_ptr: &mut RouteHintHop, mut val: crate::c_types::derived::COption_u64Z) {
 992         let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
 993         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_maximum_msat = local_val;
 994 }
 995 /// Constructs a new RouteHintHop given each field
 996 #[must_use]
 997 #[no_mangle]
 998 pub extern "C" fn RouteHintHop_new(mut src_node_id_arg: crate::c_types::PublicKey, mut short_channel_id_arg: u64, mut fees_arg: crate::lightning::routing::network_graph::RoutingFees, mut cltv_expiry_delta_arg: u16, mut htlc_minimum_msat_arg: crate::c_types::derived::COption_u64Z, mut htlc_maximum_msat_arg: crate::c_types::derived::COption_u64Z) -> RouteHintHop {
 999         let mut local_htlc_minimum_msat_arg = if htlc_minimum_msat_arg.is_some() { Some( { htlc_minimum_msat_arg.take() }) } else { None };
1000         let mut local_htlc_maximum_msat_arg = if htlc_maximum_msat_arg.is_some() { Some( { htlc_maximum_msat_arg.take() }) } else { None };
1001         RouteHintHop { inner: ObjOps::heap_alloc(nativeRouteHintHop {
1002                 src_node_id: src_node_id_arg.into_rust(),
1003                 short_channel_id: short_channel_id_arg,
1004                 fees: *unsafe { Box::from_raw(fees_arg.take_inner()) },
1005                 cltv_expiry_delta: cltv_expiry_delta_arg,
1006                 htlc_minimum_msat: local_htlc_minimum_msat_arg,
1007                 htlc_maximum_msat: local_htlc_maximum_msat_arg,
1008         }), is_owned: true }
1009 }
1010 impl Clone for RouteHintHop {
1011         fn clone(&self) -> Self {
1012                 Self {
1013                         inner: if <*mut nativeRouteHintHop>::is_null(self.inner) { core::ptr::null_mut() } else {
1014                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
1015                         is_owned: true,
1016                 }
1017         }
1018 }
1019 #[allow(unused)]
1020 /// Used only if an object of this type is returned as a trait impl by a method
1021 pub(crate) extern "C" fn RouteHintHop_clone_void(this_ptr: *const c_void) -> *mut c_void {
1022         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRouteHintHop)).clone() })) as *mut c_void
1023 }
1024 #[no_mangle]
1025 /// Creates a copy of the RouteHintHop
1026 pub extern "C" fn RouteHintHop_clone(orig: &RouteHintHop) -> RouteHintHop {
1027         orig.clone()
1028 }
1029 /// Checks if two RouteHintHops contain equal inner contents.
1030 #[no_mangle]
1031 pub extern "C" fn RouteHintHop_hash(o: &RouteHintHop) -> u64 {
1032         if o.inner.is_null() { return 0; }
1033         // Note that we'd love to use alloc::collections::hash_map::DefaultHasher but it's not in core
1034         #[allow(deprecated)]
1035         let mut hasher = core::hash::SipHasher::new();
1036         core::hash::Hash::hash(o.get_native_ref(), &mut hasher);
1037         core::hash::Hasher::finish(&hasher)
1038 }
1039 /// Checks if two RouteHintHops contain equal inner contents.
1040 /// This ignores pointers and is_owned flags and looks at the values in fields.
1041 /// Two objects with NULL inner values will be considered "equal" here.
1042 #[no_mangle]
1043 pub extern "C" fn RouteHintHop_eq(a: &RouteHintHop, b: &RouteHintHop) -> bool {
1044         if a.inner == b.inner { return true; }
1045         if a.inner.is_null() || b.inner.is_null() { return false; }
1046         if a.get_native_ref() == b.get_native_ref() { true } else { false }
1047 }
1048 #[no_mangle]
1049 /// Serialize the RouteHintHop object into a byte array which can be read by RouteHintHop_read
1050 pub extern "C" fn RouteHintHop_write(obj: &RouteHintHop) -> crate::c_types::derived::CVec_u8Z {
1051         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
1052 }
1053 #[no_mangle]
1054 pub(crate) extern "C" fn RouteHintHop_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
1055         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeRouteHintHop) })
1056 }
1057 #[no_mangle]
1058 /// Read a RouteHintHop from a byte array, created by RouteHintHop_write
1059 pub extern "C" fn RouteHintHop_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_RouteHintHopDecodeErrorZ {
1060         let res: Result<lightning::routing::router::RouteHintHop, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
1061         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::routing::router::RouteHintHop { inner: ObjOps::heap_alloc(o), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() };
1062         local_res
1063 }
1064 /// Finds a route from us (payer) to the given target node (payee).
1065 ///
1066 /// If the payee provided features in their invoice, they should be provided via `params.payee`.
1067 /// Without this, MPP will only be used if the payee's features are available in the network graph.
1068 ///
1069 /// Private routing paths between a public node and the target may be included in `params.payee`.
1070 ///
1071 /// If some channels aren't announced, it may be useful to fill in `first_hops` with the results
1072 /// from [`ChannelManager::list_usable_channels`]. If it is filled in, the view of our local
1073 /// channels from [`NetworkGraph`] will be ignored, and only those in `first_hops` will be used.
1074 ///
1075 /// The fees on channels from us to the next hop are ignored as they are assumed to all be equal.
1076 /// However, the enabled/disabled bit on such channels as well as the `htlc_minimum_msat` /
1077 /// `htlc_maximum_msat` *are* checked as they may change based on the receiving node.
1078 ///
1079 /// # Note
1080 ///
1081 /// May be used to re-compute a [`Route`] when handling a [`Event::PaymentPathFailed`]. Any
1082 /// adjustments to the [`NetworkGraph`] and channel scores should be made prior to calling this
1083 /// function.
1084 ///
1085 /// # Panics
1086 ///
1087 /// Panics if first_hops contains channels without short_channel_ids;
1088 /// [`ChannelManager::list_usable_channels`] will never include such channels.
1089 ///
1090 /// [`ChannelManager::list_usable_channels`]: crate::ln::channelmanager::ChannelManager::list_usable_channels
1091 /// [`Event::PaymentPathFailed`]: crate::util::events::Event::PaymentPathFailed
1092 ///
1093 /// Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1094 #[no_mangle]
1095 pub extern "C" fn find_route(mut our_node_pubkey: crate::c_types::PublicKey, route_params: &crate::lightning::routing::router::RouteParameters, network: &crate::lightning::routing::network_graph::NetworkGraph, first_hops: *mut crate::c_types::derived::CVec_ChannelDetailsZ, mut logger: crate::lightning::util::logger::Logger, scorer: &crate::lightning::routing::scoring::Score) -> crate::c_types::derived::CResult_RouteLightningErrorZ {
1096         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[..]);
1097         let mut ret = lightning::routing::router::find_route::<crate::lightning::util::logger::Logger, crate::lightning::routing::scoring::Score>(&our_node_pubkey.into_rust(), route_params.get_native_ref(), network.get_native_ref(), local_first_hops, logger, scorer);
1098         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() };
1099         local_ret
1100 }
1101