1 // This file is Copyright its original authors, visible in version control
2 // history and in the source files from which this was generated.
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.
9 //! Wire messages, traits representing wire message handlers, and a few error types live here.
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
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.
26 use std::str::FromStr;
28 use bitcoin::hashes::Hash;
29 use crate::c_types::*;
32 use lightning::ln::msgs::DecodeError as nativeDecodeErrorImport;
33 type nativeDecodeError = nativeDecodeErrorImport;
35 /// An error in decoding a message or struct.
38 pub struct DecodeError {
39 /// A pointer to the opaque Rust object.
41 /// Nearly everywhere, inner must be non-null, however in places where
42 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
43 pub inner: *mut nativeDecodeError,
44 /// Indicates that this is the only struct which contains the same pointer.
46 /// Rust functions which take ownership of an object provided via an argument require
47 /// this to be true and invalidate the object pointed to by inner.
51 impl Drop for DecodeError {
53 if self.is_owned && !<*mut nativeDecodeError>::is_null(self.inner) {
54 let _ = unsafe { Box::from_raw(self.inner) };
58 /// Frees any resources used by the DecodeError, if is_owned is set and inner is non-NULL.
60 pub extern "C" fn DecodeError_free(this_obj: DecodeError) { }
62 /// Used only if an object of this type is returned as a trait impl by a method
63 extern "C" fn DecodeError_free_void(this_ptr: *mut c_void) {
64 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDecodeError); }
67 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
69 pub(crate) fn take_inner(mut self) -> *mut nativeDecodeError {
70 assert!(self.is_owned);
72 self.inner = std::ptr::null_mut();
76 impl Clone for DecodeError {
77 fn clone(&self) -> Self {
79 inner: if <*mut nativeDecodeError>::is_null(self.inner) { std::ptr::null_mut() } else {
80 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
86 /// Used only if an object of this type is returned as a trait impl by a method
87 pub(crate) extern "C" fn DecodeError_clone_void(this_ptr: *const c_void) -> *mut c_void {
88 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeDecodeError)).clone() })) as *mut c_void
91 /// Creates a copy of the DecodeError
92 pub extern "C" fn DecodeError_clone(orig: &DecodeError) -> DecodeError {
96 use lightning::ln::msgs::Init as nativeInitImport;
97 type nativeInit = nativeInitImport;
99 /// An init message to be sent or received from a peer
103 /// A pointer to the opaque Rust object.
105 /// Nearly everywhere, inner must be non-null, however in places where
106 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
107 pub inner: *mut nativeInit,
108 /// Indicates that this is the only struct which contains the same pointer.
110 /// Rust functions which take ownership of an object provided via an argument require
111 /// this to be true and invalidate the object pointed to by inner.
117 if self.is_owned && !<*mut nativeInit>::is_null(self.inner) {
118 let _ = unsafe { Box::from_raw(self.inner) };
122 /// Frees any resources used by the Init, if is_owned is set and inner is non-NULL.
124 pub extern "C" fn Init_free(this_obj: Init) { }
126 /// Used only if an object of this type is returned as a trait impl by a method
127 extern "C" fn Init_free_void(this_ptr: *mut c_void) {
128 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeInit); }
131 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
133 pub(crate) fn take_inner(mut self) -> *mut nativeInit {
134 assert!(self.is_owned);
135 let ret = self.inner;
136 self.inner = std::ptr::null_mut();
140 /// The relevant features which the sender supports
142 pub extern "C" fn Init_get_features(this_ptr: &Init) -> crate::lightning::ln::features::InitFeatures {
143 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.features;
144 crate::lightning::ln::features::InitFeatures { inner: unsafe { ( (&(*inner_val) as *const _) as *mut _) }, is_owned: false }
146 /// The relevant features which the sender supports
148 pub extern "C" fn Init_set_features(this_ptr: &mut Init, mut val: crate::lightning::ln::features::InitFeatures) {
149 unsafe { &mut *this_ptr.inner }.features = *unsafe { Box::from_raw(val.take_inner()) };
151 /// Constructs a new Init given each field
154 pub extern "C" fn Init_new(mut features_arg: crate::lightning::ln::features::InitFeatures) -> Init {
155 Init { inner: Box::into_raw(Box::new(nativeInit {
156 features: *unsafe { Box::from_raw(features_arg.take_inner()) },
157 })), is_owned: true }
159 impl Clone for Init {
160 fn clone(&self) -> Self {
162 inner: if <*mut nativeInit>::is_null(self.inner) { std::ptr::null_mut() } else {
163 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
169 /// Used only if an object of this type is returned as a trait impl by a method
170 pub(crate) extern "C" fn Init_clone_void(this_ptr: *const c_void) -> *mut c_void {
171 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInit)).clone() })) as *mut c_void
174 /// Creates a copy of the Init
175 pub extern "C" fn Init_clone(orig: &Init) -> Init {
179 use lightning::ln::msgs::ErrorMessage as nativeErrorMessageImport;
180 type nativeErrorMessage = nativeErrorMessageImport;
182 /// An error message to be sent or received from a peer
185 pub struct ErrorMessage {
186 /// A pointer to the opaque Rust object.
188 /// Nearly everywhere, inner must be non-null, however in places where
189 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
190 pub inner: *mut nativeErrorMessage,
191 /// Indicates that this is the only struct which contains the same pointer.
193 /// Rust functions which take ownership of an object provided via an argument require
194 /// this to be true and invalidate the object pointed to by inner.
198 impl Drop for ErrorMessage {
200 if self.is_owned && !<*mut nativeErrorMessage>::is_null(self.inner) {
201 let _ = unsafe { Box::from_raw(self.inner) };
205 /// Frees any resources used by the ErrorMessage, if is_owned is set and inner is non-NULL.
207 pub extern "C" fn ErrorMessage_free(this_obj: ErrorMessage) { }
209 /// Used only if an object of this type is returned as a trait impl by a method
210 extern "C" fn ErrorMessage_free_void(this_ptr: *mut c_void) {
211 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeErrorMessage); }
214 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
216 pub(crate) fn take_inner(mut self) -> *mut nativeErrorMessage {
217 assert!(self.is_owned);
218 let ret = self.inner;
219 self.inner = std::ptr::null_mut();
223 /// The channel ID involved in the error
225 pub extern "C" fn ErrorMessage_get_channel_id(this_ptr: &ErrorMessage) -> *const [u8; 32] {
226 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
229 /// The channel ID involved in the error
231 pub extern "C" fn ErrorMessage_set_channel_id(this_ptr: &mut ErrorMessage, mut val: crate::c_types::ThirtyTwoBytes) {
232 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
234 /// A possibly human-readable error description.
235 /// The string should be sanitized before it is used (e.g. emitted to logs
236 /// or printed to stdout). Otherwise, a well crafted error message may trigger a security
237 /// vulnerability in the terminal emulator or the logging subsystem.
239 pub extern "C" fn ErrorMessage_get_data(this_ptr: &ErrorMessage) -> crate::c_types::Str {
240 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.data;
241 inner_val.as_str().into()
243 /// A possibly human-readable error description.
244 /// The string should be sanitized before it is used (e.g. emitted to logs
245 /// or printed to stdout). Otherwise, a well crafted error message may trigger a security
246 /// vulnerability in the terminal emulator or the logging subsystem.
248 pub extern "C" fn ErrorMessage_set_data(this_ptr: &mut ErrorMessage, mut val: crate::c_types::Str) {
249 unsafe { &mut *this_ptr.inner }.data = val.into_string();
251 /// Constructs a new ErrorMessage given each field
254 pub extern "C" fn ErrorMessage_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut data_arg: crate::c_types::Str) -> ErrorMessage {
255 ErrorMessage { inner: Box::into_raw(Box::new(nativeErrorMessage {
256 channel_id: channel_id_arg.data,
257 data: data_arg.into_string(),
258 })), is_owned: true }
260 impl Clone for ErrorMessage {
261 fn clone(&self) -> Self {
263 inner: if <*mut nativeErrorMessage>::is_null(self.inner) { std::ptr::null_mut() } else {
264 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
270 /// Used only if an object of this type is returned as a trait impl by a method
271 pub(crate) extern "C" fn ErrorMessage_clone_void(this_ptr: *const c_void) -> *mut c_void {
272 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeErrorMessage)).clone() })) as *mut c_void
275 /// Creates a copy of the ErrorMessage
276 pub extern "C" fn ErrorMessage_clone(orig: &ErrorMessage) -> ErrorMessage {
280 use lightning::ln::msgs::Ping as nativePingImport;
281 type nativePing = nativePingImport;
283 /// A ping message to be sent or received from a peer
287 /// A pointer to the opaque Rust object.
289 /// Nearly everywhere, inner must be non-null, however in places where
290 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
291 pub inner: *mut nativePing,
292 /// Indicates that this is the only struct which contains the same pointer.
294 /// Rust functions which take ownership of an object provided via an argument require
295 /// this to be true and invalidate the object pointed to by inner.
301 if self.is_owned && !<*mut nativePing>::is_null(self.inner) {
302 let _ = unsafe { Box::from_raw(self.inner) };
306 /// Frees any resources used by the Ping, if is_owned is set and inner is non-NULL.
308 pub extern "C" fn Ping_free(this_obj: Ping) { }
310 /// Used only if an object of this type is returned as a trait impl by a method
311 extern "C" fn Ping_free_void(this_ptr: *mut c_void) {
312 unsafe { let _ = Box::from_raw(this_ptr as *mut nativePing); }
315 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
317 pub(crate) fn take_inner(mut self) -> *mut nativePing {
318 assert!(self.is_owned);
319 let ret = self.inner;
320 self.inner = std::ptr::null_mut();
324 /// The desired response length
326 pub extern "C" fn Ping_get_ponglen(this_ptr: &Ping) -> u16 {
327 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.ponglen;
330 /// The desired response length
332 pub extern "C" fn Ping_set_ponglen(this_ptr: &mut Ping, mut val: u16) {
333 unsafe { &mut *this_ptr.inner }.ponglen = val;
335 /// The ping packet size.
336 /// This field is not sent on the wire. byteslen zeros are sent.
338 pub extern "C" fn Ping_get_byteslen(this_ptr: &Ping) -> u16 {
339 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.byteslen;
342 /// The ping packet size.
343 /// This field is not sent on the wire. byteslen zeros are sent.
345 pub extern "C" fn Ping_set_byteslen(this_ptr: &mut Ping, mut val: u16) {
346 unsafe { &mut *this_ptr.inner }.byteslen = val;
348 /// Constructs a new Ping given each field
351 pub extern "C" fn Ping_new(mut ponglen_arg: u16, mut byteslen_arg: u16) -> Ping {
352 Ping { inner: Box::into_raw(Box::new(nativePing {
353 ponglen: ponglen_arg,
354 byteslen: byteslen_arg,
355 })), is_owned: true }
357 impl Clone for Ping {
358 fn clone(&self) -> Self {
360 inner: if <*mut nativePing>::is_null(self.inner) { std::ptr::null_mut() } else {
361 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
367 /// Used only if an object of this type is returned as a trait impl by a method
368 pub(crate) extern "C" fn Ping_clone_void(this_ptr: *const c_void) -> *mut c_void {
369 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePing)).clone() })) as *mut c_void
372 /// Creates a copy of the Ping
373 pub extern "C" fn Ping_clone(orig: &Ping) -> Ping {
377 use lightning::ln::msgs::Pong as nativePongImport;
378 type nativePong = nativePongImport;
380 /// A pong message to be sent or received from a peer
384 /// A pointer to the opaque Rust object.
386 /// Nearly everywhere, inner must be non-null, however in places where
387 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
388 pub inner: *mut nativePong,
389 /// Indicates that this is the only struct which contains the same pointer.
391 /// Rust functions which take ownership of an object provided via an argument require
392 /// this to be true and invalidate the object pointed to by inner.
398 if self.is_owned && !<*mut nativePong>::is_null(self.inner) {
399 let _ = unsafe { Box::from_raw(self.inner) };
403 /// Frees any resources used by the Pong, if is_owned is set and inner is non-NULL.
405 pub extern "C" fn Pong_free(this_obj: Pong) { }
407 /// Used only if an object of this type is returned as a trait impl by a method
408 extern "C" fn Pong_free_void(this_ptr: *mut c_void) {
409 unsafe { let _ = Box::from_raw(this_ptr as *mut nativePong); }
412 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
414 pub(crate) fn take_inner(mut self) -> *mut nativePong {
415 assert!(self.is_owned);
416 let ret = self.inner;
417 self.inner = std::ptr::null_mut();
421 /// The pong packet size.
422 /// This field is not sent on the wire. byteslen zeros are sent.
424 pub extern "C" fn Pong_get_byteslen(this_ptr: &Pong) -> u16 {
425 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.byteslen;
428 /// The pong packet size.
429 /// This field is not sent on the wire. byteslen zeros are sent.
431 pub extern "C" fn Pong_set_byteslen(this_ptr: &mut Pong, mut val: u16) {
432 unsafe { &mut *this_ptr.inner }.byteslen = val;
434 /// Constructs a new Pong given each field
437 pub extern "C" fn Pong_new(mut byteslen_arg: u16) -> Pong {
438 Pong { inner: Box::into_raw(Box::new(nativePong {
439 byteslen: byteslen_arg,
440 })), is_owned: true }
442 impl Clone for Pong {
443 fn clone(&self) -> Self {
445 inner: if <*mut nativePong>::is_null(self.inner) { std::ptr::null_mut() } else {
446 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
452 /// Used only if an object of this type is returned as a trait impl by a method
453 pub(crate) extern "C" fn Pong_clone_void(this_ptr: *const c_void) -> *mut c_void {
454 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePong)).clone() })) as *mut c_void
457 /// Creates a copy of the Pong
458 pub extern "C" fn Pong_clone(orig: &Pong) -> Pong {
462 use lightning::ln::msgs::OpenChannel as nativeOpenChannelImport;
463 type nativeOpenChannel = nativeOpenChannelImport;
465 /// An open_channel message to be sent or received from a peer
468 pub struct OpenChannel {
469 /// A pointer to the opaque Rust object.
471 /// Nearly everywhere, inner must be non-null, however in places where
472 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
473 pub inner: *mut nativeOpenChannel,
474 /// Indicates that this is the only struct which contains the same pointer.
476 /// Rust functions which take ownership of an object provided via an argument require
477 /// this to be true and invalidate the object pointed to by inner.
481 impl Drop for OpenChannel {
483 if self.is_owned && !<*mut nativeOpenChannel>::is_null(self.inner) {
484 let _ = unsafe { Box::from_raw(self.inner) };
488 /// Frees any resources used by the OpenChannel, if is_owned is set and inner is non-NULL.
490 pub extern "C" fn OpenChannel_free(this_obj: OpenChannel) { }
492 /// Used only if an object of this type is returned as a trait impl by a method
493 extern "C" fn OpenChannel_free_void(this_ptr: *mut c_void) {
494 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeOpenChannel); }
497 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
499 pub(crate) fn take_inner(mut self) -> *mut nativeOpenChannel {
500 assert!(self.is_owned);
501 let ret = self.inner;
502 self.inner = std::ptr::null_mut();
506 /// The genesis hash of the blockchain where the channel is to be opened
508 pub extern "C" fn OpenChannel_get_chain_hash(this_ptr: &OpenChannel) -> *const [u8; 32] {
509 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash;
512 /// The genesis hash of the blockchain where the channel is to be opened
514 pub extern "C" fn OpenChannel_set_chain_hash(this_ptr: &mut OpenChannel, mut val: crate::c_types::ThirtyTwoBytes) {
515 unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
517 /// A temporary channel ID, until the funding outpoint is announced
519 pub extern "C" fn OpenChannel_get_temporary_channel_id(this_ptr: &OpenChannel) -> *const [u8; 32] {
520 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.temporary_channel_id;
523 /// A temporary channel ID, until the funding outpoint is announced
525 pub extern "C" fn OpenChannel_set_temporary_channel_id(this_ptr: &mut OpenChannel, mut val: crate::c_types::ThirtyTwoBytes) {
526 unsafe { &mut *this_ptr.inner }.temporary_channel_id = val.data;
528 /// The channel value
530 pub extern "C" fn OpenChannel_get_funding_satoshis(this_ptr: &OpenChannel) -> u64 {
531 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_satoshis;
534 /// The channel value
536 pub extern "C" fn OpenChannel_set_funding_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
537 unsafe { &mut *this_ptr.inner }.funding_satoshis = val;
539 /// The amount to push to the counterparty as part of the open, in milli-satoshi
541 pub extern "C" fn OpenChannel_get_push_msat(this_ptr: &OpenChannel) -> u64 {
542 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.push_msat;
545 /// The amount to push to the counterparty as part of the open, in milli-satoshi
547 pub extern "C" fn OpenChannel_set_push_msat(this_ptr: &mut OpenChannel, mut val: u64) {
548 unsafe { &mut *this_ptr.inner }.push_msat = val;
550 /// The threshold below which outputs on transactions broadcast by sender will be omitted
552 pub extern "C" fn OpenChannel_get_dust_limit_satoshis(this_ptr: &OpenChannel) -> u64 {
553 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.dust_limit_satoshis;
556 /// The threshold below which outputs on transactions broadcast by sender will be omitted
558 pub extern "C" fn OpenChannel_set_dust_limit_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
559 unsafe { &mut *this_ptr.inner }.dust_limit_satoshis = val;
561 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
563 pub extern "C" fn OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: &OpenChannel) -> u64 {
564 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_htlc_value_in_flight_msat;
567 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
569 pub extern "C" fn OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: &mut OpenChannel, mut val: u64) {
570 unsafe { &mut *this_ptr.inner }.max_htlc_value_in_flight_msat = val;
572 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
574 pub extern "C" fn OpenChannel_get_channel_reserve_satoshis(this_ptr: &OpenChannel) -> u64 {
575 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_reserve_satoshis;
578 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
580 pub extern "C" fn OpenChannel_set_channel_reserve_satoshis(this_ptr: &mut OpenChannel, mut val: u64) {
581 unsafe { &mut *this_ptr.inner }.channel_reserve_satoshis = val;
583 /// The minimum HTLC size incoming to sender, in milli-satoshi
585 pub extern "C" fn OpenChannel_get_htlc_minimum_msat(this_ptr: &OpenChannel) -> u64 {
586 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_minimum_msat;
589 /// The minimum HTLC size incoming to sender, in milli-satoshi
591 pub extern "C" fn OpenChannel_set_htlc_minimum_msat(this_ptr: &mut OpenChannel, mut val: u64) {
592 unsafe { &mut *this_ptr.inner }.htlc_minimum_msat = val;
594 /// The feerate per 1000-weight of sender generated transactions, until updated by update_fee
596 pub extern "C" fn OpenChannel_get_feerate_per_kw(this_ptr: &OpenChannel) -> u32 {
597 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.feerate_per_kw;
600 /// The feerate per 1000-weight of sender generated transactions, until updated by update_fee
602 pub extern "C" fn OpenChannel_set_feerate_per_kw(this_ptr: &mut OpenChannel, mut val: u32) {
603 unsafe { &mut *this_ptr.inner }.feerate_per_kw = val;
605 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
607 pub extern "C" fn OpenChannel_get_to_self_delay(this_ptr: &OpenChannel) -> u16 {
608 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.to_self_delay;
611 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
613 pub extern "C" fn OpenChannel_set_to_self_delay(this_ptr: &mut OpenChannel, mut val: u16) {
614 unsafe { &mut *this_ptr.inner }.to_self_delay = val;
616 /// The maximum number of inbound HTLCs towards sender
618 pub extern "C" fn OpenChannel_get_max_accepted_htlcs(this_ptr: &OpenChannel) -> u16 {
619 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_accepted_htlcs;
622 /// The maximum number of inbound HTLCs towards sender
624 pub extern "C" fn OpenChannel_set_max_accepted_htlcs(this_ptr: &mut OpenChannel, mut val: u16) {
625 unsafe { &mut *this_ptr.inner }.max_accepted_htlcs = val;
627 /// The sender's key controlling the funding transaction
629 pub extern "C" fn OpenChannel_get_funding_pubkey(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
630 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_pubkey;
631 crate::c_types::PublicKey::from_rust(&inner_val)
633 /// The sender's key controlling the funding transaction
635 pub extern "C" fn OpenChannel_set_funding_pubkey(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
636 unsafe { &mut *this_ptr.inner }.funding_pubkey = val.into_rust();
638 /// Used to derive a revocation key for transactions broadcast by counterparty
640 pub extern "C" fn OpenChannel_get_revocation_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
641 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_basepoint;
642 crate::c_types::PublicKey::from_rust(&inner_val)
644 /// Used to derive a revocation key for transactions broadcast by counterparty
646 pub extern "C" fn OpenChannel_set_revocation_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
647 unsafe { &mut *this_ptr.inner }.revocation_basepoint = val.into_rust();
649 /// A payment key to sender for transactions broadcast by counterparty
651 pub extern "C" fn OpenChannel_get_payment_point(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
652 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_point;
653 crate::c_types::PublicKey::from_rust(&inner_val)
655 /// A payment key to sender for transactions broadcast by counterparty
657 pub extern "C" fn OpenChannel_set_payment_point(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
658 unsafe { &mut *this_ptr.inner }.payment_point = val.into_rust();
660 /// Used to derive a payment key to sender for transactions broadcast by sender
662 pub extern "C" fn OpenChannel_get_delayed_payment_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
663 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint;
664 crate::c_types::PublicKey::from_rust(&inner_val)
666 /// Used to derive a payment key to sender for transactions broadcast by sender
668 pub extern "C" fn OpenChannel_set_delayed_payment_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
669 unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint = val.into_rust();
671 /// Used to derive an HTLC payment key to sender
673 pub extern "C" fn OpenChannel_get_htlc_basepoint(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
674 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_basepoint;
675 crate::c_types::PublicKey::from_rust(&inner_val)
677 /// Used to derive an HTLC payment key to sender
679 pub extern "C" fn OpenChannel_set_htlc_basepoint(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
680 unsafe { &mut *this_ptr.inner }.htlc_basepoint = val.into_rust();
682 /// The first to-be-broadcast-by-sender transaction's per commitment point
684 pub extern "C" fn OpenChannel_get_first_per_commitment_point(this_ptr: &OpenChannel) -> crate::c_types::PublicKey {
685 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.first_per_commitment_point;
686 crate::c_types::PublicKey::from_rust(&inner_val)
688 /// The first to-be-broadcast-by-sender transaction's per commitment point
690 pub extern "C" fn OpenChannel_set_first_per_commitment_point(this_ptr: &mut OpenChannel, mut val: crate::c_types::PublicKey) {
691 unsafe { &mut *this_ptr.inner }.first_per_commitment_point = val.into_rust();
695 pub extern "C" fn OpenChannel_get_channel_flags(this_ptr: &OpenChannel) -> u8 {
696 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_flags;
701 pub extern "C" fn OpenChannel_set_channel_flags(this_ptr: &mut OpenChannel, mut val: u8) {
702 unsafe { &mut *this_ptr.inner }.channel_flags = val;
704 impl Clone for OpenChannel {
705 fn clone(&self) -> Self {
707 inner: if <*mut nativeOpenChannel>::is_null(self.inner) { std::ptr::null_mut() } else {
708 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
714 /// Used only if an object of this type is returned as a trait impl by a method
715 pub(crate) extern "C" fn OpenChannel_clone_void(this_ptr: *const c_void) -> *mut c_void {
716 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeOpenChannel)).clone() })) as *mut c_void
719 /// Creates a copy of the OpenChannel
720 pub extern "C" fn OpenChannel_clone(orig: &OpenChannel) -> OpenChannel {
724 use lightning::ln::msgs::AcceptChannel as nativeAcceptChannelImport;
725 type nativeAcceptChannel = nativeAcceptChannelImport;
727 /// An accept_channel message to be sent or received from a peer
730 pub struct AcceptChannel {
731 /// A pointer to the opaque Rust object.
733 /// Nearly everywhere, inner must be non-null, however in places where
734 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
735 pub inner: *mut nativeAcceptChannel,
736 /// Indicates that this is the only struct which contains the same pointer.
738 /// Rust functions which take ownership of an object provided via an argument require
739 /// this to be true and invalidate the object pointed to by inner.
743 impl Drop for AcceptChannel {
745 if self.is_owned && !<*mut nativeAcceptChannel>::is_null(self.inner) {
746 let _ = unsafe { Box::from_raw(self.inner) };
750 /// Frees any resources used by the AcceptChannel, if is_owned is set and inner is non-NULL.
752 pub extern "C" fn AcceptChannel_free(this_obj: AcceptChannel) { }
754 /// Used only if an object of this type is returned as a trait impl by a method
755 extern "C" fn AcceptChannel_free_void(this_ptr: *mut c_void) {
756 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeAcceptChannel); }
759 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
761 pub(crate) fn take_inner(mut self) -> *mut nativeAcceptChannel {
762 assert!(self.is_owned);
763 let ret = self.inner;
764 self.inner = std::ptr::null_mut();
768 /// A temporary channel ID, until the funding outpoint is announced
770 pub extern "C" fn AcceptChannel_get_temporary_channel_id(this_ptr: &AcceptChannel) -> *const [u8; 32] {
771 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.temporary_channel_id;
774 /// A temporary channel ID, until the funding outpoint is announced
776 pub extern "C" fn AcceptChannel_set_temporary_channel_id(this_ptr: &mut AcceptChannel, mut val: crate::c_types::ThirtyTwoBytes) {
777 unsafe { &mut *this_ptr.inner }.temporary_channel_id = val.data;
779 /// The threshold below which outputs on transactions broadcast by sender will be omitted
781 pub extern "C" fn AcceptChannel_get_dust_limit_satoshis(this_ptr: &AcceptChannel) -> u64 {
782 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.dust_limit_satoshis;
785 /// The threshold below which outputs on transactions broadcast by sender will be omitted
787 pub extern "C" fn AcceptChannel_set_dust_limit_satoshis(this_ptr: &mut AcceptChannel, mut val: u64) {
788 unsafe { &mut *this_ptr.inner }.dust_limit_satoshis = val;
790 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
792 pub extern "C" fn AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: &AcceptChannel) -> u64 {
793 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_htlc_value_in_flight_msat;
796 /// The maximum inbound HTLC value in flight towards sender, in milli-satoshi
798 pub extern "C" fn AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: &mut AcceptChannel, mut val: u64) {
799 unsafe { &mut *this_ptr.inner }.max_htlc_value_in_flight_msat = val;
801 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
803 pub extern "C" fn AcceptChannel_get_channel_reserve_satoshis(this_ptr: &AcceptChannel) -> u64 {
804 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_reserve_satoshis;
807 /// The minimum value unencumbered by HTLCs for the counterparty to keep in the channel
809 pub extern "C" fn AcceptChannel_set_channel_reserve_satoshis(this_ptr: &mut AcceptChannel, mut val: u64) {
810 unsafe { &mut *this_ptr.inner }.channel_reserve_satoshis = val;
812 /// The minimum HTLC size incoming to sender, in milli-satoshi
814 pub extern "C" fn AcceptChannel_get_htlc_minimum_msat(this_ptr: &AcceptChannel) -> u64 {
815 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_minimum_msat;
818 /// The minimum HTLC size incoming to sender, in milli-satoshi
820 pub extern "C" fn AcceptChannel_set_htlc_minimum_msat(this_ptr: &mut AcceptChannel, mut val: u64) {
821 unsafe { &mut *this_ptr.inner }.htlc_minimum_msat = val;
823 /// Minimum depth of the funding transaction before the channel is considered open
825 pub extern "C" fn AcceptChannel_get_minimum_depth(this_ptr: &AcceptChannel) -> u32 {
826 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.minimum_depth;
829 /// Minimum depth of the funding transaction before the channel is considered open
831 pub extern "C" fn AcceptChannel_set_minimum_depth(this_ptr: &mut AcceptChannel, mut val: u32) {
832 unsafe { &mut *this_ptr.inner }.minimum_depth = val;
834 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
836 pub extern "C" fn AcceptChannel_get_to_self_delay(this_ptr: &AcceptChannel) -> u16 {
837 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.to_self_delay;
840 /// The number of blocks which the counterparty will have to wait to claim on-chain funds if they broadcast a commitment transaction
842 pub extern "C" fn AcceptChannel_set_to_self_delay(this_ptr: &mut AcceptChannel, mut val: u16) {
843 unsafe { &mut *this_ptr.inner }.to_self_delay = val;
845 /// The maximum number of inbound HTLCs towards sender
847 pub extern "C" fn AcceptChannel_get_max_accepted_htlcs(this_ptr: &AcceptChannel) -> u16 {
848 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_accepted_htlcs;
851 /// The maximum number of inbound HTLCs towards sender
853 pub extern "C" fn AcceptChannel_set_max_accepted_htlcs(this_ptr: &mut AcceptChannel, mut val: u16) {
854 unsafe { &mut *this_ptr.inner }.max_accepted_htlcs = val;
856 /// The sender's key controlling the funding transaction
858 pub extern "C" fn AcceptChannel_get_funding_pubkey(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
859 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_pubkey;
860 crate::c_types::PublicKey::from_rust(&inner_val)
862 /// The sender's key controlling the funding transaction
864 pub extern "C" fn AcceptChannel_set_funding_pubkey(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
865 unsafe { &mut *this_ptr.inner }.funding_pubkey = val.into_rust();
867 /// Used to derive a revocation key for transactions broadcast by counterparty
869 pub extern "C" fn AcceptChannel_get_revocation_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
870 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.revocation_basepoint;
871 crate::c_types::PublicKey::from_rust(&inner_val)
873 /// Used to derive a revocation key for transactions broadcast by counterparty
875 pub extern "C" fn AcceptChannel_set_revocation_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
876 unsafe { &mut *this_ptr.inner }.revocation_basepoint = val.into_rust();
878 /// A payment key to sender for transactions broadcast by counterparty
880 pub extern "C" fn AcceptChannel_get_payment_point(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
881 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_point;
882 crate::c_types::PublicKey::from_rust(&inner_val)
884 /// A payment key to sender for transactions broadcast by counterparty
886 pub extern "C" fn AcceptChannel_set_payment_point(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
887 unsafe { &mut *this_ptr.inner }.payment_point = val.into_rust();
889 /// Used to derive a payment key to sender for transactions broadcast by sender
891 pub extern "C" fn AcceptChannel_get_delayed_payment_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
892 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint;
893 crate::c_types::PublicKey::from_rust(&inner_val)
895 /// Used to derive a payment key to sender for transactions broadcast by sender
897 pub extern "C" fn AcceptChannel_set_delayed_payment_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
898 unsafe { &mut *this_ptr.inner }.delayed_payment_basepoint = val.into_rust();
900 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
902 pub extern "C" fn AcceptChannel_get_htlc_basepoint(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
903 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_basepoint;
904 crate::c_types::PublicKey::from_rust(&inner_val)
906 /// Used to derive an HTLC payment key to sender for transactions broadcast by counterparty
908 pub extern "C" fn AcceptChannel_set_htlc_basepoint(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
909 unsafe { &mut *this_ptr.inner }.htlc_basepoint = val.into_rust();
911 /// The first to-be-broadcast-by-sender transaction's per commitment point
913 pub extern "C" fn AcceptChannel_get_first_per_commitment_point(this_ptr: &AcceptChannel) -> crate::c_types::PublicKey {
914 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.first_per_commitment_point;
915 crate::c_types::PublicKey::from_rust(&inner_val)
917 /// The first to-be-broadcast-by-sender transaction's per commitment point
919 pub extern "C" fn AcceptChannel_set_first_per_commitment_point(this_ptr: &mut AcceptChannel, mut val: crate::c_types::PublicKey) {
920 unsafe { &mut *this_ptr.inner }.first_per_commitment_point = val.into_rust();
922 impl Clone for AcceptChannel {
923 fn clone(&self) -> Self {
925 inner: if <*mut nativeAcceptChannel>::is_null(self.inner) { std::ptr::null_mut() } else {
926 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
932 /// Used only if an object of this type is returned as a trait impl by a method
933 pub(crate) extern "C" fn AcceptChannel_clone_void(this_ptr: *const c_void) -> *mut c_void {
934 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeAcceptChannel)).clone() })) as *mut c_void
937 /// Creates a copy of the AcceptChannel
938 pub extern "C" fn AcceptChannel_clone(orig: &AcceptChannel) -> AcceptChannel {
942 use lightning::ln::msgs::FundingCreated as nativeFundingCreatedImport;
943 type nativeFundingCreated = nativeFundingCreatedImport;
945 /// A funding_created message to be sent or received from a peer
948 pub struct FundingCreated {
949 /// A pointer to the opaque Rust object.
951 /// Nearly everywhere, inner must be non-null, however in places where
952 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
953 pub inner: *mut nativeFundingCreated,
954 /// Indicates that this is the only struct which contains the same pointer.
956 /// Rust functions which take ownership of an object provided via an argument require
957 /// this to be true and invalidate the object pointed to by inner.
961 impl Drop for FundingCreated {
963 if self.is_owned && !<*mut nativeFundingCreated>::is_null(self.inner) {
964 let _ = unsafe { Box::from_raw(self.inner) };
968 /// Frees any resources used by the FundingCreated, if is_owned is set and inner is non-NULL.
970 pub extern "C" fn FundingCreated_free(this_obj: FundingCreated) { }
972 /// Used only if an object of this type is returned as a trait impl by a method
973 extern "C" fn FundingCreated_free_void(this_ptr: *mut c_void) {
974 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeFundingCreated); }
977 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
978 impl FundingCreated {
979 pub(crate) fn take_inner(mut self) -> *mut nativeFundingCreated {
980 assert!(self.is_owned);
981 let ret = self.inner;
982 self.inner = std::ptr::null_mut();
986 /// A temporary channel ID, until the funding is established
988 pub extern "C" fn FundingCreated_get_temporary_channel_id(this_ptr: &FundingCreated) -> *const [u8; 32] {
989 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.temporary_channel_id;
992 /// A temporary channel ID, until the funding is established
994 pub extern "C" fn FundingCreated_set_temporary_channel_id(this_ptr: &mut FundingCreated, mut val: crate::c_types::ThirtyTwoBytes) {
995 unsafe { &mut *this_ptr.inner }.temporary_channel_id = val.data;
997 /// The funding transaction ID
999 pub extern "C" fn FundingCreated_get_funding_txid(this_ptr: &FundingCreated) -> *const [u8; 32] {
1000 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_txid;
1001 inner_val.as_inner()
1003 /// The funding transaction ID
1005 pub extern "C" fn FundingCreated_set_funding_txid(this_ptr: &mut FundingCreated, mut val: crate::c_types::ThirtyTwoBytes) {
1006 unsafe { &mut *this_ptr.inner }.funding_txid = ::bitcoin::hash_types::Txid::from_slice(&val.data[..]).unwrap();
1008 /// The specific output index funding this channel
1010 pub extern "C" fn FundingCreated_get_funding_output_index(this_ptr: &FundingCreated) -> u16 {
1011 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.funding_output_index;
1014 /// The specific output index funding this channel
1016 pub extern "C" fn FundingCreated_set_funding_output_index(this_ptr: &mut FundingCreated, mut val: u16) {
1017 unsafe { &mut *this_ptr.inner }.funding_output_index = val;
1019 /// The signature of the channel initiator (funder) on the funding transaction
1021 pub extern "C" fn FundingCreated_get_signature(this_ptr: &FundingCreated) -> crate::c_types::Signature {
1022 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature;
1023 crate::c_types::Signature::from_rust(&inner_val)
1025 /// The signature of the channel initiator (funder) on the funding transaction
1027 pub extern "C" fn FundingCreated_set_signature(this_ptr: &mut FundingCreated, mut val: crate::c_types::Signature) {
1028 unsafe { &mut *this_ptr.inner }.signature = val.into_rust();
1030 /// Constructs a new FundingCreated given each field
1033 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 {
1034 FundingCreated { inner: Box::into_raw(Box::new(nativeFundingCreated {
1035 temporary_channel_id: temporary_channel_id_arg.data,
1036 funding_txid: ::bitcoin::hash_types::Txid::from_slice(&funding_txid_arg.data[..]).unwrap(),
1037 funding_output_index: funding_output_index_arg,
1038 signature: signature_arg.into_rust(),
1039 })), is_owned: true }
1041 impl Clone for FundingCreated {
1042 fn clone(&self) -> Self {
1044 inner: if <*mut nativeFundingCreated>::is_null(self.inner) { std::ptr::null_mut() } else {
1045 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1051 /// Used only if an object of this type is returned as a trait impl by a method
1052 pub(crate) extern "C" fn FundingCreated_clone_void(this_ptr: *const c_void) -> *mut c_void {
1053 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingCreated)).clone() })) as *mut c_void
1056 /// Creates a copy of the FundingCreated
1057 pub extern "C" fn FundingCreated_clone(orig: &FundingCreated) -> FundingCreated {
1061 use lightning::ln::msgs::FundingSigned as nativeFundingSignedImport;
1062 type nativeFundingSigned = nativeFundingSignedImport;
1064 /// A funding_signed message to be sent or received from a peer
1067 pub struct FundingSigned {
1068 /// A pointer to the opaque Rust object.
1070 /// Nearly everywhere, inner must be non-null, however in places where
1071 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1072 pub inner: *mut nativeFundingSigned,
1073 /// Indicates that this is the only struct which contains the same pointer.
1075 /// Rust functions which take ownership of an object provided via an argument require
1076 /// this to be true and invalidate the object pointed to by inner.
1080 impl Drop for FundingSigned {
1081 fn drop(&mut self) {
1082 if self.is_owned && !<*mut nativeFundingSigned>::is_null(self.inner) {
1083 let _ = unsafe { Box::from_raw(self.inner) };
1087 /// Frees any resources used by the FundingSigned, if is_owned is set and inner is non-NULL.
1089 pub extern "C" fn FundingSigned_free(this_obj: FundingSigned) { }
1091 /// Used only if an object of this type is returned as a trait impl by a method
1092 extern "C" fn FundingSigned_free_void(this_ptr: *mut c_void) {
1093 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeFundingSigned); }
1096 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1097 impl FundingSigned {
1098 pub(crate) fn take_inner(mut self) -> *mut nativeFundingSigned {
1099 assert!(self.is_owned);
1100 let ret = self.inner;
1101 self.inner = std::ptr::null_mut();
1107 pub extern "C" fn FundingSigned_get_channel_id(this_ptr: &FundingSigned) -> *const [u8; 32] {
1108 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
1113 pub extern "C" fn FundingSigned_set_channel_id(this_ptr: &mut FundingSigned, mut val: crate::c_types::ThirtyTwoBytes) {
1114 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
1116 /// The signature of the channel acceptor (fundee) on the funding transaction
1118 pub extern "C" fn FundingSigned_get_signature(this_ptr: &FundingSigned) -> crate::c_types::Signature {
1119 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature;
1120 crate::c_types::Signature::from_rust(&inner_val)
1122 /// The signature of the channel acceptor (fundee) on the funding transaction
1124 pub extern "C" fn FundingSigned_set_signature(this_ptr: &mut FundingSigned, mut val: crate::c_types::Signature) {
1125 unsafe { &mut *this_ptr.inner }.signature = val.into_rust();
1127 /// Constructs a new FundingSigned given each field
1130 pub extern "C" fn FundingSigned_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut signature_arg: crate::c_types::Signature) -> FundingSigned {
1131 FundingSigned { inner: Box::into_raw(Box::new(nativeFundingSigned {
1132 channel_id: channel_id_arg.data,
1133 signature: signature_arg.into_rust(),
1134 })), is_owned: true }
1136 impl Clone for FundingSigned {
1137 fn clone(&self) -> Self {
1139 inner: if <*mut nativeFundingSigned>::is_null(self.inner) { std::ptr::null_mut() } else {
1140 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1146 /// Used only if an object of this type is returned as a trait impl by a method
1147 pub(crate) extern "C" fn FundingSigned_clone_void(this_ptr: *const c_void) -> *mut c_void {
1148 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingSigned)).clone() })) as *mut c_void
1151 /// Creates a copy of the FundingSigned
1152 pub extern "C" fn FundingSigned_clone(orig: &FundingSigned) -> FundingSigned {
1156 use lightning::ln::msgs::FundingLocked as nativeFundingLockedImport;
1157 type nativeFundingLocked = nativeFundingLockedImport;
1159 /// A funding_locked message to be sent or received from a peer
1162 pub struct FundingLocked {
1163 /// A pointer to the opaque Rust object.
1165 /// Nearly everywhere, inner must be non-null, however in places where
1166 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1167 pub inner: *mut nativeFundingLocked,
1168 /// Indicates that this is the only struct which contains the same pointer.
1170 /// Rust functions which take ownership of an object provided via an argument require
1171 /// this to be true and invalidate the object pointed to by inner.
1175 impl Drop for FundingLocked {
1176 fn drop(&mut self) {
1177 if self.is_owned && !<*mut nativeFundingLocked>::is_null(self.inner) {
1178 let _ = unsafe { Box::from_raw(self.inner) };
1182 /// Frees any resources used by the FundingLocked, if is_owned is set and inner is non-NULL.
1184 pub extern "C" fn FundingLocked_free(this_obj: FundingLocked) { }
1186 /// Used only if an object of this type is returned as a trait impl by a method
1187 extern "C" fn FundingLocked_free_void(this_ptr: *mut c_void) {
1188 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeFundingLocked); }
1191 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1192 impl FundingLocked {
1193 pub(crate) fn take_inner(mut self) -> *mut nativeFundingLocked {
1194 assert!(self.is_owned);
1195 let ret = self.inner;
1196 self.inner = std::ptr::null_mut();
1202 pub extern "C" fn FundingLocked_get_channel_id(this_ptr: &FundingLocked) -> *const [u8; 32] {
1203 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
1208 pub extern "C" fn FundingLocked_set_channel_id(this_ptr: &mut FundingLocked, mut val: crate::c_types::ThirtyTwoBytes) {
1209 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
1211 /// The per-commitment point of the second commitment transaction
1213 pub extern "C" fn FundingLocked_get_next_per_commitment_point(this_ptr: &FundingLocked) -> crate::c_types::PublicKey {
1214 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.next_per_commitment_point;
1215 crate::c_types::PublicKey::from_rust(&inner_val)
1217 /// The per-commitment point of the second commitment transaction
1219 pub extern "C" fn FundingLocked_set_next_per_commitment_point(this_ptr: &mut FundingLocked, mut val: crate::c_types::PublicKey) {
1220 unsafe { &mut *this_ptr.inner }.next_per_commitment_point = val.into_rust();
1222 /// Constructs a new FundingLocked given each field
1225 pub extern "C" fn FundingLocked_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut next_per_commitment_point_arg: crate::c_types::PublicKey) -> FundingLocked {
1226 FundingLocked { inner: Box::into_raw(Box::new(nativeFundingLocked {
1227 channel_id: channel_id_arg.data,
1228 next_per_commitment_point: next_per_commitment_point_arg.into_rust(),
1229 })), is_owned: true }
1231 impl Clone for FundingLocked {
1232 fn clone(&self) -> Self {
1234 inner: if <*mut nativeFundingLocked>::is_null(self.inner) { std::ptr::null_mut() } else {
1235 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1241 /// Used only if an object of this type is returned as a trait impl by a method
1242 pub(crate) extern "C" fn FundingLocked_clone_void(this_ptr: *const c_void) -> *mut c_void {
1243 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingLocked)).clone() })) as *mut c_void
1246 /// Creates a copy of the FundingLocked
1247 pub extern "C" fn FundingLocked_clone(orig: &FundingLocked) -> FundingLocked {
1251 use lightning::ln::msgs::Shutdown as nativeShutdownImport;
1252 type nativeShutdown = nativeShutdownImport;
1254 /// A shutdown message to be sent or received from a peer
1257 pub struct Shutdown {
1258 /// A pointer to the opaque Rust object.
1260 /// Nearly everywhere, inner must be non-null, however in places where
1261 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1262 pub inner: *mut nativeShutdown,
1263 /// Indicates that this is the only struct which contains the same pointer.
1265 /// Rust functions which take ownership of an object provided via an argument require
1266 /// this to be true and invalidate the object pointed to by inner.
1270 impl Drop for Shutdown {
1271 fn drop(&mut self) {
1272 if self.is_owned && !<*mut nativeShutdown>::is_null(self.inner) {
1273 let _ = unsafe { Box::from_raw(self.inner) };
1277 /// Frees any resources used by the Shutdown, if is_owned is set and inner is non-NULL.
1279 pub extern "C" fn Shutdown_free(this_obj: Shutdown) { }
1281 /// Used only if an object of this type is returned as a trait impl by a method
1282 extern "C" fn Shutdown_free_void(this_ptr: *mut c_void) {
1283 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeShutdown); }
1286 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1288 pub(crate) fn take_inner(mut self) -> *mut nativeShutdown {
1289 assert!(self.is_owned);
1290 let ret = self.inner;
1291 self.inner = std::ptr::null_mut();
1297 pub extern "C" fn Shutdown_get_channel_id(this_ptr: &Shutdown) -> *const [u8; 32] {
1298 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
1303 pub extern "C" fn Shutdown_set_channel_id(this_ptr: &mut Shutdown, mut val: crate::c_types::ThirtyTwoBytes) {
1304 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
1306 /// The destination of this peer's funds on closing.
1307 /// Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh.
1309 pub extern "C" fn Shutdown_get_scriptpubkey(this_ptr: &Shutdown) -> crate::c_types::u8slice {
1310 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.scriptpubkey;
1311 crate::c_types::u8slice::from_slice(&inner_val[..])
1313 /// The destination of this peer's funds on closing.
1314 /// Must be in one of these forms: p2pkh, p2sh, p2wpkh, p2wsh.
1316 pub extern "C" fn Shutdown_set_scriptpubkey(this_ptr: &mut Shutdown, mut val: crate::c_types::derived::CVec_u8Z) {
1317 unsafe { &mut *this_ptr.inner }.scriptpubkey = ::bitcoin::blockdata::script::Script::from(val.into_rust());
1319 /// Constructs a new Shutdown given each field
1322 pub extern "C" fn Shutdown_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut scriptpubkey_arg: crate::c_types::derived::CVec_u8Z) -> Shutdown {
1323 Shutdown { inner: Box::into_raw(Box::new(nativeShutdown {
1324 channel_id: channel_id_arg.data,
1325 scriptpubkey: ::bitcoin::blockdata::script::Script::from(scriptpubkey_arg.into_rust()),
1326 })), is_owned: true }
1328 impl Clone for Shutdown {
1329 fn clone(&self) -> Self {
1331 inner: if <*mut nativeShutdown>::is_null(self.inner) { std::ptr::null_mut() } else {
1332 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1338 /// Used only if an object of this type is returned as a trait impl by a method
1339 pub(crate) extern "C" fn Shutdown_clone_void(this_ptr: *const c_void) -> *mut c_void {
1340 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeShutdown)).clone() })) as *mut c_void
1343 /// Creates a copy of the Shutdown
1344 pub extern "C" fn Shutdown_clone(orig: &Shutdown) -> Shutdown {
1348 use lightning::ln::msgs::ClosingSignedFeeRange as nativeClosingSignedFeeRangeImport;
1349 type nativeClosingSignedFeeRange = nativeClosingSignedFeeRangeImport;
1351 /// The minimum and maximum fees which the sender is willing to place on the closing transaction.
1352 /// This is provided in [`ClosingSigned`] by both sides to indicate the fee range they are willing
1356 pub struct ClosingSignedFeeRange {
1357 /// A pointer to the opaque Rust object.
1359 /// Nearly everywhere, inner must be non-null, however in places where
1360 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1361 pub inner: *mut nativeClosingSignedFeeRange,
1362 /// Indicates that this is the only struct which contains the same pointer.
1364 /// Rust functions which take ownership of an object provided via an argument require
1365 /// this to be true and invalidate the object pointed to by inner.
1369 impl Drop for ClosingSignedFeeRange {
1370 fn drop(&mut self) {
1371 if self.is_owned && !<*mut nativeClosingSignedFeeRange>::is_null(self.inner) {
1372 let _ = unsafe { Box::from_raw(self.inner) };
1376 /// Frees any resources used by the ClosingSignedFeeRange, if is_owned is set and inner is non-NULL.
1378 pub extern "C" fn ClosingSignedFeeRange_free(this_obj: ClosingSignedFeeRange) { }
1380 /// Used only if an object of this type is returned as a trait impl by a method
1381 extern "C" fn ClosingSignedFeeRange_free_void(this_ptr: *mut c_void) {
1382 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeClosingSignedFeeRange); }
1385 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1386 impl ClosingSignedFeeRange {
1387 pub(crate) fn take_inner(mut self) -> *mut nativeClosingSignedFeeRange {
1388 assert!(self.is_owned);
1389 let ret = self.inner;
1390 self.inner = std::ptr::null_mut();
1394 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
1397 pub extern "C" fn ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: &ClosingSignedFeeRange) -> u64 {
1398 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.min_fee_satoshis;
1401 /// The minimum absolute fee, in satoshis, which the sender is willing to place on the closing
1404 pub extern "C" fn ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: &mut ClosingSignedFeeRange, mut val: u64) {
1405 unsafe { &mut *this_ptr.inner }.min_fee_satoshis = val;
1407 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
1410 pub extern "C" fn ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: &ClosingSignedFeeRange) -> u64 {
1411 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.max_fee_satoshis;
1414 /// The maximum absolute fee, in satoshis, which the sender is willing to place on the closing
1417 pub extern "C" fn ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: &mut ClosingSignedFeeRange, mut val: u64) {
1418 unsafe { &mut *this_ptr.inner }.max_fee_satoshis = val;
1420 /// Constructs a new ClosingSignedFeeRange given each field
1423 pub extern "C" fn ClosingSignedFeeRange_new(mut min_fee_satoshis_arg: u64, mut max_fee_satoshis_arg: u64) -> ClosingSignedFeeRange {
1424 ClosingSignedFeeRange { inner: Box::into_raw(Box::new(nativeClosingSignedFeeRange {
1425 min_fee_satoshis: min_fee_satoshis_arg,
1426 max_fee_satoshis: max_fee_satoshis_arg,
1427 })), is_owned: true }
1429 impl Clone for ClosingSignedFeeRange {
1430 fn clone(&self) -> Self {
1432 inner: if <*mut nativeClosingSignedFeeRange>::is_null(self.inner) { std::ptr::null_mut() } else {
1433 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1439 /// Used only if an object of this type is returned as a trait impl by a method
1440 pub(crate) extern "C" fn ClosingSignedFeeRange_clone_void(this_ptr: *const c_void) -> *mut c_void {
1441 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeClosingSignedFeeRange)).clone() })) as *mut c_void
1444 /// Creates a copy of the ClosingSignedFeeRange
1445 pub extern "C" fn ClosingSignedFeeRange_clone(orig: &ClosingSignedFeeRange) -> ClosingSignedFeeRange {
1449 use lightning::ln::msgs::ClosingSigned as nativeClosingSignedImport;
1450 type nativeClosingSigned = nativeClosingSignedImport;
1452 /// A closing_signed message to be sent or received from a peer
1455 pub struct ClosingSigned {
1456 /// A pointer to the opaque Rust object.
1458 /// Nearly everywhere, inner must be non-null, however in places where
1459 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1460 pub inner: *mut nativeClosingSigned,
1461 /// Indicates that this is the only struct which contains the same pointer.
1463 /// Rust functions which take ownership of an object provided via an argument require
1464 /// this to be true and invalidate the object pointed to by inner.
1468 impl Drop for ClosingSigned {
1469 fn drop(&mut self) {
1470 if self.is_owned && !<*mut nativeClosingSigned>::is_null(self.inner) {
1471 let _ = unsafe { Box::from_raw(self.inner) };
1475 /// Frees any resources used by the ClosingSigned, if is_owned is set and inner is non-NULL.
1477 pub extern "C" fn ClosingSigned_free(this_obj: ClosingSigned) { }
1479 /// Used only if an object of this type is returned as a trait impl by a method
1480 extern "C" fn ClosingSigned_free_void(this_ptr: *mut c_void) {
1481 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeClosingSigned); }
1484 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1485 impl ClosingSigned {
1486 pub(crate) fn take_inner(mut self) -> *mut nativeClosingSigned {
1487 assert!(self.is_owned);
1488 let ret = self.inner;
1489 self.inner = std::ptr::null_mut();
1495 pub extern "C" fn ClosingSigned_get_channel_id(this_ptr: &ClosingSigned) -> *const [u8; 32] {
1496 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
1501 pub extern "C" fn ClosingSigned_set_channel_id(this_ptr: &mut ClosingSigned, mut val: crate::c_types::ThirtyTwoBytes) {
1502 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
1504 /// The proposed total fee for the closing transaction
1506 pub extern "C" fn ClosingSigned_get_fee_satoshis(this_ptr: &ClosingSigned) -> u64 {
1507 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_satoshis;
1510 /// The proposed total fee for the closing transaction
1512 pub extern "C" fn ClosingSigned_set_fee_satoshis(this_ptr: &mut ClosingSigned, mut val: u64) {
1513 unsafe { &mut *this_ptr.inner }.fee_satoshis = val;
1515 /// A signature on the closing transaction
1517 pub extern "C" fn ClosingSigned_get_signature(this_ptr: &ClosingSigned) -> crate::c_types::Signature {
1518 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature;
1519 crate::c_types::Signature::from_rust(&inner_val)
1521 /// A signature on the closing transaction
1523 pub extern "C" fn ClosingSigned_set_signature(this_ptr: &mut ClosingSigned, mut val: crate::c_types::Signature) {
1524 unsafe { &mut *this_ptr.inner }.signature = val.into_rust();
1526 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
1529 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
1531 pub extern "C" fn ClosingSigned_get_fee_range(this_ptr: &ClosingSigned) -> crate::lightning::ln::msgs::ClosingSignedFeeRange {
1532 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_range;
1533 let mut local_inner_val = crate::lightning::ln::msgs::ClosingSignedFeeRange { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false };
1536 /// The minimum and maximum fees which the sender is willing to accept, provided only by new
1539 /// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
1541 pub extern "C" fn ClosingSigned_set_fee_range(this_ptr: &mut ClosingSigned, mut val: crate::lightning::ln::msgs::ClosingSignedFeeRange) {
1542 let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
1543 unsafe { &mut *this_ptr.inner }.fee_range = local_val;
1545 /// Constructs a new ClosingSigned given each field
1548 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 {
1549 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()) } }) };
1550 ClosingSigned { inner: Box::into_raw(Box::new(nativeClosingSigned {
1551 channel_id: channel_id_arg.data,
1552 fee_satoshis: fee_satoshis_arg,
1553 signature: signature_arg.into_rust(),
1554 fee_range: local_fee_range_arg,
1555 })), is_owned: true }
1557 impl Clone for ClosingSigned {
1558 fn clone(&self) -> Self {
1560 inner: if <*mut nativeClosingSigned>::is_null(self.inner) { std::ptr::null_mut() } else {
1561 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1567 /// Used only if an object of this type is returned as a trait impl by a method
1568 pub(crate) extern "C" fn ClosingSigned_clone_void(this_ptr: *const c_void) -> *mut c_void {
1569 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeClosingSigned)).clone() })) as *mut c_void
1572 /// Creates a copy of the ClosingSigned
1573 pub extern "C" fn ClosingSigned_clone(orig: &ClosingSigned) -> ClosingSigned {
1577 use lightning::ln::msgs::UpdateAddHTLC as nativeUpdateAddHTLCImport;
1578 type nativeUpdateAddHTLC = nativeUpdateAddHTLCImport;
1580 /// An update_add_htlc message to be sent or received from a peer
1583 pub struct UpdateAddHTLC {
1584 /// A pointer to the opaque Rust object.
1586 /// Nearly everywhere, inner must be non-null, however in places where
1587 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1588 pub inner: *mut nativeUpdateAddHTLC,
1589 /// Indicates that this is the only struct which contains the same pointer.
1591 /// Rust functions which take ownership of an object provided via an argument require
1592 /// this to be true and invalidate the object pointed to by inner.
1596 impl Drop for UpdateAddHTLC {
1597 fn drop(&mut self) {
1598 if self.is_owned && !<*mut nativeUpdateAddHTLC>::is_null(self.inner) {
1599 let _ = unsafe { Box::from_raw(self.inner) };
1603 /// Frees any resources used by the UpdateAddHTLC, if is_owned is set and inner is non-NULL.
1605 pub extern "C" fn UpdateAddHTLC_free(this_obj: UpdateAddHTLC) { }
1607 /// Used only if an object of this type is returned as a trait impl by a method
1608 extern "C" fn UpdateAddHTLC_free_void(this_ptr: *mut c_void) {
1609 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateAddHTLC); }
1612 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1613 impl UpdateAddHTLC {
1614 pub(crate) fn take_inner(mut self) -> *mut nativeUpdateAddHTLC {
1615 assert!(self.is_owned);
1616 let ret = self.inner;
1617 self.inner = std::ptr::null_mut();
1623 pub extern "C" fn UpdateAddHTLC_get_channel_id(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] {
1624 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
1629 pub extern "C" fn UpdateAddHTLC_set_channel_id(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
1630 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
1634 pub extern "C" fn UpdateAddHTLC_get_htlc_id(this_ptr: &UpdateAddHTLC) -> u64 {
1635 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_id;
1640 pub extern "C" fn UpdateAddHTLC_set_htlc_id(this_ptr: &mut UpdateAddHTLC, mut val: u64) {
1641 unsafe { &mut *this_ptr.inner }.htlc_id = val;
1643 /// The HTLC value in milli-satoshi
1645 pub extern "C" fn UpdateAddHTLC_get_amount_msat(this_ptr: &UpdateAddHTLC) -> u64 {
1646 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.amount_msat;
1649 /// The HTLC value in milli-satoshi
1651 pub extern "C" fn UpdateAddHTLC_set_amount_msat(this_ptr: &mut UpdateAddHTLC, mut val: u64) {
1652 unsafe { &mut *this_ptr.inner }.amount_msat = val;
1654 /// The payment hash, the pre-image of which controls HTLC redemption
1656 pub extern "C" fn UpdateAddHTLC_get_payment_hash(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] {
1657 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_hash;
1660 /// The payment hash, the pre-image of which controls HTLC redemption
1662 pub extern "C" fn UpdateAddHTLC_set_payment_hash(this_ptr: &mut UpdateAddHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
1663 unsafe { &mut *this_ptr.inner }.payment_hash = ::lightning::ln::PaymentHash(val.data);
1665 /// The expiry height of the HTLC
1667 pub extern "C" fn UpdateAddHTLC_get_cltv_expiry(this_ptr: &UpdateAddHTLC) -> u32 {
1668 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.cltv_expiry;
1671 /// The expiry height of the HTLC
1673 pub extern "C" fn UpdateAddHTLC_set_cltv_expiry(this_ptr: &mut UpdateAddHTLC, mut val: u32) {
1674 unsafe { &mut *this_ptr.inner }.cltv_expiry = val;
1676 impl Clone for UpdateAddHTLC {
1677 fn clone(&self) -> Self {
1679 inner: if <*mut nativeUpdateAddHTLC>::is_null(self.inner) { std::ptr::null_mut() } else {
1680 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1686 /// Used only if an object of this type is returned as a trait impl by a method
1687 pub(crate) extern "C" fn UpdateAddHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
1688 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateAddHTLC)).clone() })) as *mut c_void
1691 /// Creates a copy of the UpdateAddHTLC
1692 pub extern "C" fn UpdateAddHTLC_clone(orig: &UpdateAddHTLC) -> UpdateAddHTLC {
1696 use lightning::ln::msgs::UpdateFulfillHTLC as nativeUpdateFulfillHTLCImport;
1697 type nativeUpdateFulfillHTLC = nativeUpdateFulfillHTLCImport;
1699 /// An update_fulfill_htlc message to be sent or received from a peer
1702 pub struct UpdateFulfillHTLC {
1703 /// A pointer to the opaque Rust object.
1705 /// Nearly everywhere, inner must be non-null, however in places where
1706 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1707 pub inner: *mut nativeUpdateFulfillHTLC,
1708 /// Indicates that this is the only struct which contains the same pointer.
1710 /// Rust functions which take ownership of an object provided via an argument require
1711 /// this to be true and invalidate the object pointed to by inner.
1715 impl Drop for UpdateFulfillHTLC {
1716 fn drop(&mut self) {
1717 if self.is_owned && !<*mut nativeUpdateFulfillHTLC>::is_null(self.inner) {
1718 let _ = unsafe { Box::from_raw(self.inner) };
1722 /// Frees any resources used by the UpdateFulfillHTLC, if is_owned is set and inner is non-NULL.
1724 pub extern "C" fn UpdateFulfillHTLC_free(this_obj: UpdateFulfillHTLC) { }
1726 /// Used only if an object of this type is returned as a trait impl by a method
1727 extern "C" fn UpdateFulfillHTLC_free_void(this_ptr: *mut c_void) {
1728 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFulfillHTLC); }
1731 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1732 impl UpdateFulfillHTLC {
1733 pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFulfillHTLC {
1734 assert!(self.is_owned);
1735 let ret = self.inner;
1736 self.inner = std::ptr::null_mut();
1742 pub extern "C" fn UpdateFulfillHTLC_get_channel_id(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] {
1743 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
1748 pub extern "C" fn UpdateFulfillHTLC_set_channel_id(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
1749 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
1753 pub extern "C" fn UpdateFulfillHTLC_get_htlc_id(this_ptr: &UpdateFulfillHTLC) -> u64 {
1754 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_id;
1759 pub extern "C" fn UpdateFulfillHTLC_set_htlc_id(this_ptr: &mut UpdateFulfillHTLC, mut val: u64) {
1760 unsafe { &mut *this_ptr.inner }.htlc_id = val;
1762 /// The pre-image of the payment hash, allowing HTLC redemption
1764 pub extern "C" fn UpdateFulfillHTLC_get_payment_preimage(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] {
1765 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.payment_preimage;
1768 /// The pre-image of the payment hash, allowing HTLC redemption
1770 pub extern "C" fn UpdateFulfillHTLC_set_payment_preimage(this_ptr: &mut UpdateFulfillHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
1771 unsafe { &mut *this_ptr.inner }.payment_preimage = ::lightning::ln::PaymentPreimage(val.data);
1773 /// Constructs a new UpdateFulfillHTLC given each field
1776 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 {
1777 UpdateFulfillHTLC { inner: Box::into_raw(Box::new(nativeUpdateFulfillHTLC {
1778 channel_id: channel_id_arg.data,
1779 htlc_id: htlc_id_arg,
1780 payment_preimage: ::lightning::ln::PaymentPreimage(payment_preimage_arg.data),
1781 })), is_owned: true }
1783 impl Clone for UpdateFulfillHTLC {
1784 fn clone(&self) -> Self {
1786 inner: if <*mut nativeUpdateFulfillHTLC>::is_null(self.inner) { std::ptr::null_mut() } else {
1787 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1793 /// Used only if an object of this type is returned as a trait impl by a method
1794 pub(crate) extern "C" fn UpdateFulfillHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
1795 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFulfillHTLC)).clone() })) as *mut c_void
1798 /// Creates a copy of the UpdateFulfillHTLC
1799 pub extern "C" fn UpdateFulfillHTLC_clone(orig: &UpdateFulfillHTLC) -> UpdateFulfillHTLC {
1803 use lightning::ln::msgs::UpdateFailHTLC as nativeUpdateFailHTLCImport;
1804 type nativeUpdateFailHTLC = nativeUpdateFailHTLCImport;
1806 /// An update_fail_htlc message to be sent or received from a peer
1809 pub struct UpdateFailHTLC {
1810 /// A pointer to the opaque Rust object.
1812 /// Nearly everywhere, inner must be non-null, however in places where
1813 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1814 pub inner: *mut nativeUpdateFailHTLC,
1815 /// Indicates that this is the only struct which contains the same pointer.
1817 /// Rust functions which take ownership of an object provided via an argument require
1818 /// this to be true and invalidate the object pointed to by inner.
1822 impl Drop for UpdateFailHTLC {
1823 fn drop(&mut self) {
1824 if self.is_owned && !<*mut nativeUpdateFailHTLC>::is_null(self.inner) {
1825 let _ = unsafe { Box::from_raw(self.inner) };
1829 /// Frees any resources used by the UpdateFailHTLC, if is_owned is set and inner is non-NULL.
1831 pub extern "C" fn UpdateFailHTLC_free(this_obj: UpdateFailHTLC) { }
1833 /// Used only if an object of this type is returned as a trait impl by a method
1834 extern "C" fn UpdateFailHTLC_free_void(this_ptr: *mut c_void) {
1835 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFailHTLC); }
1838 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1839 impl UpdateFailHTLC {
1840 pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailHTLC {
1841 assert!(self.is_owned);
1842 let ret = self.inner;
1843 self.inner = std::ptr::null_mut();
1849 pub extern "C" fn UpdateFailHTLC_get_channel_id(this_ptr: &UpdateFailHTLC) -> *const [u8; 32] {
1850 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
1855 pub extern "C" fn UpdateFailHTLC_set_channel_id(this_ptr: &mut UpdateFailHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
1856 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
1860 pub extern "C" fn UpdateFailHTLC_get_htlc_id(this_ptr: &UpdateFailHTLC) -> u64 {
1861 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_id;
1866 pub extern "C" fn UpdateFailHTLC_set_htlc_id(this_ptr: &mut UpdateFailHTLC, mut val: u64) {
1867 unsafe { &mut *this_ptr.inner }.htlc_id = val;
1869 impl Clone for UpdateFailHTLC {
1870 fn clone(&self) -> Self {
1872 inner: if <*mut nativeUpdateFailHTLC>::is_null(self.inner) { std::ptr::null_mut() } else {
1873 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1879 /// Used only if an object of this type is returned as a trait impl by a method
1880 pub(crate) extern "C" fn UpdateFailHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
1881 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFailHTLC)).clone() })) as *mut c_void
1884 /// Creates a copy of the UpdateFailHTLC
1885 pub extern "C" fn UpdateFailHTLC_clone(orig: &UpdateFailHTLC) -> UpdateFailHTLC {
1889 use lightning::ln::msgs::UpdateFailMalformedHTLC as nativeUpdateFailMalformedHTLCImport;
1890 type nativeUpdateFailMalformedHTLC = nativeUpdateFailMalformedHTLCImport;
1892 /// An update_fail_malformed_htlc message to be sent or received from a peer
1895 pub struct UpdateFailMalformedHTLC {
1896 /// A pointer to the opaque Rust object.
1898 /// Nearly everywhere, inner must be non-null, however in places where
1899 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1900 pub inner: *mut nativeUpdateFailMalformedHTLC,
1901 /// Indicates that this is the only struct which contains the same pointer.
1903 /// Rust functions which take ownership of an object provided via an argument require
1904 /// this to be true and invalidate the object pointed to by inner.
1908 impl Drop for UpdateFailMalformedHTLC {
1909 fn drop(&mut self) {
1910 if self.is_owned && !<*mut nativeUpdateFailMalformedHTLC>::is_null(self.inner) {
1911 let _ = unsafe { Box::from_raw(self.inner) };
1915 /// Frees any resources used by the UpdateFailMalformedHTLC, if is_owned is set and inner is non-NULL.
1917 pub extern "C" fn UpdateFailMalformedHTLC_free(this_obj: UpdateFailMalformedHTLC) { }
1919 /// Used only if an object of this type is returned as a trait impl by a method
1920 extern "C" fn UpdateFailMalformedHTLC_free_void(this_ptr: *mut c_void) {
1921 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFailMalformedHTLC); }
1924 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
1925 impl UpdateFailMalformedHTLC {
1926 pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailMalformedHTLC {
1927 assert!(self.is_owned);
1928 let ret = self.inner;
1929 self.inner = std::ptr::null_mut();
1935 pub extern "C" fn UpdateFailMalformedHTLC_get_channel_id(this_ptr: &UpdateFailMalformedHTLC) -> *const [u8; 32] {
1936 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
1941 pub extern "C" fn UpdateFailMalformedHTLC_set_channel_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: crate::c_types::ThirtyTwoBytes) {
1942 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
1946 pub extern "C" fn UpdateFailMalformedHTLC_get_htlc_id(this_ptr: &UpdateFailMalformedHTLC) -> u64 {
1947 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_id;
1952 pub extern "C" fn UpdateFailMalformedHTLC_set_htlc_id(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u64) {
1953 unsafe { &mut *this_ptr.inner }.htlc_id = val;
1955 /// The failure code
1957 pub extern "C" fn UpdateFailMalformedHTLC_get_failure_code(this_ptr: &UpdateFailMalformedHTLC) -> u16 {
1958 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.failure_code;
1961 /// The failure code
1963 pub extern "C" fn UpdateFailMalformedHTLC_set_failure_code(this_ptr: &mut UpdateFailMalformedHTLC, mut val: u16) {
1964 unsafe { &mut *this_ptr.inner }.failure_code = val;
1966 impl Clone for UpdateFailMalformedHTLC {
1967 fn clone(&self) -> Self {
1969 inner: if <*mut nativeUpdateFailMalformedHTLC>::is_null(self.inner) { std::ptr::null_mut() } else {
1970 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
1976 /// Used only if an object of this type is returned as a trait impl by a method
1977 pub(crate) extern "C" fn UpdateFailMalformedHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void {
1978 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFailMalformedHTLC)).clone() })) as *mut c_void
1981 /// Creates a copy of the UpdateFailMalformedHTLC
1982 pub extern "C" fn UpdateFailMalformedHTLC_clone(orig: &UpdateFailMalformedHTLC) -> UpdateFailMalformedHTLC {
1986 use lightning::ln::msgs::CommitmentSigned as nativeCommitmentSignedImport;
1987 type nativeCommitmentSigned = nativeCommitmentSignedImport;
1989 /// A commitment_signed message to be sent or received from a peer
1992 pub struct CommitmentSigned {
1993 /// A pointer to the opaque Rust object.
1995 /// Nearly everywhere, inner must be non-null, however in places where
1996 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
1997 pub inner: *mut nativeCommitmentSigned,
1998 /// Indicates that this is the only struct which contains the same pointer.
2000 /// Rust functions which take ownership of an object provided via an argument require
2001 /// this to be true and invalidate the object pointed to by inner.
2005 impl Drop for CommitmentSigned {
2006 fn drop(&mut self) {
2007 if self.is_owned && !<*mut nativeCommitmentSigned>::is_null(self.inner) {
2008 let _ = unsafe { Box::from_raw(self.inner) };
2012 /// Frees any resources used by the CommitmentSigned, if is_owned is set and inner is non-NULL.
2014 pub extern "C" fn CommitmentSigned_free(this_obj: CommitmentSigned) { }
2016 /// Used only if an object of this type is returned as a trait impl by a method
2017 extern "C" fn CommitmentSigned_free_void(this_ptr: *mut c_void) {
2018 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeCommitmentSigned); }
2021 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2022 impl CommitmentSigned {
2023 pub(crate) fn take_inner(mut self) -> *mut nativeCommitmentSigned {
2024 assert!(self.is_owned);
2025 let ret = self.inner;
2026 self.inner = std::ptr::null_mut();
2032 pub extern "C" fn CommitmentSigned_get_channel_id(this_ptr: &CommitmentSigned) -> *const [u8; 32] {
2033 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
2038 pub extern "C" fn CommitmentSigned_set_channel_id(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::ThirtyTwoBytes) {
2039 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
2041 /// A signature on the commitment transaction
2043 pub extern "C" fn CommitmentSigned_get_signature(this_ptr: &CommitmentSigned) -> crate::c_types::Signature {
2044 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature;
2045 crate::c_types::Signature::from_rust(&inner_val)
2047 /// A signature on the commitment transaction
2049 pub extern "C" fn CommitmentSigned_set_signature(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::Signature) {
2050 unsafe { &mut *this_ptr.inner }.signature = val.into_rust();
2052 /// Signatures on the HTLC transactions
2054 pub extern "C" fn CommitmentSigned_set_htlc_signatures(this_ptr: &mut CommitmentSigned, mut val: crate::c_types::derived::CVec_SignatureZ) {
2055 let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_rust() }); };
2056 unsafe { &mut *this_ptr.inner }.htlc_signatures = local_val;
2058 /// Constructs a new CommitmentSigned given each field
2061 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 {
2062 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() }); };
2063 CommitmentSigned { inner: Box::into_raw(Box::new(nativeCommitmentSigned {
2064 channel_id: channel_id_arg.data,
2065 signature: signature_arg.into_rust(),
2066 htlc_signatures: local_htlc_signatures_arg,
2067 })), is_owned: true }
2069 impl Clone for CommitmentSigned {
2070 fn clone(&self) -> Self {
2072 inner: if <*mut nativeCommitmentSigned>::is_null(self.inner) { std::ptr::null_mut() } else {
2073 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
2079 /// Used only if an object of this type is returned as a trait impl by a method
2080 pub(crate) extern "C" fn CommitmentSigned_clone_void(this_ptr: *const c_void) -> *mut c_void {
2081 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeCommitmentSigned)).clone() })) as *mut c_void
2084 /// Creates a copy of the CommitmentSigned
2085 pub extern "C" fn CommitmentSigned_clone(orig: &CommitmentSigned) -> CommitmentSigned {
2089 use lightning::ln::msgs::RevokeAndACK as nativeRevokeAndACKImport;
2090 type nativeRevokeAndACK = nativeRevokeAndACKImport;
2092 /// A revoke_and_ack message to be sent or received from a peer
2095 pub struct RevokeAndACK {
2096 /// A pointer to the opaque Rust object.
2098 /// Nearly everywhere, inner must be non-null, however in places where
2099 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2100 pub inner: *mut nativeRevokeAndACK,
2101 /// Indicates that this is the only struct which contains the same pointer.
2103 /// Rust functions which take ownership of an object provided via an argument require
2104 /// this to be true and invalidate the object pointed to by inner.
2108 impl Drop for RevokeAndACK {
2109 fn drop(&mut self) {
2110 if self.is_owned && !<*mut nativeRevokeAndACK>::is_null(self.inner) {
2111 let _ = unsafe { Box::from_raw(self.inner) };
2115 /// Frees any resources used by the RevokeAndACK, if is_owned is set and inner is non-NULL.
2117 pub extern "C" fn RevokeAndACK_free(this_obj: RevokeAndACK) { }
2119 /// Used only if an object of this type is returned as a trait impl by a method
2120 extern "C" fn RevokeAndACK_free_void(this_ptr: *mut c_void) {
2121 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeRevokeAndACK); }
2124 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2126 pub(crate) fn take_inner(mut self) -> *mut nativeRevokeAndACK {
2127 assert!(self.is_owned);
2128 let ret = self.inner;
2129 self.inner = std::ptr::null_mut();
2135 pub extern "C" fn RevokeAndACK_get_channel_id(this_ptr: &RevokeAndACK) -> *const [u8; 32] {
2136 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
2141 pub extern "C" fn RevokeAndACK_set_channel_id(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::ThirtyTwoBytes) {
2142 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
2144 /// The secret corresponding to the per-commitment point
2146 pub extern "C" fn RevokeAndACK_get_per_commitment_secret(this_ptr: &RevokeAndACK) -> *const [u8; 32] {
2147 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.per_commitment_secret;
2150 /// The secret corresponding to the per-commitment point
2152 pub extern "C" fn RevokeAndACK_set_per_commitment_secret(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::ThirtyTwoBytes) {
2153 unsafe { &mut *this_ptr.inner }.per_commitment_secret = val.data;
2155 /// The next sender-broadcast commitment transaction's per-commitment point
2157 pub extern "C" fn RevokeAndACK_get_next_per_commitment_point(this_ptr: &RevokeAndACK) -> crate::c_types::PublicKey {
2158 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.next_per_commitment_point;
2159 crate::c_types::PublicKey::from_rust(&inner_val)
2161 /// The next sender-broadcast commitment transaction's per-commitment point
2163 pub extern "C" fn RevokeAndACK_set_next_per_commitment_point(this_ptr: &mut RevokeAndACK, mut val: crate::c_types::PublicKey) {
2164 unsafe { &mut *this_ptr.inner }.next_per_commitment_point = val.into_rust();
2166 /// Constructs a new RevokeAndACK given each field
2169 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 {
2170 RevokeAndACK { inner: Box::into_raw(Box::new(nativeRevokeAndACK {
2171 channel_id: channel_id_arg.data,
2172 per_commitment_secret: per_commitment_secret_arg.data,
2173 next_per_commitment_point: next_per_commitment_point_arg.into_rust(),
2174 })), is_owned: true }
2176 impl Clone for RevokeAndACK {
2177 fn clone(&self) -> Self {
2179 inner: if <*mut nativeRevokeAndACK>::is_null(self.inner) { std::ptr::null_mut() } else {
2180 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
2186 /// Used only if an object of this type is returned as a trait impl by a method
2187 pub(crate) extern "C" fn RevokeAndACK_clone_void(this_ptr: *const c_void) -> *mut c_void {
2188 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRevokeAndACK)).clone() })) as *mut c_void
2191 /// Creates a copy of the RevokeAndACK
2192 pub extern "C" fn RevokeAndACK_clone(orig: &RevokeAndACK) -> RevokeAndACK {
2196 use lightning::ln::msgs::UpdateFee as nativeUpdateFeeImport;
2197 type nativeUpdateFee = nativeUpdateFeeImport;
2199 /// An update_fee message to be sent or received from a peer
2202 pub struct UpdateFee {
2203 /// A pointer to the opaque Rust object.
2205 /// Nearly everywhere, inner must be non-null, however in places where
2206 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2207 pub inner: *mut nativeUpdateFee,
2208 /// Indicates that this is the only struct which contains the same pointer.
2210 /// Rust functions which take ownership of an object provided via an argument require
2211 /// this to be true and invalidate the object pointed to by inner.
2215 impl Drop for UpdateFee {
2216 fn drop(&mut self) {
2217 if self.is_owned && !<*mut nativeUpdateFee>::is_null(self.inner) {
2218 let _ = unsafe { Box::from_raw(self.inner) };
2222 /// Frees any resources used by the UpdateFee, if is_owned is set and inner is non-NULL.
2224 pub extern "C" fn UpdateFee_free(this_obj: UpdateFee) { }
2226 /// Used only if an object of this type is returned as a trait impl by a method
2227 extern "C" fn UpdateFee_free_void(this_ptr: *mut c_void) {
2228 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUpdateFee); }
2231 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2233 pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFee {
2234 assert!(self.is_owned);
2235 let ret = self.inner;
2236 self.inner = std::ptr::null_mut();
2242 pub extern "C" fn UpdateFee_get_channel_id(this_ptr: &UpdateFee) -> *const [u8; 32] {
2243 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
2248 pub extern "C" fn UpdateFee_set_channel_id(this_ptr: &mut UpdateFee, mut val: crate::c_types::ThirtyTwoBytes) {
2249 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
2251 /// Fee rate per 1000-weight of the transaction
2253 pub extern "C" fn UpdateFee_get_feerate_per_kw(this_ptr: &UpdateFee) -> u32 {
2254 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.feerate_per_kw;
2257 /// Fee rate per 1000-weight of the transaction
2259 pub extern "C" fn UpdateFee_set_feerate_per_kw(this_ptr: &mut UpdateFee, mut val: u32) {
2260 unsafe { &mut *this_ptr.inner }.feerate_per_kw = val;
2262 /// Constructs a new UpdateFee given each field
2265 pub extern "C" fn UpdateFee_new(mut channel_id_arg: crate::c_types::ThirtyTwoBytes, mut feerate_per_kw_arg: u32) -> UpdateFee {
2266 UpdateFee { inner: Box::into_raw(Box::new(nativeUpdateFee {
2267 channel_id: channel_id_arg.data,
2268 feerate_per_kw: feerate_per_kw_arg,
2269 })), is_owned: true }
2271 impl Clone for UpdateFee {
2272 fn clone(&self) -> Self {
2274 inner: if <*mut nativeUpdateFee>::is_null(self.inner) { std::ptr::null_mut() } else {
2275 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
2281 /// Used only if an object of this type is returned as a trait impl by a method
2282 pub(crate) extern "C" fn UpdateFee_clone_void(this_ptr: *const c_void) -> *mut c_void {
2283 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFee)).clone() })) as *mut c_void
2286 /// Creates a copy of the UpdateFee
2287 pub extern "C" fn UpdateFee_clone(orig: &UpdateFee) -> UpdateFee {
2291 use lightning::ln::msgs::DataLossProtect as nativeDataLossProtectImport;
2292 type nativeDataLossProtect = nativeDataLossProtectImport;
2294 /// Proof that the sender knows the per-commitment secret of the previous commitment transaction.
2295 /// This is used to convince the recipient that the channel is at a certain commitment
2296 /// number even if they lost that data due to a local failure. Of course, the peer may lie
2297 /// and even later commitments may have been revoked.
2300 pub struct DataLossProtect {
2301 /// A pointer to the opaque Rust object.
2303 /// Nearly everywhere, inner must be non-null, however in places where
2304 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2305 pub inner: *mut nativeDataLossProtect,
2306 /// Indicates that this is the only struct which contains the same pointer.
2308 /// Rust functions which take ownership of an object provided via an argument require
2309 /// this to be true and invalidate the object pointed to by inner.
2313 impl Drop for DataLossProtect {
2314 fn drop(&mut self) {
2315 if self.is_owned && !<*mut nativeDataLossProtect>::is_null(self.inner) {
2316 let _ = unsafe { Box::from_raw(self.inner) };
2320 /// Frees any resources used by the DataLossProtect, if is_owned is set and inner is non-NULL.
2322 pub extern "C" fn DataLossProtect_free(this_obj: DataLossProtect) { }
2324 /// Used only if an object of this type is returned as a trait impl by a method
2325 extern "C" fn DataLossProtect_free_void(this_ptr: *mut c_void) {
2326 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeDataLossProtect); }
2329 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2330 impl DataLossProtect {
2331 pub(crate) fn take_inner(mut self) -> *mut nativeDataLossProtect {
2332 assert!(self.is_owned);
2333 let ret = self.inner;
2334 self.inner = std::ptr::null_mut();
2338 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
2339 /// belonging to the recipient
2341 pub extern "C" fn DataLossProtect_get_your_last_per_commitment_secret(this_ptr: &DataLossProtect) -> *const [u8; 32] {
2342 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.your_last_per_commitment_secret;
2345 /// Proof that the sender knows the per-commitment secret of a specific commitment transaction
2346 /// belonging to the recipient
2348 pub extern "C" fn DataLossProtect_set_your_last_per_commitment_secret(this_ptr: &mut DataLossProtect, mut val: crate::c_types::ThirtyTwoBytes) {
2349 unsafe { &mut *this_ptr.inner }.your_last_per_commitment_secret = val.data;
2351 /// The sender's per-commitment point for their current commitment transaction
2353 pub extern "C" fn DataLossProtect_get_my_current_per_commitment_point(this_ptr: &DataLossProtect) -> crate::c_types::PublicKey {
2354 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.my_current_per_commitment_point;
2355 crate::c_types::PublicKey::from_rust(&inner_val)
2357 /// The sender's per-commitment point for their current commitment transaction
2359 pub extern "C" fn DataLossProtect_set_my_current_per_commitment_point(this_ptr: &mut DataLossProtect, mut val: crate::c_types::PublicKey) {
2360 unsafe { &mut *this_ptr.inner }.my_current_per_commitment_point = val.into_rust();
2362 /// Constructs a new DataLossProtect given each field
2365 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 {
2366 DataLossProtect { inner: Box::into_raw(Box::new(nativeDataLossProtect {
2367 your_last_per_commitment_secret: your_last_per_commitment_secret_arg.data,
2368 my_current_per_commitment_point: my_current_per_commitment_point_arg.into_rust(),
2369 })), is_owned: true }
2371 impl Clone for DataLossProtect {
2372 fn clone(&self) -> Self {
2374 inner: if <*mut nativeDataLossProtect>::is_null(self.inner) { std::ptr::null_mut() } else {
2375 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
2381 /// Used only if an object of this type is returned as a trait impl by a method
2382 pub(crate) extern "C" fn DataLossProtect_clone_void(this_ptr: *const c_void) -> *mut c_void {
2383 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeDataLossProtect)).clone() })) as *mut c_void
2386 /// Creates a copy of the DataLossProtect
2387 pub extern "C" fn DataLossProtect_clone(orig: &DataLossProtect) -> DataLossProtect {
2391 use lightning::ln::msgs::ChannelReestablish as nativeChannelReestablishImport;
2392 type nativeChannelReestablish = nativeChannelReestablishImport;
2394 /// A channel_reestablish message to be sent or received from a peer
2397 pub struct ChannelReestablish {
2398 /// A pointer to the opaque Rust object.
2400 /// Nearly everywhere, inner must be non-null, however in places where
2401 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2402 pub inner: *mut nativeChannelReestablish,
2403 /// Indicates that this is the only struct which contains the same pointer.
2405 /// Rust functions which take ownership of an object provided via an argument require
2406 /// this to be true and invalidate the object pointed to by inner.
2410 impl Drop for ChannelReestablish {
2411 fn drop(&mut self) {
2412 if self.is_owned && !<*mut nativeChannelReestablish>::is_null(self.inner) {
2413 let _ = unsafe { Box::from_raw(self.inner) };
2417 /// Frees any resources used by the ChannelReestablish, if is_owned is set and inner is non-NULL.
2419 pub extern "C" fn ChannelReestablish_free(this_obj: ChannelReestablish) { }
2421 /// Used only if an object of this type is returned as a trait impl by a method
2422 extern "C" fn ChannelReestablish_free_void(this_ptr: *mut c_void) {
2423 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelReestablish); }
2426 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2427 impl ChannelReestablish {
2428 pub(crate) fn take_inner(mut self) -> *mut nativeChannelReestablish {
2429 assert!(self.is_owned);
2430 let ret = self.inner;
2431 self.inner = std::ptr::null_mut();
2437 pub extern "C" fn ChannelReestablish_get_channel_id(this_ptr: &ChannelReestablish) -> *const [u8; 32] {
2438 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
2443 pub extern "C" fn ChannelReestablish_set_channel_id(this_ptr: &mut ChannelReestablish, mut val: crate::c_types::ThirtyTwoBytes) {
2444 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
2446 /// The next commitment number for the sender
2448 pub extern "C" fn ChannelReestablish_get_next_local_commitment_number(this_ptr: &ChannelReestablish) -> u64 {
2449 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.next_local_commitment_number;
2452 /// The next commitment number for the sender
2454 pub extern "C" fn ChannelReestablish_set_next_local_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) {
2455 unsafe { &mut *this_ptr.inner }.next_local_commitment_number = val;
2457 /// The next commitment number for the recipient
2459 pub extern "C" fn ChannelReestablish_get_next_remote_commitment_number(this_ptr: &ChannelReestablish) -> u64 {
2460 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.next_remote_commitment_number;
2463 /// The next commitment number for the recipient
2465 pub extern "C" fn ChannelReestablish_set_next_remote_commitment_number(this_ptr: &mut ChannelReestablish, mut val: u64) {
2466 unsafe { &mut *this_ptr.inner }.next_remote_commitment_number = val;
2468 impl Clone for ChannelReestablish {
2469 fn clone(&self) -> Self {
2471 inner: if <*mut nativeChannelReestablish>::is_null(self.inner) { std::ptr::null_mut() } else {
2472 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
2478 /// Used only if an object of this type is returned as a trait impl by a method
2479 pub(crate) extern "C" fn ChannelReestablish_clone_void(this_ptr: *const c_void) -> *mut c_void {
2480 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelReestablish)).clone() })) as *mut c_void
2483 /// Creates a copy of the ChannelReestablish
2484 pub extern "C" fn ChannelReestablish_clone(orig: &ChannelReestablish) -> ChannelReestablish {
2488 use lightning::ln::msgs::AnnouncementSignatures as nativeAnnouncementSignaturesImport;
2489 type nativeAnnouncementSignatures = nativeAnnouncementSignaturesImport;
2491 /// An announcement_signatures message to be sent or received from a peer
2494 pub struct AnnouncementSignatures {
2495 /// A pointer to the opaque Rust object.
2497 /// Nearly everywhere, inner must be non-null, however in places where
2498 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2499 pub inner: *mut nativeAnnouncementSignatures,
2500 /// Indicates that this is the only struct which contains the same pointer.
2502 /// Rust functions which take ownership of an object provided via an argument require
2503 /// this to be true and invalidate the object pointed to by inner.
2507 impl Drop for AnnouncementSignatures {
2508 fn drop(&mut self) {
2509 if self.is_owned && !<*mut nativeAnnouncementSignatures>::is_null(self.inner) {
2510 let _ = unsafe { Box::from_raw(self.inner) };
2514 /// Frees any resources used by the AnnouncementSignatures, if is_owned is set and inner is non-NULL.
2516 pub extern "C" fn AnnouncementSignatures_free(this_obj: AnnouncementSignatures) { }
2518 /// Used only if an object of this type is returned as a trait impl by a method
2519 extern "C" fn AnnouncementSignatures_free_void(this_ptr: *mut c_void) {
2520 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeAnnouncementSignatures); }
2523 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2524 impl AnnouncementSignatures {
2525 pub(crate) fn take_inner(mut self) -> *mut nativeAnnouncementSignatures {
2526 assert!(self.is_owned);
2527 let ret = self.inner;
2528 self.inner = std::ptr::null_mut();
2534 pub extern "C" fn AnnouncementSignatures_get_channel_id(this_ptr: &AnnouncementSignatures) -> *const [u8; 32] {
2535 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.channel_id;
2540 pub extern "C" fn AnnouncementSignatures_set_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::ThirtyTwoBytes) {
2541 unsafe { &mut *this_ptr.inner }.channel_id = val.data;
2543 /// The short channel ID
2545 pub extern "C" fn AnnouncementSignatures_get_short_channel_id(this_ptr: &AnnouncementSignatures) -> u64 {
2546 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.short_channel_id;
2549 /// The short channel ID
2551 pub extern "C" fn AnnouncementSignatures_set_short_channel_id(this_ptr: &mut AnnouncementSignatures, mut val: u64) {
2552 unsafe { &mut *this_ptr.inner }.short_channel_id = val;
2554 /// A signature by the node key
2556 pub extern "C" fn AnnouncementSignatures_get_node_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::Signature {
2557 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_signature;
2558 crate::c_types::Signature::from_rust(&inner_val)
2560 /// A signature by the node key
2562 pub extern "C" fn AnnouncementSignatures_set_node_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::Signature) {
2563 unsafe { &mut *this_ptr.inner }.node_signature = val.into_rust();
2565 /// A signature by the funding key
2567 pub extern "C" fn AnnouncementSignatures_get_bitcoin_signature(this_ptr: &AnnouncementSignatures) -> crate::c_types::Signature {
2568 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_signature;
2569 crate::c_types::Signature::from_rust(&inner_val)
2571 /// A signature by the funding key
2573 pub extern "C" fn AnnouncementSignatures_set_bitcoin_signature(this_ptr: &mut AnnouncementSignatures, mut val: crate::c_types::Signature) {
2574 unsafe { &mut *this_ptr.inner }.bitcoin_signature = val.into_rust();
2576 /// Constructs a new AnnouncementSignatures given each field
2579 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 {
2580 AnnouncementSignatures { inner: Box::into_raw(Box::new(nativeAnnouncementSignatures {
2581 channel_id: channel_id_arg.data,
2582 short_channel_id: short_channel_id_arg,
2583 node_signature: node_signature_arg.into_rust(),
2584 bitcoin_signature: bitcoin_signature_arg.into_rust(),
2585 })), is_owned: true }
2587 impl Clone for AnnouncementSignatures {
2588 fn clone(&self) -> Self {
2590 inner: if <*mut nativeAnnouncementSignatures>::is_null(self.inner) { std::ptr::null_mut() } else {
2591 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
2597 /// Used only if an object of this type is returned as a trait impl by a method
2598 pub(crate) extern "C" fn AnnouncementSignatures_clone_void(this_ptr: *const c_void) -> *mut c_void {
2599 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeAnnouncementSignatures)).clone() })) as *mut c_void
2602 /// Creates a copy of the AnnouncementSignatures
2603 pub extern "C" fn AnnouncementSignatures_clone(orig: &AnnouncementSignatures) -> AnnouncementSignatures {
2606 /// An address which can be used to connect to a remote peer
2610 pub enum NetAddress {
2611 /// An IPv4 address/port on which the peer is listening.
2613 /// The 4-byte IPv4 address
2614 addr: crate::c_types::FourBytes,
2615 /// The port on which the node is listening
2618 /// An IPv6 address/port on which the peer is listening.
2620 /// The 16-byte IPv6 address
2621 addr: crate::c_types::SixteenBytes,
2622 /// The port on which the node is listening
2625 /// An old-style Tor onion address/port on which the peer is listening.
2627 /// The bytes (usually encoded in base32 with \".onion\" appended)
2628 addr: crate::c_types::TenBytes,
2629 /// The port on which the node is listening
2632 /// A new-style Tor onion address/port on which the peer is listening.
2633 /// To create the human-readable \"hostname\", concatenate ed25519_pubkey, checksum, and version,
2634 /// wrap as base32 and append \".onion\".
2636 /// The ed25519 long-term public key of the peer
2637 ed25519_pubkey: crate::c_types::ThirtyTwoBytes,
2638 /// The checksum of the pubkey and version, as included in the onion address
2640 /// The version byte, as defined by the Tor Onion v3 spec.
2642 /// The port on which the node is listening
2646 use lightning::ln::msgs::NetAddress as nativeNetAddress;
2649 pub(crate) fn to_native(&self) -> nativeNetAddress {
2651 NetAddress::IPv4 {ref addr, ref port, } => {
2652 let mut addr_nonref = (*addr).clone();
2653 let mut port_nonref = (*port).clone();
2654 nativeNetAddress::IPv4 {
2655 addr: addr_nonref.data,
2659 NetAddress::IPv6 {ref addr, ref port, } => {
2660 let mut addr_nonref = (*addr).clone();
2661 let mut port_nonref = (*port).clone();
2662 nativeNetAddress::IPv6 {
2663 addr: addr_nonref.data,
2667 NetAddress::OnionV2 {ref addr, ref port, } => {
2668 let mut addr_nonref = (*addr).clone();
2669 let mut port_nonref = (*port).clone();
2670 nativeNetAddress::OnionV2 {
2671 addr: addr_nonref.data,
2675 NetAddress::OnionV3 {ref ed25519_pubkey, ref checksum, ref version, ref port, } => {
2676 let mut ed25519_pubkey_nonref = (*ed25519_pubkey).clone();
2677 let mut checksum_nonref = (*checksum).clone();
2678 let mut version_nonref = (*version).clone();
2679 let mut port_nonref = (*port).clone();
2680 nativeNetAddress::OnionV3 {
2681 ed25519_pubkey: ed25519_pubkey_nonref.data,
2682 checksum: checksum_nonref,
2683 version: version_nonref,
2690 pub(crate) fn into_native(self) -> nativeNetAddress {
2692 NetAddress::IPv4 {mut addr, mut port, } => {
2693 nativeNetAddress::IPv4 {
2698 NetAddress::IPv6 {mut addr, mut port, } => {
2699 nativeNetAddress::IPv6 {
2704 NetAddress::OnionV2 {mut addr, mut port, } => {
2705 nativeNetAddress::OnionV2 {
2710 NetAddress::OnionV3 {mut ed25519_pubkey, mut checksum, mut version, mut port, } => {
2711 nativeNetAddress::OnionV3 {
2712 ed25519_pubkey: ed25519_pubkey.data,
2721 pub(crate) fn from_native(native: &nativeNetAddress) -> Self {
2723 nativeNetAddress::IPv4 {ref addr, ref port, } => {
2724 let mut addr_nonref = (*addr).clone();
2725 let mut port_nonref = (*port).clone();
2727 addr: crate::c_types::FourBytes { data: addr_nonref },
2731 nativeNetAddress::IPv6 {ref addr, ref port, } => {
2732 let mut addr_nonref = (*addr).clone();
2733 let mut port_nonref = (*port).clone();
2735 addr: crate::c_types::SixteenBytes { data: addr_nonref },
2739 nativeNetAddress::OnionV2 {ref addr, ref port, } => {
2740 let mut addr_nonref = (*addr).clone();
2741 let mut port_nonref = (*port).clone();
2742 NetAddress::OnionV2 {
2743 addr: crate::c_types::TenBytes { data: addr_nonref },
2747 nativeNetAddress::OnionV3 {ref ed25519_pubkey, ref checksum, ref version, ref port, } => {
2748 let mut ed25519_pubkey_nonref = (*ed25519_pubkey).clone();
2749 let mut checksum_nonref = (*checksum).clone();
2750 let mut version_nonref = (*version).clone();
2751 let mut port_nonref = (*port).clone();
2752 NetAddress::OnionV3 {
2753 ed25519_pubkey: crate::c_types::ThirtyTwoBytes { data: ed25519_pubkey_nonref },
2754 checksum: checksum_nonref,
2755 version: version_nonref,
2762 pub(crate) fn native_into(native: nativeNetAddress) -> Self {
2764 nativeNetAddress::IPv4 {mut addr, mut port, } => {
2766 addr: crate::c_types::FourBytes { data: addr },
2770 nativeNetAddress::IPv6 {mut addr, mut port, } => {
2772 addr: crate::c_types::SixteenBytes { data: addr },
2776 nativeNetAddress::OnionV2 {mut addr, mut port, } => {
2777 NetAddress::OnionV2 {
2778 addr: crate::c_types::TenBytes { data: addr },
2782 nativeNetAddress::OnionV3 {mut ed25519_pubkey, mut checksum, mut version, mut port, } => {
2783 NetAddress::OnionV3 {
2784 ed25519_pubkey: crate::c_types::ThirtyTwoBytes { data: ed25519_pubkey },
2793 /// Frees any resources used by the NetAddress
2795 pub extern "C" fn NetAddress_free(this_ptr: NetAddress) { }
2796 /// Creates a copy of the NetAddress
2798 pub extern "C" fn NetAddress_clone(orig: &NetAddress) -> NetAddress {
2802 /// Utility method to constructs a new IPv4-variant NetAddress
2803 pub extern "C" fn NetAddress_ipv4(addr: crate::c_types::FourBytes, port: u16) -> NetAddress {
2810 /// Utility method to constructs a new IPv6-variant NetAddress
2811 pub extern "C" fn NetAddress_ipv6(addr: crate::c_types::SixteenBytes, port: u16) -> NetAddress {
2818 /// Utility method to constructs a new OnionV2-variant NetAddress
2819 pub extern "C" fn NetAddress_onion_v2(addr: crate::c_types::TenBytes, port: u16) -> NetAddress {
2820 NetAddress::OnionV2 {
2826 /// Utility method to constructs a new OnionV3-variant NetAddress
2827 pub extern "C" fn NetAddress_onion_v3(ed25519_pubkey: crate::c_types::ThirtyTwoBytes, checksum: u16, version: u8, port: u16) -> NetAddress {
2828 NetAddress::OnionV3 {
2836 /// Serialize the NetAddress object into a byte array which can be read by NetAddress_read
2837 pub extern "C" fn NetAddress_write(obj: &NetAddress) -> crate::c_types::derived::CVec_u8Z {
2838 crate::c_types::serialize_obj(&unsafe { &*obj }.to_native())
2841 /// Read a Result from a byte array, created by Result_write
2842 pub extern "C" fn Result_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_CResult_NetAddressu8ZDecodeErrorZ {
2843 let res = crate::c_types::deserialize_obj(ser);
2844 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { let mut local_res_0 = match o { 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( { e }).into() }; local_res_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
2848 /// Read a NetAddress from a byte array, created by NetAddress_write
2849 pub extern "C" fn NetAddress_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_NetAddressDecodeErrorZ {
2850 let res = crate::c_types::deserialize_obj(ser);
2851 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: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
2855 use lightning::ln::msgs::UnsignedNodeAnnouncement as nativeUnsignedNodeAnnouncementImport;
2856 type nativeUnsignedNodeAnnouncement = nativeUnsignedNodeAnnouncementImport;
2858 /// The unsigned part of a node_announcement
2861 pub struct UnsignedNodeAnnouncement {
2862 /// A pointer to the opaque Rust object.
2864 /// Nearly everywhere, inner must be non-null, however in places where
2865 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2866 pub inner: *mut nativeUnsignedNodeAnnouncement,
2867 /// Indicates that this is the only struct which contains the same pointer.
2869 /// Rust functions which take ownership of an object provided via an argument require
2870 /// this to be true and invalidate the object pointed to by inner.
2874 impl Drop for UnsignedNodeAnnouncement {
2875 fn drop(&mut self) {
2876 if self.is_owned && !<*mut nativeUnsignedNodeAnnouncement>::is_null(self.inner) {
2877 let _ = unsafe { Box::from_raw(self.inner) };
2881 /// Frees any resources used by the UnsignedNodeAnnouncement, if is_owned is set and inner is non-NULL.
2883 pub extern "C" fn UnsignedNodeAnnouncement_free(this_obj: UnsignedNodeAnnouncement) { }
2885 /// Used only if an object of this type is returned as a trait impl by a method
2886 extern "C" fn UnsignedNodeAnnouncement_free_void(this_ptr: *mut c_void) {
2887 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUnsignedNodeAnnouncement); }
2890 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
2891 impl UnsignedNodeAnnouncement {
2892 pub(crate) fn take_inner(mut self) -> *mut nativeUnsignedNodeAnnouncement {
2893 assert!(self.is_owned);
2894 let ret = self.inner;
2895 self.inner = std::ptr::null_mut();
2899 /// The advertised features
2901 pub extern "C" fn UnsignedNodeAnnouncement_get_features(this_ptr: &UnsignedNodeAnnouncement) -> crate::lightning::ln::features::NodeFeatures {
2902 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.features;
2903 crate::lightning::ln::features::NodeFeatures { inner: unsafe { ( (&(*inner_val) as *const _) as *mut _) }, is_owned: false }
2905 /// The advertised features
2907 pub extern "C" fn UnsignedNodeAnnouncement_set_features(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::lightning::ln::features::NodeFeatures) {
2908 unsafe { &mut *this_ptr.inner }.features = *unsafe { Box::from_raw(val.take_inner()) };
2910 /// A strictly monotonic announcement counter, with gaps allowed
2912 pub extern "C" fn UnsignedNodeAnnouncement_get_timestamp(this_ptr: &UnsignedNodeAnnouncement) -> u32 {
2913 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.timestamp;
2916 /// A strictly monotonic announcement counter, with gaps allowed
2918 pub extern "C" fn UnsignedNodeAnnouncement_set_timestamp(this_ptr: &mut UnsignedNodeAnnouncement, mut val: u32) {
2919 unsafe { &mut *this_ptr.inner }.timestamp = val;
2921 /// The node_id this announcement originated from (don't rebroadcast the node_announcement back
2924 pub extern "C" fn UnsignedNodeAnnouncement_get_node_id(this_ptr: &UnsignedNodeAnnouncement) -> crate::c_types::PublicKey {
2925 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_id;
2926 crate::c_types::PublicKey::from_rust(&inner_val)
2928 /// The node_id this announcement originated from (don't rebroadcast the node_announcement back
2931 pub extern "C" fn UnsignedNodeAnnouncement_set_node_id(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::PublicKey) {
2932 unsafe { &mut *this_ptr.inner }.node_id = val.into_rust();
2934 /// An RGB color for UI purposes
2936 pub extern "C" fn UnsignedNodeAnnouncement_get_rgb(this_ptr: &UnsignedNodeAnnouncement) -> *const [u8; 3] {
2937 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.rgb;
2940 /// An RGB color for UI purposes
2942 pub extern "C" fn UnsignedNodeAnnouncement_set_rgb(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::ThreeBytes) {
2943 unsafe { &mut *this_ptr.inner }.rgb = val.data;
2945 /// An alias, for UI purposes. This should be sanitized before use. There is no guarantee
2948 pub extern "C" fn UnsignedNodeAnnouncement_get_alias(this_ptr: &UnsignedNodeAnnouncement) -> *const [u8; 32] {
2949 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.alias;
2952 /// An alias, for UI purposes. This should be sanitized before use. There is no guarantee
2955 pub extern "C" fn UnsignedNodeAnnouncement_set_alias(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::ThirtyTwoBytes) {
2956 unsafe { &mut *this_ptr.inner }.alias = val.data;
2958 /// List of addresses on which this node is reachable
2960 pub extern "C" fn UnsignedNodeAnnouncement_set_addresses(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::c_types::derived::CVec_NetAddressZ) {
2961 let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item.into_native() }); };
2962 unsafe { &mut *this_ptr.inner }.addresses = local_val;
2964 impl Clone for UnsignedNodeAnnouncement {
2965 fn clone(&self) -> Self {
2967 inner: if <*mut nativeUnsignedNodeAnnouncement>::is_null(self.inner) { std::ptr::null_mut() } else {
2968 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
2974 /// Used only if an object of this type is returned as a trait impl by a method
2975 pub(crate) extern "C" fn UnsignedNodeAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void {
2976 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedNodeAnnouncement)).clone() })) as *mut c_void
2979 /// Creates a copy of the UnsignedNodeAnnouncement
2980 pub extern "C" fn UnsignedNodeAnnouncement_clone(orig: &UnsignedNodeAnnouncement) -> UnsignedNodeAnnouncement {
2984 use lightning::ln::msgs::NodeAnnouncement as nativeNodeAnnouncementImport;
2985 type nativeNodeAnnouncement = nativeNodeAnnouncementImport;
2987 /// A node_announcement message to be sent or received from a peer
2990 pub struct NodeAnnouncement {
2991 /// A pointer to the opaque Rust object.
2993 /// Nearly everywhere, inner must be non-null, however in places where
2994 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
2995 pub inner: *mut nativeNodeAnnouncement,
2996 /// Indicates that this is the only struct which contains the same pointer.
2998 /// Rust functions which take ownership of an object provided via an argument require
2999 /// this to be true and invalidate the object pointed to by inner.
3003 impl Drop for NodeAnnouncement {
3004 fn drop(&mut self) {
3005 if self.is_owned && !<*mut nativeNodeAnnouncement>::is_null(self.inner) {
3006 let _ = unsafe { Box::from_raw(self.inner) };
3010 /// Frees any resources used by the NodeAnnouncement, if is_owned is set and inner is non-NULL.
3012 pub extern "C" fn NodeAnnouncement_free(this_obj: NodeAnnouncement) { }
3014 /// Used only if an object of this type is returned as a trait impl by a method
3015 extern "C" fn NodeAnnouncement_free_void(this_ptr: *mut c_void) {
3016 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeNodeAnnouncement); }
3019 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3020 impl NodeAnnouncement {
3021 pub(crate) fn take_inner(mut self) -> *mut nativeNodeAnnouncement {
3022 assert!(self.is_owned);
3023 let ret = self.inner;
3024 self.inner = std::ptr::null_mut();
3028 /// The signature by the node key
3030 pub extern "C" fn NodeAnnouncement_get_signature(this_ptr: &NodeAnnouncement) -> crate::c_types::Signature {
3031 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature;
3032 crate::c_types::Signature::from_rust(&inner_val)
3034 /// The signature by the node key
3036 pub extern "C" fn NodeAnnouncement_set_signature(this_ptr: &mut NodeAnnouncement, mut val: crate::c_types::Signature) {
3037 unsafe { &mut *this_ptr.inner }.signature = val.into_rust();
3039 /// The actual content of the announcement
3041 pub extern "C" fn NodeAnnouncement_get_contents(this_ptr: &NodeAnnouncement) -> crate::lightning::ln::msgs::UnsignedNodeAnnouncement {
3042 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.contents;
3043 crate::lightning::ln::msgs::UnsignedNodeAnnouncement { inner: unsafe { ( (&(*inner_val) as *const _) as *mut _) }, is_owned: false }
3045 /// The actual content of the announcement
3047 pub extern "C" fn NodeAnnouncement_set_contents(this_ptr: &mut NodeAnnouncement, mut val: crate::lightning::ln::msgs::UnsignedNodeAnnouncement) {
3048 unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_inner()) };
3050 /// Constructs a new NodeAnnouncement given each field
3053 pub extern "C" fn NodeAnnouncement_new(mut signature_arg: crate::c_types::Signature, mut contents_arg: crate::lightning::ln::msgs::UnsignedNodeAnnouncement) -> NodeAnnouncement {
3054 NodeAnnouncement { inner: Box::into_raw(Box::new(nativeNodeAnnouncement {
3055 signature: signature_arg.into_rust(),
3056 contents: *unsafe { Box::from_raw(contents_arg.take_inner()) },
3057 })), is_owned: true }
3059 impl Clone for NodeAnnouncement {
3060 fn clone(&self) -> Self {
3062 inner: if <*mut nativeNodeAnnouncement>::is_null(self.inner) { std::ptr::null_mut() } else {
3063 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
3069 /// Used only if an object of this type is returned as a trait impl by a method
3070 pub(crate) extern "C" fn NodeAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void {
3071 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeNodeAnnouncement)).clone() })) as *mut c_void
3074 /// Creates a copy of the NodeAnnouncement
3075 pub extern "C" fn NodeAnnouncement_clone(orig: &NodeAnnouncement) -> NodeAnnouncement {
3079 use lightning::ln::msgs::UnsignedChannelAnnouncement as nativeUnsignedChannelAnnouncementImport;
3080 type nativeUnsignedChannelAnnouncement = nativeUnsignedChannelAnnouncementImport;
3082 /// The unsigned part of a channel_announcement
3085 pub struct UnsignedChannelAnnouncement {
3086 /// A pointer to the opaque Rust object.
3088 /// Nearly everywhere, inner must be non-null, however in places where
3089 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3090 pub inner: *mut nativeUnsignedChannelAnnouncement,
3091 /// Indicates that this is the only struct which contains the same pointer.
3093 /// Rust functions which take ownership of an object provided via an argument require
3094 /// this to be true and invalidate the object pointed to by inner.
3098 impl Drop for UnsignedChannelAnnouncement {
3099 fn drop(&mut self) {
3100 if self.is_owned && !<*mut nativeUnsignedChannelAnnouncement>::is_null(self.inner) {
3101 let _ = unsafe { Box::from_raw(self.inner) };
3105 /// Frees any resources used by the UnsignedChannelAnnouncement, if is_owned is set and inner is non-NULL.
3107 pub extern "C" fn UnsignedChannelAnnouncement_free(this_obj: UnsignedChannelAnnouncement) { }
3109 /// Used only if an object of this type is returned as a trait impl by a method
3110 extern "C" fn UnsignedChannelAnnouncement_free_void(this_ptr: *mut c_void) {
3111 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUnsignedChannelAnnouncement); }
3114 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3115 impl UnsignedChannelAnnouncement {
3116 pub(crate) fn take_inner(mut self) -> *mut nativeUnsignedChannelAnnouncement {
3117 assert!(self.is_owned);
3118 let ret = self.inner;
3119 self.inner = std::ptr::null_mut();
3123 /// The advertised channel features
3125 pub extern "C" fn UnsignedChannelAnnouncement_get_features(this_ptr: &UnsignedChannelAnnouncement) -> crate::lightning::ln::features::ChannelFeatures {
3126 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.features;
3127 crate::lightning::ln::features::ChannelFeatures { inner: unsafe { ( (&(*inner_val) as *const _) as *mut _) }, is_owned: false }
3129 /// The advertised channel features
3131 pub extern "C" fn UnsignedChannelAnnouncement_set_features(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::lightning::ln::features::ChannelFeatures) {
3132 unsafe { &mut *this_ptr.inner }.features = *unsafe { Box::from_raw(val.take_inner()) };
3134 /// The genesis hash of the blockchain where the channel is to be opened
3136 pub extern "C" fn UnsignedChannelAnnouncement_get_chain_hash(this_ptr: &UnsignedChannelAnnouncement) -> *const [u8; 32] {
3137 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash;
3138 inner_val.as_inner()
3140 /// The genesis hash of the blockchain where the channel is to be opened
3142 pub extern "C" fn UnsignedChannelAnnouncement_set_chain_hash(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::ThirtyTwoBytes) {
3143 unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
3145 /// The short channel ID
3147 pub extern "C" fn UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: &UnsignedChannelAnnouncement) -> u64 {
3148 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.short_channel_id;
3151 /// The short channel ID
3153 pub extern "C" fn UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: &mut UnsignedChannelAnnouncement, mut val: u64) {
3154 unsafe { &mut *this_ptr.inner }.short_channel_id = val;
3156 /// One of the two node_ids which are endpoints of this channel
3158 pub extern "C" fn UnsignedChannelAnnouncement_get_node_id_1(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey {
3159 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_id_1;
3160 crate::c_types::PublicKey::from_rust(&inner_val)
3162 /// One of the two node_ids which are endpoints of this channel
3164 pub extern "C" fn UnsignedChannelAnnouncement_set_node_id_1(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) {
3165 unsafe { &mut *this_ptr.inner }.node_id_1 = val.into_rust();
3167 /// The other of the two node_ids which are endpoints of this channel
3169 pub extern "C" fn UnsignedChannelAnnouncement_get_node_id_2(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey {
3170 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_id_2;
3171 crate::c_types::PublicKey::from_rust(&inner_val)
3173 /// The other of the two node_ids which are endpoints of this channel
3175 pub extern "C" fn UnsignedChannelAnnouncement_set_node_id_2(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) {
3176 unsafe { &mut *this_ptr.inner }.node_id_2 = val.into_rust();
3178 /// The funding key for the first node
3180 pub extern "C" fn UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey {
3181 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_key_1;
3182 crate::c_types::PublicKey::from_rust(&inner_val)
3184 /// The funding key for the first node
3186 pub extern "C" fn UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) {
3187 unsafe { &mut *this_ptr.inner }.bitcoin_key_1 = val.into_rust();
3189 /// The funding key for the second node
3191 pub extern "C" fn UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: &UnsignedChannelAnnouncement) -> crate::c_types::PublicKey {
3192 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_key_2;
3193 crate::c_types::PublicKey::from_rust(&inner_val)
3195 /// The funding key for the second node
3197 pub extern "C" fn UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::c_types::PublicKey) {
3198 unsafe { &mut *this_ptr.inner }.bitcoin_key_2 = val.into_rust();
3200 impl Clone for UnsignedChannelAnnouncement {
3201 fn clone(&self) -> Self {
3203 inner: if <*mut nativeUnsignedChannelAnnouncement>::is_null(self.inner) { std::ptr::null_mut() } else {
3204 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
3210 /// Used only if an object of this type is returned as a trait impl by a method
3211 pub(crate) extern "C" fn UnsignedChannelAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void {
3212 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedChannelAnnouncement)).clone() })) as *mut c_void
3215 /// Creates a copy of the UnsignedChannelAnnouncement
3216 pub extern "C" fn UnsignedChannelAnnouncement_clone(orig: &UnsignedChannelAnnouncement) -> UnsignedChannelAnnouncement {
3220 use lightning::ln::msgs::ChannelAnnouncement as nativeChannelAnnouncementImport;
3221 type nativeChannelAnnouncement = nativeChannelAnnouncementImport;
3223 /// A channel_announcement message to be sent or received from a peer
3226 pub struct ChannelAnnouncement {
3227 /// A pointer to the opaque Rust object.
3229 /// Nearly everywhere, inner must be non-null, however in places where
3230 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3231 pub inner: *mut nativeChannelAnnouncement,
3232 /// Indicates that this is the only struct which contains the same pointer.
3234 /// Rust functions which take ownership of an object provided via an argument require
3235 /// this to be true and invalidate the object pointed to by inner.
3239 impl Drop for ChannelAnnouncement {
3240 fn drop(&mut self) {
3241 if self.is_owned && !<*mut nativeChannelAnnouncement>::is_null(self.inner) {
3242 let _ = unsafe { Box::from_raw(self.inner) };
3246 /// Frees any resources used by the ChannelAnnouncement, if is_owned is set and inner is non-NULL.
3248 pub extern "C" fn ChannelAnnouncement_free(this_obj: ChannelAnnouncement) { }
3250 /// Used only if an object of this type is returned as a trait impl by a method
3251 extern "C" fn ChannelAnnouncement_free_void(this_ptr: *mut c_void) {
3252 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelAnnouncement); }
3255 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3256 impl ChannelAnnouncement {
3257 pub(crate) fn take_inner(mut self) -> *mut nativeChannelAnnouncement {
3258 assert!(self.is_owned);
3259 let ret = self.inner;
3260 self.inner = std::ptr::null_mut();
3264 /// Authentication of the announcement by the first public node
3266 pub extern "C" fn ChannelAnnouncement_get_node_signature_1(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature {
3267 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_signature_1;
3268 crate::c_types::Signature::from_rust(&inner_val)
3270 /// Authentication of the announcement by the first public node
3272 pub extern "C" fn ChannelAnnouncement_set_node_signature_1(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) {
3273 unsafe { &mut *this_ptr.inner }.node_signature_1 = val.into_rust();
3275 /// Authentication of the announcement by the second public node
3277 pub extern "C" fn ChannelAnnouncement_get_node_signature_2(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature {
3278 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.node_signature_2;
3279 crate::c_types::Signature::from_rust(&inner_val)
3281 /// Authentication of the announcement by the second public node
3283 pub extern "C" fn ChannelAnnouncement_set_node_signature_2(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) {
3284 unsafe { &mut *this_ptr.inner }.node_signature_2 = val.into_rust();
3286 /// Proof of funding UTXO ownership by the first public node
3288 pub extern "C" fn ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature {
3289 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_signature_1;
3290 crate::c_types::Signature::from_rust(&inner_val)
3292 /// Proof of funding UTXO ownership by the first public node
3294 pub extern "C" fn ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) {
3295 unsafe { &mut *this_ptr.inner }.bitcoin_signature_1 = val.into_rust();
3297 /// Proof of funding UTXO ownership by the second public node
3299 pub extern "C" fn ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature {
3300 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.bitcoin_signature_2;
3301 crate::c_types::Signature::from_rust(&inner_val)
3303 /// Proof of funding UTXO ownership by the second public node
3305 pub extern "C" fn ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: &mut ChannelAnnouncement, mut val: crate::c_types::Signature) {
3306 unsafe { &mut *this_ptr.inner }.bitcoin_signature_2 = val.into_rust();
3308 /// The actual announcement
3310 pub extern "C" fn ChannelAnnouncement_get_contents(this_ptr: &ChannelAnnouncement) -> crate::lightning::ln::msgs::UnsignedChannelAnnouncement {
3311 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.contents;
3312 crate::lightning::ln::msgs::UnsignedChannelAnnouncement { inner: unsafe { ( (&(*inner_val) as *const _) as *mut _) }, is_owned: false }
3314 /// The actual announcement
3316 pub extern "C" fn ChannelAnnouncement_set_contents(this_ptr: &mut ChannelAnnouncement, mut val: crate::lightning::ln::msgs::UnsignedChannelAnnouncement) {
3317 unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_inner()) };
3319 /// Constructs a new ChannelAnnouncement given each field
3322 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 {
3323 ChannelAnnouncement { inner: Box::into_raw(Box::new(nativeChannelAnnouncement {
3324 node_signature_1: node_signature_1_arg.into_rust(),
3325 node_signature_2: node_signature_2_arg.into_rust(),
3326 bitcoin_signature_1: bitcoin_signature_1_arg.into_rust(),
3327 bitcoin_signature_2: bitcoin_signature_2_arg.into_rust(),
3328 contents: *unsafe { Box::from_raw(contents_arg.take_inner()) },
3329 })), is_owned: true }
3331 impl Clone for ChannelAnnouncement {
3332 fn clone(&self) -> Self {
3334 inner: if <*mut nativeChannelAnnouncement>::is_null(self.inner) { std::ptr::null_mut() } else {
3335 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
3341 /// Used only if an object of this type is returned as a trait impl by a method
3342 pub(crate) extern "C" fn ChannelAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void {
3343 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelAnnouncement)).clone() })) as *mut c_void
3346 /// Creates a copy of the ChannelAnnouncement
3347 pub extern "C" fn ChannelAnnouncement_clone(orig: &ChannelAnnouncement) -> ChannelAnnouncement {
3351 use lightning::ln::msgs::UnsignedChannelUpdate as nativeUnsignedChannelUpdateImport;
3352 type nativeUnsignedChannelUpdate = nativeUnsignedChannelUpdateImport;
3354 /// The unsigned part of a channel_update
3357 pub struct UnsignedChannelUpdate {
3358 /// A pointer to the opaque Rust object.
3360 /// Nearly everywhere, inner must be non-null, however in places where
3361 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3362 pub inner: *mut nativeUnsignedChannelUpdate,
3363 /// Indicates that this is the only struct which contains the same pointer.
3365 /// Rust functions which take ownership of an object provided via an argument require
3366 /// this to be true and invalidate the object pointed to by inner.
3370 impl Drop for UnsignedChannelUpdate {
3371 fn drop(&mut self) {
3372 if self.is_owned && !<*mut nativeUnsignedChannelUpdate>::is_null(self.inner) {
3373 let _ = unsafe { Box::from_raw(self.inner) };
3377 /// Frees any resources used by the UnsignedChannelUpdate, if is_owned is set and inner is non-NULL.
3379 pub extern "C" fn UnsignedChannelUpdate_free(this_obj: UnsignedChannelUpdate) { }
3381 /// Used only if an object of this type is returned as a trait impl by a method
3382 extern "C" fn UnsignedChannelUpdate_free_void(this_ptr: *mut c_void) {
3383 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeUnsignedChannelUpdate); }
3386 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3387 impl UnsignedChannelUpdate {
3388 pub(crate) fn take_inner(mut self) -> *mut nativeUnsignedChannelUpdate {
3389 assert!(self.is_owned);
3390 let ret = self.inner;
3391 self.inner = std::ptr::null_mut();
3395 /// The genesis hash of the blockchain where the channel is to be opened
3397 pub extern "C" fn UnsignedChannelUpdate_get_chain_hash(this_ptr: &UnsignedChannelUpdate) -> *const [u8; 32] {
3398 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash;
3399 inner_val.as_inner()
3401 /// The genesis hash of the blockchain where the channel is to be opened
3403 pub extern "C" fn UnsignedChannelUpdate_set_chain_hash(this_ptr: &mut UnsignedChannelUpdate, mut val: crate::c_types::ThirtyTwoBytes) {
3404 unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
3406 /// The short channel ID
3408 pub extern "C" fn UnsignedChannelUpdate_get_short_channel_id(this_ptr: &UnsignedChannelUpdate) -> u64 {
3409 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.short_channel_id;
3412 /// The short channel ID
3414 pub extern "C" fn UnsignedChannelUpdate_set_short_channel_id(this_ptr: &mut UnsignedChannelUpdate, mut val: u64) {
3415 unsafe { &mut *this_ptr.inner }.short_channel_id = val;
3417 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
3419 pub extern "C" fn UnsignedChannelUpdate_get_timestamp(this_ptr: &UnsignedChannelUpdate) -> u32 {
3420 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.timestamp;
3423 /// A strictly monotonic announcement counter, with gaps allowed, specific to this channel
3425 pub extern "C" fn UnsignedChannelUpdate_set_timestamp(this_ptr: &mut UnsignedChannelUpdate, mut val: u32) {
3426 unsafe { &mut *this_ptr.inner }.timestamp = val;
3430 pub extern "C" fn UnsignedChannelUpdate_get_flags(this_ptr: &UnsignedChannelUpdate) -> u8 {
3431 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.flags;
3436 pub extern "C" fn UnsignedChannelUpdate_set_flags(this_ptr: &mut UnsignedChannelUpdate, mut val: u8) {
3437 unsafe { &mut *this_ptr.inner }.flags = val;
3439 /// The number of blocks such that if:
3440 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
3441 /// then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
3442 /// the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
3443 /// cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
3444 /// then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
3445 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
3446 /// constructing the route.
3448 pub extern "C" fn UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: &UnsignedChannelUpdate) -> u16 {
3449 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.cltv_expiry_delta;
3452 /// The number of blocks such that if:
3453 /// `incoming_htlc.cltv_expiry < outgoing_htlc.cltv_expiry + cltv_expiry_delta`
3454 /// then we need to fail the HTLC backwards. When forwarding an HTLC, cltv_expiry_delta determines
3455 /// the outgoing HTLC's minimum cltv_expiry value -- so, if an incoming HTLC comes in with a
3456 /// cltv_expiry of 100000, and the node we're forwarding to has a cltv_expiry_delta value of 10,
3457 /// then we'll check that the outgoing HTLC's cltv_expiry value is at least 100010 before
3458 /// forwarding. Note that the HTLC sender is the one who originally sets this value when
3459 /// constructing the route.
3461 pub extern "C" fn UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: &mut UnsignedChannelUpdate, mut val: u16) {
3462 unsafe { &mut *this_ptr.inner }.cltv_expiry_delta = val;
3464 /// The minimum HTLC size incoming to sender, in milli-satoshi
3466 pub extern "C" fn UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: &UnsignedChannelUpdate) -> u64 {
3467 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.htlc_minimum_msat;
3470 /// The minimum HTLC size incoming to sender, in milli-satoshi
3472 pub extern "C" fn UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: &mut UnsignedChannelUpdate, mut val: u64) {
3473 unsafe { &mut *this_ptr.inner }.htlc_minimum_msat = val;
3475 /// The base HTLC fee charged by sender, in milli-satoshi
3477 pub extern "C" fn UnsignedChannelUpdate_get_fee_base_msat(this_ptr: &UnsignedChannelUpdate) -> u32 {
3478 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_base_msat;
3481 /// The base HTLC fee charged by sender, in milli-satoshi
3483 pub extern "C" fn UnsignedChannelUpdate_set_fee_base_msat(this_ptr: &mut UnsignedChannelUpdate, mut val: u32) {
3484 unsafe { &mut *this_ptr.inner }.fee_base_msat = val;
3486 /// The amount to fee multiplier, in micro-satoshi
3488 pub extern "C" fn UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: &UnsignedChannelUpdate) -> u32 {
3489 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.fee_proportional_millionths;
3492 /// The amount to fee multiplier, in micro-satoshi
3494 pub extern "C" fn UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: &mut UnsignedChannelUpdate, mut val: u32) {
3495 unsafe { &mut *this_ptr.inner }.fee_proportional_millionths = val;
3497 impl Clone for UnsignedChannelUpdate {
3498 fn clone(&self) -> Self {
3500 inner: if <*mut nativeUnsignedChannelUpdate>::is_null(self.inner) { std::ptr::null_mut() } else {
3501 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
3507 /// Used only if an object of this type is returned as a trait impl by a method
3508 pub(crate) extern "C" fn UnsignedChannelUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void {
3509 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedChannelUpdate)).clone() })) as *mut c_void
3512 /// Creates a copy of the UnsignedChannelUpdate
3513 pub extern "C" fn UnsignedChannelUpdate_clone(orig: &UnsignedChannelUpdate) -> UnsignedChannelUpdate {
3517 use lightning::ln::msgs::ChannelUpdate as nativeChannelUpdateImport;
3518 type nativeChannelUpdate = nativeChannelUpdateImport;
3520 /// A channel_update message to be sent or received from a peer
3523 pub struct ChannelUpdate {
3524 /// A pointer to the opaque Rust object.
3526 /// Nearly everywhere, inner must be non-null, however in places where
3527 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3528 pub inner: *mut nativeChannelUpdate,
3529 /// Indicates that this is the only struct which contains the same pointer.
3531 /// Rust functions which take ownership of an object provided via an argument require
3532 /// this to be true and invalidate the object pointed to by inner.
3536 impl Drop for ChannelUpdate {
3537 fn drop(&mut self) {
3538 if self.is_owned && !<*mut nativeChannelUpdate>::is_null(self.inner) {
3539 let _ = unsafe { Box::from_raw(self.inner) };
3543 /// Frees any resources used by the ChannelUpdate, if is_owned is set and inner is non-NULL.
3545 pub extern "C" fn ChannelUpdate_free(this_obj: ChannelUpdate) { }
3547 /// Used only if an object of this type is returned as a trait impl by a method
3548 extern "C" fn ChannelUpdate_free_void(this_ptr: *mut c_void) {
3549 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelUpdate); }
3552 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3553 impl ChannelUpdate {
3554 pub(crate) fn take_inner(mut self) -> *mut nativeChannelUpdate {
3555 assert!(self.is_owned);
3556 let ret = self.inner;
3557 self.inner = std::ptr::null_mut();
3561 /// A signature of the channel update
3563 pub extern "C" fn ChannelUpdate_get_signature(this_ptr: &ChannelUpdate) -> crate::c_types::Signature {
3564 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.signature;
3565 crate::c_types::Signature::from_rust(&inner_val)
3567 /// A signature of the channel update
3569 pub extern "C" fn ChannelUpdate_set_signature(this_ptr: &mut ChannelUpdate, mut val: crate::c_types::Signature) {
3570 unsafe { &mut *this_ptr.inner }.signature = val.into_rust();
3572 /// The actual channel update
3574 pub extern "C" fn ChannelUpdate_get_contents(this_ptr: &ChannelUpdate) -> crate::lightning::ln::msgs::UnsignedChannelUpdate {
3575 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.contents;
3576 crate::lightning::ln::msgs::UnsignedChannelUpdate { inner: unsafe { ( (&(*inner_val) as *const _) as *mut _) }, is_owned: false }
3578 /// The actual channel update
3580 pub extern "C" fn ChannelUpdate_set_contents(this_ptr: &mut ChannelUpdate, mut val: crate::lightning::ln::msgs::UnsignedChannelUpdate) {
3581 unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_inner()) };
3583 /// Constructs a new ChannelUpdate given each field
3586 pub extern "C" fn ChannelUpdate_new(mut signature_arg: crate::c_types::Signature, mut contents_arg: crate::lightning::ln::msgs::UnsignedChannelUpdate) -> ChannelUpdate {
3587 ChannelUpdate { inner: Box::into_raw(Box::new(nativeChannelUpdate {
3588 signature: signature_arg.into_rust(),
3589 contents: *unsafe { Box::from_raw(contents_arg.take_inner()) },
3590 })), is_owned: true }
3592 impl Clone for ChannelUpdate {
3593 fn clone(&self) -> Self {
3595 inner: if <*mut nativeChannelUpdate>::is_null(self.inner) { std::ptr::null_mut() } else {
3596 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
3602 /// Used only if an object of this type is returned as a trait impl by a method
3603 pub(crate) extern "C" fn ChannelUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void {
3604 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelUpdate)).clone() })) as *mut c_void
3607 /// Creates a copy of the ChannelUpdate
3608 pub extern "C" fn ChannelUpdate_clone(orig: &ChannelUpdate) -> ChannelUpdate {
3612 use lightning::ln::msgs::QueryChannelRange as nativeQueryChannelRangeImport;
3613 type nativeQueryChannelRange = nativeQueryChannelRangeImport;
3615 /// A query_channel_range message is used to query a peer for channel
3616 /// UTXOs in a range of blocks. The recipient of a query makes a best
3617 /// effort to reply to the query using one or more reply_channel_range
3621 pub struct QueryChannelRange {
3622 /// A pointer to the opaque Rust object.
3624 /// Nearly everywhere, inner must be non-null, however in places where
3625 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3626 pub inner: *mut nativeQueryChannelRange,
3627 /// Indicates that this is the only struct which contains the same pointer.
3629 /// Rust functions which take ownership of an object provided via an argument require
3630 /// this to be true and invalidate the object pointed to by inner.
3634 impl Drop for QueryChannelRange {
3635 fn drop(&mut self) {
3636 if self.is_owned && !<*mut nativeQueryChannelRange>::is_null(self.inner) {
3637 let _ = unsafe { Box::from_raw(self.inner) };
3641 /// Frees any resources used by the QueryChannelRange, if is_owned is set and inner is non-NULL.
3643 pub extern "C" fn QueryChannelRange_free(this_obj: QueryChannelRange) { }
3645 /// Used only if an object of this type is returned as a trait impl by a method
3646 extern "C" fn QueryChannelRange_free_void(this_ptr: *mut c_void) {
3647 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeQueryChannelRange); }
3650 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3651 impl QueryChannelRange {
3652 pub(crate) fn take_inner(mut self) -> *mut nativeQueryChannelRange {
3653 assert!(self.is_owned);
3654 let ret = self.inner;
3655 self.inner = std::ptr::null_mut();
3659 /// The genesis hash of the blockchain being queried
3661 pub extern "C" fn QueryChannelRange_get_chain_hash(this_ptr: &QueryChannelRange) -> *const [u8; 32] {
3662 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash;
3663 inner_val.as_inner()
3665 /// The genesis hash of the blockchain being queried
3667 pub extern "C" fn QueryChannelRange_set_chain_hash(this_ptr: &mut QueryChannelRange, mut val: crate::c_types::ThirtyTwoBytes) {
3668 unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
3670 /// The height of the first block for the channel UTXOs being queried
3672 pub extern "C" fn QueryChannelRange_get_first_blocknum(this_ptr: &QueryChannelRange) -> u32 {
3673 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.first_blocknum;
3676 /// The height of the first block for the channel UTXOs being queried
3678 pub extern "C" fn QueryChannelRange_set_first_blocknum(this_ptr: &mut QueryChannelRange, mut val: u32) {
3679 unsafe { &mut *this_ptr.inner }.first_blocknum = val;
3681 /// The number of blocks to include in the query results
3683 pub extern "C" fn QueryChannelRange_get_number_of_blocks(this_ptr: &QueryChannelRange) -> u32 {
3684 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.number_of_blocks;
3687 /// The number of blocks to include in the query results
3689 pub extern "C" fn QueryChannelRange_set_number_of_blocks(this_ptr: &mut QueryChannelRange, mut val: u32) {
3690 unsafe { &mut *this_ptr.inner }.number_of_blocks = val;
3692 /// Constructs a new QueryChannelRange given each field
3695 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 {
3696 QueryChannelRange { inner: Box::into_raw(Box::new(nativeQueryChannelRange {
3697 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
3698 first_blocknum: first_blocknum_arg,
3699 number_of_blocks: number_of_blocks_arg,
3700 })), is_owned: true }
3702 impl Clone for QueryChannelRange {
3703 fn clone(&self) -> Self {
3705 inner: if <*mut nativeQueryChannelRange>::is_null(self.inner) { std::ptr::null_mut() } else {
3706 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
3712 /// Used only if an object of this type is returned as a trait impl by a method
3713 pub(crate) extern "C" fn QueryChannelRange_clone_void(this_ptr: *const c_void) -> *mut c_void {
3714 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeQueryChannelRange)).clone() })) as *mut c_void
3717 /// Creates a copy of the QueryChannelRange
3718 pub extern "C" fn QueryChannelRange_clone(orig: &QueryChannelRange) -> QueryChannelRange {
3722 use lightning::ln::msgs::ReplyChannelRange as nativeReplyChannelRangeImport;
3723 type nativeReplyChannelRange = nativeReplyChannelRangeImport;
3725 /// A reply_channel_range message is a reply to a query_channel_range
3726 /// message. Multiple reply_channel_range messages can be sent in reply
3727 /// to a single query_channel_range message. The query recipient makes a
3728 /// best effort to respond based on their local network view which may
3729 /// not be a perfect view of the network. The short_channel_ids in the
3730 /// reply are encoded. We only support encoding_type=0 uncompressed
3731 /// serialization and do not support encoding_type=1 zlib serialization.
3734 pub struct ReplyChannelRange {
3735 /// A pointer to the opaque Rust object.
3737 /// Nearly everywhere, inner must be non-null, however in places where
3738 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3739 pub inner: *mut nativeReplyChannelRange,
3740 /// Indicates that this is the only struct which contains the same pointer.
3742 /// Rust functions which take ownership of an object provided via an argument require
3743 /// this to be true and invalidate the object pointed to by inner.
3747 impl Drop for ReplyChannelRange {
3748 fn drop(&mut self) {
3749 if self.is_owned && !<*mut nativeReplyChannelRange>::is_null(self.inner) {
3750 let _ = unsafe { Box::from_raw(self.inner) };
3754 /// Frees any resources used by the ReplyChannelRange, if is_owned is set and inner is non-NULL.
3756 pub extern "C" fn ReplyChannelRange_free(this_obj: ReplyChannelRange) { }
3758 /// Used only if an object of this type is returned as a trait impl by a method
3759 extern "C" fn ReplyChannelRange_free_void(this_ptr: *mut c_void) {
3760 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeReplyChannelRange); }
3763 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3764 impl ReplyChannelRange {
3765 pub(crate) fn take_inner(mut self) -> *mut nativeReplyChannelRange {
3766 assert!(self.is_owned);
3767 let ret = self.inner;
3768 self.inner = std::ptr::null_mut();
3772 /// The genesis hash of the blockchain being queried
3774 pub extern "C" fn ReplyChannelRange_get_chain_hash(this_ptr: &ReplyChannelRange) -> *const [u8; 32] {
3775 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash;
3776 inner_val.as_inner()
3778 /// The genesis hash of the blockchain being queried
3780 pub extern "C" fn ReplyChannelRange_set_chain_hash(this_ptr: &mut ReplyChannelRange, mut val: crate::c_types::ThirtyTwoBytes) {
3781 unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
3783 /// The height of the first block in the range of the reply
3785 pub extern "C" fn ReplyChannelRange_get_first_blocknum(this_ptr: &ReplyChannelRange) -> u32 {
3786 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.first_blocknum;
3789 /// The height of the first block in the range of the reply
3791 pub extern "C" fn ReplyChannelRange_set_first_blocknum(this_ptr: &mut ReplyChannelRange, mut val: u32) {
3792 unsafe { &mut *this_ptr.inner }.first_blocknum = val;
3794 /// The number of blocks included in the range of the reply
3796 pub extern "C" fn ReplyChannelRange_get_number_of_blocks(this_ptr: &ReplyChannelRange) -> u32 {
3797 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.number_of_blocks;
3800 /// The number of blocks included in the range of the reply
3802 pub extern "C" fn ReplyChannelRange_set_number_of_blocks(this_ptr: &mut ReplyChannelRange, mut val: u32) {
3803 unsafe { &mut *this_ptr.inner }.number_of_blocks = val;
3805 /// True when this is the final reply for a query
3807 pub extern "C" fn ReplyChannelRange_get_sync_complete(this_ptr: &ReplyChannelRange) -> bool {
3808 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.sync_complete;
3811 /// True when this is the final reply for a query
3813 pub extern "C" fn ReplyChannelRange_set_sync_complete(this_ptr: &mut ReplyChannelRange, mut val: bool) {
3814 unsafe { &mut *this_ptr.inner }.sync_complete = val;
3816 /// The short_channel_ids in the channel range
3818 pub extern "C" fn ReplyChannelRange_set_short_channel_ids(this_ptr: &mut ReplyChannelRange, mut val: crate::c_types::derived::CVec_u64Z) {
3819 let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); };
3820 unsafe { &mut *this_ptr.inner }.short_channel_ids = local_val;
3822 /// Constructs a new ReplyChannelRange given each field
3825 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 {
3826 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 }); };
3827 ReplyChannelRange { inner: Box::into_raw(Box::new(nativeReplyChannelRange {
3828 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
3829 first_blocknum: first_blocknum_arg,
3830 number_of_blocks: number_of_blocks_arg,
3831 sync_complete: sync_complete_arg,
3832 short_channel_ids: local_short_channel_ids_arg,
3833 })), is_owned: true }
3835 impl Clone for ReplyChannelRange {
3836 fn clone(&self) -> Self {
3838 inner: if <*mut nativeReplyChannelRange>::is_null(self.inner) { std::ptr::null_mut() } else {
3839 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
3845 /// Used only if an object of this type is returned as a trait impl by a method
3846 pub(crate) extern "C" fn ReplyChannelRange_clone_void(this_ptr: *const c_void) -> *mut c_void {
3847 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeReplyChannelRange)).clone() })) as *mut c_void
3850 /// Creates a copy of the ReplyChannelRange
3851 pub extern "C" fn ReplyChannelRange_clone(orig: &ReplyChannelRange) -> ReplyChannelRange {
3855 use lightning::ln::msgs::QueryShortChannelIds as nativeQueryShortChannelIdsImport;
3856 type nativeQueryShortChannelIds = nativeQueryShortChannelIdsImport;
3858 /// A query_short_channel_ids message is used to query a peer for
3859 /// routing gossip messages related to one or more short_channel_ids.
3860 /// The query recipient will reply with the latest, if available,
3861 /// channel_announcement, channel_update and node_announcement messages
3862 /// it maintains for the requested short_channel_ids followed by a
3863 /// reply_short_channel_ids_end message. The short_channel_ids sent in
3864 /// this query are encoded. We only support encoding_type=0 uncompressed
3865 /// serialization and do not support encoding_type=1 zlib serialization.
3868 pub struct QueryShortChannelIds {
3869 /// A pointer to the opaque Rust object.
3871 /// Nearly everywhere, inner must be non-null, however in places where
3872 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3873 pub inner: *mut nativeQueryShortChannelIds,
3874 /// Indicates that this is the only struct which contains the same pointer.
3876 /// Rust functions which take ownership of an object provided via an argument require
3877 /// this to be true and invalidate the object pointed to by inner.
3881 impl Drop for QueryShortChannelIds {
3882 fn drop(&mut self) {
3883 if self.is_owned && !<*mut nativeQueryShortChannelIds>::is_null(self.inner) {
3884 let _ = unsafe { Box::from_raw(self.inner) };
3888 /// Frees any resources used by the QueryShortChannelIds, if is_owned is set and inner is non-NULL.
3890 pub extern "C" fn QueryShortChannelIds_free(this_obj: QueryShortChannelIds) { }
3892 /// Used only if an object of this type is returned as a trait impl by a method
3893 extern "C" fn QueryShortChannelIds_free_void(this_ptr: *mut c_void) {
3894 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeQueryShortChannelIds); }
3897 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3898 impl QueryShortChannelIds {
3899 pub(crate) fn take_inner(mut self) -> *mut nativeQueryShortChannelIds {
3900 assert!(self.is_owned);
3901 let ret = self.inner;
3902 self.inner = std::ptr::null_mut();
3906 /// The genesis hash of the blockchain being queried
3908 pub extern "C" fn QueryShortChannelIds_get_chain_hash(this_ptr: &QueryShortChannelIds) -> *const [u8; 32] {
3909 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash;
3910 inner_val.as_inner()
3912 /// The genesis hash of the blockchain being queried
3914 pub extern "C" fn QueryShortChannelIds_set_chain_hash(this_ptr: &mut QueryShortChannelIds, mut val: crate::c_types::ThirtyTwoBytes) {
3915 unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
3917 /// The short_channel_ids that are being queried
3919 pub extern "C" fn QueryShortChannelIds_set_short_channel_ids(this_ptr: &mut QueryShortChannelIds, mut val: crate::c_types::derived::CVec_u64Z) {
3920 let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { item }); };
3921 unsafe { &mut *this_ptr.inner }.short_channel_ids = local_val;
3923 /// Constructs a new QueryShortChannelIds given each field
3926 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 {
3927 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 }); };
3928 QueryShortChannelIds { inner: Box::into_raw(Box::new(nativeQueryShortChannelIds {
3929 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
3930 short_channel_ids: local_short_channel_ids_arg,
3931 })), is_owned: true }
3933 impl Clone for QueryShortChannelIds {
3934 fn clone(&self) -> Self {
3936 inner: if <*mut nativeQueryShortChannelIds>::is_null(self.inner) { std::ptr::null_mut() } else {
3937 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
3943 /// Used only if an object of this type is returned as a trait impl by a method
3944 pub(crate) extern "C" fn QueryShortChannelIds_clone_void(this_ptr: *const c_void) -> *mut c_void {
3945 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeQueryShortChannelIds)).clone() })) as *mut c_void
3948 /// Creates a copy of the QueryShortChannelIds
3949 pub extern "C" fn QueryShortChannelIds_clone(orig: &QueryShortChannelIds) -> QueryShortChannelIds {
3953 use lightning::ln::msgs::ReplyShortChannelIdsEnd as nativeReplyShortChannelIdsEndImport;
3954 type nativeReplyShortChannelIdsEnd = nativeReplyShortChannelIdsEndImport;
3956 /// A reply_short_channel_ids_end message is sent as a reply to a
3957 /// query_short_channel_ids message. The query recipient makes a best
3958 /// effort to respond based on their local network view which may not be
3959 /// a perfect view of the network.
3962 pub struct ReplyShortChannelIdsEnd {
3963 /// A pointer to the opaque Rust object.
3965 /// Nearly everywhere, inner must be non-null, however in places where
3966 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
3967 pub inner: *mut nativeReplyShortChannelIdsEnd,
3968 /// Indicates that this is the only struct which contains the same pointer.
3970 /// Rust functions which take ownership of an object provided via an argument require
3971 /// this to be true and invalidate the object pointed to by inner.
3975 impl Drop for ReplyShortChannelIdsEnd {
3976 fn drop(&mut self) {
3977 if self.is_owned && !<*mut nativeReplyShortChannelIdsEnd>::is_null(self.inner) {
3978 let _ = unsafe { Box::from_raw(self.inner) };
3982 /// Frees any resources used by the ReplyShortChannelIdsEnd, if is_owned is set and inner is non-NULL.
3984 pub extern "C" fn ReplyShortChannelIdsEnd_free(this_obj: ReplyShortChannelIdsEnd) { }
3986 /// Used only if an object of this type is returned as a trait impl by a method
3987 extern "C" fn ReplyShortChannelIdsEnd_free_void(this_ptr: *mut c_void) {
3988 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeReplyShortChannelIdsEnd); }
3991 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
3992 impl ReplyShortChannelIdsEnd {
3993 pub(crate) fn take_inner(mut self) -> *mut nativeReplyShortChannelIdsEnd {
3994 assert!(self.is_owned);
3995 let ret = self.inner;
3996 self.inner = std::ptr::null_mut();
4000 /// The genesis hash of the blockchain that was queried
4002 pub extern "C" fn ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: &ReplyShortChannelIdsEnd) -> *const [u8; 32] {
4003 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash;
4004 inner_val.as_inner()
4006 /// The genesis hash of the blockchain that was queried
4008 pub extern "C" fn ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: &mut ReplyShortChannelIdsEnd, mut val: crate::c_types::ThirtyTwoBytes) {
4009 unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
4011 /// Indicates if the query recipient maintains up-to-date channel
4012 /// information for the chain_hash
4014 pub extern "C" fn ReplyShortChannelIdsEnd_get_full_information(this_ptr: &ReplyShortChannelIdsEnd) -> bool {
4015 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.full_information;
4018 /// Indicates if the query recipient maintains up-to-date channel
4019 /// information for the chain_hash
4021 pub extern "C" fn ReplyShortChannelIdsEnd_set_full_information(this_ptr: &mut ReplyShortChannelIdsEnd, mut val: bool) {
4022 unsafe { &mut *this_ptr.inner }.full_information = val;
4024 /// Constructs a new ReplyShortChannelIdsEnd given each field
4027 pub extern "C" fn ReplyShortChannelIdsEnd_new(mut chain_hash_arg: crate::c_types::ThirtyTwoBytes, mut full_information_arg: bool) -> ReplyShortChannelIdsEnd {
4028 ReplyShortChannelIdsEnd { inner: Box::into_raw(Box::new(nativeReplyShortChannelIdsEnd {
4029 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
4030 full_information: full_information_arg,
4031 })), is_owned: true }
4033 impl Clone for ReplyShortChannelIdsEnd {
4034 fn clone(&self) -> Self {
4036 inner: if <*mut nativeReplyShortChannelIdsEnd>::is_null(self.inner) { std::ptr::null_mut() } else {
4037 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
4043 /// Used only if an object of this type is returned as a trait impl by a method
4044 pub(crate) extern "C" fn ReplyShortChannelIdsEnd_clone_void(this_ptr: *const c_void) -> *mut c_void {
4045 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeReplyShortChannelIdsEnd)).clone() })) as *mut c_void
4048 /// Creates a copy of the ReplyShortChannelIdsEnd
4049 pub extern "C" fn ReplyShortChannelIdsEnd_clone(orig: &ReplyShortChannelIdsEnd) -> ReplyShortChannelIdsEnd {
4053 use lightning::ln::msgs::GossipTimestampFilter as nativeGossipTimestampFilterImport;
4054 type nativeGossipTimestampFilter = nativeGossipTimestampFilterImport;
4056 /// A gossip_timestamp_filter message is used by a node to request
4057 /// gossip relay for messages in the requested time range when the
4058 /// gossip_queries feature has been negotiated.
4061 pub struct GossipTimestampFilter {
4062 /// A pointer to the opaque Rust object.
4064 /// Nearly everywhere, inner must be non-null, however in places where
4065 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
4066 pub inner: *mut nativeGossipTimestampFilter,
4067 /// Indicates that this is the only struct which contains the same pointer.
4069 /// Rust functions which take ownership of an object provided via an argument require
4070 /// this to be true and invalidate the object pointed to by inner.
4074 impl Drop for GossipTimestampFilter {
4075 fn drop(&mut self) {
4076 if self.is_owned && !<*mut nativeGossipTimestampFilter>::is_null(self.inner) {
4077 let _ = unsafe { Box::from_raw(self.inner) };
4081 /// Frees any resources used by the GossipTimestampFilter, if is_owned is set and inner is non-NULL.
4083 pub extern "C" fn GossipTimestampFilter_free(this_obj: GossipTimestampFilter) { }
4085 /// Used only if an object of this type is returned as a trait impl by a method
4086 extern "C" fn GossipTimestampFilter_free_void(this_ptr: *mut c_void) {
4087 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeGossipTimestampFilter); }
4090 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4091 impl GossipTimestampFilter {
4092 pub(crate) fn take_inner(mut self) -> *mut nativeGossipTimestampFilter {
4093 assert!(self.is_owned);
4094 let ret = self.inner;
4095 self.inner = std::ptr::null_mut();
4099 /// The genesis hash of the blockchain for channel and node information
4101 pub extern "C" fn GossipTimestampFilter_get_chain_hash(this_ptr: &GossipTimestampFilter) -> *const [u8; 32] {
4102 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.chain_hash;
4103 inner_val.as_inner()
4105 /// The genesis hash of the blockchain for channel and node information
4107 pub extern "C" fn GossipTimestampFilter_set_chain_hash(this_ptr: &mut GossipTimestampFilter, mut val: crate::c_types::ThirtyTwoBytes) {
4108 unsafe { &mut *this_ptr.inner }.chain_hash = ::bitcoin::hash_types::BlockHash::from_slice(&val.data[..]).unwrap();
4110 /// The starting unix timestamp
4112 pub extern "C" fn GossipTimestampFilter_get_first_timestamp(this_ptr: &GossipTimestampFilter) -> u32 {
4113 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.first_timestamp;
4116 /// The starting unix timestamp
4118 pub extern "C" fn GossipTimestampFilter_set_first_timestamp(this_ptr: &mut GossipTimestampFilter, mut val: u32) {
4119 unsafe { &mut *this_ptr.inner }.first_timestamp = val;
4121 /// The range of information in seconds
4123 pub extern "C" fn GossipTimestampFilter_get_timestamp_range(this_ptr: &GossipTimestampFilter) -> u32 {
4124 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.timestamp_range;
4127 /// The range of information in seconds
4129 pub extern "C" fn GossipTimestampFilter_set_timestamp_range(this_ptr: &mut GossipTimestampFilter, mut val: u32) {
4130 unsafe { &mut *this_ptr.inner }.timestamp_range = val;
4132 /// Constructs a new GossipTimestampFilter given each field
4135 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 {
4136 GossipTimestampFilter { inner: Box::into_raw(Box::new(nativeGossipTimestampFilter {
4137 chain_hash: ::bitcoin::hash_types::BlockHash::from_slice(&chain_hash_arg.data[..]).unwrap(),
4138 first_timestamp: first_timestamp_arg,
4139 timestamp_range: timestamp_range_arg,
4140 })), is_owned: true }
4142 impl Clone for GossipTimestampFilter {
4143 fn clone(&self) -> Self {
4145 inner: if <*mut nativeGossipTimestampFilter>::is_null(self.inner) { std::ptr::null_mut() } else {
4146 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
4152 /// Used only if an object of this type is returned as a trait impl by a method
4153 pub(crate) extern "C" fn GossipTimestampFilter_clone_void(this_ptr: *const c_void) -> *mut c_void {
4154 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeGossipTimestampFilter)).clone() })) as *mut c_void
4157 /// Creates a copy of the GossipTimestampFilter
4158 pub extern "C" fn GossipTimestampFilter_clone(orig: &GossipTimestampFilter) -> GossipTimestampFilter {
4161 /// Used to put an error message in a LightningError
4165 pub enum ErrorAction {
4166 /// The peer took some action which made us think they were useless. Disconnect them.
4168 /// An error message which we should make an effort to send before we disconnect.
4170 /// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
4171 msg: crate::lightning::ln::msgs::ErrorMessage,
4173 /// The peer did something harmless that we weren't able to process, just log and ignore
4175 /// The peer did something harmless that we weren't able to meaningfully process.
4176 /// If the error is logged, log it at the given level.
4177 IgnoreAndLog(crate::lightning::util::logger::Level),
4178 /// The peer did something incorrect. Tell them.
4180 /// The message to send.
4181 msg: crate::lightning::ln::msgs::ErrorMessage,
4184 use lightning::ln::msgs::ErrorAction as nativeErrorAction;
4187 pub(crate) fn to_native(&self) -> nativeErrorAction {
4189 ErrorAction::DisconnectPeer {ref msg, } => {
4190 let mut msg_nonref = (*msg).clone();
4191 let mut local_msg_nonref = if msg_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg_nonref.take_inner()) } }) };
4192 nativeErrorAction::DisconnectPeer {
4193 msg: local_msg_nonref,
4196 ErrorAction::IgnoreError => nativeErrorAction::IgnoreError,
4197 ErrorAction::IgnoreAndLog (ref a, ) => {
4198 let mut a_nonref = (*a).clone();
4199 nativeErrorAction::IgnoreAndLog (
4200 a_nonref.into_native(),
4203 ErrorAction::SendErrorMessage {ref msg, } => {
4204 let mut msg_nonref = (*msg).clone();
4205 nativeErrorAction::SendErrorMessage {
4206 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
4212 pub(crate) fn into_native(self) -> nativeErrorAction {
4214 ErrorAction::DisconnectPeer {mut msg, } => {
4215 let mut local_msg = if msg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg.take_inner()) } }) };
4216 nativeErrorAction::DisconnectPeer {
4220 ErrorAction::IgnoreError => nativeErrorAction::IgnoreError,
4221 ErrorAction::IgnoreAndLog (mut a, ) => {
4222 nativeErrorAction::IgnoreAndLog (
4226 ErrorAction::SendErrorMessage {mut msg, } => {
4227 nativeErrorAction::SendErrorMessage {
4228 msg: *unsafe { Box::from_raw(msg.take_inner()) },
4234 pub(crate) fn from_native(native: &nativeErrorAction) -> Self {
4236 nativeErrorAction::DisconnectPeer {ref msg, } => {
4237 let mut msg_nonref = (*msg).clone();
4238 let mut local_msg_nonref = crate::lightning::ln::msgs::ErrorMessage { inner: if msg_nonref.is_none() { std::ptr::null_mut() } else { { Box::into_raw(Box::new((msg_nonref.unwrap()))) } }, is_owned: true };
4239 ErrorAction::DisconnectPeer {
4240 msg: local_msg_nonref,
4243 nativeErrorAction::IgnoreError => ErrorAction::IgnoreError,
4244 nativeErrorAction::IgnoreAndLog (ref a, ) => {
4245 let mut a_nonref = (*a).clone();
4246 ErrorAction::IgnoreAndLog (
4247 crate::lightning::util::logger::Level::native_into(a_nonref),
4250 nativeErrorAction::SendErrorMessage {ref msg, } => {
4251 let mut msg_nonref = (*msg).clone();
4252 ErrorAction::SendErrorMessage {
4253 msg: crate::lightning::ln::msgs::ErrorMessage { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
4259 pub(crate) fn native_into(native: nativeErrorAction) -> Self {
4261 nativeErrorAction::DisconnectPeer {mut msg, } => {
4262 let mut local_msg = crate::lightning::ln::msgs::ErrorMessage { inner: if msg.is_none() { std::ptr::null_mut() } else { { Box::into_raw(Box::new((msg.unwrap()))) } }, is_owned: true };
4263 ErrorAction::DisconnectPeer {
4267 nativeErrorAction::IgnoreError => ErrorAction::IgnoreError,
4268 nativeErrorAction::IgnoreAndLog (mut a, ) => {
4269 ErrorAction::IgnoreAndLog (
4270 crate::lightning::util::logger::Level::native_into(a),
4273 nativeErrorAction::SendErrorMessage {mut msg, } => {
4274 ErrorAction::SendErrorMessage {
4275 msg: crate::lightning::ln::msgs::ErrorMessage { inner: Box::into_raw(Box::new(msg)), is_owned: true },
4281 /// Frees any resources used by the ErrorAction
4283 pub extern "C" fn ErrorAction_free(this_ptr: ErrorAction) { }
4284 /// Creates a copy of the ErrorAction
4286 pub extern "C" fn ErrorAction_clone(orig: &ErrorAction) -> ErrorAction {
4290 /// Utility method to constructs a new DisconnectPeer-variant ErrorAction
4291 pub extern "C" fn ErrorAction_disconnect_peer(msg: crate::lightning::ln::msgs::ErrorMessage) -> ErrorAction {
4292 ErrorAction::DisconnectPeer {
4297 /// Utility method to constructs a new IgnoreError-variant ErrorAction
4298 pub extern "C" fn ErrorAction_ignore_error() -> ErrorAction {
4299 ErrorAction::IgnoreError}
4301 /// Utility method to constructs a new IgnoreAndLog-variant ErrorAction
4302 pub extern "C" fn ErrorAction_ignore_and_log(a: crate::lightning::util::logger::Level) -> ErrorAction {
4303 ErrorAction::IgnoreAndLog(a, )
4306 /// Utility method to constructs a new SendErrorMessage-variant ErrorAction
4307 pub extern "C" fn ErrorAction_send_error_message(msg: crate::lightning::ln::msgs::ErrorMessage) -> ErrorAction {
4308 ErrorAction::SendErrorMessage {
4313 use lightning::ln::msgs::LightningError as nativeLightningErrorImport;
4314 type nativeLightningError = nativeLightningErrorImport;
4316 /// An Err type for failure to process messages.
4319 pub struct LightningError {
4320 /// A pointer to the opaque Rust object.
4322 /// Nearly everywhere, inner must be non-null, however in places where
4323 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
4324 pub inner: *mut nativeLightningError,
4325 /// Indicates that this is the only struct which contains the same pointer.
4327 /// Rust functions which take ownership of an object provided via an argument require
4328 /// this to be true and invalidate the object pointed to by inner.
4332 impl Drop for LightningError {
4333 fn drop(&mut self) {
4334 if self.is_owned && !<*mut nativeLightningError>::is_null(self.inner) {
4335 let _ = unsafe { Box::from_raw(self.inner) };
4339 /// Frees any resources used by the LightningError, if is_owned is set and inner is non-NULL.
4341 pub extern "C" fn LightningError_free(this_obj: LightningError) { }
4343 /// Used only if an object of this type is returned as a trait impl by a method
4344 extern "C" fn LightningError_free_void(this_ptr: *mut c_void) {
4345 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeLightningError); }
4348 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4349 impl LightningError {
4350 pub(crate) fn take_inner(mut self) -> *mut nativeLightningError {
4351 assert!(self.is_owned);
4352 let ret = self.inner;
4353 self.inner = std::ptr::null_mut();
4357 /// A human-readable message describing the error
4359 pub extern "C" fn LightningError_get_err(this_ptr: &LightningError) -> crate::c_types::Str {
4360 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.err;
4361 inner_val.as_str().into()
4363 /// A human-readable message describing the error
4365 pub extern "C" fn LightningError_set_err(this_ptr: &mut LightningError, mut val: crate::c_types::Str) {
4366 unsafe { &mut *this_ptr.inner }.err = val.into_string();
4368 /// The action which should be taken against the offending peer.
4370 pub extern "C" fn LightningError_get_action(this_ptr: &LightningError) -> crate::lightning::ln::msgs::ErrorAction {
4371 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.action;
4372 crate::lightning::ln::msgs::ErrorAction::from_native(inner_val)
4374 /// The action which should be taken against the offending peer.
4376 pub extern "C" fn LightningError_set_action(this_ptr: &mut LightningError, mut val: crate::lightning::ln::msgs::ErrorAction) {
4377 unsafe { &mut *this_ptr.inner }.action = val.into_native();
4379 /// Constructs a new LightningError given each field
4382 pub extern "C" fn LightningError_new(mut err_arg: crate::c_types::Str, mut action_arg: crate::lightning::ln::msgs::ErrorAction) -> LightningError {
4383 LightningError { inner: Box::into_raw(Box::new(nativeLightningError {
4384 err: err_arg.into_string(),
4385 action: action_arg.into_native(),
4386 })), is_owned: true }
4388 impl Clone for LightningError {
4389 fn clone(&self) -> Self {
4391 inner: if <*mut nativeLightningError>::is_null(self.inner) { std::ptr::null_mut() } else {
4392 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
4398 /// Used only if an object of this type is returned as a trait impl by a method
4399 pub(crate) extern "C" fn LightningError_clone_void(this_ptr: *const c_void) -> *mut c_void {
4400 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeLightningError)).clone() })) as *mut c_void
4403 /// Creates a copy of the LightningError
4404 pub extern "C" fn LightningError_clone(orig: &LightningError) -> LightningError {
4408 use lightning::ln::msgs::CommitmentUpdate as nativeCommitmentUpdateImport;
4409 type nativeCommitmentUpdate = nativeCommitmentUpdateImport;
4411 /// Struct used to return values from revoke_and_ack messages, containing a bunch of commitment
4412 /// transaction updates if they were pending.
4415 pub struct CommitmentUpdate {
4416 /// A pointer to the opaque Rust object.
4418 /// Nearly everywhere, inner must be non-null, however in places where
4419 /// the Rust equivalent takes an Option, it may be set to null to indicate None.
4420 pub inner: *mut nativeCommitmentUpdate,
4421 /// Indicates that this is the only struct which contains the same pointer.
4423 /// Rust functions which take ownership of an object provided via an argument require
4424 /// this to be true and invalidate the object pointed to by inner.
4428 impl Drop for CommitmentUpdate {
4429 fn drop(&mut self) {
4430 if self.is_owned && !<*mut nativeCommitmentUpdate>::is_null(self.inner) {
4431 let _ = unsafe { Box::from_raw(self.inner) };
4435 /// Frees any resources used by the CommitmentUpdate, if is_owned is set and inner is non-NULL.
4437 pub extern "C" fn CommitmentUpdate_free(this_obj: CommitmentUpdate) { }
4439 /// Used only if an object of this type is returned as a trait impl by a method
4440 extern "C" fn CommitmentUpdate_free_void(this_ptr: *mut c_void) {
4441 unsafe { let _ = Box::from_raw(this_ptr as *mut nativeCommitmentUpdate); }
4444 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
4445 impl CommitmentUpdate {
4446 pub(crate) fn take_inner(mut self) -> *mut nativeCommitmentUpdate {
4447 assert!(self.is_owned);
4448 let ret = self.inner;
4449 self.inner = std::ptr::null_mut();
4453 /// update_add_htlc messages which should be sent
4455 pub extern "C" fn CommitmentUpdate_set_update_add_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateAddHTLCZ) {
4456 let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4457 unsafe { &mut *this_ptr.inner }.update_add_htlcs = local_val;
4459 /// update_fulfill_htlc messages which should be sent
4461 pub extern "C" fn CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFulfillHTLCZ) {
4462 let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4463 unsafe { &mut *this_ptr.inner }.update_fulfill_htlcs = local_val;
4465 /// update_fail_htlc messages which should be sent
4467 pub extern "C" fn CommitmentUpdate_set_update_fail_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFailHTLCZ) {
4468 let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4469 unsafe { &mut *this_ptr.inner }.update_fail_htlcs = local_val;
4471 /// update_fail_malformed_htlc messages which should be sent
4473 pub extern "C" fn CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFailMalformedHTLCZ) {
4474 let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
4475 unsafe { &mut *this_ptr.inner }.update_fail_malformed_htlcs = local_val;
4477 /// An update_fee message which should be sent
4479 /// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4481 pub extern "C" fn CommitmentUpdate_get_update_fee(this_ptr: &CommitmentUpdate) -> crate::lightning::ln::msgs::UpdateFee {
4482 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.update_fee;
4483 let mut local_inner_val = crate::lightning::ln::msgs::UpdateFee { inner: unsafe { (if inner_val.is_none() { std::ptr::null() } else { { (inner_val.as_ref().unwrap()) } } as *const _) as *mut _ }, is_owned: false };
4486 /// An update_fee message which should be sent
4488 /// Note that val (or a relevant inner pointer) may be NULL or all-0s to represent None
4490 pub extern "C" fn CommitmentUpdate_set_update_fee(this_ptr: &mut CommitmentUpdate, mut val: crate::lightning::ln::msgs::UpdateFee) {
4491 let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) };
4492 unsafe { &mut *this_ptr.inner }.update_fee = local_val;
4494 /// Finally, the commitment_signed message which should be sent
4496 pub extern "C" fn CommitmentUpdate_get_commitment_signed(this_ptr: &CommitmentUpdate) -> crate::lightning::ln::msgs::CommitmentSigned {
4497 let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.commitment_signed;
4498 crate::lightning::ln::msgs::CommitmentSigned { inner: unsafe { ( (&(*inner_val) as *const _) as *mut _) }, is_owned: false }
4500 /// Finally, the commitment_signed message which should be sent
4502 pub extern "C" fn CommitmentUpdate_set_commitment_signed(this_ptr: &mut CommitmentUpdate, mut val: crate::lightning::ln::msgs::CommitmentSigned) {
4503 unsafe { &mut *this_ptr.inner }.commitment_signed = *unsafe { Box::from_raw(val.take_inner()) };
4505 /// Constructs a new CommitmentUpdate given each field
4508 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 {
4509 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()) } }); };
4510 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()) } }); };
4511 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()) } }); };
4512 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()) } }); };
4513 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()) } }) };
4514 CommitmentUpdate { inner: Box::into_raw(Box::new(nativeCommitmentUpdate {
4515 update_add_htlcs: local_update_add_htlcs_arg,
4516 update_fulfill_htlcs: local_update_fulfill_htlcs_arg,
4517 update_fail_htlcs: local_update_fail_htlcs_arg,
4518 update_fail_malformed_htlcs: local_update_fail_malformed_htlcs_arg,
4519 update_fee: local_update_fee_arg,
4520 commitment_signed: *unsafe { Box::from_raw(commitment_signed_arg.take_inner()) },
4521 })), is_owned: true }
4523 impl Clone for CommitmentUpdate {
4524 fn clone(&self) -> Self {
4526 inner: if <*mut nativeCommitmentUpdate>::is_null(self.inner) { std::ptr::null_mut() } else {
4527 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
4533 /// Used only if an object of this type is returned as a trait impl by a method
4534 pub(crate) extern "C" fn CommitmentUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void {
4535 Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeCommitmentUpdate)).clone() })) as *mut c_void
4538 /// Creates a copy of the CommitmentUpdate
4539 pub extern "C" fn CommitmentUpdate_clone(orig: &CommitmentUpdate) -> CommitmentUpdate {
4542 /// The information we received from a peer along the route of a payment we originated. This is
4543 /// returned by ChannelMessageHandler::handle_update_fail_htlc to be passed into
4544 /// RoutingMessageHandler::handle_htlc_fail_channel_update to update our network map.
4548 pub enum HTLCFailChannelUpdate {
4549 /// We received an error which included a full ChannelUpdate message.
4550 ChannelUpdateMessage {
4551 /// The unwrapped message we received
4552 msg: crate::lightning::ln::msgs::ChannelUpdate,
4554 /// We received an error which indicated only that a channel has been closed
4556 /// The short_channel_id which has now closed.
4557 short_channel_id: u64,
4558 /// when this true, this channel should be permanently removed from the
4559 /// consideration. Otherwise, this channel can be restored as new channel_update is received
4562 /// We received an error which indicated only that a node has failed
4564 /// The node_id that has failed.
4565 node_id: crate::c_types::PublicKey,
4566 /// when this true, node should be permanently removed from the
4567 /// consideration. Otherwise, the channels connected to this node can be
4568 /// restored as new channel_update is received
4572 use lightning::ln::msgs::HTLCFailChannelUpdate as nativeHTLCFailChannelUpdate;
4573 impl HTLCFailChannelUpdate {
4575 pub(crate) fn to_native(&self) -> nativeHTLCFailChannelUpdate {
4577 HTLCFailChannelUpdate::ChannelUpdateMessage {ref msg, } => {
4578 let mut msg_nonref = (*msg).clone();
4579 nativeHTLCFailChannelUpdate::ChannelUpdateMessage {
4580 msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) },
4583 HTLCFailChannelUpdate::ChannelClosed {ref short_channel_id, ref is_permanent, } => {
4584 let mut short_channel_id_nonref = (*short_channel_id).clone();
4585 let mut is_permanent_nonref = (*is_permanent).clone();
4586 nativeHTLCFailChannelUpdate::ChannelClosed {
4587 short_channel_id: short_channel_id_nonref,
4588 is_permanent: is_permanent_nonref,
4591 HTLCFailChannelUpdate::NodeFailure {ref node_id, ref is_permanent, } => {
4592 let mut node_id_nonref = (*node_id).clone();
4593 let mut is_permanent_nonref = (*is_permanent).clone();
4594 nativeHTLCFailChannelUpdate::NodeFailure {
4595 node_id: node_id_nonref.into_rust(),
4596 is_permanent: is_permanent_nonref,
4602 pub(crate) fn into_native(self) -> nativeHTLCFailChannelUpdate {
4604 HTLCFailChannelUpdate::ChannelUpdateMessage {mut msg, } => {
4605 nativeHTLCFailChannelUpdate::ChannelUpdateMessage {
4606 msg: *unsafe { Box::from_raw(msg.take_inner()) },
4609 HTLCFailChannelUpdate::ChannelClosed {mut short_channel_id, mut is_permanent, } => {
4610 nativeHTLCFailChannelUpdate::ChannelClosed {
4611 short_channel_id: short_channel_id,
4612 is_permanent: is_permanent,
4615 HTLCFailChannelUpdate::NodeFailure {mut node_id, mut is_permanent, } => {
4616 nativeHTLCFailChannelUpdate::NodeFailure {
4617 node_id: node_id.into_rust(),
4618 is_permanent: is_permanent,
4624 pub(crate) fn from_native(native: &nativeHTLCFailChannelUpdate) -> Self {
4626 nativeHTLCFailChannelUpdate::ChannelUpdateMessage {ref msg, } => {
4627 let mut msg_nonref = (*msg).clone();
4628 HTLCFailChannelUpdate::ChannelUpdateMessage {
4629 msg: crate::lightning::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
4632 nativeHTLCFailChannelUpdate::ChannelClosed {ref short_channel_id, ref is_permanent, } => {
4633 let mut short_channel_id_nonref = (*short_channel_id).clone();
4634 let mut is_permanent_nonref = (*is_permanent).clone();
4635 HTLCFailChannelUpdate::ChannelClosed {
4636 short_channel_id: short_channel_id_nonref,
4637 is_permanent: is_permanent_nonref,
4640 nativeHTLCFailChannelUpdate::NodeFailure {ref node_id, ref is_permanent, } => {
4641 let mut node_id_nonref = (*node_id).clone();
4642 let mut is_permanent_nonref = (*is_permanent).clone();
4643 HTLCFailChannelUpdate::NodeFailure {
4644 node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
4645 is_permanent: is_permanent_nonref,
4651 pub(crate) fn native_into(native: nativeHTLCFailChannelUpdate) -> Self {
4653 nativeHTLCFailChannelUpdate::ChannelUpdateMessage {mut msg, } => {
4654 HTLCFailChannelUpdate::ChannelUpdateMessage {
4655 msg: crate::lightning::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg)), is_owned: true },
4658 nativeHTLCFailChannelUpdate::ChannelClosed {mut short_channel_id, mut is_permanent, } => {
4659 HTLCFailChannelUpdate::ChannelClosed {
4660 short_channel_id: short_channel_id,
4661 is_permanent: is_permanent,
4664 nativeHTLCFailChannelUpdate::NodeFailure {mut node_id, mut is_permanent, } => {
4665 HTLCFailChannelUpdate::NodeFailure {
4666 node_id: crate::c_types::PublicKey::from_rust(&node_id),
4667 is_permanent: is_permanent,
4673 /// Frees any resources used by the HTLCFailChannelUpdate
4675 pub extern "C" fn HTLCFailChannelUpdate_free(this_ptr: HTLCFailChannelUpdate) { }
4676 /// Creates a copy of the HTLCFailChannelUpdate
4678 pub extern "C" fn HTLCFailChannelUpdate_clone(orig: &HTLCFailChannelUpdate) -> HTLCFailChannelUpdate {
4682 /// Utility method to constructs a new ChannelUpdateMessage-variant HTLCFailChannelUpdate
4683 pub extern "C" fn HTLCFailChannelUpdate_channel_update_message(msg: crate::lightning::ln::msgs::ChannelUpdate) -> HTLCFailChannelUpdate {
4684 HTLCFailChannelUpdate::ChannelUpdateMessage {
4689 /// Utility method to constructs a new ChannelClosed-variant HTLCFailChannelUpdate
4690 pub extern "C" fn HTLCFailChannelUpdate_channel_closed(short_channel_id: u64, is_permanent: bool) -> HTLCFailChannelUpdate {
4691 HTLCFailChannelUpdate::ChannelClosed {
4697 /// Utility method to constructs a new NodeFailure-variant HTLCFailChannelUpdate
4698 pub extern "C" fn HTLCFailChannelUpdate_node_failure(node_id: crate::c_types::PublicKey, is_permanent: bool) -> HTLCFailChannelUpdate {
4699 HTLCFailChannelUpdate::NodeFailure {
4704 /// A trait to describe an object which can receive channel messages.
4706 /// Messages MAY be called in parallel when they originate from different their_node_ids, however
4707 /// they MUST NOT be called in parallel when the two calls have the same their_node_id.
4709 pub struct ChannelMessageHandler {
4710 /// An opaque pointer which is passed to your function implementations as an argument.
4711 /// This has no meaning in the LDK, and can be NULL or any other value.
4712 pub this_arg: *mut c_void,
4713 /// Handle an incoming open_channel message from the given peer.
4714 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),
4715 /// Handle an incoming accept_channel message from the given peer.
4716 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),
4717 /// Handle an incoming funding_created message from the given peer.
4718 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),
4719 /// Handle an incoming funding_signed message from the given peer.
4720 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),
4721 /// Handle an incoming funding_locked message from the given peer.
4722 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),
4723 /// Handle an incoming shutdown message from the given peer.
4724 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),
4725 /// Handle an incoming closing_signed message from the given peer.
4726 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),
4727 /// Handle an incoming update_add_htlc message from the given peer.
4728 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),
4729 /// Handle an incoming update_fulfill_htlc message from the given peer.
4730 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),
4731 /// Handle an incoming update_fail_htlc message from the given peer.
4732 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),
4733 /// Handle an incoming update_fail_malformed_htlc message from the given peer.
4734 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),
4735 /// Handle an incoming commitment_signed message from the given peer.
4736 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),
4737 /// Handle an incoming revoke_and_ack message from the given peer.
4738 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),
4739 /// Handle an incoming update_fee message from the given peer.
4740 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),
4741 /// Handle an incoming announcement_signatures message from the given peer.
4742 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),
4743 /// Indicates a connection to the peer failed/an existing connection was lost. If no connection
4744 /// is believed to be possible in the future (eg they're sending us messages we don't
4745 /// understand or indicate they require unknown feature bits), no_connection_possible is set
4746 /// and any outstanding channels should be failed.
4747 pub peer_disconnected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, no_connection_possible: bool),
4748 /// Handle a peer reconnecting, possibly generating channel_reestablish message(s).
4749 pub peer_connected: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::Init),
4750 /// Handle an incoming channel_reestablish message from the given peer.
4751 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),
4752 /// Handle an incoming channel update from the given peer.
4753 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),
4754 /// Handle an incoming error message from the given peer.
4755 pub handle_error: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: &crate::lightning::ln::msgs::ErrorMessage),
4756 /// Implementation of MessageSendEventsProvider for this object.
4757 pub MessageSendEventsProvider: crate::lightning::util::events::MessageSendEventsProvider,
4758 /// Frees any resources associated with this object given its this_arg pointer.
4759 /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4760 pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
4762 unsafe impl Send for ChannelMessageHandler {}
4763 unsafe impl Sync for ChannelMessageHandler {}
4765 pub(crate) extern "C" fn ChannelMessageHandler_clone_fields(orig: &ChannelMessageHandler) -> ChannelMessageHandler {
4766 ChannelMessageHandler {
4767 this_arg: orig.this_arg,
4768 handle_open_channel: Clone::clone(&orig.handle_open_channel),
4769 handle_accept_channel: Clone::clone(&orig.handle_accept_channel),
4770 handle_funding_created: Clone::clone(&orig.handle_funding_created),
4771 handle_funding_signed: Clone::clone(&orig.handle_funding_signed),
4772 handle_funding_locked: Clone::clone(&orig.handle_funding_locked),
4773 handle_shutdown: Clone::clone(&orig.handle_shutdown),
4774 handle_closing_signed: Clone::clone(&orig.handle_closing_signed),
4775 handle_update_add_htlc: Clone::clone(&orig.handle_update_add_htlc),
4776 handle_update_fulfill_htlc: Clone::clone(&orig.handle_update_fulfill_htlc),
4777 handle_update_fail_htlc: Clone::clone(&orig.handle_update_fail_htlc),
4778 handle_update_fail_malformed_htlc: Clone::clone(&orig.handle_update_fail_malformed_htlc),
4779 handle_commitment_signed: Clone::clone(&orig.handle_commitment_signed),
4780 handle_revoke_and_ack: Clone::clone(&orig.handle_revoke_and_ack),
4781 handle_update_fee: Clone::clone(&orig.handle_update_fee),
4782 handle_announcement_signatures: Clone::clone(&orig.handle_announcement_signatures),
4783 peer_disconnected: Clone::clone(&orig.peer_disconnected),
4784 peer_connected: Clone::clone(&orig.peer_connected),
4785 handle_channel_reestablish: Clone::clone(&orig.handle_channel_reestablish),
4786 handle_channel_update: Clone::clone(&orig.handle_channel_update),
4787 handle_error: Clone::clone(&orig.handle_error),
4788 MessageSendEventsProvider: crate::lightning::util::events::MessageSendEventsProvider_clone_fields(&orig.MessageSendEventsProvider),
4789 free: Clone::clone(&orig.free),
4792 impl lightning::util::events::MessageSendEventsProvider for ChannelMessageHandler {
4793 fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {
4794 let mut ret = (self.MessageSendEventsProvider.get_and_clear_pending_msg_events)(self.MessageSendEventsProvider.this_arg);
4795 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
4800 use lightning::ln::msgs::ChannelMessageHandler as rustChannelMessageHandler;
4801 impl rustChannelMessageHandler for ChannelMessageHandler {
4802 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) {
4803 (self.handle_open_channel)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::lightning::ln::features::InitFeatures { inner: Box::into_raw(Box::new(their_features)), is_owned: true }, &crate::lightning::ln::msgs::OpenChannel { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4805 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) {
4806 (self.handle_accept_channel)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::lightning::ln::features::InitFeatures { inner: Box::into_raw(Box::new(their_features)), is_owned: true }, &crate::lightning::ln::msgs::AcceptChannel { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4808 fn handle_funding_created(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::FundingCreated) {
4809 (self.handle_funding_created)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::FundingCreated { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4811 fn handle_funding_signed(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::FundingSigned) {
4812 (self.handle_funding_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::FundingSigned { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4814 fn handle_funding_locked(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::FundingLocked) {
4815 (self.handle_funding_locked)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::FundingLocked { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4817 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) {
4818 (self.handle_shutdown)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::features::InitFeatures { inner: unsafe { (their_features as *const _) as *mut _ }, is_owned: false }, &crate::lightning::ln::msgs::Shutdown { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4820 fn handle_closing_signed(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::ClosingSigned) {
4821 (self.handle_closing_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::ClosingSigned { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4823 fn handle_update_add_htlc(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateAddHTLC) {
4824 (self.handle_update_add_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::UpdateAddHTLC { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4826 fn handle_update_fulfill_htlc(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateFulfillHTLC) {
4827 (self.handle_update_fulfill_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::UpdateFulfillHTLC { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4829 fn handle_update_fail_htlc(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateFailHTLC) {
4830 (self.handle_update_fail_htlc)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::UpdateFailHTLC { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4832 fn handle_update_fail_malformed_htlc(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateFailMalformedHTLC) {
4833 (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 { (msg as *const _) as *mut _ }, is_owned: false })
4835 fn handle_commitment_signed(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::CommitmentSigned) {
4836 (self.handle_commitment_signed)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::CommitmentSigned { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4838 fn handle_revoke_and_ack(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::RevokeAndACK) {
4839 (self.handle_revoke_and_ack)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::RevokeAndACK { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4841 fn handle_update_fee(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::UpdateFee) {
4842 (self.handle_update_fee)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::UpdateFee { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4844 fn handle_announcement_signatures(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::AnnouncementSignatures) {
4845 (self.handle_announcement_signatures)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::AnnouncementSignatures { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4847 fn peer_disconnected(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut no_connection_possible: bool) {
4848 (self.peer_disconnected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), no_connection_possible)
4850 fn peer_connected(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::Init) {
4851 (self.peer_connected)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::Init { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4853 fn handle_channel_reestablish(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::ChannelReestablish) {
4854 (self.handle_channel_reestablish)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::ChannelReestablish { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4856 fn handle_channel_update(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::ChannelUpdate) {
4857 (self.handle_channel_update)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::ChannelUpdate { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4859 fn handle_error(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut msg: &lightning::ln::msgs::ErrorMessage) {
4860 (self.handle_error)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::ErrorMessage { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false })
4864 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
4865 // directly as a Deref trait in higher-level structs:
4866 impl std::ops::Deref for ChannelMessageHandler {
4868 fn deref(&self) -> &Self {
4872 /// Calls the free function if one is set
4874 pub extern "C" fn ChannelMessageHandler_free(this_ptr: ChannelMessageHandler) { }
4875 impl Drop for ChannelMessageHandler {
4876 fn drop(&mut self) {
4877 if let Some(f) = self.free {
4882 /// A trait to describe an object which can receive routing messages.
4884 /// # Implementor DoS Warnings
4886 /// For `gossip_queries` messages there are potential DoS vectors when handling
4887 /// inbound queries. Implementors using an on-disk network graph should be aware of
4888 /// repeated disk I/O for queries accessing different parts of the network graph.
4890 pub struct RoutingMessageHandler {
4891 /// An opaque pointer which is passed to your function implementations as an argument.
4892 /// This has no meaning in the LDK, and can be NULL or any other value.
4893 pub this_arg: *mut c_void,
4894 /// Handle an incoming node_announcement message, returning true if it should be forwarded on,
4895 /// false or returning an Err otherwise.
4897 pub handle_node_announcement: extern "C" fn (this_arg: *const c_void, msg: &crate::lightning::ln::msgs::NodeAnnouncement) -> crate::c_types::derived::CResult_boolLightningErrorZ,
4898 /// Handle a channel_announcement message, returning true if it should be forwarded on, false
4899 /// or returning an Err otherwise.
4901 pub handle_channel_announcement: extern "C" fn (this_arg: *const c_void, msg: &crate::lightning::ln::msgs::ChannelAnnouncement) -> crate::c_types::derived::CResult_boolLightningErrorZ,
4902 /// Handle an incoming channel_update message, returning true if it should be forwarded on,
4903 /// false or returning an Err otherwise.
4905 pub handle_channel_update: extern "C" fn (this_arg: *const c_void, msg: &crate::lightning::ln::msgs::ChannelUpdate) -> crate::c_types::derived::CResult_boolLightningErrorZ,
4906 /// Handle some updates to the route graph that we learned due to an outbound failed payment.
4907 pub handle_htlc_fail_channel_update: extern "C" fn (this_arg: *const c_void, update: &crate::lightning::ln::msgs::HTLCFailChannelUpdate),
4908 /// Gets a subset of the channel announcements and updates required to dump our routing table
4909 /// to a remote node, starting at the short_channel_id indicated by starting_point and
4910 /// including the batch_amount entries immediately higher in numerical value than starting_point.
4912 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,
4913 /// Gets a subset of the node announcements required to dump our routing table to a remote node,
4914 /// starting at the node *after* the provided publickey and including batch_amount entries
4915 /// immediately higher (as defined by <PublicKey as Ord>::cmp) than starting_point.
4916 /// If None is provided for starting_point, we start at the first node.
4918 /// Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
4920 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,
4921 /// Called when a connection is established with a peer. This can be used to
4922 /// perform routing table synchronization using a strategy defined by the
4924 pub sync_routing_table: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, init: &crate::lightning::ln::msgs::Init),
4925 /// Handles the reply of a query we initiated to learn about channels
4926 /// for a given range of blocks. We can expect to receive one or more
4927 /// replies to a single query.
4929 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,
4930 /// Handles the reply of a query we initiated asking for routing gossip
4931 /// messages for a list of channels. We should receive this message when
4932 /// a node has completed its best effort to send us the pertaining routing
4933 /// gossip messages.
4935 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,
4936 /// Handles when a peer asks us to send a list of short_channel_ids
4937 /// for the requested range of blocks.
4939 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,
4940 /// Handles when a peer asks us to send routing gossip messages for a
4941 /// list of short_channel_ids.
4943 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,
4944 /// Implementation of MessageSendEventsProvider for this object.
4945 pub MessageSendEventsProvider: crate::lightning::util::events::MessageSendEventsProvider,
4946 /// Frees any resources associated with this object given its this_arg pointer.
4947 /// Does not need to free the outer struct containing function pointers and may be NULL is no resources need to be freed.
4948 pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
4950 unsafe impl Send for RoutingMessageHandler {}
4951 unsafe impl Sync for RoutingMessageHandler {}
4953 pub(crate) extern "C" fn RoutingMessageHandler_clone_fields(orig: &RoutingMessageHandler) -> RoutingMessageHandler {
4954 RoutingMessageHandler {
4955 this_arg: orig.this_arg,
4956 handle_node_announcement: Clone::clone(&orig.handle_node_announcement),
4957 handle_channel_announcement: Clone::clone(&orig.handle_channel_announcement),
4958 handle_channel_update: Clone::clone(&orig.handle_channel_update),
4959 handle_htlc_fail_channel_update: Clone::clone(&orig.handle_htlc_fail_channel_update),
4960 get_next_channel_announcements: Clone::clone(&orig.get_next_channel_announcements),
4961 get_next_node_announcements: Clone::clone(&orig.get_next_node_announcements),
4962 sync_routing_table: Clone::clone(&orig.sync_routing_table),
4963 handle_reply_channel_range: Clone::clone(&orig.handle_reply_channel_range),
4964 handle_reply_short_channel_ids_end: Clone::clone(&orig.handle_reply_short_channel_ids_end),
4965 handle_query_channel_range: Clone::clone(&orig.handle_query_channel_range),
4966 handle_query_short_channel_ids: Clone::clone(&orig.handle_query_short_channel_ids),
4967 MessageSendEventsProvider: crate::lightning::util::events::MessageSendEventsProvider_clone_fields(&orig.MessageSendEventsProvider),
4968 free: Clone::clone(&orig.free),
4971 impl lightning::util::events::MessageSendEventsProvider for RoutingMessageHandler {
4972 fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {
4973 let mut ret = (self.MessageSendEventsProvider.get_and_clear_pending_msg_events)(self.MessageSendEventsProvider.this_arg);
4974 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
4979 use lightning::ln::msgs::RoutingMessageHandler as rustRoutingMessageHandler;
4980 impl rustRoutingMessageHandler for RoutingMessageHandler {
4981 fn handle_node_announcement(&self, mut msg: &lightning::ln::msgs::NodeAnnouncement) -> Result<bool, lightning::ln::msgs::LightningError> {
4982 let mut ret = (self.handle_node_announcement)(self.this_arg, &crate::lightning::ln::msgs::NodeAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false });
4983 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()) } })};
4986 fn handle_channel_announcement(&self, mut msg: &lightning::ln::msgs::ChannelAnnouncement) -> Result<bool, lightning::ln::msgs::LightningError> {
4987 let mut ret = (self.handle_channel_announcement)(self.this_arg, &crate::lightning::ln::msgs::ChannelAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false });
4988 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()) } })};
4991 fn handle_channel_update(&self, mut msg: &lightning::ln::msgs::ChannelUpdate) -> Result<bool, lightning::ln::msgs::LightningError> {
4992 let mut ret = (self.handle_channel_update)(self.this_arg, &crate::lightning::ln::msgs::ChannelUpdate { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false });
4993 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()) } })};
4996 fn handle_htlc_fail_channel_update(&self, mut update: &lightning::ln::msgs::HTLCFailChannelUpdate) {
4997 (self.handle_htlc_fail_channel_update)(self.this_arg, &crate::lightning::ln::msgs::HTLCFailChannelUpdate::from_native(update))
4999 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>)> {
5000 let mut ret = (self.get_next_channel_announcements)(self.this_arg, starting_point, batch_amount);
5001 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 }); };
5004 fn get_next_node_announcements(&self, mut starting_point: Option<&bitcoin::secp256k1::key::PublicKey>, mut batch_amount: u8) -> Vec<lightning::ln::msgs::NodeAnnouncement> {
5005 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())) } };
5006 let mut ret = (self.get_next_node_announcements)(self.this_arg, local_starting_point, batch_amount);
5007 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { *unsafe { Box::from_raw(item.take_inner()) } }); };
5010 fn sync_routing_table(&self, mut their_node_id: &bitcoin::secp256k1::key::PublicKey, mut init: &lightning::ln::msgs::Init) {
5011 (self.sync_routing_table)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::lightning::ln::msgs::Init { inner: unsafe { (init as *const _) as *mut _ }, is_owned: false })
5013 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> {
5014 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: Box::into_raw(Box::new(msg)), is_owned: true });
5015 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()) } })};
5018 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> {
5019 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: Box::into_raw(Box::new(msg)), is_owned: true });
5020 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()) } })};
5023 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> {
5024 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: Box::into_raw(Box::new(msg)), is_owned: true });
5025 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()) } })};
5028 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> {
5029 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: Box::into_raw(Box::new(msg)), is_owned: true });
5030 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()) } })};
5035 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
5036 // directly as a Deref trait in higher-level structs:
5037 impl std::ops::Deref for RoutingMessageHandler {
5039 fn deref(&self) -> &Self {
5043 /// Calls the free function if one is set
5045 pub extern "C" fn RoutingMessageHandler_free(this_ptr: RoutingMessageHandler) { }
5046 impl Drop for RoutingMessageHandler {
5047 fn drop(&mut self) {
5048 if let Some(f) = self.free {
5053 mod fuzzy_internal_msgs {
5055 use std::str::FromStr;
5056 use std::ffi::c_void;
5057 use bitcoin::hashes::Hash;
5058 use crate::c_types::*;
5062 /// Serialize the AcceptChannel object into a byte array which can be read by AcceptChannel_read
5063 pub extern "C" fn AcceptChannel_write(obj: &AcceptChannel) -> crate::c_types::derived::CVec_u8Z {
5064 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5067 pub(crate) extern "C" fn AcceptChannel_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5068 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeAcceptChannel) })
5071 /// Read a AcceptChannel from a byte array, created by AcceptChannel_write
5072 pub extern "C" fn AcceptChannel_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_AcceptChannelDecodeErrorZ {
5073 let res = crate::c_types::deserialize_obj(ser);
5074 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::AcceptChannel { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5078 /// Serialize the AnnouncementSignatures object into a byte array which can be read by AnnouncementSignatures_read
5079 pub extern "C" fn AnnouncementSignatures_write(obj: &AnnouncementSignatures) -> crate::c_types::derived::CVec_u8Z {
5080 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5083 pub(crate) extern "C" fn AnnouncementSignatures_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5084 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeAnnouncementSignatures) })
5087 /// Read a AnnouncementSignatures from a byte array, created by AnnouncementSignatures_write
5088 pub extern "C" fn AnnouncementSignatures_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_AnnouncementSignaturesDecodeErrorZ {
5089 let res = crate::c_types::deserialize_obj(ser);
5090 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::AnnouncementSignatures { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5094 /// Serialize the ChannelReestablish object into a byte array which can be read by ChannelReestablish_read
5095 pub extern "C" fn ChannelReestablish_write(obj: &ChannelReestablish) -> crate::c_types::derived::CVec_u8Z {
5096 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5099 pub(crate) extern "C" fn ChannelReestablish_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5100 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelReestablish) })
5103 /// Read a ChannelReestablish from a byte array, created by ChannelReestablish_write
5104 pub extern "C" fn ChannelReestablish_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChannelReestablishDecodeErrorZ {
5105 let res = crate::c_types::deserialize_obj(ser);
5106 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ChannelReestablish { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5110 /// Serialize the ClosingSigned object into a byte array which can be read by ClosingSigned_read
5111 pub extern "C" fn ClosingSigned_write(obj: &ClosingSigned) -> crate::c_types::derived::CVec_u8Z {
5112 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5115 pub(crate) extern "C" fn ClosingSigned_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5116 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeClosingSigned) })
5119 /// Read a ClosingSigned from a byte array, created by ClosingSigned_write
5120 pub extern "C" fn ClosingSigned_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ClosingSignedDecodeErrorZ {
5121 let res = crate::c_types::deserialize_obj(ser);
5122 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ClosingSigned { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5126 /// Serialize the ClosingSignedFeeRange object into a byte array which can be read by ClosingSignedFeeRange_read
5127 pub extern "C" fn ClosingSignedFeeRange_write(obj: &ClosingSignedFeeRange) -> crate::c_types::derived::CVec_u8Z {
5128 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5131 pub(crate) extern "C" fn ClosingSignedFeeRange_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5132 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeClosingSignedFeeRange) })
5135 /// Read a ClosingSignedFeeRange from a byte array, created by ClosingSignedFeeRange_write
5136 pub extern "C" fn ClosingSignedFeeRange_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ClosingSignedFeeRangeDecodeErrorZ {
5137 let res = crate::c_types::deserialize_obj(ser);
5138 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ClosingSignedFeeRange { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5142 /// Serialize the CommitmentSigned object into a byte array which can be read by CommitmentSigned_read
5143 pub extern "C" fn CommitmentSigned_write(obj: &CommitmentSigned) -> crate::c_types::derived::CVec_u8Z {
5144 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5147 pub(crate) extern "C" fn CommitmentSigned_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5148 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeCommitmentSigned) })
5151 /// Read a CommitmentSigned from a byte array, created by CommitmentSigned_write
5152 pub extern "C" fn CommitmentSigned_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_CommitmentSignedDecodeErrorZ {
5153 let res = crate::c_types::deserialize_obj(ser);
5154 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::CommitmentSigned { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5158 /// Serialize the FundingCreated object into a byte array which can be read by FundingCreated_read
5159 pub extern "C" fn FundingCreated_write(obj: &FundingCreated) -> crate::c_types::derived::CVec_u8Z {
5160 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5163 pub(crate) extern "C" fn FundingCreated_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5164 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFundingCreated) })
5167 /// Read a FundingCreated from a byte array, created by FundingCreated_write
5168 pub extern "C" fn FundingCreated_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_FundingCreatedDecodeErrorZ {
5169 let res = crate::c_types::deserialize_obj(ser);
5170 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::FundingCreated { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5174 /// Serialize the FundingSigned object into a byte array which can be read by FundingSigned_read
5175 pub extern "C" fn FundingSigned_write(obj: &FundingSigned) -> crate::c_types::derived::CVec_u8Z {
5176 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5179 pub(crate) extern "C" fn FundingSigned_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5180 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFundingSigned) })
5183 /// Read a FundingSigned from a byte array, created by FundingSigned_write
5184 pub extern "C" fn FundingSigned_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_FundingSignedDecodeErrorZ {
5185 let res = crate::c_types::deserialize_obj(ser);
5186 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::FundingSigned { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5190 /// Serialize the FundingLocked object into a byte array which can be read by FundingLocked_read
5191 pub extern "C" fn FundingLocked_write(obj: &FundingLocked) -> crate::c_types::derived::CVec_u8Z {
5192 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5195 pub(crate) extern "C" fn FundingLocked_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5196 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFundingLocked) })
5199 /// Read a FundingLocked from a byte array, created by FundingLocked_write
5200 pub extern "C" fn FundingLocked_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_FundingLockedDecodeErrorZ {
5201 let res = crate::c_types::deserialize_obj(ser);
5202 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::FundingLocked { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5206 /// Serialize the Init object into a byte array which can be read by Init_read
5207 pub extern "C" fn Init_write(obj: &Init) -> crate::c_types::derived::CVec_u8Z {
5208 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5211 pub(crate) extern "C" fn Init_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5212 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeInit) })
5215 /// Read a Init from a byte array, created by Init_write
5216 pub extern "C" fn Init_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_InitDecodeErrorZ {
5217 let res = crate::c_types::deserialize_obj(ser);
5218 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Init { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5222 /// Serialize the OpenChannel object into a byte array which can be read by OpenChannel_read
5223 pub extern "C" fn OpenChannel_write(obj: &OpenChannel) -> crate::c_types::derived::CVec_u8Z {
5224 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5227 pub(crate) extern "C" fn OpenChannel_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5228 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeOpenChannel) })
5231 /// Read a OpenChannel from a byte array, created by OpenChannel_write
5232 pub extern "C" fn OpenChannel_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_OpenChannelDecodeErrorZ {
5233 let res = crate::c_types::deserialize_obj(ser);
5234 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::OpenChannel { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5238 /// Serialize the RevokeAndACK object into a byte array which can be read by RevokeAndACK_read
5239 pub extern "C" fn RevokeAndACK_write(obj: &RevokeAndACK) -> crate::c_types::derived::CVec_u8Z {
5240 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5243 pub(crate) extern "C" fn RevokeAndACK_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5244 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeRevokeAndACK) })
5247 /// Read a RevokeAndACK from a byte array, created by RevokeAndACK_write
5248 pub extern "C" fn RevokeAndACK_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_RevokeAndACKDecodeErrorZ {
5249 let res = crate::c_types::deserialize_obj(ser);
5250 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::RevokeAndACK { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5254 /// Serialize the Shutdown object into a byte array which can be read by Shutdown_read
5255 pub extern "C" fn Shutdown_write(obj: &Shutdown) -> crate::c_types::derived::CVec_u8Z {
5256 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5259 pub(crate) extern "C" fn Shutdown_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5260 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeShutdown) })
5263 /// Read a Shutdown from a byte array, created by Shutdown_write
5264 pub extern "C" fn Shutdown_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ShutdownDecodeErrorZ {
5265 let res = crate::c_types::deserialize_obj(ser);
5266 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Shutdown { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5270 /// Serialize the UpdateFailHTLC object into a byte array which can be read by UpdateFailHTLC_read
5271 pub extern "C" fn UpdateFailHTLC_write(obj: &UpdateFailHTLC) -> crate::c_types::derived::CVec_u8Z {
5272 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5275 pub(crate) extern "C" fn UpdateFailHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5276 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFailHTLC) })
5279 /// Read a UpdateFailHTLC from a byte array, created by UpdateFailHTLC_write
5280 pub extern "C" fn UpdateFailHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateFailHTLCDecodeErrorZ {
5281 let res = crate::c_types::deserialize_obj(ser);
5282 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateFailHTLC { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5286 /// Serialize the UpdateFailMalformedHTLC object into a byte array which can be read by UpdateFailMalformedHTLC_read
5287 pub extern "C" fn UpdateFailMalformedHTLC_write(obj: &UpdateFailMalformedHTLC) -> crate::c_types::derived::CVec_u8Z {
5288 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5291 pub(crate) extern "C" fn UpdateFailMalformedHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5292 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFailMalformedHTLC) })
5295 /// Read a UpdateFailMalformedHTLC from a byte array, created by UpdateFailMalformedHTLC_write
5296 pub extern "C" fn UpdateFailMalformedHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateFailMalformedHTLCDecodeErrorZ {
5297 let res = crate::c_types::deserialize_obj(ser);
5298 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateFailMalformedHTLC { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5302 /// Serialize the UpdateFee object into a byte array which can be read by UpdateFee_read
5303 pub extern "C" fn UpdateFee_write(obj: &UpdateFee) -> crate::c_types::derived::CVec_u8Z {
5304 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5307 pub(crate) extern "C" fn UpdateFee_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5308 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFee) })
5311 /// Read a UpdateFee from a byte array, created by UpdateFee_write
5312 pub extern "C" fn UpdateFee_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateFeeDecodeErrorZ {
5313 let res = crate::c_types::deserialize_obj(ser);
5314 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateFee { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5318 /// Serialize the UpdateFulfillHTLC object into a byte array which can be read by UpdateFulfillHTLC_read
5319 pub extern "C" fn UpdateFulfillHTLC_write(obj: &UpdateFulfillHTLC) -> crate::c_types::derived::CVec_u8Z {
5320 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5323 pub(crate) extern "C" fn UpdateFulfillHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5324 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFulfillHTLC) })
5327 /// Read a UpdateFulfillHTLC from a byte array, created by UpdateFulfillHTLC_write
5328 pub extern "C" fn UpdateFulfillHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateFulfillHTLCDecodeErrorZ {
5329 let res = crate::c_types::deserialize_obj(ser);
5330 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateFulfillHTLC { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5334 /// Serialize the UpdateAddHTLC object into a byte array which can be read by UpdateAddHTLC_read
5335 pub extern "C" fn UpdateAddHTLC_write(obj: &UpdateAddHTLC) -> crate::c_types::derived::CVec_u8Z {
5336 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5339 pub(crate) extern "C" fn UpdateAddHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5340 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateAddHTLC) })
5343 /// Read a UpdateAddHTLC from a byte array, created by UpdateAddHTLC_write
5344 pub extern "C" fn UpdateAddHTLC_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UpdateAddHTLCDecodeErrorZ {
5345 let res = crate::c_types::deserialize_obj(ser);
5346 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UpdateAddHTLC { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5350 /// Serialize the Ping object into a byte array which can be read by Ping_read
5351 pub extern "C" fn Ping_write(obj: &Ping) -> crate::c_types::derived::CVec_u8Z {
5352 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5355 pub(crate) extern "C" fn Ping_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5356 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativePing) })
5359 /// Read a Ping from a byte array, created by Ping_write
5360 pub extern "C" fn Ping_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PingDecodeErrorZ {
5361 let res = crate::c_types::deserialize_obj(ser);
5362 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Ping { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5366 /// Serialize the Pong object into a byte array which can be read by Pong_read
5367 pub extern "C" fn Pong_write(obj: &Pong) -> crate::c_types::derived::CVec_u8Z {
5368 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5371 pub(crate) extern "C" fn Pong_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5372 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativePong) })
5375 /// Read a Pong from a byte array, created by Pong_write
5376 pub extern "C" fn Pong_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PongDecodeErrorZ {
5377 let res = crate::c_types::deserialize_obj(ser);
5378 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::Pong { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5382 /// Serialize the UnsignedChannelAnnouncement object into a byte array which can be read by UnsignedChannelAnnouncement_read
5383 pub extern "C" fn UnsignedChannelAnnouncement_write(obj: &UnsignedChannelAnnouncement) -> crate::c_types::derived::CVec_u8Z {
5384 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5387 pub(crate) extern "C" fn UnsignedChannelAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5388 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUnsignedChannelAnnouncement) })
5391 /// Read a UnsignedChannelAnnouncement from a byte array, created by UnsignedChannelAnnouncement_write
5392 pub extern "C" fn UnsignedChannelAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UnsignedChannelAnnouncementDecodeErrorZ {
5393 let res = crate::c_types::deserialize_obj(ser);
5394 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UnsignedChannelAnnouncement { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5398 /// Serialize the ChannelAnnouncement object into a byte array which can be read by ChannelAnnouncement_read
5399 pub extern "C" fn ChannelAnnouncement_write(obj: &ChannelAnnouncement) -> crate::c_types::derived::CVec_u8Z {
5400 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5403 pub(crate) extern "C" fn ChannelAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5404 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelAnnouncement) })
5407 /// Read a ChannelAnnouncement from a byte array, created by ChannelAnnouncement_write
5408 pub extern "C" fn ChannelAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChannelAnnouncementDecodeErrorZ {
5409 let res = crate::c_types::deserialize_obj(ser);
5410 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ChannelAnnouncement { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5414 /// Serialize the UnsignedChannelUpdate object into a byte array which can be read by UnsignedChannelUpdate_read
5415 pub extern "C" fn UnsignedChannelUpdate_write(obj: &UnsignedChannelUpdate) -> crate::c_types::derived::CVec_u8Z {
5416 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5419 pub(crate) extern "C" fn UnsignedChannelUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5420 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUnsignedChannelUpdate) })
5423 /// Read a UnsignedChannelUpdate from a byte array, created by UnsignedChannelUpdate_write
5424 pub extern "C" fn UnsignedChannelUpdate_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UnsignedChannelUpdateDecodeErrorZ {
5425 let res = crate::c_types::deserialize_obj(ser);
5426 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UnsignedChannelUpdate { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5430 /// Serialize the ChannelUpdate object into a byte array which can be read by ChannelUpdate_read
5431 pub extern "C" fn ChannelUpdate_write(obj: &ChannelUpdate) -> crate::c_types::derived::CVec_u8Z {
5432 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5435 pub(crate) extern "C" fn ChannelUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5436 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelUpdate) })
5439 /// Read a ChannelUpdate from a byte array, created by ChannelUpdate_write
5440 pub extern "C" fn ChannelUpdate_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChannelUpdateDecodeErrorZ {
5441 let res = crate::c_types::deserialize_obj(ser);
5442 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5446 /// Serialize the ErrorMessage object into a byte array which can be read by ErrorMessage_read
5447 pub extern "C" fn ErrorMessage_write(obj: &ErrorMessage) -> crate::c_types::derived::CVec_u8Z {
5448 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5451 pub(crate) extern "C" fn ErrorMessage_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5452 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeErrorMessage) })
5455 /// Read a ErrorMessage from a byte array, created by ErrorMessage_write
5456 pub extern "C" fn ErrorMessage_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ErrorMessageDecodeErrorZ {
5457 let res = crate::c_types::deserialize_obj(ser);
5458 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ErrorMessage { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5462 /// Serialize the UnsignedNodeAnnouncement object into a byte array which can be read by UnsignedNodeAnnouncement_read
5463 pub extern "C" fn UnsignedNodeAnnouncement_write(obj: &UnsignedNodeAnnouncement) -> crate::c_types::derived::CVec_u8Z {
5464 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5467 pub(crate) extern "C" fn UnsignedNodeAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5468 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUnsignedNodeAnnouncement) })
5471 /// Read a UnsignedNodeAnnouncement from a byte array, created by UnsignedNodeAnnouncement_write
5472 pub extern "C" fn UnsignedNodeAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UnsignedNodeAnnouncementDecodeErrorZ {
5473 let res = crate::c_types::deserialize_obj(ser);
5474 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::UnsignedNodeAnnouncement { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5478 /// Serialize the NodeAnnouncement object into a byte array which can be read by NodeAnnouncement_read
5479 pub extern "C" fn NodeAnnouncement_write(obj: &NodeAnnouncement) -> crate::c_types::derived::CVec_u8Z {
5480 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5483 pub(crate) extern "C" fn NodeAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5484 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeNodeAnnouncement) })
5487 /// Read a NodeAnnouncement from a byte array, created by NodeAnnouncement_write
5488 pub extern "C" fn NodeAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_NodeAnnouncementDecodeErrorZ {
5489 let res = crate::c_types::deserialize_obj(ser);
5490 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::NodeAnnouncement { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5494 /// Read a QueryShortChannelIds from a byte array, created by QueryShortChannelIds_write
5495 pub extern "C" fn QueryShortChannelIds_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_QueryShortChannelIdsDecodeErrorZ {
5496 let res = crate::c_types::deserialize_obj(ser);
5497 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::QueryShortChannelIds { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5501 /// Serialize the QueryShortChannelIds object into a byte array which can be read by QueryShortChannelIds_read
5502 pub extern "C" fn QueryShortChannelIds_write(obj: &QueryShortChannelIds) -> crate::c_types::derived::CVec_u8Z {
5503 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5506 pub(crate) extern "C" fn QueryShortChannelIds_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5507 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeQueryShortChannelIds) })
5510 /// Read a ReplyShortChannelIdsEnd from a byte array, created by ReplyShortChannelIdsEnd_write
5511 pub extern "C" fn ReplyShortChannelIdsEnd_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ReplyShortChannelIdsEndDecodeErrorZ {
5512 let res = crate::c_types::deserialize_obj(ser);
5513 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ReplyShortChannelIdsEnd { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5517 /// Serialize the ReplyShortChannelIdsEnd object into a byte array which can be read by ReplyShortChannelIdsEnd_read
5518 pub extern "C" fn ReplyShortChannelIdsEnd_write(obj: &ReplyShortChannelIdsEnd) -> crate::c_types::derived::CVec_u8Z {
5519 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5522 pub(crate) extern "C" fn ReplyShortChannelIdsEnd_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5523 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeReplyShortChannelIdsEnd) })
5525 ///\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
5528 pub extern "C" fn QueryChannelRange_end_blocknum(this_arg: &QueryChannelRange) -> u32 {
5529 let mut ret = unsafe { &*this_arg.inner }.end_blocknum();
5534 /// Read a QueryChannelRange from a byte array, created by QueryChannelRange_write
5535 pub extern "C" fn QueryChannelRange_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_QueryChannelRangeDecodeErrorZ {
5536 let res = crate::c_types::deserialize_obj(ser);
5537 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::QueryChannelRange { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5541 /// Serialize the QueryChannelRange object into a byte array which can be read by QueryChannelRange_read
5542 pub extern "C" fn QueryChannelRange_write(obj: &QueryChannelRange) -> crate::c_types::derived::CVec_u8Z {
5543 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5546 pub(crate) extern "C" fn QueryChannelRange_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5547 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeQueryChannelRange) })
5550 /// Read a ReplyChannelRange from a byte array, created by ReplyChannelRange_write
5551 pub extern "C" fn ReplyChannelRange_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ReplyChannelRangeDecodeErrorZ {
5552 let res = crate::c_types::deserialize_obj(ser);
5553 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::ReplyChannelRange { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5557 /// Serialize the ReplyChannelRange object into a byte array which can be read by ReplyChannelRange_read
5558 pub extern "C" fn ReplyChannelRange_write(obj: &ReplyChannelRange) -> crate::c_types::derived::CVec_u8Z {
5559 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5562 pub(crate) extern "C" fn ReplyChannelRange_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5563 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeReplyChannelRange) })
5566 /// Read a GossipTimestampFilter from a byte array, created by GossipTimestampFilter_write
5567 pub extern "C" fn GossipTimestampFilter_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_GossipTimestampFilterDecodeErrorZ {
5568 let res = crate::c_types::deserialize_obj(ser);
5569 let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::lightning::ln::msgs::GossipTimestampFilter { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
5573 /// Serialize the GossipTimestampFilter object into a byte array which can be read by GossipTimestampFilter_read
5574 pub extern "C" fn GossipTimestampFilter_write(obj: &GossipTimestampFilter) -> crate::c_types::derived::CVec_u8Z {
5575 crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
5578 pub(crate) extern "C" fn GossipTimestampFilter_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
5579 crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeGossipTimestampFilter) })