_ 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 #[no_mangle]
 312 pub extern "C" fn Event_clone(orig: &Event) -> Event {
 313         orig.clone()
 314 }
 315 /// An event generated by ChannelManager which indicates a message should be sent to a peer (or
 316 /// broadcast to most peers).
 317 /// These events are handled by PeerManager::process_events if you are using a PeerManager.
 318 #[must_use]
 319 #[derive(Clone)]
 320 #[repr(C)]
 321 pub enum MessageSendEvent {
 322         /// Used to indicate that we've accepted a channel open and should send the accept_channel
 323         /// message provided to the given peer.
 324         SendAcceptChannel {
 325                 node_id: crate::c_types::PublicKey,
 326                 msg: crate::ln::msgs::AcceptChannel,
 327         },
 328         /// Used to indicate that we've initiated a channel open and should send the open_channel
 329         /// message provided to the given peer.
 330         SendOpenChannel {
 331                 node_id: crate::c_types::PublicKey,
 332                 msg: crate::ln::msgs::OpenChannel,
 333         },
 334         /// Used to indicate that a funding_created message should be sent to the peer with the given node_id.
 335         SendFundingCreated {
 336                 node_id: crate::c_types::PublicKey,
 337                 msg: crate::ln::msgs::FundingCreated,
 338         },
 339         /// Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
 340         SendFundingSigned {
 341                 node_id: crate::c_types::PublicKey,
 342                 msg: crate::ln::msgs::FundingSigned,
 343         },
 344         /// Used to indicate that a funding_locked message should be sent to the peer with the given node_id.
 345         SendFundingLocked {
 346                 node_id: crate::c_types::PublicKey,
 347                 msg: crate::ln::msgs::FundingLocked,
 348         },
 349         /// Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
 350         SendAnnouncementSignatures {
 351                 node_id: crate::c_types::PublicKey,
 352                 msg: crate::ln::msgs::AnnouncementSignatures,
 353         },
 354         /// Used to indicate that a series of HTLC update messages, as well as a commitment_signed
 355         /// message should be sent to the peer with the given node_id.
 356         UpdateHTLCs {
 357                 node_id: crate::c_types::PublicKey,
 358                 updates: crate::ln::msgs::CommitmentUpdate,
 359         },
 360         /// Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
 361         SendRevokeAndACK {
 362                 node_id: crate::c_types::PublicKey,
 363                 msg: crate::ln::msgs::RevokeAndACK,
 364         },
 365         /// Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
 366         SendClosingSigned {
 367                 node_id: crate::c_types::PublicKey,
 368                 msg: crate::ln::msgs::ClosingSigned,
 369         },
 370         /// Used to indicate that a shutdown message should be sent to the peer with the given node_id.
 371         SendShutdown {
 372                 node_id: crate::c_types::PublicKey,
 373                 msg: crate::ln::msgs::Shutdown,
 374         },
 375         /// Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
 376         SendChannelReestablish {
 377                 node_id: crate::c_types::PublicKey,
 378                 msg: crate::ln::msgs::ChannelReestablish,
 379         },
 380         /// Used to indicate that a channel_announcement and channel_update should be broadcast to all
 381         /// peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
 382         ///
 383         /// Note that after doing so, you very likely (unless you did so very recently) want to call
 384         /// ChannelManager::broadcast_node_announcement to trigger a BroadcastNodeAnnouncement event.
 385         /// This ensures that any nodes which see our channel_announcement also have a relevant
 386         /// node_announcement, including relevant feature flags which may be important for routing
 387         /// through or to us.
 388         BroadcastChannelAnnouncement {
 389                 msg: crate::ln::msgs::ChannelAnnouncement,
 390                 update_msg: crate::ln::msgs::ChannelUpdate,
 391         },
 392         /// Used to indicate that a node_announcement should be broadcast to all peers.
 393         BroadcastNodeAnnouncement {
 394                 msg: crate::ln::msgs::NodeAnnouncement,
 395         },
 396         /// Used to indicate that a channel_update should be broadcast to all peers.
 397         BroadcastChannelUpdate {
 398                 msg: crate::ln::msgs::ChannelUpdate,
 399         },
 400         /// Broadcast an error downstream to be handled
 401         HandleError {
 402                 node_id: crate::c_types::PublicKey,
 403                 action: crate::ln::msgs::ErrorAction,
 404         },
 405         /// When a payment fails we may receive updates back from the hop where it failed. In such
 406         /// cases this event is generated so that we can inform the network graph of this information.
 407         PaymentFailureNetworkUpdate {
 408                 update: crate::ln::msgs::HTLCFailChannelUpdate,
 409         },
 410 }
 411 use lightning::util::events::MessageSendEvent as nativeMessageSendEvent;
 412 impl MessageSendEvent {
 413         #[allow(unused)]
 414         pub(crate) fn to_native(&self) -> nativeMessageSendEvent {
 415                 match self {
 416                         MessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => {
 417                                 let mut node_id_nonref = (*node_id).clone();
 418                                 let mut msg_nonref = (*msg).clone();
 419                                 nativeMessageSendEvent::SendAcceptChannel {
 420                                         node_id: node_id_nonref.into_rust(),
 421                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 422                                 }
 423                         },
 424                         MessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => {
 425                                 let mut node_id_nonref = (*node_id).clone();
 426                                 let mut msg_nonref = (*msg).clone();
 427                                 nativeMessageSendEvent::SendOpenChannel {
 428                                         node_id: node_id_nonref.into_rust(),
 429                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 430                                 }
 431                         },
 432                         MessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => {
 433                                 let mut node_id_nonref = (*node_id).clone();
 434                                 let mut msg_nonref = (*msg).clone();
 435                                 nativeMessageSendEvent::SendFundingCreated {
 436                                         node_id: node_id_nonref.into_rust(),
 437                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 438                                 }
 439                         },
 440                         MessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => {
 441                                 let mut node_id_nonref = (*node_id).clone();
 442                                 let mut msg_nonref = (*msg).clone();
 443                                 nativeMessageSendEvent::SendFundingSigned {
 444                                         node_id: node_id_nonref.into_rust(),
 445                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 446                                 }
 447                         },
 448                         MessageSendEvent::SendFundingLocked {ref node_id, ref msg, } => {
 449                                 let mut node_id_nonref = (*node_id).clone();
 450                                 let mut msg_nonref = (*msg).clone();
 451                                 nativeMessageSendEvent::SendFundingLocked {
 452                                         node_id: node_id_nonref.into_rust(),
 453                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 454                                 }
 455                         },
 456                         MessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => {
 457                                 let mut node_id_nonref = (*node_id).clone();
 458                                 let mut msg_nonref = (*msg).clone();
 459                                 nativeMessageSendEvent::SendAnnouncementSignatures {
 460                                         node_id: node_id_nonref.into_rust(),
 461                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 462                                 }
 463                         },
 464                         MessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => {
 465                                 let mut node_id_nonref = (*node_id).clone();
 466                                 let mut updates_nonref = (*updates).clone();
 467                                 nativeMessageSendEvent::UpdateHTLCs {
 468                                         node_id: node_id_nonref.into_rust(),
 469                                         updates: *unsafe { Box::from_raw(updates_nonref.take_ptr()) },
 470                                 }
 471                         },
 472                         MessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => {
 473                                 let mut node_id_nonref = (*node_id).clone();
 474                                 let mut msg_nonref = (*msg).clone();
 475                                 nativeMessageSendEvent::SendRevokeAndACK {
 476                                         node_id: node_id_nonref.into_rust(),
 477                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 478                                 }
 479                         },
 480                         MessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => {
 481                                 let mut node_id_nonref = (*node_id).clone();
 482                                 let mut msg_nonref = (*msg).clone();
 483                                 nativeMessageSendEvent::SendClosingSigned {
 484                                         node_id: node_id_nonref.into_rust(),
 485                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 486                                 }
 487                         },
 488                         MessageSendEvent::SendShutdown {ref node_id, ref msg, } => {
 489                                 let mut node_id_nonref = (*node_id).clone();
 490                                 let mut msg_nonref = (*msg).clone();
 491                                 nativeMessageSendEvent::SendShutdown {
 492                                         node_id: node_id_nonref.into_rust(),
 493                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 494                                 }
 495                         },
 496                         MessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => {
 497                                 let mut node_id_nonref = (*node_id).clone();
 498                                 let mut msg_nonref = (*msg).clone();
 499                                 nativeMessageSendEvent::SendChannelReestablish {
 500                                         node_id: node_id_nonref.into_rust(),
 501                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 502                                 }
 503                         },
 504                         MessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => {
 505                                 let mut msg_nonref = (*msg).clone();
 506                                 let mut update_msg_nonref = (*update_msg).clone();
 507                                 nativeMessageSendEvent::BroadcastChannelAnnouncement {
 508                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 509                                         update_msg: *unsafe { Box::from_raw(update_msg_nonref.take_ptr()) },
 510                                 }
 511                         },
 512                         MessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => {
 513                                 let mut msg_nonref = (*msg).clone();
 514                                 nativeMessageSendEvent::BroadcastNodeAnnouncement {
 515                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 516                                 }
 517                         },
 518                         MessageSendEvent::BroadcastChannelUpdate {ref msg, } => {
 519                                 let mut msg_nonref = (*msg).clone();
 520                                 nativeMessageSendEvent::BroadcastChannelUpdate {
 521                                         msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) },
 522                                 }
 523                         },
 524                         MessageSendEvent::HandleError {ref node_id, ref action, } => {
 525                                 let mut node_id_nonref = (*node_id).clone();
 526                                 let mut action_nonref = (*action).clone();
 527                                 nativeMessageSendEvent::HandleError {
 528                                         node_id: node_id_nonref.into_rust(),
 529                                         action: action_nonref.into_native(),
 530                                 }
 531                         },
 532                         MessageSendEvent::PaymentFailureNetworkUpdate {ref update, } => {
 533                                 let mut update_nonref = (*update).clone();
 534                                 nativeMessageSendEvent::PaymentFailureNetworkUpdate {
 535                                         update: update_nonref.into_native(),
 536                                 }
 537                         },
 538                 }
 539         }
 540         #[allow(unused)]
 541         pub(crate) fn into_native(self) -> nativeMessageSendEvent {
 542                 match self {
 543                         MessageSendEvent::SendAcceptChannel {mut node_id, mut msg, } => {
 544                                 nativeMessageSendEvent::SendAcceptChannel {
 545                                         node_id: node_id.into_rust(),
 546                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 547                                 }
 548                         },
 549                         MessageSendEvent::SendOpenChannel {mut node_id, mut msg, } => {
 550                                 nativeMessageSendEvent::SendOpenChannel {
 551                                         node_id: node_id.into_rust(),
 552                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 553                                 }
 554                         },
 555                         MessageSendEvent::SendFundingCreated {mut node_id, mut msg, } => {
 556                                 nativeMessageSendEvent::SendFundingCreated {
 557                                         node_id: node_id.into_rust(),
 558                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 559                                 }
 560                         },
 561                         MessageSendEvent::SendFundingSigned {mut node_id, mut msg, } => {
 562                                 nativeMessageSendEvent::SendFundingSigned {
 563                                         node_id: node_id.into_rust(),
 564                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 565                                 }
 566                         },
 567                         MessageSendEvent::SendFundingLocked {mut node_id, mut msg, } => {
 568                                 nativeMessageSendEvent::SendFundingLocked {
 569                                         node_id: node_id.into_rust(),
 570                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 571                                 }
 572                         },
 573                         MessageSendEvent::SendAnnouncementSignatures {mut node_id, mut msg, } => {
 574                                 nativeMessageSendEvent::SendAnnouncementSignatures {
 575                                         node_id: node_id.into_rust(),
 576                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 577                                 }
 578                         },
 579                         MessageSendEvent::UpdateHTLCs {mut node_id, mut updates, } => {
 580                                 nativeMessageSendEvent::UpdateHTLCs {
 581                                         node_id: node_id.into_rust(),
 582                                         updates: *unsafe { Box::from_raw(updates.take_ptr()) },
 583                                 }
 584                         },
 585                         MessageSendEvent::SendRevokeAndACK {mut node_id, mut msg, } => {
 586                                 nativeMessageSendEvent::SendRevokeAndACK {
 587                                         node_id: node_id.into_rust(),
 588                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 589                                 }
 590                         },
 591                         MessageSendEvent::SendClosingSigned {mut node_id, mut msg, } => {
 592                                 nativeMessageSendEvent::SendClosingSigned {
 593                                         node_id: node_id.into_rust(),
 594                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 595                                 }
 596                         },
 597                         MessageSendEvent::SendShutdown {mut node_id, mut msg, } => {
 598                                 nativeMessageSendEvent::SendShutdown {
 599                                         node_id: node_id.into_rust(),
 600                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 601                                 }
 602                         },
 603                         MessageSendEvent::SendChannelReestablish {mut node_id, mut msg, } => {
 604                                 nativeMessageSendEvent::SendChannelReestablish {
 605                                         node_id: node_id.into_rust(),
 606                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 607                                 }
 608                         },
 609                         MessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => {
 610                                 nativeMessageSendEvent::BroadcastChannelAnnouncement {
 611                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 612                                         update_msg: *unsafe { Box::from_raw(update_msg.take_ptr()) },
 613                                 }
 614                         },
 615                         MessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => {
 616                                 nativeMessageSendEvent::BroadcastNodeAnnouncement {
 617                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 618                                 }
 619                         },
 620                         MessageSendEvent::BroadcastChannelUpdate {mut msg, } => {
 621                                 nativeMessageSendEvent::BroadcastChannelUpdate {
 622                                         msg: *unsafe { Box::from_raw(msg.take_ptr()) },
 623                                 }
 624                         },
 625                         MessageSendEvent::HandleError {mut node_id, mut action, } => {
 626                                 nativeMessageSendEvent::HandleError {
 627                                         node_id: node_id.into_rust(),
 628                                         action: action.into_native(),
 629                                 }
 630                         },
 631                         MessageSendEvent::PaymentFailureNetworkUpdate {mut update, } => {
 632                                 nativeMessageSendEvent::PaymentFailureNetworkUpdate {
 633                                         update: update.into_native(),
 634                                 }
 635                         },
 636                 }
 637         }
 638         #[allow(unused)]
 639         pub(crate) fn from_native(native: &nativeMessageSendEvent) -> Self {
 640                 match native {
 641                         nativeMessageSendEvent::SendAcceptChannel {ref node_id, ref msg, } => {
 642                                 let mut node_id_nonref = (*node_id).clone();
 643                                 let mut msg_nonref = (*msg).clone();
 644                                 MessageSendEvent::SendAcceptChannel {
 645                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 646                                         msg: crate::ln::msgs::AcceptChannel { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 647                                 }
 648                         },
 649                         nativeMessageSendEvent::SendOpenChannel {ref node_id, ref msg, } => {
 650                                 let mut node_id_nonref = (*node_id).clone();
 651                                 let mut msg_nonref = (*msg).clone();
 652                                 MessageSendEvent::SendOpenChannel {
 653                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 654                                         msg: crate::ln::msgs::OpenChannel { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 655                                 }
 656                         },
 657                         nativeMessageSendEvent::SendFundingCreated {ref node_id, ref msg, } => {
 658                                 let mut node_id_nonref = (*node_id).clone();
 659                                 let mut msg_nonref = (*msg).clone();
 660                                 MessageSendEvent::SendFundingCreated {
 661                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 662                                         msg: crate::ln::msgs::FundingCreated { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 663                                 }
 664                         },
 665                         nativeMessageSendEvent::SendFundingSigned {ref node_id, ref msg, } => {
 666                                 let mut node_id_nonref = (*node_id).clone();
 667                                 let mut msg_nonref = (*msg).clone();
 668                                 MessageSendEvent::SendFundingSigned {
 669                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 670                                         msg: crate::ln::msgs::FundingSigned { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 671                                 }
 672                         },
 673                         nativeMessageSendEvent::SendFundingLocked {ref node_id, ref msg, } => {
 674                                 let mut node_id_nonref = (*node_id).clone();
 675                                 let mut msg_nonref = (*msg).clone();
 676                                 MessageSendEvent::SendFundingLocked {
 677                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 678                                         msg: crate::ln::msgs::FundingLocked { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 679                                 }
 680                         },
 681                         nativeMessageSendEvent::SendAnnouncementSignatures {ref node_id, ref msg, } => {
 682                                 let mut node_id_nonref = (*node_id).clone();
 683                                 let mut msg_nonref = (*msg).clone();
 684                                 MessageSendEvent::SendAnnouncementSignatures {
 685                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 686                                         msg: crate::ln::msgs::AnnouncementSignatures { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 687                                 }
 688                         },
 689                         nativeMessageSendEvent::UpdateHTLCs {ref node_id, ref updates, } => {
 690                                 let mut node_id_nonref = (*node_id).clone();
 691                                 let mut updates_nonref = (*updates).clone();
 692                                 MessageSendEvent::UpdateHTLCs {
 693                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 694                                         updates: crate::ln::msgs::CommitmentUpdate { inner: Box::into_raw(Box::new(updates_nonref)), is_owned: true },
 695                                 }
 696                         },
 697                         nativeMessageSendEvent::SendRevokeAndACK {ref node_id, ref msg, } => {
 698                                 let mut node_id_nonref = (*node_id).clone();
 699                                 let mut msg_nonref = (*msg).clone();
 700                                 MessageSendEvent::SendRevokeAndACK {
 701                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 702                                         msg: crate::ln::msgs::RevokeAndACK { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 703                                 }
 704                         },
 705                         nativeMessageSendEvent::SendClosingSigned {ref node_id, ref msg, } => {
 706                                 let mut node_id_nonref = (*node_id).clone();
 707                                 let mut msg_nonref = (*msg).clone();
 708                                 MessageSendEvent::SendClosingSigned {
 709                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 710                                         msg: crate::ln::msgs::ClosingSigned { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 711                                 }
 712                         },
 713                         nativeMessageSendEvent::SendShutdown {ref node_id, ref msg, } => {
 714                                 let mut node_id_nonref = (*node_id).clone();
 715                                 let mut msg_nonref = (*msg).clone();
 716                                 MessageSendEvent::SendShutdown {
 717                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 718                                         msg: crate::ln::msgs::Shutdown { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 719                                 }
 720                         },
 721                         nativeMessageSendEvent::SendChannelReestablish {ref node_id, ref msg, } => {
 722                                 let mut node_id_nonref = (*node_id).clone();
 723                                 let mut msg_nonref = (*msg).clone();
 724                                 MessageSendEvent::SendChannelReestablish {
 725                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 726                                         msg: crate::ln::msgs::ChannelReestablish { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 727                                 }
 728                         },
 729                         nativeMessageSendEvent::BroadcastChannelAnnouncement {ref msg, ref update_msg, } => {
 730                                 let mut msg_nonref = (*msg).clone();
 731                                 let mut update_msg_nonref = (*update_msg).clone();
 732                                 MessageSendEvent::BroadcastChannelAnnouncement {
 733                                         msg: crate::ln::msgs::ChannelAnnouncement { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 734                                         update_msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(update_msg_nonref)), is_owned: true },
 735                                 }
 736                         },
 737                         nativeMessageSendEvent::BroadcastNodeAnnouncement {ref msg, } => {
 738                                 let mut msg_nonref = (*msg).clone();
 739                                 MessageSendEvent::BroadcastNodeAnnouncement {
 740                                         msg: crate::ln::msgs::NodeAnnouncement { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 741                                 }
 742                         },
 743                         nativeMessageSendEvent::BroadcastChannelUpdate {ref msg, } => {
 744                                 let mut msg_nonref = (*msg).clone();
 745                                 MessageSendEvent::BroadcastChannelUpdate {
 746                                         msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg_nonref)), is_owned: true },
 747                                 }
 748                         },
 749                         nativeMessageSendEvent::HandleError {ref node_id, ref action, } => {
 750                                 let mut node_id_nonref = (*node_id).clone();
 751                                 let mut action_nonref = (*action).clone();
 752                                 MessageSendEvent::HandleError {
 753                                         node_id: crate::c_types::PublicKey::from_rust(&node_id_nonref),
 754                                         action: crate::ln::msgs::ErrorAction::native_into(action_nonref),
 755                                 }
 756                         },
 757                         nativeMessageSendEvent::PaymentFailureNetworkUpdate {ref update, } => {
 758                                 let mut update_nonref = (*update).clone();
 759                                 MessageSendEvent::PaymentFailureNetworkUpdate {
 760                                         update: crate::ln::msgs::HTLCFailChannelUpdate::native_into(update_nonref),
 761                                 }
 762                         },
 763                 }
 764         }
 765         #[allow(unused)]
 766         pub(crate) fn native_into(native: nativeMessageSendEvent) -> Self {
 767                 match native {
 768                         nativeMessageSendEvent::SendAcceptChannel {mut node_id, mut msg, } => {
 769                                 MessageSendEvent::SendAcceptChannel {
 770                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 771                                         msg: crate::ln::msgs::AcceptChannel { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 772                                 }
 773                         },
 774                         nativeMessageSendEvent::SendOpenChannel {mut node_id, mut msg, } => {
 775                                 MessageSendEvent::SendOpenChannel {
 776                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 777                                         msg: crate::ln::msgs::OpenChannel { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 778                                 }
 779                         },
 780                         nativeMessageSendEvent::SendFundingCreated {mut node_id, mut msg, } => {
 781                                 MessageSendEvent::SendFundingCreated {
 782                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 783                                         msg: crate::ln::msgs::FundingCreated { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 784                                 }
 785                         },
 786                         nativeMessageSendEvent::SendFundingSigned {mut node_id, mut msg, } => {
 787                                 MessageSendEvent::SendFundingSigned {
 788                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 789                                         msg: crate::ln::msgs::FundingSigned { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 790                                 }
 791                         },
 792                         nativeMessageSendEvent::SendFundingLocked {mut node_id, mut msg, } => {
 793                                 MessageSendEvent::SendFundingLocked {
 794                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 795                                         msg: crate::ln::msgs::FundingLocked { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 796                                 }
 797                         },
 798                         nativeMessageSendEvent::SendAnnouncementSignatures {mut node_id, mut msg, } => {
 799                                 MessageSendEvent::SendAnnouncementSignatures {
 800                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 801                                         msg: crate::ln::msgs::AnnouncementSignatures { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 802                                 }
 803                         },
 804                         nativeMessageSendEvent::UpdateHTLCs {mut node_id, mut updates, } => {
 805                                 MessageSendEvent::UpdateHTLCs {
 806                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 807                                         updates: crate::ln::msgs::CommitmentUpdate { inner: Box::into_raw(Box::new(updates)), is_owned: true },
 808                                 }
 809                         },
 810                         nativeMessageSendEvent::SendRevokeAndACK {mut node_id, mut msg, } => {
 811                                 MessageSendEvent::SendRevokeAndACK {
 812                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 813                                         msg: crate::ln::msgs::RevokeAndACK { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 814                                 }
 815                         },
 816                         nativeMessageSendEvent::SendClosingSigned {mut node_id, mut msg, } => {
 817                                 MessageSendEvent::SendClosingSigned {
 818                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 819                                         msg: crate::ln::msgs::ClosingSigned { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 820                                 }
 821                         },
 822                         nativeMessageSendEvent::SendShutdown {mut node_id, mut msg, } => {
 823                                 MessageSendEvent::SendShutdown {
 824                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 825                                         msg: crate::ln::msgs::Shutdown { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 826                                 }
 827                         },
 828                         nativeMessageSendEvent::SendChannelReestablish {mut node_id, mut msg, } => {
 829                                 MessageSendEvent::SendChannelReestablish {
 830                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 831                                         msg: crate::ln::msgs::ChannelReestablish { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 832                                 }
 833                         },
 834                         nativeMessageSendEvent::BroadcastChannelAnnouncement {mut msg, mut update_msg, } => {
 835                                 MessageSendEvent::BroadcastChannelAnnouncement {
 836                                         msg: crate::ln::msgs::ChannelAnnouncement { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 837                                         update_msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(update_msg)), is_owned: true },
 838                                 }
 839                         },
 840                         nativeMessageSendEvent::BroadcastNodeAnnouncement {mut msg, } => {
 841                                 MessageSendEvent::BroadcastNodeAnnouncement {
 842                                         msg: crate::ln::msgs::NodeAnnouncement { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 843                                 }
 844                         },
 845                         nativeMessageSendEvent::BroadcastChannelUpdate {mut msg, } => {
 846                                 MessageSendEvent::BroadcastChannelUpdate {
 847                                         msg: crate::ln::msgs::ChannelUpdate { inner: Box::into_raw(Box::new(msg)), is_owned: true },
 848                                 }
 849                         },
 850                         nativeMessageSendEvent::HandleError {mut node_id, mut action, } => {
 851                                 MessageSendEvent::HandleError {
 852                                         node_id: crate::c_types::PublicKey::from_rust(&node_id),
 853                                         action: crate::ln::msgs::ErrorAction::native_into(action),
 854                                 }
 855                         },
 856                         nativeMessageSendEvent::PaymentFailureNetworkUpdate {mut update, } => {
 857                                 MessageSendEvent::PaymentFailureNetworkUpdate {
 858                                         update: crate::ln::msgs::HTLCFailChannelUpdate::native_into(update),
 859                                 }
 860                         },
 861                 }
 862         }
 863 }
 864 #[no_mangle]
 865 pub extern "C" fn MessageSendEvent_free(this_ptr: MessageSendEvent) { }
 866 #[no_mangle]
 867 pub extern "C" fn MessageSendEvent_clone(orig: &MessageSendEvent) -> MessageSendEvent {
 868         orig.clone()
 869 }
 870 /// A trait indicating an object may generate message send events
 871 #[repr(C)]
 872 pub struct MessageSendEventsProvider {
 873         pub this_arg: *mut c_void,
 874         /// Gets the list of pending events which were generated by previous actions, clearing the list
 875         /// in the process.
 876         #[must_use]
 877         pub get_and_clear_pending_msg_events: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_MessageSendEventZ,
 878         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 879 }
 880
 881 use lightning::util::events::MessageSendEventsProvider as rustMessageSendEventsProvider;
 882 impl rustMessageSendEventsProvider for MessageSendEventsProvider {
 883         fn get_and_clear_pending_msg_events(&self) -> Vec<lightning::util::events::MessageSendEvent> {
 884                 let mut ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
 885                 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
 886                 local_ret
 887         }
 888 }
 889
 890 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 891 // directly as a Deref trait in higher-level structs:
 892 impl std::ops::Deref for MessageSendEventsProvider {
 893         type Target = Self;
 894         fn deref(&self) -> &Self {
 895                 self
 896         }
 897 }
 898 /// Calls the free function if one is set
 899 #[no_mangle]
 900 pub extern "C" fn MessageSendEventsProvider_free(this_ptr: MessageSendEventsProvider) { }
 901 impl Drop for MessageSendEventsProvider {
 902         fn drop(&mut self) {
 903                 if let Some(f) = self.free {
 904                         f(self.this_arg);
 905                 }
 906         }
 907 }
 908 /// A trait indicating an object may generate events
 909 #[repr(C)]
 910 pub struct EventsProvider {
 911         pub this_arg: *mut c_void,
 912         /// Gets the list of pending events which were generated by previous actions, clearing the list
 913         /// in the process.
 914         #[must_use]
 915         pub get_and_clear_pending_events: extern "C" fn (this_arg: *const c_void) -> crate::c_types::derived::CVec_EventZ,
 916         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 917 }
 918
 919 use lightning::util::events::EventsProvider as rustEventsProvider;
 920 impl rustEventsProvider for EventsProvider {
 921         fn get_and_clear_pending_events(&self) -> Vec<lightning::util::events::Event> {
 922                 let mut ret = (self.get_and_clear_pending_events)(self.this_arg);
 923                 let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { item.into_native() }); };
 924                 local_ret
 925         }
 926 }
 927
 928 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 929 // directly as a Deref trait in higher-level structs:
 930 impl std::ops::Deref for EventsProvider {
 931         type Target = Self;
 932         fn deref(&self) -> &Self {
 933                 self
 934         }
 935 }
 936 /// Calls the free function if one is set
 937 #[no_mangle]
 938 pub extern "C" fn EventsProvider_free(this_ptr: EventsProvider) { }
 939 impl Drop for EventsProvider {
 940         fn drop(&mut self) {
 941                 if let Some(f) = self.free {
 942                         f(self.this_arg);
 943                 }
 944         }
 945 }