_ Git - rust-lightning/blob - lightning-c-bindings/src/util/events.rs

   1 //! Events are returned from various bits in the library which indicate some action must be taken
   2 //! by the client.
   3 //!
   4 //! Because we don't have a built-in runtime, it's up to the client to call events at a time in the
   5 //! future, as well as generate and broadcast funding transactions handle payment preimages and a
   6 //! few other things.
   7
   8 use std::ffi::c_void;
   9 use bitcoin::hashes::Hash;
  10 use crate::c_types::*;
  11
  12 /// An Event which you should probably take some action in response to.
  13 ///
  14 /// Note that while Writeable and Readable are implemented for Event, you probably shouldn't use
  15 /// them directly as they don't round-trip exactly (for example FundingGenerationReady is never
  16 /// written as it makes no sense to respond to it after reconnecting to peers).
  17 #[must_use]
  18 #[derive(Clone)]
  19 #[repr(C)]
  20 pub enum Event {
  21         /// Used to indicate that the client should generate a funding transaction with the given
  22         /// parameters and then call ChannelManager::funding_transaction_generated.
  23         /// Generated in ChannelManager message handling.
  24         /// Note that *all inputs* in the funding transaction must spend SegWit outputs or your
  25         /// counterparty can steal your funds!
  26         FundingGenerationReady {
  27                 temporary_channel_id: crate::c_types::ThirtyTwoBytes,
  28                 channel_value_satoshis: u64,
  29                 output_script: crate::c_types::derived::CVec_u8Z,
  30                 user_channel_id: u64,
  31         },
  32         /// Used to indicate that the client may now broadcast the funding transaction it created for a
  33         /// channel. Broadcasting such a transaction prior to this event may lead to our counterparty
  34         /// trivially stealing all funds in the funding transaction!
  35         FundingBroadcastSafe {
  36                 funding_txo: crate::chain::transaction::OutPoint,
  37                 user_channel_id: u64,
  38         },
  39         /// Indicates we've received money! Just gotta dig out that payment preimage and feed it to
  40         /// ChannelManager::claim_funds to get it....
  41         /// Note that if the preimage is not known or the amount paid is incorrect, you should call
  42         /// ChannelManager::fail_htlc_backwards to free up resources for this HTLC and avoid
  43         /// network congestion.
  44         /// The amount paid should be considered 'incorrect' when it is less than or more than twice
  45         /// the amount expected.
  46         /// If you fail to call either ChannelManager::claim_funds or
  47         /// ChannelManager::fail_htlc_backwards within the HTLC's timeout, the HTLC will be
  48         /// automatically failed.
  49         PaymentReceived {
  50                 payment_hash: crate::c_types::ThirtyTwoBytes,
  51                 payment_secret: crate::c_types::ThirtyTwoBytes,
  52                 amt: u64,
  53         },
  54         /// Indicates an outbound payment we made succeeded (ie it made it all the way to its target
  55         /// and we got back the payment preimage for it).
  56         /// Note that duplicative PaymentSent Events may be generated - it is your responsibility to
  57         /// deduplicate them by payment_preimage (which MUST be unique)!
  58         PaymentSent {
  59                 payment_preimage: crate::c_types::ThirtyTwoBytes,
  60         },
  61         /// Indicates an outbound payment we made failed. Probably some intermediary node dropped
  62         /// something. You may wish to retry with a different route.
  63         /// Note that duplicative PaymentFailed Events may be generated - it is your responsibility to
  64         /// deduplicate them by payment_hash (which MUST be unique)!
  65         PaymentFailed {
  66                 payment_hash: crate::c_types::ThirtyTwoBytes,
  67                 rejected_by_dest: bool,
  68         },
  69         /// Used to indicate that ChannelManager::process_pending_htlc_forwards should be called at a
  70         /// time in the future.
  71         PendingHTLCsForwardable {
  72                 time_forwardable: u64,
  73         },
  74         /// Used to indicate that an output was generated on-chain which you should know how to spend.
  75         /// Such an output will *not* ever be spent by rust-lightning, and are not at risk of your
  76         /// counterparty spending them due to some kind of timeout. Thus, you need to store them
  77         /// somewhere and spend them when you create on-chain transactions.
  78         SpendableOutputs {
  79                 outputs: crate::c_types::derived::CVec_SpendableOutputDescriptorZ,
  80         },
  81 }
  82 use lightning::util::events::Event as nativeEvent;
  83 impl Event {
  84         #[allow(unused)]
  85         pub(crate) fn to_native(&self) -> nativeEvent {
  86                 match self {
  87                         Event::FundingGenerationReady {ref temporary_channel_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => {
  88                                 let mut temporary_channel_id_nonref = (*temporary_channel_id).clone();
  89                                 let mut channel_value_satoshis_nonref = (*channel_value_satoshis).clone();
  90                                 let mut output_script_nonref = (*output_script).clone();
  91                                 let mut user_channel_id_nonref = (*user_channel_id).clone();
  92                                 nativeEvent::FundingGenerationReady {
  93                                         temporary_channel_id: temporary_channel_id_nonref.data,
  94                                         channel_value_satoshis: channel_value_satoshis_nonref,
  95                                         output_script: ::bitcoin::blockdata::script::Script::from(output_script_nonref.into_rust()),
  96                                         user_channel_id: user_channel_id_nonref,
  97                                 }
  98                         },
  99                         Event::FundingBroadcastSafe {ref funding_txo, ref user_channel_id, } => {
 100                                 let mut funding_txo_nonref = (*funding_txo).clone();
 101                                 let mut user_channel_id_nonref = (*user_channel_id).clone();
 102                                 nativeEvent::FundingBroadcastSafe {
 103                                         funding_txo: *unsafe { Box::from_raw(funding_txo_nonref.take_ptr()) },
 104                                         user_channel_id: user_channel_id_nonref,
 105                                 }
 106                         },
 107                         Event::PaymentReceived {ref payment_hash, ref payment_secret, ref amt, } => {
 108                                 let mut payment_hash_nonref = (*payment_hash).clone();
 109                                 let mut payment_secret_nonref = (*payment_secret).clone();
 110                                 let mut local_payment_secret_nonref = if payment_secret_nonref.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentSecret(payment_secret_nonref.data) }) };
 111                                 let mut amt_nonref = (*amt).clone();
 112                                 nativeEvent::PaymentReceived {
 113                                         payment_hash: ::lightning::ln::channelmanager::PaymentHash(payment_hash_nonref.data),
 114                                         payment_secret: local_payment_secret_nonref,
 115                                         amt: amt_nonref,
 116                                 }
 117                         },
 118                         Event::PaymentSent {ref payment_preimage, } => {
 119                                 let mut payment_preimage_nonref = (*payment_preimage).clone();
 120                                 nativeEvent::PaymentSent {
 121                                         payment_preimage: ::lightning::ln::channelmanager::PaymentPreimage(payment_preimage_nonref.data),
 122                                 }
 123                         },
 124                         Event::PaymentFailed {ref payment_hash, ref rejected_by_dest, } => {
 125                                 let mut payment_hash_nonref = (*payment_hash).clone();
 126                                 let mut rejected_by_dest_nonref = (*rejected_by_dest).clone();
 127                                 nativeEvent::PaymentFailed {
 128                                         payment_hash: ::lightning::ln::channelmanager::PaymentHash(payment_hash_nonref.data),
 129                                         rejected_by_dest: rejected_by_dest_nonref,
 130                                 }
 131                         },
 132                         Event::PendingHTLCsForwardable {ref time_forwardable, } => {
 133                                 let mut time_forwardable_nonref = (*time_forwardable).clone();
 134                                 nativeEvent::PendingHTLCsForwardable {
 135                                         time_forwardable: std::time::Duration::from_secs(time_forwardable_nonref),
 136                                 }
 137                         },
 138                         Event::SpendableOutputs {ref outputs, } => {
 139                                 let mut outputs_nonref = (*outputs).clone();
 140                                 let mut local_outputs_nonref = Vec::new(); for mut item in outputs_nonref.into_rust().drain(..) { local_outputs_nonref.push( { item.into_native() }); };
 141                                 nativeEvent::SpendableOutputs {
 142                                         outputs: local_outputs_nonref,
 143                                 }
 144                         },
 145                 }
 146         }
 147         #[allow(unused)]
 148         pub(crate) fn into_native(self) -> nativeEvent {
 149                 match self {
 150                         Event::FundingGenerationReady {mut temporary_channel_id, mut channel_value_satoshis, mut output_script, mut user_channel_id, } => {
 151                                 nativeEvent::FundingGenerationReady {
 152                                         temporary_channel_id: temporary_channel_id.data,
 153                                         channel_value_satoshis: channel_value_satoshis,
 154                                         output_script: ::bitcoin::blockdata::script::Script::from(output_script.into_rust()),
 155                                         user_channel_id: user_channel_id,
 156                                 }
 157                         },
 158                         Event::FundingBroadcastSafe {mut funding_txo, mut user_channel_id, } => {
 159                                 nativeEvent::FundingBroadcastSafe {
 160                                         funding_txo: *unsafe { Box::from_raw(funding_txo.take_ptr()) },
 161                                         user_channel_id: user_channel_id,
 162                                 }
 163                         },
 164                         Event::PaymentReceived {mut payment_hash, mut payment_secret, mut amt, } => {
 165                                 let mut local_payment_secret = if payment_secret.data == [0; 32] { None } else { Some( { ::lightning::ln::channelmanager::PaymentSecret(payment_secret.data) }) };
 166                                 nativeEvent::PaymentReceived {
 167                                         payment_hash: ::lightning::ln::channelmanager::PaymentHash(payment_hash.data),
 168                                         payment_secret: local_payment_secret,
 169                                         amt: amt,
 170                                 }
 171                         },
 172                         Event::PaymentSent {mut payment_preimage, } => {
 173                                 nativeEvent::PaymentSent {
 174                                         payment_preimage: ::lightning::ln::channelmanager::PaymentPreimage(payment_preimage.data),
 175                                 }
 176                         },
 177                         Event::PaymentFailed {mut payment_hash, mut rejected_by_dest, } => {
 178                                 nativeEvent::PaymentFailed {
 179                                         payment_hash: ::lightning::ln::channelmanager::PaymentHash(payment_hash.data),
 180                                         rejected_by_dest: rejected_by_dest,
 181                                 }
 182                         },
 183                         Event::PendingHTLCsForwardable {mut time_forwardable, } => {
 184                                 nativeEvent::PendingHTLCsForwardable {
 185                                         time_forwardable: std::time::Duration::from_secs(time_forwardable),
 186                                 }
 187                         },
 188                         Event::SpendableOutputs {mut outputs, } => {
 189                                 let mut local_outputs = Vec::new(); for mut item in outputs.into_rust().drain(..) { local_outputs.push( { item.into_native() }); };
 190                                 nativeEvent::SpendableOutputs {
 191                                         outputs: local_outputs,
 192                                 }
 193                         },
 194                 }
 195         }
 196         #[allow(unused)]
 197         pub(crate) fn from_native(native: &nativeEvent) -> Self {
 198                 match native {
 199                         nativeEvent::FundingGenerationReady {ref temporary_channel_id, ref channel_value_satoshis, ref output_script, ref user_channel_id, } => {
 200                                 let mut temporary_channel_id_nonref = (*temporary_channel_id).clone();
 201                                 let mut channel_value_satoshis_nonref = (*channel_value_satoshis).clone();
 202                                 let mut output_script_nonref = (*output_script).clone();
 203                                 let mut user_channel_id_nonref = (*user_channel_id).clone();
 204                                 Event::FundingGenerationReady {
 205                                         temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id_nonref },
 206                                         channel_value_satoshis: channel_value_satoshis_nonref,
 207                                         output_script: output_script_nonref.into_bytes().into(),
 208                                         user_channel_id: user_channel_id_nonref,
 209                                 }
 210                         },
 211                         nativeEvent::FundingBroadcastSafe {ref funding_txo, ref user_channel_id, } => {
 212                                 let mut funding_txo_nonref = (*funding_txo).clone();
 213                                 let mut user_channel_id_nonref = (*user_channel_id).clone();
 214                                 Event::FundingBroadcastSafe {
 215                                         funding_txo: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(funding_txo_nonref)), is_owned: true },
 216                                         user_channel_id: user_channel_id_nonref,
 217                                 }
 218                         },
 219                         nativeEvent::PaymentReceived {ref payment_hash, ref payment_secret, ref amt, } => {
 220                                 let mut payment_hash_nonref = (*payment_hash).clone();
 221                                 let mut payment_secret_nonref = (*payment_secret).clone();
 222                                 let mut local_payment_secret_nonref = if payment_secret_nonref.is_none() { crate::c_types::ThirtyTwoBytes::null() } else {  { crate::c_types::ThirtyTwoBytes { data: (payment_secret_nonref.unwrap()).0 } } };
 223                                 let mut amt_nonref = (*amt).clone();
 224                                 Event::PaymentReceived {
 225                                         payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
 226                                         payment_secret: local_payment_secret_nonref,
 227                                         amt: amt_nonref,
 228                                 }
 229                         },
 230                         nativeEvent::PaymentSent {ref payment_preimage, } => {
 231                                 let mut payment_preimage_nonref = (*payment_preimage).clone();
 232                                 Event::PaymentSent {
 233                                         payment_preimage: crate::c_types::ThirtyTwoBytes { data: payment_preimage_nonref.0 },
 234                                 }
 235                         },
 236                         nativeEvent::PaymentFailed {ref payment_hash, ref rejected_by_dest, } => {
 237                                 let mut payment_hash_nonref = (*payment_hash).clone();
 238                                 let mut rejected_by_dest_nonref = (*rejected_by_dest).clone();
 239                                 Event::PaymentFailed {
 240                                         payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash_nonref.0 },
 241                                         rejected_by_dest: rejected_by_dest_nonref,
 242                                 }
 243                         },
 244                         nativeEvent::PendingHTLCsForwardable {ref time_forwardable, } => {
 245                                 let mut time_forwardable_nonref = (*time_forwardable).clone();
 246                                 Event::PendingHTLCsForwardable {
 247                                         time_forwardable: time_forwardable_nonref.as_secs(),
 248                                 }
 249                         },
 250                         nativeEvent::SpendableOutputs {ref outputs, } => {
 251                                 let mut outputs_nonref = (*outputs).clone();
 252                                 let mut local_outputs_nonref = Vec::new(); for item in outputs_nonref.drain(..) { local_outputs_nonref.push( { crate::chain::keysinterface::SpendableOutputDescriptor::native_into(item) }); };
 253                                 Event::SpendableOutputs {
 254                                         outputs: local_outputs_nonref.into(),
 255                                 }
 256                         },
 257                 }
 258         }
 259         #[allow(unused)]
 260         pub(crate) fn native_into(native: nativeEvent) -> Self {
 261                 match native {
 262                         nativeEvent::FundingGenerationReady {mut temporary_channel_id, mut channel_value_satoshis, mut output_script, mut user_channel_id, } => {
 263                                 Event::FundingGenerationReady {
 264                                         temporary_channel_id: crate::c_types::ThirtyTwoBytes { data: temporary_channel_id },
 265                                         channel_value_satoshis: channel_value_satoshis,
 266                                         output_script: output_script.into_bytes().into(),
 267                                         user_channel_id: user_channel_id,
 268                                 }
 269                         },
 270                         nativeEvent::FundingBroadcastSafe {mut funding_txo, mut user_channel_id, } => {
 271                                 Event::FundingBroadcastSafe {
 272                                         funding_txo: crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(funding_txo)), is_owned: true },
 273                                         user_channel_id: user_channel_id,
 274                                 }
 275                         },
 276                         nativeEvent::PaymentReceived {mut payment_hash, mut payment_secret, mut amt, } => {
 277                                 let mut local_payment_secret = if payment_secret.is_none() { crate::c_types::ThirtyTwoBytes::null() } else {  { crate::c_types::ThirtyTwoBytes { data: (payment_secret.unwrap()).0 } } };
 278                                 Event::PaymentReceived {
 279                                         payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
 280                                         payment_secret: local_payment_secret,
 281                                         amt: amt,
 282                                 }
 283                         },
 284                         nativeEvent::PaymentSent {mut payment_preimage, } => {
 285                                 Event::PaymentSent {
 286                                         payment_preimage: crate::c_types::ThirtyTwoBytes { data: payment_preimage.0 },
 287                                 }
 288                         },
 289                         nativeEvent::PaymentFailed {mut payment_hash, mut rejected_by_dest, } => {
 290                                 Event::PaymentFailed {
 291                                         payment_hash: crate::c_types::ThirtyTwoBytes { data: payment_hash.0 },
 292                                         rejected_by_dest: rejected_by_dest,
 293                                 }
 294                         },
 295                         nativeEvent::PendingHTLCsForwardable {mut time_forwardable, } => {
 296                                 Event::PendingHTLCsForwardable {
 297                                         time_forwardable: time_forwardable.as_secs(),
 298                                 }
 299                         },
 300                         nativeEvent::SpendableOutputs {mut outputs, } => {
 301                                 let mut local_outputs = Vec::new(); for item in outputs.drain(..) { local_outputs.push( { crate::chain::keysinterface::SpendableOutputDescriptor::native_into(item) }); };
 302                                 Event::SpendableOutputs {
 303                                         outputs: local_outputs.into(),
 304                                 }
 305                         },
 306                 }
 307         }
 308 }
 309 #[no_mangle]
 310 pub extern "C" fn Event_free(this_ptr: Event) { }
 311 /// An event generated by ChannelManager which indicates a message should be sent to a peer (or
 312 /// broadcast to most peers).
 313 /// These events are handled by PeerManager::process_events if you are using a PeerManager.
 314 #[must_use]
 315 #[derive(Clone)]
 316 #[repr(C)]
 317 pub enum MessageSendEvent {
 318         /// Used to indicate that we've accepted a channel open and should send the accept_channel
 319         /// message provided to the given peer.
 320         SendAcceptChannel {
 321                 node_id: crate::c_types::PublicKey,
 322                 msg: crate::ln::msgs::AcceptChannel,
 323         },
 324         /// Used to indicate that we've initiated a channel open and should send the open_channel
 325         /// message provided to the given peer.
 326         SendOpenChannel {
 327                 node_id: crate::c_types::PublicKey,
 328                 msg: crate::ln::msgs::OpenChannel,
 329         },
 330         /// Used to indicate that a funding_created message should be sent to the peer with the given node_id.
 331         SendFundingCreated {
 332                 node_id: crate::c_types::PublicKey,
 333                 msg: crate::ln::msgs::FundingCreated,
 334         },
 335         /// Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
 336         SendFundingSigned {
 337                 node_id: crate::c_types::PublicKey,
 338                 msg: crate::ln::msgs::FundingSigned,
 339         },
 340         /// Used to indicate that a funding_locked message should be sent to the peer with the given node_id.
 341         SendFundingLocked {
 342                 node_id: crate::c_types::PublicKey,
 343                 msg: crate::ln::msgs::FundingLocked,
 344         },
 345         /// Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
 346         SendAnnouncementSignatures {
 347                 node_id: crate::c_types::PublicKey,
 348                 msg: crate::ln::msgs::AnnouncementSignatures,
 349         },
 350         /// Used to indicate that a series of HTLC update messages, as well as a commitment_signed
 351         /// message should be sent to the peer with the given node_id.
 352         UpdateHTLCs {
 353                 node_id: crate::c_types::PublicKey,
 354                 updates: crate::ln::msgs::CommitmentUpdate,
 355         },
 356         /// Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
 357         SendRevokeAndACK {
 358                 node_id: crate::c_types::PublicKey,
 359                 msg: crate::ln::msgs::RevokeAndACK,
 360         },
 361         /// Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
 362         SendClosingSigned {
 363                 node_id: crate::c_types::PublicKey,
 364                 msg: crate::ln::msgs::ClosingSigned,
 365         },
 366         /// Used to indicate that a shutdown message should be sent to the peer with the given node_id.
 367         SendShutdown {
 368                 node_id: crate::c_types::PublicKey,
 369                 msg: crate::ln::msgs::Shutdown,
 370         },
 371         /// Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
 372         SendChannelReestablish {
 373                 node_id: crate::c_types::PublicKey,
 374                 msg: crate::ln::msgs::ChannelReestablish,
 375         },
 376         /// Used to indicate that a channel_announcement and channel_update should be broadcast to all
 377         /// peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
 378         ///
 379         /// Note that after doing so, you very likely (unless you did so very recently) want to call
 380         /// ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event.
 381         /// This ensures that any nodes which see our channel_announcement also have a relevant
 382         /// node_announcement, including relevant feature flags which may be important for routing
 383         /// through or to us.
 384         BroadcastChannelAnnouncement {
 385                 msg: crate::ln::msgs::ChannelAnnouncement,
 386                 update_msg: crate::ln::msgs::ChannelUpdate,
 387         },
 388         /// Used to indicate that a node_announcement should be broadcast to all peers.
 389         BroadcastNodeAnnouncement {
 390                 msg: crate::ln::msgs::NodeAnnouncement,
 391         },
 392         /// Used to indicate that a channel_update should be broadcast to all peers.
 393         BroadcastChannelUpdate {
 394                 msg: crate::ln::msgs::ChannelUpdate,
 395         },
 396         /// Broadcast an error downstream to be handled
 397         HandleError {
 398                 node_id: crate::c_types::PublicKey,
 399                 action: crate::ln::msgs::ErrorAction,
 400         },
 401         /// When a payment fails we may receive updates back from the hop where it failed. In such
 402         /// cases this event is generated so that we can inform the network graph of this information.
 403         PaymentFailureNetworkUpdate {
 404                 update: crate::ln::msgs::HTLCFailChannelUpdate,
 405         },
 406 }
 407 use lightning::util::events::MessageSendEvent as nativeMessageSendEvent;
 408 impl MessageSendEvent {
 409         #[allow(unused)]
 410         pub(crate) fn to_native(&self) -> nativeMessageSendEvent {
 411                 match self {
 412                         MessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => {
 413                                 let mut node_id_nonref = (*node_id).clone();
 414                                 let mut msg_nonref = (*msg).clone();
 415                                 nativeMessageSendEvent::SendAcceptChannel {
 416                                         node_id: node_id_nonref.into_rust(),
 417                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 418                                 }
 419                         },
 420                         MessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => {
 421                                 let mut node_id_nonref = (*node_id).clone();
 422                                 let mut msg_nonref = (*msg).clone();
 423                                 nativeMessageSendEvent::SendOpenChannel {
 424                                         node_id: node_id_nonref.into_rust(),
 425                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 426                                 }
 427                         },
 428                         MessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => {
 429                                 let mut node_id_nonref = (*node_id).clone();
 430                                 let mut msg_nonref = (*msg).clone();
 431                                 nativeMessageSendEvent::SendFundingCreated {
 432                                         node_id: node_id_nonref.into_rust(),
 433                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 434                                 }
 435                         },
 436                         MessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => {
 437                                 let mut node_id_nonref = (*node_id).clone();
 438                                 let mut msg_nonref = (*msg).clone();
 439                                 nativeMessageSendEvent::SendFundingSigned {
 440                                         node_id: node_id_nonref.into_rust(),
 441                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 442                                 }
 443                         },
 444                         MessageSendEvent::SendFundingLocked {ref node_id, ref msg, } => {
 445                                 let mut node_id_nonref = (*node_id).clone();
 446                                 let mut msg_nonref = (*msg).clone();
 447                                 nativeMessageSendEvent::SendFundingLocked {
 448                                         node_id: node_id_nonref.into_rust(),
 449                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 450                                 }
 451                         },
 452                         MessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => {
 453                                 let mut node_id_nonref = (*node_id).clone();
 454                                 let mut msg_nonref = (*msg).clone();
 455                                 nativeMessageSendEvent::SendAnnouncementSignatures {
 456                                         node_id: node_id_nonref.into_rust(),
 457                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 458                                 }
 459                         },
 460                         MessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => {
 461                                 let mut node_id_nonref = (*node_id).clone();
 462                                 let mut updates_nonref = (*updates).clone();
 463                                 nativeMessageSendEvent::UpdateHTLCs {
 464                                         node_id: node_id_nonref.into_rust(),
 465                                         updates: *unsafe { Box::from_raw(updates_nonref.take_ptr()) },
 466                                 }
 467                         },
 468                         MessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => {
 469                                 let mut node_id_nonref = (*node_id).clone();
 470                                 let mut msg_nonref = (*msg).clone();
 471                                 nativeMessageSendEvent::SendRevokeAndACK {
 472                                         node_id: node_id_nonref.into_rust(),
 473                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 474                                 }
 475                         },
 476                         MessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => {
 477                                 let mut node_id_nonref = (*node_id).clone();
 478                                 let mut msg_nonref = (*msg).clone();
 479                                 nativeMessageSendEvent::SendClosingSigned {
 480                                         node_id: node_id_nonref.into_rust(),
 481                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 482                                 }
 483                         },
 484                         MessageSendEvent::SendShutdown {ref node_id, ref msg, } => {
 485                                 let mut node_id_nonref = (*node_id).clone();
 486                                 let mut msg_nonref = (*msg).clone();
 487                                 nativeMessageSendEvent::SendShutdown {
 488                                         node_id: node_id_nonref.into_rust(),
 489                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 490                                 }
 491                         },
 492                         MessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => {
 493                                 let mut node_id_nonref = (*node_id).clone();
 494                                 let mut msg_nonref = (*msg).clone();
 495                                 nativeMessageSendEvent::SendChannelReestablish {
 496                                         node_id: node_id_nonref.into_rust(),
 497                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 498                                 }
 499                         },
 500                         MessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => {
 501                                 let mut msg_nonref = (*msg).clone();
 502                                 let mut update_msg_nonref = (*update_msg).clone();
 503                                 nativeMessageSendEvent::BroadcastChannelAnnouncement {
 504                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 505                                         update_msg: *unsafe { Box::from_raw(update_msg_nonref.take_ptr()) },
 506                                 }
 507                         },
 508                         MessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => {
 509                                 let mut msg_nonref = (*msg).clone();
 510                                 nativeMessageSendEvent::BroadcastNodeAnnouncement {
 511                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 512                                 }
 513                         },
 514                         MessageSendEvent::BroadcastChannelUpdate {ref msg, } => {
 515                                 let mut msg_nonref = (*msg).clone();
 516                                 nativeMessageSendEvent::BroadcastChannelUpdate {
 517                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 518                                 }
 519                         },
 520                         MessageSendEvent::HandleError {ref node_id, ref action, } => {
 521                                 let mut node_id_nonref = (*node_id).clone();
 522                                 let mut action_nonref = (*action).clone();
 523                                 nativeMessageSendEvent::HandleError {
 524                                         node_id: node_id_nonref.into_rust(),
 525                                         action: action_nonref.into_native(),
 526                                 }
 527                         },
 528                         MessageSendEvent::PaymentFailureNetworkUpdate {ref update, } => {
 529                                 let mut update_nonref = (*update).clone();
 530                                 nativeMessageSendEvent::PaymentFailureNetworkUpdate {
 531                                         update: update_nonref.into_native(),
 532                                 }
 533                         },
 534                 }
 535         }
 536         #[allow(unused)]
 537         pub(crate) fn into_native(self) -> nativeMessageSendEvent {
 538                 match self {
 539                         MessageSendEvent::SendAcceptChannel {mut node_id, mut msg, } => {
 540                                 nativeMessageSendEvent::SendAcceptChannel {
 541                                         node_id: node_id.into_rust(),
 542                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 543                                 }
 544                         },
 545                         MessageSendEvent::SendOpenChannel {mut node_id, mut msg, } => {
 546                                 nativeMessageSendEvent::SendOpenChannel {
 547                                         node_id: node_id.into_rust(),
 548                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 549                                 }
 550                         },
 551                         MessageSendEvent::SendFundingCreated {mut node_id, mut msg, } => {
 552                                 nativeMessageSendEvent::SendFundingCreated {
 553                                         node_id: node_id.into_rust(),
 554                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 555                                 }
 556                         },
 557                         MessageSendEvent::SendFundingSigned {mut node_id, mut msg, } => {
 558                                 nativeMessageSendEvent::SendFundingSigned {
 559                                         node_id: node_id.into_rust(),
 560                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 561                                 }
 562                         },
 563                         MessageSendEvent::SendFundingLocked {mut node_id, mut msg, } => {
 564                                 nativeMessageSendEvent::SendFundingLocked {
 565                                         node_id: node_id.into_rust(),
 566                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 567                                 }
 568                         },
 569                         MessageSendEvent::SendAnnouncementSignatures {mut node_id, mut msg, } => {
 570                                 nativeMessageSendEvent::SendAnnouncementSignatures {
 571                                         node_id: node_id.into_rust(),
 572                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 573                                 }
 574                         },
 575                         MessageSendEvent::UpdateHTLCs {mut node_id, mut updates, } => {
 576                                 nativeMessageSendEvent::UpdateHTLCs {
 577                                         node_id: node_id.into_rust(),
 578                                         updates: *unsafe { Box::from_raw(updates.take_ptr()) },
 579                                 }
 580                         },
 581                         MessageSendEvent::SendRevokeAndACK {mut node_id, mut msg, } => {
 582                                 nativeMessageSendEvent::SendRevokeAndACK {
 583                                         node_id: node_id.into_rust(),
 584                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 585                                 }
 586                         },
 587                         MessageSendEvent::SendClosingSigned {mut node_id, mut msg, } => {
 588                                 nativeMessageSendEvent::SendClosingSigned {
 589                                         node_id: node_id.into_rust(),
 590                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 591                                 }
 592                         },
 593                         MessageSendEvent::SendShutdown {mut node_id, mut msg, } => {
 594                                 nativeMessageSendEvent::SendShutdown {
 595                                         node_id: node_id.into_rust(),
 596                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 597                                 }
 598                         },
 599                         MessageSendEvent::SendChannelReestablish {mut node_id, mut msg, } => {
 600                                 nativeMessageSendEvent::SendChannelReestablish {
 601                                         node_id: node_id.into_rust(),
 602                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 603                                 }
 604                         },
 605                         MessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => {
 606                                 nativeMessageSendEvent::BroadcastChannelAnnouncement {
 607                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 608                                         update_msg: *unsafe { Box::from_raw(update_msg.take_ptr()) },
 609                                 }
 610                         },
 611                         MessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => {
 612                                 nativeMessageSendEvent::BroadcastNodeAnnouncement {
 613                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 614                                 }
 615                         },
 616                         MessageSendEvent::BroadcastChannelUpdate {mut msg, } => {
 617                                 nativeMessageSendEvent::BroadcastChannelUpdate {
 618                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 619                                 }
 620                         },
 621                         MessageSendEvent::HandleError {mut node_id, mut action, } => {
 622                                 nativeMessageSendEvent::HandleError {
 623                                         node_id: node_id.into_rust(),
 624                                         action: action.into_native(),
 625                                 }
 626                         },
 627                         MessageSendEvent::PaymentFailureNetworkUpdate {mut update, } => {
 628                                 nativeMessageSendEvent::PaymentFailureNetworkUpdate {
 629                                         update: update.into_native(),
 630                                 }
 631                         },
 632                 }
 633         }
 634         #[allow(unused)]
 635         pub(crate) fn from_native(native: &nativeMessageSendEvent) -> Self {
 636                 match native {
 637                         nativeMessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => {
 638                                 let mut node_id_nonref = (*node_id).clone();
 639                                 let mut msg_nonref = (*msg).clone();
 640                                 MessageSendEvent::SendAcceptChannel {
 641                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 642                                         msg: crate::ln::msgs::AcceptChannel { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 643                                 }
 644                         },
 645                         nativeMessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => {
 646                                 let mut node_id_nonref = (*node_id).clone();
 647                                 let mut msg_nonref = (*msg).clone();
 648                                 MessageSendEvent::SendOpenChannel {
 649                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 650                                         msg: crate::ln::msgs::OpenChannel { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 651                                 }
 652                         },
 653                         nativeMessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => {
 654                                 let mut node_id_nonref = (*node_id).clone();
 655                                 let mut msg_nonref = (*msg).clone();
 656                                 MessageSendEvent::SendFundingCreated {
 657                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 658                                         msg: crate::ln::msgs::FundingCreated { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 659                                 }
 660                         },
 661                         nativeMessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => {
 662                                 let mut node_id_nonref = (*node_id).clone();
 663                                 let mut msg_nonref = (*msg).clone();
 664                                 MessageSendEvent::SendFundingSigned {
 665                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 666                                         msg: crate::ln::msgs::FundingSigned { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 667                                 }
 668                         },
 669                         nativeMessageSendEvent::SendFundingLocked {ref node_id, ref msg, } => {
 670                                 let mut node_id_nonref = (*node_id).clone();
 671                                 let mut msg_nonref = (*msg).clone();
 672                                 MessageSendEvent::SendFundingLocked {
 673                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 674                                         msg: crate::ln::msgs::FundingLocked { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 675                                 }
 676                         },
 677                         nativeMessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => {
 678                                 let mut node_id_nonref = (*node_id).clone();
 679                                 let mut msg_nonref = (*msg).clone();
 680                                 MessageSendEvent::SendAnnouncementSignatures {
 681                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 682                                         msg: crate::ln::msgs::AnnouncementSignatures { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 683                                 }
 684                         },
 685                         nativeMessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => {
 686                                 let mut node_id_nonref = (*node_id).clone();
 687                                 let mut updates_nonref = (*updates).clone();
 688                                 MessageSendEvent::UpdateHTLCs {
 689                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 690                                         updates: crate::ln::msgs::CommitmentUpdate { inner: Box::into_raw(Box::new(updates_nonref)), is_owned: true },
 691                                 }
 692                         },
 693                         nativeMessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => {
 694                                 let mut node_id_nonref = (*node_id).clone();
 695                                 let mut msg_nonref = (*msg).clone();
 696                                 MessageSendEvent::SendRevokeAndACK {
 697                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 698                                         msg: crate::ln::msgs::RevokeAndACK { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 699                                 }
 700                         },
 701                         nativeMessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => {
 702                                 let mut node_id_nonref = (*node_id).clone();
 703                                 let mut msg_nonref = (*msg).clone();
 704                                 MessageSendEvent::SendClosingSigned {
 705                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 706                                         msg: crate::ln::msgs::ClosingSigned { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 707                                 }
 708                         },
 709                         nativeMessageSendEvent::SendShutdown {ref node_id, ref msg, } => {
 710                                 let mut node_id_nonref = (*node_id).clone();
 711                                 let mut msg_nonref = (*msg).clone();
 712                                 MessageSendEvent::SendShutdown {
 713                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 714                                         msg: crate::ln::msgs::Shutdown { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 715                                 }
 716                         },
 717                         nativeMessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => {
 718                                 let mut node_id_nonref = (*node_id).clone();
 719                                 let mut msg_nonref = (*msg).clone();
 720                                 MessageSendEvent::SendChannelReestablish {
 721                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 722                                         msg: crate::ln::msgs::ChannelReestablish { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 723                                 }
 724                         },
 725                         nativeMessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => {
 726                                 let mut msg_nonref = (*msg).clone();
 727                                 let mut update_msg_nonref = (*update_msg).clone();
 728                                 MessageSendEvent::BroadcastChannelAnnouncement {
 729                                         msg: crate::ln::msgs::ChannelAnnouncement { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 730                                         update_msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(update_msg_nonref)), is_owned: true },
 731                                 }
 732                         },
 733                         nativeMessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => {
 734                                 let mut msg_nonref = (*msg).clone();
 735                                 MessageSendEvent::BroadcastNodeAnnouncement {
 736                                         msg: crate::ln::msgs::NodeAnnouncement { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 737                                 }
 738                         },
 739                         nativeMessageSendEvent::BroadcastChannelUpdate {ref msg, } => {
 740                                 let mut msg_nonref = (*msg).clone();
 741                                 MessageSendEvent::BroadcastChannelUpdate {
 742                                         msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 743                                 }
 744                         },
 745                         nativeMessageSendEvent::HandleError {ref node_id, ref action, } => {
 746                                 let mut node_id_nonref = (*node_id).clone();
 747                                 let mut action_nonref = (*action).clone();
 748                                 MessageSendEvent::HandleError {
 749                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 750                                         action: crate::ln::msgs::ErrorAction::native_into(action_nonref),
 751                                 }
 752                         },
 753                         nativeMessageSendEvent::PaymentFailureNetworkUpdate {ref update, } => {
 754                                 let mut update_nonref = (*update).clone();
 755                                 MessageSendEvent::PaymentFailureNetworkUpdate {
 756                                         update: crate::ln::msgs::HTLCFailChannelUpdate::native_into(update_nonref),
 757                                 }
 758                         },
 759                 }
 760         }
 761         #[allow(unused)]
 762         pub(crate) fn native_into(native: nativeMessageSendEvent) -> Self {
 763                 match native {
 764                         nativeMessageSendEvent::SendAcceptChannel {mut node_id, mut msg, } => {
 765                                 MessageSendEvent::SendAcceptChannel {
 766                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 767                                         msg: crate::ln::msgs::AcceptChannel { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 768                                 }
 769                         },
 770                         nativeMessageSendEvent::SendOpenChannel {mut node_id, mut msg, } => {
 771                                 MessageSendEvent::SendOpenChannel {
 772                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 773                                         msg: crate::ln::msgs::OpenChannel { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 774                                 }
 775                         },
 776                         nativeMessageSendEvent::SendFundingCreated {mut node_id, mut msg, } => {
 777                                 MessageSendEvent::SendFundingCreated {
 778                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 779                                         msg: crate::ln::msgs::FundingCreated { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 780                                 }
 781                         },
 782                         nativeMessageSendEvent::SendFundingSigned {mut node_id, mut msg, } => {
 783                                 MessageSendEvent::SendFundingSigned {
 784                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 785                                         msg: crate::ln::msgs::FundingSigned { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 786                                 }
 787                         },
 788                         nativeMessageSendEvent::SendFundingLocked {mut node_id, mut msg, } => {
 789                                 MessageSendEvent::SendFundingLocked {
 790                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 791                                         msg: crate::ln::msgs::FundingLocked { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 792                                 }
 793                         },
 794                         nativeMessageSendEvent::SendAnnouncementSignatures {mut node_id, mut msg, } => {
 795                                 MessageSendEvent::SendAnnouncementSignatures {
 796                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 797                                         msg: crate::ln::msgs::AnnouncementSignatures { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 798                                 }
 799                         },
 800                         nativeMessageSendEvent::UpdateHTLCs {mut node_id, mut updates, } => {
 801                                 MessageSendEvent::UpdateHTLCs {
 802                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 803                                         updates: crate::ln::msgs::CommitmentUpdate { inner: Box::into_raw(Box::new(updates)), is_owned: true },
 804                                 }
 805                         },
 806                         nativeMessageSendEvent::SendRevokeAndACK {mut node_id, mut msg, } => {
 807                                 MessageSendEvent::SendRevokeAndACK {
 808                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 809                                         msg: crate::ln::msgs::RevokeAndACK { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 810                                 }
 811                         },
 812                         nativeMessageSendEvent::SendClosingSigned {mut node_id, mut msg, } => {
 813                                 MessageSendEvent::SendClosingSigned {
 814                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 815                                         msg: crate::ln::msgs::ClosingSigned { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 816                                 }
 817                         },
 818                         nativeMessageSendEvent::SendShutdown {mut node_id, mut msg, } => {
 819                                 MessageSendEvent::SendShutdown {
 820                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 821                                         msg: crate::ln::msgs::Shutdown { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 822                                 }
 823                         },
 824                         nativeMessageSendEvent::SendChannelReestablish {mut node_id, mut msg, } => {
 825                                 MessageSendEvent::SendChannelReestablish {
 826                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 827                                         msg: crate::ln::msgs::ChannelReestablish { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 828                                 }
 829                         },
 830                         nativeMessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => {
 831                                 MessageSendEvent::BroadcastChannelAnnouncement {
 832                                         msg: crate::ln::msgs::ChannelAnnouncement { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 833                                         update_msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(update_msg)), is_owned: true },
 834                                 }
 835                         },
 836                         nativeMessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => {
 837                                 MessageSendEvent::BroadcastNodeAnnouncement {
 838                                         msg: crate::ln::msgs::NodeAnnouncement { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 839                                 }
 840                         },
 841                         nativeMessageSendEvent::BroadcastChannelUpdate {mut msg, } => {
 842                                 MessageSendEvent::BroadcastChannelUpdate {
 843                                         msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 844                                 }
 845                         },
 846                         nativeMessageSendEvent::HandleError {mut node_id, mut action, } => {
 847                                 MessageSendEvent::HandleError {
 848                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 849                                         action: crate::ln::msgs::ErrorAction::native_into(action),
 850                                 }
 851                         },
 852                         nativeMessageSendEvent::PaymentFailureNetworkUpdate {mut update, } => {
 853                                 MessageSendEvent::PaymentFailureNetworkUpdate {
 854                                         update: crate::ln::msgs::HTLCFailChannelUpdate::native_into(update),
 855                                 }
 856                         },
 857                 }
 858         }
 859 }
 860 #[no_mangle]
 861 pub extern "C" fn MessageSendEvent_free(this_ptr: MessageSendEvent) { }
 862 /// A trait indicating an object may generate message send events
 863 #[repr(C)]
 864 pub struct MessageSendEventsProvider {
 865         pub this_arg: *mut c_void,
 866         /// Gets the list of pending events which were generated by previous actions, clearing the list
 867         /// in the process.
 868         #[must_use]
 869         pub get_and_clear_pending_msg_events: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_MessageSendEventZ,
 870         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 871 }
 872
 873 use lightning::util::events::MessageSendEventsProvider as rustMessageSendEventsProvider;
 874 impl rustMessageSendEventsProvider for MessageSendEventsProvider {
 875         fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {
 876                 let mut ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
 877                 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
 878                 local_ret
 879         }
 880 }
 881
 882 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 883 // directly as a Deref trait in higher-level structs:
 884 impl std::ops::Deref for MessageSendEventsProvider {
 885         type Target = Self;
 886         fn deref(&self) -> &Self {
 887                 self
 888         }
 889 }
 890 /// Calls the free function if one is set
 891 #[no_mangle]
 892 pub extern "C" fn MessageSendEventsProvider_free(this_ptr: MessageSendEventsProvider) { }
 893 impl Drop for MessageSendEventsProvider {
 894         fn drop(&mut self) {
 895                 if let Some(f) = self.free {
 896                         f(self.this_arg);
 897                 }
 898         }
 899 }
 900 /// A trait indicating an object may generate events
 901 #[repr(C)]
 902 pub struct EventsProvider {
 903         pub this_arg: *mut c_void,
 904         /// Gets the list of pending events which were generated by previous actions, clearing the list
 905         /// in the process.
 906         #[must_use]
 907         pub get_and_clear_pending_events: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_EventZ,
 908         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 909 }
 910
 911 use lightning::util::events::EventsProvider as rustEventsProvider;
 912 impl rustEventsProvider for EventsProvider {
 913         fn get_and_clear_pending_events(&self) -> Vec<lightning::util::events::Event> {
 914                 let mut ret = (self.get_and_clear_pending_events)(self.this_arg);
 915                 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
 916                 local_ret
 917         }
 918 }
 919
 920 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 921 // directly as a Deref trait in higher-level structs:
 922 impl std::ops::Deref for EventsProvider {
 923         type Target = Self;
 924         fn deref(&self) -> &Self {
 925                 self
 926         }
 927 }
 928 /// Calls the free function if one is set
 929 #[no_mangle]
 930 pub extern "C" fn EventsProvider_free(this_ptr: EventsProvider) { }
 931 impl Drop for EventsProvider {
 932         fn drop(&mut self) {
 933                 if let Some(f) = self.free {
 934                         f(self.this_arg);
 935                 }
 936         }
 937 }