_ Git - rust-lightning/blob - lightning-c-bindings/src/chain/channelmonitor.rs

   1 //! The logic to monitor for on-chain transactions and create the relevant claim responses lives
   2 //! here.
   3 //!
   4 //! ChannelMonitor objects are generated by ChannelManager in response to relevant
   5 //! messages/actions, and MUST be persisted to disk (and, preferably, remotely) before progress can
   6 //! be made in responding to certain messages, see [`chain::Watch`] for more.
   7 //!
   8 //! Note that ChannelMonitors are an important part of the lightning trust model and a copy of the
   9 //! latest ChannelMonitor must always be actively monitoring for chain updates (and no out-of-date
  10 //! ChannelMonitors should do so). Thus, if you're building rust-lightning into an HSM or other
  11 //! security-domain-separated system design, you should consider having multiple paths for
  12 //! ChannelMonitors to get out of the HSM and onto monitoring devices.
  13 //!
  14 //! [`chain::Watch`]: ../trait.Watch.html
  15
  16 use std::ffi::c_void;
  17 use bitcoin::hashes::Hash;
  18 use crate::c_types::*;
  19
  20
  21 use lightning::chain::channelmonitor::ChannelMonitorUpdate as nativeChannelMonitorUpdateImport;
  22 type nativeChannelMonitorUpdate = nativeChannelMonitorUpdateImport;
  23
  24 /// An update generated by the underlying Channel itself which contains some new information the
  25 /// ChannelMonitor should be made aware of.
  26 #[must_use]
  27 #[repr(C)]
  28 pub struct ChannelMonitorUpdate {
  29         /// Nearly everywhere, inner must be non-null, however in places where
  30         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
  31         pub inner: *mut nativeChannelMonitorUpdate,
  32         pub is_owned: bool,
  33 }
  34
  35 impl Drop for ChannelMonitorUpdate {
  36         fn drop(&mut self) {
  37                 if self.is_owned && !self.inner.is_null() {
  38                         let _ = unsafe { Box::from_raw(self.inner) };
  39                 }
  40         }
  41 }
  42 #[no_mangle]
  43 pub extern "C" fn ChannelMonitorUpdate_free(this_ptr: ChannelMonitorUpdate) { }
  44 #[allow(unused)]
  45 /// Used only if an object of this type is returned as a trait impl by a method
  46 extern "C" fn ChannelMonitorUpdate_free_void(this_ptr: *mut c_void) {
  47         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelMonitorUpdate); }
  48 }
  49 #[allow(unused)]
  50 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
  51 impl ChannelMonitorUpdate {
  52         pub(crate) fn take_inner(mut self) -> *mut nativeChannelMonitorUpdate {
  53                 assert!(self.is_owned);
  54                 let ret = self.inner;
  55                 self.inner = std::ptr::null_mut();
  56                 ret
  57         }
  58 }
  59 /// The sequence number of this update. Updates *must* be replayed in-order according to this
  60 /// sequence number (and updates may panic if they are not). The update_id values are strictly
  61 /// increasing and increase by one for each new update, with one exception specified below.
  62 ///
  63 /// This sequence number is also used to track up to which points updates which returned
  64 /// ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given
  65 /// ChannelMonitor when ChannelManager::channel_monitor_updated is called.
  66 ///
  67 /// The only instance where update_id values are not strictly increasing is the case where we
  68 /// allow post-force-close updates with a special update ID of [`CLOSED_CHANNEL_UPDATE_ID`]. See
  69 /// its docs for more details.
  70 ///
  71 /// [`CLOSED_CHANNEL_UPDATE_ID`]: constant.CLOSED_CHANNEL_UPDATE_ID.html
  72 #[no_mangle]
  73 pub extern "C" fn ChannelMonitorUpdate_get_update_id(this_ptr: &ChannelMonitorUpdate) -> u64 {
  74         let mut inner_val = &mut unsafe { &mut *this_ptr.inner }.update_id;
  75         (*inner_val)
  76 }
  77 /// The sequence number of this update. Updates *must* be replayed in-order according to this
  78 /// sequence number (and updates may panic if they are not). The update_id values are strictly
  79 /// increasing and increase by one for each new update, with one exception specified below.
  80 ///
  81 /// This sequence number is also used to track up to which points updates which returned
  82 /// ChannelMonitorUpdateErr::TemporaryFailure have been applied to all copies of a given
  83 /// ChannelMonitor when ChannelManager::channel_monitor_updated is called.
  84 ///
  85 /// The only instance where update_id values are not strictly increasing is the case where we
  86 /// allow post-force-close updates with a special update ID of [`CLOSED_CHANNEL_UPDATE_ID`]. See
  87 /// its docs for more details.
  88 ///
  89 /// [`CLOSED_CHANNEL_UPDATE_ID`]: constant.CLOSED_CHANNEL_UPDATE_ID.html
  90 #[no_mangle]
  91 pub extern "C" fn ChannelMonitorUpdate_set_update_id(this_ptr: &mut ChannelMonitorUpdate, mut val: u64) {
  92         unsafe { &mut *this_ptr.inner }.update_id = val;
  93 }
  94 impl Clone for ChannelMonitorUpdate {
  95         fn clone(&self) -> Self {
  96                 Self {
  97                         inner: if self.inner.is_null() { std::ptr::null_mut() } else {
  98                                 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
  99                         is_owned: true,
 100                 }
 101         }
 102 }
 103 #[allow(unused)]
 104 /// Used only if an object of this type is returned as a trait impl by a method
 105 pub(crate) extern "C" fn ChannelMonitorUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void {
 106         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelMonitorUpdate)).clone() })) as *mut c_void
 107 }
 108 #[no_mangle]
 109 pub extern "C" fn ChannelMonitorUpdate_clone(orig: &ChannelMonitorUpdate) -> ChannelMonitorUpdate {
 110         orig.clone()
 111 }
 112
 113 #[no_mangle]
 114 pub static CLOSED_CHANNEL_UPDATE_ID: u64 = lightning::chain::channelmonitor::CLOSED_CHANNEL_UPDATE_ID;
 115 #[no_mangle]
 116 pub extern "C" fn ChannelMonitorUpdate_write(obj: &ChannelMonitorUpdate) -> crate::c_types::derived::CVec_u8Z {
 117         crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
 118 }
 119 #[no_mangle]
 120 pub(crate) extern "C" fn ChannelMonitorUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 121         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelMonitorUpdate) })
 122 }
 123 #[no_mangle]
 124 pub extern "C" fn ChannelMonitorUpdate_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChannelMonitorUpdateDecodeErrorZ {
 125         let res = crate::c_types::deserialize_obj(ser);
 126         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::chain::channelmonitor::ChannelMonitorUpdate { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
 127         local_res
 128 }
 129 /// An error enum representing a failure to persist a channel monitor update.
 130 #[must_use]
 131 #[derive(Clone)]
 132 #[repr(C)]
 133 pub enum ChannelMonitorUpdateErr {
 134         /// Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
 135         /// our state failed, but is expected to succeed at some point in the future).
 136         ///
 137         /// Such a failure will \"freeze\" a channel, preventing us from revoking old states or
 138         /// submitting new commitment transactions to the counterparty. Once the update(s) which failed
 139         /// have been successfully applied, ChannelManager::channel_monitor_updated can be used to
 140         /// restore the channel to an operational state.
 141         ///
 142         /// Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
 143         /// you return a TemporaryFailure you must ensure that it is written to disk safely before
 144         /// writing out the latest ChannelManager state.
 145         ///
 146         /// Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
 147         /// (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
 148         /// to claim it on this channel) and those updates must be applied wherever they can be. At
 149         /// least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
 150         /// be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
 151         /// the channel which would invalidate previous ChannelMonitors are not made when a channel has
 152         /// been \"frozen\".
 153         ///
 154         /// Note that even if updates made after TemporaryFailure succeed you must still call
 155         /// channel_monitor_updated to ensure you have the latest monitor and re-enable normal channel
 156         /// operation.
 157         ///
 158         /// Note that the update being processed here will not be replayed for you when you call
 159         /// ChannelManager::channel_monitor_updated, so you must store the update itself along
 160         /// with the persisted ChannelMonitor on your own local disk prior to returning a
 161         /// TemporaryFailure. You may, of course, employ a journaling approach, storing only the
 162         /// ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
 163         /// reload-time.
 164         ///
 165         /// For deployments where a copy of ChannelMonitors and other local state are backed up in a
 166         /// remote location (with local copies persisted immediately), it is anticipated that all
 167         /// updates will return TemporaryFailure until the remote copies could be updated.
 168         TemporaryFailure,
 169         /// Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
 170         /// different watchtower and cannot update with all watchtowers that were previously informed
 171         /// of this channel).
 172         ///
 173         /// At reception of this error, ChannelManager will force-close the channel and return at
 174         /// least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
 175         /// least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
 176         /// update must be rejected.
 177         ///
 178         /// This failure may also signal a failure to update the local persisted copy of one of
 179         /// the channel monitor instance.
 180         ///
 181         /// Note that even when you fail a holder commitment transaction update, you must store the
 182         /// update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
 183         /// broadcasts it (e.g distributed channel-monitor deployment)
 184         ///
 185         /// In case of distributed watchtowers deployment, the new version must be written to disk, as
 186         /// state may have been stored but rejected due to a block forcing a commitment broadcast. This
 187         /// storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
 188         /// lagging behind on block processing.
 189         PermanentFailure,
 190 }
 191 use lightning::chain::channelmonitor::ChannelMonitorUpdateErr as nativeChannelMonitorUpdateErr;
 192 impl ChannelMonitorUpdateErr {
 193         #[allow(unused)]
 194         pub(crate) fn to_native(&self) -> nativeChannelMonitorUpdateErr {
 195                 match self {
 196                         ChannelMonitorUpdateErr::TemporaryFailure => nativeChannelMonitorUpdateErr::TemporaryFailure,
 197                         ChannelMonitorUpdateErr::PermanentFailure => nativeChannelMonitorUpdateErr::PermanentFailure,
 198                 }
 199         }
 200         #[allow(unused)]
 201         pub(crate) fn into_native(self) -> nativeChannelMonitorUpdateErr {
 202                 match self {
 203                         ChannelMonitorUpdateErr::TemporaryFailure => nativeChannelMonitorUpdateErr::TemporaryFailure,
 204                         ChannelMonitorUpdateErr::PermanentFailure => nativeChannelMonitorUpdateErr::PermanentFailure,
 205                 }
 206         }
 207         #[allow(unused)]
 208         pub(crate) fn from_native(native: &nativeChannelMonitorUpdateErr) -> Self {
 209                 match native {
 210                         nativeChannelMonitorUpdateErr::TemporaryFailure => ChannelMonitorUpdateErr::TemporaryFailure,
 211                         nativeChannelMonitorUpdateErr::PermanentFailure => ChannelMonitorUpdateErr::PermanentFailure,
 212                 }
 213         }
 214         #[allow(unused)]
 215         pub(crate) fn native_into(native: nativeChannelMonitorUpdateErr) -> Self {
 216                 match native {
 217                         nativeChannelMonitorUpdateErr::TemporaryFailure => ChannelMonitorUpdateErr::TemporaryFailure,
 218                         nativeChannelMonitorUpdateErr::PermanentFailure => ChannelMonitorUpdateErr::PermanentFailure,
 219                 }
 220         }
 221 }
 222 #[no_mangle]
 223 pub extern "C" fn ChannelMonitorUpdateErr_clone(orig: &ChannelMonitorUpdateErr) -> ChannelMonitorUpdateErr {
 224         orig.clone()
 225 }
 226
 227 use lightning::chain::channelmonitor::MonitorUpdateError as nativeMonitorUpdateErrorImport;
 228 type nativeMonitorUpdateError = nativeMonitorUpdateErrorImport;
 229
 230 /// General Err type for ChannelMonitor actions. Generally, this implies that the data provided is
 231 /// inconsistent with the ChannelMonitor being called. eg for ChannelMonitor::update_monitor this
 232 /// means you tried to update a monitor for a different channel or the ChannelMonitorUpdate was
 233 /// corrupted.
 234 /// Contains a developer-readable error message.
 235 #[must_use]
 236 #[repr(C)]
 237 pub struct MonitorUpdateError {
 238         /// Nearly everywhere, inner must be non-null, however in places where
 239         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 240         pub inner: *mut nativeMonitorUpdateError,
 241         pub is_owned: bool,
 242 }
 243
 244 impl Drop for MonitorUpdateError {
 245         fn drop(&mut self) {
 246                 if self.is_owned && !self.inner.is_null() {
 247                         let _ = unsafe { Box::from_raw(self.inner) };
 248                 }
 249         }
 250 }
 251 #[no_mangle]
 252 pub extern "C" fn MonitorUpdateError_free(this_ptr: MonitorUpdateError) { }
 253 #[allow(unused)]
 254 /// Used only if an object of this type is returned as a trait impl by a method
 255 extern "C" fn MonitorUpdateError_free_void(this_ptr: *mut c_void) {
 256         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeMonitorUpdateError); }
 257 }
 258 #[allow(unused)]
 259 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 260 impl MonitorUpdateError {
 261         pub(crate) fn take_inner(mut self) -> *mut nativeMonitorUpdateError {
 262                 assert!(self.is_owned);
 263                 let ret = self.inner;
 264                 self.inner = std::ptr::null_mut();
 265                 ret
 266         }
 267 }
 268 impl Clone for MonitorUpdateError {
 269         fn clone(&self) -> Self {
 270                 Self {
 271                         inner: if self.inner.is_null() { std::ptr::null_mut() } else {
 272                                 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
 273                         is_owned: true,
 274                 }
 275         }
 276 }
 277 #[allow(unused)]
 278 /// Used only if an object of this type is returned as a trait impl by a method
 279 pub(crate) extern "C" fn MonitorUpdateError_clone_void(this_ptr: *const c_void) -> *mut c_void {
 280         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeMonitorUpdateError)).clone() })) as *mut c_void
 281 }
 282 #[no_mangle]
 283 pub extern "C" fn MonitorUpdateError_clone(orig: &MonitorUpdateError) -> MonitorUpdateError {
 284         orig.clone()
 285 }
 286
 287 use lightning::chain::channelmonitor::MonitorEvent as nativeMonitorEventImport;
 288 type nativeMonitorEvent = nativeMonitorEventImport;
 289
 290 /// An event to be processed by the ChannelManager.
 291 #[must_use]
 292 #[repr(C)]
 293 pub struct MonitorEvent {
 294         /// Nearly everywhere, inner must be non-null, however in places where
 295         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 296         pub inner: *mut nativeMonitorEvent,
 297         pub is_owned: bool,
 298 }
 299
 300 impl Drop for MonitorEvent {
 301         fn drop(&mut self) {
 302                 if self.is_owned && !self.inner.is_null() {
 303                         let _ = unsafe { Box::from_raw(self.inner) };
 304                 }
 305         }
 306 }
 307 #[no_mangle]
 308 pub extern "C" fn MonitorEvent_free(this_ptr: MonitorEvent) { }
 309 #[allow(unused)]
 310 /// Used only if an object of this type is returned as a trait impl by a method
 311 extern "C" fn MonitorEvent_free_void(this_ptr: *mut c_void) {
 312         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeMonitorEvent); }
 313 }
 314 #[allow(unused)]
 315 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 316 impl MonitorEvent {
 317         pub(crate) fn take_inner(mut self) -> *mut nativeMonitorEvent {
 318                 assert!(self.is_owned);
 319                 let ret = self.inner;
 320                 self.inner = std::ptr::null_mut();
 321                 ret
 322         }
 323 }
 324 impl Clone for MonitorEvent {
 325         fn clone(&self) -> Self {
 326                 Self {
 327                         inner: if self.inner.is_null() { std::ptr::null_mut() } else {
 328                                 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
 329                         is_owned: true,
 330                 }
 331         }
 332 }
 333 #[allow(unused)]
 334 /// Used only if an object of this type is returned as a trait impl by a method
 335 pub(crate) extern "C" fn MonitorEvent_clone_void(this_ptr: *const c_void) -> *mut c_void {
 336         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeMonitorEvent)).clone() })) as *mut c_void
 337 }
 338 #[no_mangle]
 339 pub extern "C" fn MonitorEvent_clone(orig: &MonitorEvent) -> MonitorEvent {
 340         orig.clone()
 341 }
 342
 343 use lightning::chain::channelmonitor::HTLCUpdate as nativeHTLCUpdateImport;
 344 type nativeHTLCUpdate = nativeHTLCUpdateImport;
 345
 346 /// Simple structure sent back by `chain::Watch` when an HTLC from a forward channel is detected on
 347 /// chain. Used to update the corresponding HTLC in the backward channel. Failing to pass the
 348 /// preimage claim backward will lead to loss of funds.
 349 ///
 350 /// [`chain::Watch`]: ../trait.Watch.html
 351 #[must_use]
 352 #[repr(C)]
 353 pub struct HTLCUpdate {
 354         /// Nearly everywhere, inner must be non-null, however in places where
 355         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 356         pub inner: *mut nativeHTLCUpdate,
 357         pub is_owned: bool,
 358 }
 359
 360 impl Drop for HTLCUpdate {
 361         fn drop(&mut self) {
 362                 if self.is_owned && !self.inner.is_null() {
 363                         let _ = unsafe { Box::from_raw(self.inner) };
 364                 }
 365         }
 366 }
 367 #[no_mangle]
 368 pub extern "C" fn HTLCUpdate_free(this_ptr: HTLCUpdate) { }
 369 #[allow(unused)]
 370 /// Used only if an object of this type is returned as a trait impl by a method
 371 extern "C" fn HTLCUpdate_free_void(this_ptr: *mut c_void) {
 372         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeHTLCUpdate); }
 373 }
 374 #[allow(unused)]
 375 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 376 impl HTLCUpdate {
 377         pub(crate) fn take_inner(mut self) -> *mut nativeHTLCUpdate {
 378                 assert!(self.is_owned);
 379                 let ret = self.inner;
 380                 self.inner = std::ptr::null_mut();
 381                 ret
 382         }
 383 }
 384 impl Clone for HTLCUpdate {
 385         fn clone(&self) -> Self {
 386                 Self {
 387                         inner: if self.inner.is_null() { std::ptr::null_mut() } else {
 388                                 Box::into_raw(Box::new(unsafe { &*self.inner }.clone())) },
 389                         is_owned: true,
 390                 }
 391         }
 392 }
 393 #[allow(unused)]
 394 /// Used only if an object of this type is returned as a trait impl by a method
 395 pub(crate) extern "C" fn HTLCUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void {
 396         Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeHTLCUpdate)).clone() })) as *mut c_void
 397 }
 398 #[no_mangle]
 399 pub extern "C" fn HTLCUpdate_clone(orig: &HTLCUpdate) -> HTLCUpdate {
 400         orig.clone()
 401 }
 402 #[no_mangle]
 403 pub extern "C" fn HTLCUpdate_write(obj: &HTLCUpdate) -> crate::c_types::derived::CVec_u8Z {
 404         crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
 405 }
 406 #[no_mangle]
 407 pub(crate) extern "C" fn HTLCUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 408         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeHTLCUpdate) })
 409 }
 410 #[no_mangle]
 411 pub extern "C" fn HTLCUpdate_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_HTLCUpdateDecodeErrorZ {
 412         let res = crate::c_types::deserialize_obj(ser);
 413         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::chain::channelmonitor::HTLCUpdate { inner: Box::into_raw(Box::new(o)), is_owned: true } }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
 414         local_res
 415 }
 416
 417 use lightning::chain::channelmonitor::ChannelMonitor as nativeChannelMonitorImport;
 418 type nativeChannelMonitor = nativeChannelMonitorImport<crate::chain::keysinterface::ChannelKeys>;
 419
 420 /// A ChannelMonitor handles chain events (blocks connected and disconnected) and generates
 421 /// on-chain transactions to ensure no loss of funds occurs.
 422 ///
 423 /// You MUST ensure that no ChannelMonitors for a given channel anywhere contain out-of-date
 424 /// information and are actively monitoring the chain.
 425 ///
 426 /// Pending Events or updated HTLCs which have not yet been read out by
 427 /// get_and_clear_pending_monitor_events or get_and_clear_pending_events are serialized to disk and
 428 /// reloaded at deserialize-time. Thus, you must ensure that, when handling events, all events
 429 /// gotten are fully handled before re-serializing the new state.
 430 ///
 431 /// Note that the deserializer is only implemented for (Sha256dHash, ChannelMonitor), which
 432 /// tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along
 433 /// the \"reorg path\" (ie disconnecting blocks until you find a common ancestor from both the
 434 /// returned block hash and the the current chain and then reconnecting blocks to get to the
 435 /// best chain) upon deserializing the object!
 436 #[must_use]
 437 #[repr(C)]
 438 pub struct ChannelMonitor {
 439         /// Nearly everywhere, inner must be non-null, however in places where
 440         /// the Rust equivalent takes an Option, it may be set to null to indicate None.
 441         pub inner: *mut nativeChannelMonitor,
 442         pub is_owned: bool,
 443 }
 444
 445 impl Drop for ChannelMonitor {
 446         fn drop(&mut self) {
 447                 if self.is_owned && !self.inner.is_null() {
 448                         let _ = unsafe { Box::from_raw(self.inner) };
 449                 }
 450         }
 451 }
 452 #[no_mangle]
 453 pub extern "C" fn ChannelMonitor_free(this_ptr: ChannelMonitor) { }
 454 #[allow(unused)]
 455 /// Used only if an object of this type is returned as a trait impl by a method
 456 extern "C" fn ChannelMonitor_free_void(this_ptr: *mut c_void) {
 457         unsafe { let _ = Box::from_raw(this_ptr as *mut nativeChannelMonitor); }
 458 }
 459 #[allow(unused)]
 460 /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
 461 impl ChannelMonitor {
 462         pub(crate) fn take_inner(mut self) -> *mut nativeChannelMonitor {
 463                 assert!(self.is_owned);
 464                 let ret = self.inner;
 465                 self.inner = std::ptr::null_mut();
 466                 ret
 467         }
 468 }
 469 #[no_mangle]
 470 pub extern "C" fn ChannelMonitor_write(obj: &ChannelMonitor) -> crate::c_types::derived::CVec_u8Z {
 471         crate::c_types::serialize_obj(unsafe { &*unsafe { &*obj }.inner })
 472 }
 473 #[no_mangle]
 474 pub(crate) extern "C" fn ChannelMonitor_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
 475         crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelMonitor) })
 476 }
 477 /// Updates a ChannelMonitor on the basis of some new information provided by the Channel
 478 /// itself.
 479 ///
 480 /// panics if the given update is not the next update by update_id.
 481 #[must_use]
 482 #[no_mangle]
 483 pub extern "C" fn ChannelMonitor_update_monitor(this_arg: &mut ChannelMonitor, updates: &crate::chain::channelmonitor::ChannelMonitorUpdate, broadcaster: &crate::chain::chaininterface::BroadcasterInterface, fee_estimator: &crate::chain::chaininterface::FeeEstimator, logger: &crate::util::logger::Logger) -> crate::c_types::derived::CResult_NoneMonitorUpdateErrorZ {
 484         let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.update_monitor(unsafe { &*updates.inner }, broadcaster, fee_estimator, logger);
 485         let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { 0u8 /*o*/ }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::chain::channelmonitor::MonitorUpdateError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
 486         local_ret
 487 }
 488
 489 /// Gets the update_id from the latest ChannelMonitorUpdate which was applied to this
 490 /// ChannelMonitor.
 491 #[must_use]
 492 #[no_mangle]
 493 pub extern "C" fn ChannelMonitor_get_latest_update_id(this_arg: &ChannelMonitor) -> u64 {
 494         let mut ret = unsafe { &*this_arg.inner }.get_latest_update_id();
 495         ret
 496 }
 497
 498 /// Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for.
 499 #[must_use]
 500 #[no_mangle]
 501 pub extern "C" fn ChannelMonitor_get_funding_txo(this_arg: &ChannelMonitor) -> crate::c_types::derived::C2Tuple_OutPointScriptZ {
 502         let mut ret = unsafe { &*this_arg.inner }.get_funding_txo();
 503         let (ref orig_ret_0, ref orig_ret_1) = ret; let mut local_ret = (crate::chain::transaction::OutPoint { inner: unsafe { ( (&(*orig_ret_0) as *const _) as *mut _) }, is_owned: false }, orig_ret_1.clone().into_bytes().into()).into();
 504         local_ret
 505 }
 506
 507 /// Get the list of HTLCs who's status has been updated on chain. This should be called by
 508 /// ChannelManager via [`chain::Watch::release_pending_monitor_events`].
 509 ///
 510 /// [`chain::Watch::release_pending_monitor_events`]: ../trait.Watch.html#tymethod.release_pending_monitor_events
 511 #[must_use]
 512 #[no_mangle]
 513 pub extern "C" fn ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: &mut ChannelMonitor) -> crate::c_types::derived::CVec_MonitorEventZ {
 514         let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.get_and_clear_pending_monitor_events();
 515         let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::chain::channelmonitor::MonitorEvent { inner: Box::into_raw(Box::new(item)), is_owned: true } }); };
 516         local_ret.into()
 517 }
 518
 519 /// Gets the list of pending events which were generated by previous actions, clearing the list
 520 /// in the process.
 521 ///
 522 /// This is called by ChainMonitor::get_and_clear_pending_events() and is equivalent to
 523 /// EventsProvider::get_and_clear_pending_events() except that it requires &mut self as we do
 524 /// no internal locking in ChannelMonitors.
 525 #[must_use]
 526 #[no_mangle]
 527 pub extern "C" fn ChannelMonitor_get_and_clear_pending_events(this_arg: &mut ChannelMonitor) -> crate::c_types::derived::CVec_EventZ {
 528         let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.get_and_clear_pending_events();
 529         let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { crate::util::events::Event::native_into(item) }); };
 530         local_ret.into()
 531 }
 532
 533 /// Used by ChannelManager deserialization to broadcast the latest holder state if its copy of
 534 /// the Channel was out-of-date. You may use it to get a broadcastable holder toxic tx in case of
 535 /// fallen-behind, i.e when receiving a channel_reestablish with a proof that our counterparty side knows
 536 /// a higher revocation secret than the holder commitment number we are aware of. Broadcasting these
 537 /// transactions are UNSAFE, as they allow counterparty side to punish you. Nevertheless you may want to
 538 /// broadcast them if counterparty don't close channel with his higher commitment transaction after a
 539 /// substantial amount of time (a month or even a year) to get back funds. Best may be to contact
 540 /// out-of-band the other node operator to coordinate with him if option is available to you.
 541 /// In any-case, choice is up to the user.
 542 #[must_use]
 543 #[no_mangle]
 544 pub extern "C" fn ChannelMonitor_get_latest_holder_commitment_txn(this_arg: &mut ChannelMonitor, logger: &crate::util::logger::Logger) -> crate::c_types::derived::CVec_TransactionZ {
 545         let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.get_latest_holder_commitment_txn(logger);
 546         let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { let mut local_ret_0 = ::bitcoin::consensus::encode::serialize(&item); crate::c_types::Transaction::from_vec(local_ret_0) }); };
 547         local_ret.into()
 548 }
 549
 550 /// Processes transactions in a newly connected block, which may result in any of the following:
 551 /// - update the monitor's state against resolved HTLCs
 552 /// - punish the counterparty in the case of seeing a revoked commitment transaction
 553 /// - force close the channel and claim/timeout incoming/outgoing HTLCs if near expiration
 554 /// - detect settled outputs for later spending
 555 /// - schedule and bump any in-flight claims
 556 ///
 557 /// Returns any new outputs to watch from `txdata`; after called, these are also included in
 558 /// [`get_outputs_to_watch`].
 559 ///
 560 /// [`get_outputs_to_watch`]: #method.get_outputs_to_watch
 561 #[must_use]
 562 #[no_mangle]
 563 pub extern "C" fn ChannelMonitor_block_connected(this_arg: &mut ChannelMonitor, header: *const [u8; 80], mut txdata: crate::c_types::derived::CVec_C2Tuple_usizeTransactionZZ, mut height: u32, mut broadcaster: crate::chain::chaininterface::BroadcasterInterface, mut fee_estimator: crate::chain::chaininterface::FeeEstimator, mut logger: crate::util::logger::Logger) -> crate::c_types::derived::CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ {
 564         let mut local_txdata = Vec::new(); for mut item in txdata.into_rust().drain(..) { local_txdata.push( { let (mut orig_txdata_0_0, mut orig_txdata_0_1) = item.to_rust(); let mut local_txdata_0 = (orig_txdata_0_0, orig_txdata_0_1.into_bitcoin()); local_txdata_0 }); };
 565         let mut ret = unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.block_connected(&::bitcoin::consensus::encode::deserialize(unsafe { &*header }).unwrap(), &local_txdata.iter().map(|(a, b)| (*a, b)).collect::<Vec<_>>()[..], height, broadcaster, fee_estimator, logger);
 566         let mut local_ret = Vec::new(); for item in ret.drain(..) { local_ret.push( { let (mut orig_ret_0_0, mut orig_ret_0_1) = item; let mut local_orig_ret_0_1 = Vec::new(); for item in orig_ret_0_1.drain(..) { local_orig_ret_0_1.push( { let (mut orig_orig_ret_0_1_0_0, mut orig_orig_ret_0_1_0_1) = item; let mut local_orig_ret_0_1_0 = (orig_orig_ret_0_1_0_0, crate::c_types::TxOut::from_rust(orig_orig_ret_0_1_0_1)).into(); local_orig_ret_0_1_0 }); }; let mut local_ret_0 = (crate::c_types::ThirtyTwoBytes { data: orig_ret_0_0.into_inner() }, local_orig_ret_0_1.into()).into(); local_ret_0 }); };
 567         local_ret.into()
 568 }
 569
 570 /// Determines if the disconnected block contained any transactions of interest and updates
 571 /// appropriately.
 572 #[no_mangle]
 573 pub extern "C" fn ChannelMonitor_block_disconnected(this_arg: &mut ChannelMonitor, header: *const [u8; 80], mut height: u32, mut broadcaster: crate::chain::chaininterface::BroadcasterInterface, mut fee_estimator: crate::chain::chaininterface::FeeEstimator, mut logger: crate::util::logger::Logger) {
 574         unsafe { &mut (*(this_arg.inner as *mut nativeChannelMonitor)) }.block_disconnected(&::bitcoin::consensus::encode::deserialize(unsafe { &*header }).unwrap(), height, broadcaster, fee_estimator, logger)
 575 }
 576
 577 /// `Persist` defines behavior for persisting channel monitors: this could mean
 578 /// writing once to disk, and/or uploading to one or more backup services.
 579 ///
 580 /// Note that for every new monitor, you **must** persist the new `ChannelMonitor`
 581 /// to disk/backups. And, on every update, you **must** persist either the
 582 /// `ChannelMonitorUpdate` or the updated monitor itself. Otherwise, there is risk
 583 /// of situations such as revoking a transaction, then crashing before this
 584 /// revocation can be persisted, then unintentionally broadcasting a revoked
 585 /// transaction and losing money. This is a risk because previous channel states
 586 /// are toxic, so it's important that whatever channel state is persisted is
 587 /// kept up-to-date.
 588 #[repr(C)]
 589 pub struct Persist {
 590         pub this_arg: *mut c_void,
 591         /// Persist a new channel's data. The data can be stored any way you want, but
 592         /// the identifier provided by Rust-Lightning is the channel's outpoint (and
 593         /// it is up to you to maintain a correct mapping between the outpoint and the
 594         /// stored channel data). Note that you **must** persist every new monitor to
 595         /// disk. See the `Persist` trait documentation for more details.
 596         ///
 597         /// See [`ChannelMonitor::serialize_for_disk`] for writing out a `ChannelMonitor`,
 598         /// and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
 599         ///
 600         /// [`ChannelMonitor::serialize_for_disk`]: struct.ChannelMonitor.html#method.serialize_for_disk
 601         /// [`ChannelMonitorUpdateErr`]: enum.ChannelMonitorUpdateErr.html
 602         #[must_use]
 603         pub persist_new_channel: extern "C" fn (this_arg: *const c_void, id: crate::chain::transaction::OutPoint, data: &crate::chain::channelmonitor::ChannelMonitor) -> crate::c_types::derived::CResult_NoneChannelMonitorUpdateErrZ,
 604         /// Update one channel's data. The provided `ChannelMonitor` has already
 605         /// applied the given update.
 606         ///
 607         /// Note that on every update, you **must** persist either the
 608         /// `ChannelMonitorUpdate` or the updated monitor itself to disk/backups. See
 609         /// the `Persist` trait documentation for more details.
 610         ///
 611         /// If an implementer chooses to persist the updates only, they need to make
 612         /// sure that all the updates are applied to the `ChannelMonitors` *before*
 613         /// the set of channel monitors is given to the `ChannelManager`
 614         /// deserialization routine. See [`ChannelMonitor::update_monitor`] for
 615         /// applying a monitor update to a monitor. If full `ChannelMonitors` are
 616         /// persisted, then there is no need to persist individual updates.
 617         ///
 618         /// Note that there could be a performance tradeoff between persisting complete
 619         /// channel monitors on every update vs. persisting only updates and applying
 620         /// them in batches. The size of each monitor grows `O(number of state updates)`
 621         /// whereas updates are small and `O(1)`.
 622         ///
 623         /// See [`ChannelMonitor::serialize_for_disk`] for writing out a `ChannelMonitor`,
 624         /// [`ChannelMonitorUpdate::write`] for writing out an update, and
 625         /// [`ChannelMonitorUpdateErr`] for requirements when returning errors.
 626         ///
 627         /// [`ChannelMonitor::update_monitor`]: struct.ChannelMonitor.html#impl-1
 628         /// [`ChannelMonitor::serialize_for_disk`]: struct.ChannelMonitor.html#method.serialize_for_disk
 629         /// [`ChannelMonitorUpdate::write`]: struct.ChannelMonitorUpdate.html#method.write
 630         /// [`ChannelMonitorUpdateErr`]: enum.ChannelMonitorUpdateErr.html
 631         #[must_use]
 632         pub update_persisted_channel: extern "C" fn (this_arg: *const c_void, id: crate::chain::transaction::OutPoint, update: &crate::chain::channelmonitor::ChannelMonitorUpdate, data: &crate::chain::channelmonitor::ChannelMonitor) -> crate::c_types::derived::CResult_NoneChannelMonitorUpdateErrZ,
 633         pub free: Option<extern "C" fn(this_arg: *mut c_void)>,
 634 }
 635 unsafe impl Send for Persist {}
 636 unsafe impl Sync for Persist {}
 637
 638 use lightning::chain::channelmonitor::Persist as rustPersist;
 639 impl rustPersist<crate::chain::keysinterface::ChannelKeys> for Persist {
 640         fn persist_new_channel(&self, id: lightning::chain::transaction::OutPoint, data: &lightning::chain::channelmonitor::ChannelMonitor<crate::chain::keysinterface::ChannelKeys>) -> Result<(), lightning::chain::channelmonitor::ChannelMonitorUpdateErr> {
 641                 let mut ret = (self.persist_new_channel)(self.this_arg, crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(id)), is_owned: true }, &crate::chain::channelmonitor::ChannelMonitor { inner: unsafe { (data as *const _) as *mut _ }, is_owned: false });
 642                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).into_native() })};
 643                 local_ret
 644         }
 645         fn update_persisted_channel(&self, id: lightning::chain::transaction::OutPoint, update: &lightning::chain::channelmonitor::ChannelMonitorUpdate, data: &lightning::chain::channelmonitor::ChannelMonitor<crate::chain::keysinterface::ChannelKeys>) -> Result<(), lightning::chain::channelmonitor::ChannelMonitorUpdateErr> {
 646                 let mut ret = (self.update_persisted_channel)(self.this_arg, crate::chain::transaction::OutPoint { inner: Box::into_raw(Box::new(id)), is_owned: true }, &crate::chain::channelmonitor::ChannelMonitorUpdate { inner: unsafe { (update as *const _) as *mut _ }, is_owned: false }, &crate::chain::channelmonitor::ChannelMonitor { inner: unsafe { (data as *const _) as *mut _ }, is_owned: false });
 647                 let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).into_native() })};
 648                 local_ret
 649         }
 650 }
 651
 652 // We're essentially a pointer already, or at least a set of pointers, so allow us to be used
 653 // directly as a Deref trait in higher-level structs:
 654 impl std::ops::Deref for Persist {
 655         type Target = Self;
 656         fn deref(&self) -> &Self {
 657                 self
 658         }
 659 }
 660 /// Calls the free function if one is set
 661 #[no_mangle]
 662 pub extern "C" fn Persist_free(this_ptr: Persist) { }
 663 impl Drop for Persist {
 664         fn drop(&mut self) {
 665                 if let Some(f) = self.free {
 666                         f(self.this_arg);
 667                 }
 668         }
 669 }
 670 #[no_mangle]
 671 pub extern "C" fn C2Tuple_BlockHashChannelMonitorZ_read(ser: crate::c_types::u8slice, arg: &crate::chain::keysinterface::KeysInterface) -> crate::c_types::derived::CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
 672         let arg_conv = arg;
 673         let res: Result<(bitcoin::hash_types::BlockHash, lightning::chain::channelmonitor::ChannelMonitor<crate::chain::keysinterface::ChannelKeys>), lightning::ln::msgs::DecodeError> = crate::c_types::deserialize_obj_arg(ser, arg_conv);
 674         let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { let (mut orig_res_0_0, mut orig_res_0_1) = o; let mut local_res_0 = (crate::c_types::ThirtyTwoBytes { data: orig_res_0_0.into_inner() }, crate::chain::channelmonitor::ChannelMonitor { inner: Box::into_raw(Box::new(orig_res_0_1)), is_owned: true }).into(); local_res_0 }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }).into() };
 675         local_res
 676 }