#[allow(unused)]
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
impl ChannelMonitorUpdate {
- pub(crate) fn take_ptr(mut self) -> *mut nativeChannelMonitorUpdate {
+ pub(crate) fn take_inner(mut self) -> *mut nativeChannelMonitorUpdate {
assert!(self.is_owned);
let ret = self.inner;
self.inner = std::ptr::null_mut();
crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) })
}
#[no_mangle]
+pub(crate) extern "C" fn ChannelMonitorUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelMonitorUpdate) })
+}
+#[no_mangle]
pub extern "C" fn ChannelMonitorUpdate_read(ser: crate::c_types::u8slice) -> ChannelMonitorUpdate {
if let Ok(res) = crate::c_types::deserialize_obj(ser) {
ChannelMonitorUpdate { inner: Box::into_raw(Box::new(res)), is_owned: true }
#[allow(unused)]
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
impl MonitorUpdateError {
- pub(crate) fn take_ptr(mut self) -> *mut nativeMonitorUpdateError {
+ pub(crate) fn take_inner(mut self) -> *mut nativeMonitorUpdateError {
assert!(self.is_owned);
let ret = self.inner;
self.inner = std::ptr::null_mut();
#[allow(unused)]
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
impl MonitorEvent {
- pub(crate) fn take_ptr(mut self) -> *mut nativeMonitorEvent {
+ pub(crate) fn take_inner(mut self) -> *mut nativeMonitorEvent {
assert!(self.is_owned);
let ret = self.inner;
self.inner = std::ptr::null_mut();
#[allow(unused)]
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
impl HTLCUpdate {
- pub(crate) fn take_ptr(mut self) -> *mut nativeHTLCUpdate {
+ pub(crate) fn take_inner(mut self) -> *mut nativeHTLCUpdate {
assert!(self.is_owned);
let ret = self.inner;
self.inner = std::ptr::null_mut();
crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) })
}
#[no_mangle]
+pub(crate) extern "C" fn HTLCUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {
+ crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeHTLCUpdate) })
+}
+#[no_mangle]
pub extern "C" fn HTLCUpdate_read(ser: crate::c_types::u8slice) -> HTLCUpdate {
if let Ok(res) = crate::c_types::deserialize_obj(ser) {
HTLCUpdate { inner: Box::into_raw(Box::new(res)), is_owned: true }
/// get_and_clear_pending_monitor_events or get_and_clear_pending_events are serialized to disk and
/// reloaded at deserialize-time. Thus, you must ensure that, when handling events, all events
/// gotten are fully handled before re-serializing the new state.
+///
+/// Note that the deserializer is only implemented for (Sha256dHash, ChannelMonitor), which
+/// tells you the last block hash which was block_connect()ed. You MUST rescan any blocks along
+/// the \"reorg path\" (ie disconnecting blocks until you find a common ancestor from both the
+/// returned block hash and the the current chain and then reconnecting blocks to get to the
+/// best chain) upon deserializing the object!
#[must_use]
#[repr(C)]
pub struct ChannelMonitor {
#[allow(unused)]
/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
impl ChannelMonitor {
- pub(crate) fn take_ptr(mut self) -> *mut nativeChannelMonitor {
+ pub(crate) fn take_inner(mut self) -> *mut nativeChannelMonitor {
assert!(self.is_owned);
let ret = self.inner;
self.inner = std::ptr::null_mut();