_ Git - ldk-c-bindings/blob - lightning-c-bindings/src/lightning/ln/msgs.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 //! Wire messages, traits representing wire message handlers, and a few error types live here.
  10 //!
  11 //! For a normal node you probably don't need to use anything here, however, if you wish to split a
  12 //! node into an internet-facing route/message socket handling daemon and a separate daemon (or
  13 //! server entirely) which handles only channel-related messages you may wish to implement
  14 //! ChannelMessageHandler yourself and use it to re-serialize messages and pass them across
  15 //! daemons/servers.
  16 //!
  17 //! Note that if you go with such an architecture (instead of passing raw socket events to a
  18 //! non-internet-facing system) you trust the frontend internet-facing system to not lie about the
  19 //! source node_id of the message, however this does allow you to significantly reduce bandwidth
  20 //! between the systems as routing messages can represent a significant chunk of bandwidth usage
  21 //! (especially for non-channel-publicly-announcing nodes). As an alternate design which avoids
  22 //! this issue, if you have sufficient bidirectional bandwidth between your systems, you may send
  23 //! raw socket events into your non-internet-facing system and then send routing events back to
  24 //! track the network on the less-secure system.
  25
  26 use alloc::str::FromStr;
  27 use core::ffi::c_void;
  28 use core::convert::Infallible;
  29 use bitcoin::hashes::Hash;
  30 use crate::c_types::*;
  31 #[cfg(feature="no-std")]
  32 use alloc::{vec::Vec, boxed::Box};
  33
  34
  35 use lightning::ln::msgs::DecodeError as nativeDecodeErrorImport;
  36 pub(crate) type nativeDecodeError = nativeDecodeErrorImport;
  37
  38 /// An error in decoding a message or struct.
  39 #[must_use]
  40 #[repr(C)]
  41 pub struct DecodeError {
  42         /// A pointer to the opaque Rust object.
  43
  44         /// Nearly everywhere, inner must be non-null, however in places where
  45         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
  46         pub inner: *mut nativeDecodeError,
  47         /// Indicates that this is the only struct which contains the same pointer.
  48
  49         /// Rust functions which take ownership of an object provided via an argument require
  50         /// this to be true and invalidate the object pointed to by inner.
  51         pub is_owned: bool,
  52 }
  53
  54 impl Drop for DecodeError {
  55         fn drop(&mut self) {
  56                 if self.is_owned && !<*mut nativeDecodeError>::is_null(self.inner) {
  57                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
  58                 }
  59         }
  60 }
  61 /// Frees any resources used by the DecodeError, if is_owned is set and inner is non-NULL.
  62 #[no_mangle]
  63 pub extern "C" fn DecodeError_free(this_obj: DecodeError) { }
  64 #[allow(unused)]
  65 /// Used only if an object of this type is returned as a trait impl by a method
  66 pub(crate) extern "C" fn DecodeError_free_void(this_ptr: *mut c_void) {
  67         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDecodeError); }
  68 }
  69 #[allow(unused)]
  70 impl DecodeError {
  71         pub(crate) fn get_native_ref(&self) -> &'static nativeDecodeError {
  72                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
  73         }
  74         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeDecodeError {
  75                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
  76         }
  77         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
  78         pub(crate) fn take_inner(mut self) -> *mut nativeDecodeError {
  79                 assert!(self.is_owned);
  80                 let ret = ObjOps::untweak_ptr(self.inner);
  81                 self.inner = core::ptr::null_mut();
  82                 ret
  83         }
  84 }
  85 impl Clone for DecodeError {
  86         fn clone(&self) -> Self {
  87                 Self {
  88                         inner: if <*mut nativeDecodeError>::is_null(self.inner) { core::ptr::null_mut() } else {
  89                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
  90                         is_owned: true,
  91                 }
  92         }
  93 }
  94 #[allow(unused)]
  95 /// Used only if an object of this type is returned as a trait impl by a method
  96 pub(crate) extern "C" fn DecodeError_clone_void(this_ptr: *const c_void) -> *mut c_void {
  97         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeDecodeError)).clone() })) as *mut c_void
  98 }
  99 #[no_mangle]
 100 /// Creates a copy of the DecodeError
 101 pub extern "C" fn DecodeError_clone(orig: &DecodeError) -> DecodeError {
 102         orig.clone()
 103 }
 104
 105 use lightning::ln::msgs::Init as nativeInitImport;
 106 pub(crate) type nativeInit = nativeInitImport;
 107
 108 /// An init message to be sent or received from a peer
 109 #[must_use]
 110 #[repr(C)]
 111 pub struct Init {
 112         /// A pointer to the opaque Rust object.
 113
 114         /// Nearly everywhere, inner must be non-null, however in places where
 115         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 116         pub inner: *mut nativeInit,
 117         /// Indicates that this is the only struct which contains the same pointer.
 118
 119         /// Rust functions which take ownership of an object provided via an argument require
 120         /// this to be true and invalidate the object pointed to by inner.
 121         pub is_owned: bool,
 122 }
 123
 124 impl Drop for Init {
 125         fn drop(&mut self) {
 126                 if self.is_owned && !<*mut nativeInit>::is_null(self.inner) {
 127                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 128                 }
 129         }
 130 }
 131 /// Frees any resources used by the Init, if is_owned is set and inner is non-NULL.
 132 #[no_mangle]
 133 pub extern "C" fn Init_free(this_obj: Init) { }
 134 #[allow(unused)]
 135 /// Used only if an object of this type is returned as a trait impl by a method
 136 pub(crate) extern "C" fn Init_free_void(this_ptr: *mut c_void) {
 137         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInit); }
 138 }
 139 #[allow(unused)]
 140 impl Init {
 141         pub(crate) fn get_native_ref(&self) -> &'static nativeInit {
 142                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 143         }
 144         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeInit {
 145                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 146         }
 147         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 148         pub(crate) fn take_inner(mut self) -> *mut nativeInit {
 149                 assert!(self.is_owned);
 150                 let ret = ObjOps::untweak_ptr(self.inner);
 151                 self.inner = core::ptr::null_mut();
 152                 ret
 153         }
 154 }
 155 /// The relevant features which the sender supports
 156 #[no_mangle]
 157 pub extern "C" fn Init_get_features(this_ptr: &Init) -> crate::lightning::ln::features::InitFeatures {
 158         let mut inner_val = &mut this_ptr.get_native_mut_ref().features;
 159         crate::lightning::ln::features::InitFeatures { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::features::InitFeatures<>) as *mut _) }, is_owned: false }
 160 }
 161 /// The relevant features which the sender supports
 162 #[no_mangle]
 163 pub extern "C" fn Init_set_features(this_ptr: &mut Init, mut val: crate::lightning::ln::features::InitFeatures) {
 164         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.features = *unsafe { Box::from_raw(val.take_inner()) };
 165 }
 166 /// The receipient's network address. This adds the option to report a remote IP address
 167 /// back to a connecting peer using the init message. A node can decide to use that information
 168 /// to discover a potential update to its public IPv4 address (NAT) and use
 169 /// that for a node_announcement update message containing the new address.
 170 #[no_mangle]
 171 pub extern "C" fn Init_get_remote_network_address(this_ptr: &Init) -> crate::c_types::derived::COption_NetAddressZ {
 172         let mut inner_val = &mut this_ptr.get_native_mut_ref().remote_network_address;
 173         let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_NetAddressZ::None } else { crate::c_types::derived::COption_NetAddressZ::Some(/* WARNING: CLONING CONVERSION HERE! &Option<Enum> is otherwise un-expressable. */ { crate::lightning::ln::msgs::NetAddress::native_into(inner_val.clone().unwrap()) }) };
 174         local_inner_val
 175 }
 176 /// The receipient's network address. This adds the option to report a remote IP address
 177 /// back to a connecting peer using the init message. A node can decide to use that information
 178 /// to discover a potential update to its public IPv4 address (NAT) and use
 179 /// that for a node_announcement update message containing the new address.
 180 #[no_mangle]
 181 pub extern "C" fn Init_set_remote_network_address(this_ptr: &mut Init, mut val: crate::c_types::derived::COption_NetAddressZ) {
 182         let mut local_val = { /* val*/ let val_opt = val; { } if val_opt.is_none() { None } else { Some({ val_opt.take().into_native() }) } };
 183         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.remote_network_address = local_val;
 184 }
 185 /// Constructs a new Init given each field
 186 #[must_use]
 187 #[no_mangle]
 188 pub extern "C" fn Init_new(mut features_arg: crate::lightning::ln::features::InitFeatures, mut remote_network_address_arg: crate::c_types::derived::COption_NetAddressZ) -> Init {
 189         let mut local_remote_network_address_arg = { /* remote_network_address_arg*/ let remote_network_address_arg_opt = remote_network_address_arg; { } if remote_network_address_arg_opt.is_none() { None } else { Some({ remote_network_address_arg_opt.take().into_native() }) } };
 190         Init { inner: ObjOps::heap_alloc(nativeInit {
 191                 features: *unsafe { Box::from_raw(features_arg.take_inner()) },
 192                 remote_network_address: local_remote_network_address_arg,
 193         }), is_owned: true }
 194 }
 195 impl Clone for Init {
 196         fn clone(&self) -> Self {
 197                 Self {
 198                         inner: if <*mut nativeInit>::is_null(self.inner) { core::ptr::null_mut() } else {
 199                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 200                         is_owned: true,
 201                 }
 202         }
 203 }
 204 #[allow(unused)]
 205 /// Used only if an object of this type is returned as a trait impl by a method
 206 pub(crate) extern "C" fn Init_clone_void(this_ptr: *const c_void) -> *mut c_void {
 207         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInit)).clone() })) as *mut c_void
 208 }
 209 #[no_mangle]
 210 /// Creates a copy of the Init
 211 pub extern "C" fn Init_clone(orig: &Init) -> Init {
 212         orig.clone()
 213 }
 214
 215 use lightning::ln::msgs::ErrorMessage as nativeErrorMessageImport;
 216 pub(crate) type nativeErrorMessage = nativeErrorMessageImport;
 217
 218 /// An error message to be sent or received from a peer
 219 #[must_use]
 220 #[repr(C)]
 221 pub struct ErrorMessage {
 222         /// A pointer to the opaque Rust object.
 223
 224         /// Nearly everywhere, inner must be non-null, however in places where
 225         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 226         pub inner: *mut nativeErrorMessage,
 227         /// Indicates that this is the only struct which contains the same pointer.
 228
 229         /// Rust functions which take ownership of an object provided via an argument require
 230         /// this to be true and invalidate the object pointed to by inner.
 231         pub is_owned: bool,
 232 }
 233
 234 impl Drop for ErrorMessage {
 235         fn drop(&mut self) {
 236                 if self.is_owned && !<*mut nativeErrorMessage>::is_null(self.inner) {
 237                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 238                 }
 239         }
 240 }
 241 /// Frees any resources used by the ErrorMessage, if is_owned is set and inner is non-NULL.
 242 #[no_mangle]
 243 pub extern "C" fn ErrorMessage_free(this_obj: ErrorMessage) { }
 244 #[allow(unused)]
 245 /// Used only if an object of this type is returned as a trait impl by a method
 246 pub(crate) extern "C" fn ErrorMessage_free_void(this_ptr: *mut c_void) {
 247         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeErrorMessage); }
 248 }
 249 #[allow(unused)]
 250 impl ErrorMessage {
 251         pub(crate) fn get_native_ref(&self) -> &'static nativeErrorMessage {
 252                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 253         }
 254         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeErrorMessage {
 255                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 256         }
 257         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 258         pub(crate) fn take_inner(mut self) -> *mut nativeErrorMessage {
 259                 assert!(self.is_owned);
 260                 let ret = ObjOps::untweak_ptr(self.inner);
 261                 self.inner = core::ptr::null_mut();
 262                 ret
 263         }
 264 }
 265 /// The channel ID involved in the error.
 266 ///
 267 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
 268 /// with the sending peer should be closed.
 269 #[no_mangle]
 270 pub extern "C" fn ErrorMessage_get_channel_id(this_ptr: &ErrorMessage) -> *const [u8; 32] {
 271         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
 272         inner_val
 273 }
 274 /// The channel ID involved in the error.
 275 ///
 276 /// All-0s indicates a general error unrelated to a specific channel, after which all channels
 277 /// with the sending peer should be closed.
 278 #[no_mangle]
 279 pub extern "C" fn ErrorMessage_set_channel_id(this_ptr: &mut ErrorMessage, mut val: crate::c_types::ThirtyTwoBytes) {
 280         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
 281 }
 282 /// A possibly human-readable error description.
 283 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
 284 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
 285 /// the terminal emulator or the logging subsystem.
 286 #[no_mangle]
 287 pub extern "C" fn ErrorMessage_get_data(this_ptr: &ErrorMessage) -> crate::c_types::Str {
 288         let mut inner_val = &mut this_ptr.get_native_mut_ref().data;
 289         inner_val.as_str().into()
 290 }
 291 /// A possibly human-readable error description.
 292 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
 293 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
 294 /// the terminal emulator or the logging subsystem.
 295 #[no_mangle]
 296 pub extern "C" fn ErrorMessage_set_data(this_ptr: &mut ErrorMessage, mut val: crate::c_types::Str) {
 297         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.data = val.into_string();
 298 }
 299 /// Constructs a new ErrorMessage given each field
 300 #[must_use]
 301 #[no_mangle]
 302 pub extern "C" fn ErrorMessage_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut data_arg: crate::c_types::Str) -> ErrorMessage {
 303         ErrorMessage { inner: ObjOps::heap_alloc(nativeErrorMessage {
 304                 channel_id: channel_id_arg.data,
 305                 data: data_arg.into_string(),
 306         }), is_owned: true }
 307 }
 308 impl Clone for ErrorMessage {
 309         fn clone(&self) -> Self {
 310                 Self {
 311                         inner: if <*mut nativeErrorMessage>::is_null(self.inner) { core::ptr::null_mut() } else {
 312                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 313                         is_owned: true,
 314                 }
 315         }
 316 }
 317 #[allow(unused)]
 318 /// Used only if an object of this type is returned as a trait impl by a method
 319 pub(crate) extern "C" fn ErrorMessage_clone_void(this_ptr: *const c_void) -> *mut c_void {
 320         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeErrorMessage)).clone() })) as *mut c_void
 321 }
 322 #[no_mangle]
 323 /// Creates a copy of the ErrorMessage
 324 pub extern "C" fn ErrorMessage_clone(orig: &ErrorMessage) -> ErrorMessage {
 325         orig.clone()
 326 }
 327
 328 use lightning::ln::msgs::WarningMessage as nativeWarningMessageImport;
 329 pub(crate) type nativeWarningMessage = nativeWarningMessageImport;
 330
 331 /// A warning message to be sent or received from a peer
 332 #[must_use]
 333 #[repr(C)]
 334 pub struct WarningMessage {
 335         /// A pointer to the opaque Rust object.
 336
 337         /// Nearly everywhere, inner must be non-null, however in places where
 338         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 339         pub inner: *mut nativeWarningMessage,
 340         /// Indicates that this is the only struct which contains the same pointer.
 341
 342         /// Rust functions which take ownership of an object provided via an argument require
 343         /// this to be true and invalidate the object pointed to by inner.
 344         pub is_owned: bool,
 345 }
 346
 347 impl Drop for WarningMessage {
 348         fn drop(&mut self) {
 349                 if self.is_owned && !<*mut nativeWarningMessage>::is_null(self.inner) {
 350                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 351                 }
 352         }
 353 }
 354 /// Frees any resources used by the WarningMessage, if is_owned is set and inner is non-NULL.
 355 #[no_mangle]
 356 pub extern "C" fn WarningMessage_free(this_obj: WarningMessage) { }
 357 #[allow(unused)]
 358 /// Used only if an object of this type is returned as a trait impl by a method
 359 pub(crate) extern "C" fn WarningMessage_free_void(this_ptr: *mut c_void) {
 360         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeWarningMessage); }
 361 }
 362 #[allow(unused)]
 363 impl WarningMessage {
 364         pub(crate) fn get_native_ref(&self) -> &'static nativeWarningMessage {
 365                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 366         }
 367         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeWarningMessage {
 368                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 369         }
 370         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 371         pub(crate) fn take_inner(mut self) -> *mut nativeWarningMessage {
 372                 assert!(self.is_owned);
 373                 let ret = ObjOps::untweak_ptr(self.inner);
 374                 self.inner = core::ptr::null_mut();
 375                 ret
 376         }
 377 }
 378 /// The channel ID involved in the warning.
 379 ///
 380 /// All-0s indicates a warning unrelated to a specific channel.
 381 #[no_mangle]
 382 pub extern "C" fn WarningMessage_get_channel_id(this_ptr: &WarningMessage) -> *const [u8; 32] {
 383         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
 384         inner_val
 385 }
 386 /// The channel ID involved in the warning.
 387 ///
 388 /// All-0s indicates a warning unrelated to a specific channel.
 389 #[no_mangle]
 390 pub extern "C" fn WarningMessage_set_channel_id(this_ptr: &mut WarningMessage, mut val: crate::c_types::ThirtyTwoBytes) {
 391         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
 392 }
 393 /// A possibly human-readable warning description.
 394 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
 395 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
 396 /// the terminal emulator or the logging subsystem.
 397 #[no_mangle]
 398 pub extern "C" fn WarningMessage_get_data(this_ptr: &WarningMessage) -> crate::c_types::Str {
 399         let mut inner_val = &mut this_ptr.get_native_mut_ref().data;
 400         inner_val.as_str().into()
 401 }
 402 /// A possibly human-readable warning description.
 403 /// The string should be sanitized before it is used (e.g. emitted to logs or printed to
 404 /// stdout). Otherwise, a well crafted error message may trigger a security vulnerability in
 405 /// the terminal emulator or the logging subsystem.
 406 #[no_mangle]
 407 pub extern "C" fn WarningMessage_set_data(this_ptr: &mut WarningMessage, mut val: crate::c_types::Str) {
 408         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.data = val.into_string();
 409 }
 410 /// Constructs a new WarningMessage given each field
 411 #[must_use]
 412 #[no_mangle]
 413 pub extern "C" fn WarningMessage_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut data_arg: crate::c_types::Str) -> WarningMessage {
 414         WarningMessage { inner: ObjOps::heap_alloc(nativeWarningMessage {
 415                 channel_id: channel_id_arg.data,
 416                 data: data_arg.into_string(),
 417         }), is_owned: true }
 418 }
 419 impl Clone for WarningMessage {
 420         fn clone(&self) -> Self {
 421                 Self {
 422                         inner: if <*mut nativeWarningMessage>::is_null(self.inner) { core::ptr::null_mut() } else {
 423                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 424                         is_owned: true,
 425                 }
 426         }
 427 }
 428 #[allow(unused)]
 429 /// Used only if an object of this type is returned as a trait impl by a method
 430 pub(crate) extern "C" fn WarningMessage_clone_void(this_ptr: *const c_void) -> *mut c_void {
 431         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeWarningMessage)).clone() })) as *mut c_void
 432 }
 433 #[no_mangle]
 434 /// Creates a copy of the WarningMessage
 435 pub extern "C" fn WarningMessage_clone(orig: &WarningMessage) -> WarningMessage {
 436         orig.clone()
 437 }
 438
 439 use lightning::ln::msgs::Ping as nativePingImport;
 440 pub(crate) type nativePing = nativePingImport;
 441
 442 /// A ping message to be sent or received from a peer
 443 #[must_use]
 444 #[repr(C)]
 445 pub struct Ping {
 446         /// A pointer to the opaque Rust object.
 447
 448         /// Nearly everywhere, inner must be non-null, however in places where
 449         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 450         pub inner: *mut nativePing,
 451         /// Indicates that this is the only struct which contains the same pointer.
 452
 453         /// Rust functions which take ownership of an object provided via an argument require
 454         /// this to be true and invalidate the object pointed to by inner.
 455         pub is_owned: bool,
 456 }
 457
 458 impl Drop for Ping {
 459         fn drop(&mut self) {
 460                 if self.is_owned && !<*mut nativePing>::is_null(self.inner) {
 461                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 462                 }
 463         }
 464 }
 465 /// Frees any resources used by the Ping, if is_owned is set and inner is non-NULL.
 466 #[no_mangle]
 467 pub extern "C" fn Ping_free(this_obj: Ping) { }
 468 #[allow(unused)]
 469 /// Used only if an object of this type is returned as a trait impl by a method
 470 pub(crate) extern "C" fn Ping_free_void(this_ptr: *mut c_void) {
 471         unsafe { let _ = Box::from_raw(this_ptr as *mut nativePing); }
 472 }
 473 #[allow(unused)]
 474 impl Ping {
 475         pub(crate) fn get_native_ref(&self) -> &'static nativePing {
 476                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 477         }
 478         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativePing {
 479                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 480         }
 481         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 482         pub(crate) fn take_inner(mut self) -> *mut nativePing {
 483                 assert!(self.is_owned);
 484                 let ret = ObjOps::untweak_ptr(self.inner);
 485                 self.inner = core::ptr::null_mut();
 486                 ret
 487         }
 488 }
 489 /// The desired response length
 490 #[no_mangle]
 491 pub extern "C" fn Ping_get_ponglen(this_ptr: &Ping) -> u16 {
 492         let mut inner_val = &mut this_ptr.get_native_mut_ref().ponglen;
 493         *inner_val
 494 }
 495 /// The desired response length
 496 #[no_mangle]
 497 pub extern "C" fn Ping_set_ponglen(this_ptr: &mut Ping, mut val: u16) {
 498         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.ponglen = val;
 499 }
 500 /// The ping packet size.
 501 /// This field is not sent on the wire. byteslen zeros are sent.
 502 #[no_mangle]
 503 pub extern "C" fn Ping_get_byteslen(this_ptr: &Ping) -> u16 {
 504         let mut inner_val = &mut this_ptr.get_native_mut_ref().byteslen;
 505         *inner_val
 506 }
 507 /// The ping packet size.
 508 /// This field is not sent on the wire. byteslen zeros are sent.
 509 #[no_mangle]
 510 pub extern "C" fn Ping_set_byteslen(this_ptr: &mut Ping, mut val: u16) {
 511         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.byteslen = val;
 512 }
 513 /// Constructs a new Ping given each field
 514 #[must_use]
 515 #[no_mangle]
 516 pub extern "C" fn Ping_new(mut ponglen_arg: u16, mut byteslen_arg: u16) -> Ping {
 517         Ping { inner: ObjOps::heap_alloc(nativePing {
 518                 ponglen: ponglen_arg,
 519                 byteslen: byteslen_arg,
 520         }), is_owned: true }
 521 }
 522 impl Clone for Ping {
 523         fn clone(&self) -> Self {
 524                 Self {
 525                         inner: if <*mut nativePing>::is_null(self.inner) { core::ptr::null_mut() } else {
 526                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 527                         is_owned: true,
 528                 }
 529         }
 530 }
 531 #[allow(unused)]
 532 /// Used only if an object of this type is returned as a trait impl by a method
 533 pub(crate) extern "C" fn Ping_clone_void(this_ptr: *const c_void) -> *mut c_void {
 534         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePing)).clone() })) as *mut c_void
 535 }
 536 #[no_mangle]
 537 /// Creates a copy of the Ping
 538 pub extern "C" fn Ping_clone(orig: &Ping) -> Ping {
 539         orig.clone()
 540 }
 541
 542 use lightning::ln::msgs::Pong as nativePongImport;
 543 pub(crate) type nativePong = nativePongImport;
 544
 545 /// A pong message to be sent or received from a peer
 546 #[must_use]
 547 #[repr(C)]
 548 pub struct Pong {
 549         /// A pointer to the opaque Rust object.
 550
 551         /// Nearly everywhere, inner must be non-null, however in places where
 552         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 553         pub inner: *mut nativePong,
 554         /// Indicates that this is the only struct which contains the same pointer.
 555
 556         /// Rust functions which take ownership of an object provided via an argument require
 557         /// this to be true and invalidate the object pointed to by inner.
 558         pub is_owned: bool,
 559 }
 560
 561 impl Drop for Pong {
 562         fn drop(&mut self) {
 563                 if self.is_owned && !<*mut nativePong>::is_null(self.inner) {
 564                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 565                 }
 566         }
 567 }
 568 /// Frees any resources used by the Pong, if is_owned is set and inner is non-NULL.
 569 #[no_mangle]
 570 pub extern "C" fn Pong_free(this_obj: Pong) { }
 571 #[allow(unused)]
 572 /// Used only if an object of this type is returned as a trait impl by a method
 573 pub(crate) extern "C" fn Pong_free_void(this_ptr: *mut c_void) {
 574         unsafe { let _ = Box::from_raw(this_ptr as *mut nativePong); }
 575 }
 576 #[allow(unused)]
 577 impl Pong {
 578         pub(crate) fn get_native_ref(&self) -> &'static nativePong {
 579                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 580         }
 581         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativePong {
 582                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 583         }
 584         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 585         pub(crate) fn take_inner(mut self) -> *mut nativePong {
 586                 assert!(self.is_owned);
 587                 let ret = ObjOps::untweak_ptr(self.inner);
 588                 self.inner = core::ptr::null_mut();
 589                 ret
 590         }
 591 }
 592 /// The pong packet size.
 593 /// This field is not sent on the wire. byteslen zeros are sent.
 594 #[no_mangle]
 595 pub extern "C" fn Pong_get_byteslen(this_ptr: &Pong) -> u16 {
 596         let mut inner_val = &mut this_ptr.get_native_mut_ref().byteslen;
 597         *inner_val
 598 }
 599 /// The pong packet size.
 600 /// This field is not sent on the wire. byteslen zeros are sent.
 601 #[no_mangle]
 602 pub extern "C" fn Pong_set_byteslen(this_ptr: &mut Pong, mut val: u16) {
 603         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.byteslen = val;
 604 }
 605 /// Constructs a new Pong given each field
 606 #[must_use]
 607 #[no_mangle]
 608 pub extern "C" fn Pong_new(mut byteslen_arg: u16) -> Pong {
 609         Pong { inner: ObjOps::heap_alloc(nativePong {
 610                 byteslen: byteslen_arg,
 611         }), is_owned: true }
 612 }
 613 impl Clone for Pong {
 614         fn clone(&self) -> Self {
 615                 Self {
 616                         inner: if <*mut nativePong>::is_null(self.inner) { core::ptr::null_mut() } else {
 617                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 618                         is_owned: true,
 619                 }
 620         }
 621 }
 622 #[allow(unused)]
 623 /// Used only if an object of this type is returned as a trait impl by a method
 624 pub(crate) extern "C" fn Pong_clone_void(this_ptr: *const c_void) -> *mut c_void {
 625         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePong)).clone() })) as *mut c_void
 626 }
 627 #[no_mangle]
 628 /// Creates a copy of the Pong
 629 pub extern "C" fn Pong_clone(orig: &Pong) -> Pong {
 630         orig.clone()
 631 }
 632
 633 use lightning::ln::msgs::OpenChannel as nativeOpenChannelImport;
 634 pub(crate) type nativeOpenChannel = nativeOpenChannelImport;
 635
 636 /// An open_channel message to be sent or received from a peer
 637 #[must_use]
 638 #[repr(C)]
 639 pub struct OpenChannel {
 640         /// A pointer to the opaque Rust object.
 641
 642         /// Nearly everywhere, inner must be non-null, however in places where
 643         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 644         pub inner: *mut nativeOpenChannel,
 645         /// Indicates that this is the only struct which contains the same pointer.
 646
 647         /// Rust functions which take ownership of an object provided via an argument require
 648         /// this to be true and invalidate the object pointed to by inner.
 649         pub is_owned: bool,
 650 }
 651
 652 impl Drop for OpenChannel {
 653         fn drop(&mut self) {
 654                 if self.is_owned && !<*mut nativeOpenChannel>::is_null(self.inner) {
 655                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 656                 }
 657         }
 658 }
 659 /// Frees any resources used by the OpenChannel, if is_owned is set and inner is non-NULL.
 660 #[no_mangle]
 661 pub extern "C" fn OpenChannel_free(this_obj: OpenChannel) { }
 662 #[allow(unused)]
 663 /// Used only if an object of this type is returned as a trait impl by a method
 664 pub(crate) extern "C" fn OpenChannel_free_void(this_ptr: *mut c_void) {
 665         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeOpenChannel); }
 666 }
 667 #[allow(unused)]
 668 impl OpenChannel {
 669         pub(crate) fn get_native_ref(&self) -> &'static nativeOpenChannel {
 670                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 671         }
 672         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeOpenChannel {
 673                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 674         }
 675         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 676         pub(crate) fn take_inner(mut self) -> *mut nativeOpenChannel {
 677                 assert!(self.is_owned);
 678                 let ret = ObjOps::untweak_ptr(self.inner);
 679                 self.inner = core::ptr::null_mut();
 680                 ret
 681         }
 682 }
 683 /// The genesis hash of the blockchain where the channel is to be opened
 684 #[no_mangle]
 685 pub extern "C" fn OpenChannel_get_chain_hash(this_ptr: &OpenChannel) -> *const [u8; 32] {
 686         let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
 687         inner_val.as_inner()
 688 }
 689 /// The genesis hash of the blockchain where the channel is to be opened
 690 #[no_mangle]
 691 pub extern "C" fn OpenChannel_set_chain_hash(this_ptr: &mut OpenChannel, mut val: crate::c_types::ThirtyTwoBytes) {
 692         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
 693 }
 694 /// A temporary channel ID, until the funding outpoint is announced
 695 #[no_mangle]
 696 pub extern "C" fn OpenChannel_get_temporary_channel_id(this_ptr: &OpenChannel) -> *const [u8; 32] {
 697         let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
 698         inner_val
 699 }
 700 /// A temporary channel ID, until the funding outpoint is announced
 701 #[no_mangle]
 702 pub extern "C" fn OpenChannel_set_temporary_channel_id(this_ptr: &mut OpenChannel, mut val: crate::c_types::ThirtyTwoBytes) {
 703         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = val.data;
 704 }
 705 /// The channel value
 706 #[no_mangle]
 707 pub extern "C" fn OpenChannel_get_funding_satoshis(this_ptr: &OpenChannel) -> u64 {
 708         let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_satoshis;
 709         *inner_val
 710 }
 711 /// The channel value
 712 #[no_mangle]
 713 pub extern "C" fn OpenChannel_set_funding_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
 714         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_satoshis = val;
 715 }
 716 /// The amount to push to the counterparty as part of the open, in milli-satoshi
 717 #[no_mangle]
 718 pub extern "C" fn OpenChannel_get_push_msat(this_ptr: &OpenChannel) -> u64 {
 719         let mut inner_val = &mut this_ptr.get_native_mut_ref().push_msat;
 720         *inner_val
 721 }
 722 /// The amount to push to the counterparty as part of the open, in milli-satoshi
 723 #[no_mangle]
 724 pub extern "C" fn OpenChannel_set_push_msat(this_ptr: &mut OpenChannel, mut val: u64) {
 725         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.push_msat = val;
 726 }
 727 /// The threshold below which outputs on transactions broadcast by sender will be omitted
 728 #[no_mangle]
 729 pub extern "C" fn OpenChannel_get_dust_limit_satoshis(this_ptr: &OpenChannel) -> u64 {
 730         let mut inner_val = &mut this_ptr.get_native_mut_ref().dust_limit_satoshis;
 731         *inner_val
 732 }
 733 /// The threshold below which outputs on transactions broadcast by sender will be omitted
 734 #[no_mangle]
 735 pub extern "C" fn OpenChannel_set_dust_limit_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
 736         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.dust_limit_satoshis = val;
 737 }
 738 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
 739 #[no_mangle]
 740 pub extern "C" fn OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: &OpenChannel) -> u64 {
 741         let mut inner_val = &mut this_ptr.get_native_mut_ref().max_htlc_value_in_flight_msat;
 742         *inner_val
 743 }
 744 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
 745 #[no_mangle]
 746 pub extern "C" fn OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: &mut OpenChannel, mut val: u64) {
 747         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_htlc_value_in_flight_msat = val;
 748 }
 749 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
 750 #[no_mangle]
 751 pub extern "C" fn OpenChannel_get_channel_reserve_satoshis(this_ptr: &OpenChannel) -> u64 {
 752         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_reserve_satoshis;
 753         *inner_val
 754 }
 755 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
 756 #[no_mangle]
 757 pub extern "C" fn OpenChannel_set_channel_reserve_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
 758         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_reserve_satoshis = val;
 759 }
 760 /// The minimum HTLC size incoming to sender, in milli-satoshi
 761 #[no_mangle]
 762 pub extern "C" fn OpenChannel_get_htlc_minimum_msat(this_ptr: &OpenChannel) -> u64 {
 763         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_minimum_msat;
 764         *inner_val
 765 }
 766 /// The minimum HTLC size incoming to sender, in milli-satoshi
 767 #[no_mangle]
 768 pub extern "C" fn OpenChannel_set_htlc_minimum_msat(this_ptr: &mut OpenChannel, mut val: u64) {
 769         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_minimum_msat = val;
 770 }
 771 /// The feerate per 1000-weight of sender generated transactions, until updated by update_fee
 772 #[no_mangle]
 773 pub extern "C" fn OpenChannel_get_feerate_per_kw(this_ptr: &OpenChannel) -> u32 {
 774         let mut inner_val = &mut this_ptr.get_native_mut_ref().feerate_per_kw;
 775         *inner_val
 776 }
 777 /// The feerate per 1000-weight of sender generated transactions, until updated by update_fee
 778 #[no_mangle]
 779 pub extern "C" fn OpenChannel_set_feerate_per_kw(this_ptr: &mut OpenChannel, mut val: u32) {
 780         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.feerate_per_kw = val;
 781 }
 782 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
 783 #[no_mangle]
 784 pub extern "C" fn OpenChannel_get_to_self_delay(this_ptr: &OpenChannel) -> u16 {
 785         let mut inner_val = &mut this_ptr.get_native_mut_ref().to_self_delay;
 786         *inner_val
 787 }
 788 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
 789 #[no_mangle]
 790 pub extern "C" fn OpenChannel_set_to_self_delay(this_ptr: &mut OpenChannel, mut val: u16) {
 791         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.to_self_delay = val;
 792 }
 793 /// The maximum number of inbound HTLCs towards sender
 794 #[no_mangle]
 795 pub extern "C" fn OpenChannel_get_max_accepted_htlcs(this_ptr: &OpenChannel) -> u16 {
 796         let mut inner_val = &mut this_ptr.get_native_mut_ref().max_accepted_htlcs;
 797         *inner_val
 798 }
 799 /// The maximum number of inbound HTLCs towards sender
 800 #[no_mangle]
 801 pub extern "C" fn OpenChannel_set_max_accepted_htlcs(this_ptr: &mut OpenChannel, mut val: u16) {
 802         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_accepted_htlcs = val;
 803 }
 804 /// The sender's key controlling the funding transaction
 805 #[no_mangle]
 806 pub extern "C" fn OpenChannel_get_funding_pubkey(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
 807         let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_pubkey;
 808         crate::c_types::PublicKey::from_rust(&inner_val)
 809 }
 810 /// The sender's key controlling the funding transaction
 811 #[no_mangle]
 812 pub extern "C" fn OpenChannel_set_funding_pubkey(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
 813         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_pubkey = val.into_rust();
 814 }
 815 /// Used to derive a revocation key for transactions broadcast by counterparty
 816 #[no_mangle]
 817 pub extern "C" fn OpenChannel_get_revocation_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
 818         let mut inner_val = &mut this_ptr.get_native_mut_ref().revocation_basepoint;
 819         crate::c_types::PublicKey::from_rust(&inner_val)
 820 }
 821 /// Used to derive a revocation key for transactions broadcast by counterparty
 822 #[no_mangle]
 823 pub extern "C" fn OpenChannel_set_revocation_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
 824         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.revocation_basepoint = val.into_rust();
 825 }
 826 /// A payment key to sender for transactions broadcast by counterparty
 827 #[no_mangle]
 828 pub extern "C" fn OpenChannel_get_payment_point(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
 829         let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_point;
 830         crate::c_types::PublicKey::from_rust(&inner_val)
 831 }
 832 /// A payment key to sender for transactions broadcast by counterparty
 833 #[no_mangle]
 834 pub extern "C" fn OpenChannel_set_payment_point(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
 835         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_point = val.into_rust();
 836 }
 837 /// Used to derive a payment key to sender for transactions broadcast by sender
 838 #[no_mangle]
 839 pub extern "C" fn OpenChannel_get_delayed_payment_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
 840         let mut inner_val = &mut this_ptr.get_native_mut_ref().delayed_payment_basepoint;
 841         crate::c_types::PublicKey::from_rust(&inner_val)
 842 }
 843 /// Used to derive a payment key to sender for transactions broadcast by sender
 844 #[no_mangle]
 845 pub extern "C" fn OpenChannel_set_delayed_payment_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
 846         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.delayed_payment_basepoint = val.into_rust();
 847 }
 848 /// Used to derive an HTLC payment key to sender
 849 #[no_mangle]
 850 pub extern "C" fn OpenChannel_get_htlc_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
 851         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_basepoint;
 852         crate::c_types::PublicKey::from_rust(&inner_val)
 853 }
 854 /// Used to derive an HTLC payment key to sender
 855 #[no_mangle]
 856 pub extern "C" fn OpenChannel_set_htlc_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
 857         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_basepoint = val.into_rust();
 858 }
 859 /// The first to-be-broadcast-by-sender transaction's per commitment point
 860 #[no_mangle]
 861 pub extern "C" fn OpenChannel_get_first_per_commitment_point(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
 862         let mut inner_val = &mut this_ptr.get_native_mut_ref().first_per_commitment_point;
 863         crate::c_types::PublicKey::from_rust(&inner_val)
 864 }
 865 /// The first to-be-broadcast-by-sender transaction's per commitment point
 866 #[no_mangle]
 867 pub extern "C" fn OpenChannel_set_first_per_commitment_point(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
 868         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.first_per_commitment_point = val.into_rust();
 869 }
 870 /// Channel flags
 871 #[no_mangle]
 872 pub extern "C" fn OpenChannel_get_channel_flags(this_ptr: &OpenChannel) -> u8 {
 873         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_flags;
 874         *inner_val
 875 }
 876 /// Channel flags
 877 #[no_mangle]
 878 pub extern "C" fn OpenChannel_set_channel_flags(this_ptr: &mut OpenChannel, mut val: u8) {
 879         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_flags = val;
 880 }
 881 /// The channel type that this channel will represent. If none is set, we derive the channel
 882 /// type from the intersection of our feature bits with our counterparty's feature bits from
 883 /// the Init message.
 884 ///
 885 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
 886 #[no_mangle]
 887 pub extern "C" fn OpenChannel_get_channel_type(this_ptr: &OpenChannel) -> crate::lightning::ln::features::ChannelTypeFeatures {
 888         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_type;
 889         let mut local_inner_val = crate::lightning::ln::features::ChannelTypeFeatures { 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::ChannelTypeFeatures<>) as *mut _ }, is_owned: false };
 890         local_inner_val
 891 }
 892 /// The channel type that this channel will represent. If none is set, we derive the channel
 893 /// type from the intersection of our feature bits with our counterparty's feature bits from
 894 /// the Init message.
 895 ///
 896 /// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
 897 #[no_mangle]
 898 pub extern "C" fn OpenChannel_set_channel_type(this_ptr: &mut OpenChannel, mut val: crate::lightning::ln::features::ChannelTypeFeatures) {
 899         let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
 900         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_type = local_val;
 901 }
 902 impl Clone for OpenChannel {
 903         fn clone(&self) -> Self {
 904                 Self {
 905                         inner: if <*mut nativeOpenChannel>::is_null(self.inner) { core::ptr::null_mut() } else {
 906                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
 907                         is_owned: true,
 908                 }
 909         }
 910 }
 911 #[allow(unused)]
 912 /// Used only if an object of this type is returned as a trait impl by a method
 913 pub(crate) extern "C" fn OpenChannel_clone_void(this_ptr: *const c_void) -> *mut c_void {
 914         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeOpenChannel)).clone() })) as *mut c_void
 915 }
 916 #[no_mangle]
 917 /// Creates a copy of the OpenChannel
 918 pub extern "C" fn OpenChannel_clone(orig: &OpenChannel) -> OpenChannel {
 919         orig.clone()
 920 }
 921
 922 use lightning::ln::msgs::AcceptChannel as nativeAcceptChannelImport;
 923 pub(crate) type nativeAcceptChannel = nativeAcceptChannelImport;
 924
 925 /// An accept_channel message to be sent or received from a peer
 926 #[must_use]
 927 #[repr(C)]
 928 pub struct AcceptChannel {
 929         /// A pointer to the opaque Rust object.
 930
 931         /// Nearly everywhere, inner must be non-null, however in places where
 932         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 933         pub inner: *mut nativeAcceptChannel,
 934         /// Indicates that this is the only struct which contains the same pointer.
 935
 936         /// Rust functions which take ownership of an object provided via an argument require
 937         /// this to be true and invalidate the object pointed to by inner.
 938         pub is_owned: bool,
 939 }
 940
 941 impl Drop for AcceptChannel {
 942         fn drop(&mut self) {
 943                 if self.is_owned && !<*mut nativeAcceptChannel>::is_null(self.inner) {
 944                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
 945                 }
 946         }
 947 }
 948 /// Frees any resources used by the AcceptChannel, if is_owned is set and inner is non-NULL.
 949 #[no_mangle]
 950 pub extern "C" fn AcceptChannel_free(this_obj: AcceptChannel) { }
 951 #[allow(unused)]
 952 /// Used only if an object of this type is returned as a trait impl by a method
 953 pub(crate) extern "C" fn AcceptChannel_free_void(this_ptr: *mut c_void) {
 954         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeAcceptChannel); }
 955 }
 956 #[allow(unused)]
 957 impl AcceptChannel {
 958         pub(crate) fn get_native_ref(&self) -> &'static nativeAcceptChannel {
 959                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
 960         }
 961         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeAcceptChannel {
 962                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
 963         }
 964         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 965         pub(crate) fn take_inner(mut self) -> *mut nativeAcceptChannel {
 966                 assert!(self.is_owned);
 967                 let ret = ObjOps::untweak_ptr(self.inner);
 968                 self.inner = core::ptr::null_mut();
 969                 ret
 970         }
 971 }
 972 /// A temporary channel ID, until the funding outpoint is announced
 973 #[no_mangle]
 974 pub extern "C" fn AcceptChannel_get_temporary_channel_id(this_ptr: &AcceptChannel) -> *const [u8; 32] {
 975         let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
 976         inner_val
 977 }
 978 /// A temporary channel ID, until the funding outpoint is announced
 979 #[no_mangle]
 980 pub extern "C" fn AcceptChannel_set_temporary_channel_id(this_ptr: &mut AcceptChannel, mut val: crate::c_types::ThirtyTwoBytes) {
 981         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = val.data;
 982 }
 983 /// The threshold below which outputs on transactions broadcast by sender will be omitted
 984 #[no_mangle]
 985 pub extern "C" fn AcceptChannel_get_dust_limit_satoshis(this_ptr: &AcceptChannel) -> u64 {
 986         let mut inner_val = &mut this_ptr.get_native_mut_ref().dust_limit_satoshis;
 987         *inner_val
 988 }
 989 /// The threshold below which outputs on transactions broadcast by sender will be omitted
 990 #[no_mangle]
 991 pub extern "C" fn AcceptChannel_set_dust_limit_satoshis(this_ptr: &mut AcceptChannel, mut val: u64) {
 992         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.dust_limit_satoshis = val;
 993 }
 994 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
 995 #[no_mangle]
 996 pub extern "C" fn AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: &AcceptChannel) -> u64 {
 997         let mut inner_val = &mut this_ptr.get_native_mut_ref().max_htlc_value_in_flight_msat;
 998         *inner_val
 999 }
1000 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
1001 #[no_mangle]
1002 pub extern "C" fn AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: &mut AcceptChannel, mut val: u64) {
1003         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_htlc_value_in_flight_msat = val;
1004 }
1005 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
1006 #[no_mangle]
1007 pub extern "C" fn AcceptChannel_get_channel_reserve_satoshis(this_ptr: &AcceptChannel) -> u64 {
1008         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_reserve_satoshis;
1009         *inner_val
1010 }
1011 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
1012 #[no_mangle]
1013 pub extern "C" fn AcceptChannel_set_channel_reserve_satoshis(this_ptr: &mut AcceptChannel, mut val: u64) {
1014         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_reserve_satoshis = val;
1015 }
1016 /// The minimum HTLC size incoming to sender, in milli-satoshi
1017 #[no_mangle]
1018 pub extern "C" fn AcceptChannel_get_htlc_minimum_msat(this_ptr: &AcceptChannel) -> u64 {
1019         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_minimum_msat;
1020         *inner_val
1021 }
1022 /// The minimum HTLC size incoming to sender, in milli-satoshi
1023 #[no_mangle]
1024 pub extern "C" fn AcceptChannel_set_htlc_minimum_msat(this_ptr: &mut AcceptChannel, mut val: u64) {
1025         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_minimum_msat = val;
1026 }
1027 /// Minimum depth of the funding transaction before the channel is considered open
1028 #[no_mangle]
1029 pub extern "C" fn AcceptChannel_get_minimum_depth(this_ptr: &AcceptChannel) -> u32 {
1030         let mut inner_val = &mut this_ptr.get_native_mut_ref().minimum_depth;
1031         *inner_val
1032 }
1033 /// Minimum depth of the funding transaction before the channel is considered open
1034 #[no_mangle]
1035 pub extern "C" fn AcceptChannel_set_minimum_depth(this_ptr: &mut AcceptChannel, mut val: u32) {
1036         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.minimum_depth = val;
1037 }
1038 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
1039 #[no_mangle]
1040 pub extern "C" fn AcceptChannel_get_to_self_delay(this_ptr: &AcceptChannel) -> u16 {
1041         let mut inner_val = &mut this_ptr.get_native_mut_ref().to_self_delay;
1042         *inner_val
1043 }
1044 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
1045 #[no_mangle]
1046 pub extern "C" fn AcceptChannel_set_to_self_delay(this_ptr: &mut AcceptChannel, mut val: u16) {
1047         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.to_self_delay = val;
1048 }
1049 /// The maximum number of inbound HTLCs towards sender
1050 #[no_mangle]
1051 pub extern "C" fn AcceptChannel_get_max_accepted_htlcs(this_ptr: &AcceptChannel) -> u16 {
1052         let mut inner_val = &mut this_ptr.get_native_mut_ref().max_accepted_htlcs;
1053         *inner_val
1054 }
1055 /// The maximum number of inbound HTLCs towards sender
1056 #[no_mangle]
1057 pub extern "C" fn AcceptChannel_set_max_accepted_htlcs(this_ptr: &mut AcceptChannel, mut val: u16) {
1058         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_accepted_htlcs = val;
1059 }
1060 /// The sender's key controlling the funding transaction
1061 #[no_mangle]
1062 pub extern "C" fn AcceptChannel_get_funding_pubkey(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
1063         let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_pubkey;
1064         crate::c_types::PublicKey::from_rust(&inner_val)
1065 }
1066 /// The sender's key controlling the funding transaction
1067 #[no_mangle]
1068 pub extern "C" fn AcceptChannel_set_funding_pubkey(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
1069         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_pubkey = val.into_rust();
1070 }
1071 /// Used to derive a revocation key for transactions broadcast by counterparty
1072 #[no_mangle]
1073 pub extern "C" fn AcceptChannel_get_revocation_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
1074         let mut inner_val = &mut this_ptr.get_native_mut_ref().revocation_basepoint;
1075         crate::c_types::PublicKey::from_rust(&inner_val)
1076 }
1077 /// Used to derive a revocation key for transactions broadcast by counterparty
1078 #[no_mangle]
1079 pub extern "C" fn AcceptChannel_set_revocation_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
1080         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.revocation_basepoint = val.into_rust();
1081 }
1082 /// A payment key to sender for transactions broadcast by counterparty
1083 #[no_mangle]
1084 pub extern "C" fn AcceptChannel_get_payment_point(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
1085         let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_point;
1086         crate::c_types::PublicKey::from_rust(&inner_val)
1087 }
1088 /// A payment key to sender for transactions broadcast by counterparty
1089 #[no_mangle]
1090 pub extern "C" fn AcceptChannel_set_payment_point(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
1091         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_point = val.into_rust();
1092 }
1093 /// Used to derive a payment key to sender for transactions broadcast by sender
1094 #[no_mangle]
1095 pub extern "C" fn AcceptChannel_get_delayed_payment_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
1096         let mut inner_val = &mut this_ptr.get_native_mut_ref().delayed_payment_basepoint;
1097         crate::c_types::PublicKey::from_rust(&inner_val)
1098 }
1099 /// Used to derive a payment key to sender for transactions broadcast by sender
1100 #[no_mangle]
1101 pub extern "C" fn AcceptChannel_set_delayed_payment_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
1102         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.delayed_payment_basepoint = val.into_rust();
1103 }
1104 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
1105 #[no_mangle]
1106 pub extern "C" fn AcceptChannel_get_htlc_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
1107         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_basepoint;
1108         crate::c_types::PublicKey::from_rust(&inner_val)
1109 }
1110 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
1111 #[no_mangle]
1112 pub extern "C" fn AcceptChannel_set_htlc_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
1113         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_basepoint = val.into_rust();
1114 }
1115 /// The first to-be-broadcast-by-sender transaction's per commitment point
1116 #[no_mangle]
1117 pub extern "C" fn AcceptChannel_get_first_per_commitment_point(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
1118         let mut inner_val = &mut this_ptr.get_native_mut_ref().first_per_commitment_point;
1119         crate::c_types::PublicKey::from_rust(&inner_val)
1120 }
1121 /// The first to-be-broadcast-by-sender transaction's per commitment point
1122 #[no_mangle]
1123 pub extern "C" fn AcceptChannel_set_first_per_commitment_point(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
1124         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.first_per_commitment_point = val.into_rust();
1125 }
1126 /// The channel type that this channel will represent. If none is set, we derive the channel
1127 /// type from the intersection of our feature bits with our counterparty's feature bits from
1128 /// the Init message.
1129 ///
1130 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
1131 ///
1132 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
1133 #[no_mangle]
1134 pub extern "C" fn AcceptChannel_get_channel_type(this_ptr: &AcceptChannel) -> crate::lightning::ln::features::ChannelTypeFeatures {
1135         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_type;
1136         let mut local_inner_val = crate::lightning::ln::features::ChannelTypeFeatures { 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::ChannelTypeFeatures<>) as *mut _ }, is_owned: false };
1137         local_inner_val
1138 }
1139 /// The channel type that this channel will represent. If none is set, we derive the channel
1140 /// type from the intersection of our feature bits with our counterparty's feature bits from
1141 /// the Init message.
1142 ///
1143 /// This is required to match the equivalent field in [`OpenChannel::channel_type`].
1144 ///
1145 /// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
1146 #[no_mangle]
1147 pub extern "C" fn AcceptChannel_set_channel_type(this_ptr: &mut AcceptChannel, mut val: crate::lightning::ln::features::ChannelTypeFeatures) {
1148         let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
1149         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_type = local_val;
1150 }
1151 impl Clone for AcceptChannel {
1152         fn clone(&self) -> Self {
1153                 Self {
1154                         inner: if <*mut nativeAcceptChannel>::is_null(self.inner) { core::ptr::null_mut() } else {
1155                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
1156                         is_owned: true,
1157                 }
1158         }
1159 }
1160 #[allow(unused)]
1161 /// Used only if an object of this type is returned as a trait impl by a method
1162 pub(crate) extern "C" fn AcceptChannel_clone_void(this_ptr: *const c_void) -> *mut c_void {
1163         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeAcceptChannel)).clone() })) as *mut c_void
1164 }
1165 #[no_mangle]
1166 /// Creates a copy of the AcceptChannel
1167 pub extern "C" fn AcceptChannel_clone(orig: &AcceptChannel) -> AcceptChannel {
1168         orig.clone()
1169 }
1170
1171 use lightning::ln::msgs::FundingCreated as nativeFundingCreatedImport;
1172 pub(crate) type nativeFundingCreated = nativeFundingCreatedImport;
1173
1174 /// A funding_created message to be sent or received from a peer
1175 #[must_use]
1176 #[repr(C)]
1177 pub struct FundingCreated {
1178         /// A pointer to the opaque Rust object.
1179
1180         /// Nearly everywhere, inner must be non-null, however in places where
1181         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1182         pub inner: *mut nativeFundingCreated,
1183         /// Indicates that this is the only struct which contains the same pointer.
1184
1185         /// Rust functions which take ownership of an object provided via an argument require
1186         /// this to be true and invalidate the object pointed to by inner.
1187         pub is_owned: bool,
1188 }
1189
1190 impl Drop for FundingCreated {
1191         fn drop(&mut self) {
1192                 if self.is_owned && !<*mut nativeFundingCreated>::is_null(self.inner) {
1193                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
1194                 }
1195         }
1196 }
1197 /// Frees any resources used by the FundingCreated, if is_owned is set and inner is non-NULL.
1198 #[no_mangle]
1199 pub extern "C" fn FundingCreated_free(this_obj: FundingCreated) { }
1200 #[allow(unused)]
1201 /// Used only if an object of this type is returned as a trait impl by a method
1202 pub(crate) extern "C" fn FundingCreated_free_void(this_ptr: *mut c_void) {
1203         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeFundingCreated); }
1204 }
1205 #[allow(unused)]
1206 impl FundingCreated {
1207         pub(crate) fn get_native_ref(&self) -> &'static nativeFundingCreated {
1208                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
1209         }
1210         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeFundingCreated {
1211                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
1212         }
1213         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1214         pub(crate) fn take_inner(mut self) -> *mut nativeFundingCreated {
1215                 assert!(self.is_owned);
1216                 let ret = ObjOps::untweak_ptr(self.inner);
1217                 self.inner = core::ptr::null_mut();
1218                 ret
1219         }
1220 }
1221 /// A temporary channel ID, until the funding is established
1222 #[no_mangle]
1223 pub extern "C" fn FundingCreated_get_temporary_channel_id(this_ptr: &FundingCreated) -> *const [u8; 32] {
1224         let mut inner_val = &mut this_ptr.get_native_mut_ref().temporary_channel_id;
1225         inner_val
1226 }
1227 /// A temporary channel ID, until the funding is established
1228 #[no_mangle]
1229 pub extern "C" fn FundingCreated_set_temporary_channel_id(this_ptr: &mut FundingCreated, mut val: crate::c_types::ThirtyTwoBytes) {
1230         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.temporary_channel_id = val.data;
1231 }
1232 /// The funding transaction ID
1233 #[no_mangle]
1234 pub extern "C" fn FundingCreated_get_funding_txid(this_ptr: &FundingCreated) -> *const [u8; 32] {
1235         let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_txid;
1236         inner_val.as_inner()
1237 }
1238 /// The funding transaction ID
1239 #[no_mangle]
1240 pub extern "C" fn FundingCreated_set_funding_txid(this_ptr: &mut FundingCreated, mut val: crate::c_types::ThirtyTwoBytes) {
1241         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_txid = ::bitcoin::hash_types::Txid::from_slice(&val.data[..]).unwrap();
1242 }
1243 /// The specific output index funding this channel
1244 #[no_mangle]
1245 pub extern "C" fn FundingCreated_get_funding_output_index(this_ptr: &FundingCreated) -> u16 {
1246         let mut inner_val = &mut this_ptr.get_native_mut_ref().funding_output_index;
1247         *inner_val
1248 }
1249 /// The specific output index funding this channel
1250 #[no_mangle]
1251 pub extern "C" fn FundingCreated_set_funding_output_index(this_ptr: &mut FundingCreated, mut val: u16) {
1252         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.funding_output_index = val;
1253 }
1254 /// The signature of the channel initiator (funder) on the initial commitment transaction
1255 #[no_mangle]
1256 pub extern "C" fn FundingCreated_get_signature(this_ptr: &FundingCreated) -> crate::c_types::Signature {
1257         let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
1258         crate::c_types::Signature::from_rust(&inner_val)
1259 }
1260 /// The signature of the channel initiator (funder) on the initial commitment transaction
1261 #[no_mangle]
1262 pub extern "C" fn FundingCreated_set_signature(this_ptr: &mut FundingCreated, mut val: crate::c_types::Signature) {
1263         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
1264 }
1265 /// Constructs a new FundingCreated given each field
1266 #[must_use]
1267 #[no_mangle]
1268 pub extern "C" fn FundingCreated_new(mut temporary_channel_id_arg: crate::c_types::ThirtyTwoBytes, mut funding_txid_arg: crate::c_types::ThirtyTwoBytes, mut funding_output_index_arg: u16, mut signature_arg: crate::c_types::Signature) -> FundingCreated {
1269         FundingCreated { inner: ObjOps::heap_alloc(nativeFundingCreated {
1270                 temporary_channel_id: temporary_channel_id_arg.data,
1271                 funding_txid: ::bitcoin::hash_types::Txid::from_slice(&funding_txid_arg.data[..]).unwrap(),
1272                 funding_output_index: funding_output_index_arg,
1273                 signature: signature_arg.into_rust(),
1274         }), is_owned: true }
1275 }
1276 impl Clone for FundingCreated {
1277         fn clone(&self) -> Self {
1278                 Self {
1279                         inner: if <*mut nativeFundingCreated>::is_null(self.inner) { core::ptr::null_mut() } else {
1280                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
1281                         is_owned: true,
1282                 }
1283         }
1284 }
1285 #[allow(unused)]
1286 /// Used only if an object of this type is returned as a trait impl by a method
1287 pub(crate) extern "C" fn FundingCreated_clone_void(this_ptr: *const c_void) -> *mut c_void {
1288         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingCreated)).clone() })) as *mut c_void
1289 }
1290 #[no_mangle]
1291 /// Creates a copy of the FundingCreated
1292 pub extern "C" fn FundingCreated_clone(orig: &FundingCreated) -> FundingCreated {
1293         orig.clone()
1294 }
1295
1296 use lightning::ln::msgs::FundingSigned as nativeFundingSignedImport;
1297 pub(crate) type nativeFundingSigned = nativeFundingSignedImport;
1298
1299 /// A funding_signed message to be sent or received from a peer
1300 #[must_use]
1301 #[repr(C)]
1302 pub struct FundingSigned {
1303         /// A pointer to the opaque Rust object.
1304
1305         /// Nearly everywhere, inner must be non-null, however in places where
1306         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1307         pub inner: *mut nativeFundingSigned,
1308         /// Indicates that this is the only struct which contains the same pointer.
1309
1310         /// Rust functions which take ownership of an object provided via an argument require
1311         /// this to be true and invalidate the object pointed to by inner.
1312         pub is_owned: bool,
1313 }
1314
1315 impl Drop for FundingSigned {
1316         fn drop(&mut self) {
1317                 if self.is_owned && !<*mut nativeFundingSigned>::is_null(self.inner) {
1318                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
1319                 }
1320         }
1321 }
1322 /// Frees any resources used by the FundingSigned, if is_owned is set and inner is non-NULL.
1323 #[no_mangle]
1324 pub extern "C" fn FundingSigned_free(this_obj: FundingSigned) { }
1325 #[allow(unused)]
1326 /// Used only if an object of this type is returned as a trait impl by a method
1327 pub(crate) extern "C" fn FundingSigned_free_void(this_ptr: *mut c_void) {
1328         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeFundingSigned); }
1329 }
1330 #[allow(unused)]
1331 impl FundingSigned {
1332         pub(crate) fn get_native_ref(&self) -> &'static nativeFundingSigned {
1333                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
1334         }
1335         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeFundingSigned {
1336                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
1337         }
1338         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1339         pub(crate) fn take_inner(mut self) -> *mut nativeFundingSigned {
1340                 assert!(self.is_owned);
1341                 let ret = ObjOps::untweak_ptr(self.inner);
1342                 self.inner = core::ptr::null_mut();
1343                 ret
1344         }
1345 }
1346 /// The channel ID
1347 #[no_mangle]
1348 pub extern "C" fn FundingSigned_get_channel_id(this_ptr: &FundingSigned) -> *const [u8; 32] {
1349         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
1350         inner_val
1351 }
1352 /// The channel ID
1353 #[no_mangle]
1354 pub extern "C" fn FundingSigned_set_channel_id(this_ptr: &mut FundingSigned, mut val: crate::c_types::ThirtyTwoBytes) {
1355         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
1356 }
1357 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
1358 #[no_mangle]
1359 pub extern "C" fn FundingSigned_get_signature(this_ptr: &FundingSigned) -> crate::c_types::Signature {
1360         let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
1361         crate::c_types::Signature::from_rust(&inner_val)
1362 }
1363 /// The signature of the channel acceptor (fundee) on the initial commitment transaction
1364 #[no_mangle]
1365 pub extern "C" fn FundingSigned_set_signature(this_ptr: &mut FundingSigned, mut val: crate::c_types::Signature) {
1366         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
1367 }
1368 /// Constructs a new FundingSigned given each field
1369 #[must_use]
1370 #[no_mangle]
1371 pub extern "C" fn FundingSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut signature_arg: crate::c_types::Signature) -> FundingSigned {
1372         FundingSigned { inner: ObjOps::heap_alloc(nativeFundingSigned {
1373                 channel_id: channel_id_arg.data,
1374                 signature: signature_arg.into_rust(),
1375         }), is_owned: true }
1376 }
1377 impl Clone for FundingSigned {
1378         fn clone(&self) -> Self {
1379                 Self {
1380                         inner: if <*mut nativeFundingSigned>::is_null(self.inner) { core::ptr::null_mut() } else {
1381                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
1382                         is_owned: true,
1383                 }
1384         }
1385 }
1386 #[allow(unused)]
1387 /// Used only if an object of this type is returned as a trait impl by a method
1388 pub(crate) extern "C" fn FundingSigned_clone_void(this_ptr: *const c_void) -> *mut c_void {
1389         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingSigned)).clone() })) as *mut c_void
1390 }
1391 #[no_mangle]
1392 /// Creates a copy of the FundingSigned
1393 pub extern "C" fn FundingSigned_clone(orig: &FundingSigned) -> FundingSigned {
1394         orig.clone()
1395 }
1396
1397 use lightning::ln::msgs::FundingLocked as nativeFundingLockedImport;
1398 pub(crate) type nativeFundingLocked = nativeFundingLockedImport;
1399
1400 /// A funding_locked message to be sent or received from a peer
1401 #[must_use]
1402 #[repr(C)]
1403 pub struct FundingLocked {
1404         /// A pointer to the opaque Rust object.
1405
1406         /// Nearly everywhere, inner must be non-null, however in places where
1407         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1408         pub inner: *mut nativeFundingLocked,
1409         /// Indicates that this is the only struct which contains the same pointer.
1410
1411         /// Rust functions which take ownership of an object provided via an argument require
1412         /// this to be true and invalidate the object pointed to by inner.
1413         pub is_owned: bool,
1414 }
1415
1416 impl Drop for FundingLocked {
1417         fn drop(&mut self) {
1418                 if self.is_owned && !<*mut nativeFundingLocked>::is_null(self.inner) {
1419                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
1420                 }
1421         }
1422 }
1423 /// Frees any resources used by the FundingLocked, if is_owned is set and inner is non-NULL.
1424 #[no_mangle]
1425 pub extern "C" fn FundingLocked_free(this_obj: FundingLocked) { }
1426 #[allow(unused)]
1427 /// Used only if an object of this type is returned as a trait impl by a method
1428 pub(crate) extern "C" fn FundingLocked_free_void(this_ptr: *mut c_void) {
1429         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeFundingLocked); }
1430 }
1431 #[allow(unused)]
1432 impl FundingLocked {
1433         pub(crate) fn get_native_ref(&self) -> &'static nativeFundingLocked {
1434                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
1435         }
1436         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeFundingLocked {
1437                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
1438         }
1439         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1440         pub(crate) fn take_inner(mut self) -> *mut nativeFundingLocked {
1441                 assert!(self.is_owned);
1442                 let ret = ObjOps::untweak_ptr(self.inner);
1443                 self.inner = core::ptr::null_mut();
1444                 ret
1445         }
1446 }
1447 /// The channel ID
1448 #[no_mangle]
1449 pub extern "C" fn FundingLocked_get_channel_id(this_ptr: &FundingLocked) -> *const [u8; 32] {
1450         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
1451         inner_val
1452 }
1453 /// The channel ID
1454 #[no_mangle]
1455 pub extern "C" fn FundingLocked_set_channel_id(this_ptr: &mut FundingLocked, mut val: crate::c_types::ThirtyTwoBytes) {
1456         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
1457 }
1458 /// The per-commitment point of the second commitment transaction
1459 #[no_mangle]
1460 pub extern "C" fn FundingLocked_get_next_per_commitment_point(this_ptr: &FundingLocked) -> crate::c_types::PublicKey {
1461         let mut inner_val = &mut this_ptr.get_native_mut_ref().next_per_commitment_point;
1462         crate::c_types::PublicKey::from_rust(&inner_val)
1463 }
1464 /// The per-commitment point of the second commitment transaction
1465 #[no_mangle]
1466 pub extern "C" fn FundingLocked_set_next_per_commitment_point(this_ptr: &mut FundingLocked, mut val: crate::c_types::PublicKey) {
1467         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_per_commitment_point = val.into_rust();
1468 }
1469 /// If set, provides a short_channel_id alias for this channel. The sender will accept payments
1470 /// to be forwarded over this SCID and forward them to this messages' recipient.
1471 #[no_mangle]
1472 pub extern "C" fn FundingLocked_get_short_channel_id_alias(this_ptr: &FundingLocked) -> crate::c_types::derived::COption_u64Z {
1473         let mut inner_val = &mut this_ptr.get_native_mut_ref().short_channel_id_alias;
1474         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() }) };
1475         local_inner_val
1476 }
1477 /// If set, provides a short_channel_id alias for this channel. The sender will accept payments
1478 /// to be forwarded over this SCID and forward them to this messages' recipient.
1479 #[no_mangle]
1480 pub extern "C" fn FundingLocked_set_short_channel_id_alias(this_ptr: &mut FundingLocked, mut val: crate::c_types::derived::COption_u64Z) {
1481         let mut local_val = if val.is_some() { Some( { val.take() }) } else { None };
1482         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_id_alias = local_val;
1483 }
1484 /// Constructs a new FundingLocked given each field
1485 #[must_use]
1486 #[no_mangle]
1487 pub extern "C" fn FundingLocked_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut next_per_commitment_point_arg: crate::c_types::PublicKey, mut short_channel_id_alias_arg: crate::c_types::derived::COption_u64Z) -> FundingLocked {
1488         let mut local_short_channel_id_alias_arg = if short_channel_id_alias_arg.is_some() { Some( { short_channel_id_alias_arg.take() }) } else { None };
1489         FundingLocked { inner: ObjOps::heap_alloc(nativeFundingLocked {
1490                 channel_id: channel_id_arg.data,
1491                 next_per_commitment_point: next_per_commitment_point_arg.into_rust(),
1492                 short_channel_id_alias: local_short_channel_id_alias_arg,
1493         }), is_owned: true }
1494 }
1495 impl Clone for FundingLocked {
1496         fn clone(&self) -> Self {
1497                 Self {
1498                         inner: if <*mut nativeFundingLocked>::is_null(self.inner) { core::ptr::null_mut() } else {
1499                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
1500                         is_owned: true,
1501                 }
1502         }
1503 }
1504 #[allow(unused)]
1505 /// Used only if an object of this type is returned as a trait impl by a method
1506 pub(crate) extern "C" fn FundingLocked_clone_void(this_ptr: *const c_void) -> *mut c_void {
1507         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingLocked)).clone() })) as *mut c_void
1508 }
1509 #[no_mangle]
1510 /// Creates a copy of the FundingLocked
1511 pub extern "C" fn FundingLocked_clone(orig: &FundingLocked) -> FundingLocked {
1512         orig.clone()
1513 }
1514
1515 use lightning::ln::msgs::Shutdown as nativeShutdownImport;
1516 pub(crate) type nativeShutdown = nativeShutdownImport;
1517
1518 /// A shutdown message to be sent or received from a peer
1519 #[must_use]
1520 #[repr(C)]
1521 pub struct Shutdown {
1522         /// A pointer to the opaque Rust object.
1523
1524         /// Nearly everywhere, inner must be non-null, however in places where
1525         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1526         pub inner: *mut nativeShutdown,
1527         /// Indicates that this is the only struct which contains the same pointer.
1528
1529         /// Rust functions which take ownership of an object provided via an argument require
1530         /// this to be true and invalidate the object pointed to by inner.
1531         pub is_owned: bool,
1532 }
1533
1534 impl Drop for Shutdown {
1535         fn drop(&mut self) {
1536                 if self.is_owned && !<*mut nativeShutdown>::is_null(self.inner) {
1537                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
1538                 }
1539         }
1540 }
1541 /// Frees any resources used by the Shutdown, if is_owned is set and inner is non-NULL.
1542 #[no_mangle]
1543 pub extern "C" fn Shutdown_free(this_obj: Shutdown) { }
1544 #[allow(unused)]
1545 /// Used only if an object of this type is returned as a trait impl by a method
1546 pub(crate) extern "C" fn Shutdown_free_void(this_ptr: *mut c_void) {
1547         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeShutdown); }
1548 }
1549 #[allow(unused)]
1550 impl Shutdown {
1551         pub(crate) fn get_native_ref(&self) -> &'static nativeShutdown {
1552                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
1553         }
1554         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeShutdown {
1555                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
1556         }
1557         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1558         pub(crate) fn take_inner(mut self) -> *mut nativeShutdown {
1559                 assert!(self.is_owned);
1560                 let ret = ObjOps::untweak_ptr(self.inner);
1561                 self.inner = core::ptr::null_mut();
1562                 ret
1563         }
1564 }
1565 /// The channel ID
1566 #[no_mangle]
1567 pub extern "C" fn Shutdown_get_channel_id(this_ptr: &Shutdown) -> *const [u8; 32] {
1568         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
1569         inner_val
1570 }
1571 /// The channel ID
1572 #[no_mangle]
1573 pub extern "C" fn Shutdown_set_channel_id(this_ptr: &mut Shutdown, mut val: crate::c_types::ThirtyTwoBytes) {
1574         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
1575 }
1576 /// The destination of this peer's funds on closing.
1577 /// Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh.
1578 #[no_mangle]
1579 pub extern "C" fn Shutdown_get_scriptpubkey(this_ptr: &Shutdown) -> crate::c_types::u8slice {
1580         let mut inner_val = &mut this_ptr.get_native_mut_ref().scriptpubkey;
1581         crate::c_types::u8slice::from_slice(&inner_val[..])
1582 }
1583 /// The destination of this peer's funds on closing.
1584 /// Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh.
1585 #[no_mangle]
1586 pub extern "C" fn Shutdown_set_scriptpubkey(this_ptr: &mut Shutdown, mut val: crate::c_types::derived::CVec_u8Z) {
1587         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.scriptpubkey = ::bitcoin::blockdata::script::Script::from(val.into_rust());
1588 }
1589 /// Constructs a new Shutdown given each field
1590 #[must_use]
1591 #[no_mangle]
1592 pub extern "C" fn Shutdown_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut scriptpubkey_arg: crate::c_types::derived::CVec_u8Z) -> Shutdown {
1593         Shutdown { inner: ObjOps::heap_alloc(nativeShutdown {
1594                 channel_id: channel_id_arg.data,
1595                 scriptpubkey: ::bitcoin::blockdata::script::Script::from(scriptpubkey_arg.into_rust()),
1596         }), is_owned: true }
1597 }
1598 impl Clone for Shutdown {
1599         fn clone(&self) -> Self {
1600                 Self {
1601                         inner: if <*mut nativeShutdown>::is_null(self.inner) { core::ptr::null_mut() } else {
1602                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
1603                         is_owned: true,
1604                 }
1605         }
1606 }
1607 #[allow(unused)]
1608 /// Used only if an object of this type is returned as a trait impl by a method
1609 pub(crate) extern "C" fn Shutdown_clone_void(this_ptr: *const c_void) -> *mut c_void {
1610         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeShutdown)).clone() })) as *mut c_void
1611 }
1612 #[no_mangle]
1613 /// Creates a copy of the Shutdown
1614 pub extern "C" fn Shutdown_clone(orig: &Shutdown) -> Shutdown {
1615         orig.clone()
1616 }
1617
1618 use lightning::ln::msgs::ClosingSignedFeeRange as nativeClosingSignedFeeRangeImport;
1619 pub(crate) type nativeClosingSignedFeeRange = nativeClosingSignedFeeRangeImport;
1620
1621 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
1622 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
1623 /// to use.
1624 #[must_use]
1625 #[repr(C)]
1626 pub struct ClosingSignedFeeRange {
1627         /// A pointer to the opaque Rust object.
1628
1629         /// Nearly everywhere, inner must be non-null, however in places where
1630         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1631         pub inner: *mut nativeClosingSignedFeeRange,
1632         /// Indicates that this is the only struct which contains the same pointer.
1633
1634         /// Rust functions which take ownership of an object provided via an argument require
1635         /// this to be true and invalidate the object pointed to by inner.
1636         pub is_owned: bool,
1637 }
1638
1639 impl Drop for ClosingSignedFeeRange {
1640         fn drop(&mut self) {
1641                 if self.is_owned && !<*mut nativeClosingSignedFeeRange>::is_null(self.inner) {
1642                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
1643                 }
1644         }
1645 }
1646 /// Frees any resources used by the ClosingSignedFeeRange, if is_owned is set and inner is non-NULL.
1647 #[no_mangle]
1648 pub extern "C" fn ClosingSignedFeeRange_free(this_obj: ClosingSignedFeeRange) { }
1649 #[allow(unused)]
1650 /// Used only if an object of this type is returned as a trait impl by a method
1651 pub(crate) extern "C" fn ClosingSignedFeeRange_free_void(this_ptr: *mut c_void) {
1652         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeClosingSignedFeeRange); }
1653 }
1654 #[allow(unused)]
1655 impl ClosingSignedFeeRange {
1656         pub(crate) fn get_native_ref(&self) -> &'static nativeClosingSignedFeeRange {
1657                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
1658         }
1659         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeClosingSignedFeeRange {
1660                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
1661         }
1662         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1663         pub(crate) fn take_inner(mut self) -> *mut nativeClosingSignedFeeRange {
1664                 assert!(self.is_owned);
1665                 let ret = ObjOps::untweak_ptr(self.inner);
1666                 self.inner = core::ptr::null_mut();
1667                 ret
1668         }
1669 }
1670 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
1671 /// transaction.
1672 #[no_mangle]
1673 pub extern "C" fn ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: &ClosingSignedFeeRange) -> u64 {
1674         let mut inner_val = &mut this_ptr.get_native_mut_ref().min_fee_satoshis;
1675         *inner_val
1676 }
1677 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
1678 /// transaction.
1679 #[no_mangle]
1680 pub extern "C" fn ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: &mut ClosingSignedFeeRange, mut val: u64) {
1681         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.min_fee_satoshis = val;
1682 }
1683 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
1684 /// transaction.
1685 #[no_mangle]
1686 pub extern "C" fn ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: &ClosingSignedFeeRange) -> u64 {
1687         let mut inner_val = &mut this_ptr.get_native_mut_ref().max_fee_satoshis;
1688         *inner_val
1689 }
1690 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
1691 /// transaction.
1692 #[no_mangle]
1693 pub extern "C" fn ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: &mut ClosingSignedFeeRange, mut val: u64) {
1694         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.max_fee_satoshis = val;
1695 }
1696 /// Constructs a new ClosingSignedFeeRange given each field
1697 #[must_use]
1698 #[no_mangle]
1699 pub extern "C" fn ClosingSignedFeeRange_new(mut min_fee_satoshis_arg: u64, mut max_fee_satoshis_arg: u64) -> ClosingSignedFeeRange {
1700         ClosingSignedFeeRange { inner: ObjOps::heap_alloc(nativeClosingSignedFeeRange {
1701                 min_fee_satoshis: min_fee_satoshis_arg,
1702                 max_fee_satoshis: max_fee_satoshis_arg,
1703         }), is_owned: true }
1704 }
1705 impl Clone for ClosingSignedFeeRange {
1706         fn clone(&self) -> Self {
1707                 Self {
1708                         inner: if <*mut nativeClosingSignedFeeRange>::is_null(self.inner) { core::ptr::null_mut() } else {
1709                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
1710                         is_owned: true,
1711                 }
1712         }
1713 }
1714 #[allow(unused)]
1715 /// Used only if an object of this type is returned as a trait impl by a method
1716 pub(crate) extern "C" fn ClosingSignedFeeRange_clone_void(this_ptr: *const c_void) -> *mut c_void {
1717         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeClosingSignedFeeRange)).clone() })) as *mut c_void
1718 }
1719 #[no_mangle]
1720 /// Creates a copy of the ClosingSignedFeeRange
1721 pub extern "C" fn ClosingSignedFeeRange_clone(orig: &ClosingSignedFeeRange) -> ClosingSignedFeeRange {
1722         orig.clone()
1723 }
1724
1725 use lightning::ln::msgs::ClosingSigned as nativeClosingSignedImport;
1726 pub(crate) type nativeClosingSigned = nativeClosingSignedImport;
1727
1728 /// A closing_signed message to be sent or received from a peer
1729 #[must_use]
1730 #[repr(C)]
1731 pub struct ClosingSigned {
1732         /// A pointer to the opaque Rust object.
1733
1734         /// Nearly everywhere, inner must be non-null, however in places where
1735         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1736         pub inner: *mut nativeClosingSigned,
1737         /// Indicates that this is the only struct which contains the same pointer.
1738
1739         /// Rust functions which take ownership of an object provided via an argument require
1740         /// this to be true and invalidate the object pointed to by inner.
1741         pub is_owned: bool,
1742 }
1743
1744 impl Drop for ClosingSigned {
1745         fn drop(&mut self) {
1746                 if self.is_owned && !<*mut nativeClosingSigned>::is_null(self.inner) {
1747                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
1748                 }
1749         }
1750 }
1751 /// Frees any resources used by the ClosingSigned, if is_owned is set and inner is non-NULL.
1752 #[no_mangle]
1753 pub extern "C" fn ClosingSigned_free(this_obj: ClosingSigned) { }
1754 #[allow(unused)]
1755 /// Used only if an object of this type is returned as a trait impl by a method
1756 pub(crate) extern "C" fn ClosingSigned_free_void(this_ptr: *mut c_void) {
1757         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeClosingSigned); }
1758 }
1759 #[allow(unused)]
1760 impl ClosingSigned {
1761         pub(crate) fn get_native_ref(&self) -> &'static nativeClosingSigned {
1762                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
1763         }
1764         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeClosingSigned {
1765                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
1766         }
1767         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1768         pub(crate) fn take_inner(mut self) -> *mut nativeClosingSigned {
1769                 assert!(self.is_owned);
1770                 let ret = ObjOps::untweak_ptr(self.inner);
1771                 self.inner = core::ptr::null_mut();
1772                 ret
1773         }
1774 }
1775 /// The channel ID
1776 #[no_mangle]
1777 pub extern "C" fn ClosingSigned_get_channel_id(this_ptr: &ClosingSigned) -> *const [u8; 32] {
1778         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
1779         inner_val
1780 }
1781 /// The channel ID
1782 #[no_mangle]
1783 pub extern "C" fn ClosingSigned_set_channel_id(this_ptr: &mut ClosingSigned, mut val: crate::c_types::ThirtyTwoBytes) {
1784         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
1785 }
1786 /// The proposed total fee for the closing transaction
1787 #[no_mangle]
1788 pub extern "C" fn ClosingSigned_get_fee_satoshis(this_ptr: &ClosingSigned) -> u64 {
1789         let mut inner_val = &mut this_ptr.get_native_mut_ref().fee_satoshis;
1790         *inner_val
1791 }
1792 /// The proposed total fee for the closing transaction
1793 #[no_mangle]
1794 pub extern "C" fn ClosingSigned_set_fee_satoshis(this_ptr: &mut ClosingSigned, mut val: u64) {
1795         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fee_satoshis = val;
1796 }
1797 /// A signature on the closing transaction
1798 #[no_mangle]
1799 pub extern "C" fn ClosingSigned_get_signature(this_ptr: &ClosingSigned) -> crate::c_types::Signature {
1800         let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
1801         crate::c_types::Signature::from_rust(&inner_val)
1802 }
1803 /// A signature on the closing transaction
1804 #[no_mangle]
1805 pub extern "C" fn ClosingSigned_set_signature(this_ptr: &mut ClosingSigned, mut val: crate::c_types::Signature) {
1806         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
1807 }
1808 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
1809 /// nodes.
1810 ///
1811 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
1812 #[no_mangle]
1813 pub extern "C" fn ClosingSigned_get_fee_range(this_ptr: &ClosingSigned) -> crate::lightning::ln::msgs::ClosingSignedFeeRange {
1814         let mut inner_val = &mut this_ptr.get_native_mut_ref().fee_range;
1815         let mut local_inner_val = crate::lightning::ln::msgs::ClosingSignedFeeRange { 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::msgs::ClosingSignedFeeRange<>) as *mut _ }, is_owned: false };
1816         local_inner_val
1817 }
1818 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
1819 /// nodes.
1820 ///
1821 /// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
1822 #[no_mangle]
1823 pub extern "C" fn ClosingSigned_set_fee_range(this_ptr: &mut ClosingSigned, mut val: crate::lightning::ln::msgs::ClosingSignedFeeRange) {
1824         let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
1825         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fee_range = local_val;
1826 }
1827 /// Constructs a new ClosingSigned given each field
1828 #[must_use]
1829 #[no_mangle]
1830 pub extern "C" fn ClosingSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut fee_satoshis_arg: u64, mut signature_arg: crate::c_types::Signature, mut fee_range_arg: crate::lightning::ln::msgs::ClosingSignedFeeRange) -> ClosingSigned {
1831         let mut local_fee_range_arg = if fee_range_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(fee_range_arg.take_inner()) } }) };
1832         ClosingSigned { inner: ObjOps::heap_alloc(nativeClosingSigned {
1833                 channel_id: channel_id_arg.data,
1834                 fee_satoshis: fee_satoshis_arg,
1835                 signature: signature_arg.into_rust(),
1836                 fee_range: local_fee_range_arg,
1837         }), is_owned: true }
1838 }
1839 impl Clone for ClosingSigned {
1840         fn clone(&self) -> Self {
1841                 Self {
1842                         inner: if <*mut nativeClosingSigned>::is_null(self.inner) { core::ptr::null_mut() } else {
1843                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
1844                         is_owned: true,
1845                 }
1846         }
1847 }
1848 #[allow(unused)]
1849 /// Used only if an object of this type is returned as a trait impl by a method
1850 pub(crate) extern "C" fn ClosingSigned_clone_void(this_ptr: *const c_void) -> *mut c_void {
1851         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeClosingSigned)).clone() })) as *mut c_void
1852 }
1853 #[no_mangle]
1854 /// Creates a copy of the ClosingSigned
1855 pub extern "C" fn ClosingSigned_clone(orig: &ClosingSigned) -> ClosingSigned {
1856         orig.clone()
1857 }
1858
1859 use lightning::ln::msgs::UpdateAddHTLC as nativeUpdateAddHTLCImport;
1860 pub(crate) type nativeUpdateAddHTLC = nativeUpdateAddHTLCImport;
1861
1862 /// An update_add_htlc message to be sent or received from a peer
1863 #[must_use]
1864 #[repr(C)]
1865 pub struct UpdateAddHTLC {
1866         /// A pointer to the opaque Rust object.
1867
1868         /// Nearly everywhere, inner must be non-null, however in places where
1869         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1870         pub inner: *mut nativeUpdateAddHTLC,
1871         /// Indicates that this is the only struct which contains the same pointer.
1872
1873         /// Rust functions which take ownership of an object provided via an argument require
1874         /// this to be true and invalidate the object pointed to by inner.
1875         pub is_owned: bool,
1876 }
1877
1878 impl Drop for UpdateAddHTLC {
1879         fn drop(&mut self) {
1880                 if self.is_owned && !<*mut nativeUpdateAddHTLC>::is_null(self.inner) {
1881                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
1882                 }
1883         }
1884 }
1885 /// Frees any resources used by the UpdateAddHTLC, if is_owned is set and inner is non-NULL.
1886 #[no_mangle]
1887 pub extern "C" fn UpdateAddHTLC_free(this_obj: UpdateAddHTLC) { }
1888 #[allow(unused)]
1889 /// Used only if an object of this type is returned as a trait impl by a method
1890 pub(crate) extern "C" fn UpdateAddHTLC_free_void(this_ptr: *mut c_void) {
1891         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateAddHTLC); }
1892 }
1893 #[allow(unused)]
1894 impl UpdateAddHTLC {
1895         pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateAddHTLC {
1896                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
1897         }
1898         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateAddHTLC {
1899                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
1900         }
1901         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1902         pub(crate) fn take_inner(mut self) -> *mut nativeUpdateAddHTLC {
1903                 assert!(self.is_owned);
1904                 let ret = ObjOps::untweak_ptr(self.inner);
1905                 self.inner = core::ptr::null_mut();
1906                 ret
1907         }
1908 }
1909 /// The channel ID
1910 #[no_mangle]
1911 pub extern "C" fn UpdateAddHTLC_get_channel_id(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] {
1912         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
1913         inner_val
1914 }
1915 /// The channel ID
1916 #[no_mangle]
1917 pub extern "C" fn UpdateAddHTLC_set_channel_id(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
1918         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
1919 }
1920 /// The HTLC ID
1921 #[no_mangle]
1922 pub extern "C" fn UpdateAddHTLC_get_htlc_id(this_ptr: &UpdateAddHTLC) -> u64 {
1923         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
1924         *inner_val
1925 }
1926 /// The HTLC ID
1927 #[no_mangle]
1928 pub extern "C" fn UpdateAddHTLC_set_htlc_id(this_ptr: &mut UpdateAddHTLC, mut val: u64) {
1929         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
1930 }
1931 /// The HTLC value in milli-satoshi
1932 #[no_mangle]
1933 pub extern "C" fn UpdateAddHTLC_get_amount_msat(this_ptr: &UpdateAddHTLC) -> u64 {
1934         let mut inner_val = &mut this_ptr.get_native_mut_ref().amount_msat;
1935         *inner_val
1936 }
1937 /// The HTLC value in milli-satoshi
1938 #[no_mangle]
1939 pub extern "C" fn UpdateAddHTLC_set_amount_msat(this_ptr: &mut UpdateAddHTLC, mut val: u64) {
1940         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.amount_msat = val;
1941 }
1942 /// The payment hash, the pre-image of which controls HTLC redemption
1943 #[no_mangle]
1944 pub extern "C" fn UpdateAddHTLC_get_payment_hash(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] {
1945         let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_hash;
1946         &inner_val.0
1947 }
1948 /// The payment hash, the pre-image of which controls HTLC redemption
1949 #[no_mangle]
1950 pub extern "C" fn UpdateAddHTLC_set_payment_hash(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
1951         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_hash = ::lightning::ln::PaymentHash(val.data);
1952 }
1953 /// The expiry height of the HTLC
1954 #[no_mangle]
1955 pub extern "C" fn UpdateAddHTLC_get_cltv_expiry(this_ptr: &UpdateAddHTLC) -> u32 {
1956         let mut inner_val = &mut this_ptr.get_native_mut_ref().cltv_expiry;
1957         *inner_val
1958 }
1959 /// The expiry height of the HTLC
1960 #[no_mangle]
1961 pub extern "C" fn UpdateAddHTLC_set_cltv_expiry(this_ptr: &mut UpdateAddHTLC, mut val: u32) {
1962         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry = val;
1963 }
1964 impl Clone for UpdateAddHTLC {
1965         fn clone(&self) -> Self {
1966                 Self {
1967                         inner: if <*mut nativeUpdateAddHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
1968                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
1969                         is_owned: true,
1970                 }
1971         }
1972 }
1973 #[allow(unused)]
1974 /// Used only if an object of this type is returned as a trait impl by a method
1975 pub(crate) extern "C" fn UpdateAddHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
1976         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateAddHTLC)).clone() })) as *mut c_void
1977 }
1978 #[no_mangle]
1979 /// Creates a copy of the UpdateAddHTLC
1980 pub extern "C" fn UpdateAddHTLC_clone(orig: &UpdateAddHTLC) -> UpdateAddHTLC {
1981         orig.clone()
1982 }
1983
1984 use lightning::ln::msgs::UpdateFulfillHTLC as nativeUpdateFulfillHTLCImport;
1985 pub(crate) type nativeUpdateFulfillHTLC = nativeUpdateFulfillHTLCImport;
1986
1987 /// An update_fulfill_htlc message to be sent or received from a peer
1988 #[must_use]
1989 #[repr(C)]
1990 pub struct UpdateFulfillHTLC {
1991         /// A pointer to the opaque Rust object.
1992
1993         /// Nearly everywhere, inner must be non-null, however in places where
1994         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1995         pub inner: *mut nativeUpdateFulfillHTLC,
1996         /// Indicates that this is the only struct which contains the same pointer.
1997
1998         /// Rust functions which take ownership of an object provided via an argument require
1999         /// this to be true and invalidate the object pointed to by inner.
2000         pub is_owned: bool,
2001 }
2002
2003 impl Drop for UpdateFulfillHTLC {
2004         fn drop(&mut self) {
2005                 if self.is_owned && !<*mut nativeUpdateFulfillHTLC>::is_null(self.inner) {
2006                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
2007                 }
2008         }
2009 }
2010 /// Frees any resources used by the UpdateFulfillHTLC, if is_owned is set and inner is non-NULL.
2011 #[no_mangle]
2012 pub extern "C" fn UpdateFulfillHTLC_free(this_obj: UpdateFulfillHTLC) { }
2013 #[allow(unused)]
2014 /// Used only if an object of this type is returned as a trait impl by a method
2015 pub(crate) extern "C" fn UpdateFulfillHTLC_free_void(this_ptr: *mut c_void) {
2016         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFulfillHTLC); }
2017 }
2018 #[allow(unused)]
2019 impl UpdateFulfillHTLC {
2020         pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFulfillHTLC {
2021                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
2022         }
2023         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFulfillHTLC {
2024                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
2025         }
2026         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2027         pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFulfillHTLC {
2028                 assert!(self.is_owned);
2029                 let ret = ObjOps::untweak_ptr(self.inner);
2030                 self.inner = core::ptr::null_mut();
2031                 ret
2032         }
2033 }
2034 /// The channel ID
2035 #[no_mangle]
2036 pub extern "C" fn UpdateFulfillHTLC_get_channel_id(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] {
2037         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
2038         inner_val
2039 }
2040 /// The channel ID
2041 #[no_mangle]
2042 pub extern "C" fn UpdateFulfillHTLC_set_channel_id(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
2043         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
2044 }
2045 /// The HTLC ID
2046 #[no_mangle]
2047 pub extern "C" fn UpdateFulfillHTLC_get_htlc_id(this_ptr: &UpdateFulfillHTLC) -> u64 {
2048         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
2049         *inner_val
2050 }
2051 /// The HTLC ID
2052 #[no_mangle]
2053 pub extern "C" fn UpdateFulfillHTLC_set_htlc_id(this_ptr: &mut UpdateFulfillHTLC, mut val: u64) {
2054         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
2055 }
2056 /// The pre-image of the payment hash, allowing HTLC redemption
2057 #[no_mangle]
2058 pub extern "C" fn UpdateFulfillHTLC_get_payment_preimage(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] {
2059         let mut inner_val = &mut this_ptr.get_native_mut_ref().payment_preimage;
2060         &inner_val.0
2061 }
2062 /// The pre-image of the payment hash, allowing HTLC redemption
2063 #[no_mangle]
2064 pub extern "C" fn UpdateFulfillHTLC_set_payment_preimage(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
2065         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.payment_preimage = ::lightning::ln::PaymentPreimage(val.data);
2066 }
2067 /// Constructs a new UpdateFulfillHTLC given each field
2068 #[must_use]
2069 #[no_mangle]
2070 pub extern "C" fn UpdateFulfillHTLC_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut htlc_id_arg: u64, mut payment_preimage_arg: crate::c_types::ThirtyTwoBytes) -> UpdateFulfillHTLC {
2071         UpdateFulfillHTLC { inner: ObjOps::heap_alloc(nativeUpdateFulfillHTLC {
2072                 channel_id: channel_id_arg.data,
2073                 htlc_id: htlc_id_arg,
2074                 payment_preimage: ::lightning::ln::PaymentPreimage(payment_preimage_arg.data),
2075         }), is_owned: true }
2076 }
2077 impl Clone for UpdateFulfillHTLC {
2078         fn clone(&self) -> Self {
2079                 Self {
2080                         inner: if <*mut nativeUpdateFulfillHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
2081                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
2082                         is_owned: true,
2083                 }
2084         }
2085 }
2086 #[allow(unused)]
2087 /// Used only if an object of this type is returned as a trait impl by a method
2088 pub(crate) extern "C" fn UpdateFulfillHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
2089         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFulfillHTLC)).clone() })) as *mut c_void
2090 }
2091 #[no_mangle]
2092 /// Creates a copy of the UpdateFulfillHTLC
2093 pub extern "C" fn UpdateFulfillHTLC_clone(orig: &UpdateFulfillHTLC) -> UpdateFulfillHTLC {
2094         orig.clone()
2095 }
2096
2097 use lightning::ln::msgs::UpdateFailHTLC as nativeUpdateFailHTLCImport;
2098 pub(crate) type nativeUpdateFailHTLC = nativeUpdateFailHTLCImport;
2099
2100 /// An update_fail_htlc message to be sent or received from a peer
2101 #[must_use]
2102 #[repr(C)]
2103 pub struct UpdateFailHTLC {
2104         /// A pointer to the opaque Rust object.
2105
2106         /// Nearly everywhere, inner must be non-null, however in places where
2107         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2108         pub inner: *mut nativeUpdateFailHTLC,
2109         /// Indicates that this is the only struct which contains the same pointer.
2110
2111         /// Rust functions which take ownership of an object provided via an argument require
2112         /// this to be true and invalidate the object pointed to by inner.
2113         pub is_owned: bool,
2114 }
2115
2116 impl Drop for UpdateFailHTLC {
2117         fn drop(&mut self) {
2118                 if self.is_owned && !<*mut nativeUpdateFailHTLC>::is_null(self.inner) {
2119                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
2120                 }
2121         }
2122 }
2123 /// Frees any resources used by the UpdateFailHTLC, if is_owned is set and inner is non-NULL.
2124 #[no_mangle]
2125 pub extern "C" fn UpdateFailHTLC_free(this_obj: UpdateFailHTLC) { }
2126 #[allow(unused)]
2127 /// Used only if an object of this type is returned as a trait impl by a method
2128 pub(crate) extern "C" fn UpdateFailHTLC_free_void(this_ptr: *mut c_void) {
2129         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFailHTLC); }
2130 }
2131 #[allow(unused)]
2132 impl UpdateFailHTLC {
2133         pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFailHTLC {
2134                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
2135         }
2136         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFailHTLC {
2137                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
2138         }
2139         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2140         pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailHTLC {
2141                 assert!(self.is_owned);
2142                 let ret = ObjOps::untweak_ptr(self.inner);
2143                 self.inner = core::ptr::null_mut();
2144                 ret
2145         }
2146 }
2147 /// The channel ID
2148 #[no_mangle]
2149 pub extern "C" fn UpdateFailHTLC_get_channel_id(this_ptr: &UpdateFailHTLC) -> *const [u8; 32] {
2150         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
2151         inner_val
2152 }
2153 /// The channel ID
2154 #[no_mangle]
2155 pub extern "C" fn UpdateFailHTLC_set_channel_id(this_ptr: &mut UpdateFailHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
2156         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
2157 }
2158 /// The HTLC ID
2159 #[no_mangle]
2160 pub extern "C" fn UpdateFailHTLC_get_htlc_id(this_ptr: &UpdateFailHTLC) -> u64 {
2161         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
2162         *inner_val
2163 }
2164 /// The HTLC ID
2165 #[no_mangle]
2166 pub extern "C" fn UpdateFailHTLC_set_htlc_id(this_ptr: &mut UpdateFailHTLC, mut val: u64) {
2167         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
2168 }
2169 impl Clone for UpdateFailHTLC {
2170         fn clone(&self) -> Self {
2171                 Self {
2172                         inner: if <*mut nativeUpdateFailHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
2173                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
2174                         is_owned: true,
2175                 }
2176         }
2177 }
2178 #[allow(unused)]
2179 /// Used only if an object of this type is returned as a trait impl by a method
2180 pub(crate) extern "C" fn UpdateFailHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
2181         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFailHTLC)).clone() })) as *mut c_void
2182 }
2183 #[no_mangle]
2184 /// Creates a copy of the UpdateFailHTLC
2185 pub extern "C" fn UpdateFailHTLC_clone(orig: &UpdateFailHTLC) -> UpdateFailHTLC {
2186         orig.clone()
2187 }
2188
2189 use lightning::ln::msgs::UpdateFailMalformedHTLC as nativeUpdateFailMalformedHTLCImport;
2190 pub(crate) type nativeUpdateFailMalformedHTLC = nativeUpdateFailMalformedHTLCImport;
2191
2192 /// An update_fail_malformed_htlc message to be sent or received from a peer
2193 #[must_use]
2194 #[repr(C)]
2195 pub struct UpdateFailMalformedHTLC {
2196         /// A pointer to the opaque Rust object.
2197
2198         /// Nearly everywhere, inner must be non-null, however in places where
2199         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2200         pub inner: *mut nativeUpdateFailMalformedHTLC,
2201         /// Indicates that this is the only struct which contains the same pointer.
2202
2203         /// Rust functions which take ownership of an object provided via an argument require
2204         /// this to be true and invalidate the object pointed to by inner.
2205         pub is_owned: bool,
2206 }
2207
2208 impl Drop for UpdateFailMalformedHTLC {
2209         fn drop(&mut self) {
2210                 if self.is_owned && !<*mut nativeUpdateFailMalformedHTLC>::is_null(self.inner) {
2211                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
2212                 }
2213         }
2214 }
2215 /// Frees any resources used by the UpdateFailMalformedHTLC, if is_owned is set and inner is non-NULL.
2216 #[no_mangle]
2217 pub extern "C" fn UpdateFailMalformedHTLC_free(this_obj: UpdateFailMalformedHTLC) { }
2218 #[allow(unused)]
2219 /// Used only if an object of this type is returned as a trait impl by a method
2220 pub(crate) extern "C" fn UpdateFailMalformedHTLC_free_void(this_ptr: *mut c_void) {
2221         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFailMalformedHTLC); }
2222 }
2223 #[allow(unused)]
2224 impl UpdateFailMalformedHTLC {
2225         pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFailMalformedHTLC {
2226                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
2227         }
2228         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFailMalformedHTLC {
2229                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
2230         }
2231         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2232         pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailMalformedHTLC {
2233                 assert!(self.is_owned);
2234                 let ret = ObjOps::untweak_ptr(self.inner);
2235                 self.inner = core::ptr::null_mut();
2236                 ret
2237         }
2238 }
2239 /// The channel ID
2240 #[no_mangle]
2241 pub extern "C" fn UpdateFailMalformedHTLC_get_channel_id(this_ptr: &UpdateFailMalformedHTLC) -> *const [u8; 32] {
2242         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
2243         inner_val
2244 }
2245 /// The channel ID
2246 #[no_mangle]
2247 pub extern "C" fn UpdateFailMalformedHTLC_set_channel_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
2248         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
2249 }
2250 /// The HTLC ID
2251 #[no_mangle]
2252 pub extern "C" fn UpdateFailMalformedHTLC_get_htlc_id(this_ptr: &UpdateFailMalformedHTLC) -> u64 {
2253         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_id;
2254         *inner_val
2255 }
2256 /// The HTLC ID
2257 #[no_mangle]
2258 pub extern "C" fn UpdateFailMalformedHTLC_set_htlc_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u64) {
2259         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_id = val;
2260 }
2261 /// The failure code
2262 #[no_mangle]
2263 pub extern "C" fn UpdateFailMalformedHTLC_get_failure_code(this_ptr: &UpdateFailMalformedHTLC) -> u16 {
2264         let mut inner_val = &mut this_ptr.get_native_mut_ref().failure_code;
2265         *inner_val
2266 }
2267 /// The failure code
2268 #[no_mangle]
2269 pub extern "C" fn UpdateFailMalformedHTLC_set_failure_code(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u16) {
2270         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.failure_code = val;
2271 }
2272 impl Clone for UpdateFailMalformedHTLC {
2273         fn clone(&self) -> Self {
2274                 Self {
2275                         inner: if <*mut nativeUpdateFailMalformedHTLC>::is_null(self.inner) { core::ptr::null_mut() } else {
2276                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
2277                         is_owned: true,
2278                 }
2279         }
2280 }
2281 #[allow(unused)]
2282 /// Used only if an object of this type is returned as a trait impl by a method
2283 pub(crate) extern "C" fn UpdateFailMalformedHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
2284         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFailMalformedHTLC)).clone() })) as *mut c_void
2285 }
2286 #[no_mangle]
2287 /// Creates a copy of the UpdateFailMalformedHTLC
2288 pub extern "C" fn UpdateFailMalformedHTLC_clone(orig: &UpdateFailMalformedHTLC) -> UpdateFailMalformedHTLC {
2289         orig.clone()
2290 }
2291
2292 use lightning::ln::msgs::CommitmentSigned as nativeCommitmentSignedImport;
2293 pub(crate) type nativeCommitmentSigned = nativeCommitmentSignedImport;
2294
2295 /// A commitment_signed message to be sent or received from a peer
2296 #[must_use]
2297 #[repr(C)]
2298 pub struct CommitmentSigned {
2299         /// A pointer to the opaque Rust object.
2300
2301         /// Nearly everywhere, inner must be non-null, however in places where
2302         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2303         pub inner: *mut nativeCommitmentSigned,
2304         /// Indicates that this is the only struct which contains the same pointer.
2305
2306         /// Rust functions which take ownership of an object provided via an argument require
2307         /// this to be true and invalidate the object pointed to by inner.
2308         pub is_owned: bool,
2309 }
2310
2311 impl Drop for CommitmentSigned {
2312         fn drop(&mut self) {
2313                 if self.is_owned && !<*mut nativeCommitmentSigned>::is_null(self.inner) {
2314                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
2315                 }
2316         }
2317 }
2318 /// Frees any resources used by the CommitmentSigned, if is_owned is set and inner is non-NULL.
2319 #[no_mangle]
2320 pub extern "C" fn CommitmentSigned_free(this_obj: CommitmentSigned) { }
2321 #[allow(unused)]
2322 /// Used only if an object of this type is returned as a trait impl by a method
2323 pub(crate) extern "C" fn CommitmentSigned_free_void(this_ptr: *mut c_void) {
2324         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeCommitmentSigned); }
2325 }
2326 #[allow(unused)]
2327 impl CommitmentSigned {
2328         pub(crate) fn get_native_ref(&self) -> &'static nativeCommitmentSigned {
2329                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
2330         }
2331         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeCommitmentSigned {
2332                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
2333         }
2334         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2335         pub(crate) fn take_inner(mut self) -> *mut nativeCommitmentSigned {
2336                 assert!(self.is_owned);
2337                 let ret = ObjOps::untweak_ptr(self.inner);
2338                 self.inner = core::ptr::null_mut();
2339                 ret
2340         }
2341 }
2342 /// The channel ID
2343 #[no_mangle]
2344 pub extern "C" fn CommitmentSigned_get_channel_id(this_ptr: &CommitmentSigned) -> *const [u8; 32] {
2345         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
2346         inner_val
2347 }
2348 /// The channel ID
2349 #[no_mangle]
2350 pub extern "C" fn CommitmentSigned_set_channel_id(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::ThirtyTwoBytes) {
2351         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
2352 }
2353 /// A signature on the commitment transaction
2354 #[no_mangle]
2355 pub extern "C" fn CommitmentSigned_get_signature(this_ptr: &CommitmentSigned) -> crate::c_types::Signature {
2356         let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
2357         crate::c_types::Signature::from_rust(&inner_val)
2358 }
2359 /// A signature on the commitment transaction
2360 #[no_mangle]
2361 pub extern "C" fn CommitmentSigned_set_signature(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::Signature) {
2362         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
2363 }
2364 /// Signatures on the HTLC transactions
2365 #[no_mangle]
2366 pub extern "C" fn CommitmentSigned_set_htlc_signatures(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::derived::CVec_SignatureZ) {
2367         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_rust() }); };
2368         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_signatures = local_val;
2369 }
2370 /// Constructs a new CommitmentSigned given each field
2371 #[must_use]
2372 #[no_mangle]
2373 pub extern "C" fn CommitmentSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut signature_arg: crate::c_types::Signature, mut htlc_signatures_arg: crate::c_types::derived::CVec_SignatureZ) -> CommitmentSigned {
2374         let mut local_htlc_signatures_arg = Vec::new(); for mut item in htlc_signatures_arg.into_rust().drain(..) { local_htlc_signatures_arg.push( { item.into_rust() }); };
2375         CommitmentSigned { inner: ObjOps::heap_alloc(nativeCommitmentSigned {
2376                 channel_id: channel_id_arg.data,
2377                 signature: signature_arg.into_rust(),
2378                 htlc_signatures: local_htlc_signatures_arg,
2379         }), is_owned: true }
2380 }
2381 impl Clone for CommitmentSigned {
2382         fn clone(&self) -> Self {
2383                 Self {
2384                         inner: if <*mut nativeCommitmentSigned>::is_null(self.inner) { core::ptr::null_mut() } else {
2385                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
2386                         is_owned: true,
2387                 }
2388         }
2389 }
2390 #[allow(unused)]
2391 /// Used only if an object of this type is returned as a trait impl by a method
2392 pub(crate) extern "C" fn CommitmentSigned_clone_void(this_ptr: *const c_void) -> *mut c_void {
2393         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeCommitmentSigned)).clone() })) as *mut c_void
2394 }
2395 #[no_mangle]
2396 /// Creates a copy of the CommitmentSigned
2397 pub extern "C" fn CommitmentSigned_clone(orig: &CommitmentSigned) -> CommitmentSigned {
2398         orig.clone()
2399 }
2400
2401 use lightning::ln::msgs::RevokeAndACK as nativeRevokeAndACKImport;
2402 pub(crate) type nativeRevokeAndACK = nativeRevokeAndACKImport;
2403
2404 /// A revoke_and_ack message to be sent or received from a peer
2405 #[must_use]
2406 #[repr(C)]
2407 pub struct RevokeAndACK {
2408         /// A pointer to the opaque Rust object.
2409
2410         /// Nearly everywhere, inner must be non-null, however in places where
2411         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2412         pub inner: *mut nativeRevokeAndACK,
2413         /// Indicates that this is the only struct which contains the same pointer.
2414
2415         /// Rust functions which take ownership of an object provided via an argument require
2416         /// this to be true and invalidate the object pointed to by inner.
2417         pub is_owned: bool,
2418 }
2419
2420 impl Drop for RevokeAndACK {
2421         fn drop(&mut self) {
2422                 if self.is_owned && !<*mut nativeRevokeAndACK>::is_null(self.inner) {
2423                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
2424                 }
2425         }
2426 }
2427 /// Frees any resources used by the RevokeAndACK, if is_owned is set and inner is non-NULL.
2428 #[no_mangle]
2429 pub extern "C" fn RevokeAndACK_free(this_obj: RevokeAndACK) { }
2430 #[allow(unused)]
2431 /// Used only if an object of this type is returned as a trait impl by a method
2432 pub(crate) extern "C" fn RevokeAndACK_free_void(this_ptr: *mut c_void) {
2433         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRevokeAndACK); }
2434 }
2435 #[allow(unused)]
2436 impl RevokeAndACK {
2437         pub(crate) fn get_native_ref(&self) -> &'static nativeRevokeAndACK {
2438                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
2439         }
2440         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRevokeAndACK {
2441                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
2442         }
2443         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2444         pub(crate) fn take_inner(mut self) -> *mut nativeRevokeAndACK {
2445                 assert!(self.is_owned);
2446                 let ret = ObjOps::untweak_ptr(self.inner);
2447                 self.inner = core::ptr::null_mut();
2448                 ret
2449         }
2450 }
2451 /// The channel ID
2452 #[no_mangle]
2453 pub extern "C" fn RevokeAndACK_get_channel_id(this_ptr: &RevokeAndACK) -> *const [u8; 32] {
2454         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
2455         inner_val
2456 }
2457 /// The channel ID
2458 #[no_mangle]
2459 pub extern "C" fn RevokeAndACK_set_channel_id(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::ThirtyTwoBytes) {
2460         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
2461 }
2462 /// The secret corresponding to the per-commitment point
2463 #[no_mangle]
2464 pub extern "C" fn RevokeAndACK_get_per_commitment_secret(this_ptr: &RevokeAndACK) -> *const [u8; 32] {
2465         let mut inner_val = &mut this_ptr.get_native_mut_ref().per_commitment_secret;
2466         inner_val
2467 }
2468 /// The secret corresponding to the per-commitment point
2469 #[no_mangle]
2470 pub extern "C" fn RevokeAndACK_set_per_commitment_secret(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::ThirtyTwoBytes) {
2471         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.per_commitment_secret = val.data;
2472 }
2473 /// The next sender-broadcast commitment transaction's per-commitment point
2474 #[no_mangle]
2475 pub extern "C" fn RevokeAndACK_get_next_per_commitment_point(this_ptr: &RevokeAndACK) -> crate::c_types::PublicKey {
2476         let mut inner_val = &mut this_ptr.get_native_mut_ref().next_per_commitment_point;
2477         crate::c_types::PublicKey::from_rust(&inner_val)
2478 }
2479 /// The next sender-broadcast commitment transaction's per-commitment point
2480 #[no_mangle]
2481 pub extern "C" fn RevokeAndACK_set_next_per_commitment_point(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::PublicKey) {
2482         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_per_commitment_point = val.into_rust();
2483 }
2484 /// Constructs a new RevokeAndACK given each field
2485 #[must_use]
2486 #[no_mangle]
2487 pub extern "C" fn RevokeAndACK_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut per_commitment_secret_arg: crate::c_types::ThirtyTwoBytes, mut next_per_commitment_point_arg: crate::c_types::PublicKey) -> RevokeAndACK {
2488         RevokeAndACK { inner: ObjOps::heap_alloc(nativeRevokeAndACK {
2489                 channel_id: channel_id_arg.data,
2490                 per_commitment_secret: per_commitment_secret_arg.data,
2491                 next_per_commitment_point: next_per_commitment_point_arg.into_rust(),
2492         }), is_owned: true }
2493 }
2494 impl Clone for RevokeAndACK {
2495         fn clone(&self) -> Self {
2496                 Self {
2497                         inner: if <*mut nativeRevokeAndACK>::is_null(self.inner) { core::ptr::null_mut() } else {
2498                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
2499                         is_owned: true,
2500                 }
2501         }
2502 }
2503 #[allow(unused)]
2504 /// Used only if an object of this type is returned as a trait impl by a method
2505 pub(crate) extern "C" fn RevokeAndACK_clone_void(this_ptr: *const c_void) -> *mut c_void {
2506         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRevokeAndACK)).clone() })) as *mut c_void
2507 }
2508 #[no_mangle]
2509 /// Creates a copy of the RevokeAndACK
2510 pub extern "C" fn RevokeAndACK_clone(orig: &RevokeAndACK) -> RevokeAndACK {
2511         orig.clone()
2512 }
2513
2514 use lightning::ln::msgs::UpdateFee as nativeUpdateFeeImport;
2515 pub(crate) type nativeUpdateFee = nativeUpdateFeeImport;
2516
2517 /// An update_fee message to be sent or received from a peer
2518 #[must_use]
2519 #[repr(C)]
2520 pub struct UpdateFee {
2521         /// A pointer to the opaque Rust object.
2522
2523         /// Nearly everywhere, inner must be non-null, however in places where
2524         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2525         pub inner: *mut nativeUpdateFee,
2526         /// Indicates that this is the only struct which contains the same pointer.
2527
2528         /// Rust functions which take ownership of an object provided via an argument require
2529         /// this to be true and invalidate the object pointed to by inner.
2530         pub is_owned: bool,
2531 }
2532
2533 impl Drop for UpdateFee {
2534         fn drop(&mut self) {
2535                 if self.is_owned && !<*mut nativeUpdateFee>::is_null(self.inner) {
2536                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
2537                 }
2538         }
2539 }
2540 /// Frees any resources used by the UpdateFee, if is_owned is set and inner is non-NULL.
2541 #[no_mangle]
2542 pub extern "C" fn UpdateFee_free(this_obj: UpdateFee) { }
2543 #[allow(unused)]
2544 /// Used only if an object of this type is returned as a trait impl by a method
2545 pub(crate) extern "C" fn UpdateFee_free_void(this_ptr: *mut c_void) {
2546         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFee); }
2547 }
2548 #[allow(unused)]
2549 impl UpdateFee {
2550         pub(crate) fn get_native_ref(&self) -> &'static nativeUpdateFee {
2551                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
2552         }
2553         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUpdateFee {
2554                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
2555         }
2556         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2557         pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFee {
2558                 assert!(self.is_owned);
2559                 let ret = ObjOps::untweak_ptr(self.inner);
2560                 self.inner = core::ptr::null_mut();
2561                 ret
2562         }
2563 }
2564 /// The channel ID
2565 #[no_mangle]
2566 pub extern "C" fn UpdateFee_get_channel_id(this_ptr: &UpdateFee) -> *const [u8; 32] {
2567         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
2568         inner_val
2569 }
2570 /// The channel ID
2571 #[no_mangle]
2572 pub extern "C" fn UpdateFee_set_channel_id(this_ptr: &mut UpdateFee, mut val: crate::c_types::ThirtyTwoBytes) {
2573         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
2574 }
2575 /// Fee rate per 1000-weight of the transaction
2576 #[no_mangle]
2577 pub extern "C" fn UpdateFee_get_feerate_per_kw(this_ptr: &UpdateFee) -> u32 {
2578         let mut inner_val = &mut this_ptr.get_native_mut_ref().feerate_per_kw;
2579         *inner_val
2580 }
2581 /// Fee rate per 1000-weight of the transaction
2582 #[no_mangle]
2583 pub extern "C" fn UpdateFee_set_feerate_per_kw(this_ptr: &mut UpdateFee, mut val: u32) {
2584         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.feerate_per_kw = val;
2585 }
2586 /// Constructs a new UpdateFee given each field
2587 #[must_use]
2588 #[no_mangle]
2589 pub extern "C" fn UpdateFee_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut feerate_per_kw_arg: u32) -> UpdateFee {
2590         UpdateFee { inner: ObjOps::heap_alloc(nativeUpdateFee {
2591                 channel_id: channel_id_arg.data,
2592                 feerate_per_kw: feerate_per_kw_arg,
2593         }), is_owned: true }
2594 }
2595 impl Clone for UpdateFee {
2596         fn clone(&self) -> Self {
2597                 Self {
2598                         inner: if <*mut nativeUpdateFee>::is_null(self.inner) { core::ptr::null_mut() } else {
2599                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
2600                         is_owned: true,
2601                 }
2602         }
2603 }
2604 #[allow(unused)]
2605 /// Used only if an object of this type is returned as a trait impl by a method
2606 pub(crate) extern "C" fn UpdateFee_clone_void(this_ptr: *const c_void) -> *mut c_void {
2607         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFee)).clone() })) as *mut c_void
2608 }
2609 #[no_mangle]
2610 /// Creates a copy of the UpdateFee
2611 pub extern "C" fn UpdateFee_clone(orig: &UpdateFee) -> UpdateFee {
2612         orig.clone()
2613 }
2614
2615 use lightning::ln::msgs::DataLossProtect as nativeDataLossProtectImport;
2616 pub(crate) type nativeDataLossProtect = nativeDataLossProtectImport;
2617
2618 /// Proof that the sender knows the per-commitment secret of the previous commitment transaction.
2619 /// This is used to convince the recipient that the channel is at a certain commitment
2620 /// number even if they lost that data due to a local failure.  Of course, the peer may lie
2621 /// and even later commitments may have been revoked.
2622 #[must_use]
2623 #[repr(C)]
2624 pub struct DataLossProtect {
2625         /// A pointer to the opaque Rust object.
2626
2627         /// Nearly everywhere, inner must be non-null, however in places where
2628         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2629         pub inner: *mut nativeDataLossProtect,
2630         /// Indicates that this is the only struct which contains the same pointer.
2631
2632         /// Rust functions which take ownership of an object provided via an argument require
2633         /// this to be true and invalidate the object pointed to by inner.
2634         pub is_owned: bool,
2635 }
2636
2637 impl Drop for DataLossProtect {
2638         fn drop(&mut self) {
2639                 if self.is_owned && !<*mut nativeDataLossProtect>::is_null(self.inner) {
2640                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
2641                 }
2642         }
2643 }
2644 /// Frees any resources used by the DataLossProtect, if is_owned is set and inner is non-NULL.
2645 #[no_mangle]
2646 pub extern "C" fn DataLossProtect_free(this_obj: DataLossProtect) { }
2647 #[allow(unused)]
2648 /// Used only if an object of this type is returned as a trait impl by a method
2649 pub(crate) extern "C" fn DataLossProtect_free_void(this_ptr: *mut c_void) {
2650         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDataLossProtect); }
2651 }
2652 #[allow(unused)]
2653 impl DataLossProtect {
2654         pub(crate) fn get_native_ref(&self) -> &'static nativeDataLossProtect {
2655                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
2656         }
2657         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeDataLossProtect {
2658                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
2659         }
2660         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2661         pub(crate) fn take_inner(mut self) -> *mut nativeDataLossProtect {
2662                 assert!(self.is_owned);
2663                 let ret = ObjOps::untweak_ptr(self.inner);
2664                 self.inner = core::ptr::null_mut();
2665                 ret
2666         }
2667 }
2668 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
2669 /// belonging to the recipient
2670 #[no_mangle]
2671 pub extern "C" fn DataLossProtect_get_your_last_per_commitment_secret(this_ptr: &DataLossProtect) -> *const [u8; 32] {
2672         let mut inner_val = &mut this_ptr.get_native_mut_ref().your_last_per_commitment_secret;
2673         inner_val
2674 }
2675 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
2676 /// belonging to the recipient
2677 #[no_mangle]
2678 pub extern "C" fn DataLossProtect_set_your_last_per_commitment_secret(this_ptr: &mut DataLossProtect, mut val: crate::c_types::ThirtyTwoBytes) {
2679         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.your_last_per_commitment_secret = val.data;
2680 }
2681 /// The sender's per-commitment point for their current commitment transaction
2682 #[no_mangle]
2683 pub extern "C" fn DataLossProtect_get_my_current_per_commitment_point(this_ptr: &DataLossProtect) -> crate::c_types::PublicKey {
2684         let mut inner_val = &mut this_ptr.get_native_mut_ref().my_current_per_commitment_point;
2685         crate::c_types::PublicKey::from_rust(&inner_val)
2686 }
2687 /// The sender's per-commitment point for their current commitment transaction
2688 #[no_mangle]
2689 pub extern "C" fn DataLossProtect_set_my_current_per_commitment_point(this_ptr: &mut DataLossProtect, mut val: crate::c_types::PublicKey) {
2690         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.my_current_per_commitment_point = val.into_rust();
2691 }
2692 /// Constructs a new DataLossProtect given each field
2693 #[must_use]
2694 #[no_mangle]
2695 pub extern "C" fn DataLossProtect_new(mut your_last_per_commitment_secret_arg: crate::c_types::ThirtyTwoBytes, mut my_current_per_commitment_point_arg: crate::c_types::PublicKey) -> DataLossProtect {
2696         DataLossProtect { inner: ObjOps::heap_alloc(nativeDataLossProtect {
2697                 your_last_per_commitment_secret: your_last_per_commitment_secret_arg.data,
2698                 my_current_per_commitment_point: my_current_per_commitment_point_arg.into_rust(),
2699         }), is_owned: true }
2700 }
2701 impl Clone for DataLossProtect {
2702         fn clone(&self) -> Self {
2703                 Self {
2704                         inner: if <*mut nativeDataLossProtect>::is_null(self.inner) { core::ptr::null_mut() } else {
2705                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
2706                         is_owned: true,
2707                 }
2708         }
2709 }
2710 #[allow(unused)]
2711 /// Used only if an object of this type is returned as a trait impl by a method
2712 pub(crate) extern "C" fn DataLossProtect_clone_void(this_ptr: *const c_void) -> *mut c_void {
2713         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeDataLossProtect)).clone() })) as *mut c_void
2714 }
2715 #[no_mangle]
2716 /// Creates a copy of the DataLossProtect
2717 pub extern "C" fn DataLossProtect_clone(orig: &DataLossProtect) -> DataLossProtect {
2718         orig.clone()
2719 }
2720
2721 use lightning::ln::msgs::ChannelReestablish as nativeChannelReestablishImport;
2722 pub(crate) type nativeChannelReestablish = nativeChannelReestablishImport;
2723
2724 /// A channel_reestablish message to be sent or received from a peer
2725 #[must_use]
2726 #[repr(C)]
2727 pub struct ChannelReestablish {
2728         /// A pointer to the opaque Rust object.
2729
2730         /// Nearly everywhere, inner must be non-null, however in places where
2731         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2732         pub inner: *mut nativeChannelReestablish,
2733         /// Indicates that this is the only struct which contains the same pointer.
2734
2735         /// Rust functions which take ownership of an object provided via an argument require
2736         /// this to be true and invalidate the object pointed to by inner.
2737         pub is_owned: bool,
2738 }
2739
2740 impl Drop for ChannelReestablish {
2741         fn drop(&mut self) {
2742                 if self.is_owned && !<*mut nativeChannelReestablish>::is_null(self.inner) {
2743                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
2744                 }
2745         }
2746 }
2747 /// Frees any resources used by the ChannelReestablish, if is_owned is set and inner is non-NULL.
2748 #[no_mangle]
2749 pub extern "C" fn ChannelReestablish_free(this_obj: ChannelReestablish) { }
2750 #[allow(unused)]
2751 /// Used only if an object of this type is returned as a trait impl by a method
2752 pub(crate) extern "C" fn ChannelReestablish_free_void(this_ptr: *mut c_void) {
2753         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelReestablish); }
2754 }
2755 #[allow(unused)]
2756 impl ChannelReestablish {
2757         pub(crate) fn get_native_ref(&self) -> &'static nativeChannelReestablish {
2758                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
2759         }
2760         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeChannelReestablish {
2761                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
2762         }
2763         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2764         pub(crate) fn take_inner(mut self) -> *mut nativeChannelReestablish {
2765                 assert!(self.is_owned);
2766                 let ret = ObjOps::untweak_ptr(self.inner);
2767                 self.inner = core::ptr::null_mut();
2768                 ret
2769         }
2770 }
2771 /// The channel ID
2772 #[no_mangle]
2773 pub extern "C" fn ChannelReestablish_get_channel_id(this_ptr: &ChannelReestablish) -> *const [u8; 32] {
2774         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
2775         inner_val
2776 }
2777 /// The channel ID
2778 #[no_mangle]
2779 pub extern "C" fn ChannelReestablish_set_channel_id(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::ThirtyTwoBytes) {
2780         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
2781 }
2782 /// The next commitment number for the sender
2783 #[no_mangle]
2784 pub extern "C" fn ChannelReestablish_get_next_local_commitment_number(this_ptr: &ChannelReestablish) -> u64 {
2785         let mut inner_val = &mut this_ptr.get_native_mut_ref().next_local_commitment_number;
2786         *inner_val
2787 }
2788 /// The next commitment number for the sender
2789 #[no_mangle]
2790 pub extern "C" fn ChannelReestablish_set_next_local_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) {
2791         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_local_commitment_number = val;
2792 }
2793 /// The next commitment number for the recipient
2794 #[no_mangle]
2795 pub extern "C" fn ChannelReestablish_get_next_remote_commitment_number(this_ptr: &ChannelReestablish) -> u64 {
2796         let mut inner_val = &mut this_ptr.get_native_mut_ref().next_remote_commitment_number;
2797         *inner_val
2798 }
2799 /// The next commitment number for the recipient
2800 #[no_mangle]
2801 pub extern "C" fn ChannelReestablish_set_next_remote_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) {
2802         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.next_remote_commitment_number = val;
2803 }
2804 impl Clone for ChannelReestablish {
2805         fn clone(&self) -> Self {
2806                 Self {
2807                         inner: if <*mut nativeChannelReestablish>::is_null(self.inner) { core::ptr::null_mut() } else {
2808                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
2809                         is_owned: true,
2810                 }
2811         }
2812 }
2813 #[allow(unused)]
2814 /// Used only if an object of this type is returned as a trait impl by a method
2815 pub(crate) extern "C" fn ChannelReestablish_clone_void(this_ptr: *const c_void) -> *mut c_void {
2816         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelReestablish)).clone() })) as *mut c_void
2817 }
2818 #[no_mangle]
2819 /// Creates a copy of the ChannelReestablish
2820 pub extern "C" fn ChannelReestablish_clone(orig: &ChannelReestablish) -> ChannelReestablish {
2821         orig.clone()
2822 }
2823
2824 use lightning::ln::msgs::AnnouncementSignatures as nativeAnnouncementSignaturesImport;
2825 pub(crate) type nativeAnnouncementSignatures = nativeAnnouncementSignaturesImport;
2826
2827 /// An announcement_signatures message to be sent or received from a peer
2828 #[must_use]
2829 #[repr(C)]
2830 pub struct AnnouncementSignatures {
2831         /// A pointer to the opaque Rust object.
2832
2833         /// Nearly everywhere, inner must be non-null, however in places where
2834         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2835         pub inner: *mut nativeAnnouncementSignatures,
2836         /// Indicates that this is the only struct which contains the same pointer.
2837
2838         /// Rust functions which take ownership of an object provided via an argument require
2839         /// this to be true and invalidate the object pointed to by inner.
2840         pub is_owned: bool,
2841 }
2842
2843 impl Drop for AnnouncementSignatures {
2844         fn drop(&mut self) {
2845                 if self.is_owned && !<*mut nativeAnnouncementSignatures>::is_null(self.inner) {
2846                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
2847                 }
2848         }
2849 }
2850 /// Frees any resources used by the AnnouncementSignatures, if is_owned is set and inner is non-NULL.
2851 #[no_mangle]
2852 pub extern "C" fn AnnouncementSignatures_free(this_obj: AnnouncementSignatures) { }
2853 #[allow(unused)]
2854 /// Used only if an object of this type is returned as a trait impl by a method
2855 pub(crate) extern "C" fn AnnouncementSignatures_free_void(this_ptr: *mut c_void) {
2856         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeAnnouncementSignatures); }
2857 }
2858 #[allow(unused)]
2859 impl AnnouncementSignatures {
2860         pub(crate) fn get_native_ref(&self) -> &'static nativeAnnouncementSignatures {
2861                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
2862         }
2863         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeAnnouncementSignatures {
2864                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
2865         }
2866         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2867         pub(crate) fn take_inner(mut self) -> *mut nativeAnnouncementSignatures {
2868                 assert!(self.is_owned);
2869                 let ret = ObjOps::untweak_ptr(self.inner);
2870                 self.inner = core::ptr::null_mut();
2871                 ret
2872         }
2873 }
2874 /// The channel ID
2875 #[no_mangle]
2876 pub extern "C" fn AnnouncementSignatures_get_channel_id(this_ptr: &AnnouncementSignatures) -> *const [u8; 32] {
2877         let mut inner_val = &mut this_ptr.get_native_mut_ref().channel_id;
2878         inner_val
2879 }
2880 /// The channel ID
2881 #[no_mangle]
2882 pub extern "C" fn AnnouncementSignatures_set_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::ThirtyTwoBytes) {
2883         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.channel_id = val.data;
2884 }
2885 /// The short channel ID
2886 #[no_mangle]
2887 pub extern "C" fn AnnouncementSignatures_get_short_channel_id(this_ptr: &AnnouncementSignatures) -> u64 {
2888         let mut inner_val = &mut this_ptr.get_native_mut_ref().short_channel_id;
2889         *inner_val
2890 }
2891 /// The short channel ID
2892 #[no_mangle]
2893 pub extern "C" fn AnnouncementSignatures_set_short_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: u64) {
2894         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_id = val;
2895 }
2896 /// A signature by the node key
2897 #[no_mangle]
2898 pub extern "C" fn AnnouncementSignatures_get_node_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::Signature {
2899         let mut inner_val = &mut this_ptr.get_native_mut_ref().node_signature;
2900         crate::c_types::Signature::from_rust(&inner_val)
2901 }
2902 /// A signature by the node key
2903 #[no_mangle]
2904 pub extern "C" fn AnnouncementSignatures_set_node_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::Signature) {
2905         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.node_signature = val.into_rust();
2906 }
2907 /// A signature by the funding key
2908 #[no_mangle]
2909 pub extern "C" fn AnnouncementSignatures_get_bitcoin_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::Signature {
2910         let mut inner_val = &mut this_ptr.get_native_mut_ref().bitcoin_signature;
2911         crate::c_types::Signature::from_rust(&inner_val)
2912 }
2913 /// A signature by the funding key
2914 #[no_mangle]
2915 pub extern "C" fn AnnouncementSignatures_set_bitcoin_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::Signature) {
2916         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.bitcoin_signature = val.into_rust();
2917 }
2918 /// Constructs a new AnnouncementSignatures given each field
2919 #[must_use]
2920 #[no_mangle]
2921 pub extern "C" fn AnnouncementSignatures_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut short_channel_id_arg: u64, mut node_signature_arg: crate::c_types::Signature, mut bitcoin_signature_arg: crate::c_types::Signature) -> AnnouncementSignatures {
2922         AnnouncementSignatures { inner: ObjOps::heap_alloc(nativeAnnouncementSignatures {
2923                 channel_id: channel_id_arg.data,
2924                 short_channel_id: short_channel_id_arg,
2925                 node_signature: node_signature_arg.into_rust(),
2926                 bitcoin_signature: bitcoin_signature_arg.into_rust(),
2927         }), is_owned: true }
2928 }
2929 impl Clone for AnnouncementSignatures {
2930         fn clone(&self) -> Self {
2931                 Self {
2932                         inner: if <*mut nativeAnnouncementSignatures>::is_null(self.inner) { core::ptr::null_mut() } else {
2933                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
2934                         is_owned: true,
2935                 }
2936         }
2937 }
2938 #[allow(unused)]
2939 /// Used only if an object of this type is returned as a trait impl by a method
2940 pub(crate) extern "C" fn AnnouncementSignatures_clone_void(this_ptr: *const c_void) -> *mut c_void {
2941         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeAnnouncementSignatures)).clone() })) as *mut c_void
2942 }
2943 #[no_mangle]
2944 /// Creates a copy of the AnnouncementSignatures
2945 pub extern "C" fn AnnouncementSignatures_clone(orig: &AnnouncementSignatures) -> AnnouncementSignatures {
2946         orig.clone()
2947 }
2948 /// An address which can be used to connect to a remote peer
2949 #[must_use]
2950 #[derive(Clone)]
2951 #[repr(C)]
2952 pub enum NetAddress {
2953         /// An IPv4 address/port on which the peer is listening.
2954         IPv4 {
2955                 /// The 4-byte IPv4 address
2956                 addr: crate::c_types::FourBytes,
2957                 /// The port on which the node is listening
2958                 port: u16,
2959         },
2960         /// An IPv6 address/port on which the peer is listening.
2961         IPv6 {
2962                 /// The 16-byte IPv6 address
2963                 addr: crate::c_types::SixteenBytes,
2964                 /// The port on which the node is listening
2965                 port: u16,
2966         },
2967         /// An old-style Tor onion address/port on which the peer is listening.
2968         ///
2969         /// This field is deprecated and the Tor network generally no longer supports V2 Onion
2970         /// addresses. Thus, the details are not parsed here.
2971         OnionV2(crate::c_types::TwelveBytes),
2972         /// A new-style Tor onion address/port on which the peer is listening.
2973         /// To create the human-readable \"hostname\", concatenate ed25519_pubkey, checksum, and version,
2974         /// wrap as base32 and append \".onion\".
2975         OnionV3 {
2976                 /// The ed25519 long-term public key of the peer
2977                 ed25519_pubkey: crate::c_types::ThirtyTwoBytes,
2978                 /// The checksum of the pubkey and version, as included in the onion address
2979                 checksum: u16,
2980                 /// The version byte, as defined by the Tor Onion v3 spec.
2981                 version: u8,
2982                 /// The port on which the node is listening
2983                 port: u16,
2984         },
2985 }
2986 use lightning::ln::msgs::NetAddress as nativeNetAddress;
2987 impl NetAddress {
2988         #[allow(unused)]
2989         pub(crate) fn to_native(&self) -> nativeNetAddress {
2990                 match self {
2991                         NetAddress::IPv4 {ref addr, ref port, } => {
2992                                 let mut addr_nonref = (*addr).clone();
2993                                 let mut port_nonref = (*port).clone();
2994                                 nativeNetAddress::IPv4 {
2995                                         addr: addr_nonref.data,
2996                                         port: port_nonref,
2997                                 }
2998                         },
2999                         NetAddress::IPv6 {ref addr, ref port, } => {
3000                                 let mut addr_nonref = (*addr).clone();
3001                                 let mut port_nonref = (*port).clone();
3002                                 nativeNetAddress::IPv6 {
3003                                         addr: addr_nonref.data,
3004                                         port: port_nonref,
3005                                 }
3006                         },
3007                         NetAddress::OnionV2 (ref a, ) => {
3008                                 let mut a_nonref = (*a).clone();
3009                                 nativeNetAddress::OnionV2 (
3010                                         a_nonref.data,
3011                                 )
3012                         },
3013                         NetAddress::OnionV3 {ref ed25519_pubkey, ref checksum, ref version, ref port, } => {
3014                                 let mut ed25519_pubkey_nonref = (*ed25519_pubkey).clone();
3015                                 let mut checksum_nonref = (*checksum).clone();
3016                                 let mut version_nonref = (*version).clone();
3017                                 let mut port_nonref = (*port).clone();
3018                                 nativeNetAddress::OnionV3 {
3019                                         ed25519_pubkey: ed25519_pubkey_nonref.data,
3020                                         checksum: checksum_nonref,
3021                                         version: version_nonref,
3022                                         port: port_nonref,
3023                                 }
3024                         },
3025                 }
3026         }
3027         #[allow(unused)]
3028         pub(crate) fn into_native(self) -> nativeNetAddress {
3029                 match self {
3030                         NetAddress::IPv4 {mut addr, mut port, } => {
3031                                 nativeNetAddress::IPv4 {
3032                                         addr: addr.data,
3033                                         port: port,
3034                                 }
3035                         },
3036                         NetAddress::IPv6 {mut addr, mut port, } => {
3037                                 nativeNetAddress::IPv6 {
3038                                         addr: addr.data,
3039                                         port: port,
3040                                 }
3041                         },
3042                         NetAddress::OnionV2 (mut a, ) => {
3043                                 nativeNetAddress::OnionV2 (
3044                                         a.data,
3045                                 )
3046                         },
3047                         NetAddress::OnionV3 {mut ed25519_pubkey, mut checksum, mut version, mut port, } => {
3048                                 nativeNetAddress::OnionV3 {
3049                                         ed25519_pubkey: ed25519_pubkey.data,
3050                                         checksum: checksum,
3051                                         version: version,
3052                                         port: port,
3053                                 }
3054                         },
3055                 }
3056         }
3057         #[allow(unused)]
3058         pub(crate) fn from_native(native: &nativeNetAddress) -> Self {
3059                 match native {
3060                         nativeNetAddress::IPv4 {ref addr, ref port, } => {
3061                                 let mut addr_nonref = (*addr).clone();
3062                                 let mut port_nonref = (*port).clone();
3063                                 NetAddress::IPv4 {
3064                                         addr: crate::c_types::FourBytes { data: addr_nonref },
3065                                         port: port_nonref,
3066                                 }
3067                         },
3068                         nativeNetAddress::IPv6 {ref addr, ref port, } => {
3069                                 let mut addr_nonref = (*addr).clone();
3070                                 let mut port_nonref = (*port).clone();
3071                                 NetAddress::IPv6 {
3072                                         addr: crate::c_types::SixteenBytes { data: addr_nonref },
3073                                         port: port_nonref,
3074                                 }
3075                         },
3076                         nativeNetAddress::OnionV2 (ref a, ) => {
3077                                 let mut a_nonref = (*a).clone();
3078                                 NetAddress::OnionV2 (
3079                                         crate::c_types::TwelveBytes { data: a_nonref },
3080                                 )
3081                         },
3082                         nativeNetAddress::OnionV3 {ref ed25519_pubkey, ref checksum, ref version, ref port, } => {
3083                                 let mut ed25519_pubkey_nonref = (*ed25519_pubkey).clone();
3084                                 let mut checksum_nonref = (*checksum).clone();
3085                                 let mut version_nonref = (*version).clone();
3086                                 let mut port_nonref = (*port).clone();
3087                                 NetAddress::OnionV3 {
3088                                         ed25519_pubkey: crate::c_types::ThirtyTwoBytes { data: ed25519_pubkey_nonref },
3089                                         checksum: checksum_nonref,
3090                                         version: version_nonref,
3091                                         port: port_nonref,
3092                                 }
3093                         },
3094                 }
3095         }
3096         #[allow(unused)]
3097         pub(crate) fn native_into(native: nativeNetAddress) -> Self {
3098                 match native {
3099                         nativeNetAddress::IPv4 {mut addr, mut port, } => {
3100                                 NetAddress::IPv4 {
3101                                         addr: crate::c_types::FourBytes { data: addr },
3102                                         port: port,
3103                                 }
3104                         },
3105                         nativeNetAddress::IPv6 {mut addr, mut port, } => {
3106                                 NetAddress::IPv6 {
3107                                         addr: crate::c_types::SixteenBytes { data: addr },
3108                                         port: port,
3109                                 }
3110                         },
3111                         nativeNetAddress::OnionV2 (mut a, ) => {
3112                                 NetAddress::OnionV2 (
3113                                         crate::c_types::TwelveBytes { data: a },
3114                                 )
3115                         },
3116                         nativeNetAddress::OnionV3 {mut ed25519_pubkey, mut checksum, mut version, mut port, } => {
3117                                 NetAddress::OnionV3 {
3118                                         ed25519_pubkey: crate::c_types::ThirtyTwoBytes { data: ed25519_pubkey },
3119                                         checksum: checksum,
3120                                         version: version,
3121                                         port: port,
3122                                 }
3123                         },
3124                 }
3125         }
3126 }
3127 /// Frees any resources used by the NetAddress
3128 #[no_mangle]
3129 pub extern "C" fn NetAddress_free(this_ptr: NetAddress) { }
3130 /// Creates a copy of the NetAddress
3131 #[no_mangle]
3132 pub extern "C" fn NetAddress_clone(orig: &NetAddress) -> NetAddress {
3133         orig.clone()
3134 }
3135 #[no_mangle]
3136 /// Utility method to constructs a new IPv4-variant NetAddress
3137 pub extern "C" fn NetAddress_ipv4(addr: crate::c_types::FourBytes, port: u16) -> NetAddress {
3138         NetAddress::IPv4 {
3139                 addr,
3140                 port,
3141         }
3142 }
3143 #[no_mangle]
3144 /// Utility method to constructs a new IPv6-variant NetAddress
3145 pub extern "C" fn NetAddress_ipv6(addr: crate::c_types::SixteenBytes, port: u16) -> NetAddress {
3146         NetAddress::IPv6 {
3147                 addr,
3148                 port,
3149         }
3150 }
3151 #[no_mangle]
3152 /// Utility method to constructs a new OnionV2-variant NetAddress
3153 pub extern "C" fn NetAddress_onion_v2(a: crate::c_types::TwelveBytes) -> NetAddress {
3154         NetAddress::OnionV2(a, )
3155 }
3156 #[no_mangle]
3157 /// Utility method to constructs a new OnionV3-variant NetAddress
3158 pub extern "C" fn NetAddress_onion_v3(ed25519_pubkey: crate::c_types::ThirtyTwoBytes, checksum: u16, version: u8, port: u16) -> NetAddress {
3159         NetAddress::OnionV3 {
3160                 ed25519_pubkey,
3161                 checksum,
3162                 version,
3163                 port,
3164         }
3165 }
3166 #[no_mangle]
3167 /// Serialize the NetAddress object into a byte array which can be read by NetAddress_read
3168 pub extern "C" fn NetAddress_write(obj: &NetAddress) -> crate::c_types::derived::CVec_u8Z {
3169         crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
3170 }
3171 #[no_mangle]
3172 /// Read a NetAddress from a byte array, created by NetAddress_write
3173 pub extern "C" fn NetAddress_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_NetAddressDecodeErrorZ {
3174         let res: Result<lightning::ln::msgs::NetAddress, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
3175         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::NetAddress::native_into(o) }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: ObjOps::heap_alloc(e), is_owned: true } }).into() };
3176         local_res
3177 }
3178
3179 use lightning::ln::msgs::UnsignedNodeAnnouncement as nativeUnsignedNodeAnnouncementImport;
3180 pub(crate) type nativeUnsignedNodeAnnouncement = nativeUnsignedNodeAnnouncementImport;
3181
3182 /// The unsigned part of a node_announcement
3183 #[must_use]
3184 #[repr(C)]
3185 pub struct UnsignedNodeAnnouncement {
3186         /// A pointer to the opaque Rust object.
3187
3188         /// Nearly everywhere, inner must be non-null, however in places where
3189         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3190         pub inner: *mut nativeUnsignedNodeAnnouncement,
3191         /// Indicates that this is the only struct which contains the same pointer.
3192
3193         /// Rust functions which take ownership of an object provided via an argument require
3194         /// this to be true and invalidate the object pointed to by inner.
3195         pub is_owned: bool,
3196 }
3197
3198 impl Drop for UnsignedNodeAnnouncement {
3199         fn drop(&mut self) {
3200                 if self.is_owned && !<*mut nativeUnsignedNodeAnnouncement>::is_null(self.inner) {
3201                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
3202                 }
3203         }
3204 }
3205 /// Frees any resources used by the UnsignedNodeAnnouncement, if is_owned is set and inner is non-NULL.
3206 #[no_mangle]
3207 pub extern "C" fn UnsignedNodeAnnouncement_free(this_obj: UnsignedNodeAnnouncement) { }
3208 #[allow(unused)]
3209 /// Used only if an object of this type is returned as a trait impl by a method
3210 pub(crate) extern "C" fn UnsignedNodeAnnouncement_free_void(this_ptr: *mut c_void) {
3211         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUnsignedNodeAnnouncement); }
3212 }
3213 #[allow(unused)]
3214 impl UnsignedNodeAnnouncement {
3215         pub(crate) fn get_native_ref(&self) -> &'static nativeUnsignedNodeAnnouncement {
3216                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
3217         }
3218         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUnsignedNodeAnnouncement {
3219                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
3220         }
3221         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3222         pub(crate) fn take_inner(mut self) -> *mut nativeUnsignedNodeAnnouncement {
3223                 assert!(self.is_owned);
3224                 let ret = ObjOps::untweak_ptr(self.inner);
3225                 self.inner = core::ptr::null_mut();
3226                 ret
3227         }
3228 }
3229 /// The advertised features
3230 #[no_mangle]
3231 pub extern "C" fn UnsignedNodeAnnouncement_get_features(this_ptr: &UnsignedNodeAnnouncement) -> crate::lightning::ln::features::NodeFeatures {
3232         let mut inner_val = &mut this_ptr.get_native_mut_ref().features;
3233         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 }
3234 }
3235 /// The advertised features
3236 #[no_mangle]
3237 pub extern "C" fn UnsignedNodeAnnouncement_set_features(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::lightning::ln::features::NodeFeatures) {
3238         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.features = *unsafe { Box::from_raw(val.take_inner()) };
3239 }
3240 /// A strictly monotonic announcement counter, with gaps allowed
3241 #[no_mangle]
3242 pub extern "C" fn UnsignedNodeAnnouncement_get_timestamp(this_ptr: &UnsignedNodeAnnouncement) -> u32 {
3243         let mut inner_val = &mut this_ptr.get_native_mut_ref().timestamp;
3244         *inner_val
3245 }
3246 /// A strictly monotonic announcement counter, with gaps allowed
3247 #[no_mangle]
3248 pub extern "C" fn UnsignedNodeAnnouncement_set_timestamp(this_ptr: &mut UnsignedNodeAnnouncement, mut val: u32) {
3249         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.timestamp = val;
3250 }
3251 /// The node_id this announcement originated from (don't rebroadcast the node_announcement back
3252 /// to this node).
3253 #[no_mangle]
3254 pub extern "C" fn UnsignedNodeAnnouncement_get_node_id(this_ptr: &UnsignedNodeAnnouncement) -> crate::c_types::PublicKey {
3255         let mut inner_val = &mut this_ptr.get_native_mut_ref().node_id;
3256         crate::c_types::PublicKey::from_rust(&inner_val)
3257 }
3258 /// The node_id this announcement originated from (don't rebroadcast the node_announcement back
3259 /// to this node).
3260 #[no_mangle]
3261 pub extern "C" fn UnsignedNodeAnnouncement_set_node_id(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::PublicKey) {
3262         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.node_id = val.into_rust();
3263 }
3264 /// An RGB color for UI purposes
3265 #[no_mangle]
3266 pub extern "C" fn UnsignedNodeAnnouncement_get_rgb(this_ptr: &UnsignedNodeAnnouncement) -> *const [u8; 3] {
3267         let mut inner_val = &mut this_ptr.get_native_mut_ref().rgb;
3268         inner_val
3269 }
3270 /// An RGB color for UI purposes
3271 #[no_mangle]
3272 pub extern "C" fn UnsignedNodeAnnouncement_set_rgb(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::ThreeBytes) {
3273         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.rgb = val.data;
3274 }
3275 /// An alias, for UI purposes.  This should be sanitized before use.  There is no guarantee
3276 /// of uniqueness.
3277 #[no_mangle]
3278 pub extern "C" fn UnsignedNodeAnnouncement_get_alias(this_ptr: &UnsignedNodeAnnouncement) -> *const [u8; 32] {
3279         let mut inner_val = &mut this_ptr.get_native_mut_ref().alias;
3280         inner_val
3281 }
3282 /// An alias, for UI purposes.  This should be sanitized before use.  There is no guarantee
3283 /// of uniqueness.
3284 #[no_mangle]
3285 pub extern "C" fn UnsignedNodeAnnouncement_set_alias(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::ThirtyTwoBytes) {
3286         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.alias = val.data;
3287 }
3288 /// List of addresses on which this node is reachable
3289 #[no_mangle]
3290 pub extern "C" fn UnsignedNodeAnnouncement_set_addresses(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::derived::CVec_NetAddressZ) {
3291         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_native() }); };
3292         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.addresses = local_val;
3293 }
3294 impl Clone for UnsignedNodeAnnouncement {
3295         fn clone(&self) -> Self {
3296                 Self {
3297                         inner: if <*mut nativeUnsignedNodeAnnouncement>::is_null(self.inner) { core::ptr::null_mut() } else {
3298                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
3299                         is_owned: true,
3300                 }
3301         }
3302 }
3303 #[allow(unused)]
3304 /// Used only if an object of this type is returned as a trait impl by a method
3305 pub(crate) extern "C" fn UnsignedNodeAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void {
3306         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedNodeAnnouncement)).clone() })) as *mut c_void
3307 }
3308 #[no_mangle]
3309 /// Creates a copy of the UnsignedNodeAnnouncement
3310 pub extern "C" fn UnsignedNodeAnnouncement_clone(orig: &UnsignedNodeAnnouncement) -> UnsignedNodeAnnouncement {
3311         orig.clone()
3312 }
3313
3314 use lightning::ln::msgs::NodeAnnouncement as nativeNodeAnnouncementImport;
3315 pub(crate) type nativeNodeAnnouncement = nativeNodeAnnouncementImport;
3316
3317 /// A node_announcement message to be sent or received from a peer
3318 #[must_use]
3319 #[repr(C)]
3320 pub struct NodeAnnouncement {
3321         /// A pointer to the opaque Rust object.
3322
3323         /// Nearly everywhere, inner must be non-null, however in places where
3324         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3325         pub inner: *mut nativeNodeAnnouncement,
3326         /// Indicates that this is the only struct which contains the same pointer.
3327
3328         /// Rust functions which take ownership of an object provided via an argument require
3329         /// this to be true and invalidate the object pointed to by inner.
3330         pub is_owned: bool,
3331 }
3332
3333 impl Drop for NodeAnnouncement {
3334         fn drop(&mut self) {
3335                 if self.is_owned && !<*mut nativeNodeAnnouncement>::is_null(self.inner) {
3336                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
3337                 }
3338         }
3339 }
3340 /// Frees any resources used by the NodeAnnouncement, if is_owned is set and inner is non-NULL.
3341 #[no_mangle]
3342 pub extern "C" fn NodeAnnouncement_free(this_obj: NodeAnnouncement) { }
3343 #[allow(unused)]
3344 /// Used only if an object of this type is returned as a trait impl by a method
3345 pub(crate) extern "C" fn NodeAnnouncement_free_void(this_ptr: *mut c_void) {
3346         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeNodeAnnouncement); }
3347 }
3348 #[allow(unused)]
3349 impl NodeAnnouncement {
3350         pub(crate) fn get_native_ref(&self) -> &'static nativeNodeAnnouncement {
3351                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
3352         }
3353         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeNodeAnnouncement {
3354                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
3355         }
3356         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3357         pub(crate) fn take_inner(mut self) -> *mut nativeNodeAnnouncement {
3358                 assert!(self.is_owned);
3359                 let ret = ObjOps::untweak_ptr(self.inner);
3360                 self.inner = core::ptr::null_mut();
3361                 ret
3362         }
3363 }
3364 /// The signature by the node key
3365 #[no_mangle]
3366 pub extern "C" fn NodeAnnouncement_get_signature(this_ptr: &NodeAnnouncement) -> crate::c_types::Signature {
3367         let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
3368         crate::c_types::Signature::from_rust(&inner_val)
3369 }
3370 /// The signature by the node key
3371 #[no_mangle]
3372 pub extern "C" fn NodeAnnouncement_set_signature(this_ptr: &mut NodeAnnouncement, mut val: crate::c_types::Signature) {
3373         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
3374 }
3375 /// The actual content of the announcement
3376 #[no_mangle]
3377 pub extern "C" fn NodeAnnouncement_get_contents(this_ptr: &NodeAnnouncement) -> crate::lightning::ln::msgs::UnsignedNodeAnnouncement {
3378         let mut inner_val = &mut this_ptr.get_native_mut_ref().contents;
3379         crate::lightning::ln::msgs::UnsignedNodeAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::msgs::UnsignedNodeAnnouncement<>) as *mut _) }, is_owned: false }
3380 }
3381 /// The actual content of the announcement
3382 #[no_mangle]
3383 pub extern "C" fn NodeAnnouncement_set_contents(this_ptr: &mut NodeAnnouncement, mut val: crate::lightning::ln::msgs::UnsignedNodeAnnouncement) {
3384         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.contents = *unsafe { Box::from_raw(val.take_inner()) };
3385 }
3386 /// Constructs a new NodeAnnouncement given each field
3387 #[must_use]
3388 #[no_mangle]
3389 pub extern "C" fn NodeAnnouncement_new(mut signature_arg: crate::c_types::Signature, mut contents_arg: crate::lightning::ln::msgs::UnsignedNodeAnnouncement) -> NodeAnnouncement {
3390         NodeAnnouncement { inner: ObjOps::heap_alloc(nativeNodeAnnouncement {
3391                 signature: signature_arg.into_rust(),
3392                 contents: *unsafe { Box::from_raw(contents_arg.take_inner()) },
3393         }), is_owned: true }
3394 }
3395 impl Clone for NodeAnnouncement {
3396         fn clone(&self) -> Self {
3397                 Self {
3398                         inner: if <*mut nativeNodeAnnouncement>::is_null(self.inner) { core::ptr::null_mut() } else {
3399                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
3400                         is_owned: true,
3401                 }
3402         }
3403 }
3404 #[allow(unused)]
3405 /// Used only if an object of this type is returned as a trait impl by a method
3406 pub(crate) extern "C" fn NodeAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void {
3407         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeNodeAnnouncement)).clone() })) as *mut c_void
3408 }
3409 #[no_mangle]
3410 /// Creates a copy of the NodeAnnouncement
3411 pub extern "C" fn NodeAnnouncement_clone(orig: &NodeAnnouncement) -> NodeAnnouncement {
3412         orig.clone()
3413 }
3414
3415 use lightning::ln::msgs::UnsignedChannelAnnouncement as nativeUnsignedChannelAnnouncementImport;
3416 pub(crate) type nativeUnsignedChannelAnnouncement = nativeUnsignedChannelAnnouncementImport;
3417
3418 /// The unsigned part of a channel_announcement
3419 #[must_use]
3420 #[repr(C)]
3421 pub struct UnsignedChannelAnnouncement {
3422         /// A pointer to the opaque Rust object.
3423
3424         /// Nearly everywhere, inner must be non-null, however in places where
3425         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3426         pub inner: *mut nativeUnsignedChannelAnnouncement,
3427         /// Indicates that this is the only struct which contains the same pointer.
3428
3429         /// Rust functions which take ownership of an object provided via an argument require
3430         /// this to be true and invalidate the object pointed to by inner.
3431         pub is_owned: bool,
3432 }
3433
3434 impl Drop for UnsignedChannelAnnouncement {
3435         fn drop(&mut self) {
3436                 if self.is_owned && !<*mut nativeUnsignedChannelAnnouncement>::is_null(self.inner) {
3437                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
3438                 }
3439         }
3440 }
3441 /// Frees any resources used by the UnsignedChannelAnnouncement, if is_owned is set and inner is non-NULL.
3442 #[no_mangle]
3443 pub extern "C" fn UnsignedChannelAnnouncement_free(this_obj: UnsignedChannelAnnouncement) { }
3444 #[allow(unused)]
3445 /// Used only if an object of this type is returned as a trait impl by a method
3446 pub(crate) extern "C" fn UnsignedChannelAnnouncement_free_void(this_ptr: *mut c_void) {
3447         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUnsignedChannelAnnouncement); }
3448 }
3449 #[allow(unused)]
3450 impl UnsignedChannelAnnouncement {
3451         pub(crate) fn get_native_ref(&self) -> &'static nativeUnsignedChannelAnnouncement {
3452                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
3453         }
3454         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUnsignedChannelAnnouncement {
3455                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
3456         }
3457         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3458         pub(crate) fn take_inner(mut self) -> *mut nativeUnsignedChannelAnnouncement {
3459                 assert!(self.is_owned);
3460                 let ret = ObjOps::untweak_ptr(self.inner);
3461                 self.inner = core::ptr::null_mut();
3462                 ret
3463         }
3464 }
3465 /// The advertised channel features
3466 #[no_mangle]
3467 pub extern "C" fn UnsignedChannelAnnouncement_get_features(this_ptr: &UnsignedChannelAnnouncement) -> crate::lightning::ln::features::ChannelFeatures {
3468         let mut inner_val = &mut this_ptr.get_native_mut_ref().features;
3469         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 }
3470 }
3471 /// The advertised channel features
3472 #[no_mangle]
3473 pub extern "C" fn UnsignedChannelAnnouncement_set_features(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::lightning::ln::features::ChannelFeatures) {
3474         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.features = *unsafe { Box::from_raw(val.take_inner()) };
3475 }
3476 /// The genesis hash of the blockchain where the channel is to be opened
3477 #[no_mangle]
3478 pub extern "C" fn UnsignedChannelAnnouncement_get_chain_hash(this_ptr: &UnsignedChannelAnnouncement) -> *const [u8; 32] {
3479         let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
3480         inner_val.as_inner()
3481 }
3482 /// The genesis hash of the blockchain where the channel is to be opened
3483 #[no_mangle]
3484 pub extern "C" fn UnsignedChannelAnnouncement_set_chain_hash(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::ThirtyTwoBytes) {
3485         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
3486 }
3487 /// The short channel ID
3488 #[no_mangle]
3489 pub extern "C" fn UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: &UnsignedChannelAnnouncement) -> u64 {
3490         let mut inner_val = &mut this_ptr.get_native_mut_ref().short_channel_id;
3491         *inner_val
3492 }
3493 /// The short channel ID
3494 #[no_mangle]
3495 pub extern "C" fn UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: &mut UnsignedChannelAnnouncement, mut val: u64) {
3496         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_id = val;
3497 }
3498 /// One of the two node_ids which are endpoints of this channel
3499 #[no_mangle]
3500 pub extern "C" fn UnsignedChannelAnnouncement_get_node_id_1(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey {
3501         let mut inner_val = &mut this_ptr.get_native_mut_ref().node_id_1;
3502         crate::c_types::PublicKey::from_rust(&inner_val)
3503 }
3504 /// One of the two node_ids which are endpoints of this channel
3505 #[no_mangle]
3506 pub extern "C" fn UnsignedChannelAnnouncement_set_node_id_1(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) {
3507         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.node_id_1 = val.into_rust();
3508 }
3509 /// The other of the two node_ids which are endpoints of this channel
3510 #[no_mangle]
3511 pub extern "C" fn UnsignedChannelAnnouncement_get_node_id_2(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey {
3512         let mut inner_val = &mut this_ptr.get_native_mut_ref().node_id_2;
3513         crate::c_types::PublicKey::from_rust(&inner_val)
3514 }
3515 /// The other of the two node_ids which are endpoints of this channel
3516 #[no_mangle]
3517 pub extern "C" fn UnsignedChannelAnnouncement_set_node_id_2(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) {
3518         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.node_id_2 = val.into_rust();
3519 }
3520 /// The funding key for the first node
3521 #[no_mangle]
3522 pub extern "C" fn UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey {
3523         let mut inner_val = &mut this_ptr.get_native_mut_ref().bitcoin_key_1;
3524         crate::c_types::PublicKey::from_rust(&inner_val)
3525 }
3526 /// The funding key for the first node
3527 #[no_mangle]
3528 pub extern "C" fn UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) {
3529         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.bitcoin_key_1 = val.into_rust();
3530 }
3531 /// The funding key for the second node
3532 #[no_mangle]
3533 pub extern "C" fn UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey {
3534         let mut inner_val = &mut this_ptr.get_native_mut_ref().bitcoin_key_2;
3535         crate::c_types::PublicKey::from_rust(&inner_val)
3536 }
3537 /// The funding key for the second node
3538 #[no_mangle]
3539 pub extern "C" fn UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) {
3540         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.bitcoin_key_2 = val.into_rust();
3541 }
3542 impl Clone for UnsignedChannelAnnouncement {
3543         fn clone(&self) -> Self {
3544                 Self {
3545                         inner: if <*mut nativeUnsignedChannelAnnouncement>::is_null(self.inner) { core::ptr::null_mut() } else {
3546                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
3547                         is_owned: true,
3548                 }
3549         }
3550 }
3551 #[allow(unused)]
3552 /// Used only if an object of this type is returned as a trait impl by a method
3553 pub(crate) extern "C" fn UnsignedChannelAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void {
3554         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedChannelAnnouncement)).clone() })) as *mut c_void
3555 }
3556 #[no_mangle]
3557 /// Creates a copy of the UnsignedChannelAnnouncement
3558 pub extern "C" fn UnsignedChannelAnnouncement_clone(orig: &UnsignedChannelAnnouncement) -> UnsignedChannelAnnouncement {
3559         orig.clone()
3560 }
3561
3562 use lightning::ln::msgs::ChannelAnnouncement as nativeChannelAnnouncementImport;
3563 pub(crate) type nativeChannelAnnouncement = nativeChannelAnnouncementImport;
3564
3565 /// A channel_announcement message to be sent or received from a peer
3566 #[must_use]
3567 #[repr(C)]
3568 pub struct ChannelAnnouncement {
3569         /// A pointer to the opaque Rust object.
3570
3571         /// Nearly everywhere, inner must be non-null, however in places where
3572         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3573         pub inner: *mut nativeChannelAnnouncement,
3574         /// Indicates that this is the only struct which contains the same pointer.
3575
3576         /// Rust functions which take ownership of an object provided via an argument require
3577         /// this to be true and invalidate the object pointed to by inner.
3578         pub is_owned: bool,
3579 }
3580
3581 impl Drop for ChannelAnnouncement {
3582         fn drop(&mut self) {
3583                 if self.is_owned && !<*mut nativeChannelAnnouncement>::is_null(self.inner) {
3584                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
3585                 }
3586         }
3587 }
3588 /// Frees any resources used by the ChannelAnnouncement, if is_owned is set and inner is non-NULL.
3589 #[no_mangle]
3590 pub extern "C" fn ChannelAnnouncement_free(this_obj: ChannelAnnouncement) { }
3591 #[allow(unused)]
3592 /// Used only if an object of this type is returned as a trait impl by a method
3593 pub(crate) extern "C" fn ChannelAnnouncement_free_void(this_ptr: *mut c_void) {
3594         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelAnnouncement); }
3595 }
3596 #[allow(unused)]
3597 impl ChannelAnnouncement {
3598         pub(crate) fn get_native_ref(&self) -> &'static nativeChannelAnnouncement {
3599                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
3600         }
3601         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeChannelAnnouncement {
3602                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
3603         }
3604         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3605         pub(crate) fn take_inner(mut self) -> *mut nativeChannelAnnouncement {
3606                 assert!(self.is_owned);
3607                 let ret = ObjOps::untweak_ptr(self.inner);
3608                 self.inner = core::ptr::null_mut();
3609                 ret
3610         }
3611 }
3612 /// Authentication of the announcement by the first public node
3613 #[no_mangle]
3614 pub extern "C" fn ChannelAnnouncement_get_node_signature_1(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature {
3615         let mut inner_val = &mut this_ptr.get_native_mut_ref().node_signature_1;
3616         crate::c_types::Signature::from_rust(&inner_val)
3617 }
3618 /// Authentication of the announcement by the first public node
3619 #[no_mangle]
3620 pub extern "C" fn ChannelAnnouncement_set_node_signature_1(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) {
3621         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.node_signature_1 = val.into_rust();
3622 }
3623 /// Authentication of the announcement by the second public node
3624 #[no_mangle]
3625 pub extern "C" fn ChannelAnnouncement_get_node_signature_2(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature {
3626         let mut inner_val = &mut this_ptr.get_native_mut_ref().node_signature_2;
3627         crate::c_types::Signature::from_rust(&inner_val)
3628 }
3629 /// Authentication of the announcement by the second public node
3630 #[no_mangle]
3631 pub extern "C" fn ChannelAnnouncement_set_node_signature_2(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) {
3632         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.node_signature_2 = val.into_rust();
3633 }
3634 /// Proof of funding UTXO ownership by the first public node
3635 #[no_mangle]
3636 pub extern "C" fn ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature {
3637         let mut inner_val = &mut this_ptr.get_native_mut_ref().bitcoin_signature_1;
3638         crate::c_types::Signature::from_rust(&inner_val)
3639 }
3640 /// Proof of funding UTXO ownership by the first public node
3641 #[no_mangle]
3642 pub extern "C" fn ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) {
3643         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.bitcoin_signature_1 = val.into_rust();
3644 }
3645 /// Proof of funding UTXO ownership by the second public node
3646 #[no_mangle]
3647 pub extern "C" fn ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature {
3648         let mut inner_val = &mut this_ptr.get_native_mut_ref().bitcoin_signature_2;
3649         crate::c_types::Signature::from_rust(&inner_val)
3650 }
3651 /// Proof of funding UTXO ownership by the second public node
3652 #[no_mangle]
3653 pub extern "C" fn ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) {
3654         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.bitcoin_signature_2 = val.into_rust();
3655 }
3656 /// The actual announcement
3657 #[no_mangle]
3658 pub extern "C" fn ChannelAnnouncement_get_contents(this_ptr: &ChannelAnnouncement) -> crate::lightning::ln::msgs::UnsignedChannelAnnouncement {
3659         let mut inner_val = &mut this_ptr.get_native_mut_ref().contents;
3660         crate::lightning::ln::msgs::UnsignedChannelAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::msgs::UnsignedChannelAnnouncement<>) as *mut _) }, is_owned: false }
3661 }
3662 /// The actual announcement
3663 #[no_mangle]
3664 pub extern "C" fn ChannelAnnouncement_set_contents(this_ptr: &mut ChannelAnnouncement, mut val: crate::lightning::ln::msgs::UnsignedChannelAnnouncement) {
3665         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.contents = *unsafe { Box::from_raw(val.take_inner()) };
3666 }
3667 /// Constructs a new ChannelAnnouncement given each field
3668 #[must_use]
3669 #[no_mangle]
3670 pub extern "C" fn ChannelAnnouncement_new(mut node_signature_1_arg: crate::c_types::Signature, mut node_signature_2_arg: crate::c_types::Signature, mut bitcoin_signature_1_arg: crate::c_types::Signature, mut bitcoin_signature_2_arg: crate::c_types::Signature, mut contents_arg: crate::lightning::ln::msgs::UnsignedChannelAnnouncement) -> ChannelAnnouncement {
3671         ChannelAnnouncement { inner: ObjOps::heap_alloc(nativeChannelAnnouncement {
3672                 node_signature_1: node_signature_1_arg.into_rust(),
3673                 node_signature_2: node_signature_2_arg.into_rust(),
3674                 bitcoin_signature_1: bitcoin_signature_1_arg.into_rust(),
3675                 bitcoin_signature_2: bitcoin_signature_2_arg.into_rust(),
3676                 contents: *unsafe { Box::from_raw(contents_arg.take_inner()) },
3677         }), is_owned: true }
3678 }
3679 impl Clone for ChannelAnnouncement {
3680         fn clone(&self) -> Self {
3681                 Self {
3682                         inner: if <*mut nativeChannelAnnouncement>::is_null(self.inner) { core::ptr::null_mut() } else {
3683                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
3684                         is_owned: true,
3685                 }
3686         }
3687 }
3688 #[allow(unused)]
3689 /// Used only if an object of this type is returned as a trait impl by a method
3690 pub(crate) extern "C" fn ChannelAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void {
3691         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelAnnouncement)).clone() })) as *mut c_void
3692 }
3693 #[no_mangle]
3694 /// Creates a copy of the ChannelAnnouncement
3695 pub extern "C" fn ChannelAnnouncement_clone(orig: &ChannelAnnouncement) -> ChannelAnnouncement {
3696         orig.clone()
3697 }
3698
3699 use lightning::ln::msgs::UnsignedChannelUpdate as nativeUnsignedChannelUpdateImport;
3700 pub(crate) type nativeUnsignedChannelUpdate = nativeUnsignedChannelUpdateImport;
3701
3702 /// The unsigned part of a channel_update
3703 #[must_use]
3704 #[repr(C)]
3705 pub struct UnsignedChannelUpdate {
3706         /// A pointer to the opaque Rust object.
3707
3708         /// Nearly everywhere, inner must be non-null, however in places where
3709         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3710         pub inner: *mut nativeUnsignedChannelUpdate,
3711         /// Indicates that this is the only struct which contains the same pointer.
3712
3713         /// Rust functions which take ownership of an object provided via an argument require
3714         /// this to be true and invalidate the object pointed to by inner.
3715         pub is_owned: bool,
3716 }
3717
3718 impl Drop for UnsignedChannelUpdate {
3719         fn drop(&mut self) {
3720                 if self.is_owned && !<*mut nativeUnsignedChannelUpdate>::is_null(self.inner) {
3721                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
3722                 }
3723         }
3724 }
3725 /// Frees any resources used by the UnsignedChannelUpdate, if is_owned is set and inner is non-NULL.
3726 #[no_mangle]
3727 pub extern "C" fn UnsignedChannelUpdate_free(this_obj: UnsignedChannelUpdate) { }
3728 #[allow(unused)]
3729 /// Used only if an object of this type is returned as a trait impl by a method
3730 pub(crate) extern "C" fn UnsignedChannelUpdate_free_void(this_ptr: *mut c_void) {
3731         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUnsignedChannelUpdate); }
3732 }
3733 #[allow(unused)]
3734 impl UnsignedChannelUpdate {
3735         pub(crate) fn get_native_ref(&self) -> &'static nativeUnsignedChannelUpdate {
3736                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
3737         }
3738         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeUnsignedChannelUpdate {
3739                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
3740         }
3741         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3742         pub(crate) fn take_inner(mut self) -> *mut nativeUnsignedChannelUpdate {
3743                 assert!(self.is_owned);
3744                 let ret = ObjOps::untweak_ptr(self.inner);
3745                 self.inner = core::ptr::null_mut();
3746                 ret
3747         }
3748 }
3749 /// The genesis hash of the blockchain where the channel is to be opened
3750 #[no_mangle]
3751 pub extern "C" fn UnsignedChannelUpdate_get_chain_hash(this_ptr: &UnsignedChannelUpdate) -> *const [u8; 32] {
3752         let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
3753         inner_val.as_inner()
3754 }
3755 /// The genesis hash of the blockchain where the channel is to be opened
3756 #[no_mangle]
3757 pub extern "C" fn UnsignedChannelUpdate_set_chain_hash(this_ptr: &mut UnsignedChannelUpdate, mut val: crate::c_types::ThirtyTwoBytes) {
3758         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
3759 }
3760 /// The short channel ID
3761 #[no_mangle]
3762 pub extern "C" fn UnsignedChannelUpdate_get_short_channel_id(this_ptr: &UnsignedChannelUpdate) -> u64 {
3763         let mut inner_val = &mut this_ptr.get_native_mut_ref().short_channel_id;
3764         *inner_val
3765 }
3766 /// The short channel ID
3767 #[no_mangle]
3768 pub extern "C" fn UnsignedChannelUpdate_set_short_channel_id(this_ptr: &mut UnsignedChannelUpdate, mut val: u64) {
3769         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_id = val;
3770 }
3771 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
3772 #[no_mangle]
3773 pub extern "C" fn UnsignedChannelUpdate_get_timestamp(this_ptr: &UnsignedChannelUpdate) -> u32 {
3774         let mut inner_val = &mut this_ptr.get_native_mut_ref().timestamp;
3775         *inner_val
3776 }
3777 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
3778 #[no_mangle]
3779 pub extern "C" fn UnsignedChannelUpdate_set_timestamp(this_ptr: &mut UnsignedChannelUpdate, mut val: u32) {
3780         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.timestamp = val;
3781 }
3782 /// Channel flags
3783 #[no_mangle]
3784 pub extern "C" fn UnsignedChannelUpdate_get_flags(this_ptr: &UnsignedChannelUpdate) -> u8 {
3785         let mut inner_val = &mut this_ptr.get_native_mut_ref().flags;
3786         *inner_val
3787 }
3788 /// Channel flags
3789 #[no_mangle]
3790 pub extern "C" fn UnsignedChannelUpdate_set_flags(this_ptr: &mut UnsignedChannelUpdate, mut val: u8) {
3791         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.flags = val;
3792 }
3793 /// The number of blocks such that if:
3794 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
3795 /// then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
3796 /// the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
3797 /// cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
3798 /// then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
3799 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
3800 /// constructing the route.
3801 #[no_mangle]
3802 pub extern "C" fn UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: &UnsignedChannelUpdate) -> u16 {
3803         let mut inner_val = &mut this_ptr.get_native_mut_ref().cltv_expiry_delta;
3804         *inner_val
3805 }
3806 /// The number of blocks such that if:
3807 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
3808 /// then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
3809 /// the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
3810 /// cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
3811 /// then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
3812 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
3813 /// constructing the route.
3814 #[no_mangle]
3815 pub extern "C" fn UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: &mut UnsignedChannelUpdate, mut val: u16) {
3816         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.cltv_expiry_delta = val;
3817 }
3818 /// The minimum HTLC size incoming to sender, in milli-satoshi
3819 #[no_mangle]
3820 pub extern "C" fn UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: &UnsignedChannelUpdate) -> u64 {
3821         let mut inner_val = &mut this_ptr.get_native_mut_ref().htlc_minimum_msat;
3822         *inner_val
3823 }
3824 /// The minimum HTLC size incoming to sender, in milli-satoshi
3825 #[no_mangle]
3826 pub extern "C" fn UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: &mut UnsignedChannelUpdate, mut val: u64) {
3827         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.htlc_minimum_msat = val;
3828 }
3829 /// The base HTLC fee charged by sender, in milli-satoshi
3830 #[no_mangle]
3831 pub extern "C" fn UnsignedChannelUpdate_get_fee_base_msat(this_ptr: &UnsignedChannelUpdate) -> u32 {
3832         let mut inner_val = &mut this_ptr.get_native_mut_ref().fee_base_msat;
3833         *inner_val
3834 }
3835 /// The base HTLC fee charged by sender, in milli-satoshi
3836 #[no_mangle]
3837 pub extern "C" fn UnsignedChannelUpdate_set_fee_base_msat(this_ptr: &mut UnsignedChannelUpdate, mut val: u32) {
3838         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fee_base_msat = val;
3839 }
3840 /// The amount to fee multiplier, in micro-satoshi
3841 #[no_mangle]
3842 pub extern "C" fn UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: &UnsignedChannelUpdate) -> u32 {
3843         let mut inner_val = &mut this_ptr.get_native_mut_ref().fee_proportional_millionths;
3844         *inner_val
3845 }
3846 /// The amount to fee multiplier, in micro-satoshi
3847 #[no_mangle]
3848 pub extern "C" fn UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: &mut UnsignedChannelUpdate, mut val: u32) {
3849         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.fee_proportional_millionths = val;
3850 }
3851 impl Clone for UnsignedChannelUpdate {
3852         fn clone(&self) -> Self {
3853                 Self {
3854                         inner: if <*mut nativeUnsignedChannelUpdate>::is_null(self.inner) { core::ptr::null_mut() } else {
3855                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
3856                         is_owned: true,
3857                 }
3858         }
3859 }
3860 #[allow(unused)]
3861 /// Used only if an object of this type is returned as a trait impl by a method
3862 pub(crate) extern "C" fn UnsignedChannelUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void {
3863         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedChannelUpdate)).clone() })) as *mut c_void
3864 }
3865 #[no_mangle]
3866 /// Creates a copy of the UnsignedChannelUpdate
3867 pub extern "C" fn UnsignedChannelUpdate_clone(orig: &UnsignedChannelUpdate) -> UnsignedChannelUpdate {
3868         orig.clone()
3869 }
3870
3871 use lightning::ln::msgs::ChannelUpdate as nativeChannelUpdateImport;
3872 pub(crate) type nativeChannelUpdate = nativeChannelUpdateImport;
3873
3874 /// A channel_update message to be sent or received from a peer
3875 #[must_use]
3876 #[repr(C)]
3877 pub struct ChannelUpdate {
3878         /// A pointer to the opaque Rust object.
3879
3880         /// Nearly everywhere, inner must be non-null, however in places where
3881         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3882         pub inner: *mut nativeChannelUpdate,
3883         /// Indicates that this is the only struct which contains the same pointer.
3884
3885         /// Rust functions which take ownership of an object provided via an argument require
3886         /// this to be true and invalidate the object pointed to by inner.
3887         pub is_owned: bool,
3888 }
3889
3890 impl Drop for ChannelUpdate {
3891         fn drop(&mut self) {
3892                 if self.is_owned && !<*mut nativeChannelUpdate>::is_null(self.inner) {
3893                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
3894                 }
3895         }
3896 }
3897 /// Frees any resources used by the ChannelUpdate, if is_owned is set and inner is non-NULL.
3898 #[no_mangle]
3899 pub extern "C" fn ChannelUpdate_free(this_obj: ChannelUpdate) { }
3900 #[allow(unused)]
3901 /// Used only if an object of this type is returned as a trait impl by a method
3902 pub(crate) extern "C" fn ChannelUpdate_free_void(this_ptr: *mut c_void) {
3903         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelUpdate); }
3904 }
3905 #[allow(unused)]
3906 impl ChannelUpdate {
3907         pub(crate) fn get_native_ref(&self) -> &'static nativeChannelUpdate {
3908                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
3909         }
3910         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeChannelUpdate {
3911                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
3912         }
3913         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3914         pub(crate) fn take_inner(mut self) -> *mut nativeChannelUpdate {
3915                 assert!(self.is_owned);
3916                 let ret = ObjOps::untweak_ptr(self.inner);
3917                 self.inner = core::ptr::null_mut();
3918                 ret
3919         }
3920 }
3921 /// A signature of the channel update
3922 #[no_mangle]
3923 pub extern "C" fn ChannelUpdate_get_signature(this_ptr: &ChannelUpdate) -> crate::c_types::Signature {
3924         let mut inner_val = &mut this_ptr.get_native_mut_ref().signature;
3925         crate::c_types::Signature::from_rust(&inner_val)
3926 }
3927 /// A signature of the channel update
3928 #[no_mangle]
3929 pub extern "C" fn ChannelUpdate_set_signature(this_ptr: &mut ChannelUpdate, mut val: crate::c_types::Signature) {
3930         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.signature = val.into_rust();
3931 }
3932 /// The actual channel update
3933 #[no_mangle]
3934 pub extern "C" fn ChannelUpdate_get_contents(this_ptr: &ChannelUpdate) -> crate::lightning::ln::msgs::UnsignedChannelUpdate {
3935         let mut inner_val = &mut this_ptr.get_native_mut_ref().contents;
3936         crate::lightning::ln::msgs::UnsignedChannelUpdate { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::msgs::UnsignedChannelUpdate<>) as *mut _) }, is_owned: false }
3937 }
3938 /// The actual channel update
3939 #[no_mangle]
3940 pub extern "C" fn ChannelUpdate_set_contents(this_ptr: &mut ChannelUpdate, mut val: crate::lightning::ln::msgs::UnsignedChannelUpdate) {
3941         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.contents = *unsafe { Box::from_raw(val.take_inner()) };
3942 }
3943 /// Constructs a new ChannelUpdate given each field
3944 #[must_use]
3945 #[no_mangle]
3946 pub extern "C" fn ChannelUpdate_new(mut signature_arg: crate::c_types::Signature, mut contents_arg: crate::lightning::ln::msgs::UnsignedChannelUpdate) -> ChannelUpdate {
3947         ChannelUpdate { inner: ObjOps::heap_alloc(nativeChannelUpdate {
3948                 signature: signature_arg.into_rust(),
3949                 contents: *unsafe { Box::from_raw(contents_arg.take_inner()) },
3950         }), is_owned: true }
3951 }
3952 impl Clone for ChannelUpdate {
3953         fn clone(&self) -> Self {
3954                 Self {
3955                         inner: if <*mut nativeChannelUpdate>::is_null(self.inner) { core::ptr::null_mut() } else {
3956                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
3957                         is_owned: true,
3958                 }
3959         }
3960 }
3961 #[allow(unused)]
3962 /// Used only if an object of this type is returned as a trait impl by a method
3963 pub(crate) extern "C" fn ChannelUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void {
3964         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelUpdate)).clone() })) as *mut c_void
3965 }
3966 #[no_mangle]
3967 /// Creates a copy of the ChannelUpdate
3968 pub extern "C" fn ChannelUpdate_clone(orig: &ChannelUpdate) -> ChannelUpdate {
3969         orig.clone()
3970 }
3971
3972 use lightning::ln::msgs::QueryChannelRange as nativeQueryChannelRangeImport;
3973 pub(crate) type nativeQueryChannelRange = nativeQueryChannelRangeImport;
3974
3975 /// A query_channel_range message is used to query a peer for channel
3976 /// UTXOs in a range of blocks. The recipient of a query makes a best
3977 /// effort to reply to the query using one or more reply_channel_range
3978 /// messages.
3979 #[must_use]
3980 #[repr(C)]
3981 pub struct QueryChannelRange {
3982         /// A pointer to the opaque Rust object.
3983
3984         /// Nearly everywhere, inner must be non-null, however in places where
3985         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3986         pub inner: *mut nativeQueryChannelRange,
3987         /// Indicates that this is the only struct which contains the same pointer.
3988
3989         /// Rust functions which take ownership of an object provided via an argument require
3990         /// this to be true and invalidate the object pointed to by inner.
3991         pub is_owned: bool,
3992 }
3993
3994 impl Drop for QueryChannelRange {
3995         fn drop(&mut self) {
3996                 if self.is_owned && !<*mut nativeQueryChannelRange>::is_null(self.inner) {
3997                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
3998                 }
3999         }
4000 }
4001 /// Frees any resources used by the QueryChannelRange, if is_owned is set and inner is non-NULL.
4002 #[no_mangle]
4003 pub extern "C" fn QueryChannelRange_free(this_obj: QueryChannelRange) { }
4004 #[allow(unused)]
4005 /// Used only if an object of this type is returned as a trait impl by a method
4006 pub(crate) extern "C" fn QueryChannelRange_free_void(this_ptr: *mut c_void) {
4007         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeQueryChannelRange); }
4008 }
4009 #[allow(unused)]
4010 impl QueryChannelRange {
4011         pub(crate) fn get_native_ref(&self) -> &'static nativeQueryChannelRange {
4012                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
4013         }
4014         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeQueryChannelRange {
4015                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
4016         }
4017         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4018         pub(crate) fn take_inner(mut self) -> *mut nativeQueryChannelRange {
4019                 assert!(self.is_owned);
4020                 let ret = ObjOps::untweak_ptr(self.inner);
4021                 self.inner = core::ptr::null_mut();
4022                 ret
4023         }
4024 }
4025 /// The genesis hash of the blockchain being queried
4026 #[no_mangle]
4027 pub extern "C" fn QueryChannelRange_get_chain_hash(this_ptr: &QueryChannelRange) -> *const [u8; 32] {
4028         let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
4029         inner_val.as_inner()
4030 }
4031 /// The genesis hash of the blockchain being queried
4032 #[no_mangle]
4033 pub extern "C" fn QueryChannelRange_set_chain_hash(this_ptr: &mut QueryChannelRange, mut val: crate::c_types::ThirtyTwoBytes) {
4034         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
4035 }
4036 /// The height of the first block for the channel UTXOs being queried
4037 #[no_mangle]
4038 pub extern "C" fn QueryChannelRange_get_first_blocknum(this_ptr: &QueryChannelRange) -> u32 {
4039         let mut inner_val = &mut this_ptr.get_native_mut_ref().first_blocknum;
4040         *inner_val
4041 }
4042 /// The height of the first block for the channel UTXOs being queried
4043 #[no_mangle]
4044 pub extern "C" fn QueryChannelRange_set_first_blocknum(this_ptr: &mut QueryChannelRange, mut val: u32) {
4045         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.first_blocknum = val;
4046 }
4047 /// The number of blocks to include in the query results
4048 #[no_mangle]
4049 pub extern "C" fn QueryChannelRange_get_number_of_blocks(this_ptr: &QueryChannelRange) -> u32 {
4050         let mut inner_val = &mut this_ptr.get_native_mut_ref().number_of_blocks;
4051         *inner_val
4052 }
4053 /// The number of blocks to include in the query results
4054 #[no_mangle]
4055 pub extern "C" fn QueryChannelRange_set_number_of_blocks(this_ptr: &mut QueryChannelRange, mut val: u32) {
4056         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.number_of_blocks = val;
4057 }
4058 /// Constructs a new QueryChannelRange given each field
4059 #[must_use]
4060 #[no_mangle]
4061 pub extern "C" fn QueryChannelRange_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut first_blocknum_arg: u32, mut number_of_blocks_arg: u32) -> QueryChannelRange {
4062         QueryChannelRange { inner: ObjOps::heap_alloc(nativeQueryChannelRange {
4063                 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
4064                 first_blocknum: first_blocknum_arg,
4065                 number_of_blocks: number_of_blocks_arg,
4066         }), is_owned: true }
4067 }
4068 impl Clone for QueryChannelRange {
4069         fn clone(&self) -> Self {
4070                 Self {
4071                         inner: if <*mut nativeQueryChannelRange>::is_null(self.inner) { core::ptr::null_mut() } else {
4072                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
4073                         is_owned: true,
4074                 }
4075         }
4076 }
4077 #[allow(unused)]
4078 /// Used only if an object of this type is returned as a trait impl by a method
4079 pub(crate) extern "C" fn QueryChannelRange_clone_void(this_ptr: *const c_void) -> *mut c_void {
4080         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeQueryChannelRange)).clone() })) as *mut c_void
4081 }
4082 #[no_mangle]
4083 /// Creates a copy of the QueryChannelRange
4084 pub extern "C" fn QueryChannelRange_clone(orig: &QueryChannelRange) -> QueryChannelRange {
4085         orig.clone()
4086 }
4087
4088 use lightning::ln::msgs::ReplyChannelRange as nativeReplyChannelRangeImport;
4089 pub(crate) type nativeReplyChannelRange = nativeReplyChannelRangeImport;
4090
4091 /// A reply_channel_range message is a reply to a query_channel_range
4092 /// message. Multiple reply_channel_range messages can be sent in reply
4093 /// to a single query_channel_range message. The query recipient makes a
4094 /// best effort to respond based on their local network view which may
4095 /// not be a perfect view of the network. The short_channel_ids in the
4096 /// reply are encoded. We only support encoding_type=0 uncompressed
4097 /// serialization and do not support encoding_type=1 zlib serialization.
4098 #[must_use]
4099 #[repr(C)]
4100 pub struct ReplyChannelRange {
4101         /// A pointer to the opaque Rust object.
4102
4103         /// Nearly everywhere, inner must be non-null, however in places where
4104         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
4105         pub inner: *mut nativeReplyChannelRange,
4106         /// Indicates that this is the only struct which contains the same pointer.
4107
4108         /// Rust functions which take ownership of an object provided via an argument require
4109         /// this to be true and invalidate the object pointed to by inner.
4110         pub is_owned: bool,
4111 }
4112
4113 impl Drop for ReplyChannelRange {
4114         fn drop(&mut self) {
4115                 if self.is_owned && !<*mut nativeReplyChannelRange>::is_null(self.inner) {
4116                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
4117                 }
4118         }
4119 }
4120 /// Frees any resources used by the ReplyChannelRange, if is_owned is set and inner is non-NULL.
4121 #[no_mangle]
4122 pub extern "C" fn ReplyChannelRange_free(this_obj: ReplyChannelRange) { }
4123 #[allow(unused)]
4124 /// Used only if an object of this type is returned as a trait impl by a method
4125 pub(crate) extern "C" fn ReplyChannelRange_free_void(this_ptr: *mut c_void) {
4126         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeReplyChannelRange); }
4127 }
4128 #[allow(unused)]
4129 impl ReplyChannelRange {
4130         pub(crate) fn get_native_ref(&self) -> &'static nativeReplyChannelRange {
4131                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
4132         }
4133         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeReplyChannelRange {
4134                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
4135         }
4136         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4137         pub(crate) fn take_inner(mut self) -> *mut nativeReplyChannelRange {
4138                 assert!(self.is_owned);
4139                 let ret = ObjOps::untweak_ptr(self.inner);
4140                 self.inner = core::ptr::null_mut();
4141                 ret
4142         }
4143 }
4144 /// The genesis hash of the blockchain being queried
4145 #[no_mangle]
4146 pub extern "C" fn ReplyChannelRange_get_chain_hash(this_ptr: &ReplyChannelRange) -> *const [u8; 32] {
4147         let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
4148         inner_val.as_inner()
4149 }
4150 /// The genesis hash of the blockchain being queried
4151 #[no_mangle]
4152 pub extern "C" fn ReplyChannelRange_set_chain_hash(this_ptr: &mut ReplyChannelRange, mut val: crate::c_types::ThirtyTwoBytes) {
4153         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
4154 }
4155 /// The height of the first block in the range of the reply
4156 #[no_mangle]
4157 pub extern "C" fn ReplyChannelRange_get_first_blocknum(this_ptr: &ReplyChannelRange) -> u32 {
4158         let mut inner_val = &mut this_ptr.get_native_mut_ref().first_blocknum;
4159         *inner_val
4160 }
4161 /// The height of the first block in the range of the reply
4162 #[no_mangle]
4163 pub extern "C" fn ReplyChannelRange_set_first_blocknum(this_ptr: &mut ReplyChannelRange, mut val: u32) {
4164         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.first_blocknum = val;
4165 }
4166 /// The number of blocks included in the range of the reply
4167 #[no_mangle]
4168 pub extern "C" fn ReplyChannelRange_get_number_of_blocks(this_ptr: &ReplyChannelRange) -> u32 {
4169         let mut inner_val = &mut this_ptr.get_native_mut_ref().number_of_blocks;
4170         *inner_val
4171 }
4172 /// The number of blocks included in the range of the reply
4173 #[no_mangle]
4174 pub extern "C" fn ReplyChannelRange_set_number_of_blocks(this_ptr: &mut ReplyChannelRange, mut val: u32) {
4175         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.number_of_blocks = val;
4176 }
4177 /// True when this is the final reply for a query
4178 #[no_mangle]
4179 pub extern "C" fn ReplyChannelRange_get_sync_complete(this_ptr: &ReplyChannelRange) -> bool {
4180         let mut inner_val = &mut this_ptr.get_native_mut_ref().sync_complete;
4181         *inner_val
4182 }
4183 /// True when this is the final reply for a query
4184 #[no_mangle]
4185 pub extern "C" fn ReplyChannelRange_set_sync_complete(this_ptr: &mut ReplyChannelRange, mut val: bool) {
4186         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.sync_complete = val;
4187 }
4188 /// The short_channel_ids in the channel range
4189 #[no_mangle]
4190 pub extern "C" fn ReplyChannelRange_set_short_channel_ids(this_ptr: &mut ReplyChannelRange, mut val: crate::c_types::derived::CVec_u64Z) {
4191         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); };
4192         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_ids = local_val;
4193 }
4194 /// Constructs a new ReplyChannelRange given each field
4195 #[must_use]
4196 #[no_mangle]
4197 pub extern "C" fn ReplyChannelRange_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut first_blocknum_arg: u32, mut number_of_blocks_arg: u32, mut sync_complete_arg: bool, mut short_channel_ids_arg: crate::c_types::derived::CVec_u64Z) -> ReplyChannelRange {
4198         let mut local_short_channel_ids_arg = Vec::new(); for mut item in short_channel_ids_arg.into_rust().drain(..) { local_short_channel_ids_arg.push( { item }); };
4199         ReplyChannelRange { inner: ObjOps::heap_alloc(nativeReplyChannelRange {
4200                 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
4201                 first_blocknum: first_blocknum_arg,
4202                 number_of_blocks: number_of_blocks_arg,
4203                 sync_complete: sync_complete_arg,
4204                 short_channel_ids: local_short_channel_ids_arg,
4205         }), is_owned: true }
4206 }
4207 impl Clone for ReplyChannelRange {
4208         fn clone(&self) -> Self {
4209                 Self {
4210                         inner: if <*mut nativeReplyChannelRange>::is_null(self.inner) { core::ptr::null_mut() } else {
4211                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
4212                         is_owned: true,
4213                 }
4214         }
4215 }
4216 #[allow(unused)]
4217 /// Used only if an object of this type is returned as a trait impl by a method
4218 pub(crate) extern "C" fn ReplyChannelRange_clone_void(this_ptr: *const c_void) -> *mut c_void {
4219         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeReplyChannelRange)).clone() })) as *mut c_void
4220 }
4221 #[no_mangle]
4222 /// Creates a copy of the ReplyChannelRange
4223 pub extern "C" fn ReplyChannelRange_clone(orig: &ReplyChannelRange) -> ReplyChannelRange {
4224         orig.clone()
4225 }
4226
4227 use lightning::ln::msgs::QueryShortChannelIds as nativeQueryShortChannelIdsImport;
4228 pub(crate) type nativeQueryShortChannelIds = nativeQueryShortChannelIdsImport;
4229
4230 /// A query_short_channel_ids message is used to query a peer for
4231 /// routing gossip messages related to one or more short_channel_ids.
4232 /// The query recipient will reply with the latest, if available,
4233 /// channel_announcement, channel_update and node_announcement messages
4234 /// it maintains for the requested short_channel_ids followed by a
4235 /// reply_short_channel_ids_end message. The short_channel_ids sent in
4236 /// this query are encoded. We only support encoding_type=0 uncompressed
4237 /// serialization and do not support encoding_type=1 zlib serialization.
4238 #[must_use]
4239 #[repr(C)]
4240 pub struct QueryShortChannelIds {
4241         /// A pointer to the opaque Rust object.
4242
4243         /// Nearly everywhere, inner must be non-null, however in places where
4244         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
4245         pub inner: *mut nativeQueryShortChannelIds,
4246         /// Indicates that this is the only struct which contains the same pointer.
4247
4248         /// Rust functions which take ownership of an object provided via an argument require
4249         /// this to be true and invalidate the object pointed to by inner.
4250         pub is_owned: bool,
4251 }
4252
4253 impl Drop for QueryShortChannelIds {
4254         fn drop(&mut self) {
4255                 if self.is_owned && !<*mut nativeQueryShortChannelIds>::is_null(self.inner) {
4256                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
4257                 }
4258         }
4259 }
4260 /// Frees any resources used by the QueryShortChannelIds, if is_owned is set and inner is non-NULL.
4261 #[no_mangle]
4262 pub extern "C" fn QueryShortChannelIds_free(this_obj: QueryShortChannelIds) { }
4263 #[allow(unused)]
4264 /// Used only if an object of this type is returned as a trait impl by a method
4265 pub(crate) extern "C" fn QueryShortChannelIds_free_void(this_ptr: *mut c_void) {
4266         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeQueryShortChannelIds); }
4267 }
4268 #[allow(unused)]
4269 impl QueryShortChannelIds {
4270         pub(crate) fn get_native_ref(&self) -> &'static nativeQueryShortChannelIds {
4271                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
4272         }
4273         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeQueryShortChannelIds {
4274                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
4275         }
4276         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4277         pub(crate) fn take_inner(mut self) -> *mut nativeQueryShortChannelIds {
4278                 assert!(self.is_owned);
4279                 let ret = ObjOps::untweak_ptr(self.inner);
4280                 self.inner = core::ptr::null_mut();
4281                 ret
4282         }
4283 }
4284 /// The genesis hash of the blockchain being queried
4285 #[no_mangle]
4286 pub extern "C" fn QueryShortChannelIds_get_chain_hash(this_ptr: &QueryShortChannelIds) -> *const [u8; 32] {
4287         let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
4288         inner_val.as_inner()
4289 }
4290 /// The genesis hash of the blockchain being queried
4291 #[no_mangle]
4292 pub extern "C" fn QueryShortChannelIds_set_chain_hash(this_ptr: &mut QueryShortChannelIds, mut val: crate::c_types::ThirtyTwoBytes) {
4293         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
4294 }
4295 /// The short_channel_ids that are being queried
4296 #[no_mangle]
4297 pub extern "C" fn QueryShortChannelIds_set_short_channel_ids(this_ptr: &mut QueryShortChannelIds, mut val: crate::c_types::derived::CVec_u64Z) {
4298         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); };
4299         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.short_channel_ids = local_val;
4300 }
4301 /// Constructs a new QueryShortChannelIds given each field
4302 #[must_use]
4303 #[no_mangle]
4304 pub extern "C" fn QueryShortChannelIds_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut short_channel_ids_arg: crate::c_types::derived::CVec_u64Z) -> QueryShortChannelIds {
4305         let mut local_short_channel_ids_arg = Vec::new(); for mut item in short_channel_ids_arg.into_rust().drain(..) { local_short_channel_ids_arg.push( { item }); };
4306         QueryShortChannelIds { inner: ObjOps::heap_alloc(nativeQueryShortChannelIds {
4307                 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
4308                 short_channel_ids: local_short_channel_ids_arg,
4309         }), is_owned: true }
4310 }
4311 impl Clone for QueryShortChannelIds {
4312         fn clone(&self) -> Self {
4313                 Self {
4314                         inner: if <*mut nativeQueryShortChannelIds>::is_null(self.inner) { core::ptr::null_mut() } else {
4315                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
4316                         is_owned: true,
4317                 }
4318         }
4319 }
4320 #[allow(unused)]
4321 /// Used only if an object of this type is returned as a trait impl by a method
4322 pub(crate) extern "C" fn QueryShortChannelIds_clone_void(this_ptr: *const c_void) -> *mut c_void {
4323         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeQueryShortChannelIds)).clone() })) as *mut c_void
4324 }
4325 #[no_mangle]
4326 /// Creates a copy of the QueryShortChannelIds
4327 pub extern "C" fn QueryShortChannelIds_clone(orig: &QueryShortChannelIds) -> QueryShortChannelIds {
4328         orig.clone()
4329 }
4330
4331 use lightning::ln::msgs::ReplyShortChannelIdsEnd as nativeReplyShortChannelIdsEndImport;
4332 pub(crate) type nativeReplyShortChannelIdsEnd = nativeReplyShortChannelIdsEndImport;
4333
4334 /// A reply_short_channel_ids_end message is sent as a reply to a
4335 /// query_short_channel_ids message. The query recipient makes a best
4336 /// effort to respond based on their local network view which may not be
4337 /// a perfect view of the network.
4338 #[must_use]
4339 #[repr(C)]
4340 pub struct ReplyShortChannelIdsEnd {
4341         /// A pointer to the opaque Rust object.
4342
4343         /// Nearly everywhere, inner must be non-null, however in places where
4344         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
4345         pub inner: *mut nativeReplyShortChannelIdsEnd,
4346         /// Indicates that this is the only struct which contains the same pointer.
4347
4348         /// Rust functions which take ownership of an object provided via an argument require
4349         /// this to be true and invalidate the object pointed to by inner.
4350         pub is_owned: bool,
4351 }
4352
4353 impl Drop for ReplyShortChannelIdsEnd {
4354         fn drop(&mut self) {
4355                 if self.is_owned && !<*mut nativeReplyShortChannelIdsEnd>::is_null(self.inner) {
4356                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
4357                 }
4358         }
4359 }
4360 /// Frees any resources used by the ReplyShortChannelIdsEnd, if is_owned is set and inner is non-NULL.
4361 #[no_mangle]
4362 pub extern "C" fn ReplyShortChannelIdsEnd_free(this_obj: ReplyShortChannelIdsEnd) { }
4363 #[allow(unused)]
4364 /// Used only if an object of this type is returned as a trait impl by a method
4365 pub(crate) extern "C" fn ReplyShortChannelIdsEnd_free_void(this_ptr: *mut c_void) {
4366         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeReplyShortChannelIdsEnd); }
4367 }
4368 #[allow(unused)]
4369 impl ReplyShortChannelIdsEnd {
4370         pub(crate) fn get_native_ref(&self) -> &'static nativeReplyShortChannelIdsEnd {
4371                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
4372         }
4373         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeReplyShortChannelIdsEnd {
4374                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
4375         }
4376         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4377         pub(crate) fn take_inner(mut self) -> *mut nativeReplyShortChannelIdsEnd {
4378                 assert!(self.is_owned);
4379                 let ret = ObjOps::untweak_ptr(self.inner);
4380                 self.inner = core::ptr::null_mut();
4381                 ret
4382         }
4383 }
4384 /// The genesis hash of the blockchain that was queried
4385 #[no_mangle]
4386 pub extern "C" fn ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: &ReplyShortChannelIdsEnd) -> *const [u8; 32] {
4387         let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
4388         inner_val.as_inner()
4389 }
4390 /// The genesis hash of the blockchain that was queried
4391 #[no_mangle]
4392 pub extern "C" fn ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: &mut ReplyShortChannelIdsEnd, mut val: crate::c_types::ThirtyTwoBytes) {
4393         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
4394 }
4395 /// Indicates if the query recipient maintains up-to-date channel
4396 /// information for the chain_hash
4397 #[no_mangle]
4398 pub extern "C" fn ReplyShortChannelIdsEnd_get_full_information(this_ptr: &ReplyShortChannelIdsEnd) -> bool {
4399         let mut inner_val = &mut this_ptr.get_native_mut_ref().full_information;
4400         *inner_val
4401 }
4402 /// Indicates if the query recipient maintains up-to-date channel
4403 /// information for the chain_hash
4404 #[no_mangle]
4405 pub extern "C" fn ReplyShortChannelIdsEnd_set_full_information(this_ptr: &mut ReplyShortChannelIdsEnd, mut val: bool) {
4406         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.full_information = val;
4407 }
4408 /// Constructs a new ReplyShortChannelIdsEnd given each field
4409 #[must_use]
4410 #[no_mangle]
4411 pub extern "C" fn ReplyShortChannelIdsEnd_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut full_information_arg: bool) -> ReplyShortChannelIdsEnd {
4412         ReplyShortChannelIdsEnd { inner: ObjOps::heap_alloc(nativeReplyShortChannelIdsEnd {
4413                 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
4414                 full_information: full_information_arg,
4415         }), is_owned: true }
4416 }
4417 impl Clone for ReplyShortChannelIdsEnd {
4418         fn clone(&self) -> Self {
4419                 Self {
4420                         inner: if <*mut nativeReplyShortChannelIdsEnd>::is_null(self.inner) { core::ptr::null_mut() } else {
4421                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
4422                         is_owned: true,
4423                 }
4424         }
4425 }
4426 #[allow(unused)]
4427 /// Used only if an object of this type is returned as a trait impl by a method
4428 pub(crate) extern "C" fn ReplyShortChannelIdsEnd_clone_void(this_ptr: *const c_void) -> *mut c_void {
4429         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeReplyShortChannelIdsEnd)).clone() })) as *mut c_void
4430 }
4431 #[no_mangle]
4432 /// Creates a copy of the ReplyShortChannelIdsEnd
4433 pub extern "C" fn ReplyShortChannelIdsEnd_clone(orig: &ReplyShortChannelIdsEnd) -> ReplyShortChannelIdsEnd {
4434         orig.clone()
4435 }
4436
4437 use lightning::ln::msgs::GossipTimestampFilter as nativeGossipTimestampFilterImport;
4438 pub(crate) type nativeGossipTimestampFilter = nativeGossipTimestampFilterImport;
4439
4440 /// A gossip_timestamp_filter message is used by a node to request
4441 /// gossip relay for messages in the requested time range when the
4442 /// gossip_queries feature has been negotiated.
4443 #[must_use]
4444 #[repr(C)]
4445 pub struct GossipTimestampFilter {
4446         /// A pointer to the opaque Rust object.
4447
4448         /// Nearly everywhere, inner must be non-null, however in places where
4449         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
4450         pub inner: *mut nativeGossipTimestampFilter,
4451         /// Indicates that this is the only struct which contains the same pointer.
4452
4453         /// Rust functions which take ownership of an object provided via an argument require
4454         /// this to be true and invalidate the object pointed to by inner.
4455         pub is_owned: bool,
4456 }
4457
4458 impl Drop for GossipTimestampFilter {
4459         fn drop(&mut self) {
4460                 if self.is_owned && !<*mut nativeGossipTimestampFilter>::is_null(self.inner) {
4461                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
4462                 }
4463         }
4464 }
4465 /// Frees any resources used by the GossipTimestampFilter, if is_owned is set and inner is non-NULL.
4466 #[no_mangle]
4467 pub extern "C" fn GossipTimestampFilter_free(this_obj: GossipTimestampFilter) { }
4468 #[allow(unused)]
4469 /// Used only if an object of this type is returned as a trait impl by a method
4470 pub(crate) extern "C" fn GossipTimestampFilter_free_void(this_ptr: *mut c_void) {
4471         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeGossipTimestampFilter); }
4472 }
4473 #[allow(unused)]
4474 impl GossipTimestampFilter {
4475         pub(crate) fn get_native_ref(&self) -> &'static nativeGossipTimestampFilter {
4476                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
4477         }
4478         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeGossipTimestampFilter {
4479                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
4480         }
4481         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4482         pub(crate) fn take_inner(mut self) -> *mut nativeGossipTimestampFilter {
4483                 assert!(self.is_owned);
4484                 let ret = ObjOps::untweak_ptr(self.inner);
4485                 self.inner = core::ptr::null_mut();
4486                 ret
4487         }
4488 }
4489 /// The genesis hash of the blockchain for channel and node information
4490 #[no_mangle]
4491 pub extern "C" fn GossipTimestampFilter_get_chain_hash(this_ptr: &GossipTimestampFilter) -> *const [u8; 32] {
4492         let mut inner_val = &mut this_ptr.get_native_mut_ref().chain_hash;
4493         inner_val.as_inner()
4494 }
4495 /// The genesis hash of the blockchain for channel and node information
4496 #[no_mangle]
4497 pub extern "C" fn GossipTimestampFilter_set_chain_hash(this_ptr: &mut GossipTimestampFilter, mut val: crate::c_types::ThirtyTwoBytes) {
4498         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
4499 }
4500 /// The starting unix timestamp
4501 #[no_mangle]
4502 pub extern "C" fn GossipTimestampFilter_get_first_timestamp(this_ptr: &GossipTimestampFilter) -> u32 {
4503         let mut inner_val = &mut this_ptr.get_native_mut_ref().first_timestamp;
4504         *inner_val
4505 }
4506 /// The starting unix timestamp
4507 #[no_mangle]
4508 pub extern "C" fn GossipTimestampFilter_set_first_timestamp(this_ptr: &mut GossipTimestampFilter, mut val: u32) {
4509         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.first_timestamp = val;
4510 }
4511 /// The range of information in seconds
4512 #[no_mangle]
4513 pub extern "C" fn GossipTimestampFilter_get_timestamp_range(this_ptr: &GossipTimestampFilter) -> u32 {
4514         let mut inner_val = &mut this_ptr.get_native_mut_ref().timestamp_range;
4515         *inner_val
4516 }
4517 /// The range of information in seconds
4518 #[no_mangle]
4519 pub extern "C" fn GossipTimestampFilter_set_timestamp_range(this_ptr: &mut GossipTimestampFilter, mut val: u32) {
4520         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.timestamp_range = val;
4521 }
4522 /// Constructs a new GossipTimestampFilter given each field
4523 #[must_use]
4524 #[no_mangle]
4525 pub extern "C" fn GossipTimestampFilter_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut first_timestamp_arg: u32, mut timestamp_range_arg: u32) -> GossipTimestampFilter {
4526         GossipTimestampFilter { inner: ObjOps::heap_alloc(nativeGossipTimestampFilter {
4527                 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
4528                 first_timestamp: first_timestamp_arg,
4529                 timestamp_range: timestamp_range_arg,
4530         }), is_owned: true }
4531 }
4532 impl Clone for GossipTimestampFilter {
4533         fn clone(&self) -> Self {
4534                 Self {
4535                         inner: if <*mut nativeGossipTimestampFilter>::is_null(self.inner) { core::ptr::null_mut() } else {
4536                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
4537                         is_owned: true,
4538                 }
4539         }
4540 }
4541 #[allow(unused)]
4542 /// Used only if an object of this type is returned as a trait impl by a method
4543 pub(crate) extern "C" fn GossipTimestampFilter_clone_void(this_ptr: *const c_void) -> *mut c_void {
4544         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeGossipTimestampFilter)).clone() })) as *mut c_void
4545 }
4546 #[no_mangle]
4547 /// Creates a copy of the GossipTimestampFilter
4548 pub extern "C" fn GossipTimestampFilter_clone(orig: &GossipTimestampFilter) -> GossipTimestampFilter {
4549         orig.clone()
4550 }
4551 /// Used to put an error message in a LightningError
4552 #[must_use]
4553 #[derive(Clone)]
4554 #[repr(C)]
4555 pub enum ErrorAction {
4556         /// The peer took some action which made us think they were useless. Disconnect them.
4557         DisconnectPeer {
4558                 /// An error message which we should make an effort to send before we disconnect.
4559                 ///
4560                 /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
4561                 msg: crate::lightning::ln::msgs::ErrorMessage,
4562         },
4563         /// The peer did something harmless that we weren't able to process, just log and ignore
4564         IgnoreError,
4565         /// The peer did something harmless that we weren't able to meaningfully process.
4566         /// If the error is logged, log it at the given level.
4567         IgnoreAndLog(crate::lightning::util::logger::Level),
4568         /// The peer provided us with a gossip message which we'd already seen. In most cases this
4569         /// should be ignored, but it may result in the message being forwarded if it is a duplicate of
4570         /// our own channel announcements.
4571         IgnoreDuplicateGossip,
4572         /// The peer did something incorrect. Tell them.
4573         SendErrorMessage {
4574                 /// The message to send.
4575                 msg: crate::lightning::ln::msgs::ErrorMessage,
4576         },
4577         /// The peer did something incorrect. Tell them without closing any channels.
4578         SendWarningMessage {
4579                 /// The message to send.
4580                 msg: crate::lightning::ln::msgs::WarningMessage,
4581                 /// The peer may have done something harmless that we weren't able to meaningfully process,
4582                 /// though we should still tell them about it.
4583                 /// If this event is logged, log it at the given level.
4584                 log_level: crate::lightning::util::logger::Level,
4585         },
4586 }
4587 use lightning::ln::msgs::ErrorAction as nativeErrorAction;
4588 impl ErrorAction {
4589         #[allow(unused)]
4590         pub(crate) fn to_native(&self) -> nativeErrorAction {
4591                 match self {
4592                         ErrorAction::DisconnectPeer {ref msg, } => {
4593                                 let mut msg_nonref = (*msg).clone();
4594                                 let mut local_msg_nonref = if msg_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg_nonref.take_inner()) } }) };
4595                                 nativeErrorAction::DisconnectPeer {
4596                                         msg: local_msg_nonref,
4597                                 }
4598                         },
4599                         ErrorAction::IgnoreError => nativeErrorAction::IgnoreError,
4600                         ErrorAction::IgnoreAndLog (ref a, ) => {
4601                                 let mut a_nonref = (*a).clone();
4602                                 nativeErrorAction::IgnoreAndLog (
4603                                         a_nonref.into_native(),
4604                                 )
4605                         },
4606                         ErrorAction::IgnoreDuplicateGossip => nativeErrorAction::IgnoreDuplicateGossip,
4607                         ErrorAction::SendErrorMessage {ref msg, } => {
4608                                 let mut msg_nonref = (*msg).clone();
4609                                 nativeErrorAction::SendErrorMessage {
4610                                         msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
4611                                 }
4612                         },
4613                         ErrorAction::SendWarningMessage {ref msg, ref log_level, } => {
4614                                 let mut msg_nonref = (*msg).clone();
4615                                 let mut log_level_nonref = (*log_level).clone();
4616                                 nativeErrorAction::SendWarningMessage {
4617                                         msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
4618                                         log_level: log_level_nonref.into_native(),
4619                                 }
4620                         },
4621                 }
4622         }
4623         #[allow(unused)]
4624         pub(crate) fn into_native(self) -> nativeErrorAction {
4625                 match self {
4626                         ErrorAction::DisconnectPeer {mut msg, } => {
4627                                 let mut local_msg = if msg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg.take_inner()) } }) };
4628                                 nativeErrorAction::DisconnectPeer {
4629                                         msg: local_msg,
4630                                 }
4631                         },
4632                         ErrorAction::IgnoreError => nativeErrorAction::IgnoreError,
4633                         ErrorAction::IgnoreAndLog (mut a, ) => {
4634                                 nativeErrorAction::IgnoreAndLog (
4635                                         a.into_native(),
4636                                 )
4637                         },
4638                         ErrorAction::IgnoreDuplicateGossip => nativeErrorAction::IgnoreDuplicateGossip,
4639                         ErrorAction::SendErrorMessage {mut msg, } => {
4640                                 nativeErrorAction::SendErrorMessage {
4641                                         msg: *unsafe { Box::from_raw(msg.take_inner()) },
4642                                 }
4643                         },
4644                         ErrorAction::SendWarningMessage {mut msg, mut log_level, } => {
4645                                 nativeErrorAction::SendWarningMessage {
4646                                         msg: *unsafe { Box::from_raw(msg.take_inner()) },
4647                                         log_level: log_level.into_native(),
4648                                 }
4649                         },
4650                 }
4651         }
4652         #[allow(unused)]
4653         pub(crate) fn from_native(native: &nativeErrorAction) -> Self {
4654                 match native {
4655                         nativeErrorAction::DisconnectPeer {ref msg, } => {
4656                                 let mut msg_nonref = (*msg).clone();
4657                                 let mut local_msg_nonref = crate::lightning::ln::msgs::ErrorMessage { inner: if msg_nonref.is_none() { core::ptr::null_mut() } else {  { ObjOps::heap_alloc((msg_nonref.unwrap())) } }, is_owned: true };
4658                                 ErrorAction::DisconnectPeer {
4659                                         msg: local_msg_nonref,
4660                                 }
4661                         },
4662                         nativeErrorAction::IgnoreError => ErrorAction::IgnoreError,
4663                         nativeErrorAction::IgnoreAndLog (ref a, ) => {
4664                                 let mut a_nonref = (*a).clone();
4665                                 ErrorAction::IgnoreAndLog (
4666                                         crate::lightning::util::logger::Level::native_into(a_nonref),
4667                                 )
4668                         },
4669                         nativeErrorAction::IgnoreDuplicateGossip => ErrorAction::IgnoreDuplicateGossip,
4670                         nativeErrorAction::SendErrorMessage {ref msg, } => {
4671                                 let mut msg_nonref = (*msg).clone();
4672                                 ErrorAction::SendErrorMessage {
4673                                         msg: crate::lightning::ln::msgs::ErrorMessage { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
4674                                 }
4675                         },
4676                         nativeErrorAction::SendWarningMessage {ref msg, ref log_level, } => {
4677                                 let mut msg_nonref = (*msg).clone();
4678                                 let mut log_level_nonref = (*log_level).clone();
4679                                 ErrorAction::SendWarningMessage {
4680                                         msg: crate::lightning::ln::msgs::WarningMessage { inner: ObjOps::heap_alloc(msg_nonref), is_owned: true },
4681                                         log_level: crate::lightning::util::logger::Level::native_into(log_level_nonref),
4682                                 }
4683                         },
4684                 }
4685         }
4686         #[allow(unused)]
4687         pub(crate) fn native_into(native: nativeErrorAction) -> Self {
4688                 match native {
4689                         nativeErrorAction::DisconnectPeer {mut msg, } => {
4690                                 let mut local_msg = crate::lightning::ln::msgs::ErrorMessage { inner: if msg.is_none() { core::ptr::null_mut() } else {  { ObjOps::heap_alloc((msg.unwrap())) } }, is_owned: true };
4691                                 ErrorAction::DisconnectPeer {
4692                                         msg: local_msg,
4693                                 }
4694                         },
4695                         nativeErrorAction::IgnoreError => ErrorAction::IgnoreError,
4696                         nativeErrorAction::IgnoreAndLog (mut a, ) => {
4697                                 ErrorAction::IgnoreAndLog (
4698                                         crate::lightning::util::logger::Level::native_into(a),
4699                                 )
4700                         },
4701                         nativeErrorAction::IgnoreDuplicateGossip => ErrorAction::IgnoreDuplicateGossip,
4702                         nativeErrorAction::SendErrorMessage {mut msg, } => {
4703                                 ErrorAction::SendErrorMessage {
4704                                         msg: crate::lightning::ln::msgs::ErrorMessage { inner: ObjOps::heap_alloc(msg), is_owned: true },
4705                                 }
4706                         },
4707                         nativeErrorAction::SendWarningMessage {mut msg, mut log_level, } => {
4708                                 ErrorAction::SendWarningMessage {
4709                                         msg: crate::lightning::ln::msgs::WarningMessage { inner: ObjOps::heap_alloc(msg), is_owned: true },
4710                                         log_level: crate::lightning::util::logger::Level::native_into(log_level),
4711                                 }
4712                         },
4713                 }
4714         }
4715 }
4716 /// Frees any resources used by the ErrorAction
4717 #[no_mangle]
4718 pub extern "C" fn ErrorAction_free(this_ptr: ErrorAction) { }
4719 /// Creates a copy of the ErrorAction
4720 #[no_mangle]
4721 pub extern "C" fn ErrorAction_clone(orig: &ErrorAction) -> ErrorAction {
4722         orig.clone()
4723 }
4724 #[no_mangle]
4725 /// Utility method to constructs a new DisconnectPeer-variant ErrorAction
4726 pub extern "C" fn ErrorAction_disconnect_peer(msg: crate::lightning::ln::msgs::ErrorMessage) -> ErrorAction {
4727         ErrorAction::DisconnectPeer {
4728                 msg,
4729         }
4730 }
4731 #[no_mangle]
4732 /// Utility method to constructs a new IgnoreError-variant ErrorAction
4733 pub extern "C" fn ErrorAction_ignore_error() -> ErrorAction {
4734         ErrorAction::IgnoreError}
4735 #[no_mangle]
4736 /// Utility method to constructs a new IgnoreAndLog-variant ErrorAction
4737 pub extern "C" fn ErrorAction_ignore_and_log(a: crate::lightning::util::logger::Level) -> ErrorAction {
4738         ErrorAction::IgnoreAndLog(a, )
4739 }
4740 #[no_mangle]
4741 /// Utility method to constructs a new IgnoreDuplicateGossip-variant ErrorAction
4742 pub extern "C" fn ErrorAction_ignore_duplicate_gossip() -> ErrorAction {
4743         ErrorAction::IgnoreDuplicateGossip}
4744 #[no_mangle]
4745 /// Utility method to constructs a new SendErrorMessage-variant ErrorAction
4746 pub extern "C" fn ErrorAction_send_error_message(msg: crate::lightning::ln::msgs::ErrorMessage) -> ErrorAction {
4747         ErrorAction::SendErrorMessage {
4748                 msg,
4749         }
4750 }
4751 #[no_mangle]
4752 /// Utility method to constructs a new SendWarningMessage-variant ErrorAction
4753 pub extern "C" fn ErrorAction_send_warning_message(msg: crate::lightning::ln::msgs::WarningMessage, log_level: crate::lightning::util::logger::Level) -> ErrorAction {
4754         ErrorAction::SendWarningMessage {
4755                 msg,
4756                 log_level,
4757         }
4758 }
4759
4760 use lightning::ln::msgs::LightningError as nativeLightningErrorImport;
4761 pub(crate) type nativeLightningError = nativeLightningErrorImport;
4762
4763 /// An Err type for failure to process messages.
4764 #[must_use]
4765 #[repr(C)]
4766 pub struct LightningError {
4767         /// A pointer to the opaque Rust object.
4768
4769         /// Nearly everywhere, inner must be non-null, however in places where
4770         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
4771         pub inner: *mut nativeLightningError,
4772         /// Indicates that this is the only struct which contains the same pointer.
4773
4774         /// Rust functions which take ownership of an object provided via an argument require
4775         /// this to be true and invalidate the object pointed to by inner.
4776         pub is_owned: bool,
4777 }
4778
4779 impl Drop for LightningError {
4780         fn drop(&mut self) {
4781                 if self.is_owned && !<*mut nativeLightningError>::is_null(self.inner) {
4782                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
4783                 }
4784         }
4785 }
4786 /// Frees any resources used by the LightningError, if is_owned is set and inner is non-NULL.
4787 #[no_mangle]
4788 pub extern "C" fn LightningError_free(this_obj: LightningError) { }
4789 #[allow(unused)]
4790 /// Used only if an object of this type is returned as a trait impl by a method
4791 pub(crate) extern "C" fn LightningError_free_void(this_ptr: *mut c_void) {
4792         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeLightningError); }
4793 }
4794 #[allow(unused)]
4795 impl LightningError {
4796         pub(crate) fn get_native_ref(&self) -> &'static nativeLightningError {
4797                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
4798         }
4799         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeLightningError {
4800                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
4801         }
4802         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4803         pub(crate) fn take_inner(mut self) -> *mut nativeLightningError {
4804                 assert!(self.is_owned);
4805                 let ret = ObjOps::untweak_ptr(self.inner);
4806                 self.inner = core::ptr::null_mut();
4807                 ret
4808         }
4809 }
4810 /// A human-readable message describing the error
4811 #[no_mangle]
4812 pub extern "C" fn LightningError_get_err(this_ptr: &LightningError) -> crate::c_types::Str {
4813         let mut inner_val = &mut this_ptr.get_native_mut_ref().err;
4814         inner_val.as_str().into()
4815 }
4816 /// A human-readable message describing the error
4817 #[no_mangle]
4818 pub extern "C" fn LightningError_set_err(this_ptr: &mut LightningError, mut val: crate::c_types::Str) {
4819         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.err = val.into_string();
4820 }
4821 /// The action which should be taken against the offending peer.
4822 #[no_mangle]
4823 pub extern "C" fn LightningError_get_action(this_ptr: &LightningError) -> crate::lightning::ln::msgs::ErrorAction {
4824         let mut inner_val = &mut this_ptr.get_native_mut_ref().action;
4825         crate::lightning::ln::msgs::ErrorAction::from_native(inner_val)
4826 }
4827 /// The action which should be taken against the offending peer.
4828 #[no_mangle]
4829 pub extern "C" fn LightningError_set_action(this_ptr: &mut LightningError, mut val: crate::lightning::ln::msgs::ErrorAction) {
4830         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.action = val.into_native();
4831 }
4832 /// Constructs a new LightningError given each field
4833 #[must_use]
4834 #[no_mangle]
4835 pub extern "C" fn LightningError_new(mut err_arg: crate::c_types::Str, mut action_arg: crate::lightning::ln::msgs::ErrorAction) -> LightningError {
4836         LightningError { inner: ObjOps::heap_alloc(nativeLightningError {
4837                 err: err_arg.into_string(),
4838                 action: action_arg.into_native(),
4839         }), is_owned: true }
4840 }
4841 impl Clone for LightningError {
4842         fn clone(&self) -> Self {
4843                 Self {
4844                         inner: if <*mut nativeLightningError>::is_null(self.inner) { core::ptr::null_mut() } else {
4845                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
4846                         is_owned: true,
4847                 }
4848         }
4849 }
4850 #[allow(unused)]
4851 /// Used only if an object of this type is returned as a trait impl by a method
4852 pub(crate) extern "C" fn LightningError_clone_void(this_ptr: *const c_void) -> *mut c_void {
4853         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeLightningError)).clone() })) as *mut c_void
4854 }
4855 #[no_mangle]
4856 /// Creates a copy of the LightningError
4857 pub extern "C" fn LightningError_clone(orig: &LightningError) -> LightningError {
4858         orig.clone()
4859 }
4860
4861 use lightning::ln::msgs::CommitmentUpdate as nativeCommitmentUpdateImport;
4862 pub(crate) type nativeCommitmentUpdate = nativeCommitmentUpdateImport;
4863
4864 /// Struct used to return values from revoke_and_ack messages, containing a bunch of commitment
4865 /// transaction updates if they were pending.
4866 #[must_use]
4867 #[repr(C)]
4868 pub struct CommitmentUpdate {
4869         /// A pointer to the opaque Rust object.
4870
4871         /// Nearly everywhere, inner must be non-null, however in places where
4872         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
4873         pub inner: *mut nativeCommitmentUpdate,
4874         /// Indicates that this is the only struct which contains the same pointer.
4875
4876         /// Rust functions which take ownership of an object provided via an argument require
4877         /// this to be true and invalidate the object pointed to by inner.
4878         pub is_owned: bool,
4879 }
4880
4881 impl Drop for CommitmentUpdate {
4882         fn drop(&mut self) {
4883                 if self.is_owned && !<*mut nativeCommitmentUpdate>::is_null(self.inner) {
4884                         let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
4885                 }
4886         }
4887 }
4888 /// Frees any resources used by the CommitmentUpdate, if is_owned is set and inner is non-NULL.
4889 #[no_mangle]
4890 pub extern "C" fn CommitmentUpdate_free(this_obj: CommitmentUpdate) { }
4891 #[allow(unused)]
4892 /// Used only if an object of this type is returned as a trait impl by a method
4893 pub(crate) extern "C" fn CommitmentUpdate_free_void(this_ptr: *mut c_void) {
4894         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeCommitmentUpdate); }
4895 }
4896 #[allow(unused)]
4897 impl CommitmentUpdate {
4898         pub(crate) fn get_native_ref(&self) -> &'static nativeCommitmentUpdate {
4899                 unsafe { &*ObjOps::untweak_ptr(self.inner) }
4900         }
4901         pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeCommitmentUpdate {
4902                 unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
4903         }
4904         /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4905         pub(crate) fn take_inner(mut self) -> *mut nativeCommitmentUpdate {
4906                 assert!(self.is_owned);
4907                 let ret = ObjOps::untweak_ptr(self.inner);
4908                 self.inner = core::ptr::null_mut();
4909                 ret
4910         }
4911 }
4912 /// update_add_htlc messages which should be sent
4913 #[no_mangle]
4914 pub extern "C" fn CommitmentUpdate_get_update_add_htlcs(this_ptr: &CommitmentUpdate) -> crate::c_types::derived::CVec_UpdateAddHTLCZ {
4915         let mut inner_val = &mut this_ptr.get_native_mut_ref().update_add_htlcs;
4916         let mut local_inner_val = Vec::new(); for item in inner_val.iter() { local_inner_val.push( { crate::lightning::ln::msgs::UpdateAddHTLC { inner: unsafe { ObjOps::nonnull_ptr_to_inner((item as *const lightning::ln::msgs::UpdateAddHTLC<>) as *mut _) }, is_owned: false } }); };
4917         local_inner_val.into()
4918 }
4919 /// update_add_htlc messages which should be sent
4920 #[no_mangle]
4921 pub extern "C" fn CommitmentUpdate_set_update_add_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateAddHTLCZ) {
4922         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4923         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.update_add_htlcs = local_val;
4924 }
4925 /// update_fulfill_htlc messages which should be sent
4926 #[no_mangle]
4927 pub extern "C" fn CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: &CommitmentUpdate) -> crate::c_types::derived::CVec_UpdateFulfillHTLCZ {
4928         let mut inner_val = &mut this_ptr.get_native_mut_ref().update_fulfill_htlcs;
4929         let mut local_inner_val = Vec::new(); for item in inner_val.iter() { local_inner_val.push( { crate::lightning::ln::msgs::UpdateFulfillHTLC { inner: unsafe { ObjOps::nonnull_ptr_to_inner((item as *const lightning::ln::msgs::UpdateFulfillHTLC<>) as *mut _) }, is_owned: false } }); };
4930         local_inner_val.into()
4931 }
4932 /// update_fulfill_htlc messages which should be sent
4933 #[no_mangle]
4934 pub extern "C" fn CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFulfillHTLCZ) {
4935         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4936         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.update_fulfill_htlcs = local_val;
4937 }
4938 /// update_fail_htlc messages which should be sent
4939 #[no_mangle]
4940 pub extern "C" fn CommitmentUpdate_get_update_fail_htlcs(this_ptr: &CommitmentUpdate) -> crate::c_types::derived::CVec_UpdateFailHTLCZ {
4941         let mut inner_val = &mut this_ptr.get_native_mut_ref().update_fail_htlcs;
4942         let mut local_inner_val = Vec::new(); for item in inner_val.iter() { local_inner_val.push( { crate::lightning::ln::msgs::UpdateFailHTLC { inner: unsafe { ObjOps::nonnull_ptr_to_inner((item as *const lightning::ln::msgs::UpdateFailHTLC<>) as *mut _) }, is_owned: false } }); };
4943         local_inner_val.into()
4944 }
4945 /// update_fail_htlc messages which should be sent
4946 #[no_mangle]
4947 pub extern "C" fn CommitmentUpdate_set_update_fail_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFailHTLCZ) {
4948         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4949         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.update_fail_htlcs = local_val;
4950 }
4951 /// update_fail_malformed_htlc messages which should be sent
4952 #[no_mangle]
4953 pub extern "C" fn CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: &CommitmentUpdate) -> crate::c_types::derived::CVec_UpdateFailMalformedHTLCZ {
4954         let mut inner_val = &mut this_ptr.get_native_mut_ref().update_fail_malformed_htlcs;
4955         let mut local_inner_val = Vec::new(); for item in inner_val.iter() { local_inner_val.push( { crate::lightning::ln::msgs::UpdateFailMalformedHTLC { inner: unsafe { ObjOps::nonnull_ptr_to_inner((item as *const lightning::ln::msgs::UpdateFailMalformedHTLC<>) as *mut _) }, is_owned: false } }); };
4956         local_inner_val.into()
4957 }
4958 /// update_fail_malformed_htlc messages which should be sent
4959 #[no_mangle]
4960 pub extern "C" fn CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFailMalformedHTLCZ) {
4961         let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4962         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.update_fail_malformed_htlcs = local_val;
4963 }
4964 /// An update_fee message which should be sent
4965 ///
4966 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4967 #[no_mangle]
4968 pub extern "C" fn CommitmentUpdate_get_update_fee(this_ptr: &CommitmentUpdate) -> crate::lightning::ln::msgs::UpdateFee {
4969         let mut inner_val = &mut this_ptr.get_native_mut_ref().update_fee;
4970         let mut local_inner_val = crate::lightning::ln::msgs::UpdateFee { 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::msgs::UpdateFee<>) as *mut _ }, is_owned: false };
4971         local_inner_val
4972 }
4973 /// An update_fee message which should be sent
4974 ///
4975 /// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
4976 #[no_mangle]
4977 pub extern "C" fn CommitmentUpdate_set_update_fee(this_ptr: &mut CommitmentUpdate, mut val: crate::lightning::ln::msgs::UpdateFee) {
4978         let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
4979         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.update_fee = local_val;
4980 }
4981 /// Finally, the commitment_signed message which should be sent
4982 #[no_mangle]
4983 pub extern "C" fn CommitmentUpdate_get_commitment_signed(this_ptr: &CommitmentUpdate) -> crate::lightning::ln::msgs::CommitmentSigned {
4984         let mut inner_val = &mut this_ptr.get_native_mut_ref().commitment_signed;
4985         crate::lightning::ln::msgs::CommitmentSigned { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning::ln::msgs::CommitmentSigned<>) as *mut _) }, is_owned: false }
4986 }
4987 /// Finally, the commitment_signed message which should be sent
4988 #[no_mangle]
4989 pub extern "C" fn CommitmentUpdate_set_commitment_signed(this_ptr: &mut CommitmentUpdate, mut val: crate::lightning::ln::msgs::CommitmentSigned) {
4990         unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.commitment_signed = *unsafe { Box::from_raw(val.take_inner()) };
4991 }
4992 /// Constructs a new CommitmentUpdate given each field
4993 #[must_use]
4994 #[no_mangle]
4995 pub extern "C" fn CommitmentUpdate_new(mut update_add_htlcs_arg: crate::c_types::derived::CVec_UpdateAddHTLCZ, mut update_fulfill_htlcs_arg: crate::c_types::derived::CVec_UpdateFulfillHTLCZ, mut update_fail_htlcs_arg: crate::c_types::derived::CVec_UpdateFailHTLCZ, mut update_fail_malformed_htlcs_arg: crate::c_types::derived::CVec_UpdateFailMalformedHTLCZ, mut update_fee_arg: crate::lightning::ln::msgs::UpdateFee, mut commitment_signed_arg: crate::lightning::ln::msgs::CommitmentSigned) -> CommitmentUpdate {
4996         let mut local_update_add_htlcs_arg = Vec::new(); for mut item in update_add_htlcs_arg.into_rust().drain(..) { local_update_add_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4997         let mut local_update_fulfill_htlcs_arg = Vec::new(); for mut item in update_fulfill_htlcs_arg.into_rust().drain(..) { local_update_fulfill_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4998         let mut local_update_fail_htlcs_arg = Vec::new(); for mut item in update_fail_htlcs_arg.into_rust().drain(..) { local_update_fail_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4999         let mut local_update_fail_malformed_htlcs_arg = Vec::new(); for mut item in update_fail_malformed_htlcs_arg.into_rust().drain(..) { local_update_fail_malformed_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
5000         let mut local_update_fee_arg = if update_fee_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(update_fee_arg.take_inner()) } }) };
5001         CommitmentUpdate { inner: ObjOps::heap_alloc(nativeCommitmentUpdate {
5002                 update_add_htlcs: local_update_add_htlcs_arg,
5003                 update_fulfill_htlcs: local_update_fulfill_htlcs_arg,
5004                 update_fail_htlcs: local_update_fail_htlcs_arg,
5005                 update_fail_malformed_htlcs: local_update_fail_malformed_htlcs_arg,
5006                 update_fee: local_update_fee_arg,
5007                 commitment_signed: *unsafe { Box::from_raw(commitment_signed_arg.take_inner()) },
5008         }), is_owned: true }
5009 }
5010 impl Clone for CommitmentUpdate {
5011         fn clone(&self) -> Self {
5012                 Self {
5013                         inner: if <*mut nativeCommitmentUpdate>::is_null(self.inner) { core::ptr::null_mut() } else {
5014                                 ObjOps::heap_alloc(unsafe { &*ObjOps::untweak_ptr(self.inner) }.clone()) },
5015                         is_owned: true,
5016                 }
5017         }
5018 }
5019 #[allow(unused)]
5020 /// Used only if an object of this type is returned as a trait impl by a method
5021 pub(crate) extern "C" fn CommitmentUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void {
5022         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeCommitmentUpdate)).clone() })) as *mut c_void
5023 }
5024 #[no_mangle]
5025 /// Creates a copy of the CommitmentUpdate
5026 pub extern "C" fn CommitmentUpdate_clone(orig: &CommitmentUpdate) -> CommitmentUpdate {
5027         orig.clone()
5028 }
5029 /// A trait to describe an object which can receive channel messages.
5030 ///
5031 /// Messages MAY be called in parallel when they originate from different their_node_ids, however
5032 /// they MUST NOT be called in parallel when the two calls have the same their_node_id.
5033 #[repr(C)]
5034 pub struct ChannelMessageHandler {
5035         /// An opaque pointer which is passed to your function implementations as an argument.
5036         /// This has no meaning in the LDK, and can be NULL or any other value.
5037         pub this_arg: *mut c_void,
5038         /// Handle an incoming open_channel message from the given peer.
5039         pub handle_open_channel: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, their_features: crate::lightning::ln::features::InitFeatures, msg: &crate::lightning::ln::msgs::OpenChannel),
5040         /// Handle an incoming accept_channel message from the given peer.
5041         pub handle_accept_channel: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, their_features: crate::lightning::ln::features::InitFeatures, msg: &crate::lightning::ln::msgs::AcceptChannel),
5042         /// Handle an incoming funding_created message from the given peer.
5043         pub handle_funding_created: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::FundingCreated),
5044         /// Handle an incoming funding_signed message from the given peer.
5045         pub handle_funding_signed: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::FundingSigned),
5046         /// Handle an incoming funding_locked message from the given peer.
5047         pub handle_funding_locked: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::FundingLocked),
5048         /// Handle an incoming shutdown message from the given peer.
5049         pub handle_shutdown: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, their_features: &crate::lightning::ln::features::InitFeatures, msg: &crate::lightning::ln::msgs::Shutdown),
5050         /// Handle an incoming closing_signed message from the given peer.
5051         pub handle_closing_signed: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::ClosingSigned),
5052         /// Handle an incoming update_add_htlc message from the given peer.
5053         pub handle_update_add_htlc: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::UpdateAddHTLC),
5054         /// Handle an incoming update_fulfill_htlc message from the given peer.
5055         pub handle_update_fulfill_htlc: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::UpdateFulfillHTLC),
5056         /// Handle an incoming update_fail_htlc message from the given peer.
5057         pub handle_update_fail_htlc: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::UpdateFailHTLC),
5058         /// Handle an incoming update_fail_malformed_htlc message from the given peer.
5059         pub handle_update_fail_malformed_htlc: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::UpdateFailMalformedHTLC),
5060         /// Handle an incoming commitment_signed message from the given peer.
5061         pub handle_commitment_signed: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::CommitmentSigned),
5062         /// Handle an incoming revoke_and_ack message from the given peer.
5063         pub handle_revoke_and_ack: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::RevokeAndACK),
5064         /// Handle an incoming update_fee message from the given peer.
5065         pub handle_update_fee: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::UpdateFee),
5066         /// Handle an incoming announcement_signatures message from the given peer.
5067         pub handle_announcement_signatures: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::AnnouncementSignatures),
5068         /// Indicates a connection to the peer failed/an existing connection was lost. If no connection
5069         /// is believed to be possible in the future (eg they're sending us messages we don't
5070         /// understand or indicate they require unknown feature bits), no_connection_possible is set
5071         /// and any outstanding channels should be failed.
5072         pub peer_disconnected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, no_connection_possible: bool),
5073         /// Handle a peer reconnecting, possibly generating channel_reestablish message(s).
5074         pub peer_connected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::Init),
5075         /// Handle an incoming channel_reestablish message from the given peer.
5076         pub handle_channel_reestablish: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::ChannelReestablish),
5077         /// Handle an incoming channel update from the given peer.
5078         pub handle_channel_update: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::ChannelUpdate),
5079         /// Handle an incoming error message from the given peer.
5080         pub handle_error: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::ErrorMessage),
5081         /// Implementation of MessageSendEventsProvider for this object.
5082         pub MessageSendEventsProvider: crate::lightning::util::events::MessageSendEventsProvider,
5083         /// Frees any resources associated with this object given its this_arg pointer.
5084         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
5085         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
5086 }
5087 unsafe impl Send for ChannelMessageHandler {}
5088 unsafe impl Sync for ChannelMessageHandler {}
5089 #[no_mangle]
5090 pub(crate) extern "C" fn ChannelMessageHandler_clone_fields(orig: &ChannelMessageHandler) -> ChannelMessageHandler {
5091         ChannelMessageHandler {
5092                 this_arg: orig.this_arg,
5093                 handle_open_channel: Clone::clone(&orig.handle_open_channel),
5094                 handle_accept_channel: Clone::clone(&orig.handle_accept_channel),
5095                 handle_funding_created: Clone::clone(&orig.handle_funding_created),
5096                 handle_funding_signed: Clone::clone(&orig.handle_funding_signed),
5097                 handle_funding_locked: Clone::clone(&orig.handle_funding_locked),
5098                 handle_shutdown: Clone::clone(&orig.handle_shutdown),
5099                 handle_closing_signed: Clone::clone(&orig.handle_closing_signed),
5100                 handle_update_add_htlc: Clone::clone(&orig.handle_update_add_htlc),
5101                 handle_update_fulfill_htlc: Clone::clone(&orig.handle_update_fulfill_htlc),
5102                 handle_update_fail_htlc: Clone::clone(&orig.handle_update_fail_htlc),
5103                 handle_update_fail_malformed_htlc: Clone::clone(&orig.handle_update_fail_malformed_htlc),
5104                 handle_commitment_signed: Clone::clone(&orig.handle_commitment_signed),
5105                 handle_revoke_and_ack: Clone::clone(&orig.handle_revoke_and_ack),
5106                 handle_update_fee: Clone::clone(&orig.handle_update_fee),
5107                 handle_announcement_signatures: Clone::clone(&orig.handle_announcement_signatures),
5108                 peer_disconnected: Clone::clone(&orig.peer_disconnected),
5109                 peer_connected: Clone::clone(&orig.peer_connected),
5110                 handle_channel_reestablish: Clone::clone(&orig.handle_channel_reestablish),
5111                 handle_channel_update: Clone::clone(&orig.handle_channel_update),
5112                 handle_error: Clone::clone(&orig.handle_error),
5113                 MessageSendEventsProvider: crate::lightning::util::events::MessageSendEventsProvider_clone_fields(&orig.MessageSendEventsProvider),
5114                 free: Clone::clone(&orig.free),
5115         }
5116 }
5117 impl lightning::util::events::MessageSendEventsProvider for ChannelMessageHandler {
5118         fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {
5119                 let mut ret = (self.MessageSendEventsProvider.get_and_clear_pending_msg_events)(self.MessageSendEventsProvider.this_arg);
5120                 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
5121                 local_ret
5122         }
5123 }
5124
5125 use lightning::ln::msgs::ChannelMessageHandler as rustChannelMessageHandler;
5126 impl rustChannelMessageHandler for ChannelMessageHandler {
5127         fn handle_open_channel(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut their_features: lightning::ln::features::InitFeatures, mut msg: &lightning::ln::msgs::OpenChannel) {
5128                 (self.handle_open_channel)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::lightning::ln::features::InitFeatures { inner: ObjOps::heap_alloc(their_features), is_owned: true }, &crate::lightning::ln::msgs::OpenChannel { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::OpenChannel<>) as *mut _) }, is_owned: false })
5129         }
5130         fn handle_accept_channel(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut their_features: lightning::ln::features::InitFeatures, mut msg: &lightning::ln::msgs::AcceptChannel) {
5131                 (self.handle_accept_channel)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::lightning::ln::features::InitFeatures { inner: ObjOps::heap_alloc(their_features), is_owned: true }, &crate::lightning::ln::msgs::AcceptChannel { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::AcceptChannel<>) as *mut _) }, is_owned: false })
5132         }
5133         fn handle_funding_created(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::FundingCreated) {
5134                 (self.handle_funding_created)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::FundingCreated { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::FundingCreated<>) as *mut _) }, is_owned: false })
5135         }
5136         fn handle_funding_signed(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::FundingSigned) {
5137                 (self.handle_funding_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::FundingSigned { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::FundingSigned<>) as *mut _) }, is_owned: false })
5138         }
5139         fn handle_funding_locked(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::FundingLocked) {
5140                 (self.handle_funding_locked)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::FundingLocked { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::FundingLocked<>) as *mut _) }, is_owned: false })
5141         }
5142         fn handle_shutdown(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut their_features: &lightning::ln::features::InitFeatures, mut msg: &lightning::ln::msgs::Shutdown) {
5143                 (self.handle_shutdown)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::features::InitFeatures { inner: unsafe { ObjOps::nonnull_ptr_to_inner((their_features as *const lightning::ln::features::InitFeatures<>) as *mut _) }, is_owned: false }, &crate::lightning::ln::msgs::Shutdown { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::Shutdown<>) as *mut _) }, is_owned: false })
5144         }
5145         fn handle_closing_signed(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::ClosingSigned) {
5146                 (self.handle_closing_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::ClosingSigned { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ClosingSigned<>) as *mut _) }, is_owned: false })
5147         }
5148         fn handle_update_add_htlc(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateAddHTLC) {
5149                 (self.handle_update_add_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::UpdateAddHTLC { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::UpdateAddHTLC<>) as *mut _) }, is_owned: false })
5150         }
5151         fn handle_update_fulfill_htlc(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateFulfillHTLC) {
5152                 (self.handle_update_fulfill_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::UpdateFulfillHTLC { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::UpdateFulfillHTLC<>) as *mut _) }, is_owned: false })
5153         }
5154         fn handle_update_fail_htlc(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateFailHTLC) {
5155                 (self.handle_update_fail_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::UpdateFailHTLC { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::UpdateFailHTLC<>) as *mut _) }, is_owned: false })
5156         }
5157         fn handle_update_fail_malformed_htlc(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateFailMalformedHTLC) {
5158                 (self.handle_update_fail_malformed_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::UpdateFailMalformedHTLC { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::UpdateFailMalformedHTLC<>) as *mut _) }, is_owned: false })
5159         }
5160         fn handle_commitment_signed(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::CommitmentSigned) {
5161                 (self.handle_commitment_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::CommitmentSigned { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::CommitmentSigned<>) as *mut _) }, is_owned: false })
5162         }
5163         fn handle_revoke_and_ack(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::RevokeAndACK) {
5164                 (self.handle_revoke_and_ack)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::RevokeAndACK { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::RevokeAndACK<>) as *mut _) }, is_owned: false })
5165         }
5166         fn handle_update_fee(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateFee) {
5167                 (self.handle_update_fee)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::UpdateFee { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::UpdateFee<>) as *mut _) }, is_owned: false })
5168         }
5169         fn handle_announcement_signatures(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::AnnouncementSignatures) {
5170                 (self.handle_announcement_signatures)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::AnnouncementSignatures { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::AnnouncementSignatures<>) as *mut _) }, is_owned: false })
5171         }
5172         fn peer_disconnected(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut no_connection_possible: bool) {
5173                 (self.peer_disconnected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), no_connection_possible)
5174         }
5175         fn peer_connected(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::Init) {
5176                 (self.peer_connected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::Init { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::Init<>) as *mut _) }, is_owned: false })
5177         }
5178         fn handle_channel_reestablish(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::ChannelReestablish) {
5179                 (self.handle_channel_reestablish)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::ChannelReestablish { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ChannelReestablish<>) as *mut _) }, is_owned: false })
5180         }
5181         fn handle_channel_update(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::ChannelUpdate) {
5182                 (self.handle_channel_update)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::ChannelUpdate { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ChannelUpdate<>) as *mut _) }, is_owned: false })
5183         }
5184         fn handle_error(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::ErrorMessage) {
5185                 (self.handle_error)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::ErrorMessage { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ErrorMessage<>) as *mut _) }, is_owned: false })
5186         }
5187 }
5188
5189 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
5190 // directly as a Deref trait in higher-level structs:
5191 impl core::ops::Deref for ChannelMessageHandler {
5192         type Target = Self;
5193         fn deref(&self) -> &Self {
5194                 self
5195         }
5196 }
5197 /// Calls the free function if one is set
5198 #[no_mangle]
5199 pub extern "C" fn ChannelMessageHandler_free(this_ptr: ChannelMessageHandler) { }
5200 impl Drop for ChannelMessageHandler {
5201         fn drop(&mut self) {
5202                 if let Some(f) = self.free {
5203                         f(self.this_arg);
5204                 }
5205         }
5206 }
5207 /// A trait to describe an object which can receive routing messages.
5208 ///
5209 /// # Implementor DoS Warnings
5210 ///
5211 /// For `gossip_queries` messages there are potential DoS vectors when handling
5212 /// inbound queries. Implementors using an on-disk network graph should be aware of
5213 /// repeated disk I/O for queries accessing different parts of the network graph.
5214 #[repr(C)]
5215 pub struct RoutingMessageHandler {
5216         /// An opaque pointer which is passed to your function implementations as an argument.
5217         /// This has no meaning in the LDK, and can be NULL or any other value.
5218         pub this_arg: *mut c_void,
5219         /// Handle an incoming node_announcement message, returning true if it should be forwarded on,
5220         /// false or returning an Err otherwise.
5221         #[must_use]
5222         pub handle_node_announcement: extern "C" fn (this_arg: *const c_void, msg: &crate::lightning::ln::msgs::NodeAnnouncement) -> crate::c_types::derived::CResult_boolLightningErrorZ,
5223         /// Handle a channel_announcement message, returning true if it should be forwarded on, false
5224         /// or returning an Err otherwise.
5225         #[must_use]
5226         pub handle_channel_announcement: extern "C" fn (this_arg: *const c_void, msg: &crate::lightning::ln::msgs::ChannelAnnouncement) -> crate::c_types::derived::CResult_boolLightningErrorZ,
5227         /// Handle an incoming channel_update message, returning true if it should be forwarded on,
5228         /// false or returning an Err otherwise.
5229         #[must_use]
5230         pub handle_channel_update: extern "C" fn (this_arg: *const c_void, msg: &crate::lightning::ln::msgs::ChannelUpdate) -> crate::c_types::derived::CResult_boolLightningErrorZ,
5231         /// Gets a subset of the channel announcements and updates required to dump our routing table
5232         /// to a remote node, starting at the short_channel_id indicated by starting_point and
5233         /// including the batch_amount entries immediately higher in numerical value than starting_point.
5234         #[must_use]
5235         pub get_next_channel_announcements: extern "C" fn (this_arg: *const c_void, starting_point: u64, batch_amount: u8) -> crate::c_types::derived::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ,
5236         /// Gets a subset of the node announcements required to dump our routing table to a remote node,
5237         /// starting at the node *after* the provided publickey and including batch_amount entries
5238         /// immediately higher (as defined by <PublicKey as Ord>::cmp) than starting_point.
5239         /// If None is provided for starting_point, we start at the first node.
5240         ///
5241         /// Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
5242         #[must_use]
5243         pub get_next_node_announcements: extern "C" fn (this_arg: *const c_void, starting_point: crate::c_types::PublicKey, batch_amount: u8) -> crate::c_types::derived::CVec_NodeAnnouncementZ,
5244         /// Called when a connection is established with a peer. This can be used to
5245         /// perform routing table synchronization using a strategy defined by the
5246         /// implementor.
5247         pub peer_connected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, init: &crate::lightning::ln::msgs::Init),
5248         /// Handles the reply of a query we initiated to learn about channels
5249         /// for a given range of blocks. We can expect to receive one or more
5250         /// replies to a single query.
5251         #[must_use]
5252         pub handle_reply_channel_range: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::ReplyChannelRange) -> crate::c_types::derived::CResult_NoneLightningErrorZ,
5253         /// Handles the reply of a query we initiated asking for routing gossip
5254         /// messages for a list of channels. We should receive this message when
5255         /// a node has completed its best effort to send us the pertaining routing
5256         /// gossip messages.
5257         #[must_use]
5258         pub handle_reply_short_channel_ids_end: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::ReplyShortChannelIdsEnd) -> crate::c_types::derived::CResult_NoneLightningErrorZ,
5259         /// Handles when a peer asks us to send a list of short_channel_ids
5260         /// for the requested range of blocks.
5261         #[must_use]
5262         pub handle_query_channel_range: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::QueryChannelRange) -> crate::c_types::derived::CResult_NoneLightningErrorZ,
5263         /// Handles when a peer asks us to send routing gossip messages for a
5264         /// list of short_channel_ids.
5265         #[must_use]
5266         pub handle_query_short_channel_ids: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: crate::lightning::ln::msgs::QueryShortChannelIds) -> crate::c_types::derived::CResult_NoneLightningErrorZ,
5267         /// Implementation of MessageSendEventsProvider for this object.
5268         pub MessageSendEventsProvider: crate::lightning::util::events::MessageSendEventsProvider,
5269         /// Frees any resources associated with this object given its this_arg pointer.
5270         /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
5271         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
5272 }
5273 unsafe impl Send for RoutingMessageHandler {}
5274 unsafe impl Sync for RoutingMessageHandler {}
5275 #[no_mangle]
5276 pub(crate) extern "C" fn RoutingMessageHandler_clone_fields(orig: &RoutingMessageHandler) -> RoutingMessageHandler {
5277         RoutingMessageHandler {
5278                 this_arg: orig.this_arg,
5279                 handle_node_announcement: Clone::clone(&orig.handle_node_announcement),
5280                 handle_channel_announcement: Clone::clone(&orig.handle_channel_announcement),
5281                 handle_channel_update: Clone::clone(&orig.handle_channel_update),
5282                 get_next_channel_announcements: Clone::clone(&orig.get_next_channel_announcements),
5283                 get_next_node_announcements: Clone::clone(&orig.get_next_node_announcements),
5284                 peer_connected: Clone::clone(&orig.peer_connected),
5285                 handle_reply_channel_range: Clone::clone(&orig.handle_reply_channel_range),
5286                 handle_reply_short_channel_ids_end: Clone::clone(&orig.handle_reply_short_channel_ids_end),
5287                 handle_query_channel_range: Clone::clone(&orig.handle_query_channel_range),
5288                 handle_query_short_channel_ids: Clone::clone(&orig.handle_query_short_channel_ids),
5289                 MessageSendEventsProvider: crate::lightning::util::events::MessageSendEventsProvider_clone_fields(&orig.MessageSendEventsProvider),
5290                 free: Clone::clone(&orig.free),
5291         }
5292 }
5293 impl lightning::util::events::MessageSendEventsProvider for RoutingMessageHandler {
5294         fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {
5295                 let mut ret = (self.MessageSendEventsProvider.get_and_clear_pending_msg_events)(self.MessageSendEventsProvider.this_arg);
5296                 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
5297                 local_ret
5298         }
5299 }
5300
5301 use lightning::ln::msgs::RoutingMessageHandler as rustRoutingMessageHandler;
5302 impl rustRoutingMessageHandler for RoutingMessageHandler {
5303         fn handle_node_announcement(&self, mut msg: &lightning::ln::msgs::NodeAnnouncement) -> Result<bool, lightning::ln::msgs::LightningError> {
5304                 let mut ret = (self.handle_node_announcement)(self.this_arg, &crate::lightning::ln::msgs::NodeAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::NodeAnnouncement<>) as *mut _) }, is_owned: false });
5305                 let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })};
5306                 local_ret
5307         }
5308         fn handle_channel_announcement(&self, mut msg: &lightning::ln::msgs::ChannelAnnouncement) -> Result<bool, lightning::ln::msgs::LightningError> {
5309                 let mut ret = (self.handle_channel_announcement)(self.this_arg, &crate::lightning::ln::msgs::ChannelAnnouncement { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ChannelAnnouncement<>) as *mut _) }, is_owned: false });
5310                 let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })};
5311                 local_ret
5312         }
5313         fn handle_channel_update(&self, mut msg: &lightning::ln::msgs::ChannelUpdate) -> Result<bool, lightning::ln::msgs::LightningError> {
5314                 let mut ret = (self.handle_channel_update)(self.this_arg, &crate::lightning::ln::msgs::ChannelUpdate { inner: unsafe { ObjOps::nonnull_ptr_to_inner((msg as *const lightning::ln::msgs::ChannelUpdate<>) as *mut _) }, is_owned: false });
5315                 let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })};
5316                 local_ret
5317         }
5318         fn get_next_channel_announcements(&self, mut starting_point: u64, mut batch_amount: u8) -> Vec<(lightning::ln::msgs::ChannelAnnouncement, Option<lightning::ln::msgs::ChannelUpdate>, Option<lightning::ln::msgs::ChannelUpdate>)> {
5319                 let mut ret = (self.get_next_channel_announcements)(self.this_arg, starting_point, batch_amount);
5320                 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { let (mut orig_ret_0_0, mut orig_ret_0_1, mut orig_ret_0_2) = item.to_rust(); let mut local_orig_ret_0_1 = if orig_ret_0_1.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(orig_ret_0_1.take_inner()) } }) }; let mut local_orig_ret_0_2 = if orig_ret_0_2.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(orig_ret_0_2.take_inner()) } }) }; let mut local_ret_0 = (*unsafe { Box::from_raw(orig_ret_0_0.take_inner()) }, local_orig_ret_0_1, local_orig_ret_0_2); local_ret_0 }); };
5321                 local_ret
5322         }
5323         fn get_next_node_announcements(&self, mut starting_point: Option<&bitcoin::secp256k1::key::PublicKey>, mut batch_amount: u8) -> Vec<lightning::ln::msgs::NodeAnnouncement> {
5324                 let mut local_starting_point = if starting_point.is_none() { crate::c_types::PublicKey::null() } else {  { crate::c_types::PublicKey::from_rust(&(starting_point.unwrap())) } };
5325                 let mut ret = (self.get_next_node_announcements)(self.this_arg, local_starting_point, batch_amount);
5326                 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
5327                 local_ret
5328         }
5329         fn peer_connected(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut init: &lightning::ln::msgs::Init) {
5330                 (self.peer_connected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::Init { inner: unsafe { ObjOps::nonnull_ptr_to_inner((init as *const lightning::ln::msgs::Init<>) as *mut _) }, is_owned: false })
5331         }
5332         fn handle_reply_channel_range(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: lightning::ln::msgs::ReplyChannelRange) -> Result<(), lightning::ln::msgs::LightningError> {
5333                 let mut ret = (self.handle_reply_channel_range)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::lightning::ln::msgs::ReplyChannelRange { inner: ObjOps::heap_alloc(msg), is_owned: true });
5334                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })};
5335                 local_ret
5336         }
5337         fn handle_reply_short_channel_ids_end(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: lightning::ln::msgs::ReplyShortChannelIdsEnd) -> Result<(), lightning::ln::msgs::LightningError> {
5338                 let mut ret = (self.handle_reply_short_channel_ids_end)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::lightning::ln::msgs::ReplyShortChannelIdsEnd { inner: ObjOps::heap_alloc(msg), is_owned: true });
5339                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })};
5340                 local_ret
5341         }
5342         fn handle_query_channel_range(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: lightning::ln::msgs::QueryChannelRange) -> Result<(), lightning::ln::msgs::LightningError> {
5343                 let mut ret = (self.handle_query_channel_range)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::lightning::ln::msgs::QueryChannelRange { inner: ObjOps::heap_alloc(msg), is_owned: true });
5344                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })};
5345                 local_ret
5346         }
5347         fn handle_query_short_channel_ids(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: lightning::ln::msgs::QueryShortChannelIds) -> Result<(), lightning::ln::msgs::LightningError> {
5348                 let mut ret = (self.handle_query_short_channel_ids)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::lightning::ln::msgs::QueryShortChannelIds { inner: ObjOps::heap_alloc(msg), is_owned: true });
5349                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })};
5350                 local_ret
5351         }
5352 }
5353
5354 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
5355 // directly as a Deref trait in higher-level structs:
5356 impl core::ops::Deref for RoutingMessageHandler {
5357         type Target = Self;
5358         fn deref(&self) -> &Self {
5359                 self
5360         }
5361 }
5362 /// Calls the free function if one is set
5363 #[no_mangle]
5364 pub extern "C" fn RoutingMessageHandler_free(this_ptr: RoutingMessageHandler) { }
5365 impl Drop for RoutingMessageHandler {
5366         fn drop(&mut self) {
5367                 if let Some(f) = self.free {
5368                         f(self.this_arg);
5369                 }
5370         }
5371 }
5372 mod fuzzy_internal_msgs {
5373
5374 use alloc::str::FromStr;
5375 use core::ffi::c_void;
5376 use core::convert::Infallible;
5377 use bitcoin::hashes::Hash;
5378 use crate::c_types::*;
5379 #[cfg(feature="no-std")]
5380 use alloc::{vec::Vec, boxed::Box};
5381
5382 }
5383 #[no_mangle]
5384 /// Serialize the AcceptChannel object into a byte array which can be read by AcceptChannel_read
5385 pub extern "C" fn AcceptChannel_write(obj: &AcceptChannel) -> crate::c_types::derived::CVec_u8Z {
5386         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5387 }
5388 #[no_mangle]
5389 pub(crate) extern "C" fn AcceptChannel_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5390         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeAcceptChannel) })
5391 }
5392 #[no_mangle]
5393 /// Read a AcceptChannel from a byte array, created by AcceptChannel_write
5394 pub extern "C" fn AcceptChannel_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_AcceptChannelDecodeErrorZ {
5395         let res: Result<lightning::ln::msgs::AcceptChannel, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5396         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::AcceptChannel { 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() };
5397         local_res
5398 }
5399 #[no_mangle]
5400 /// Serialize the AnnouncementSignatures object into a byte array which can be read by AnnouncementSignatures_read
5401 pub extern "C" fn AnnouncementSignatures_write(obj: &AnnouncementSignatures) -> crate::c_types::derived::CVec_u8Z {
5402         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5403 }
5404 #[no_mangle]
5405 pub(crate) extern "C" fn AnnouncementSignatures_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5406         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeAnnouncementSignatures) })
5407 }
5408 #[no_mangle]
5409 /// Read a AnnouncementSignatures from a byte array, created by AnnouncementSignatures_write
5410 pub extern "C" fn AnnouncementSignatures_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_AnnouncementSignaturesDecodeErrorZ {
5411         let res: Result<lightning::ln::msgs::AnnouncementSignatures, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5412         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::AnnouncementSignatures { 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() };
5413         local_res
5414 }
5415 #[no_mangle]
5416 /// Serialize the ChannelReestablish object into a byte array which can be read by ChannelReestablish_read
5417 pub extern "C" fn ChannelReestablish_write(obj: &ChannelReestablish) -> crate::c_types::derived::CVec_u8Z {
5418         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5419 }
5420 #[no_mangle]
5421 pub(crate) extern "C" fn ChannelReestablish_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5422         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelReestablish) })
5423 }
5424 #[no_mangle]
5425 /// Read a ChannelReestablish from a byte array, created by ChannelReestablish_write
5426 pub extern "C" fn ChannelReestablish_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChannelReestablishDecodeErrorZ {
5427         let res: Result<lightning::ln::msgs::ChannelReestablish, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5428         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ChannelReestablish { 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() };
5429         local_res
5430 }
5431 #[no_mangle]
5432 /// Serialize the ClosingSigned object into a byte array which can be read by ClosingSigned_read
5433 pub extern "C" fn ClosingSigned_write(obj: &ClosingSigned) -> crate::c_types::derived::CVec_u8Z {
5434         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5435 }
5436 #[no_mangle]
5437 pub(crate) extern "C" fn ClosingSigned_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5438         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeClosingSigned) })
5439 }
5440 #[no_mangle]
5441 /// Read a ClosingSigned from a byte array, created by ClosingSigned_write
5442 pub extern "C" fn ClosingSigned_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ClosingSignedDecodeErrorZ {
5443         let res: Result<lightning::ln::msgs::ClosingSigned, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5444         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ClosingSigned { 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() };
5445         local_res
5446 }
5447 #[no_mangle]
5448 /// Serialize the ClosingSignedFeeRange object into a byte array which can be read by ClosingSignedFeeRange_read
5449 pub extern "C" fn ClosingSignedFeeRange_write(obj: &ClosingSignedFeeRange) -> crate::c_types::derived::CVec_u8Z {
5450         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5451 }
5452 #[no_mangle]
5453 pub(crate) extern "C" fn ClosingSignedFeeRange_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5454         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeClosingSignedFeeRange) })
5455 }
5456 #[no_mangle]
5457 /// Read a ClosingSignedFeeRange from a byte array, created by ClosingSignedFeeRange_write
5458 pub extern "C" fn ClosingSignedFeeRange_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ClosingSignedFeeRangeDecodeErrorZ {
5459         let res: Result<lightning::ln::msgs::ClosingSignedFeeRange, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5460         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ClosingSignedFeeRange { 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() };
5461         local_res
5462 }
5463 #[no_mangle]
5464 /// Serialize the CommitmentSigned object into a byte array which can be read by CommitmentSigned_read
5465 pub extern "C" fn CommitmentSigned_write(obj: &CommitmentSigned) -> crate::c_types::derived::CVec_u8Z {
5466         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5467 }
5468 #[no_mangle]
5469 pub(crate) extern "C" fn CommitmentSigned_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5470         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeCommitmentSigned) })
5471 }
5472 #[no_mangle]
5473 /// Read a CommitmentSigned from a byte array, created by CommitmentSigned_write
5474 pub extern "C" fn CommitmentSigned_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_CommitmentSignedDecodeErrorZ {
5475         let res: Result<lightning::ln::msgs::CommitmentSigned, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5476         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::CommitmentSigned { 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() };
5477         local_res
5478 }
5479 #[no_mangle]
5480 /// Serialize the FundingCreated object into a byte array which can be read by FundingCreated_read
5481 pub extern "C" fn FundingCreated_write(obj: &FundingCreated) -> crate::c_types::derived::CVec_u8Z {
5482         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5483 }
5484 #[no_mangle]
5485 pub(crate) extern "C" fn FundingCreated_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5486         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFundingCreated) })
5487 }
5488 #[no_mangle]
5489 /// Read a FundingCreated from a byte array, created by FundingCreated_write
5490 pub extern "C" fn FundingCreated_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_FundingCreatedDecodeErrorZ {
5491         let res: Result<lightning::ln::msgs::FundingCreated, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5492         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::FundingCreated { 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() };
5493         local_res
5494 }
5495 #[no_mangle]
5496 /// Serialize the FundingSigned object into a byte array which can be read by FundingSigned_read
5497 pub extern "C" fn FundingSigned_write(obj: &FundingSigned) -> crate::c_types::derived::CVec_u8Z {
5498         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5499 }
5500 #[no_mangle]
5501 pub(crate) extern "C" fn FundingSigned_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5502         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFundingSigned) })
5503 }
5504 #[no_mangle]
5505 /// Read a FundingSigned from a byte array, created by FundingSigned_write
5506 pub extern "C" fn FundingSigned_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_FundingSignedDecodeErrorZ {
5507         let res: Result<lightning::ln::msgs::FundingSigned, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5508         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::FundingSigned { 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() };
5509         local_res
5510 }
5511 #[no_mangle]
5512 /// Serialize the FundingLocked object into a byte array which can be read by FundingLocked_read
5513 pub extern "C" fn FundingLocked_write(obj: &FundingLocked) -> crate::c_types::derived::CVec_u8Z {
5514         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5515 }
5516 #[no_mangle]
5517 pub(crate) extern "C" fn FundingLocked_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5518         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFundingLocked) })
5519 }
5520 #[no_mangle]
5521 /// Read a FundingLocked from a byte array, created by FundingLocked_write
5522 pub extern "C" fn FundingLocked_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_FundingLockedDecodeErrorZ {
5523         let res: Result<lightning::ln::msgs::FundingLocked, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5524         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::FundingLocked { 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() };
5525         local_res
5526 }
5527 #[no_mangle]
5528 /// Serialize the Init object into a byte array which can be read by Init_read
5529 pub extern "C" fn Init_write(obj: &Init) -> crate::c_types::derived::CVec_u8Z {
5530         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5531 }
5532 #[no_mangle]
5533 pub(crate) extern "C" fn Init_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5534         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeInit) })
5535 }
5536 #[no_mangle]
5537 /// Read a Init from a byte array, created by Init_write
5538 pub extern "C" fn Init_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_InitDecodeErrorZ {
5539         let res: Result<lightning::ln::msgs::Init, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5540         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Init { 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() };
5541         local_res
5542 }
5543 #[no_mangle]
5544 /// Serialize the OpenChannel object into a byte array which can be read by OpenChannel_read
5545 pub extern "C" fn OpenChannel_write(obj: &OpenChannel) -> crate::c_types::derived::CVec_u8Z {
5546         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5547 }
5548 #[no_mangle]
5549 pub(crate) extern "C" fn OpenChannel_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5550         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeOpenChannel) })
5551 }
5552 #[no_mangle]
5553 /// Read a OpenChannel from a byte array, created by OpenChannel_write
5554 pub extern "C" fn OpenChannel_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_OpenChannelDecodeErrorZ {
5555         let res: Result<lightning::ln::msgs::OpenChannel, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5556         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::OpenChannel { 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() };
5557         local_res
5558 }
5559 #[no_mangle]
5560 /// Serialize the RevokeAndACK object into a byte array which can be read by RevokeAndACK_read
5561 pub extern "C" fn RevokeAndACK_write(obj: &RevokeAndACK) -> crate::c_types::derived::CVec_u8Z {
5562         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5563 }
5564 #[no_mangle]
5565 pub(crate) extern "C" fn RevokeAndACK_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5566         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeRevokeAndACK) })
5567 }
5568 #[no_mangle]
5569 /// Read a RevokeAndACK from a byte array, created by RevokeAndACK_write
5570 pub extern "C" fn RevokeAndACK_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_RevokeAndACKDecodeErrorZ {
5571         let res: Result<lightning::ln::msgs::RevokeAndACK, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5572         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::RevokeAndACK { 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() };
5573         local_res
5574 }
5575 #[no_mangle]
5576 /// Serialize the Shutdown object into a byte array which can be read by Shutdown_read
5577 pub extern "C" fn Shutdown_write(obj: &Shutdown) -> crate::c_types::derived::CVec_u8Z {
5578         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5579 }
5580 #[no_mangle]
5581 pub(crate) extern "C" fn Shutdown_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5582         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeShutdown) })
5583 }
5584 #[no_mangle]
5585 /// Read a Shutdown from a byte array, created by Shutdown_write
5586 pub extern "C" fn Shutdown_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ShutdownDecodeErrorZ {
5587         let res: Result<lightning::ln::msgs::Shutdown, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5588         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Shutdown { 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() };
5589         local_res
5590 }
5591 #[no_mangle]
5592 /// Serialize the UpdateFailHTLC object into a byte array which can be read by UpdateFailHTLC_read
5593 pub extern "C" fn UpdateFailHTLC_write(obj: &UpdateFailHTLC) -> crate::c_types::derived::CVec_u8Z {
5594         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5595 }
5596 #[no_mangle]
5597 pub(crate) extern "C" fn UpdateFailHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5598         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFailHTLC) })
5599 }
5600 #[no_mangle]
5601 /// Read a UpdateFailHTLC from a byte array, created by UpdateFailHTLC_write
5602 pub extern "C" fn UpdateFailHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateFailHTLCDecodeErrorZ {
5603         let res: Result<lightning::ln::msgs::UpdateFailHTLC, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5604         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateFailHTLC { 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() };
5605         local_res
5606 }
5607 #[no_mangle]
5608 /// Serialize the UpdateFailMalformedHTLC object into a byte array which can be read by UpdateFailMalformedHTLC_read
5609 pub extern "C" fn UpdateFailMalformedHTLC_write(obj: &UpdateFailMalformedHTLC) -> crate::c_types::derived::CVec_u8Z {
5610         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5611 }
5612 #[no_mangle]
5613 pub(crate) extern "C" fn UpdateFailMalformedHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5614         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFailMalformedHTLC) })
5615 }
5616 #[no_mangle]
5617 /// Read a UpdateFailMalformedHTLC from a byte array, created by UpdateFailMalformedHTLC_write
5618 pub extern "C" fn UpdateFailMalformedHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateFailMalformedHTLCDecodeErrorZ {
5619         let res: Result<lightning::ln::msgs::UpdateFailMalformedHTLC, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5620         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateFailMalformedHTLC { 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() };
5621         local_res
5622 }
5623 #[no_mangle]
5624 /// Serialize the UpdateFee object into a byte array which can be read by UpdateFee_read
5625 pub extern "C" fn UpdateFee_write(obj: &UpdateFee) -> crate::c_types::derived::CVec_u8Z {
5626         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5627 }
5628 #[no_mangle]
5629 pub(crate) extern "C" fn UpdateFee_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5630         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFee) })
5631 }
5632 #[no_mangle]
5633 /// Read a UpdateFee from a byte array, created by UpdateFee_write
5634 pub extern "C" fn UpdateFee_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateFeeDecodeErrorZ {
5635         let res: Result<lightning::ln::msgs::UpdateFee, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5636         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateFee { 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() };
5637         local_res
5638 }
5639 #[no_mangle]
5640 /// Serialize the UpdateFulfillHTLC object into a byte array which can be read by UpdateFulfillHTLC_read
5641 pub extern "C" fn UpdateFulfillHTLC_write(obj: &UpdateFulfillHTLC) -> crate::c_types::derived::CVec_u8Z {
5642         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5643 }
5644 #[no_mangle]
5645 pub(crate) extern "C" fn UpdateFulfillHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5646         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFulfillHTLC) })
5647 }
5648 #[no_mangle]
5649 /// Read a UpdateFulfillHTLC from a byte array, created by UpdateFulfillHTLC_write
5650 pub extern "C" fn UpdateFulfillHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateFulfillHTLCDecodeErrorZ {
5651         let res: Result<lightning::ln::msgs::UpdateFulfillHTLC, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5652         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateFulfillHTLC { 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() };
5653         local_res
5654 }
5655 #[no_mangle]
5656 /// Serialize the UpdateAddHTLC object into a byte array which can be read by UpdateAddHTLC_read
5657 pub extern "C" fn UpdateAddHTLC_write(obj: &UpdateAddHTLC) -> crate::c_types::derived::CVec_u8Z {
5658         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5659 }
5660 #[no_mangle]
5661 pub(crate) extern "C" fn UpdateAddHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5662         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateAddHTLC) })
5663 }
5664 #[no_mangle]
5665 /// Read a UpdateAddHTLC from a byte array, created by UpdateAddHTLC_write
5666 pub extern "C" fn UpdateAddHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateAddHTLCDecodeErrorZ {
5667         let res: Result<lightning::ln::msgs::UpdateAddHTLC, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5668         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateAddHTLC { 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() };
5669         local_res
5670 }
5671 #[no_mangle]
5672 /// Serialize the Ping object into a byte array which can be read by Ping_read
5673 pub extern "C" fn Ping_write(obj: &Ping) -> crate::c_types::derived::CVec_u8Z {
5674         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5675 }
5676 #[no_mangle]
5677 pub(crate) extern "C" fn Ping_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5678         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativePing) })
5679 }
5680 #[no_mangle]
5681 /// Read a Ping from a byte array, created by Ping_write
5682 pub extern "C" fn Ping_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PingDecodeErrorZ {
5683         let res: Result<lightning::ln::msgs::Ping, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5684         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Ping { 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() };
5685         local_res
5686 }
5687 #[no_mangle]
5688 /// Serialize the Pong object into a byte array which can be read by Pong_read
5689 pub extern "C" fn Pong_write(obj: &Pong) -> crate::c_types::derived::CVec_u8Z {
5690         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5691 }
5692 #[no_mangle]
5693 pub(crate) extern "C" fn Pong_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5694         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativePong) })
5695 }
5696 #[no_mangle]
5697 /// Read a Pong from a byte array, created by Pong_write
5698 pub extern "C" fn Pong_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PongDecodeErrorZ {
5699         let res: Result<lightning::ln::msgs::Pong, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5700         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Pong { 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() };
5701         local_res
5702 }
5703 #[no_mangle]
5704 /// Serialize the UnsignedChannelAnnouncement object into a byte array which can be read by UnsignedChannelAnnouncement_read
5705 pub extern "C" fn UnsignedChannelAnnouncement_write(obj: &UnsignedChannelAnnouncement) -> crate::c_types::derived::CVec_u8Z {
5706         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5707 }
5708 #[no_mangle]
5709 pub(crate) extern "C" fn UnsignedChannelAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5710         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUnsignedChannelAnnouncement) })
5711 }
5712 #[no_mangle]
5713 /// Read a UnsignedChannelAnnouncement from a byte array, created by UnsignedChannelAnnouncement_write
5714 pub extern "C" fn UnsignedChannelAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UnsignedChannelAnnouncementDecodeErrorZ {
5715         let res: Result<lightning::ln::msgs::UnsignedChannelAnnouncement, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5716         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UnsignedChannelAnnouncement { 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() };
5717         local_res
5718 }
5719 #[no_mangle]
5720 /// Serialize the ChannelAnnouncement object into a byte array which can be read by ChannelAnnouncement_read
5721 pub extern "C" fn ChannelAnnouncement_write(obj: &ChannelAnnouncement) -> crate::c_types::derived::CVec_u8Z {
5722         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5723 }
5724 #[no_mangle]
5725 pub(crate) extern "C" fn ChannelAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5726         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelAnnouncement) })
5727 }
5728 #[no_mangle]
5729 /// Read a ChannelAnnouncement from a byte array, created by ChannelAnnouncement_write
5730 pub extern "C" fn ChannelAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChannelAnnouncementDecodeErrorZ {
5731         let res: Result<lightning::ln::msgs::ChannelAnnouncement, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5732         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ChannelAnnouncement { 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() };
5733         local_res
5734 }
5735 #[no_mangle]
5736 /// Serialize the UnsignedChannelUpdate object into a byte array which can be read by UnsignedChannelUpdate_read
5737 pub extern "C" fn UnsignedChannelUpdate_write(obj: &UnsignedChannelUpdate) -> crate::c_types::derived::CVec_u8Z {
5738         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5739 }
5740 #[no_mangle]
5741 pub(crate) extern "C" fn UnsignedChannelUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5742         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUnsignedChannelUpdate) })
5743 }
5744 #[no_mangle]
5745 /// Read a UnsignedChannelUpdate from a byte array, created by UnsignedChannelUpdate_write
5746 pub extern "C" fn UnsignedChannelUpdate_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UnsignedChannelUpdateDecodeErrorZ {
5747         let res: Result<lightning::ln::msgs::UnsignedChannelUpdate, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5748         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UnsignedChannelUpdate { 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() };
5749         local_res
5750 }
5751 #[no_mangle]
5752 /// Serialize the ChannelUpdate object into a byte array which can be read by ChannelUpdate_read
5753 pub extern "C" fn ChannelUpdate_write(obj: &ChannelUpdate) -> crate::c_types::derived::CVec_u8Z {
5754         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5755 }
5756 #[no_mangle]
5757 pub(crate) extern "C" fn ChannelUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5758         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelUpdate) })
5759 }
5760 #[no_mangle]
5761 /// Read a ChannelUpdate from a byte array, created by ChannelUpdate_write
5762 pub extern "C" fn ChannelUpdate_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChannelUpdateDecodeErrorZ {
5763         let res: Result<lightning::ln::msgs::ChannelUpdate, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5764         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ChannelUpdate { 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() };
5765         local_res
5766 }
5767 #[no_mangle]
5768 /// Serialize the ErrorMessage object into a byte array which can be read by ErrorMessage_read
5769 pub extern "C" fn ErrorMessage_write(obj: &ErrorMessage) -> crate::c_types::derived::CVec_u8Z {
5770         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5771 }
5772 #[no_mangle]
5773 pub(crate) extern "C" fn ErrorMessage_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5774         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeErrorMessage) })
5775 }
5776 #[no_mangle]
5777 /// Read a ErrorMessage from a byte array, created by ErrorMessage_write
5778 pub extern "C" fn ErrorMessage_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ErrorMessageDecodeErrorZ {
5779         let res: Result<lightning::ln::msgs::ErrorMessage, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5780         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ErrorMessage { 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() };
5781         local_res
5782 }
5783 #[no_mangle]
5784 /// Serialize the WarningMessage object into a byte array which can be read by WarningMessage_read
5785 pub extern "C" fn WarningMessage_write(obj: &WarningMessage) -> crate::c_types::derived::CVec_u8Z {
5786         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5787 }
5788 #[no_mangle]
5789 pub(crate) extern "C" fn WarningMessage_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5790         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeWarningMessage) })
5791 }
5792 #[no_mangle]
5793 /// Read a WarningMessage from a byte array, created by WarningMessage_write
5794 pub extern "C" fn WarningMessage_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_WarningMessageDecodeErrorZ {
5795         let res: Result<lightning::ln::msgs::WarningMessage, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5796         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::WarningMessage { 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() };
5797         local_res
5798 }
5799 #[no_mangle]
5800 /// Serialize the UnsignedNodeAnnouncement object into a byte array which can be read by UnsignedNodeAnnouncement_read
5801 pub extern "C" fn UnsignedNodeAnnouncement_write(obj: &UnsignedNodeAnnouncement) -> crate::c_types::derived::CVec_u8Z {
5802         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5803 }
5804 #[no_mangle]
5805 pub(crate) extern "C" fn UnsignedNodeAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5806         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUnsignedNodeAnnouncement) })
5807 }
5808 #[no_mangle]
5809 /// Read a UnsignedNodeAnnouncement from a byte array, created by UnsignedNodeAnnouncement_write
5810 pub extern "C" fn UnsignedNodeAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UnsignedNodeAnnouncementDecodeErrorZ {
5811         let res: Result<lightning::ln::msgs::UnsignedNodeAnnouncement, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5812         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UnsignedNodeAnnouncement { 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() };
5813         local_res
5814 }
5815 #[no_mangle]
5816 /// Serialize the NodeAnnouncement object into a byte array which can be read by NodeAnnouncement_read
5817 pub extern "C" fn NodeAnnouncement_write(obj: &NodeAnnouncement) -> crate::c_types::derived::CVec_u8Z {
5818         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5819 }
5820 #[no_mangle]
5821 pub(crate) extern "C" fn NodeAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5822         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeNodeAnnouncement) })
5823 }
5824 #[no_mangle]
5825 /// Read a NodeAnnouncement from a byte array, created by NodeAnnouncement_write
5826 pub extern "C" fn NodeAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_NodeAnnouncementDecodeErrorZ {
5827         let res: Result<lightning::ln::msgs::NodeAnnouncement, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5828         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::NodeAnnouncement { 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() };
5829         local_res
5830 }
5831 #[no_mangle]
5832 /// Read a QueryShortChannelIds from a byte array, created by QueryShortChannelIds_write
5833 pub extern "C" fn QueryShortChannelIds_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_QueryShortChannelIdsDecodeErrorZ {
5834         let res: Result<lightning::ln::msgs::QueryShortChannelIds, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5835         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::QueryShortChannelIds { 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() };
5836         local_res
5837 }
5838 #[no_mangle]
5839 /// Serialize the QueryShortChannelIds object into a byte array which can be read by QueryShortChannelIds_read
5840 pub extern "C" fn QueryShortChannelIds_write(obj: &QueryShortChannelIds) -> crate::c_types::derived::CVec_u8Z {
5841         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5842 }
5843 #[no_mangle]
5844 pub(crate) extern "C" fn QueryShortChannelIds_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5845         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeQueryShortChannelIds) })
5846 }
5847 #[no_mangle]
5848 /// Serialize the ReplyShortChannelIdsEnd object into a byte array which can be read by ReplyShortChannelIdsEnd_read
5849 pub extern "C" fn ReplyShortChannelIdsEnd_write(obj: &ReplyShortChannelIdsEnd) -> crate::c_types::derived::CVec_u8Z {
5850         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5851 }
5852 #[no_mangle]
5853 pub(crate) extern "C" fn ReplyShortChannelIdsEnd_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5854         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeReplyShortChannelIdsEnd) })
5855 }
5856 #[no_mangle]
5857 /// Read a ReplyShortChannelIdsEnd from a byte array, created by ReplyShortChannelIdsEnd_write
5858 pub extern "C" fn ReplyShortChannelIdsEnd_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ReplyShortChannelIdsEndDecodeErrorZ {
5859         let res: Result<lightning::ln::msgs::ReplyShortChannelIdsEnd, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5860         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ReplyShortChannelIdsEnd { 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() };
5861         local_res
5862 }
5863 ///\n\t * Calculates the overflow safe ending block height for the query.\n\t * Overflow returns `0xffffffff`, otherwise returns `first_blocknum + number_of_blocks`\n\t
5864 #[must_use]
5865 #[no_mangle]
5866 pub extern "C" fn QueryChannelRange_end_blocknum(this_arg: &QueryChannelRange) -> u32 {
5867         let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.end_blocknum();
5868         ret
5869 }
5870
5871 #[no_mangle]
5872 /// Serialize the QueryChannelRange object into a byte array which can be read by QueryChannelRange_read
5873 pub extern "C" fn QueryChannelRange_write(obj: &QueryChannelRange) -> crate::c_types::derived::CVec_u8Z {
5874         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5875 }
5876 #[no_mangle]
5877 pub(crate) extern "C" fn QueryChannelRange_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5878         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeQueryChannelRange) })
5879 }
5880 #[no_mangle]
5881 /// Read a QueryChannelRange from a byte array, created by QueryChannelRange_write
5882 pub extern "C" fn QueryChannelRange_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_QueryChannelRangeDecodeErrorZ {
5883         let res: Result<lightning::ln::msgs::QueryChannelRange, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5884         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::QueryChannelRange { 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() };
5885         local_res
5886 }
5887 #[no_mangle]
5888 /// Read a ReplyChannelRange from a byte array, created by ReplyChannelRange_write
5889 pub extern "C" fn ReplyChannelRange_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ReplyChannelRangeDecodeErrorZ {
5890         let res: Result<lightning::ln::msgs::ReplyChannelRange, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5891         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ReplyChannelRange { 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() };
5892         local_res
5893 }
5894 #[no_mangle]
5895 /// Serialize the ReplyChannelRange object into a byte array which can be read by ReplyChannelRange_read
5896 pub extern "C" fn ReplyChannelRange_write(obj: &ReplyChannelRange) -> crate::c_types::derived::CVec_u8Z {
5897         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5898 }
5899 #[no_mangle]
5900 pub(crate) extern "C" fn ReplyChannelRange_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5901         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeReplyChannelRange) })
5902 }
5903 #[no_mangle]
5904 /// Serialize the GossipTimestampFilter object into a byte array which can be read by GossipTimestampFilter_read
5905 pub extern "C" fn GossipTimestampFilter_write(obj: &GossipTimestampFilter) -> crate::c_types::derived::CVec_u8Z {
5906         crate::c_types::serialize_obj(unsafe { &*obj }.get_native_ref())
5907 }
5908 #[no_mangle]
5909 pub(crate) extern "C" fn GossipTimestampFilter_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5910         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeGossipTimestampFilter) })
5911 }
5912 #[no_mangle]
5913 /// Read a GossipTimestampFilter from a byte array, created by GossipTimestampFilter_write
5914 pub extern "C" fn GossipTimestampFilter_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_GossipTimestampFilterDecodeErrorZ {
5915         let res: Result<lightning::ln::msgs::GossipTimestampFilter, lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj(ser);
5916         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::GossipTimestampFilter { 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() };
5917         local_res
5918 }