X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Fln%2Fmsgs.rs;h=cdd4c7b035d99552a434d2ac48688a6c1c08ccb5;hb=b8f49c04ba3e86a02f101861e61826086e40b7e7;hp=6925139d69392335e62ca8176160cecc0f0a5995;hpb=5988789a2d0bc5121e6e56c1707396b8188027e1;p=rust-lightning diff --git a/lightning-c-bindings/src/ln/msgs.rs b/lightning-c-bindings/src/ln/msgs.rs index 6925139d..cdd4c7b0 100644 --- a/lightning-c-bindings/src/ln/msgs.rs +++ b/lightning-c-bindings/src/ln/msgs.rs @@ -50,7 +50,7 @@ extern "C" fn DecodeError_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl DecodeError { - pub(crate) fn take_ptr(mut self) -> *mut nativeDecodeError { + pub(crate) fn take_inner(mut self) -> *mut nativeDecodeError { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -88,13 +88,30 @@ extern "C" fn Init_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl Init { - pub(crate) fn take_ptr(mut self) -> *mut nativeInit { + pub(crate) fn take_inner(mut self) -> *mut nativeInit { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); ret } } +impl Clone for Init { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Init_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeInit)).clone() })) as *mut c_void +} +#[no_mangle] +pub extern "C" fn Init_clone(orig: &Init) -> Init { + Init { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} use lightning::ln::msgs::ErrorMessage as nativeErrorMessageImport; type nativeErrorMessage = nativeErrorMessageImport; @@ -126,7 +143,7 @@ extern "C" fn ErrorMessage_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl ErrorMessage { - pub(crate) fn take_ptr(mut self) -> *mut nativeErrorMessage { + pub(crate) fn take_inner(mut self) -> *mut nativeErrorMessage { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -146,6 +163,10 @@ impl Clone for ErrorMessage { pub(crate) extern "C" fn ErrorMessage_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeErrorMessage)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn ErrorMessage_clone(orig: &ErrorMessage) -> ErrorMessage { + ErrorMessage { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID involved in the error #[no_mangle] pub extern "C" fn ErrorMessage_get_channel_id(this_ptr: &ErrorMessage) -> *const [u8; 32] { @@ -213,13 +234,30 @@ extern "C" fn Ping_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl Ping { - pub(crate) fn take_ptr(mut self) -> *mut nativePing { + pub(crate) fn take_inner(mut self) -> *mut nativePing { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); ret } } +impl Clone for Ping { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Ping_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePing)).clone() })) as *mut c_void +} +#[no_mangle] +pub extern "C" fn Ping_clone(orig: &Ping) -> Ping { + Ping { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The desired response length #[no_mangle] pub extern "C" fn Ping_get_ponglen(this_ptr: &Ping) -> u16 { @@ -283,13 +321,30 @@ extern "C" fn Pong_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl Pong { - pub(crate) fn take_ptr(mut self) -> *mut nativePong { + pub(crate) fn take_inner(mut self) -> *mut nativePong { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); ret } } +impl Clone for Pong { + fn clone(&self) -> Self { + Self { + inner: Box::into_raw(Box::new(unsafe { &*self.inner }.clone())), + is_owned: true, + } + } +} +#[allow(unused)] +/// Used only if an object of this type is returned as a trait impl by a method +pub(crate) extern "C" fn Pong_clone_void(this_ptr: *const c_void) -> *mut c_void { + Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativePong)).clone() })) as *mut c_void +} +#[no_mangle] +pub extern "C" fn Pong_clone(orig: &Pong) -> Pong { + Pong { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The pong packet size. /// This field is not sent on the wire. byteslen zeros are sent. #[no_mangle] @@ -341,7 +396,7 @@ extern "C" fn OpenChannel_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl OpenChannel { - pub(crate) fn take_ptr(mut self) -> *mut nativeOpenChannel { + pub(crate) fn take_inner(mut self) -> *mut nativeOpenChannel { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -361,6 +416,10 @@ impl Clone for OpenChannel { pub(crate) extern "C" fn OpenChannel_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeOpenChannel)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn OpenChannel_clone(orig: &OpenChannel) -> OpenChannel { + OpenChannel { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The genesis hash of the blockchain where the channel is to be opened #[no_mangle] pub extern "C" fn OpenChannel_get_chain_hash(this_ptr: &OpenChannel) -> *const [u8; 32] { @@ -590,7 +649,7 @@ extern "C" fn AcceptChannel_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl AcceptChannel { - pub(crate) fn take_ptr(mut self) -> *mut nativeAcceptChannel { + pub(crate) fn take_inner(mut self) -> *mut nativeAcceptChannel { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -610,6 +669,10 @@ impl Clone for AcceptChannel { pub(crate) extern "C" fn AcceptChannel_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeAcceptChannel)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn AcceptChannel_clone(orig: &AcceptChannel) -> AcceptChannel { + AcceptChannel { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// A temporary channel ID, until the funding outpoint is announced #[no_mangle] pub extern "C" fn AcceptChannel_get_temporary_channel_id(this_ptr: &AcceptChannel) -> *const [u8; 32] { @@ -795,7 +858,7 @@ extern "C" fn FundingCreated_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl FundingCreated { - pub(crate) fn take_ptr(mut self) -> *mut nativeFundingCreated { + pub(crate) fn take_inner(mut self) -> *mut nativeFundingCreated { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -815,6 +878,10 @@ impl Clone for FundingCreated { pub(crate) extern "C" fn FundingCreated_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingCreated)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn FundingCreated_clone(orig: &FundingCreated) -> FundingCreated { + FundingCreated { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// A temporary channel ID, until the funding is established #[no_mangle] pub extern "C" fn FundingCreated_get_temporary_channel_id(this_ptr: &FundingCreated) -> *const [u8; 32] { @@ -900,7 +967,7 @@ extern "C" fn FundingSigned_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl FundingSigned { - pub(crate) fn take_ptr(mut self) -> *mut nativeFundingSigned { + pub(crate) fn take_inner(mut self) -> *mut nativeFundingSigned { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -920,6 +987,10 @@ impl Clone for FundingSigned { pub(crate) extern "C" fn FundingSigned_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingSigned)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn FundingSigned_clone(orig: &FundingSigned) -> FundingSigned { + FundingSigned { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn FundingSigned_get_channel_id(this_ptr: &FundingSigned) -> *const [u8; 32] { @@ -981,7 +1052,7 @@ extern "C" fn FundingLocked_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl FundingLocked { - pub(crate) fn take_ptr(mut self) -> *mut nativeFundingLocked { + pub(crate) fn take_inner(mut self) -> *mut nativeFundingLocked { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1001,6 +1072,10 @@ impl Clone for FundingLocked { pub(crate) extern "C" fn FundingLocked_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeFundingLocked)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn FundingLocked_clone(orig: &FundingLocked) -> FundingLocked { + FundingLocked { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn FundingLocked_get_channel_id(this_ptr: &FundingLocked) -> *const [u8; 32] { @@ -1062,7 +1137,7 @@ extern "C" fn Shutdown_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl Shutdown { - pub(crate) fn take_ptr(mut self) -> *mut nativeShutdown { + pub(crate) fn take_inner(mut self) -> *mut nativeShutdown { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1082,6 +1157,10 @@ impl Clone for Shutdown { pub(crate) extern "C" fn Shutdown_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeShutdown)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn Shutdown_clone(orig: &Shutdown) -> Shutdown { + Shutdown { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn Shutdown_get_channel_id(this_ptr: &Shutdown) -> *const [u8; 32] { @@ -1145,7 +1224,7 @@ extern "C" fn ClosingSigned_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl ClosingSigned { - pub(crate) fn take_ptr(mut self) -> *mut nativeClosingSigned { + pub(crate) fn take_inner(mut self) -> *mut nativeClosingSigned { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1165,6 +1244,10 @@ impl Clone for ClosingSigned { pub(crate) extern "C" fn ClosingSigned_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeClosingSigned)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn ClosingSigned_clone(orig: &ClosingSigned) -> ClosingSigned { + ClosingSigned { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn ClosingSigned_get_channel_id(this_ptr: &ClosingSigned) -> *const [u8; 32] { @@ -1238,7 +1321,7 @@ extern "C" fn UpdateAddHTLC_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl UpdateAddHTLC { - pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateAddHTLC { + pub(crate) fn take_inner(mut self) -> *mut nativeUpdateAddHTLC { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1258,6 +1341,10 @@ impl Clone for UpdateAddHTLC { pub(crate) extern "C" fn UpdateAddHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateAddHTLC)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn UpdateAddHTLC_clone(orig: &UpdateAddHTLC) -> UpdateAddHTLC { + UpdateAddHTLC { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn UpdateAddHTLC_get_channel_id(this_ptr: &UpdateAddHTLC) -> *const [u8; 32] { @@ -1344,7 +1431,7 @@ extern "C" fn UpdateFulfillHTLC_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl UpdateFulfillHTLC { - pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateFulfillHTLC { + pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFulfillHTLC { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1364,6 +1451,10 @@ impl Clone for UpdateFulfillHTLC { pub(crate) extern "C" fn UpdateFulfillHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFulfillHTLC)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn UpdateFulfillHTLC_clone(orig: &UpdateFulfillHTLC) -> UpdateFulfillHTLC { + UpdateFulfillHTLC { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn UpdateFulfillHTLC_get_channel_id(this_ptr: &UpdateFulfillHTLC) -> *const [u8; 32] { @@ -1437,7 +1528,7 @@ extern "C" fn UpdateFailHTLC_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl UpdateFailHTLC { - pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateFailHTLC { + pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailHTLC { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1457,6 +1548,10 @@ impl Clone for UpdateFailHTLC { pub(crate) extern "C" fn UpdateFailHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFailHTLC)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn UpdateFailHTLC_clone(orig: &UpdateFailHTLC) -> UpdateFailHTLC { + UpdateFailHTLC { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn UpdateFailHTLC_get_channel_id(this_ptr: &UpdateFailHTLC) -> *const [u8; 32] { @@ -1510,7 +1605,7 @@ extern "C" fn UpdateFailMalformedHTLC_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl UpdateFailMalformedHTLC { - pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateFailMalformedHTLC { + pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFailMalformedHTLC { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1530,6 +1625,10 @@ impl Clone for UpdateFailMalformedHTLC { pub(crate) extern "C" fn UpdateFailMalformedHTLC_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFailMalformedHTLC)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn UpdateFailMalformedHTLC_clone(orig: &UpdateFailMalformedHTLC) -> UpdateFailMalformedHTLC { + UpdateFailMalformedHTLC { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn UpdateFailMalformedHTLC_get_channel_id(this_ptr: &UpdateFailMalformedHTLC) -> *const [u8; 32] { @@ -1594,7 +1693,7 @@ extern "C" fn CommitmentSigned_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl CommitmentSigned { - pub(crate) fn take_ptr(mut self) -> *mut nativeCommitmentSigned { + pub(crate) fn take_inner(mut self) -> *mut nativeCommitmentSigned { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1614,6 +1713,10 @@ impl Clone for CommitmentSigned { pub(crate) extern "C" fn CommitmentSigned_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeCommitmentSigned)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn CommitmentSigned_clone(orig: &CommitmentSigned) -> CommitmentSigned { + CommitmentSigned { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn CommitmentSigned_get_channel_id(this_ptr: &CommitmentSigned) -> *const [u8; 32] { @@ -1683,7 +1786,7 @@ extern "C" fn RevokeAndACK_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl RevokeAndACK { - pub(crate) fn take_ptr(mut self) -> *mut nativeRevokeAndACK { + pub(crate) fn take_inner(mut self) -> *mut nativeRevokeAndACK { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1703,6 +1806,10 @@ impl Clone for RevokeAndACK { pub(crate) extern "C" fn RevokeAndACK_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeRevokeAndACK)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn RevokeAndACK_clone(orig: &RevokeAndACK) -> RevokeAndACK { + RevokeAndACK { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn RevokeAndACK_get_channel_id(this_ptr: &RevokeAndACK) -> *const [u8; 32] { @@ -1776,7 +1883,7 @@ extern "C" fn UpdateFee_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl UpdateFee { - pub(crate) fn take_ptr(mut self) -> *mut nativeUpdateFee { + pub(crate) fn take_inner(mut self) -> *mut nativeUpdateFee { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1796,6 +1903,10 @@ impl Clone for UpdateFee { pub(crate) extern "C" fn UpdateFee_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUpdateFee)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn UpdateFee_clone(orig: &UpdateFee) -> UpdateFee { + UpdateFee { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn UpdateFee_get_channel_id(this_ptr: &UpdateFee) -> *const [u8; 32] { @@ -1860,7 +1971,7 @@ extern "C" fn DataLossProtect_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl DataLossProtect { - pub(crate) fn take_ptr(mut self) -> *mut nativeDataLossProtect { + pub(crate) fn take_inner(mut self) -> *mut nativeDataLossProtect { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1880,6 +1991,10 @@ impl Clone for DataLossProtect { pub(crate) extern "C" fn DataLossProtect_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeDataLossProtect)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn DataLossProtect_clone(orig: &DataLossProtect) -> DataLossProtect { + DataLossProtect { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// Proof that the sender knows the per-commitment secret of a specific commitment transaction /// belonging to the recipient #[no_mangle] @@ -1943,7 +2058,7 @@ extern "C" fn ChannelReestablish_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl ChannelReestablish { - pub(crate) fn take_ptr(mut self) -> *mut nativeChannelReestablish { + pub(crate) fn take_inner(mut self) -> *mut nativeChannelReestablish { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -1963,6 +2078,10 @@ impl Clone for ChannelReestablish { pub(crate) extern "C" fn ChannelReestablish_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelReestablish)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn ChannelReestablish_clone(orig: &ChannelReestablish) -> ChannelReestablish { + ChannelReestablish { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn ChannelReestablish_get_channel_id(this_ptr: &ChannelReestablish) -> *const [u8; 32] { @@ -2027,7 +2146,7 @@ extern "C" fn AnnouncementSignatures_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl AnnouncementSignatures { - pub(crate) fn take_ptr(mut self) -> *mut nativeAnnouncementSignatures { + pub(crate) fn take_inner(mut self) -> *mut nativeAnnouncementSignatures { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -2047,6 +2166,10 @@ impl Clone for AnnouncementSignatures { pub(crate) extern "C" fn AnnouncementSignatures_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeAnnouncementSignatures)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn AnnouncementSignatures_clone(orig: &AnnouncementSignatures) -> AnnouncementSignatures { + AnnouncementSignatures { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The channel ID #[no_mangle] pub extern "C" fn AnnouncementSignatures_get_channel_id(this_ptr: &AnnouncementSignatures) -> *const [u8; 32] { @@ -2280,6 +2403,10 @@ impl NetAddress { } #[no_mangle] pub extern "C" fn NetAddress_free(this_ptr: NetAddress) { } +#[no_mangle] +pub extern "C" fn NetAddress_clone(orig: &NetAddress) -> NetAddress { + orig.clone() +} use lightning::ln::msgs::UnsignedNodeAnnouncement as nativeUnsignedNodeAnnouncementImport; type nativeUnsignedNodeAnnouncement = nativeUnsignedNodeAnnouncementImport; @@ -2311,7 +2438,7 @@ extern "C" fn UnsignedNodeAnnouncement_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl UnsignedNodeAnnouncement { - pub(crate) fn take_ptr(mut self) -> *mut nativeUnsignedNodeAnnouncement { + pub(crate) fn take_inner(mut self) -> *mut nativeUnsignedNodeAnnouncement { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -2331,6 +2458,10 @@ impl Clone for UnsignedNodeAnnouncement { pub(crate) extern "C" fn UnsignedNodeAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedNodeAnnouncement)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_clone(orig: &UnsignedNodeAnnouncement) -> UnsignedNodeAnnouncement { + UnsignedNodeAnnouncement { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The advertised features #[no_mangle] pub extern "C" fn UnsignedNodeAnnouncement_get_features(this_ptr: &UnsignedNodeAnnouncement) -> crate::ln::features::NodeFeatures { @@ -2340,7 +2471,7 @@ pub extern "C" fn UnsignedNodeAnnouncement_get_features(this_ptr: &UnsignedNodeA /// The advertised features #[no_mangle] pub extern "C" fn UnsignedNodeAnnouncement_set_features(this_ptr: &mut UnsignedNodeAnnouncement, mut val: crate::ln::features::NodeFeatures) { - unsafe { &mut *this_ptr.inner }.features = *unsafe { Box::from_raw(val.take_ptr()) }; + unsafe { &mut *this_ptr.inner }.features = *unsafe { Box::from_raw(val.take_inner()) }; } /// A strictly monotonic announcement counter, with gaps allowed #[no_mangle] @@ -2427,7 +2558,7 @@ extern "C" fn NodeAnnouncement_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl NodeAnnouncement { - pub(crate) fn take_ptr(mut self) -> *mut nativeNodeAnnouncement { + pub(crate) fn take_inner(mut self) -> *mut nativeNodeAnnouncement { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -2447,6 +2578,10 @@ impl Clone for NodeAnnouncement { pub(crate) extern "C" fn NodeAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeNodeAnnouncement)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn NodeAnnouncement_clone(orig: &NodeAnnouncement) -> NodeAnnouncement { + NodeAnnouncement { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The signature by the node key #[no_mangle] pub extern "C" fn NodeAnnouncement_get_signature(this_ptr: &NodeAnnouncement) -> crate::c_types::Signature { @@ -2467,14 +2602,14 @@ pub extern "C" fn NodeAnnouncement_get_contents(this_ptr: &NodeAnnouncement) -> /// The actual content of the announcement #[no_mangle] pub extern "C" fn NodeAnnouncement_set_contents(this_ptr: &mut NodeAnnouncement, mut val: crate::ln::msgs::UnsignedNodeAnnouncement) { - unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_ptr()) }; + unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_inner()) }; } #[must_use] #[no_mangle] pub extern "C" fn NodeAnnouncement_new(mut signature_arg: crate::c_types::Signature, mut contents_arg: crate::ln::msgs::UnsignedNodeAnnouncement) -> NodeAnnouncement { NodeAnnouncement { inner: Box::into_raw(Box::new(nativeNodeAnnouncement { signature: signature_arg.into_rust(), - contents: *unsafe { Box::from_raw(contents_arg.take_ptr()) }, + contents: *unsafe { Box::from_raw(contents_arg.take_inner()) }, })), is_owned: true } } @@ -2508,7 +2643,7 @@ extern "C" fn UnsignedChannelAnnouncement_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl UnsignedChannelAnnouncement { - pub(crate) fn take_ptr(mut self) -> *mut nativeUnsignedChannelAnnouncement { + pub(crate) fn take_inner(mut self) -> *mut nativeUnsignedChannelAnnouncement { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -2528,6 +2663,10 @@ impl Clone for UnsignedChannelAnnouncement { pub(crate) extern "C" fn UnsignedChannelAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedChannelAnnouncement)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_clone(orig: &UnsignedChannelAnnouncement) -> UnsignedChannelAnnouncement { + UnsignedChannelAnnouncement { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The advertised channel features #[no_mangle] pub extern "C" fn UnsignedChannelAnnouncement_get_features(this_ptr: &UnsignedChannelAnnouncement) -> crate::ln::features::ChannelFeatures { @@ -2537,7 +2676,7 @@ pub extern "C" fn UnsignedChannelAnnouncement_get_features(this_ptr: &UnsignedCh /// The advertised channel features #[no_mangle] pub extern "C" fn UnsignedChannelAnnouncement_set_features(this_ptr: &mut UnsignedChannelAnnouncement, mut val: crate::ln::features::ChannelFeatures) { - unsafe { &mut *this_ptr.inner }.features = *unsafe { Box::from_raw(val.take_ptr()) }; + unsafe { &mut *this_ptr.inner }.features = *unsafe { Box::from_raw(val.take_inner()) }; } /// The genesis hash of the blockchain where the channel is to be opened #[no_mangle] @@ -2636,7 +2775,7 @@ extern "C" fn ChannelAnnouncement_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl ChannelAnnouncement { - pub(crate) fn take_ptr(mut self) -> *mut nativeChannelAnnouncement { + pub(crate) fn take_inner(mut self) -> *mut nativeChannelAnnouncement { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -2656,6 +2795,10 @@ impl Clone for ChannelAnnouncement { pub(crate) extern "C" fn ChannelAnnouncement_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelAnnouncement)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn ChannelAnnouncement_clone(orig: &ChannelAnnouncement) -> ChannelAnnouncement { + ChannelAnnouncement { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// Authentication of the announcement by the first public node #[no_mangle] pub extern "C" fn ChannelAnnouncement_get_node_signature_1(this_ptr: &ChannelAnnouncement) -> crate::c_types::Signature { @@ -2709,7 +2852,7 @@ pub extern "C" fn ChannelAnnouncement_get_contents(this_ptr: &ChannelAnnouncemen /// The actual announcement #[no_mangle] pub extern "C" fn ChannelAnnouncement_set_contents(this_ptr: &mut ChannelAnnouncement, mut val: crate::ln::msgs::UnsignedChannelAnnouncement) { - unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_ptr()) }; + unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_inner()) }; } #[must_use] #[no_mangle] @@ -2719,7 +2862,7 @@ pub extern "C" fn ChannelAnnouncement_new(mut node_signature_1_arg: crate::c_typ node_signature_2: node_signature_2_arg.into_rust(), bitcoin_signature_1: bitcoin_signature_1_arg.into_rust(), bitcoin_signature_2: bitcoin_signature_2_arg.into_rust(), - contents: *unsafe { Box::from_raw(contents_arg.take_ptr()) }, + contents: *unsafe { Box::from_raw(contents_arg.take_inner()) }, })), is_owned: true } } @@ -2753,7 +2896,7 @@ extern "C" fn UnsignedChannelUpdate_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl UnsignedChannelUpdate { - pub(crate) fn take_ptr(mut self) -> *mut nativeUnsignedChannelUpdate { + pub(crate) fn take_inner(mut self) -> *mut nativeUnsignedChannelUpdate { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -2773,6 +2916,10 @@ impl Clone for UnsignedChannelUpdate { pub(crate) extern "C" fn UnsignedChannelUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeUnsignedChannelUpdate)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_clone(orig: &UnsignedChannelUpdate) -> UnsignedChannelUpdate { + UnsignedChannelUpdate { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The genesis hash of the blockchain where the channel is to be opened #[no_mangle] pub extern "C" fn UnsignedChannelUpdate_get_chain_hash(this_ptr: &UnsignedChannelUpdate) -> *const [u8; 32] { @@ -2892,7 +3039,7 @@ extern "C" fn ChannelUpdate_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl ChannelUpdate { - pub(crate) fn take_ptr(mut self) -> *mut nativeChannelUpdate { + pub(crate) fn take_inner(mut self) -> *mut nativeChannelUpdate { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -2912,6 +3059,10 @@ impl Clone for ChannelUpdate { pub(crate) extern "C" fn ChannelUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeChannelUpdate)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn ChannelUpdate_clone(orig: &ChannelUpdate) -> ChannelUpdate { + ChannelUpdate { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// A signature of the channel update #[no_mangle] pub extern "C" fn ChannelUpdate_get_signature(this_ptr: &ChannelUpdate) -> crate::c_types::Signature { @@ -2932,14 +3083,14 @@ pub extern "C" fn ChannelUpdate_get_contents(this_ptr: &ChannelUpdate) -> crate: /// The actual channel update #[no_mangle] pub extern "C" fn ChannelUpdate_set_contents(this_ptr: &mut ChannelUpdate, mut val: crate::ln::msgs::UnsignedChannelUpdate) { - unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_ptr()) }; + unsafe { &mut *this_ptr.inner }.contents = *unsafe { Box::from_raw(val.take_inner()) }; } #[must_use] #[no_mangle] pub extern "C" fn ChannelUpdate_new(mut signature_arg: crate::c_types::Signature, mut contents_arg: crate::ln::msgs::UnsignedChannelUpdate) -> ChannelUpdate { ChannelUpdate { inner: Box::into_raw(Box::new(nativeChannelUpdate { signature: signature_arg.into_rust(), - contents: *unsafe { Box::from_raw(contents_arg.take_ptr()) }, + contents: *unsafe { Box::from_raw(contents_arg.take_inner()) }, })), is_owned: true } } @@ -2976,7 +3127,7 @@ extern "C" fn QueryChannelRange_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl QueryChannelRange { - pub(crate) fn take_ptr(mut self) -> *mut nativeQueryChannelRange { + pub(crate) fn take_inner(mut self) -> *mut nativeQueryChannelRange { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -2996,6 +3147,10 @@ impl Clone for QueryChannelRange { pub(crate) extern "C" fn QueryChannelRange_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeQueryChannelRange)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn QueryChannelRange_clone(orig: &QueryChannelRange) -> QueryChannelRange { + QueryChannelRange { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The genesis hash of the blockchain being queried #[no_mangle] pub extern "C" fn QueryChannelRange_get_chain_hash(this_ptr: &QueryChannelRange) -> *const [u8; 32] { @@ -3075,7 +3230,7 @@ extern "C" fn ReplyChannelRange_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl ReplyChannelRange { - pub(crate) fn take_ptr(mut self) -> *mut nativeReplyChannelRange { + pub(crate) fn take_inner(mut self) -> *mut nativeReplyChannelRange { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -3095,6 +3250,10 @@ impl Clone for ReplyChannelRange { pub(crate) extern "C" fn ReplyChannelRange_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeReplyChannelRange)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn ReplyChannelRange_clone(orig: &ReplyChannelRange) -> ReplyChannelRange { + ReplyChannelRange { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The genesis hash of the blockchain being queried #[no_mangle] pub extern "C" fn ReplyChannelRange_get_chain_hash(this_ptr: &ReplyChannelRange) -> *const [u8; 32] { @@ -3197,7 +3356,7 @@ extern "C" fn QueryShortChannelIds_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl QueryShortChannelIds { - pub(crate) fn take_ptr(mut self) -> *mut nativeQueryShortChannelIds { + pub(crate) fn take_inner(mut self) -> *mut nativeQueryShortChannelIds { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -3217,6 +3376,10 @@ impl Clone for QueryShortChannelIds { pub(crate) extern "C" fn QueryShortChannelIds_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeQueryShortChannelIds)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn QueryShortChannelIds_clone(orig: &QueryShortChannelIds) -> QueryShortChannelIds { + QueryShortChannelIds { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The genesis hash of the blockchain being queried #[no_mangle] pub extern "C" fn QueryShortChannelIds_get_chain_hash(this_ptr: &QueryShortChannelIds) -> *const [u8; 32] { @@ -3277,7 +3440,7 @@ extern "C" fn ReplyShortChannelIdsEnd_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl ReplyShortChannelIdsEnd { - pub(crate) fn take_ptr(mut self) -> *mut nativeReplyShortChannelIdsEnd { + pub(crate) fn take_inner(mut self) -> *mut nativeReplyShortChannelIdsEnd { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -3297,6 +3460,10 @@ impl Clone for ReplyShortChannelIdsEnd { pub(crate) extern "C" fn ReplyShortChannelIdsEnd_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeReplyShortChannelIdsEnd)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn ReplyShortChannelIdsEnd_clone(orig: &ReplyShortChannelIdsEnd) -> ReplyShortChannelIdsEnd { + ReplyShortChannelIdsEnd { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The genesis hash of the blockchain that was queried #[no_mangle] pub extern "C" fn ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: &ReplyShortChannelIdsEnd) -> *const [u8; 32] { @@ -3362,7 +3529,7 @@ extern "C" fn GossipTimestampFilter_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl GossipTimestampFilter { - pub(crate) fn take_ptr(mut self) -> *mut nativeGossipTimestampFilter { + pub(crate) fn take_inner(mut self) -> *mut nativeGossipTimestampFilter { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -3382,6 +3549,10 @@ impl Clone for GossipTimestampFilter { pub(crate) extern "C" fn GossipTimestampFilter_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeGossipTimestampFilter)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn GossipTimestampFilter_clone(orig: &GossipTimestampFilter) -> GossipTimestampFilter { + GossipTimestampFilter { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// The genesis hash of the blockchain for channel and node information #[no_mangle] pub extern "C" fn GossipTimestampFilter_get_chain_hash(this_ptr: &GossipTimestampFilter) -> *const [u8; 32] { @@ -3447,7 +3618,7 @@ impl ErrorAction { match self { ErrorAction::DisconnectPeer {ref msg, } => { let mut msg_nonref = (*msg).clone(); - let mut local_msg_nonref = if msg_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg_nonref.take_ptr()) } }) }; + let mut local_msg_nonref = if msg_nonref.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg_nonref.take_inner()) } }) }; nativeErrorAction::DisconnectPeer { msg: local_msg_nonref, } @@ -3456,7 +3627,7 @@ impl ErrorAction { ErrorAction::SendErrorMessage {ref msg, } => { let mut msg_nonref = (*msg).clone(); nativeErrorAction::SendErrorMessage { - msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, } @@ -3465,7 +3636,7 @@ impl ErrorAction { pub(crate) fn into_native(self) -> nativeErrorAction { match self { ErrorAction::DisconnectPeer {mut msg, } => { - let mut local_msg = if msg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg.take_ptr()) } }) }; + let mut local_msg = if msg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(msg.take_inner()) } }) }; nativeErrorAction::DisconnectPeer { msg: local_msg, } @@ -3473,7 +3644,7 @@ impl ErrorAction { ErrorAction::IgnoreError => nativeErrorAction::IgnoreError, ErrorAction::SendErrorMessage {mut msg, } => { nativeErrorAction::SendErrorMessage { - msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + msg: *unsafe { Box::from_raw(msg.take_inner()) }, } }, } @@ -3517,6 +3688,10 @@ impl ErrorAction { } #[no_mangle] pub extern "C" fn ErrorAction_free(this_ptr: ErrorAction) { } +#[no_mangle] +pub extern "C" fn ErrorAction_clone(orig: &ErrorAction) -> ErrorAction { + orig.clone() +} use lightning::ln::msgs::LightningError as nativeLightningErrorImport; type nativeLightningError = nativeLightningErrorImport; @@ -3548,7 +3723,7 @@ extern "C" fn LightningError_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl LightningError { - pub(crate) fn take_ptr(mut self) -> *mut nativeLightningError { + pub(crate) fn take_inner(mut self) -> *mut nativeLightningError { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -3617,7 +3792,7 @@ extern "C" fn CommitmentUpdate_free_void(this_ptr: *mut c_void) { #[allow(unused)] /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy impl CommitmentUpdate { - pub(crate) fn take_ptr(mut self) -> *mut nativeCommitmentUpdate { + pub(crate) fn take_inner(mut self) -> *mut nativeCommitmentUpdate { assert!(self.is_owned); let ret = self.inner; self.inner = std::ptr::null_mut(); @@ -3637,28 +3812,32 @@ impl Clone for CommitmentUpdate { pub(crate) extern "C" fn CommitmentUpdate_clone_void(this_ptr: *const c_void) -> *mut c_void { Box::into_raw(Box::new(unsafe { (*(this_ptr as *mut nativeCommitmentUpdate)).clone() })) as *mut c_void } +#[no_mangle] +pub extern "C" fn CommitmentUpdate_clone(orig: &CommitmentUpdate) -> CommitmentUpdate { + CommitmentUpdate { inner: Box::into_raw(Box::new(unsafe { &*orig.inner }.clone())), is_owned: true } +} /// update_add_htlc messages which should be sent #[no_mangle] pub extern "C" fn CommitmentUpdate_set_update_add_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateAddHTLCZ) { - let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; unsafe { &mut *this_ptr.inner }.update_add_htlcs = local_val; } /// update_fulfill_htlc messages which should be sent #[no_mangle] pub extern "C" fn CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFulfillHTLCZ) { - let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; unsafe { &mut *this_ptr.inner }.update_fulfill_htlcs = local_val; } /// update_fail_htlc messages which should be sent #[no_mangle] pub extern "C" fn CommitmentUpdate_set_update_fail_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFailHTLCZ) { - let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; unsafe { &mut *this_ptr.inner }.update_fail_htlcs = local_val; } /// update_fail_malformed_htlc messages which should be sent #[no_mangle] pub extern "C" fn CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: &mut CommitmentUpdate, mut val: crate::c_types::derived::CVec_UpdateFailMalformedHTLCZ) { - let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + let mut local_val = Vec::new(); for mut item in val.into_rust().drain(..) { local_val.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; unsafe { &mut *this_ptr.inner }.update_fail_malformed_htlcs = local_val; } /// An update_fee message which should be sent @@ -3671,7 +3850,7 @@ pub extern "C" fn CommitmentUpdate_get_update_fee(this_ptr: &CommitmentUpdate) - /// An update_fee message which should be sent #[no_mangle] pub extern "C" fn CommitmentUpdate_set_update_fee(this_ptr: &mut CommitmentUpdate, mut val: crate::ln::msgs::UpdateFee) { - let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_ptr()) } }) }; + let mut local_val = if val.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(val.take_inner()) } }) }; unsafe { &mut *this_ptr.inner }.update_fee = local_val; } /// Finally, the commitment_signed message which should be sent @@ -3683,23 +3862,23 @@ pub extern "C" fn CommitmentUpdate_get_commitment_signed(this_ptr: &CommitmentUp /// Finally, the commitment_signed message which should be sent #[no_mangle] pub extern "C" fn CommitmentUpdate_set_commitment_signed(this_ptr: &mut CommitmentUpdate, mut val: crate::ln::msgs::CommitmentSigned) { - unsafe { &mut *this_ptr.inner }.commitment_signed = *unsafe { Box::from_raw(val.take_ptr()) }; + unsafe { &mut *this_ptr.inner }.commitment_signed = *unsafe { Box::from_raw(val.take_inner()) }; } #[must_use] #[no_mangle] pub extern "C" fn CommitmentUpdate_new(mut update_add_htlcs_arg: crate::c_types::derived::CVec_UpdateAddHTLCZ, mut update_fulfill_htlcs_arg: crate::c_types::derived::CVec_UpdateFulfillHTLCZ, mut update_fail_htlcs_arg: crate::c_types::derived::CVec_UpdateFailHTLCZ, mut update_fail_malformed_htlcs_arg: crate::c_types::derived::CVec_UpdateFailMalformedHTLCZ, mut update_fee_arg: crate::ln::msgs::UpdateFee, mut commitment_signed_arg: crate::ln::msgs::CommitmentSigned) -> CommitmentUpdate { - let mut local_update_add_htlcs_arg = Vec::new(); for mut item in update_add_htlcs_arg.into_rust().drain(..) { local_update_add_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; - let mut local_update_fulfill_htlcs_arg = Vec::new(); for mut item in update_fulfill_htlcs_arg.into_rust().drain(..) { local_update_fulfill_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; - let mut local_update_fail_htlcs_arg = Vec::new(); for mut item in update_fail_htlcs_arg.into_rust().drain(..) { local_update_fail_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; - let mut local_update_fail_malformed_htlcs_arg = Vec::new(); for mut item in update_fail_malformed_htlcs_arg.into_rust().drain(..) { local_update_fail_malformed_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; - let mut local_update_fee_arg = if update_fee_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(update_fee_arg.take_ptr()) } }) }; + let mut local_update_add_htlcs_arg = Vec::new(); for mut item in update_add_htlcs_arg.into_rust().drain(..) { local_update_add_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; + let mut local_update_fulfill_htlcs_arg = Vec::new(); for mut item in update_fulfill_htlcs_arg.into_rust().drain(..) { local_update_fulfill_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; + let mut local_update_fail_htlcs_arg = Vec::new(); for mut item in update_fail_htlcs_arg.into_rust().drain(..) { local_update_fail_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; + let mut local_update_fail_malformed_htlcs_arg = Vec::new(); for mut item in update_fail_malformed_htlcs_arg.into_rust().drain(..) { local_update_fail_malformed_htlcs_arg.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; + let mut local_update_fee_arg = if update_fee_arg.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(update_fee_arg.take_inner()) } }) }; CommitmentUpdate { inner: Box::into_raw(Box::new(nativeCommitmentUpdate { update_add_htlcs: local_update_add_htlcs_arg, update_fulfill_htlcs: local_update_fulfill_htlcs_arg, update_fail_htlcs: local_update_fail_htlcs_arg, update_fail_malformed_htlcs: local_update_fail_malformed_htlcs_arg, update_fee: local_update_fee_arg, - commitment_signed: *unsafe { Box::from_raw(commitment_signed_arg.take_ptr()) }, + commitment_signed: *unsafe { Box::from_raw(commitment_signed_arg.take_inner()) }, })), is_owned: true } } /// The information we received from a peer along the route of a payment we originated. This is @@ -3732,7 +3911,7 @@ impl HTLCFailChannelUpdate { HTLCFailChannelUpdate::ChannelUpdateMessage {ref msg, } => { let mut msg_nonref = (*msg).clone(); nativeHTLCFailChannelUpdate::ChannelUpdateMessage { - msg: *unsafe { Box::from_raw(msg_nonref.take_ptr()) }, + msg: *unsafe { Box::from_raw(msg_nonref.take_inner()) }, } }, HTLCFailChannelUpdate::ChannelClosed {ref short_channel_id, ref is_permanent, } => { @@ -3758,7 +3937,7 @@ impl HTLCFailChannelUpdate { match self { HTLCFailChannelUpdate::ChannelUpdateMessage {mut msg, } => { nativeHTLCFailChannelUpdate::ChannelUpdateMessage { - msg: *unsafe { Box::from_raw(msg.take_ptr()) }, + msg: *unsafe { Box::from_raw(msg.take_inner()) }, } }, HTLCFailChannelUpdate::ChannelClosed {mut short_channel_id, mut is_permanent, } => { @@ -3827,6 +4006,10 @@ impl HTLCFailChannelUpdate { } #[no_mangle] pub extern "C" fn HTLCFailChannelUpdate_free(this_ptr: HTLCFailChannelUpdate) { } +#[no_mangle] +pub extern "C" fn HTLCFailChannelUpdate_clone(orig: &HTLCFailChannelUpdate) -> HTLCFailChannelUpdate { + orig.clone() +} /// A trait to describe an object which can receive channel messages. /// /// Messages MAY be called in parallel when they originate from different their_node_ids, however @@ -3966,6 +4149,12 @@ impl Drop for ChannelMessageHandler { } } /// A trait to describe an object which can receive routing messages. +/// +/// # Implementor DoS Warnings +/// +/// For `gossip_queries` messages there are potential DoS vectors when handling +/// inbound queries. Implementors using an on-disk network graph should be aware of +/// repeated disk I/O for queries accessing different parts of the network graph. #[repr(C)] pub struct RoutingMessageHandler { pub this_arg: *mut c_void, @@ -3994,29 +4183,55 @@ pub struct RoutingMessageHandler { /// If None is provided for starting_point, we start at the first node. #[must_use] pub get_next_node_announcements: extern "C" fn (this_arg: *const c_void, starting_point: crate::c_types::PublicKey, batch_amount: u8) -> crate::c_types::derived::CVec_NodeAnnouncementZ, - /// Returns whether a full sync should be requested from a peer. + /// Called when a connection is established with a peer. This can be used to + /// perform routing table synchronization using a strategy defined by the + /// implementor. + pub sync_routing_table: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, init: &crate::ln::msgs::Init), + /// Handles the reply of a query we initiated to learn about channels + /// for a given range of blocks. We can expect to receive one or more + /// replies to a single query. + #[must_use] + pub handle_reply_channel_range: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: crate::ln::msgs::ReplyChannelRange) -> crate::c_types::derived::CResult_NoneLightningErrorZ, + /// Handles the reply of a query we initiated asking for routing gossip + /// messages for a list of channels. We should receive this message when + /// a node has completed its best effort to send us the pertaining routing + /// gossip messages. #[must_use] - pub should_request_full_sync: extern "C" fn (this_arg: *const c_void, node_id: crate::c_types::PublicKey) -> bool, + pub handle_reply_short_channel_ids_end: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: crate::ln::msgs::ReplyShortChannelIdsEnd) -> crate::c_types::derived::CResult_NoneLightningErrorZ, + /// Handles when a peer asks us to send a list of short_channel_ids + /// for the requested range of blocks. + #[must_use] + pub handle_query_channel_range: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: crate::ln::msgs::QueryChannelRange) -> crate::c_types::derived::CResult_NoneLightningErrorZ, + /// Handles when a peer asks us to send routing gossip messages for a + /// list of short_channel_ids. + #[must_use] + pub handle_query_short_channel_ids: extern "C" fn (this_arg: *const c_void, their_node_id: crate::c_types::PublicKey, msg: crate::ln::msgs::QueryShortChannelIds) -> crate::c_types::derived::CResult_NoneLightningErrorZ, + pub MessageSendEventsProvider: crate::util::events::MessageSendEventsProvider, pub free: Option, } unsafe impl Send for RoutingMessageHandler {} unsafe impl Sync for RoutingMessageHandler {} +impl lightning::util::events::MessageSendEventsProvider for RoutingMessageHandler { + fn get_and_clear_pending_msg_events(&self) -> Vec { + ::get_and_clear_pending_msg_events(&self.MessageSendEventsProvider) + } +} use lightning::ln::msgs::RoutingMessageHandler as rustRoutingMessageHandler; impl rustRoutingMessageHandler for RoutingMessageHandler { fn handle_node_announcement(&self, msg: &lightning::ln::msgs::NodeAnnouncement) -> Result { let mut ret = (self.handle_node_announcement)(self.this_arg, &crate::ln::msgs::NodeAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }); - let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(ret.contents.err.take_ptr()) }).take_ptr()) } })}; + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })}; local_ret } fn handle_channel_announcement(&self, msg: &lightning::ln::msgs::ChannelAnnouncement) -> Result { let mut ret = (self.handle_channel_announcement)(self.this_arg, &crate::ln::msgs::ChannelAnnouncement { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }); - let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(ret.contents.err.take_ptr()) }).take_ptr()) } })}; + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })}; local_ret } fn handle_channel_update(&self, msg: &lightning::ln::msgs::ChannelUpdate) -> Result { let mut ret = (self.handle_channel_update)(self.this_arg, &crate::ln::msgs::ChannelUpdate { inner: unsafe { (msg as *const _) as *mut _ }, is_owned: false }); - let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(ret.contents.result.take_ptr()) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(ret.contents.err.take_ptr()) }).take_ptr()) } })}; + let mut local_ret = match ret.result_ok { true => Ok( { (*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) }) }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })}; local_ret } fn handle_htlc_fail_channel_update(&self, update: &lightning::ln::msgs::HTLCFailChannelUpdate) { @@ -4024,18 +4239,37 @@ impl rustRoutingMessageHandler for RoutingMessageHandler { } fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(lightning::ln::msgs::ChannelAnnouncement, Option, Option)> { let mut ret = (self.get_next_channel_announcements)(self.this_arg, starting_point, batch_amount); - let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { let (mut orig_ret_0_0, mut orig_ret_0_1, mut orig_ret_0_2) = item.to_rust(); let mut local_orig_ret_0_1 = if orig_ret_0_1.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(orig_ret_0_1.take_ptr()) } }) }; let mut local_orig_ret_0_2 = if orig_ret_0_2.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(orig_ret_0_2.take_ptr()) } }) }; let mut local_ret_0 = (*unsafe { Box::from_raw(orig_ret_0_0.take_ptr()) }, local_orig_ret_0_1, local_orig_ret_0_2); local_ret_0 }); }; + let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { let (mut orig_ret_0_0, mut orig_ret_0_1, mut orig_ret_0_2) = item.to_rust(); let mut local_orig_ret_0_1 = if orig_ret_0_1.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(orig_ret_0_1.take_inner()) } }) }; let mut local_orig_ret_0_2 = if orig_ret_0_2.inner.is_null() { None } else { Some( { *unsafe { Box::from_raw(orig_ret_0_2.take_inner()) } }) }; let mut local_ret_0 = (*unsafe { Box::from_raw(orig_ret_0_0.take_inner()) }, local_orig_ret_0_1, local_orig_ret_0_2); local_ret_0 }); }; local_ret } fn get_next_node_announcements(&self, starting_point: Option<&bitcoin::secp256k1::key::PublicKey>, batch_amount: u8) -> Vec { let mut local_starting_point = if starting_point.is_none() { crate::c_types::PublicKey::null() } else { { crate::c_types::PublicKey::from_rust(&(starting_point.unwrap())) } }; let mut ret = (self.get_next_node_announcements)(self.this_arg, local_starting_point, batch_amount); - let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { *unsafe { Box::from_raw(item.take_ptr()) } }); }; + let mut local_ret = Vec::new(); for mut item in ret.into_rust().drain(..) { local_ret.push( { *unsafe { Box::from_raw(item.take_inner()) } }); }; local_ret } - fn should_request_full_sync(&self, node_id: &bitcoin::secp256k1::key::PublicKey) -> bool { - let mut ret = (self.should_request_full_sync)(self.this_arg, crate::c_types::PublicKey::from_rust(&node_id)); - ret + fn sync_routing_table(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, init: &lightning::ln::msgs::Init) { + (self.sync_routing_table)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), &crate::ln::msgs::Init { inner: unsafe { (init as *const _) as *mut _ }, is_owned: false }) + } + fn handle_reply_channel_range(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: lightning::ln::msgs::ReplyChannelRange) -> Result<(), lightning::ln::msgs::LightningError> { + let mut ret = (self.handle_reply_channel_range)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::ln::msgs::ReplyChannelRange { inner: Box::into_raw(Box::new(msg)), is_owned: true }); + let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })}; + local_ret + } + fn handle_reply_short_channel_ids_end(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: lightning::ln::msgs::ReplyShortChannelIdsEnd) -> Result<(), lightning::ln::msgs::LightningError> { + let mut ret = (self.handle_reply_short_channel_ids_end)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::ln::msgs::ReplyShortChannelIdsEnd { inner: Box::into_raw(Box::new(msg)), is_owned: true }); + let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })}; + local_ret + } + fn handle_query_channel_range(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: lightning::ln::msgs::QueryChannelRange) -> Result<(), lightning::ln::msgs::LightningError> { + let mut ret = (self.handle_query_channel_range)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::ln::msgs::QueryChannelRange { inner: Box::into_raw(Box::new(msg)), is_owned: true }); + let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })}; + local_ret + } + fn handle_query_short_channel_ids(&self, their_node_id: &bitcoin::secp256k1::key::PublicKey, msg: lightning::ln::msgs::QueryShortChannelIds) -> Result<(), lightning::ln::msgs::LightningError> { + let mut ret = (self.handle_query_short_channel_ids)(self.this_arg, crate::c_types::PublicKey::from_rust(&their_node_id), crate::ln::msgs::QueryShortChannelIds { inner: Box::into_raw(Box::new(msg)), is_owned: true }); + let mut local_ret = match ret.result_ok { true => Ok( { () /*(*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.result)) })*/ }), false => Err( { *unsafe { Box::from_raw((*unsafe { Box::from_raw(<*mut _>::take_ptr(&mut ret.contents.err)) }).take_inner()) } })}; + local_ret } } @@ -4062,6 +4296,10 @@ pub extern "C" fn AcceptChannel_write(obj: *const AcceptChannel) -> crate::c_typ crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn AcceptChannel_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeAcceptChannel) }) +} +#[no_mangle] pub extern "C" fn AcceptChannel_read(ser: crate::c_types::u8slice) -> AcceptChannel { if let Ok(res) = crate::c_types::deserialize_obj(ser) { AcceptChannel { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4074,6 +4312,10 @@ pub extern "C" fn AnnouncementSignatures_write(obj: *const AnnouncementSignature crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn AnnouncementSignatures_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeAnnouncementSignatures) }) +} +#[no_mangle] pub extern "C" fn AnnouncementSignatures_read(ser: crate::c_types::u8slice) -> AnnouncementSignatures { if let Ok(res) = crate::c_types::deserialize_obj(ser) { AnnouncementSignatures { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4086,18 +4328,24 @@ pub extern "C" fn ChannelReestablish_write(obj: *const ChannelReestablish) -> cr crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn ChannelReestablish_read(ser: crate::c_types::u8slice) -> ChannelReestablish { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - ChannelReestablish { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - ChannelReestablish { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn ChannelReestablish_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelReestablish) }) +} +#[no_mangle] +pub extern "C" fn ChannelReestablish_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ChannelReestablishDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::ChannelReestablish { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn ClosingSigned_write(obj: *const ClosingSigned) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn ClosingSigned_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeClosingSigned) }) +} +#[no_mangle] pub extern "C" fn ClosingSigned_read(ser: crate::c_types::u8slice) -> ClosingSigned { if let Ok(res) = crate::c_types::deserialize_obj(ser) { ClosingSigned { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4110,6 +4358,10 @@ pub extern "C" fn CommitmentSigned_write(obj: *const CommitmentSigned) -> crate: crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn CommitmentSigned_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeCommitmentSigned) }) +} +#[no_mangle] pub extern "C" fn CommitmentSigned_read(ser: crate::c_types::u8slice) -> CommitmentSigned { if let Ok(res) = crate::c_types::deserialize_obj(ser) { CommitmentSigned { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4122,6 +4374,10 @@ pub extern "C" fn FundingCreated_write(obj: *const FundingCreated) -> crate::c_t crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn FundingCreated_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFundingCreated) }) +} +#[no_mangle] pub extern "C" fn FundingCreated_read(ser: crate::c_types::u8slice) -> FundingCreated { if let Ok(res) = crate::c_types::deserialize_obj(ser) { FundingCreated { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4134,6 +4390,10 @@ pub extern "C" fn FundingSigned_write(obj: *const FundingSigned) -> crate::c_typ crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn FundingSigned_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFundingSigned) }) +} +#[no_mangle] pub extern "C" fn FundingSigned_read(ser: crate::c_types::u8slice) -> FundingSigned { if let Ok(res) = crate::c_types::deserialize_obj(ser) { FundingSigned { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4146,6 +4406,10 @@ pub extern "C" fn FundingLocked_write(obj: *const FundingLocked) -> crate::c_typ crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn FundingLocked_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeFundingLocked) }) +} +#[no_mangle] pub extern "C" fn FundingLocked_read(ser: crate::c_types::u8slice) -> FundingLocked { if let Ok(res) = crate::c_types::deserialize_obj(ser) { FundingLocked { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4158,18 +4422,24 @@ pub extern "C" fn Init_write(obj: *const Init) -> crate::c_types::derived::CVec_ crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn Init_read(ser: crate::c_types::u8slice) -> Init { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - Init { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - Init { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn Init_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeInit) }) +} +#[no_mangle] +pub extern "C" fn Init_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_InitDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::Init { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn OpenChannel_write(obj: *const OpenChannel) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn OpenChannel_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeOpenChannel) }) +} +#[no_mangle] pub extern "C" fn OpenChannel_read(ser: crate::c_types::u8slice) -> OpenChannel { if let Ok(res) = crate::c_types::deserialize_obj(ser) { OpenChannel { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4182,6 +4452,10 @@ pub extern "C" fn RevokeAndACK_write(obj: *const RevokeAndACK) -> crate::c_types crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn RevokeAndACK_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeRevokeAndACK) }) +} +#[no_mangle] pub extern "C" fn RevokeAndACK_read(ser: crate::c_types::u8slice) -> RevokeAndACK { if let Ok(res) = crate::c_types::deserialize_obj(ser) { RevokeAndACK { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4194,6 +4468,10 @@ pub extern "C" fn Shutdown_write(obj: *const Shutdown) -> crate::c_types::derive crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn Shutdown_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeShutdown) }) +} +#[no_mangle] pub extern "C" fn Shutdown_read(ser: crate::c_types::u8slice) -> Shutdown { if let Ok(res) = crate::c_types::deserialize_obj(ser) { Shutdown { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4206,6 +4484,10 @@ pub extern "C" fn UpdateFailHTLC_write(obj: *const UpdateFailHTLC) -> crate::c_t crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn UpdateFailHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFailHTLC) }) +} +#[no_mangle] pub extern "C" fn UpdateFailHTLC_read(ser: crate::c_types::u8slice) -> UpdateFailHTLC { if let Ok(res) = crate::c_types::deserialize_obj(ser) { UpdateFailHTLC { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4218,6 +4500,10 @@ pub extern "C" fn UpdateFailMalformedHTLC_write(obj: *const UpdateFailMalformedH crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn UpdateFailMalformedHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFailMalformedHTLC) }) +} +#[no_mangle] pub extern "C" fn UpdateFailMalformedHTLC_read(ser: crate::c_types::u8slice) -> UpdateFailMalformedHTLC { if let Ok(res) = crate::c_types::deserialize_obj(ser) { UpdateFailMalformedHTLC { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4230,6 +4516,10 @@ pub extern "C" fn UpdateFee_write(obj: *const UpdateFee) -> crate::c_types::deri crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn UpdateFee_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFee) }) +} +#[no_mangle] pub extern "C" fn UpdateFee_read(ser: crate::c_types::u8slice) -> UpdateFee { if let Ok(res) = crate::c_types::deserialize_obj(ser) { UpdateFee { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4242,6 +4532,10 @@ pub extern "C" fn UpdateFulfillHTLC_write(obj: *const UpdateFulfillHTLC) -> crat crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn UpdateFulfillHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateFulfillHTLC) }) +} +#[no_mangle] pub extern "C" fn UpdateFulfillHTLC_read(ser: crate::c_types::u8slice) -> UpdateFulfillHTLC { if let Ok(res) = crate::c_types::deserialize_obj(ser) { UpdateFulfillHTLC { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4254,6 +4548,10 @@ pub extern "C" fn UpdateAddHTLC_write(obj: *const UpdateAddHTLC) -> crate::c_typ crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn UpdateAddHTLC_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUpdateAddHTLC) }) +} +#[no_mangle] pub extern "C" fn UpdateAddHTLC_read(ser: crate::c_types::u8slice) -> UpdateAddHTLC { if let Ok(res) = crate::c_types::deserialize_obj(ser) { UpdateAddHTLC { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4266,42 +4564,52 @@ pub extern "C" fn Ping_write(obj: *const Ping) -> crate::c_types::derived::CVec_ crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn Ping_read(ser: crate::c_types::u8slice) -> Ping { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - Ping { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - Ping { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn Ping_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativePing) }) +} +#[no_mangle] +pub extern "C" fn Ping_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PingDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::Ping { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn Pong_write(obj: *const Pong) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn Pong_read(ser: crate::c_types::u8slice) -> Pong { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - Pong { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - Pong { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn Pong_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativePong) }) +} +#[no_mangle] +pub extern "C" fn Pong_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_PongDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::Pong { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn UnsignedChannelAnnouncement_write(obj: *const UnsignedChannelAnnouncement) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn UnsignedChannelAnnouncement_read(ser: crate::c_types::u8slice) -> UnsignedChannelAnnouncement { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - UnsignedChannelAnnouncement { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - UnsignedChannelAnnouncement { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn UnsignedChannelAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUnsignedChannelAnnouncement) }) +} +#[no_mangle] +pub extern "C" fn UnsignedChannelAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UnsignedChannelAnnouncementDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::UnsignedChannelAnnouncement { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn ChannelAnnouncement_write(obj: *const ChannelAnnouncement) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn ChannelAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelAnnouncement) }) +} +#[no_mangle] pub extern "C" fn ChannelAnnouncement_read(ser: crate::c_types::u8slice) -> ChannelAnnouncement { if let Ok(res) = crate::c_types::deserialize_obj(ser) { ChannelAnnouncement { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4314,18 +4622,24 @@ pub extern "C" fn UnsignedChannelUpdate_write(obj: *const UnsignedChannelUpdate) crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn UnsignedChannelUpdate_read(ser: crate::c_types::u8slice) -> UnsignedChannelUpdate { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - UnsignedChannelUpdate { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - UnsignedChannelUpdate { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn UnsignedChannelUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUnsignedChannelUpdate) }) +} +#[no_mangle] +pub extern "C" fn UnsignedChannelUpdate_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UnsignedChannelUpdateDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::UnsignedChannelUpdate { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn ChannelUpdate_write(obj: *const ChannelUpdate) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn ChannelUpdate_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeChannelUpdate) }) +} +#[no_mangle] pub extern "C" fn ChannelUpdate_read(ser: crate::c_types::u8slice) -> ChannelUpdate { if let Ok(res) = crate::c_types::deserialize_obj(ser) { ChannelUpdate { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4338,30 +4652,38 @@ pub extern "C" fn ErrorMessage_write(obj: *const ErrorMessage) -> crate::c_types crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn ErrorMessage_read(ser: crate::c_types::u8slice) -> ErrorMessage { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - ErrorMessage { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - ErrorMessage { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn ErrorMessage_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeErrorMessage) }) +} +#[no_mangle] +pub extern "C" fn ErrorMessage_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ErrorMessageDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::ErrorMessage { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn UnsignedNodeAnnouncement_write(obj: *const UnsignedNodeAnnouncement) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn UnsignedNodeAnnouncement_read(ser: crate::c_types::u8slice) -> UnsignedNodeAnnouncement { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - UnsignedNodeAnnouncement { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - UnsignedNodeAnnouncement { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn UnsignedNodeAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeUnsignedNodeAnnouncement) }) +} +#[no_mangle] +pub extern "C" fn UnsignedNodeAnnouncement_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_UnsignedNodeAnnouncementDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::UnsignedNodeAnnouncement { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn NodeAnnouncement_write(obj: *const NodeAnnouncement) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] +pub(crate) extern "C" fn NodeAnnouncement_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeNodeAnnouncement) }) +} +#[no_mangle] pub extern "C" fn NodeAnnouncement_read(ser: crate::c_types::u8slice) -> NodeAnnouncement { if let Ok(res) = crate::c_types::deserialize_obj(ser) { NodeAnnouncement { inner: Box::into_raw(Box::new(res)), is_owned: true } @@ -4370,62 +4692,72 @@ pub extern "C" fn NodeAnnouncement_read(ser: crate::c_types::u8slice) -> NodeAnn } } #[no_mangle] -pub extern "C" fn QueryShortChannelIds_read(ser: crate::c_types::u8slice) -> QueryShortChannelIds { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - QueryShortChannelIds { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - QueryShortChannelIds { inner: std::ptr::null_mut(), is_owned: true } - } +pub extern "C" fn QueryShortChannelIds_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_QueryShortChannelIdsDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::QueryShortChannelIds { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn QueryShortChannelIds_write(obj: *const QueryShortChannelIds) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn ReplyShortChannelIdsEnd_read(ser: crate::c_types::u8slice) -> ReplyShortChannelIdsEnd { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - ReplyShortChannelIdsEnd { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - ReplyShortChannelIdsEnd { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn QueryShortChannelIds_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeQueryShortChannelIds) }) +} +#[no_mangle] +pub extern "C" fn ReplyShortChannelIdsEnd_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ReplyShortChannelIdsEndDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::ReplyShortChannelIdsEnd { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn ReplyShortChannelIdsEnd_write(obj: *const ReplyShortChannelIdsEnd) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn QueryChannelRange_read(ser: crate::c_types::u8slice) -> QueryChannelRange { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - QueryChannelRange { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - QueryChannelRange { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn ReplyShortChannelIdsEnd_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeReplyShortChannelIdsEnd) }) +} +#[no_mangle] +pub extern "C" fn QueryChannelRange_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_QueryChannelRangeDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::QueryChannelRange { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn QueryChannelRange_write(obj: *const QueryChannelRange) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn ReplyChannelRange_read(ser: crate::c_types::u8slice) -> ReplyChannelRange { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - ReplyChannelRange { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - ReplyChannelRange { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn QueryChannelRange_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeQueryChannelRange) }) +} +#[no_mangle] +pub extern "C" fn ReplyChannelRange_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_ReplyChannelRangeDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::ReplyChannelRange { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn ReplyChannelRange_write(obj: *const ReplyChannelRange) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } #[no_mangle] -pub extern "C" fn GossipTimestampFilter_read(ser: crate::c_types::u8slice) -> GossipTimestampFilter { - if let Ok(res) = crate::c_types::deserialize_obj(ser) { - GossipTimestampFilter { inner: Box::into_raw(Box::new(res)), is_owned: true } - } else { - GossipTimestampFilter { inner: std::ptr::null_mut(), is_owned: true } - } +pub(crate) extern "C" fn ReplyChannelRange_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeReplyChannelRange) }) +} +#[no_mangle] +pub extern "C" fn GossipTimestampFilter_read(ser: crate::c_types::u8slice) -> crate::c_types::derived::CResult_GossipTimestampFilterDecodeErrorZ { + let res = crate::c_types::deserialize_obj(ser); + let mut local_res = match res { Ok(mut o) => crate::c_types::CResultTempl::ok( { crate::ln::msgs::GossipTimestampFilter { inner: Box::into_raw(Box::new(o)), is_owned: true } }), Err(mut e) => crate::c_types::CResultTempl::err( { crate::ln::msgs::DecodeError { inner: Box::into_raw(Box::new(e)), is_owned: true } }) }; + local_res } #[no_mangle] pub extern "C" fn GossipTimestampFilter_write(obj: *const GossipTimestampFilter) -> crate::c_types::derived::CVec_u8Z { crate::c_types::serialize_obj(unsafe { &(*(*obj).inner) }) } +#[no_mangle] +pub(crate) extern "C" fn GossipTimestampFilter_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z { + crate::c_types::serialize_obj(unsafe { &*(obj as *const nativeGossipTimestampFilter) }) +}