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